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

package/src/__tests__/multi-agent.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it, vi } from 'vitest';
+import { DEFAULT_SYSTEM_PROMPTS, type WorkflowType } from '../multi-agent/types';
+import { WorkflowRunner, createEmptyMultiAgentResult } from '../multi-agent/workflows';
+
+describe('Multi-Agent Collaboration', () => {
+  const createMockGenerator = (responses: Record<string, string>) =>
+    vi.fn().mockImplementation(async (modelId: string) => {
+      return {
+        text: responses[modelId] || `Response from ${modelId}`,
+        usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 }
+      };
+    });
+
+  describe('WorkflowRunner', () => {
+    describe('planner-executor workflow', () => {
+      it('runs planner-executor workflow', async () => {
+        const generator = createMockGenerator({
+          'kimi-k2.5-thinking': '1. Analyze requirements\n2. Design solution\n3. Implement',
+          'kimi-k2.5': 'function solve() { return 42; }'
+        });
+
+        const runner = new WorkflowRunner(generator);
+        const result = await runner.run('Create a function', {
+          workflow: 'planner-executor',
+          modelA: 'kimi-k2.5-thinking',
+          modelB: 'kimi-k2.5'
+        });
+
+        expect(result.text).toContain('function solve');
+        expect(result.reasoning).toContain('Analyze requirements');
+        expect(result.intermediateSteps).toHaveLength(2);
+        expect(result.metadata.workflow).toBe('planner-executor');
+        expect(result.metadata.models).toContain('kimi-k2.5-thinking');
+        expect(result.metadata.models).toContain('kimi-k2.5');
+      });
+
+      it('includes validation step when enabled', async () => {
+        const generator = createMockGenerator({
+          'kimi-k2.5-thinking': 'Plan step',
+          'kimi-k2.5': '```javascript\nconst x = 5;\n```'
+        });
+
+        const validateCode = vi.fn().mockResolvedValue({
+          valid: true,
+          errors: []
+        });
+
+        const runner = new WorkflowRunner(generator, validateCode);
+        const result = await runner.run('Create code', {
+          workflow: 'planner-executor',
+          validateCode: true
+        });
+
+        expect(result.intermediateSteps.length).toBeGreaterThanOrEqual(2);
+        expect(result.validation).toBeDefined();
+        expect(result.validation?.valid).toBe(true);
+      });
+    });
+
+    describe('proposer-critic workflow', () => {
+      it('runs proposer-critic workflow', async () => {
+        const generator = createMockGenerator({
+          'kimi-k2.5': 'First attempt at solution',
+          'kimi-k2.5-thinking': 'Consider these improvements...'
+        });
+
+        const runner = new WorkflowRunner(generator);
+        const result = await runner.run('Solve this problem', {
+          workflow: 'proposer-critic',
+          iterations: 2,
+          modelA: 'kimi-k2.5',
+          modelB: 'kimi-k2.5-thinking'
+        });
+
+        expect(result.metadata.workflow).toBe('proposer-critic');
+        expect(result.intermediateSteps.length).toBeGreaterThanOrEqual(2);
+
+        const roles = result.intermediateSteps.map((s) => s.role);
+        expect(roles).toContain('proposer');
+        expect(roles).toContain('critic');
+      });
+
+      it('iterates specified number of times', async () => {
+        const generator = vi.fn().mockResolvedValue({
+          text: 'Response',
+          usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 }
+        });
+
+        const runner = new WorkflowRunner(generator);
+        await runner.run('Task', {
+          workflow: 'proposer-critic',
+          iterations: 3
+        });
+
+        // 3 proposer iterations + 2 critic iterations (critic doesn't run on last)
+        expect(generator).toHaveBeenCalledTimes(5);
+      });
+    });
+
+    describe('debate workflow', () => {
+      it('runs debate workflow', async () => {
+        const generator = createMockGenerator({
+          'kimi-k2.5': 'Position A'
+        });
+
+        const runner = new WorkflowRunner(generator);
+        const result = await runner.run('Debate this topic', {
+          workflow: 'debate',
+          iterations: 2
+        });
+
+        expect(result.metadata.workflow).toBe('debate');
+        expect(result.intermediateSteps.length).toBeGreaterThan(0);
+      });
+    });
+
+    describe('custom workflow', () => {
+      it('runs custom workflow', async () => {
+        const generator = createMockGenerator({});
+        const runner = new WorkflowRunner(generator);
+
+        const customWorkflow = vi.fn().mockResolvedValue({
+          text: 'Custom result',
+          intermediateSteps: [
+            {
+              agent: 'Custom',
+              role: 'custom',
+              action: 'Custom action',
+              output: 'Custom output',
+              timestamp: Date.now(),
+              durationMs: 100
+            }
+          ],
+          usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+          metadata: {
+            workflow: 'custom',
+            iterations: 1,
+            durationMs: 0,
+            models: [],
+            validationEnabled: false,
+            success: true
+          }
+        });
+
+        const result = await runner.run('Task', {
+          workflow: 'custom',
+          customWorkflow
+        });
+
+        expect(customWorkflow).toHaveBeenCalled();
+        expect(result.text).toBe('Custom result');
+      });
+
+      it('throws without customWorkflow function', async () => {
+        const generator = createMockGenerator({});
+        const runner = new WorkflowRunner(generator);
+
+        await expect(runner.run('Task', { workflow: 'custom' })).rejects.toThrow(
+          'Custom workflow requires customWorkflow function'
+        );
+      });
+    });
+
+    describe('error handling', () => {
+      it('throws for unknown workflow', async () => {
+        const generator = createMockGenerator({});
+        const runner = new WorkflowRunner(generator);
+
+        await expect(runner.run('Task', { workflow: 'invalid' as WorkflowType })).rejects.toThrow(
+          'Unknown workflow type'
+        );
+      });
+    });
+  });
+
+  describe('createEmptyMultiAgentResult', () => {
+    it('creates empty result with error', () => {
+      const result = createEmptyMultiAgentResult('planner-executor', 'Something failed');
+
+      expect(result.text).toBe('');
+      expect(result.intermediateSteps).toHaveLength(0);
+      expect(result.metadata.success).toBe(false);
+      expect(result.metadata.error).toBe('Something failed');
+      expect(result.metadata.workflow).toBe('planner-executor');
+    });
+  });
+
+  describe('DEFAULT_SYSTEM_PROMPTS', () => {
+    it('has all required prompts', () => {
+      expect(DEFAULT_SYSTEM_PROMPTS.planner).toBeDefined();
+      expect(DEFAULT_SYSTEM_PROMPTS.executor).toBeDefined();
+      expect(DEFAULT_SYSTEM_PROMPTS.proposer).toBeDefined();
+      expect(DEFAULT_SYSTEM_PROMPTS.critic).toBeDefined();
+    });
+
+    it('prompts are non-empty strings', () => {
+      expect(typeof DEFAULT_SYSTEM_PROMPTS.planner).toBe('string');
+      expect(DEFAULT_SYSTEM_PROMPTS.planner.length).toBeGreaterThan(50);
+    });
+  });
+});

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__/tools.test.ts

@@ -462,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-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()
 });
 
 /**