feat: Claude Code AI SDK v5 Integration (#1114)

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Ralph Khreish <35776126+Crunchyman-ralph@users.noreply.github.com>

tests/integration/claude-code-error-handling.test.js

@@ -0,0 +1,58 @@
+import { jest } from '@jest/globals';
+
+// Mock AI SDK functions at the top level
+jest.unstable_mockModule('ai', () => ({
+	generateObject: jest.fn(),
+	generateText: jest.fn(),
+	streamText: jest.fn(),
+	streamObject: jest.fn(),
+	zodSchema: jest.fn(),
+	JSONParseError: class JSONParseError extends Error {},
+	NoObjectGeneratedError: class NoObjectGeneratedError extends Error {}
+}));
+
+// Mock CLI failure scenario
+jest.unstable_mockModule('ai-sdk-provider-claude-code', () => ({
+	createClaudeCode: jest.fn(() => {
+		throw new Error('Claude Code CLI not found');
+	})
+}));
+
+// Import the provider after mocking
+const { ClaudeCodeProvider } = await import(
+	'../../src/ai-providers/claude-code.js'
+);
+
+describe('Claude Code Error Handling', () => {
+	it('should handle missing Claude Code CLI gracefully', () => {
+		const provider = new ClaudeCodeProvider();
+
+		expect(() => provider.getClient()).toThrow(/Claude Code CLI not available/);
+	});
+
+	it('should handle CLI errors during client creation', () => {
+		const provider = new ClaudeCodeProvider();
+
+		expect(() => provider.getClient({ commandName: 'test' })).toThrow(
+			/Claude Code CLI not available/
+		);
+	});
+
+	it('should provide a helpful CLI-not-available error', () => {
+		const provider = new ClaudeCodeProvider();
+		expect(() => provider.getClient()).toThrow(
+			/Claude Code CLI not available/i
+		);
+	});
+
+	it('should still support basic provider functionality', () => {
+		const provider = new ClaudeCodeProvider();
+
+		// These should work even if CLI is not available
+		expect(provider.name).toBe('Claude Code');
+		expect(provider.getSupportedModels()).toEqual(['sonnet', 'opus']);
+		expect(provider.isModelSupported('sonnet')).toBe(true);
+		expect(provider.isRequiredApiKey()).toBe(false);
+		expect(() => provider.validateAuth()).not.toThrow();
+	});
+});

tests/integration/claude-code-optional.test.js

@@ -1,95 +1,128 @@
 import { jest } from '@jest/globals';
 
-// Mock the base provider to avoid circular dependencies
-jest.unstable_mockModule('../../src/ai-providers/base-provider.js', () => ({
-	BaseAIProvider: class {
-		constructor() {
-			this.name = 'Base Provider';
-		}
-		handleError(context, error) {
-			throw error;
-		}
-	}
+// Mock AI SDK functions at the top level
+const generateText = jest.fn();
+const streamText = jest.fn();
+
+jest.unstable_mockModule('ai', () => ({
+	generateObject: jest.fn(),
+	generateText,
+	streamText,
+	streamObject: jest.fn(),
+	zodSchema: jest.fn(),
+	JSONParseError: class JSONParseError extends Error {},
+	NoObjectGeneratedError: class NoObjectGeneratedError extends Error {}
 }));
 
-// Mock the claude-code SDK to simulate it not being installed
-jest.unstable_mockModule('@anthropic-ai/claude-code', () => {
-	throw new Error("Cannot find module '@anthropic-ai/claude-code'");
-});
+// Mock successful provider creation for all tests
+const mockProvider = jest.fn((modelId) => ({
+	id: modelId,
+	doGenerate: jest.fn(),
+	doStream: jest.fn()
+}));
+mockProvider.languageModel = jest.fn((id, settings) => ({ id, settings }));
+mockProvider.chat = mockProvider.languageModel;
 
-// Import after mocking
+jest.unstable_mockModule('ai-sdk-provider-claude-code', () => ({
+	createClaudeCode: jest.fn(() => mockProvider)
+}));
+
+// Import the provider after mocking
 const { ClaudeCodeProvider } = await import(
 	'../../src/ai-providers/claude-code.js'
 );
 
-describe('Claude Code Optional Dependency Integration', () => {
-	describe('when @anthropic-ai/claude-code is not installed', () => {
-		it('should allow provider instantiation', () => {
-			// Provider should instantiate without error
-			const provider = new ClaudeCodeProvider();
-			expect(provider).toBeDefined();
-			expect(provider.name).toBe('Claude Code');
+describe('Claude Code Integration (Optional)', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('should create a working provider instance', () => {
+		const provider = new ClaudeCodeProvider();
+		expect(provider.name).toBe('Claude Code');
+		expect(provider.getSupportedModels()).toEqual(['sonnet', 'opus']);
+	});
+
+	it('should support model validation', () => {
+		const provider = new ClaudeCodeProvider();
+		expect(provider.isModelSupported('sonnet')).toBe(true);
+		expect(provider.isModelSupported('opus')).toBe(true);
+		expect(provider.isModelSupported('haiku')).toBe(false);
+		expect(provider.isModelSupported('unknown')).toBe(false);
+	});
+
+	it('should create a client successfully', () => {
+		const provider = new ClaudeCodeProvider();
+		const client = provider.getClient();
+
+		expect(client).toBeDefined();
+		expect(typeof client).toBe('function');
+		expect(client.languageModel).toBeDefined();
+		expect(client.chat).toBeDefined();
+		expect(client.chat).toBe(client.languageModel);
+	});
+
+	it('should pass command-specific settings to client', async () => {
+		const provider = new ClaudeCodeProvider();
+		const client = provider.getClient({ commandName: 'test-command' });
+
+		expect(client).toBeDefined();
+		expect(typeof client).toBe('function');
+		const { createClaudeCode } = await import('ai-sdk-provider-claude-code');
+		expect(createClaudeCode).toHaveBeenCalledTimes(1);
+	});
+
+	it('should handle AI SDK generateText integration', async () => {
+		const provider = new ClaudeCodeProvider();
+		const client = provider.getClient();
+
+		// Mock successful generation
+		generateText.mockResolvedValueOnce({
+			text: 'Hello from Claude Code!',
+			usage: { totalTokens: 10 }
 		});
 
-		it('should allow client creation', () => {
-			const provider = new ClaudeCodeProvider();
-			// Client creation should work
-			const client = provider.getClient({});
-			expect(client).toBeDefined();
-			expect(typeof client).toBe('function');
+		const result = await generateText({
+			model: client('sonnet'),
+			messages: [{ role: 'user', content: 'Hello' }]
 		});
 
-		it('should fail with clear error when trying to use the model', async () => {
-			const provider = new ClaudeCodeProvider();
-			const client = provider.getClient({});
-			const model = client('opus');
-
-			// The actual usage should fail with the lazy loading error
-			await expect(
-				model.doGenerate({
-					prompt: [{ role: 'user', content: 'Hello' }],
-					mode: { type: 'regular' }
-				})
-			).rejects.toThrow(
-				"Claude Code SDK is not installed. Please install '@anthropic-ai/claude-code' to use the claude-code provider."
-			);
-		});
-
-		it('should provide helpful error message for streaming', async () => {
-			const provider = new ClaudeCodeProvider();
-			const client = provider.getClient({});
-			const model = client('sonnet');
-
-			await expect(
-				model.doStream({
-					prompt: [{ role: 'user', content: 'Hello' }],
-					mode: { type: 'regular' }
-				})
-			).rejects.toThrow(
-				"Claude Code SDK is not installed. Please install '@anthropic-ai/claude-code' to use the claude-code provider."
-			);
+		expect(result.text).toBe('Hello from Claude Code!');
+		expect(generateText).toHaveBeenCalledWith({
+			model: expect.any(Object),
+			messages: [{ role: 'user', content: 'Hello' }]
 		});
 	});
 
-	describe('provider behavior', () => {
-		it('should not require API key', () => {
-			const provider = new ClaudeCodeProvider();
-			// Should not throw
-			expect(() => provider.validateAuth()).not.toThrow();
-			expect(() => provider.validateAuth({ apiKey: null })).not.toThrow();
+	it('should handle AI SDK streamText integration', async () => {
+		const provider = new ClaudeCodeProvider();
+		const client = provider.getClient();
+
+		// Mock successful streaming
+		const mockStream = {
+			textStream: (async function* () {
+				yield 'Streamed response';
+			})()
+		};
+		streamText.mockResolvedValueOnce(mockStream);
+
+		const streamResult = await streamText({
+			model: client('sonnet'),
+			messages: [{ role: 'user', content: 'Stream test' }]
 		});
 
-		it('should work with ai-services-unified when provider is configured', async () => {
-			// This tests that the provider can be selected but will fail appropriately
-			// when the actual model is used
-			const provider = new ClaudeCodeProvider();
-			expect(provider).toBeDefined();
-
-			// In real usage, ai-services-unified would:
-			// 1. Get the provider instance (works)
-			// 2. Call provider.getClient() (works)
-			// 3. Create a model (works)
-			// 4. Try to generate (fails with clear error)
+		expect(streamResult.textStream).toBeDefined();
+		expect(streamText).toHaveBeenCalledWith({
+			model: expect.any(Object),
+			messages: [{ role: 'user', content: 'Stream test' }]
 		});
 	});
+
+	it('should not require authentication validation', () => {
+		const provider = new ClaudeCodeProvider();
+		expect(provider.isRequiredApiKey()).toBe(false);
+		expect(() => provider.validateAuth()).not.toThrow();
+		expect(() => provider.validateAuth({})).not.toThrow();
+		expect(() => provider.validateAuth({ commandName: 'test' })).not.toThrow();
+	});
 });

tests/unit/ai-providers/claude-code.test.js

@@ -1,21 +1,20 @@
 import { jest } from '@jest/globals';
 
-// Mock the claude-code SDK module
-jest.unstable_mockModule(
-	'../../../src/ai-providers/custom-sdk/claude-code/index.js',
-	() => ({
-		createClaudeCode: jest.fn(() => {
-			const provider = (modelId, settings) => ({
-				// Mock language model
-				id: modelId,
-				settings
-			});
-			provider.languageModel = jest.fn((id, settings) => ({ id, settings }));
-			provider.chat = provider.languageModel;
-			return provider;
-		})
+// Mock the ai-sdk-provider-claude-code package
+jest.unstable_mockModule('ai-sdk-provider-claude-code', () => ({
+	createClaudeCode: jest.fn(() => {
+		const provider = (modelId, settings) => ({
+			// Minimal mock language model surface
+			id: modelId,
+			settings,
+			doGenerate: jest.fn(() => ({ text: 'ok', usage: {} })),
+			doStream: jest.fn(() => ({ stream: true }))
+		});
+		provider.languageModel = jest.fn((id, settings) => ({ id, settings }));
+		provider.chat = provider.languageModel;
+		return provider;
 	})
-);
+}));
 
 // Mock the base provider
 jest.unstable_mockModule('../../../src/ai-providers/base-provider.js', () => ({
@@ -74,15 +73,14 @@ describe('ClaudeCodeProvider', () => {
 			expect(typeof client).toBe('function');
 		});
 
-		it('should create client without API key or base URL', () => {
-			const client = provider.getClient({});
+		it('should create client without parameters', () => {
+			const client = provider.getClient();
 			expect(client).toBeDefined();
 		});
 
-		it('should handle params even though they are not used', () => {
+		it('should handle commandName parameter', () => {
 			const client = provider.getClient({
-				baseURL: 'https://example.com',
-				apiKey: 'unused-key'
+				commandName: 'test-command'
 			});
 			expect(client).toBeDefined();
 		});
@@ -95,12 +93,24 @@ describe('ClaudeCodeProvider', () => {
 		});
 	});
 
+	describe('model support', () => {
+		it('should return supported models', () => {
+			const models = provider.getSupportedModels();
+			expect(models).toEqual(['sonnet', 'opus']);
+		});
+
+		it('should check if model is supported', () => {
+			expect(provider.isModelSupported('sonnet')).toBe(true);
+			expect(provider.isModelSupported('opus')).toBe(true);
+			expect(provider.isModelSupported('haiku')).toBe(false);
+			expect(provider.isModelSupported('unknown')).toBe(false);
+		});
+	});
+
 	describe('error handling', () => {
 		it('should handle client initialization errors', async () => {
 			// Force an error by making createClaudeCode throw
-			const { createClaudeCode } = await import(
-				'../../../src/ai-providers/custom-sdk/claude-code/index.js'
-			);
+			const { createClaudeCode } = await import('ai-sdk-provider-claude-code');
 			createClaudeCode.mockImplementationOnce(() => {
 				throw new Error('Mock initialization error');
 			});

tests/unit/ai-providers/custom-sdk/claude-code/language-model.test.js

@@ -1,237 +0,0 @@
-import { jest } from '@jest/globals';
-
-// Mock modules before importing
-jest.unstable_mockModule('@ai-sdk/provider', () => ({
-	NoSuchModelError: class NoSuchModelError extends Error {
-		constructor({ modelId, modelType }) {
-			super(`No such model: ${modelId}`);
-			this.modelId = modelId;
-			this.modelType = modelType;
-		}
-	}
-}));
-
-jest.unstable_mockModule('@ai-sdk/provider-utils', () => ({
-	generateId: jest.fn(() => 'test-id-123')
-}));
-
-jest.unstable_mockModule(
-	'../../../../../src/ai-providers/custom-sdk/claude-code/message-converter.js',
-	() => ({
-		convertToClaudeCodeMessages: jest.fn((prompt) => ({
-			messagesPrompt: 'converted-prompt',
-			systemPrompt: 'system'
-		}))
-	})
-);
-
-jest.unstable_mockModule(
-	'../../../../../src/ai-providers/custom-sdk/claude-code/json-extractor.js',
-	() => ({
-		extractJson: jest.fn((text) => text)
-	})
-);
-
-jest.unstable_mockModule(
-	'../../../../../src/ai-providers/custom-sdk/claude-code/errors.js',
-	() => ({
-		createAPICallError: jest.fn((opts) => new Error(opts.message)),
-		createAuthenticationError: jest.fn((opts) => new Error(opts.message))
-	})
-);
-
-// This mock will be controlled by tests
-let mockClaudeCodeModule = null;
-jest.unstable_mockModule('@anthropic-ai/claude-code', () => {
-	if (mockClaudeCodeModule) {
-		return mockClaudeCodeModule;
-	}
-	throw new Error("Cannot find module '@anthropic-ai/claude-code'");
-});
-
-// Import the module under test
-const { ClaudeCodeLanguageModel } = await import(
-	'../../../../../src/ai-providers/custom-sdk/claude-code/language-model.js'
-);
-
-describe('ClaudeCodeLanguageModel', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		// Reset the module mock
-		mockClaudeCodeModule = null;
-		// Clear module cache to ensure fresh imports
-		jest.resetModules();
-	});
-
-	describe('constructor', () => {
-		it('should initialize with valid model ID', () => {
-			const model = new ClaudeCodeLanguageModel({
-				id: 'opus',
-				settings: { maxTurns: 5 }
-			});
-
-			expect(model.modelId).toBe('opus');
-			expect(model.settings).toEqual({ maxTurns: 5 });
-			expect(model.provider).toBe('claude-code');
-		});
-
-		it('should throw NoSuchModelError for invalid model ID', async () => {
-			expect(
-				() =>
-					new ClaudeCodeLanguageModel({
-						id: '',
-						settings: {}
-					})
-			).toThrow('No such model: ');
-
-			expect(
-				() =>
-					new ClaudeCodeLanguageModel({
-						id: null,
-						settings: {}
-					})
-			).toThrow('No such model: null');
-		});
-	});
-
-	describe('lazy loading of @anthropic-ai/claude-code', () => {
-		it('should throw error when package is not installed', async () => {
-			// Keep mockClaudeCodeModule as null to simulate missing package
-			const model = new ClaudeCodeLanguageModel({
-				id: 'opus',
-				settings: {}
-			});
-
-			await expect(
-				model.doGenerate({
-					prompt: [{ role: 'user', content: 'test' }],
-					mode: { type: 'regular' }
-				})
-			).rejects.toThrow(
-				"Claude Code SDK is not installed. Please install '@anthropic-ai/claude-code' to use the claude-code provider."
-			);
-		});
-
-		it('should load package successfully when available', async () => {
-			// Mock successful package load
-			const mockQuery = jest.fn(async function* () {
-				yield {
-					type: 'assistant',
-					message: { content: [{ type: 'text', text: 'Hello' }] }
-				};
-				yield {
-					type: 'result',
-					subtype: 'done',
-					usage: { output_tokens: 10, input_tokens: 5 }
-				};
-			});
-
-			mockClaudeCodeModule = {
-				query: mockQuery,
-				AbortError: class AbortError extends Error {}
-			};
-
-			// Need to re-import to get fresh module with mocks
-			jest.resetModules();
-			const { ClaudeCodeLanguageModel: FreshModel } = await import(
-				'../../../../../src/ai-providers/custom-sdk/claude-code/language-model.js'
-			);
-
-			const model = new FreshModel({
-				id: 'opus',
-				settings: {}
-			});
-
-			const result = await model.doGenerate({
-				prompt: [{ role: 'user', content: 'test' }],
-				mode: { type: 'regular' }
-			});
-
-			expect(result.text).toBe('Hello');
-			expect(mockQuery).toHaveBeenCalled();
-		});
-
-		it('should only attempt to load package once', async () => {
-			// Get a fresh import to ensure clean state
-			jest.resetModules();
-			const { ClaudeCodeLanguageModel: TestModel } = await import(
-				'../../../../../src/ai-providers/custom-sdk/claude-code/language-model.js'
-			);
-
-			const model = new TestModel({
-				id: 'opus',
-				settings: {}
-			});
-
-			// First call should throw
-			await expect(
-				model.doGenerate({
-					prompt: [{ role: 'user', content: 'test' }],
-					mode: { type: 'regular' }
-				})
-			).rejects.toThrow('Claude Code SDK is not installed');
-
-			// Second call should also throw without trying to load again
-			await expect(
-				model.doGenerate({
-					prompt: [{ role: 'user', content: 'test' }],
-					mode: { type: 'regular' }
-				})
-			).rejects.toThrow('Claude Code SDK is not installed');
-		});
-	});
-
-	describe('generateUnsupportedWarnings', () => {
-		it('should generate warnings for unsupported parameters', () => {
-			const model = new ClaudeCodeLanguageModel({
-				id: 'opus',
-				settings: {}
-			});
-
-			const warnings = model.generateUnsupportedWarnings({
-				temperature: 0.7,
-				maxTokens: 1000,
-				topP: 0.9,
-				seed: 42
-			});
-
-			expect(warnings).toHaveLength(4);
-			expect(warnings[0]).toEqual({
-				type: 'unsupported-setting',
-				setting: 'temperature',
-				details:
-					'Claude Code CLI does not support the temperature parameter. It will be ignored.'
-			});
-		});
-
-		it('should return empty array when no unsupported parameters', () => {
-			const model = new ClaudeCodeLanguageModel({
-				id: 'opus',
-				settings: {}
-			});
-
-			const warnings = model.generateUnsupportedWarnings({});
-			expect(warnings).toEqual([]);
-		});
-	});
-
-	describe('getModel', () => {
-		it('should map model IDs correctly', () => {
-			const model = new ClaudeCodeLanguageModel({
-				id: 'opus',
-				settings: {}
-			});
-
-			expect(model.getModel()).toBe('opus');
-		});
-
-		it('should return unmapped model IDs as-is', () => {
-			const model = new ClaudeCodeLanguageModel({
-				id: 'custom-model',
-				settings: {}
-			});
-
-			expect(model.getModel()).toBe('custom-model');
-		});
-	});
-});

tests/unit/ai-providers/gemini-cli.test.js

@@ -524,7 +524,7 @@ describe('GeminiCliProvider', () => {
 					}),
 					system: 'You are a helpful assistant',
 					messages: [{ role: 'user', content: 'Hello' }],
-					maxTokens: 100,
+					maxOutputTokens: 100,
 					temperature: 0.7
 				});
 				expect(result.text).toBe('Hello! How can I help you?');
@@ -550,7 +550,7 @@ describe('GeminiCliProvider', () => {
 					}),
 					system: undefined,
 					messages: [{ role: 'user', content: 'Hello' }],
-					maxTokens: 100,
+					maxOutputTokens: 100,
 					temperature: 0.7
 				});
 			});
@@ -570,7 +570,7 @@ describe('GeminiCliProvider', () => {
 					}),
 					system: 'You are a helpful assistant',
 					messages: [{ role: 'user', content: 'Hello' }],
-					maxTokens: 100,
+					maxOutputTokens: 100,
 					temperature: 0.7
 				});
 				expect(result).toBe(mockStream);
@@ -609,7 +609,7 @@ describe('GeminiCliProvider', () => {
 					messages: [{ role: 'user', content: 'Hello' }],
 					schema: mockObjectParams.schema,
 					mode: 'json',
-					maxTokens: 100,
+					maxOutputTokens: 100,
 					temperature: 0.7
 				});
 				expect(result.object).toEqual({ result: 'success' });

tests/unit/ai-providers/openai.test.js

@@ -1,11 +1,10 @@
 /**
- * Tests for OpenAI Provider - Token parameter handling for GPT-5
+ * Tests for OpenAI Provider
  *
  * This test suite covers:
- * 1. Correct identification of GPT-5 models requiring max_completion_tokens
- * 2. Token parameter preparation for different model types
- * 3. Validation of maxTokens parameter
- * 4. Integer coercion of token values
+ * 1. Validation of maxTokens parameter
+ * 2. Client creation and configuration
+ * 3. Model handling
  */
 
 import { jest } from '@jest/globals';
@@ -26,81 +25,6 @@ describe('OpenAIProvider', () => {
 		jest.clearAllMocks();
 	});
 
-	describe('requiresMaxCompletionTokens', () => {
-		it('should return true for GPT-5 models', () => {
-			expect(provider.requiresMaxCompletionTokens('gpt-5')).toBe(true);
-			expect(provider.requiresMaxCompletionTokens('gpt-5-mini')).toBe(true);
-			expect(provider.requiresMaxCompletionTokens('gpt-5-nano')).toBe(true);
-			expect(provider.requiresMaxCompletionTokens('gpt-5-turbo')).toBe(true);
-		});
-
-		it('should return false for non-GPT-5 models', () => {
-			expect(provider.requiresMaxCompletionTokens('gpt-4')).toBe(false);
-			expect(provider.requiresMaxCompletionTokens('gpt-4o')).toBe(false);
-			expect(provider.requiresMaxCompletionTokens('gpt-3.5-turbo')).toBe(false);
-			expect(provider.requiresMaxCompletionTokens('o1')).toBe(false);
-			expect(provider.requiresMaxCompletionTokens('o1-mini')).toBe(false);
-		});
-
-		it('should handle null/undefined modelId', () => {
-			expect(provider.requiresMaxCompletionTokens(null)).toBeFalsy();
-			expect(provider.requiresMaxCompletionTokens(undefined)).toBeFalsy();
-			expect(provider.requiresMaxCompletionTokens('')).toBeFalsy();
-		});
-	});
-
-	describe('prepareTokenParam', () => {
-		it('should return max_completion_tokens for GPT-5 models', () => {
-			const result = provider.prepareTokenParam('gpt-5', 1000);
-			expect(result).toEqual({ max_completion_tokens: 1000 });
-		});
-
-		it('should return maxTokens for non-GPT-5 models', () => {
-			const result = provider.prepareTokenParam('gpt-4', 1000);
-			expect(result).toEqual({ maxTokens: 1000 });
-		});
-
-		it('should coerce token value to integer', () => {
-			// Float values
-			const result1 = provider.prepareTokenParam('gpt-5', 1000.7);
-			expect(result1).toEqual({ max_completion_tokens: 1000 });
-
-			const result2 = provider.prepareTokenParam('gpt-4', 1000.7);
-			expect(result2).toEqual({ maxTokens: 1000 });
-
-			// String float
-			const result3 = provider.prepareTokenParam('gpt-5', '1000.7');
-			expect(result3).toEqual({ max_completion_tokens: 1000 });
-
-			// String integers (common CLI input path)
-			expect(provider.prepareTokenParam('gpt-5', '1000')).toEqual({
-				max_completion_tokens: 1000
-			});
-			expect(provider.prepareTokenParam('gpt-4', '1000')).toEqual({
-				maxTokens: 1000
-			});
-		});
-
-		it('should return empty object for undefined maxTokens', () => {
-			const result = provider.prepareTokenParam('gpt-5', undefined);
-			expect(result).toEqual({});
-		});
-
-		it('should handle edge cases', () => {
-			// Test with 0 (should still pass through as 0)
-			const result1 = provider.prepareTokenParam('gpt-5', 0);
-			expect(result1).toEqual({ max_completion_tokens: 0 });
-
-			// Test with string number
-			const result2 = provider.prepareTokenParam('gpt-5', '100');
-			expect(result2).toEqual({ max_completion_tokens: 100 });
-
-			// Test with negative number (will be floored, validation happens elsewhere)
-			const result3 = provider.prepareTokenParam('gpt-4', -10.5);
-			expect(result3).toEqual({ maxTokens: -11 });
-		});
-	});
-
 	describe('validateOptionalParams', () => {
 		it('should accept valid maxTokens values', () => {
 			expect(() =>

tests/unit/dependency-manager.test.js

@@ -27,10 +27,6 @@ jest.mock('chalk', () => ({
 
 jest.mock('boxen', () => jest.fn((text) => `[boxed: ${text}]`));
 
-jest.mock('@anthropic-ai/sdk', () => ({
-	Anthropic: jest.fn().mockImplementation(() => ({}))
-}));
-
 // Mock utils module
 const mockTaskExists = jest.fn();
 const mockFormatTaskId = jest.fn();