kimi-vercel-ai-sdk-provider 0.4.0 → 0.5.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.4.0",
+  "version": "0.5.0",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/__tests__/auto-detect.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+import { detectToolsFromPrompt, hasToolOptOut, shouldAutoEnableTools } from '../tools/auto-detect';
+
+describe('Auto-detect Tools', () => {
+  describe('detectToolsFromPrompt', () => {
+    describe('web search detection', () => {
+      it('detects direct search requests', () => {
+        const result = detectToolsFromPrompt('Search for the latest news about AI');
+        expect(result.webSearch).toBe(true);
+        expect(result.webSearchConfidence).toBeGreaterThan(0.5);
+        expect(result.webSearchMatches).toContain('direct_search');
+      });
+
+      it('detects current/latest information requests', () => {
+        const result = detectToolsFromPrompt('What is the current price of Bitcoin?');
+        expect(result.webSearch).toBe(true);
+        expect(result.webSearchConfidence).toBeGreaterThan(0.7);
+      });
+
+      it('detects weather requests', () => {
+        const result = detectToolsFromPrompt('What is the weather in New York today?');
+        expect(result.webSearch).toBe(true);
+        expect(result.webSearchMatches).toContain('weather');
+      });
+
+      it('detects news requests', () => {
+        const result = detectToolsFromPrompt('What are the latest headlines about technology?');
+        expect(result.webSearch).toBe(true);
+      });
+
+      it('does not detect web search for general questions', () => {
+        const result = detectToolsFromPrompt('What is the capital of France?');
+        expect(result.webSearch).toBe(false);
+        expect(result.webSearchConfidence).toBeLessThan(0.3);
+      });
+    });
+
+    describe('code interpreter detection', () => {
+      it('detects write code requests', () => {
+        const result = detectToolsFromPrompt('Write a function to sort an array');
+        expect(result.codeInterpreter).toBe(true);
+        expect(result.codeInterpreterConfidence).toBeGreaterThan(0.5);
+        expect(result.codeInterpreterMatches).toContain('write_code');
+      });
+
+      it('detects calculation requests', () => {
+        const result = detectToolsFromPrompt('Calculate 5 factorial');
+        expect(result.codeInterpreter).toBe(true);
+        expect(result.codeInterpreterMatches).toContain('calculate');
+      });
+
+      it('detects debug requests', () => {
+        const result = detectToolsFromPrompt('Debug this code and find the error');
+        expect(result.codeInterpreter).toBe(true);
+        expect(result.codeInterpreterMatches).toContain('debug');
+      });
+
+      it('detects code execution requests', () => {
+        const result = detectToolsFromPrompt('Run this script and show the output');
+        expect(result.codeInterpreter).toBe(true);
+        expect(result.codeInterpreterMatches).toContain('run_code');
+      });
+
+      it('detects code blocks in prompt', () => {
+        const result = detectToolsFromPrompt(`
+          Please help me with this code:
+          \`\`\`javascript
+          const x = 5;
+          console.log(x);
+          \`\`\`
+        `);
+        expect(result.codeInterpreter).toBe(true);
+      });
+
+      it('does not detect code interpreter for general questions', () => {
+        const result = detectToolsFromPrompt('Tell me a joke');
+        expect(result.codeInterpreter).toBe(false);
+      });
+    });
+
+    describe('combined detection', () => {
+      it('can detect both tools in one prompt', () => {
+        const result = detectToolsFromPrompt(
+          'Search for the latest Python tutorials and write a function to parse JSON'
+        );
+        expect(result.webSearch).toBe(true);
+        expect(result.codeInterpreter).toBe(true);
+      });
+
+      it('respects custom confidence threshold', () => {
+        const result = detectToolsFromPrompt('What is the price of something?', {
+          confidenceThreshold: 0.9
+        });
+        // Price alone may not meet 0.9 threshold
+        expect(result.webSearchConfidence).toBeLessThan(0.9);
+      });
+    });
+  });
+
+  describe('shouldAutoEnableTools', () => {
+    it('returns simple boolean flags', () => {
+      const result = shouldAutoEnableTools('Search for news about AI');
+      expect(typeof result.webSearch).toBe('boolean');
+      expect(typeof result.codeInterpreter).toBe('boolean');
+      expect(result.webSearch).toBe(true);
+    });
+
+    it('handles empty prompts', () => {
+      const result = shouldAutoEnableTools('');
+      expect(result.webSearch).toBe(false);
+      expect(result.codeInterpreter).toBe(false);
+    });
+  });
+
+  describe('hasToolOptOut', () => {
+    it('detects web search opt-out', () => {
+      const result = hasToolOptOut("Don't search the web, just answer from memory");
+      expect(result.webSearch).toBe(true);
+      expect(result.codeInterpreter).toBe(false);
+    });
+
+    it('detects code execution opt-out', () => {
+      const result = hasToolOptOut("Don't run or execute any code");
+      expect(result.webSearch).toBe(false);
+      expect(result.codeInterpreter).toBe(true);
+    });
+
+    it('detects both opt-outs', () => {
+      const result = hasToolOptOut('Without searching online or running code, explain this concept');
+      expect(result.webSearch).toBe(true);
+      expect(result.codeInterpreter).toBe(true);
+    });
+
+    it('returns false when no opt-out', () => {
+      const result = hasToolOptOut('Please help me with this task');
+      expect(result.webSearch).toBe(false);
+      expect(result.codeInterpreter).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,267 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  containsCode,
+  detectLanguage,
+  extractCodeBlocks,
+  extractPrimaryCode,
+  getFileExtension
+} from '../code-validation/detector';
+import {
+  CodeValidator,
+  createFailedValidationResult,
+  createPassedValidationResult
+} from '../code-validation/validator';
+
+describe('Code Validation', () => {
+  describe('detectLanguage', () => {
+    it('detects TypeScript', () => {
+      const code = `
+        interface User {
+          name: string;
+          age: number;
+        }
+        
+        const user: User = { name: 'John', age: 30 };
+      `;
+      const result = detectLanguage(code);
+      expect(result.language).toBe('typescript');
+      expect(result.confidence).toBeGreaterThan(0.5);
+      expect(result.indicators).toContain('interface');
+    });
+
+    it('detects JavaScript', () => {
+      const code = `
+        const express = require('express');
+        const app = express();
+        
+        app.get('/', (req, res) => {
+          res.send('Hello World!');
+        });
+        
+        module.exports = app;
+      `;
+      const result = detectLanguage(code);
+      expect(result.language).toBe('javascript');
+      expect(result.indicators).toContain('require');
+    });
+
+    it('detects Python', () => {
+      const code = `
+        def hello_world():
+            print("Hello, World!")
+        
+        if __name__ == "__main__":
+            hello_world()
+      `;
+      const result = detectLanguage(code);
+      expect(result.language).toBe('python');
+      expect(result.indicators).toContain('def');
+      expect(result.indicators).toContain('main_guard');
+    });
+
+    it('detects Java', () => {
+      const code = `
+        public class HelloWorld {
+            public static void main(String[] args) {
+                System.out.println("Hello, World!");
+            }
+        }
+      `;
+      const result = detectLanguage(code);
+      expect(result.language).toBe('java');
+      expect(result.indicators).toContain('main_method');
+    });
+
+    it('detects Go', () => {
+      const code = `
+        package main
+        
+        import "fmt"
+        
+        func main() {
+            fmt.Println("Hello, World!")
+        }
+      `;
+      const result = detectLanguage(code);
+      expect(result.language).toBe('go');
+      expect(result.indicators).toContain('package_main');
+    });
+
+    it('detects Rust', () => {
+      const code = `
+        fn main() {
+            let mut x = 5;
+            println!("The value is: {}", x);
+        }
+      `;
+      const result = detectLanguage(code);
+      expect(result.language).toBe('rust');
+      expect(result.indicators).toContain('fn');
+      expect(result.indicators).toContain('let_mut');
+    });
+  });
+
+  describe('extractCodeBlocks', () => {
+    it('extracts fenced code blocks', () => {
+      const text = `
+        Here is some code:
+        
+        \`\`\`javascript
+        const x = 5;
+        console.log(x);
+        \`\`\`
+        
+        And another:
+        
+        \`\`\`python
+        print("hello")
+        \`\`\`
+      `;
+
+      const result = extractCodeBlocks(text);
+      expect(result.hasCode).toBe(true);
+      expect(result.blocks).toHaveLength(2);
+      expect(result.blocks[0].language).toBe('javascript');
+      expect(result.blocks[0].code).toContain('const x = 5');
+      expect(result.blocks[1].language).toBe('python');
+    });
+
+    it('handles code blocks without language annotation', () => {
+      const text = `
+        \`\`\`
+        some code here
+        \`\`\`
+      `;
+
+      const result = extractCodeBlocks(text);
+      expect(result.hasCode).toBe(true);
+      expect(result.blocks[0].language).toBeUndefined();
+    });
+
+    it('returns empty when no code found', () => {
+      const text = 'Just plain text without any code.';
+      const result = extractCodeBlocks(text);
+      expect(result.hasCode).toBe(false);
+      expect(result.blocks).toHaveLength(0);
+    });
+  });
+
+  describe('extractPrimaryCode', () => {
+    it('returns the largest code block', () => {
+      const text = `
+        \`\`\`
+        small
+        \`\`\`
+        
+        \`\`\`
+        this is a much larger code block
+        with multiple lines
+        of code
+        \`\`\`
+      `;
+
+      const code = extractPrimaryCode(text);
+      expect(code).toContain('much larger');
+    });
+
+    it('returns undefined for no code', () => {
+      const code = extractPrimaryCode('no code here');
+      expect(code).toBeUndefined();
+    });
+  });
+
+  describe('containsCode', () => {
+    it('returns true for code fences', () => {
+      expect(containsCode('```\ncode\n```')).toBe(true);
+    });
+
+    it('returns true for code-like patterns', () => {
+      expect(containsCode('function test() { return 42; }')).toBe(true);
+    });
+
+    it('returns false for plain text', () => {
+      expect(containsCode('Hello, this is just text.')).toBe(false);
+    });
+  });
+
+  describe('getFileExtension', () => {
+    it('returns correct extensions', () => {
+      expect(getFileExtension('javascript')).toBe('js');
+      expect(getFileExtension('typescript')).toBe('ts');
+      expect(getFileExtension('python')).toBe('py');
+      expect(getFileExtension('java')).toBe('java');
+      expect(getFileExtension('go')).toBe('go');
+      expect(getFileExtension('rust')).toBe('rs');
+      expect(getFileExtension('auto')).toBe('txt');
+    });
+  });
+
+  describe('CodeValidator', () => {
+    const createMockGenerator = (response: string) => vi.fn().mockResolvedValue({ text: response });
+
+    it('validates correct code', async () => {
+      const validator = new CodeValidator({
+        generateText: createMockGenerator('{"errors": [], "warnings": []}')
+      });
+
+      const result = await validator.validate(
+        'function add(a, b) { return a + b; }',
+        { enabled: true, language: 'javascript' },
+        ''
+      );
+
+      // Static analysis should pass for this simple function
+      expect(result.attempts).toBe(1);
+      expect(result.language).toBe('javascript');
+    });
+
+    it('detects syntax errors', async () => {
+      const validator = new CodeValidator({
+        generateText: createMockGenerator(
+          '{"errors": [{"message": "Missing bracket", "type": "syntax"}], "warnings": []}'
+        )
+      });
+
+      const result = await validator.validate(
+        'function test( { return 42; }', // Missing closing paren
+        { enabled: true, language: 'javascript', maxAttempts: 1 },
+        ''
+      );
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('respects maxAttempts', async () => {
+      let attempts = 0;
+      const validator = new CodeValidator({
+        generateText: vi.fn().mockImplementation(async () => {
+          attempts++;
+          return { text: '{"errors": [{"message": "error"}], "warnings": []}' };
+        })
+      });
+
+      const result = await validator.validate('broken code {{{', { enabled: true, maxAttempts: 2 }, '');
+
+      expect(result.attempts).toBeLessThanOrEqual(2);
+      expect(attempts).toBe(1);
+    });
+  });
+
+  describe('utility functions', () => {
+    it('createPassedValidationResult creates valid result', () => {
+      const result = createPassedValidationResult('code', 'javascript', 'output');
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+      expect(result.output).toBe('output');
+    });
+
+    it('createFailedValidationResult creates invalid result', () => {
+      const result = createFailedValidationResult('code', 'python', [
+        { type: 'syntax', message: 'Error', severity: 'error' }
+      ]);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+    });
+  });
+});

package/src/__tests__/ensemble.test.ts

@@ -0,0 +1,242 @@
+import type { EnsembleResponse } from '../ensemble/types';
+import { describe, expect, it, vi } from 'vitest';
+import { MultiSampler, createSingletonEnsembleResult } from '../ensemble/multi-sampler';
+
+describe('Ensemble / Multi-Sampling', () => {
+  describe('MultiSampler', () => {
+    const createMockGenerator = (responses: Array<{ text: string; error?: string }>) => {
+      let callIndex = 0;
+      return vi.fn().mockImplementation(async ({ temperature, sampleIndex }) => {
+        const response = responses[callIndex % responses.length];
+        callIndex++;
+
+        if (response.error) {
+          throw new Error(response.error);
+        }
+
+        return {
+          text: response.text,
+          usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+          finishReason: 'stop',
+          temperature,
+          sampleIndex
+        };
+      });
+    };
+
+    it('generates multiple samples', async () => {
+      const sampler = new MultiSampler({ modelId: 'test-model' });
+      const generator = createMockGenerator([{ text: 'Response 1' }, { text: 'Response 2' }, { text: 'Response 3' }]);
+
+      const result = await sampler.generate(generator, {
+        n: 3,
+        selectionStrategy: 'first'
+      });
+
+      expect(generator).toHaveBeenCalledTimes(3);
+      expect(result.text).toBe('Response 1');
+      expect(result.metadata.nRequested).toBe(3);
+      expect(result.metadata.nCompleted).toBe(3);
+    });
+
+    it('applies temperature variance', async () => {
+      const sampler = new MultiSampler({ modelId: 'test-model', baseTemperature: 0.5 });
+      const temperatures: number[] = [];
+
+      const generator = vi.fn().mockImplementation(async ({ temperature }) => {
+        temperatures.push(temperature);
+        return {
+          text: 'Response',
+          usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+          finishReason: 'stop'
+        };
+      });
+
+      await sampler.generate(generator, {
+        n: 3,
+        temperatureVariance: 0.2,
+        selectionStrategy: 'first'
+      });
+
+      expect(temperatures[0]).toBe(0.5);
+      expect(temperatures[1]).toBe(0.7);
+      expect(temperatures[2]).toBe(0.9);
+    });
+
+    describe('selection strategies', () => {
+      it('first strategy returns first response', async () => {
+        const sampler = new MultiSampler({ modelId: 'test-model' });
+        const generator = createMockGenerator([{ text: 'First' }, { text: 'Second' }, { text: 'Third' }]);
+
+        const result = await sampler.generate(generator, {
+          n: 3,
+          selectionStrategy: 'first'
+        });
+
+        expect(result.text).toBe('First');
+        expect(result.metadata.winningIndex).toBe(0);
+      });
+
+      it('best strategy with confidence heuristic prefers longer completions', async () => {
+        const sampler = new MultiSampler({ modelId: 'test-model' });
+        let callIndex = 0;
+
+        const generator = vi.fn().mockImplementation(async () => {
+          callIndex++;
+          const completionTokens = callIndex === 2 ? 100 : 20; // Second response has most tokens
+          return {
+            text: `Response ${callIndex}`,
+            usage: { promptTokens: 10, completionTokens, totalTokens: 10 + completionTokens },
+            finishReason: 'stop'
+          };
+        });
+
+        const result = await sampler.generate(generator, {
+          n: 3,
+          selectionStrategy: 'best',
+          scoringHeuristic: 'confidence'
+        });
+
+        expect(result.metadata.winningIndex).toBe(1); // Second response wins
+      });
+
+      it('best strategy with code heuristic penalizes errors', async () => {
+        const sampler = new MultiSampler({ modelId: 'test-model' });
+
+        const generator = vi.fn().mockImplementation(async ({ sampleIndex }) => {
+          const texts = [
+            'function test() { return SyntaxError; }', // Has error pattern
+            'function test() { return 42; }', // Clean code
+            'TypeError: undefined is not a function' // Has error
+          ];
+          return {
+            text: texts[sampleIndex],
+            usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+            finishReason: 'stop'
+          };
+        });
+
+        const result = await sampler.generate(generator, {
+          n: 3,
+          selectionStrategy: 'best',
+          scoringHeuristic: 'code'
+        });
+
+        expect(result.metadata.winningIndex).toBe(1); // Clean code wins
+      });
+
+      it('all strategy returns alternatives', async () => {
+        const sampler = new MultiSampler({ modelId: 'test-model' });
+        const generator = createMockGenerator([{ text: 'First' }, { text: 'Second' }, { text: 'Third' }]);
+
+        const result = await sampler.generate(generator, {
+          n: 3,
+          selectionStrategy: 'all'
+        });
+
+        expect(result.alternatives).toHaveLength(3);
+        expect(result.alternatives![0].text).toBe('First');
+        expect(result.alternatives![1].text).toBe('Second');
+        expect(result.alternatives![2].text).toBe('Third');
+      });
+    });
+
+    describe('error handling', () => {
+      it('handles partial failures with allowPartialFailure', async () => {
+        const sampler = new MultiSampler({ modelId: 'test-model' });
+        const generator = createMockGenerator([
+          { text: 'Success' },
+          { text: '', error: 'Failed' },
+          { text: 'Another success' }
+        ]);
+
+        const result = await sampler.generate(generator, {
+          n: 3,
+          selectionStrategy: 'first',
+          allowPartialFailure: true
+        });
+
+        expect(result.metadata.nCompleted).toBe(2);
+        expect(result.metadata.nFailed).toBe(1);
+      });
+
+      it('throws when all samples fail', async () => {
+        const sampler = new MultiSampler({ modelId: 'test-model' });
+        const generator = createMockGenerator([
+          { text: '', error: 'Failed 1' },
+          { text: '', error: 'Failed 2' },
+          { text: '', error: 'Failed 3' }
+        ]);
+
+        await expect(
+          sampler.generate(generator, {
+            n: 3,
+            selectionStrategy: 'first'
+          })
+        ).rejects.toThrow('All ensemble samples failed');
+      });
+
+      it('validates n parameter', async () => {
+        const sampler = new MultiSampler({ modelId: 'test-model' });
+        const generator = createMockGenerator([{ text: 'test' }]);
+
+        await expect(sampler.generate(generator, { n: 0, selectionStrategy: 'first' })).rejects.toThrow(
+          'Ensemble n must be between 1 and 10'
+        );
+
+        await expect(sampler.generate(generator, { n: 11, selectionStrategy: 'first' })).rejects.toThrow(
+          'Ensemble n must be between 1 and 10'
+        );
+      });
+    });
+
+    describe('custom scorer', () => {
+      it('uses custom scorer when heuristic is custom', async () => {
+        const sampler = new MultiSampler({ modelId: 'test-model' });
+
+        const generator = vi.fn().mockImplementation(async ({ sampleIndex }) => {
+          return {
+            text: `Response ${sampleIndex}`,
+            usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+            finishReason: 'stop'
+          };
+        });
+
+        const customScorer = vi.fn().mockImplementation((response: EnsembleResponse) => {
+          // Prefer response 2
+          return response.sampleIndex === 2 ? 100 : 10;
+        });
+
+        const result = await sampler.generate(generator, {
+          n: 3,
+          selectionStrategy: 'best',
+          scoringHeuristic: 'custom',
+          customScorer
+        });
+
+        expect(customScorer).toHaveBeenCalledTimes(3);
+        expect(result.metadata.winningIndex).toBe(2);
+      });
+    });
+  });
+
+  describe('createSingletonEnsembleResult', () => {
+    it('creates a result for single response', () => {
+      const response = {
+        text: 'Hello',
+        reasoning: 'Thinking...',
+        usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+        finishReason: 'stop'
+      };
+
+      const result = createSingletonEnsembleResult(response, 'test-model', 100);
+
+      expect(result.text).toBe('Hello');
+      expect(result.reasoning).toBe('Thinking...');
+      expect(result.metadata.nRequested).toBe(1);
+      expect(result.metadata.nCompleted).toBe(1);
+      expect(result.metadata.modelId).toBe('test-model');
+      expect(result.metadata.durationMs).toBe(100);
+    });
+  });
+});