ros/claude-task-master
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Ralph Khreish <35776126+Crunchyman-ralph@users.noreply.github.com>
This commit is contained in:
tommy-ca
2025-09-24 22:57:04 +02:00
committed by Ralph Khreish
parent 0079b7defd
commit 18aa416035
31 changed files with 1590 additions and 2515 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
tests/unit/ai-providers/claude-code.test.js
View File

@@ -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');
});

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

@@ -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');
});
});
});

8
tests/unit/ai-providers/gemini-cli.test.js
View File

@@ -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' });

84
tests/unit/ai-providers/openai.test.js
View File

@@ -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(() =>

4
tests/unit/dependency-manager.test.js
View File

@@ -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();