kimi-vercel-ai-sdk-provider 0.2.0 → 0.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kimi-vercel-ai-sdk-provider",
   "description": "Kimi (Moonshot AI) provider for Vercel AI SDK v6",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -15,6 +15,9 @@
   "scripts": {
     "build": "tsup",
     "clean": "del-cli dist *.tsbuildinfo",
+    "format": "biome format --write",
+    "lint": "biome lint --write",
+    "lint:fix": "biome lint --write",
     "type-check": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",

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

@@ -1,9 +1,27 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import type { LanguageModelV3StreamPart } from '@ai-sdk/provider';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { createKimiCode } from '../code';
 
 // Mock fetch for API testing
 const mockFetch = vi.fn();
 
+async function readStreamParts<T>(stream: ReadableStream<T>) {
+  const reader = stream.getReader();
+  const parts: T[] = [];
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) {
+      break;
+    }
+    if (value !== undefined) {
+      parts.push(value);
+    }
+  }
+
+  return parts;
+}
+
 describe('KimiCodeLanguageModel Integration', () => {
   const originalEnv = process.env;
 
@@ -147,7 +165,7 @@ describe('KimiCodeLanguageModel Integration', () => {
 
       const result = await model.doGenerate({
         prompt: [{ role: 'user', content: [{ type: 'text', text: 'Read the index file' }] }],
-        
+
         tools: [
           {
             type: 'function',
@@ -198,8 +216,7 @@ describe('KimiCodeLanguageModel Integration', () => {
       });
 
       await model.doGenerate({
-        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Think hard' }] }],
-        
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Think hard' }] }]
       });
 
       const body = JSON.parse(mockFetch.mock.calls[0][1].body);
@@ -239,8 +256,7 @@ describe('KimiCodeLanguageModel Integration', () => {
       const model = provider('kimi-for-coding');
 
       const result = await model.doGenerate({
-        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test' }] }],
-        
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test' }] }]
       });
 
       expect(result.usage.inputTokens.total).toBe(100);
@@ -273,8 +289,7 @@ describe('KimiCodeLanguageModel Integration', () => {
 
       await expect(
         model.doGenerate({
-          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test' }] }],
-          
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test' }] }]
         })
       ).rejects.toThrow('Invalid API key');
     });
@@ -305,7 +320,7 @@ describe('KimiCodeLanguageModel Integration', () => {
 
       const result = await model.doGenerate({
         prompt: [{ role: 'user', content: [{ type: 'text', text: 'Write a long story' }] }],
-        
+
         maxOutputTokens: 100
       });
 
@@ -350,14 +365,10 @@ describe('KimiCodeLanguageModel Integration', () => {
       const model = provider('kimi-for-coding');
 
       const result = await model.doStream({
-        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Say hello' }] }],
-        
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Say hello' }] }]
       });
 
-      const parts: any[] = [];
-      for await (const part of result.stream) {
-        parts.push(part);
-      }
+      const parts = await readStreamParts<LanguageModelV3StreamPart>(result.stream);
 
       // Verify streaming worked
       expect(parts.length).toBeGreaterThan(0);
@@ -409,14 +420,10 @@ describe('KimiCodeLanguageModel Integration', () => {
       const model = provider('kimi-k2-thinking');
 
       const result = await model.doStream({
-        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Think about this' }] }],
-        
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Think about this' }] }]
       });
 
-      const parts: any[] = [];
-      for await (const part of result.stream) {
-        parts.push(part);
-      }
+      const parts = await readStreamParts<LanguageModelV3StreamPart>(result.stream);
 
       const partTypes = parts.map((p) => p.type);
       expect(partTypes).toContain('reasoning-start');
@@ -463,7 +470,7 @@ describe('KimiCodeLanguageModel Integration', () => {
 
       const result = await model.doStream({
         prompt: [{ role: 'user', content: [{ type: 'text', text: 'Read the file' }] }],
-        
+
         tools: [
           {
             type: 'function',
@@ -474,10 +481,7 @@ describe('KimiCodeLanguageModel Integration', () => {
         ]
       });
 
-      const parts: any[] = [];
-      for await (const part of result.stream) {
-        parts.push(part);
-      }
+      const parts = await readStreamParts<LanguageModelV3StreamPart>(result.stream);
 
       const partTypes = parts.map((p) => p.type);
       expect(partTypes).toContain('tool-input-start');
@@ -485,9 +489,12 @@ describe('KimiCodeLanguageModel Integration', () => {
       expect(partTypes).toContain('tool-input-end');
       expect(partTypes).toContain('tool-call');
 
-      const toolCallPart = parts.find((p) => p.type === 'tool-call');
-      expect(toolCallPart.toolName).toBe('read_file');
-      expect(toolCallPart.input).toContain('/src/index.ts');
+      const toolCallPart = parts.find(
+        (p): p is Extract<LanguageModelV3StreamPart, { type: 'tool-call' }> => p.type === 'tool-call'
+      );
+      expect(toolCallPart).toBeDefined();
+      expect(toolCallPart?.toolName).toBe('read_file');
+      expect(toolCallPart?.input).toContain('/src/index.ts');
     });
   });
 
@@ -517,8 +524,7 @@ describe('KimiCodeLanguageModel Integration', () => {
       const model = provider('kimi-for-coding');
 
       await model.doGenerate({
-        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test' }] }],
-        
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test' }] }]
       });
 
       const headers = mockFetch.mock.calls[0][1].headers;

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

@@ -1,12 +1,11 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
-  createKimiCode,
-  kimiCode,
-  KimiCodeLanguageModel,
-  KIMI_CODE_BASE_URL,
   KIMI_CODE_DEFAULT_MODEL,
   KIMI_CODE_THINKING_MODEL,
-  inferKimiCodeCapabilities
+  KimiCodeLanguageModel,
+  createKimiCode,
+  inferKimiCodeCapabilities,
+  kimiCode
 } from '../code';
 
 describe('createKimiCode', () => {

package/src/__tests__/code.test.ts

@@ -171,9 +171,7 @@ describe('toAnthropicThinking', () => {
 
 describe('convertToKimiCodePrompt', () => {
   it('should convert simple user message', async () => {
-    const result = await convertToKimiCodePrompt([
-      { role: 'user', content: [{ type: 'text', text: 'Hello!' }] }
-    ]);
+    const result = await convertToKimiCodePrompt([{ role: 'user', content: [{ type: 'text', text: 'Hello!' }] }]);
 
     expect(result.system).toBeUndefined();
     expect(result.messages).toEqual([{ role: 'user', content: 'Hello!' }]);

package/src/__tests__/file-cache.test.ts

@@ -0,0 +1,310 @@
+/**
+ * Tests for file content caching.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  FileCache,
+  type FileCacheEntry,
+  clearDefaultFileCache,
+  generateCacheKey,
+  generateContentHash,
+  getDefaultFileCache,
+  setDefaultFileCache
+} from '../files';
+
+describe('FileCache', () => {
+  describe('basic operations', () => {
+    it('should store and retrieve entries', () => {
+      const cache = new FileCache();
+      const entry: FileCacheEntry = {
+        fileId: 'file_123',
+        content: 'extracted text',
+        createdAt: Date.now(),
+        purpose: 'file-extract'
+      };
+
+      cache.set('hash123', entry);
+      const retrieved = cache.get('hash123');
+
+      expect(retrieved).toEqual(entry);
+    });
+
+    it('should return undefined for missing entries', () => {
+      const cache = new FileCache();
+
+      expect(cache.get('nonexistent')).toBeUndefined();
+    });
+
+    it('should delete entries', () => {
+      const cache = new FileCache();
+      const entry: FileCacheEntry = {
+        fileId: 'file_123',
+        createdAt: Date.now(),
+        purpose: 'file-extract'
+      };
+
+      cache.set('hash123', entry);
+      expect(cache.has('hash123')).toBe(true);
+
+      cache.delete('hash123');
+      expect(cache.has('hash123')).toBe(false);
+    });
+
+    it('should clear all entries', () => {
+      const cache = new FileCache();
+
+      cache.set('hash1', { fileId: 'f1', createdAt: Date.now(), purpose: 'file-extract' });
+      cache.set('hash2', { fileId: 'f2', createdAt: Date.now(), purpose: 'image' });
+      cache.set('hash3', { fileId: 'f3', createdAt: Date.now(), purpose: 'video' });
+
+      expect(cache.size).toBe(3);
+
+      cache.clear();
+      expect(cache.size).toBe(0);
+    });
+
+    it('should report correct size', () => {
+      const cache = new FileCache();
+
+      expect(cache.size).toBe(0);
+
+      cache.set('hash1', { fileId: 'f1', createdAt: Date.now(), purpose: 'file-extract' });
+      expect(cache.size).toBe(1);
+
+      cache.set('hash2', { fileId: 'f2', createdAt: Date.now(), purpose: 'file-extract' });
+      expect(cache.size).toBe(2);
+    });
+  });
+
+  describe('LRU eviction', () => {
+    it('should evict oldest entries when at capacity', () => {
+      const cache = new FileCache({ maxSize: 3 });
+
+      cache.set('hash1', { fileId: 'f1', createdAt: Date.now(), purpose: 'file-extract' });
+      cache.set('hash2', { fileId: 'f2', createdAt: Date.now(), purpose: 'file-extract' });
+      cache.set('hash3', { fileId: 'f3', createdAt: Date.now(), purpose: 'file-extract' });
+
+      expect(cache.size).toBe(3);
+
+      // Add a 4th entry, should evict hash1
+      cache.set('hash4', { fileId: 'f4', createdAt: Date.now(), purpose: 'file-extract' });
+
+      expect(cache.size).toBe(3);
+      expect(cache.has('hash1')).toBe(false);
+      expect(cache.has('hash2')).toBe(true);
+      expect(cache.has('hash3')).toBe(true);
+      expect(cache.has('hash4')).toBe(true);
+    });
+
+    it('should update LRU order on get', () => {
+      const cache = new FileCache({ maxSize: 3 });
+
+      cache.set('hash1', { fileId: 'f1', createdAt: Date.now(), purpose: 'file-extract' });
+      cache.set('hash2', { fileId: 'f2', createdAt: Date.now(), purpose: 'file-extract' });
+      cache.set('hash3', { fileId: 'f3', createdAt: Date.now(), purpose: 'file-extract' });
+
+      // Access hash1 to make it recently used
+      cache.get('hash1');
+
+      // Add a 4th entry, should evict hash2 (not hash1)
+      cache.set('hash4', { fileId: 'f4', createdAt: Date.now(), purpose: 'file-extract' });
+
+      expect(cache.has('hash1')).toBe(true);
+      expect(cache.has('hash2')).toBe(false);
+      expect(cache.has('hash3')).toBe(true);
+      expect(cache.has('hash4')).toBe(true);
+    });
+
+    it('should handle updating existing entries', () => {
+      const cache = new FileCache({ maxSize: 3 });
+
+      cache.set('hash1', { fileId: 'f1', createdAt: Date.now(), purpose: 'file-extract' });
+      cache.set('hash2', { fileId: 'f2', createdAt: Date.now(), purpose: 'file-extract' });
+      cache.set('hash3', { fileId: 'f3', createdAt: Date.now(), purpose: 'file-extract' });
+
+      // Update hash1
+      cache.set('hash1', { fileId: 'f1-updated', createdAt: Date.now(), purpose: 'file-extract' });
+
+      expect(cache.size).toBe(3);
+      expect(cache.get('hash1')?.fileId).toBe('f1-updated');
+    });
+  });
+
+  describe('TTL expiration', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should expire entries after TTL', () => {
+      const cache = new FileCache({ ttlMs: 1000 }); // 1 second TTL
+
+      cache.set('hash1', { fileId: 'f1', createdAt: Date.now(), purpose: 'file-extract' });
+
+      expect(cache.get('hash1')).toBeDefined();
+
+      // Advance time past TTL
+      vi.advanceTimersByTime(1500);
+
+      expect(cache.get('hash1')).toBeUndefined();
+    });
+
+    it('should not expire entries before TTL', () => {
+      const cache = new FileCache({ ttlMs: 1000 });
+
+      cache.set('hash1', { fileId: 'f1', createdAt: Date.now(), purpose: 'file-extract' });
+
+      // Advance time but not past TTL
+      vi.advanceTimersByTime(500);
+
+      expect(cache.get('hash1')).toBeDefined();
+    });
+
+    it('should prune expired entries', () => {
+      const cache = new FileCache({ ttlMs: 1000 });
+
+      cache.set('hash1', { fileId: 'f1', createdAt: Date.now(), purpose: 'file-extract' });
+      cache.set('hash2', { fileId: 'f2', createdAt: Date.now(), purpose: 'file-extract' });
+
+      vi.advanceTimersByTime(1500);
+
+      cache.set('hash3', { fileId: 'f3', createdAt: Date.now(), purpose: 'file-extract' });
+
+      const pruned = cache.prune();
+
+      expect(pruned).toBe(2);
+      expect(cache.size).toBe(1);
+      expect(cache.has('hash3')).toBe(true);
+    });
+  });
+
+  describe('default options', () => {
+    it('should use default maxSize of 100', () => {
+      const cache = new FileCache();
+
+      // Add 100 entries
+      for (let i = 0; i < 100; i++) {
+        cache.set(`hash${i}`, { fileId: `f${i}`, createdAt: Date.now(), purpose: 'file-extract' });
+      }
+
+      expect(cache.size).toBe(100);
+
+      // Add one more, should evict
+      cache.set('hash100', { fileId: 'f100', createdAt: Date.now(), purpose: 'file-extract' });
+      expect(cache.size).toBe(100);
+    });
+
+    it('should use default TTL of 1 hour', () => {
+      vi.useFakeTimers();
+
+      const cache = new FileCache();
+      cache.set('hash1', { fileId: 'f1', createdAt: Date.now(), purpose: 'file-extract' });
+
+      // 59 minutes - should still be valid
+      vi.advanceTimersByTime(59 * 60 * 1000);
+      expect(cache.get('hash1')).toBeDefined();
+
+      // 61 minutes - should be expired
+      vi.advanceTimersByTime(2 * 60 * 1000);
+      expect(cache.get('hash1')).toBeUndefined();
+
+      vi.useRealTimers();
+    });
+  });
+});
+
+describe('generateContentHash', () => {
+  it('should generate consistent hashes for same content', () => {
+    const data = new Uint8Array([1, 2, 3, 4, 5]);
+
+    const hash1 = generateContentHash(data);
+    const hash2 = generateContentHash(data);
+
+    expect(hash1).toBe(hash2);
+  });
+
+  it('should generate different hashes for different content', () => {
+    const data1 = new Uint8Array([1, 2, 3]);
+    const data2 = new Uint8Array([4, 5, 6]);
+
+    const hash1 = generateContentHash(data1);
+    const hash2 = generateContentHash(data2);
+
+    expect(hash1).not.toBe(hash2);
+  });
+
+  it('should work with string input', () => {
+    const hash1 = generateContentHash('hello world');
+    const hash2 = generateContentHash('hello world');
+    const hash3 = generateContentHash('goodbye world');
+
+    expect(hash1).toBe(hash2);
+    expect(hash1).not.toBe(hash3);
+  });
+
+  it('should return 8-character hex string', () => {
+    const hash = generateContentHash('test');
+
+    expect(hash).toMatch(/^[0-9a-f]{8}$/);
+  });
+});
+
+describe('generateCacheKey', () => {
+  it('should include content hash, size, and filename', () => {
+    const data = new Uint8Array([1, 2, 3, 4, 5]);
+    const key = generateCacheKey(data, 'document.pdf');
+
+    expect(key).toContain('_5_'); // size
+    expect(key).toContain('document.pdf');
+  });
+
+  it('should normalize filename', () => {
+    const data = new Uint8Array([1, 2, 3]);
+    const key = generateCacheKey(data, 'My Document (1).PDF');
+
+    expect(key).toContain('my_document__1_.pdf');
+  });
+
+  it('should generate different keys for same content with different names', () => {
+    const data = new Uint8Array([1, 2, 3, 4, 5]);
+
+    const key1 = generateCacheKey(data, 'file1.pdf');
+    const key2 = generateCacheKey(data, 'file2.pdf');
+
+    expect(key1).not.toBe(key2);
+  });
+});
+
+describe('Default Cache', () => {
+  afterEach(() => {
+    clearDefaultFileCache();
+    setDefaultFileCache(null);
+  });
+
+  it('should create default cache on first access', () => {
+    const cache1 = getDefaultFileCache();
+    const cache2 = getDefaultFileCache();
+
+    expect(cache1).toBe(cache2);
+  });
+
+  it('should allow setting custom default cache', () => {
+    const customCache = new FileCache({ maxSize: 10 });
+    setDefaultFileCache(customCache);
+
+    expect(getDefaultFileCache()).toBe(customCache);
+  });
+
+  it('should clear default cache', () => {
+    const cache = getDefaultFileCache();
+    cache.set('test', { fileId: 'f1', createdAt: Date.now(), purpose: 'file-extract' });
+
+    clearDefaultFileCache();
+
+    expect(cache.size).toBe(0);
+  });
+});

package/src/__tests__/model-config.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Tests for model configuration features:
+ * - Temperature locking for thinking models
+ * - Default max_tokens
+ * - Model capability inference
+ */
+
+import { describe, expect, it } from 'vitest';
+import {
+  STANDARD_MODEL_DEFAULT_MAX_TOKENS,
+  THINKING_MODEL_DEFAULT_MAX_TOKENS,
+  THINKING_MODEL_TEMPERATURE,
+  inferModelCapabilities
+} from '../core';
+
+describe('Model Configuration', () => {
+  describe('inferModelCapabilities', () => {
+    it('should detect thinking models by suffix', () => {
+      const caps = inferModelCapabilities('kimi-k2.5-thinking');
+
+      expect(caps.thinking).toBe(true);
+      expect(caps.alwaysThinking).toBe(true);
+    });
+
+    it('should detect non-thinking models', () => {
+      const caps = inferModelCapabilities('kimi-k2.5');
+
+      expect(caps.thinking).toBe(false);
+      expect(caps.alwaysThinking).toBe(false);
+    });
+
+    it('should detect K2.5 models for video support', () => {
+      const k25Caps = inferModelCapabilities('kimi-k2.5');
+      const k2Caps = inferModelCapabilities('kimi-k2-turbo');
+
+      expect(k25Caps.videoInput).toBe(true);
+      expect(k2Caps.videoInput).toBe(false);
+    });
+
+    it('should support alternative K2.5 naming', () => {
+      const caps = inferModelCapabilities('kimi-k2-5-thinking');
+
+      expect(caps.videoInput).toBe(true);
+      expect(caps.thinking).toBe(true);
+    });
+  });
+
+  describe('Temperature Locking', () => {
+    it('should set locked temperature for thinking models', () => {
+      const caps = inferModelCapabilities('kimi-k2.5-thinking');
+
+      expect(caps.temperatureLocked).toBe(true);
+      expect(caps.defaultTemperature).toBe(THINKING_MODEL_TEMPERATURE);
+      expect(caps.defaultTemperature).toBe(1.0);
+    });
+
+    it('should not lock temperature for standard models', () => {
+      const caps = inferModelCapabilities('kimi-k2.5');
+
+      expect(caps.temperatureLocked).toBe(false);
+      expect(caps.defaultTemperature).toBeUndefined();
+    });
+
+    it('should use correct constant value', () => {
+      expect(THINKING_MODEL_TEMPERATURE).toBe(1.0);
+    });
+  });
+
+  describe('Default Max Tokens', () => {
+    it('should set higher default for thinking models', () => {
+      const caps = inferModelCapabilities('kimi-k2.5-thinking');
+
+      expect(caps.defaultMaxOutputTokens).toBe(THINKING_MODEL_DEFAULT_MAX_TOKENS);
+      expect(caps.defaultMaxOutputTokens).toBe(32768);
+    });
+
+    it('should set standard default for regular models', () => {
+      const caps = inferModelCapabilities('kimi-k2.5');
+
+      expect(caps.defaultMaxOutputTokens).toBe(STANDARD_MODEL_DEFAULT_MAX_TOKENS);
+      expect(caps.defaultMaxOutputTokens).toBe(4096);
+    });
+
+    it('should use correct constant values', () => {
+      expect(THINKING_MODEL_DEFAULT_MAX_TOKENS).toBe(32768);
+      expect(STANDARD_MODEL_DEFAULT_MAX_TOKENS).toBe(4096);
+    });
+  });
+
+  describe('All models have common capabilities', () => {
+    const testModels = ['kimi-k2.5', 'kimi-k2.5-thinking', 'kimi-k2-turbo', 'kimi-k2-thinking'];
+
+    for (const modelId of testModels) {
+      it(`${modelId} should have imageInput support`, () => {
+        const caps = inferModelCapabilities(modelId);
+        expect(caps.imageInput).toBe(true);
+      });
+
+      it(`${modelId} should have 256k context`, () => {
+        const caps = inferModelCapabilities(modelId);
+        expect(caps.maxContextSize).toBe(256_000);
+      });
+
+      it(`${modelId} should support tool calling`, () => {
+        const caps = inferModelCapabilities(modelId);
+        expect(caps.toolCalling).toBe(true);
+      });
+
+      it(`${modelId} should support JSON mode`, () => {
+        const caps = inferModelCapabilities(modelId);
+        expect(caps.jsonMode).toBe(true);
+      });
+
+      it(`${modelId} should support structured outputs`, () => {
+        const caps = inferModelCapabilities(modelId);
+        expect(caps.structuredOutputs).toBe(true);
+      });
+    }
+  });
+});

package/src/__tests__/provider.test.ts

@@ -42,8 +42,9 @@ describe('createKimi', () => {
   it('should throw when called with new', () => {
     const provider = createKimi();
     // The error can be either our custom message or the native constructor error
-    // biome-ignore lint/suspicious/noExplicitAny: testing edge case requires any
-    expect(() => new (provider as any)('kimi-k2.5')).toThrow();
+    // Test that the provider function throws when used as a constructor
+    const ProviderAsConstructor = provider as unknown as new (modelId: string) => unknown;
+    expect(() => new ProviderAsConstructor('kimi-k2.5')).toThrow();
   });
 
   it('should throw for unsupported model types', () => {