fix: loadcodeassist eligible tiers getting ignored for unlicensed users (regression)

Author: gsquared94

packages/core/src/code_assist/setup.test.ts

@@ -332,9 +332,10 @@ describe('setupUser validation', () => {
     vi.unstubAllEnvs();
   });
 
-  it('should throw error if LoadCodeAssist returns ineligible tiers and no current tier', async () => {
+  it('should throw error if LoadCodeAssist returns ineligible tiers, no current tier, and no allowed tiers', async () => {
     mockLoad.mockResolvedValue({
       currentTier: null,
+      allowedTiers: [],
       ineligibleTiers: [
         {
           reasonMessage: 'User is not eligible',
@@ -350,6 +351,110 @@ describe('setupUser validation', () => {
     );
   });
 
+  it('should continue if LoadCodeAssist returns ineligible tiers but has allowed tiers', async () => {
+    const mockOnboardUser = vi.fn().mockResolvedValue({
+      done: true,
+      response: {
+        cloudaicompanionProject: {
+          id: 'server-project',
+        },
+      },
+    });
+    vi.mocked(CodeAssistServer).mockImplementation(
+      () =>
+        ({
+          loadCodeAssist: mockLoad,
+          onboardUser: mockOnboardUser,
+        }) as unknown as CodeAssistServer,
+    );
+
+    mockLoad.mockResolvedValue({
+      currentTier: null,
+      allowedTiers: [mockPaidTier],
+      ineligibleTiers: [
+        {
+          reasonMessage: 'Not eligible for free tier',
+          reasonCode: 'INELIGIBLE_ACCOUNT',
+          tierId: 'free-tier',
+          tierName: 'free',
+        },
+      ],
+    });
+
+    // Should not throw - should proceed to onboarding with the allowed tier
+    const result = await setupUser({} as OAuth2Client);
+    expect(result).toEqual({
+      projectId: 'server-project',
+      userTier: 'standard-tier',
+      userTierName: 'paid',
+    });
+    expect(mockOnboardUser).toHaveBeenCalled();
+  });
+
+  it('should throw error when only ineligible tiers exist and allowedTiers is undefined', async () => {
+    mockLoad.mockResolvedValue({
+      currentTier: null,
+      allowedTiers: undefined,
+      ineligibleTiers: [
+        {
+          reasonMessage: 'User is not eligible',
+          reasonCode: 'INELIGIBLE_ACCOUNT',
+          tierId: 'standard-tier',
+          tierName: 'standard',
+        },
+      ],
+    });
+
+    await expect(setupUser({} as OAuth2Client)).rejects.toThrow(
+      'User is not eligible',
+    );
+  });
+
+  it('should throw ValidationRequiredError even if allowed tiers exist', async () => {
+    mockLoad.mockResolvedValue({
+      currentTier: null,
+      allowedTiers: [mockPaidTier],
+      ineligibleTiers: [
+        {
+          reasonMessage: 'Please verify your account',
+          reasonCode: 'VALIDATION_REQUIRED',
+          tierId: 'free-tier',
+          tierName: 'free',
+          validationUrl: 'https://example.com/verify',
+        },
+      ],
+    });
+
+    await expect(setupUser({} as OAuth2Client)).rejects.toThrow(
+      ValidationRequiredError,
+    );
+  });
+
+  it('should combine multiple ineligible tier messages when no allowed tiers', async () => {
+    mockLoad.mockResolvedValue({
+      currentTier: null,
+      allowedTiers: [],
+      ineligibleTiers: [
+        {
+          reasonMessage: 'Not eligible for standard',
+          reasonCode: 'INELIGIBLE_ACCOUNT',
+          tierId: 'standard-tier',
+          tierName: 'standard',
+        },
+        {
+          reasonMessage: 'Not eligible for free',
+          reasonCode: 'INELIGIBLE_ACCOUNT',
+          tierId: 'free-tier',
+          tierName: 'free',
+        },
+      ],
+    });
+
+    await expect(setupUser({} as OAuth2Client)).rejects.toThrow(
+      'Not eligible for standard, Not eligible for free',
+    );
+  });
+
   it('should retry if validation handler returns verify', async () => {
     // First call fails
     mockLoad.mockResolvedValueOnce({

packages/core/src/code_assist/setup.ts

@@ -204,7 +204,12 @@ function validateLoadCodeAssistResponse(res: LoadCodeAssistResponse): void {
       );
     }
 
-    // For other ineligibility reasons, throw a generic error
+    // If there are eligible tiers, continue despite ineligible ones
+    if (res.allowedTiers && res.allowedTiers.length > 0) {
+      return;
+    }
+
+    // No eligible tiers - throw error with ineligibility reasons
     const reasons = res.ineligibleTiers.map((t) => t.reasonMessage).join(', ');
     throw new Error(reasons);
   }