kimi-vercel-ai-sdk-provider 0.3.0 → 0.5.0

package/src/__tests__/project-tools.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ProjectScaffolder, createEmptyScaffoldResult } from '../project-tools/scaffolder';
+
+describe('Project Tools', () => {
+  describe('ProjectScaffolder', () => {
+    const createMockGenerator = (response: string) => vi.fn().mockResolvedValue({ text: response });
+
+    it('scaffolds a project from JSON response', async () => {
+      const jsonResponse = `
+Here's your project:
+
+\`\`\`json
+{
+  "projectName": "my-api",
+  "projectType": "express",
+  "technologies": ["Express.js", "TypeScript"],
+  "files": [
+    {
+      "path": "package.json",
+      "content": "{\\"name\\": \\"my-api\\"}",
+      "description": "Package manifest"
+    },
+    {
+      "path": "src/index.ts",
+      "content": "import express from 'express';",
+      "description": "Entry point"
+    }
+  ],
+  "setupCommands": ["npm install", "npm run dev"],
+  "estimatedSetupTime": "5 minutes"
+}
+\`\`\`
+      `;
+
+      const scaffolder = new ProjectScaffolder({
+        generateText: createMockGenerator(jsonResponse)
+      });
+
+      const result = await scaffolder.scaffold('A REST API for todos', {
+        type: 'express'
+      });
+
+      expect(result.files).toHaveLength(2);
+      expect(result.files[0].path).toBe('package.json');
+      expect(result.metadata.projectName).toBe('my-api');
+      expect(result.metadata.projectType).toBe('express');
+      expect(result.setupCommands).toContain('npm install');
+    });
+
+    it('extracts files from code blocks when JSON parsing fails', async () => {
+      const codeBlockResponse = `
+Here are your files:
+
+\`\`\`package.json
+{
+  "name": "test-project"
+}
+\`\`\`
+
+\`\`\`src/index.ts
+console.log("Hello");
+\`\`\`
+      `;
+
+      const scaffolder = new ProjectScaffolder({
+        generateText: createMockGenerator(codeBlockResponse)
+      });
+
+      const result = await scaffolder.scaffold('A simple project', {
+        type: 'node'
+      });
+
+      expect(result.files.length).toBeGreaterThan(0);
+    });
+
+    it('includes configuration options in prompt', async () => {
+      let capturedPrompt = '';
+      const scaffolder = new ProjectScaffolder({
+        generateText: vi.fn().mockImplementation(async (prompt: string) => {
+          capturedPrompt = prompt;
+          return { text: '{"files": [], "projectName": "test"}' };
+        })
+      });
+
+      await scaffolder.scaffold('A project', {
+        type: 'nextjs',
+        includeTests: true,
+        includeCI: true,
+        includeDocker: true,
+        includeDocs: true,
+        includeLinting: true,
+        useTypeScript: true
+      });
+
+      expect(capturedPrompt).toContain('nextjs');
+      expect(capturedPrompt).toContain('test files');
+      expect(capturedPrompt).toContain('GitHub Actions');
+      expect(capturedPrompt).toContain('Dockerfile');
+      expect(capturedPrompt).toContain('README');
+      expect(capturedPrompt).toContain('ESLint');
+      expect(capturedPrompt).toContain('TypeScript');
+    });
+
+    it('generates instructions', async () => {
+      const scaffolder = new ProjectScaffolder({
+        generateText: createMockGenerator(`{
+          "projectName": "my-project",
+          "projectType": "node",
+          "files": [{"path": "index.js", "content": "// code"}],
+          "setupCommands": ["npm install"],
+          "estimatedSetupTime": "2 minutes"
+        }`)
+      });
+
+      const result = await scaffolder.scaffold('A project', {});
+
+      expect(result.instructions).toContain('Quick Start');
+      expect(result.instructions).toContain('my-project');
+      expect(result.instructions).toContain('npm install');
+    });
+
+    it('handles custom template', async () => {
+      let capturedPrompt = '';
+      const scaffolder = new ProjectScaffolder({
+        generateText: vi.fn().mockImplementation(async (prompt: string) => {
+          capturedPrompt = prompt;
+          return { text: '{"files": []}' };
+        })
+      });
+
+      await scaffolder.scaffold('A project', {
+        customTemplate: 'Must use Redux and React Query'
+      });
+
+      expect(capturedPrompt).toContain('Redux');
+      expect(capturedPrompt).toContain('React Query');
+    });
+
+    it('detects project type from files', async () => {
+      const scaffolder = new ProjectScaffolder({
+        generateText: createMockGenerator(`{
+          "files": [
+            {"path": "package.json", "content": "{\\"dependencies\\": {\\"react\\": \\"^18.0.0\\"}}"},
+            {"path": "src/App.tsx", "content": "export const App = () => <div>Hello</div>"}
+          ]
+        }`)
+      });
+
+      const result = await scaffolder.scaffold('A project', { type: 'auto' });
+
+      expect(result.metadata.projectType).toBe('react');
+    });
+
+    it('returns empty files for instructions-only format', async () => {
+      const scaffolder = new ProjectScaffolder({
+        generateText: createMockGenerator(`{
+          "projectName": "test",
+          "files": [{"path": "index.js", "content": "code"}]
+        }`)
+      });
+
+      const result = await scaffolder.scaffold('A project', {
+        outputFormat: 'instructions'
+      });
+
+      expect(result.files).toHaveLength(0);
+      expect(result.instructions).toBeTruthy();
+    });
+  });
+
+  describe('createEmptyScaffoldResult', () => {
+    it('creates empty result with error message', () => {
+      const result = createEmptyScaffoldResult('Failed to generate project');
+
+      expect(result.files).toHaveLength(0);
+      expect(result.instructions).toContain('Failed to generate project');
+      expect(result.setupCommands).toHaveLength(0);
+      expect(result.metadata.fileCount).toBe(0);
+    });
+  });
+});

package/src/__tests__/reasoning-utils.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Tests for multi-turn reasoning utilities.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { analyzeReasoningPreservation, recommendThinkingModel } from '../core';
+
+describe('analyzeReasoningPreservation', () => {
+  it('should detect messages with reasoning content', () => {
+    const messages = [
+      { role: 'user', content: 'What is 2+2?' },
+      {
+        role: 'assistant',
+        content: 'The answer is 4.',
+        reasoning_content: 'Let me calculate: 2+2 = 4'
+      }
+    ];
+
+    const analysis = analyzeReasoningPreservation(messages);
+
+    expect(analysis.messagesWithReasoning).toBe(1);
+    expect(analysis.isPreserved).toBe(true);
+    expect(analysis.missingReasoningIndices).toHaveLength(0);
+  });
+
+  it('should handle reasoning field variant', () => {
+    const messages = [
+      { role: 'user', content: 'Test' },
+      {
+        role: 'assistant',
+        content: 'Answer',
+        reasoning: 'My reasoning process...'
+      }
+    ];
+
+    const analysis = analyzeReasoningPreservation(messages);
+
+    expect(analysis.messagesWithReasoning).toBe(1);
+  });
+
+  it('should estimate reasoning tokens', () => {
+    const messages = [
+      { role: 'user', content: 'Test' },
+      {
+        role: 'assistant',
+        content: 'Answer',
+        reasoning_content: 'A'.repeat(400) // 400 chars ≈ 100 tokens
+      }
+    ];
+
+    const analysis = analyzeReasoningPreservation(messages);
+
+    expect(analysis.estimatedReasoningTokens).toBe(100);
+  });
+
+  it('should detect missing reasoning after tool calls', () => {
+    const messages = [
+      { role: 'user', content: 'Search for X' },
+      {
+        role: 'assistant',
+        content: null,
+        reasoning_content: 'I need to search...',
+        tool_calls: [{ id: 'call_1', type: 'function', function: { name: 'search', arguments: '{}' } }]
+      },
+      { role: 'tool', tool_call_id: 'call_1', content: 'Search results...' },
+      {
+        role: 'assistant',
+        content: 'Here are the results', // Missing reasoning!
+        reasoning_content: null
+      }
+    ];
+
+    const analysis = analyzeReasoningPreservation(messages);
+
+    expect(analysis.isPreserved).toBe(false);
+    expect(analysis.missingReasoningIndices).toContain(3);
+  });
+
+  it('should handle proper reasoning preservation in tool loops', () => {
+    const messages = [
+      { role: 'user', content: 'Search for X' },
+      {
+        role: 'assistant',
+        content: null,
+        reasoning_content: 'I need to search...',
+        tool_calls: [{ id: 'call_1', type: 'function', function: { name: 'search', arguments: '{}' } }]
+      },
+      { role: 'tool', tool_call_id: 'call_1', content: 'Search results...' },
+      {
+        role: 'assistant',
+        content: 'Here are the results',
+        reasoning_content: 'Based on the search results, I can now answer...'
+      }
+    ];
+
+    const analysis = analyzeReasoningPreservation(messages);
+
+    expect(analysis.isPreserved).toBe(true);
+    expect(analysis.messagesWithReasoning).toBe(2);
+  });
+
+  it('should handle empty conversations', () => {
+    const analysis = analyzeReasoningPreservation([]);
+
+    expect(analysis.messagesWithReasoning).toBe(0);
+    expect(analysis.isPreserved).toBe(true);
+    expect(analysis.estimatedReasoningTokens).toBe(0);
+  });
+
+  it('should handle conversations without assistant messages', () => {
+    const messages = [
+      { role: 'user', content: 'Hello' },
+      { role: 'system', content: 'You are helpful' }
+    ];
+
+    const analysis = analyzeReasoningPreservation(messages);
+
+    expect(analysis.messagesWithReasoning).toBe(0);
+    expect(analysis.isPreserved).toBe(true);
+  });
+});
+
+describe('recommendThinkingModel', () => {
+  it('should recommend for high complexity tasks', () => {
+    const recommendation = recommendThinkingModel(1, false, 0.8);
+
+    expect(recommendation.recommended).toBe(true);
+    expect(recommendation.reason).toContain('High complexity');
+  });
+
+  it('should recommend for multi-turn tool usage', () => {
+    const recommendation = recommendThinkingModel(5, true, 0.3);
+
+    expect(recommendation.recommended).toBe(true);
+    expect(recommendation.reason).toContain('tool usage');
+  });
+
+  it('should recommend for moderate complexity', () => {
+    const recommendation = recommendThinkingModel(1, false, 0.6);
+
+    expect(recommendation.recommended).toBe(true);
+    expect(recommendation.reason).toContain('Moderate complexity');
+  });
+
+  it('should not recommend for simple tasks', () => {
+    const recommendation = recommendThinkingModel(1, false, 0.2);
+
+    expect(recommendation.recommended).toBe(false);
+    expect(recommendation.reason).toContain('Standard model sufficient');
+  });
+
+  it('should not recommend for short tool conversations', () => {
+    const recommendation = recommendThinkingModel(2, true, 0.3);
+
+    expect(recommendation.recommended).toBe(false);
+  });
+
+  it('should prioritize high complexity over other factors', () => {
+    const recommendation = recommendThinkingModel(1, false, 0.9);
+
+    expect(recommendation.recommended).toBe(true);
+    expect(recommendation.reason).toContain('High complexity');
+  });
+});

package/src/__tests__/tools.test.ts

@@ -225,7 +225,8 @@ describe('prepareKimiTools', () => {
       });
     });
 
-    it('should include strict when provided', () => {
+    it('should not pass strict mode to Kimi for better compatibility', () => {
+      // Kimi doesn't fully support strict mode, so we don't pass it
       const result = prepareKimiTools({
         tools: [
           {
@@ -238,13 +239,80 @@ describe('prepareKimiTools', () => {
         ]
       });
 
-      expect(result.tools?.[0]).toMatchObject({
-        type: 'function',
-        function: {
-          name: 'test',
-          strict: true
-        }
+      // Strict should not be present in the output
+      const tool = result.tools?.[0];
+      expect(tool).toBeDefined();
+      if (tool && 'function' in tool) {
+        expect(tool.function).not.toHaveProperty('strict');
+      }
+    });
+
+    it('should sanitize JSON schema by removing unsupported keywords', () => {
+      const result = prepareKimiTools({
+        tools: [
+          {
+            type: 'function',
+            name: 'test',
+            description: 'Test tool',
+            inputSchema: {
+              $schema: 'http://json-schema.org/draft-07/schema#',
+              $id: 'test-schema',
+              type: 'object',
+              properties: {
+                name: { type: 'string' }
+              },
+              $defs: { unused: { type: 'string' } },
+              $comment: 'This is a comment'
+            }
+          }
+        ]
+      });
+
+      const tool = result.tools?.[0];
+      expect(tool).toBeDefined();
+      expect(tool?.type).toBe('function');
+      if (tool && tool.type === 'function') {
+        const params = tool.function.parameters as Record<string, unknown>;
+        expect(params).not.toHaveProperty('$schema');
+        expect(params).not.toHaveProperty('$id');
+        expect(params).not.toHaveProperty('$defs');
+        expect(params).not.toHaveProperty('$comment');
+        expect(params.type).toBe('object');
+        expect(params.properties).toEqual({ name: { type: 'string' } });
+      }
+    });
+
+    it('should preserve basic schema properties', () => {
+      const result = prepareKimiTools({
+        tools: [
+          {
+            type: 'function',
+            name: 'test',
+            description: 'Test tool',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                name: { type: 'string', description: 'Name field' },
+                count: { type: 'number', minimum: 0 }
+              },
+              required: ['name']
+            }
+          }
+        ]
       });
+
+      const tool = result.tools?.[0];
+      expect(tool).toBeDefined();
+      expect(tool?.type).toBe('function');
+      if (tool && tool.type === 'function') {
+        const params = tool.function.parameters as Record<string, unknown>;
+        expect(params.type).toBe('object');
+        expect(params.required).toEqual(['name']);
+        expect((params.properties as Record<string, unknown>).name).toEqual({
+          type: 'string',
+          description: 'Name field'
+        });
+      }
     });
   });
 
@@ -394,7 +462,7 @@ describe('prepareKimiTools', () => {
         details: 'Using tool choice polyfill with system message injection.'
       });
       expect(result.toolChoiceSystemMessage).toBeDefined();
-      expect(result.toolChoiceSystemMessage).toContain('MUST use one of the available tools');
+      expect(result.toolChoiceSystemMessage).toContain('MUST use at least one of the available tools');
     });
 
     it('should warn and fallback to auto for required tool choice without polyfill', () => {

package/src/chat/kimi-chat-language-model.ts

@@ -205,11 +205,30 @@ export class KimiChatLanguageModel implements LanguageModelV3 {
       messages.unshift({ role: 'system', content: toolChoiceSystemMessage });
     }
 
+    // Apply model-specific defaults and constraints
+    const caps = this.capabilities;
+
+    // Resolve temperature: thinking models require locked temperature
+    let resolvedTemperature = temperature;
+    if (caps.temperatureLocked && caps.defaultTemperature !== undefined) {
+      if (temperature !== undefined && temperature !== caps.defaultTemperature) {
+        warnings.push({
+          type: 'compatibility',
+          feature: 'temperature',
+          details: `Thinking models require temperature=${caps.defaultTemperature}. Your value (${temperature}) will be overridden.`
+        });
+      }
+      resolvedTemperature = caps.defaultTemperature;
+    }
+
+    // Resolve max_tokens: use model default if not specified
+    const resolvedMaxTokens = maxOutputTokens ?? caps.defaultMaxOutputTokens;
+
     const body = removeUndefinedEntries({
       model: this.modelId,
       messages,
-      max_tokens: maxOutputTokens,
-      temperature,
+      max_tokens: resolvedMaxTokens,
+      temperature: resolvedTemperature,
       top_p: topP,
       frequency_penalty: frequencyPenalty,
       presence_penalty: presencePenalty,

package/src/chat/kimi-chat-settings.ts

@@ -116,6 +116,15 @@ export interface KimiChatSettings {
    * Reduces costs by up to 90% for repeated long prompts.
    */
   caching?: boolean | KimiCachingConfig;
+
+  /**
+   * Auto-enable tools based on prompt content analysis.
+   * When true, the provider will analyze the prompt and automatically
+   * enable webSearch or codeInterpreter if patterns match.
+   *
+   * @default false
+   */
+  autoEnableTools?: boolean;
 }
 
 // ============================================================================
@@ -207,7 +216,12 @@ export const kimiProviderOptionsSchema = z.object({
   /**
    * Enable tool choice polyfill for this request.
    */
-  toolChoicePolyfill: z.boolean().optional()
+  toolChoicePolyfill: z.boolean().optional(),
+
+  /**
+   * Auto-enable tools based on prompt content analysis.
+   */
+  autoEnableTools: z.boolean().optional()
 });
 
 /**