kimi-vercel-ai-sdk-provider 0.2.0

package/src/__tests__/code-provider.test.ts

@@ -0,0 +1,289 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import {
+  createKimiCode,
+  kimiCode,
+  KimiCodeLanguageModel,
+  KIMI_CODE_BASE_URL,
+  KIMI_CODE_DEFAULT_MODEL,
+  KIMI_CODE_THINKING_MODEL,
+  inferKimiCodeCapabilities
+} from '../code';
+
+describe('createKimiCode', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.resetModules();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('API key handling', () => {
+    it('should use provided apiKey', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test-key' });
+      const model = provider();
+
+      expect(model).toBeInstanceOf(KimiCodeLanguageModel);
+      expect(model.modelId).toBe(KIMI_CODE_DEFAULT_MODEL);
+    });
+
+    it('should use KIMI_CODE_API_KEY env var', () => {
+      process.env.KIMI_CODE_API_KEY = 'sk-env-key';
+
+      const provider = createKimiCode();
+      const model = provider();
+
+      expect(model).toBeInstanceOf(KimiCodeLanguageModel);
+    });
+
+    it('should fallback to KIMI_API_KEY env var', () => {
+      delete process.env.KIMI_CODE_API_KEY;
+      process.env.KIMI_API_KEY = 'sk-fallback-key';
+
+      const provider = createKimiCode();
+      const model = provider();
+
+      expect(model).toBeInstanceOf(KimiCodeLanguageModel);
+    });
+
+    it('should throw error when no API key is available', () => {
+      delete process.env.KIMI_CODE_API_KEY;
+      delete process.env.KIMI_API_KEY;
+
+      const provider = createKimiCode();
+      const model = provider();
+
+      // The error is thrown when headers are accessed, not when creating the model
+      // This happens during actual API calls
+      expect(model).toBeInstanceOf(KimiCodeLanguageModel);
+    });
+  });
+
+  describe('model creation', () => {
+    it('should create model with default model ID', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+      const model = provider();
+
+      expect(model.modelId).toBe(KIMI_CODE_DEFAULT_MODEL);
+    });
+
+    it('should create model with specified model ID', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+      const model = provider(KIMI_CODE_THINKING_MODEL);
+
+      expect(model.modelId).toBe(KIMI_CODE_THINKING_MODEL);
+    });
+
+    it('should create model with custom model ID', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+      const model = provider('custom-model');
+
+      expect(model.modelId).toBe('custom-model');
+    });
+
+    it('should pass settings to model', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+      const model = provider(KIMI_CODE_DEFAULT_MODEL, {
+        extendedThinking: { enabled: true, effort: 'high' }
+      }) as KimiCodeLanguageModel;
+
+      expect(model.capabilities.extendedThinking).toBe(false); // inferred from model ID
+    });
+
+    it('should override capabilities when provided in settings', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+      const model = provider(KIMI_CODE_DEFAULT_MODEL, {
+        capabilities: { extendedThinking: true }
+      }) as KimiCodeLanguageModel;
+
+      expect(model.capabilities.extendedThinking).toBe(true);
+    });
+  });
+
+  describe('provider interface', () => {
+    it('should have specificationVersion v3', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+
+      expect(provider.specificationVersion).toBe('v3');
+    });
+
+    it('should have languageModel method', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+
+      expect(typeof provider.languageModel).toBe('function');
+    });
+
+    it('should have chat method (alias)', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+
+      expect(typeof provider.chat).toBe('function');
+    });
+
+    it('should throw NoSuchModelError for embeddingModel', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+
+      expect(() => provider.embeddingModel('test')).toThrow('No such embeddingModel');
+    });
+
+    it('should throw NoSuchModelError for imageModel', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+
+      expect(() => provider.imageModel('test')).toThrow('No such imageModel');
+    });
+
+    it('should throw NoSuchModelError for rerankingModel', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+
+      expect(() => provider.rerankingModel!('test')).toThrow('No such rerankingModel');
+    });
+
+    it('should throw when called with new keyword', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+
+      expect(() => new (provider as unknown as new () => unknown)()).toThrow();
+    });
+  });
+
+  describe('base URL handling', () => {
+    it('should use default base URL', () => {
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+      const model = provider();
+
+      expect(model.provider).toBe('kimi.code');
+    });
+
+    it('should use custom base URL', () => {
+      const provider = createKimiCode({
+        apiKey: 'sk-test',
+        baseURL: 'https://custom.api.com/v1'
+      });
+      const model = provider();
+
+      expect(model).toBeInstanceOf(KimiCodeLanguageModel);
+    });
+
+    it('should use KIMI_CODE_BASE_URL env var', () => {
+      process.env.KIMI_CODE_BASE_URL = 'https://env.api.com/v1';
+
+      const provider = createKimiCode({ apiKey: 'sk-test' });
+      const model = provider();
+
+      expect(model).toBeInstanceOf(KimiCodeLanguageModel);
+    });
+  });
+
+  describe('custom fetch', () => {
+    it('should accept custom fetch function', () => {
+      const customFetch = vi.fn();
+      const provider = createKimiCode({
+        apiKey: 'sk-test',
+        fetch: customFetch
+      });
+      const model = provider();
+
+      expect(model).toBeInstanceOf(KimiCodeLanguageModel);
+    });
+  });
+
+  describe('generateId', () => {
+    it('should accept custom generateId function', () => {
+      const customGenerateId = vi.fn(() => 'custom-id');
+      const provider = createKimiCode({
+        apiKey: 'sk-test',
+        generateId: customGenerateId
+      });
+      const model = provider();
+
+      expect(model).toBeInstanceOf(KimiCodeLanguageModel);
+    });
+  });
+});
+
+describe('kimiCode default instance', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    process.env.KIMI_CODE_API_KEY = 'sk-default-test';
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('should be a function', () => {
+    expect(typeof kimiCode).toBe('function');
+  });
+
+  it('should create model with default settings', () => {
+    const model = kimiCode() as KimiCodeLanguageModel;
+
+    expect(model).toBeInstanceOf(KimiCodeLanguageModel);
+    expect(model.modelId).toBe(KIMI_CODE_DEFAULT_MODEL);
+  });
+
+  it('should create thinking model', () => {
+    const model = kimiCode(KIMI_CODE_THINKING_MODEL) as KimiCodeLanguageModel;
+
+    expect(model.modelId).toBe(KIMI_CODE_THINKING_MODEL);
+    expect(model.capabilities.extendedThinking).toBe(true);
+  });
+});
+
+describe('KimiCodeLanguageModel', () => {
+  it('should have specificationVersion v3', () => {
+    const provider = createKimiCode({ apiKey: 'sk-test' });
+    const model = provider() as KimiCodeLanguageModel;
+
+    expect(model.specificationVersion).toBe('v3');
+  });
+
+  it('should have provider name', () => {
+    const provider = createKimiCode({ apiKey: 'sk-test' });
+    const model = provider() as KimiCodeLanguageModel;
+
+    expect(model.provider).toBe('kimi.code');
+  });
+
+  it('should infer capabilities for default model', () => {
+    const caps = inferKimiCodeCapabilities(KIMI_CODE_DEFAULT_MODEL);
+
+    expect(caps.extendedThinking).toBe(false);
+    expect(caps.maxOutputTokens).toBe(32768);
+    expect(caps.maxContextSize).toBe(262144);
+    expect(caps.streaming).toBe(true);
+    expect(caps.toolCalling).toBe(true);
+    expect(caps.imageInput).toBe(true);
+  });
+
+  it('should infer capabilities for thinking model', () => {
+    const caps = inferKimiCodeCapabilities(KIMI_CODE_THINKING_MODEL);
+
+    expect(caps.extendedThinking).toBe(true);
+    expect(caps.maxOutputTokens).toBe(32768);
+    expect(caps.maxContextSize).toBe(262144);
+  });
+
+  it('should have supportedUrls for images', async () => {
+    const provider = createKimiCode({ apiKey: 'sk-test' });
+    const model = provider() as KimiCodeLanguageModel;
+
+    const urls = await model.supportedUrls;
+    expect(urls).toBeDefined();
+    expect(urls['image/*']).toBeDefined();
+  });
+
+  it('should allow overriding supportedUrls in settings', async () => {
+    const customPatterns = { 'image/*': [/^https:\/\/example\.com/] };
+    const provider = createKimiCode({ apiKey: 'sk-test' });
+    const model = provider(KIMI_CODE_DEFAULT_MODEL, {
+      supportedUrls: customPatterns
+    }) as KimiCodeLanguageModel;
+
+    const urls = await model.supportedUrls;
+    expect(urls).toEqual(customPatterns);
+  });
+});

package/src/__tests__/code.test.ts

@@ -0,0 +1,427 @@
+import { describe, expect, it } from 'vitest';
+import {
+  convertToKimiCodePrompt,
+  inferKimiCodeCapabilities,
+  normalizeExtendedThinkingConfig,
+  effortToBudgetTokens,
+  toAnthropicThinking,
+  KIMI_CODE_BASE_URL,
+  KIMI_CODE_DEFAULT_MODEL,
+  KIMI_CODE_THINKING_MODEL,
+  KIMI_CODE_MODELS,
+  KIMI_CODE_OPENAI_BASE_URL,
+  KIMI_CODE_DEFAULT_MAX_TOKENS,
+  KIMI_CODE_DEFAULT_CONTEXT_WINDOW,
+  KIMI_CODE_ANTHROPIC_VERSION
+} from '../code';
+
+describe('inferKimiCodeCapabilities', () => {
+  it('should detect kimi-for-coding model capabilities', () => {
+    const caps = inferKimiCodeCapabilities('kimi-for-coding');
+    expect(caps.extendedThinking).toBe(false);
+    expect(caps.maxOutputTokens).toBe(32768);
+    expect(caps.streaming).toBe(true);
+    expect(caps.toolCalling).toBe(true);
+  });
+
+  it('should detect kimi-k2-thinking model capabilities', () => {
+    const caps = inferKimiCodeCapabilities('kimi-k2-thinking');
+    expect(caps.extendedThinking).toBe(true);
+    expect(caps.maxOutputTokens).toBe(32768);
+  });
+
+  it('should handle unknown model', () => {
+    const caps = inferKimiCodeCapabilities('unknown-model');
+    expect(caps.extendedThinking).toBe(false);
+    expect(caps.maxOutputTokens).toBe(32768);
+    expect(caps.maxContextSize).toBe(262144);
+  });
+
+  it('should detect thinking model by name pattern', () => {
+    const caps = inferKimiCodeCapabilities('custom-thinking-model');
+    expect(caps.extendedThinking).toBe(true);
+  });
+});
+
+describe('normalizeExtendedThinkingConfig', () => {
+  it('should return undefined for undefined input', () => {
+    expect(normalizeExtendedThinkingConfig(undefined)).toBeUndefined();
+  });
+
+  it('should normalize boolean true to enabled config with default effort', () => {
+    const result = normalizeExtendedThinkingConfig(true);
+    expect(result).toEqual({ enabled: true, effort: 'medium' });
+  });
+
+  it('should normalize boolean false to disabled config', () => {
+    const result = normalizeExtendedThinkingConfig(false);
+    expect(result).toEqual({ enabled: false });
+  });
+
+  it('should pass through object config with defaults', () => {
+    const config = { enabled: true, budgetTokens: 10000 };
+    const result = normalizeExtendedThinkingConfig(config);
+    expect(result?.enabled).toBe(true);
+    expect(result?.budgetTokens).toBe(10000);
+    expect(result?.effort).toBe('medium'); // default
+  });
+
+  it('should preserve custom effort', () => {
+    const config = { enabled: true, effort: 'high' as const };
+    const result = normalizeExtendedThinkingConfig(config);
+    expect(result?.effort).toBe('high');
+  });
+});
+
+describe('effortToBudgetTokens', () => {
+  it('should return 2048 for low effort', () => {
+    expect(effortToBudgetTokens('low')).toBe(2048);
+  });
+
+  it('should return 8192 for medium effort', () => {
+    expect(effortToBudgetTokens('medium')).toBe(8192);
+  });
+
+  it('should return 16384 for high effort', () => {
+    expect(effortToBudgetTokens('high')).toBe(16384);
+  });
+});
+
+describe('Kimi Code Constants', () => {
+  it('should have correct base URL', () => {
+    expect(KIMI_CODE_BASE_URL).toBe('https://api.kimi.com/coding/v1');
+  });
+
+  it('should have correct OpenAI base URL', () => {
+    expect(KIMI_CODE_OPENAI_BASE_URL).toBe('https://api.kimi.com/coding/v1');
+  });
+
+  it('should have correct default model', () => {
+    expect(KIMI_CODE_DEFAULT_MODEL).toBe('kimi-for-coding');
+  });
+
+  it('should have correct thinking model', () => {
+    expect(KIMI_CODE_THINKING_MODEL).toBe('kimi-k2-thinking');
+  });
+
+  it('should have correct model list', () => {
+    expect(KIMI_CODE_MODELS).toContain('kimi-for-coding');
+    expect(KIMI_CODE_MODELS).toContain('kimi-k2-thinking');
+    expect(KIMI_CODE_MODELS).toHaveLength(2);
+  });
+
+  it('should have correct default max tokens (per Roo Code docs)', () => {
+    expect(KIMI_CODE_DEFAULT_MAX_TOKENS).toBe(32768);
+  });
+
+  it('should have correct default context window (per Roo Code docs)', () => {
+    expect(KIMI_CODE_DEFAULT_CONTEXT_WINDOW).toBe(262144);
+  });
+
+  it('should have correct Anthropic version', () => {
+    expect(KIMI_CODE_ANTHROPIC_VERSION).toBe('2023-06-01');
+  });
+});
+
+describe('toAnthropicThinking', () => {
+  it('should return undefined for undefined input', () => {
+    expect(toAnthropicThinking(undefined)).toBeUndefined();
+  });
+
+  it('should return enabled with default budget for boolean true', () => {
+    const result = toAnthropicThinking(true);
+    expect(result).toEqual({ type: 'enabled', budget_tokens: 8192 });
+  });
+
+  it('should return disabled for boolean false', () => {
+    const result = toAnthropicThinking(false);
+    expect(result).toEqual({ type: 'disabled' });
+  });
+
+  it('should return disabled for config with enabled: false', () => {
+    const result = toAnthropicThinking({ enabled: false });
+    expect(result).toEqual({ type: 'disabled' });
+  });
+
+  it('should use low effort budget tokens', () => {
+    const result = toAnthropicThinking({ enabled: true, effort: 'low' });
+    expect(result).toEqual({ type: 'enabled', budget_tokens: 2048 });
+  });
+
+  it('should use medium effort budget tokens', () => {
+    const result = toAnthropicThinking({ enabled: true, effort: 'medium' });
+    expect(result).toEqual({ type: 'enabled', budget_tokens: 8192 });
+  });
+
+  it('should use high effort budget tokens', () => {
+    const result = toAnthropicThinking({ enabled: true, effort: 'high' });
+    expect(result).toEqual({ type: 'enabled', budget_tokens: 16384 });
+  });
+
+  it('should prioritize explicit budgetTokens over effort', () => {
+    const result = toAnthropicThinking({ enabled: true, effort: 'low', budgetTokens: 10000 });
+    expect(result).toEqual({ type: 'enabled', budget_tokens: 10000 });
+  });
+
+  it('should use default medium effort when no effort specified', () => {
+    const result = toAnthropicThinking({ enabled: true });
+    expect(result).toEqual({ type: 'enabled', budget_tokens: 8192 });
+  });
+});
+
+describe('convertToKimiCodePrompt', () => {
+  it('should convert simple user message', async () => {
+    const result = await convertToKimiCodePrompt([
+      { role: 'user', content: [{ type: 'text', text: 'Hello!' }] }
+    ]);
+
+    expect(result.system).toBeUndefined();
+    expect(result.messages).toEqual([{ role: 'user', content: 'Hello!' }]);
+  });
+
+  it('should extract system message', async () => {
+    const result = await convertToKimiCodePrompt([
+      { role: 'system', content: 'You are a coding assistant.' },
+      { role: 'user', content: [{ type: 'text', text: 'Help me write code' }] }
+    ]);
+
+    expect(result.system).toBe('You are a coding assistant.');
+    expect(result.messages).toEqual([{ role: 'user', content: 'Help me write code' }]);
+  });
+
+  it('should combine multiple system messages', async () => {
+    const result = await convertToKimiCodePrompt([
+      { role: 'system', content: 'First instruction' },
+      { role: 'system', content: 'Second instruction' },
+      { role: 'user', content: [{ type: 'text', text: 'Hello' }] }
+    ]);
+
+    expect(result.system).toBe('First instruction\n\nSecond instruction');
+  });
+
+  it('should convert assistant message with text', async () => {
+    const result = await convertToKimiCodePrompt([
+      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
+      { role: 'assistant', content: [{ type: 'text', text: 'Hi there!' }] }
+    ]);
+
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[1]).toEqual({ role: 'assistant', content: 'Hi there!' });
+  });
+
+  it('should convert assistant message with tool call', async () => {
+    const result = await convertToKimiCodePrompt([
+      { role: 'user', content: [{ type: 'text', text: 'Calculate 2+2' }] },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool-call',
+            toolCallId: 'call-123',
+            toolName: 'calculator',
+            input: { a: 2, b: 2 }
+          }
+        ]
+      }
+    ]);
+
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[1]).toEqual({
+      role: 'assistant',
+      content: [
+        {
+          type: 'tool_use',
+          id: 'call-123',
+          name: 'calculator',
+          input: { a: 2, b: 2 }
+        }
+      ]
+    });
+  });
+
+  it('should convert tool result as user message after assistant', async () => {
+    const result = await convertToKimiCodePrompt([
+      { role: 'user', content: [{ type: 'text', text: 'Calculate' }] },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool-call',
+            toolCallId: 'call-123',
+            toolName: 'calculator',
+            input: { a: 2, b: 2 }
+          }
+        ]
+      },
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'call-123',
+            toolName: 'calculator',
+            output: { type: 'text', value: '4' }
+          }
+        ]
+      }
+    ]);
+
+    expect(result.messages).toHaveLength(3);
+    expect(result.messages[2]).toEqual({
+      role: 'user',
+      content: [
+        {
+          type: 'tool_result',
+          tool_use_id: 'call-123',
+          content: '4',
+          is_error: undefined
+        }
+      ]
+    });
+  });
+
+  it('should handle tool result with error', async () => {
+    const result = await convertToKimiCodePrompt([
+      { role: 'user', content: [{ type: 'text', text: 'Calculate' }] },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool-call',
+            toolCallId: 'call-123',
+            toolName: 'calculator',
+            input: { a: 2, b: 2 }
+          }
+        ]
+      },
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'call-123',
+            toolName: 'calculator',
+            output: { type: 'error-text', value: 'Error: Division by zero' }
+          }
+        ]
+      }
+    ]);
+
+    expect(result.messages[2]).toEqual({
+      role: 'user',
+      content: [
+        {
+          type: 'tool_result',
+          tool_use_id: 'call-123',
+          content: 'Error: Division by zero',
+          is_error: true
+        }
+      ]
+    });
+  });
+
+  it('should convert user message with image URL', async () => {
+    const result = await convertToKimiCodePrompt([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'What is in this image?' },
+          {
+            type: 'file',
+            mediaType: 'image/png',
+            data: new URL('https://example.com/image.png')
+          }
+        ]
+      }
+    ]);
+
+    expect(result.messages).toEqual([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'What is in this image?' },
+          {
+            type: 'image',
+            source: { type: 'url', url: 'https://example.com/image.png' }
+          }
+        ]
+      }
+    ]);
+  });
+
+  it('should convert user message with base64 image', async () => {
+    const result = await convertToKimiCodePrompt([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'What is this?' },
+          {
+            type: 'file',
+            mediaType: 'image/jpeg',
+            data: 'SGVsbG8gV29ybGQ=' // base64 of "Hello World"
+          }
+        ]
+      }
+    ]);
+
+    expect(result.messages).toEqual([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'What is this?' },
+          {
+            type: 'image',
+            source: {
+              type: 'base64',
+              media_type: 'image/jpeg',
+              data: 'SGVsbG8gV29ybGQ='
+            }
+          }
+        ]
+      }
+    ]);
+  });
+
+  it('should handle assistant message with reasoning', async () => {
+    const result = await convertToKimiCodePrompt([
+      { role: 'user', content: [{ type: 'text', text: 'Think about this' }] },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'reasoning', text: 'Let me think...' },
+          { type: 'text', text: 'Here is my answer' }
+        ]
+      }
+    ]);
+
+    expect(result.messages[1]).toEqual({
+      role: 'assistant',
+      content: [
+        { type: 'text', text: '<thinking>Let me think...</thinking>' },
+        { type: 'text', text: 'Here is my answer' }
+      ]
+    });
+  });
+
+  it('should handle multipart user message with text only', async () => {
+    const result = await convertToKimiCodePrompt([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Part 1' },
+          { type: 'text', text: 'Part 2' }
+        ]
+      }
+    ]);
+
+    expect(result.messages).toEqual([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Part 1' },
+          { type: 'text', text: 'Part 2' }
+        ]
+      }
+    ]);
+  });
+});