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

package/dist/index.mjs

@@ -96,6 +96,46 @@ var KimiContextLengthError = class extends KimiError {
     this.name = "KimiContextLengthError";
   }
 };
+var KimiEnsembleValidationError = class extends KimiError {
+  constructor(message, config, modelId) {
+    super(message, "ensemble_validation_error", 400);
+    this.name = "KimiEnsembleValidationError";
+    this.config = config;
+    this.modelId = modelId;
+  }
+};
+var KimiEnsembleTimeoutError = class extends KimiError {
+  constructor(message, completedSamples, requestedSamples) {
+    super(message, "ensemble_timeout", 408);
+    this.name = "KimiEnsembleTimeoutError";
+    this.completedSamples = completedSamples;
+    this.requestedSamples = requestedSamples;
+  }
+};
+var KimiMultiAgentError = class extends KimiError {
+  constructor(message, workflow, step, stepError) {
+    super(message, "multi_agent_error", 500);
+    this.name = "KimiMultiAgentError";
+    this.workflow = workflow;
+    this.step = step;
+    this.stepError = stepError;
+  }
+};
+var KimiCodeValidationError = class extends KimiError {
+  constructor(message, validationErrors, attempts) {
+    super(message, "code_validation_error", 400);
+    this.name = "KimiCodeValidationError";
+    this.validationErrors = validationErrors;
+    this.attempts = attempts;
+  }
+};
+var KimiScaffoldError = class extends KimiError {
+  constructor(message, projectType) {
+    super(message, "scaffold_error", 500);
+    this.name = "KimiScaffoldError";
+    this.projectType = projectType;
+  }
+};
 
 // src/core/types.ts
 var THINKING_MODEL_TEMPERATURE = 1;
@@ -239,6 +279,131 @@ function extractMessageContent(message) {
   return { text, reasoning };
 }
 
+// src/tools/auto-detect.ts
+var WEB_SEARCH_PATTERNS = [
+  // Direct search requests
+  { pattern: /search\s+(for|the\s+web|online|internet)/i, weight: 1, name: "direct_search" },
+  { pattern: /look\s+up\b/i, weight: 0.9, name: "look_up" },
+  { pattern: /find\s+(information|info|data|details)\s+(about|on|regarding)/i, weight: 0.9, name: "find_info" },
+  // Real-time/current information
+  {
+    pattern: /\b(latest|current|recent|today'?s?|now)\b.*\b(news|price|weather|update|version|status)/i,
+    weight: 1,
+    name: "current_info"
+  },
+  { pattern: /what\s+(is|are)\s+the\s+(latest|current|newest)/i, weight: 0.95, name: "what_latest" },
+  { pattern: /\b(right\s+now|at\s+the\s+moment|currently)\b/i, weight: 0.7, name: "temporal" },
+  // News and events
+  { pattern: /\bnews\b.*\b(about|on|regarding)\b/i, weight: 0.85, name: "news_about" },
+  { pattern: /what('?s|\s+is)\s+happening\b/i, weight: 0.8, name: "happening" },
+  { pattern: /\b(headline|breaking|trending)\b/i, weight: 0.85, name: "headlines" },
+  // Prices and markets
+  { pattern: /\b(price|cost|rate)\s+of\b/i, weight: 0.7, name: "price" },
+  { pattern: /\b(stock|crypto|bitcoin|ethereum|btc|eth)\s+(price|value|market)/i, weight: 0.95, name: "crypto_stock" },
+  { pattern: /how\s+much\s+(does|is|are).*\b(cost|worth)\b/i, weight: 0.7, name: "how_much" },
+  // Weather
+  { pattern: /\bweather\b.*\b(in|at|for|today|tomorrow|forecast)\b/i, weight: 0.95, name: "weather" },
+  // Documentation and APIs
+  { pattern: /\bdocumentation\b.*\b(for|of|about)\b/i, weight: 0.6, name: "documentation" },
+  { pattern: /official\s+(website|docs|documentation|guide)/i, weight: 0.7, name: "official_docs" },
+  // Verification needs
+  { pattern: /\b(verify|confirm|check|fact-check)\b.*\b(true|accurate|correct|real)\b/i, weight: 0.75, name: "verify" },
+  // Comparisons with external data
+  { pattern: /\bcompare\b.*\b(prices|reviews|ratings|options)\b/i, weight: 0.65, name: "compare" }
+];
+var CODE_INTERPRETER_PATTERNS = [
+  // Direct code requests
+  { pattern: /write\s+(a\s+)?(function|code|script|program|algorithm)/i, weight: 0.95, name: "write_code" },
+  { pattern: /\b(code|implement|program)\s+(this|that|the|a)/i, weight: 0.85, name: "code_this" },
+  { pattern: /create\s+(a\s+)?(script|function|class|module)/i, weight: 0.9, name: "create_script" },
+  // Mathematical calculations
+  { pattern: /\bcalculate\b.*\d+/i, weight: 0.9, name: "calculate" },
+  { pattern: /\b(compute|evaluate|solve)\b.*\b(equation|expression|formula|problem)\b/i, weight: 0.9, name: "compute" },
+  { pattern: /what\s+(is|are)\s+\d+[\s+\-*/^]+\d+/i, weight: 0.95, name: "arithmetic" },
+  { pattern: /\b(factorial|fibonacci|prime|sqrt|power|exponent)\b/i, weight: 0.85, name: "math_functions" },
+  // Data processing
+  {
+    pattern: /\b(parse|process|transform|convert)\s+(this\s+)?(data|json|csv|xml)/i,
+    weight: 0.85,
+    name: "data_processing"
+  },
+  { pattern: /\b(analyze|process)\s+(this\s+)?(file|dataset|table)/i, weight: 0.8, name: "analyze_data" },
+  // Debugging
+  { pattern: /\bdebug\b.*\b(this|my|the)\s+(code|function|script|program)/i, weight: 0.9, name: "debug" },
+  { pattern: /\b(fix|correct|repair)\s+(this|my|the)\s+(error|bug|issue|problem)\b/i, weight: 0.85, name: "fix_error" },
+  {
+    pattern: /why\s+(is|does)\s+(this|my)\s+(code|function)\s+(not\s+work|fail|error)/i,
+    weight: 0.9,
+    name: "why_not_work"
+  },
+  // Testing
+  {
+    pattern: /\b(test|verify|validate)\s+(this|my|the)\s+(code|function|implementation)/i,
+    weight: 0.85,
+    name: "test_code"
+  },
+  { pattern: /\brun\s+(this|my|the)\s+(code|script|program)/i, weight: 0.95, name: "run_code" },
+  { pattern: /\bexecute\b.*\b(code|script|command)/i, weight: 0.95, name: "execute" },
+  // Code blocks in input (handles various markdown formats)
+  { pattern: /```[\w]*[\s\S]*?```/, weight: 0.7, name: "code_block" },
+  // Algorithm requests
+  { pattern: /\b(sort|search|traverse|optimize)\s+(algorithm|function|method)/i, weight: 0.85, name: "algorithm" },
+  // Regex
+  { pattern: /\b(regex|regular\s+expression)\b/i, weight: 0.75, name: "regex" },
+  // File operations
+  { pattern: /\b(read|write|create|delete)\s+(a\s+)?(file|directory|folder)/i, weight: 0.7, name: "file_ops" }
+];
+function detectToolsFromPrompt(prompt, config = {}) {
+  const { confidenceThreshold = 0.3, includePartialMatches = true } = config;
+  const webSearchResult = detectPatterns(prompt, WEB_SEARCH_PATTERNS, includePartialMatches);
+  const codeInterpreterResult = detectPatterns(prompt, CODE_INTERPRETER_PATTERNS, includePartialMatches);
+  return {
+    webSearch: webSearchResult.confidence >= confidenceThreshold,
+    codeInterpreter: codeInterpreterResult.confidence >= confidenceThreshold,
+    webSearchConfidence: webSearchResult.confidence,
+    codeInterpreterConfidence: codeInterpreterResult.confidence,
+    webSearchMatches: webSearchResult.matches,
+    codeInterpreterMatches: codeInterpreterResult.matches
+  };
+}
+function shouldAutoEnableTools(prompt) {
+  const result = detectToolsFromPrompt(prompt);
+  return {
+    webSearch: result.webSearch,
+    codeInterpreter: result.codeInterpreter
+  };
+}
+function detectPatterns(text, patterns, includePartial) {
+  const matches = [];
+  let maxWeight = 0;
+  let matchCount = 0;
+  for (const { pattern, weight, name } of patterns) {
+    if (pattern.test(text)) {
+      matches.push(name);
+      maxWeight = Math.max(maxWeight, weight);
+      matchCount++;
+    }
+  }
+  let confidence = 0;
+  if (matchCount > 0) {
+    if (includePartial) {
+      const boost = Math.min(0.15, (matchCount - 1) * 0.05);
+      confidence = Math.min(1, maxWeight + boost);
+    } else {
+      confidence = maxWeight;
+    }
+  }
+  return { confidence, matches };
+}
+function hasToolOptOut(prompt) {
+  const webSearchOptOut = /(don'?t|do\s+not|without|no)\s+(search(ing)?|web|internet|online)/i.test(prompt);
+  const codeOptOut = /(don'?t|do\s+not|without|no)\s+(run(ning)?|execut(e|ing)|cod(e|ing))/i.test(prompt) || /without\s+[\w\s]*running\s+code/i.test(prompt) || /(or|and)\s+running\s+code/i.test(prompt);
+  return {
+    webSearch: webSearchOptOut,
+    codeInterpreter: codeOptOut
+  };
+}
+
 // src/tools/builtin-tools.ts
 var KIMI_WEB_SEARCH_TOOL_NAME = "$web_search";
 var KIMI_CODE_INTERPRETER_TOOL_NAME = "$code";
@@ -435,11 +600,49 @@ function prepareKimiTools({
     }
   }
 }
+var TOOL_DESCRIPTIONS = {
+  $web_search: "Search the web for up-to-date information, current events, facts, news, prices, weather, or any data not available in your training",
+  $code: "Execute code to perform calculations, data processing, algorithmic tasks, or verify code correctness"
+};
+function generateToolGuidanceMessage(options) {
+  const { toolNames, choiceType, targetTool, promptContext, includeDescriptions = true } = options;
+  const lines = ["=== TOOL USAGE GUIDANCE ===", ""];
+  if (includeDescriptions && toolNames.length > 0) {
+    lines.push("Available tools:");
+    for (const toolName of toolNames) {
+      const description = TOOL_DESCRIPTIONS[toolName] || "Execute this tool";
+      lines.push(`- ${toolName}: ${description}`);
+    }
+    lines.push("");
+  }
+  if (choiceType === "required") {
+    lines.push("\u26A0\uFE0F IMPORTANT: You MUST use at least one of the available tools to respond.");
+    lines.push("Do NOT provide a direct text response without first calling a tool.");
+  } else if (choiceType === "tool" && targetTool) {
+    lines.push(`\u26A0\uFE0F IMPORTANT: You MUST use the "${targetTool}" tool to respond.`);
+    lines.push("Do NOT use any other tool or provide a direct text response.");
+  }
+  if (promptContext) {
+    lines.push("");
+    lines.push(`Task context: ${promptContext.slice(0, 200)}${promptContext.length > 200 ? "..." : ""}`);
+  }
+  return lines.join("\n");
+}
 function generateRequiredToolMessage(toolNames) {
-  return `IMPORTANT INSTRUCTION: You MUST use one of the available tools (${toolNames}) to respond to the user's request. Do NOT provide a direct text response without first calling a tool. Always invoke a tool to complete this task.`;
+  const tools = toolNames.split(", ");
+  return generateToolGuidanceMessage({
+    toolNames: tools,
+    choiceType: "required",
+    includeDescriptions: true
+  });
 }
 function generateSpecificToolMessage(toolName) {
-  return `IMPORTANT INSTRUCTION: You MUST use the "${toolName}" tool to respond to this request. Do NOT use any other tool or provide a direct text response. Call the "${toolName}" tool with appropriate parameters.`;
+  return generateToolGuidanceMessage({
+    toolNames: [toolName],
+    choiceType: "tool",
+    targetTool: toolName,
+    includeDescriptions: true
+  });
 }
 var UNSUPPORTED_SCHEMA_KEYWORDS = [
   "$schema",
@@ -785,7 +988,11 @@ var kimiProviderOptionsSchema = z2.object({
   /**
    * Enable tool choice polyfill for this request.
    */
-  toolChoicePolyfill: z2.boolean().optional()
+  toolChoicePolyfill: z2.boolean().optional(),
+  /**
+   * Auto-enable tools based on prompt content analysis.
+   */
+  autoEnableTools: z2.boolean().optional()
 });
 
 // src/chat/kimi-chat-language-model.ts
@@ -1401,6 +1608,879 @@ var kimiChatChunkBaseSchema = z3.looseObject({
 });
 var kimiChatChunkSchema = z3.union([kimiChatChunkBaseSchema, kimiErrorSchema]);
 
+// src/code-validation/detector.ts
+var LANGUAGE_PATTERNS = [
+  {
+    language: "typescript",
+    patterns: [
+      { pattern: /:\s*(string|number|boolean|void|any|unknown|never)\b/, weight: 0.9, name: "type_annotation" },
+      { pattern: /interface\s+\w+\s*{/, weight: 0.95, name: "interface" },
+      { pattern: /type\s+\w+\s*=/, weight: 0.9, name: "type_alias" },
+      { pattern: /<\w+>/, weight: 0.5, name: "generics" },
+      { pattern: /import\s+.*\s+from\s+['"]/, weight: 0.7, name: "import_from" },
+      { pattern: /export\s+(interface|type|enum)\b/, weight: 0.95, name: "export_type" },
+      { pattern: /as\s+(string|number|boolean|any)\b/, weight: 0.85, name: "type_assertion" }
+    ]
+  },
+  {
+    language: "javascript",
+    patterns: [
+      { pattern: /\bfunction\s+\w+\s*\(/, weight: 0.6, name: "function_decl" },
+      { pattern: /\bconst\s+\w+\s*=/, weight: 0.5, name: "const" },
+      { pattern: /\blet\s+\w+\s*=/, weight: 0.5, name: "let" },
+      { pattern: /=>\s*{/, weight: 0.6, name: "arrow_function" },
+      { pattern: /require\s*\(['"]/, weight: 0.7, name: "require" },
+      { pattern: /module\.exports\s*=/, weight: 0.85, name: "module_exports" },
+      { pattern: /console\.(log|error|warn)\(/, weight: 0.5, name: "console" }
+    ]
+  },
+  {
+    language: "python",
+    patterns: [
+      { pattern: /\bdef\s+\w+\s*\([^)]*\)\s*:/, weight: 0.9, name: "def" },
+      { pattern: /\bclass\s+\w+.*:/, weight: 0.85, name: "class" },
+      { pattern: /\bimport\s+\w+/, weight: 0.6, name: "import" },
+      { pattern: /\bfrom\s+\w+\s+import\b/, weight: 0.85, name: "from_import" },
+      { pattern: /\bif\s+__name__\s*==\s*['"]__main__['"]\s*:/, weight: 0.95, name: "main_guard" },
+      { pattern: /\bprint\s*\(/, weight: 0.5, name: "print" },
+      { pattern: /\bself\.\w+/, weight: 0.85, name: "self" },
+      { pattern: /#.*$/, weight: 0.3, name: "comment" }
+    ]
+  },
+  {
+    language: "java",
+    patterns: [
+      { pattern: /public\s+class\s+\w+/, weight: 0.95, name: "public_class" },
+      { pattern: /public\s+static\s+void\s+main/, weight: 0.98, name: "main_method" },
+      { pattern: /System\.out\.println/, weight: 0.9, name: "sysout" },
+      { pattern: /\bpackage\s+[\w.]+;/, weight: 0.95, name: "package" },
+      { pattern: /\bimport\s+[\w.]+;/, weight: 0.8, name: "import" },
+      { pattern: /@Override\b/, weight: 0.9, name: "override" },
+      { pattern: /\bprivate\s+\w+\s+\w+;/, weight: 0.7, name: "private_field" }
+    ]
+  },
+  {
+    language: "go",
+    patterns: [
+      { pattern: /\bpackage\s+main\b/, weight: 0.95, name: "package_main" },
+      { pattern: /\bfunc\s+\w+\s*\(/, weight: 0.85, name: "func" },
+      { pattern: /\bfmt\.Print/, weight: 0.9, name: "fmt_print" },
+      { pattern: /\bimport\s+\(/, weight: 0.85, name: "import_block" },
+      { pattern: /:=/, weight: 0.7, name: "short_var_decl" },
+      { pattern: /\bgo\s+\w+\(/, weight: 0.9, name: "goroutine" },
+      { pattern: /\bchan\s+\w+/, weight: 0.9, name: "channel" }
+    ]
+  },
+  {
+    language: "rust",
+    patterns: [
+      { pattern: /\bfn\s+\w+\s*\(/, weight: 0.9, name: "fn" },
+      { pattern: /\blet\s+mut\s+\w+/, weight: 0.95, name: "let_mut" },
+      { pattern: /\bimpl\s+\w+\s+for\s+\w+/, weight: 0.95, name: "impl_for" },
+      { pattern: /\buse\s+[\w:]+;/, weight: 0.85, name: "use" },
+      { pattern: /\bpub\s+(fn|struct|enum|mod)\b/, weight: 0.9, name: "pub" },
+      { pattern: /->.*{/, weight: 0.7, name: "return_type" },
+      { pattern: /\bprintln!\(/, weight: 0.95, name: "println_macro" }
+    ]
+  },
+  {
+    language: "ruby",
+    patterns: [
+      { pattern: /\bdef\s+\w+/, weight: 0.8, name: "def" },
+      { pattern: /\bclass\s+\w+/, weight: 0.7, name: "class" },
+      { pattern: /\bend\s*$/, weight: 0.4, name: "end" },
+      { pattern: /\brequire\s+['"]/, weight: 0.85, name: "require" },
+      { pattern: /\bputs\s+/, weight: 0.8, name: "puts" },
+      { pattern: /@\w+/, weight: 0.5, name: "instance_var" },
+      { pattern: /\.each\s+do\s*\|/, weight: 0.85, name: "each_block" }
+    ]
+  },
+  {
+    language: "php",
+    patterns: [
+      { pattern: /<\?php/, weight: 0.98, name: "php_tag" },
+      { pattern: /\$\w+\s*=/, weight: 0.75, name: "php_var" },
+      { pattern: /\bfunction\s+\w+\s*\(/, weight: 0.5, name: "function" },
+      { pattern: /\becho\s+/, weight: 0.7, name: "echo" },
+      { pattern: /->(\w+)\(/, weight: 0.6, name: "method_call" },
+      { pattern: /\buse\s+[\w\\]+;/, weight: 0.8, name: "use" }
+    ]
+  },
+  {
+    language: "cpp",
+    patterns: [
+      { pattern: /#include\s*<[\w.]+>/, weight: 0.9, name: "include_angle" },
+      { pattern: /#include\s*"[\w.]+"/, weight: 0.85, name: "include_quote" },
+      { pattern: /\bstd::\w+/, weight: 0.9, name: "std_namespace" },
+      { pattern: /\bint\s+main\s*\(/, weight: 0.95, name: "main" },
+      { pattern: /\bcout\s*<</, weight: 0.95, name: "cout" },
+      { pattern: /\bnamespace\s+\w+/, weight: 0.85, name: "namespace" },
+      { pattern: /\btemplate\s*</, weight: 0.9, name: "template" }
+    ]
+  }
+];
+function detectLanguage(code) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const { language } of LANGUAGE_PATTERNS) {
+    scores.set(language, { score: 0, indicators: [] });
+  }
+  for (const { language, patterns } of LANGUAGE_PATTERNS) {
+    const langScore = scores.get(language);
+    for (const { pattern, weight, name } of patterns) {
+      if (pattern.test(code)) {
+        langScore.score += weight;
+        langScore.indicators.push(name);
+      }
+    }
+  }
+  let bestLanguage = "javascript";
+  let bestScore = 0;
+  let bestIndicators = [];
+  for (const [language, { score, indicators }] of scores) {
+    if (score > bestScore) {
+      bestScore = score;
+      bestLanguage = language;
+      bestIndicators = indicators;
+    }
+  }
+  const tsScore = scores.get("typescript").score;
+  const jsScore = scores.get("javascript").score;
+  if (tsScore > 0 && jsScore > 0 && Math.abs(tsScore - jsScore) < 0.5 && scores.get("typescript").indicators.some((i) => ["type_annotation", "interface", "type_alias", "export_type"].includes(i))) {
+    bestLanguage = "typescript";
+    bestScore = tsScore;
+    bestIndicators = scores.get("typescript").indicators;
+  }
+  const maxPossibleScore = LANGUAGE_PATTERNS.find((l) => l.language === bestLanguage)?.patterns.reduce((sum, p) => sum + p.weight, 0) ?? 1;
+  const confidence = Math.min(1, bestScore / Math.max(1, maxPossibleScore * 0.5));
+  return {
+    language: bestLanguage,
+    confidence,
+    indicators: bestIndicators
+  };
+}
+function extractCodeBlocks(text) {
+  const blocks = [];
+  const fenceRegex = /```(\w*)\n([\s\S]*?)```/g;
+  let match = fenceRegex.exec(text);
+  while (match !== null) {
+    blocks.push({
+      code: match[2].trim(),
+      language: match[1] || void 0,
+      startIndex: match.index,
+      endIndex: match.index + match[0].length
+    });
+    match = fenceRegex.exec(text);
+  }
+  if (blocks.length === 0) {
+    const { confidence } = detectLanguage(text);
+    if (confidence > 0.3) {
+      blocks.push({
+        code: text.trim(),
+        startIndex: 0,
+        endIndex: text.length
+      });
+    }
+  }
+  return {
+    blocks,
+    hasCode: blocks.length > 0
+  };
+}
+function extractPrimaryCode(text) {
+  const { blocks, hasCode } = extractCodeBlocks(text);
+  if (!hasCode) {
+    return void 0;
+  }
+  return blocks.reduce((largest, block) => block.code.length > largest.code.length ? block : largest).code;
+}
+function containsCode(text) {
+  if (/```[\s\S]*```/.test(text)) {
+    return true;
+  }
+  const quickCodePatterns = [
+    /\bfunction\s+\w+\s*\([^)]*\)\s*\{/,
+    // function declarations
+    /\bconst\s+\w+\s*=\s*\([^)]*\)\s*=>/,
+    // arrow functions
+    /\bclass\s+\w+\s*(\s+extends\s+\w+)?\s*\{/,
+    // class declarations
+    /\bdef\s+\w+\s*\([^)]*\)\s*:/,
+    // Python functions
+    /\bimport\s+.*\s+from\s+['"]/,
+    // ES imports
+    /\b(if|for|while)\s*\([^)]*\)\s*\{/,
+    // Control structures with braces
+    /=>\s*\{[\s\S]*\}/,
+    // Arrow function bodies
+    /\breturn\s+[\w"'`{[<]/
+    // Return statements
+  ];
+  for (const pattern of quickCodePatterns) {
+    if (pattern.test(text)) {
+      return true;
+    }
+  }
+  const { confidence } = detectLanguage(text);
+  return confidence > 0.4;
+}
+function getFileExtension(language) {
+  const extensions = {
+    javascript: "js",
+    typescript: "ts",
+    python: "py",
+    java: "java",
+    cpp: "cpp",
+    go: "go",
+    rust: "rs",
+    ruby: "rb",
+    php: "php",
+    auto: "txt"
+  };
+  return extensions[language] || "txt";
+}
+
+// src/code-validation/validator.ts
+var CodeValidator = class {
+  constructor(options) {
+    this.generateText = options.generateText;
+    this.executeCode = options.executeCode;
+  }
+  /**
+   * Validate code and optionally fix errors.
+   *
+   * @param code - The code to validate
+   * @param config - Validation configuration
+   * @param originalPrompt - The original user prompt (for context in fixes)
+   * @returns Validation result
+   */
+  async validate(code, config, originalPrompt = "") {
+    const {
+      maxAttempts = 3,
+      language: configLanguage = "auto",
+      executionTimeoutMs = 3e4,
+      strictness = "strict",
+      returnPartialFix = true
+    } = config;
+    const language = configLanguage === "auto" ? detectLanguage(code).language : configLanguage;
+    let currentCode = code;
+    const allErrors = [];
+    const allWarnings = [];
+    const fixHistory = [];
+    let attempts = 0;
+    for (let i = 0; i < maxAttempts; i++) {
+      attempts++;
+      const validationResult = await this.validateCode(currentCode, language, strictness, executionTimeoutMs);
+      const newErrors = validationResult.errors.filter(
+        (e) => !allErrors.some((existing) => existing.message === e.message)
+      );
+      allErrors.push(...newErrors);
+      allWarnings.push(...validationResult.warnings);
+      if (validationResult.valid) {
+        return {
+          valid: true,
+          errors: [],
+          warnings: allWarnings,
+          output: validationResult.output,
+          executionTimeMs: validationResult.executionTimeMs,
+          attempts,
+          finalCode: currentCode,
+          originalCode: code,
+          language,
+          fixHistory
+        };
+      }
+      if (i === maxAttempts - 1) {
+        break;
+      }
+      const fixResult = await this.attemptFix(currentCode, validationResult.errors, language, originalPrompt);
+      fixHistory.push({
+        attempt: attempts,
+        codeBefore: currentCode,
+        codeAfter: fixResult.code,
+        errorsAddressed: validationResult.errors,
+        success: false
+        // Will be updated if next validation passes
+      });
+      if (fixResult.fixed) {
+        currentCode = fixResult.code;
+      } else {
+        break;
+      }
+    }
+    return {
+      valid: false,
+      errors: allErrors,
+      warnings: allWarnings,
+      attempts,
+      finalCode: returnPartialFix ? currentCode : code,
+      originalCode: code,
+      language,
+      fixHistory
+    };
+  }
+  /**
+   * Validate code without attempting fixes.
+   */
+  async validateCode(code, language, strictness, _timeoutMs) {
+    const errors = [];
+    const warnings = [];
+    const staticErrors = this.performStaticAnalysis(code, language);
+    errors.push(...staticErrors);
+    if (staticErrors.some((e) => e.type === "syntax" && e.severity === "error")) {
+      return { valid: false, errors, warnings };
+    }
+    if (this.executeCode) {
+      try {
+        const startTime = Date.now();
+        const output = await this.executeCode(code, language);
+        const executionTimeMs = Date.now() - startTime;
+        const runtimeErrors = this.detectRuntimeErrors(output);
+        errors.push(...runtimeErrors);
+        if (runtimeErrors.length === 0) {
+          return {
+            valid: true,
+            errors: [],
+            warnings,
+            output,
+            executionTimeMs
+          };
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Execution failed";
+        errors.push({
+          type: "runtime",
+          message,
+          severity: "error"
+        });
+      }
+    }
+    if (!this.executeCode && strictness !== "lenient") {
+      const llmValidation = await this.validateWithLLM(code, language);
+      errors.push(...llmValidation.errors);
+      warnings.push(...llmValidation.warnings);
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Perform static analysis on code.
+   */
+  performStaticAnalysis(code, language) {
+    const errors = [];
+    switch (language) {
+      case "javascript":
+      case "typescript":
+        errors.push(...this.analyzeJavaScript(code));
+        break;
+      case "python":
+        errors.push(...this.analyzePython(code));
+        break;
+      default:
+        errors.push(...this.analyzeGeneric(code));
+    }
+    return errors;
+  }
+  /**
+   * Analyze JavaScript/TypeScript code.
+   */
+  analyzeJavaScript(code) {
+    const errors = [];
+    const patterns = [
+      { pattern: /\bif\s*\([^)]*\)\s*[^{](?!.*[;{])/, message: "Missing braces after if statement" },
+      { pattern: /\bfor\s*\([^)]*\)\s*[^{](?!.*[;{])/, message: "Missing braces after for loop" },
+      { pattern: /==(?!=)/, message: "Use === instead of == for strict equality", isWarning: true },
+      { pattern: /!=(?!=)/, message: "Use !== instead of != for strict inequality", isWarning: true },
+      { pattern: /\bconsole\.log\(/, message: "Console.log found - remove for production", isWarning: true }
+    ];
+    const bracketBalance = this.checkBracketBalance(code);
+    if (!bracketBalance.valid) {
+      errors.push({
+        type: "syntax",
+        message: bracketBalance.message,
+        severity: "error"
+      });
+    }
+    for (const { pattern, message, isWarning } of patterns) {
+      if (pattern.test(code)) {
+        errors.push({
+          type: isWarning ? "style" : "syntax",
+          message,
+          severity: isWarning ? "warning" : "error"
+        });
+      }
+    }
+    return errors;
+  }
+  /**
+   * Analyze Python code.
+   */
+  analyzePython(code) {
+    const errors = [];
+    const lines = code.split("\n");
+    let indentUnit = null;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim() === "" || line.trim().startsWith("#")) {
+        continue;
+      }
+      const leadingSpaces = line.match(/^(\s*)/)?.[1].length ?? 0;
+      if (indentUnit === null && leadingSpaces > 0) {
+        indentUnit = leadingSpaces;
+      }
+      if (/^\s*\t/.test(line) && /^\s* /.test(line)) {
+        errors.push({
+          type: "style",
+          message: "Mixed tabs and spaces in indentation",
+          line: i + 1,
+          severity: "warning"
+        });
+      }
+    }
+    if (/\bprint\s+[^(]/.test(code)) {
+      errors.push({
+        type: "syntax",
+        message: "Python 2 print statement syntax - use print() function",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  /**
+   * Generic code analysis.
+   */
+  analyzeGeneric(code) {
+    const errors = [];
+    const bracketBalance = this.checkBracketBalance(code);
+    if (!bracketBalance.valid) {
+      errors.push({
+        type: "syntax",
+        message: bracketBalance.message,
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  /**
+   * Check bracket balance in code.
+   */
+  checkBracketBalance(code) {
+    const stack = [];
+    const pairs = {
+      "(": ")",
+      "[": "]",
+      "{": "}"
+    };
+    const cleanCode = code.replace(/"[^"\\]*(\\.[^"\\]*)*"/g, '""').replace(/'[^'\\]*(\\.[^'\\]*)*'/g, "''").replace(/`[^`\\]*(\\.[^`\\]*)*`/g, "``").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/#.*$/gm, "");
+    for (const char of cleanCode) {
+      if (char in pairs) {
+        stack.push(pairs[char]);
+      } else if (Object.values(pairs).includes(char)) {
+        if (stack.length === 0 || stack.pop() !== char) {
+          return { valid: false, message: `Unmatched bracket: ${char}` };
+        }
+      }
+    }
+    if (stack.length > 0) {
+      return { valid: false, message: `Missing closing bracket: ${stack[stack.length - 1]}` };
+    }
+    return { valid: true, message: "" };
+  }
+  /**
+   * Detect runtime errors from execution output.
+   */
+  detectRuntimeErrors(output) {
+    const errors = [];
+    const errorPatterns = [
+      { pattern: /SyntaxError:\s*(.+)/i, type: "syntax" },
+      { pattern: /ReferenceError:\s*(.+)/i, type: "runtime" },
+      { pattern: /TypeError:\s*(.+)/i, type: "runtime" },
+      { pattern: /RangeError:\s*(.+)/i, type: "runtime" },
+      { pattern: /Error:\s*(.+)/i, type: "runtime" },
+      { pattern: /Exception:\s*(.+)/i, type: "runtime" },
+      { pattern: /Traceback \(most recent call last\)/i, type: "runtime" }
+    ];
+    for (const { pattern, type } of errorPatterns) {
+      const match = output.match(pattern);
+      if (match) {
+        errors.push({
+          type,
+          message: match[1] || match[0],
+          severity: "error"
+        });
+      }
+    }
+    return errors;
+  }
+  /**
+   * Use LLM to validate code.
+   */
+  async validateWithLLM(code, language) {
+    const prompt = `Analyze this ${language} code for errors. Only report actual bugs, not style preferences.
+Return JSON format: {"errors": [{"message": "...", "line": N, "type": "syntax|runtime|logic"}], "warnings": [{"message": "..."}]}
+If no errors, return: {"errors": [], "warnings": []}
+
+Code:
+\`\`\`${language}
+${code}
+\`\`\`
+
+Respond ONLY with the JSON object, no other text.`;
+    try {
+      const result = await this.generateText(prompt);
+      const parsed = JSON.parse(result.text);
+      return {
+        errors: (parsed.errors || []).map((e) => {
+          return {
+            type: e.type || "logic",
+            message: e.message,
+            line: e.line,
+            severity: "error"
+          };
+        }),
+        warnings: (parsed.warnings || []).map((w) => {
+          return {
+            type: "style",
+            message: w.message,
+            severity: "warning"
+          };
+        })
+      };
+    } catch {
+      return { errors: [], warnings: [] };
+    }
+  }
+  /**
+   * Attempt to fix errors in code.
+   */
+  async attemptFix(code, errors, language, originalPrompt) {
+    const errorList = errors.map((e) => `- ${e.type}: ${e.message}${e.line ? ` (line ${e.line})` : ""}`).join("\n");
+    const prompt = `Fix the following errors in this ${language} code.
+
+${originalPrompt ? `Original request: ${originalPrompt}
+` : ""}
+Errors to fix:
+${errorList}
+
+Current code:
+\`\`\`${language}
+${code}
+\`\`\`
+
+Provide ONLY the fixed code wrapped in a code block. No explanations.`;
+    try {
+      const result = await this.generateText(prompt);
+      const extractedCode = extractPrimaryCode(result.text);
+      if (extractedCode && extractedCode !== code) {
+        return { fixed: true, code: extractedCode };
+      }
+    } catch {
+    }
+    return { fixed: false, code };
+  }
+};
+function createPassedValidationResult(code, language, output) {
+  return {
+    valid: true,
+    errors: [],
+    warnings: [],
+    output,
+    attempts: 1,
+    finalCode: code,
+    originalCode: code,
+    language
+  };
+}
+function createFailedValidationResult(code, language, errors) {
+  return {
+    valid: false,
+    errors,
+    warnings: [],
+    attempts: 1,
+    finalCode: code,
+    originalCode: code,
+    language
+  };
+}
+
+// src/ensemble/multi-sampler.ts
+var MultiSampler = class {
+  constructor(options) {
+    this.modelId = options.modelId;
+    this.baseTemperature = options.baseTemperature ?? 0.7;
+  }
+  /**
+   * Generate multiple samples and select the best one.
+   *
+   * @param generateFn - Function to generate a single response
+   * @param config - Ensemble configuration
+   * @returns The ensemble result
+   */
+  async generate(generateFn, config) {
+    const startTime = Date.now();
+    const {
+      n,
+      selectionStrategy = "best",
+      temperatureVariance = 0.1,
+      scoringHeuristic = "confidence",
+      customScorer,
+      timeoutMs = 6e4,
+      allowPartialFailure = true,
+      minSuccessfulSamples = 1
+    } = config;
+    if (n < 1 || n > 10) {
+      throw new Error("Ensemble n must be between 1 and 10");
+    }
+    const promises = Array.from({ length: n }, async (_, i) => {
+      const temperature = Math.min(this.baseTemperature + i * temperatureVariance, 2);
+      const sampleStart = Date.now();
+      try {
+        const result2 = await generateFn({ temperature, sampleIndex: i });
+        return {
+          text: result2.text,
+          reasoning: result2.reasoning,
+          toolCalls: result2.toolCalls,
+          toolResults: result2.toolResults,
+          usage: result2.usage,
+          sampleIndex: i,
+          temperature,
+          finishReason: result2.finishReason,
+          success: true,
+          durationMs: Date.now() - sampleStart
+        };
+      } catch (error) {
+        return {
+          text: "",
+          sampleIndex: i,
+          temperature,
+          finishReason: "error",
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error",
+          durationMs: Date.now() - sampleStart
+        };
+      }
+    });
+    let responses;
+    try {
+      responses = await Promise.race([
+        Promise.all(promises),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Ensemble generation timed out")), timeoutMs)
+        )
+      ]);
+    } catch (_error) {
+      const partialResponses = await Promise.all(
+        promises.map(
+          (p) => p.catch(
+            () => ({
+              text: "",
+              sampleIndex: -1,
+              temperature: 0,
+              finishReason: "timeout",
+              success: false,
+              error: "Timed out"
+            })
+          )
+        )
+      );
+      responses = partialResponses.filter((r) => r.sampleIndex >= 0);
+    }
+    const successfulResponses = responses.filter((r) => r.success);
+    if (successfulResponses.length < minSuccessfulSamples && !allowPartialFailure) {
+      throw new Error(
+        `Only ${successfulResponses.length} samples succeeded, minimum required is ${minSuccessfulSamples}`
+      );
+    }
+    if (successfulResponses.length === 0) {
+      throw new Error("All ensemble samples failed");
+    }
+    const result = this.selectBest(successfulResponses, responses, {
+      selectionStrategy,
+      scoringHeuristic,
+      customScorer,
+      modelId: this.modelId,
+      startTime
+    });
+    return result;
+  }
+  /**
+   * Select the best response based on the strategy.
+   */
+  selectBest(successfulResponses, allResponses, options) {
+    const { selectionStrategy, scoringHeuristic, customScorer, modelId, startTime } = options;
+    const scored = successfulResponses.map((r) => {
+      return {
+        ...r,
+        score: this.calculateScore(r, scoringHeuristic, customScorer)
+      };
+    });
+    let winner;
+    let alternatives;
+    switch (selectionStrategy) {
+      case "first":
+        winner = scored[0];
+        break;
+      case "vote":
+        winner = this.majorityVote(scored);
+        break;
+      case "best":
+        scored.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+        winner = scored[0];
+        break;
+      case "all":
+        winner = scored[0];
+        alternatives = scored;
+        break;
+      default:
+        throw new Error(`Unknown selection strategy: ${selectionStrategy}`);
+    }
+    const metadata = {
+      nRequested: allResponses.length,
+      nCompleted: successfulResponses.length,
+      nFailed: allResponses.filter((r) => !r.success).length,
+      selectionStrategy,
+      winningIndex: winner.sampleIndex,
+      scores: scored.map((r) => r.score ?? 0),
+      durationMs: Date.now() - startTime,
+      modelId,
+      totalUsage: this.aggregateUsage(successfulResponses)
+    };
+    return {
+      text: winner.text,
+      reasoning: winner.reasoning,
+      toolCalls: winner.toolCalls,
+      toolResults: winner.toolResults,
+      usage: winner.usage ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+      alternatives,
+      metadata
+    };
+  }
+  /**
+   * Calculate score for a response based on the heuristic.
+   */
+  calculateScore(response, heuristic, customScorer) {
+    switch (heuristic) {
+      case "length":
+        return 1e3 / (response.text.length + 1);
+      case "confidence":
+        return response.usage?.completionTokens ?? 0;
+      case "code":
+        return this.scoreCodeQuality(response.text);
+      case "custom":
+        if (!customScorer) {
+          throw new Error("Custom scorer function required for custom heuristic");
+        }
+        return customScorer(response);
+      default:
+        return 0;
+    }
+  }
+  /**
+   * Score code quality based on heuristics.
+   */
+  scoreCodeQuality(text) {
+    let score = 100;
+    const errorPatterns = [
+      { pattern: /SyntaxError/gi, penalty: 25 },
+      { pattern: /ReferenceError/gi, penalty: 20 },
+      { pattern: /TypeError/gi, penalty: 20 },
+      { pattern: /undefined is not/gi, penalty: 15 },
+      { pattern: /cannot read property/gi, penalty: 15 },
+      { pattern: /is not defined/gi, penalty: 15 },
+      { pattern: /unexpected token/gi, penalty: 20 },
+      { pattern: /null is not/gi, penalty: 15 }
+    ];
+    for (const { pattern, penalty } of errorPatterns) {
+      const matches = text.match(pattern);
+      if (matches) {
+        score -= penalty * matches.length;
+      }
+    }
+    if (text.includes("```")) {
+      score += 10;
+    }
+    if (/\/\/.*|\/\*[\s\S]*?\*\/|#.*/.test(text)) {
+      score += 5;
+    }
+    if (/\b(test|spec|assert|expect|describe|it)\b/i.test(text)) {
+      score += 5;
+    }
+    if (/:\s*(string|number|boolean|void|any|unknown|never)\b/.test(text)) {
+      score += 5;
+    }
+    if (/\b(TODO|FIXME|XXX|HACK)\b/i.test(text)) {
+      score -= 5;
+    }
+    return Math.max(0, score);
+  }
+  /**
+   * Select the most common response (majority voting).
+   */
+  majorityVote(responses) {
+    const normalized = responses.map((r) => {
+      return {
+        response: r,
+        key: r.text.toLowerCase().replace(/\s+/g, " ").trim().slice(0, 500)
+      };
+    });
+    const votes = /* @__PURE__ */ new Map();
+    for (const { response, key } of normalized) {
+      const existing = votes.get(key);
+      if (existing) {
+        existing.count++;
+      } else {
+        votes.set(key, { count: 1, response });
+      }
+    }
+    let maxVotes = 0;
+    let winner = responses[0];
+    for (const { count, response } of votes.values()) {
+      if (count > maxVotes) {
+        maxVotes = count;
+        winner = response;
+      }
+    }
+    return winner;
+  }
+  /**
+   * Aggregate usage across all responses.
+   */
+  aggregateUsage(responses) {
+    return responses.reduce(
+      (acc, r) => {
+        return {
+          promptTokens: acc.promptTokens + (r.usage?.promptTokens ?? 0),
+          completionTokens: acc.completionTokens + (r.usage?.completionTokens ?? 0),
+          totalTokens: acc.totalTokens + (r.usage?.totalTokens ?? 0)
+        };
+      },
+      { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+    );
+  }
+};
+function createSingletonEnsembleResult(response, modelId, durationMs) {
+  return {
+    text: response.text,
+    reasoning: response.reasoning,
+    toolCalls: response.toolCalls,
+    toolResults: response.toolResults,
+    usage: response.usage ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+    metadata: {
+      nRequested: 1,
+      nCompleted: 1,
+      nFailed: 0,
+      selectionStrategy: "first",
+      winningIndex: 0,
+      scores: [100],
+      durationMs,
+      modelId,
+      totalUsage: response.usage ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+    }
+  };
+}
+
 // src/files/file-cache.ts
 var FileCache = class {
   constructor(options = {}) {
@@ -2021,8 +3101,747 @@ function guessFilename(attachment, contentType) {
   return extensionMap[contentType] ?? "file.bin";
 }
 
+// src/multi-agent/types.ts
+var DEFAULT_SYSTEM_PROMPTS = {
+  planner: `You are a system architect and planner. Your role is to:
+1. Analyze the problem thoroughly
+2. Break it down into clear, actionable steps
+3. Consider edge cases and potential issues
+4. Provide a detailed implementation plan
+
+Format your response as a numbered list of steps that can be followed to implement the solution.`,
+  executor: `You are an expert implementer. Your role is to:
+1. Follow the provided plan precisely
+2. Write clean, well-documented code
+3. Handle edge cases mentioned in the plan
+4. Ensure the implementation is complete and functional
+
+Provide only the implementation code with necessary comments.`,
+  proposer: `You are a solution architect. Your role is to:
+1. Analyze the problem carefully
+2. Propose a complete solution
+3. Consider best practices and patterns
+4. Write clean, maintainable code
+
+Provide your solution with explanations for key design decisions.`,
+  critic: `You are a code reviewer and critic. Your role is to:
+1. Review the proposed solution critically
+2. Identify any bugs, errors, or issues
+3. Suggest improvements for performance and readability
+4. Verify edge cases are handled
+
+Provide specific, actionable feedback. Be thorough but constructive.`
+};
+
+// src/multi-agent/workflows.ts
+var WorkflowRunner = class {
+  constructor(generateText, validateCode) {
+    this.generateText = generateText;
+    this.validateCode = validateCode;
+  }
+  /**
+   * Run a multi-agent workflow.
+   */
+  async run(prompt, config) {
+    const startTime = Date.now();
+    switch (config.workflow) {
+      case "planner-executor":
+        return this.runPlannerExecutor(prompt, config, startTime);
+      case "proposer-critic":
+        return this.runProposerCritic(prompt, config, startTime);
+      case "debate":
+        return this.runDebate(prompt, config, startTime);
+      case "custom":
+        if (!config.customWorkflow) {
+          throw new Error("Custom workflow requires customWorkflow function");
+        }
+        return this.runCustom(prompt, config, startTime);
+      default:
+        throw new Error(`Unknown workflow type: ${config.workflow}`);
+    }
+  }
+  /**
+   * Planner-Executor workflow.
+   */
+  async runPlannerExecutor(prompt, config, startTime) {
+    const steps = [];
+    let totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    const modelA = config.modelA || "kimi-k2.5-thinking";
+    const modelB = config.modelB || "kimi-k2.5";
+    const planStart = Date.now();
+    const plannerPrompt = `${config.systemPrompts?.planner || DEFAULT_SYSTEM_PROMPTS.planner}
+
+Problem to solve:
+${prompt}
+
+Provide a detailed step-by-step plan.`;
+    const planResult = await this.generateText(modelA, plannerPrompt);
+    steps.push({
+      agent: "A (Planner)",
+      role: "planner",
+      action: "Create implementation plan",
+      input: prompt,
+      output: planResult.text,
+      timestamp: Date.now(),
+      durationMs: Date.now() - planStart,
+      usage: planResult.usage,
+      model: modelA
+    });
+    totalUsage = this.addUsage(totalUsage, planResult.usage);
+    const execStart = Date.now();
+    const executorPrompt = `${config.systemPrompts?.executor || DEFAULT_SYSTEM_PROMPTS.executor}
+
+Plan to implement:
+${planResult.text}
+
+Original problem: ${prompt}
+
+Implement the solution following the plan.`;
+    const execResult = await this.generateText(modelB, executorPrompt);
+    steps.push({
+      agent: "B (Executor)",
+      role: "executor",
+      action: "Implement solution",
+      input: planResult.text,
+      output: execResult.text,
+      timestamp: Date.now(),
+      durationMs: Date.now() - execStart,
+      usage: execResult.usage,
+      model: modelB
+    });
+    totalUsage = this.addUsage(totalUsage, execResult.usage);
+    let validation;
+    if (config.validateCode && this.validateCode) {
+      const code = extractPrimaryCode(execResult.text);
+      if (code) {
+        const validStart = Date.now();
+        const validResult = await this.validateCode(code);
+        steps.push({
+          agent: "Validator",
+          role: "validator",
+          action: "Validate code",
+          input: code,
+          output: validResult.valid ? "Code is valid" : `Errors: ${validResult.errors.join(", ")}`,
+          timestamp: Date.now(),
+          durationMs: Date.now() - validStart
+        });
+        validation = {
+          valid: validResult.valid,
+          errors: validResult.errors,
+          finalCode: validResult.fixedCode || code
+        };
+      }
+    }
+    return {
+      text: execResult.text,
+      reasoning: planResult.text,
+      intermediateSteps: steps,
+      usage: totalUsage,
+      metadata: this.buildMetadata(config, steps, startTime, [modelA, modelB]),
+      validation
+    };
+  }
+  /**
+   * Proposer-Critic workflow.
+   */
+  async runProposerCritic(prompt, config, startTime) {
+    const steps = [];
+    let totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    const modelA = config.modelA || "kimi-k2.5";
+    const modelB = config.modelB || "kimi-k2.5-thinking";
+    const iterations = config.iterations || 2;
+    let currentSolution = "";
+    let critique = "";
+    for (let i = 0; i < iterations; i++) {
+      const proposeStart = Date.now();
+      const proposerPrompt = i === 0 ? `${config.systemPrompts?.proposer || DEFAULT_SYSTEM_PROMPTS.proposer}
+
+Problem: ${prompt}
+
+Provide your solution.` : `${config.systemPrompts?.proposer || DEFAULT_SYSTEM_PROMPTS.proposer}
+
+Problem: ${prompt}
+
+Previous solution:
+${currentSolution}
+
+Critique/feedback to address:
+${critique}
+
+Provide an improved solution addressing the feedback.`;
+      const proposeResult = await this.generateText(modelA, proposerPrompt);
+      currentSolution = proposeResult.text;
+      steps.push({
+        agent: "A (Proposer)",
+        role: "proposer",
+        action: `Generate solution (iteration ${i + 1})`,
+        input: i === 0 ? prompt : critique,
+        output: currentSolution,
+        timestamp: Date.now(),
+        durationMs: Date.now() - proposeStart,
+        usage: proposeResult.usage,
+        model: modelA
+      });
+      totalUsage = this.addUsage(totalUsage, proposeResult.usage);
+      if (i < iterations - 1) {
+        const critiqueStart = Date.now();
+        const criticPrompt = `${config.systemPrompts?.critic || DEFAULT_SYSTEM_PROMPTS.critic}
+
+Original problem: ${prompt}
+
+Solution to review:
+${currentSolution}
+
+Provide detailed feedback and suggestions for improvement.`;
+        const critiqueResult = await this.generateText(modelB, criticPrompt);
+        critique = critiqueResult.text;
+        steps.push({
+          agent: "B (Critic)",
+          role: "critic",
+          action: `Critique solution (iteration ${i + 1})`,
+          input: currentSolution,
+          output: critique,
+          timestamp: Date.now(),
+          durationMs: Date.now() - critiqueStart,
+          usage: critiqueResult.usage,
+          model: modelB
+        });
+        totalUsage = this.addUsage(totalUsage, critiqueResult.usage);
+      }
+    }
+    let validation;
+    if (config.validateCode && this.validateCode) {
+      const code = extractPrimaryCode(currentSolution);
+      if (code) {
+        const validResult = await this.validateCode(code);
+        validation = {
+          valid: validResult.valid,
+          errors: validResult.errors,
+          finalCode: validResult.fixedCode || code
+        };
+      }
+    }
+    return {
+      text: currentSolution,
+      reasoning: critique,
+      intermediateSteps: steps,
+      usage: totalUsage,
+      metadata: this.buildMetadata(config, steps, startTime, [modelA, modelB]),
+      validation
+    };
+  }
+  /**
+   * Debate workflow.
+   */
+  async runDebate(prompt, config, startTime) {
+    const steps = [];
+    let totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    const modelA = config.modelA || "kimi-k2.5";
+    const modelB = config.modelB || "kimi-k2.5";
+    const iterations = config.iterations || 2;
+    let positionA = "";
+    let positionB = "";
+    const initialPrompt = `Problem: ${prompt}
+
+Provide your solution and reasoning.`;
+    const aStart = Date.now();
+    const aResult = await this.generateText(modelA, initialPrompt);
+    positionA = aResult.text;
+    steps.push({
+      agent: "A",
+      role: "proposer",
+      action: "Initial position",
+      input: prompt,
+      output: positionA,
+      timestamp: Date.now(),
+      durationMs: Date.now() - aStart,
+      usage: aResult.usage,
+      model: modelA
+    });
+    totalUsage = this.addUsage(totalUsage, aResult.usage);
+    const bStart = Date.now();
+    const bResult = await this.generateText(modelB, initialPrompt);
+    positionB = bResult.text;
+    steps.push({
+      agent: "B",
+      role: "proposer",
+      action: "Initial position",
+      input: prompt,
+      output: positionB,
+      timestamp: Date.now(),
+      durationMs: Date.now() - bStart,
+      usage: bResult.usage,
+      model: modelB
+    });
+    totalUsage = this.addUsage(totalUsage, bResult.usage);
+    for (let i = 0; i < iterations - 1; i++) {
+      const aDebateStart = Date.now();
+      const aDebatePrompt = `Problem: ${prompt}
+
+Your previous position:
+${positionA}
+
+Other perspective:
+${positionB}
+
+Consider the other perspective. Either defend your position with additional reasoning, or revise it based on valid points. Provide your updated solution.`;
+      const aDebateResult = await this.generateText(modelA, aDebatePrompt);
+      positionA = aDebateResult.text;
+      steps.push({
+        agent: "A",
+        role: "proposer",
+        action: `Debate round ${i + 1}`,
+        input: positionB,
+        output: positionA,
+        timestamp: Date.now(),
+        durationMs: Date.now() - aDebateStart,
+        usage: aDebateResult.usage,
+        model: modelA
+      });
+      totalUsage = this.addUsage(totalUsage, aDebateResult.usage);
+      const bDebateStart = Date.now();
+      const bDebatePrompt = `Problem: ${prompt}
+
+Your previous position:
+${positionB}
+
+Other perspective:
+${positionA}
+
+Consider the other perspective. Either defend your position with additional reasoning, or revise it based on valid points. Provide your updated solution.`;
+      const bDebateResult = await this.generateText(modelB, bDebatePrompt);
+      positionB = bDebateResult.text;
+      steps.push({
+        agent: "B",
+        role: "proposer",
+        action: `Debate round ${i + 1}`,
+        input: positionA,
+        output: positionB,
+        timestamp: Date.now(),
+        durationMs: Date.now() - bDebateStart,
+        usage: bDebateResult.usage,
+        model: modelB
+      });
+      totalUsage = this.addUsage(totalUsage, bDebateResult.usage);
+    }
+    const finalText = positionA.length > positionB.length ? positionA : positionB;
+    return {
+      text: finalText,
+      reasoning: `Debate synthesis from ${iterations} rounds`,
+      intermediateSteps: steps,
+      usage: totalUsage,
+      metadata: this.buildMetadata(config, steps, startTime, [modelA, modelB])
+    };
+  }
+  /**
+   * Custom workflow.
+   */
+  async runCustom(prompt, config, startTime) {
+    const steps = [];
+    const modelA = config.modelA || "kimi-k2.5";
+    const modelB = config.modelB || "kimi-k2.5";
+    const context = {
+      generateWithModelA: (p) => this.generateText(modelA, p),
+      generateWithModelB: (p) => this.generateText(modelB, p),
+      validateCode: this.validateCode,
+      config,
+      addStep: (step) => {
+        steps.push({
+          ...step,
+          timestamp: Date.now(),
+          durationMs: 0
+        });
+      }
+    };
+    const result = await config.customWorkflow(prompt, context);
+    if (result.intermediateSteps.length === 0 && steps.length > 0) {
+      result.intermediateSteps = steps;
+    }
+    result.metadata.durationMs = Date.now() - startTime;
+    return result;
+  }
+  /**
+   * Build metadata for result.
+   */
+  buildMetadata(config, steps, startTime, models) {
+    return {
+      workflow: config.workflow,
+      iterations: steps.length,
+      durationMs: Date.now() - startTime,
+      models: [...new Set(models)],
+      validationEnabled: config.validateCode ?? false,
+      success: true
+    };
+  }
+  /**
+   * Add usage stats.
+   */
+  addUsage(a, b) {
+    if (!b) {
+      return a;
+    }
+    return {
+      promptTokens: a.promptTokens + b.promptTokens,
+      completionTokens: a.completionTokens + b.completionTokens,
+      totalTokens: a.totalTokens + b.totalTokens
+    };
+  }
+};
+function createEmptyMultiAgentResult(workflow, error) {
+  return {
+    text: "",
+    intermediateSteps: [],
+    usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+    metadata: {
+      workflow,
+      iterations: 0,
+      durationMs: 0,
+      models: [],
+      validationEnabled: false,
+      success: false,
+      error
+    }
+  };
+}
+
+// src/project-tools/scaffolder.ts
+var ProjectScaffolder = class {
+  constructor(options) {
+    this.generateText = options.generateText;
+  }
+  /**
+   * Scaffold a new project based on a description.
+   *
+   * @param description - Description of the project to create
+   * @param config - Scaffold configuration
+   * @returns Scaffold result with files and instructions
+   */
+  async scaffold(description, config = {}) {
+    const {
+      type = "auto",
+      includeTests = true,
+      includeCI = false,
+      includeDocs = true,
+      includeDocker = false,
+      includeLinting = true,
+      outputFormat = "files",
+      useTypeScript = true,
+      features = [],
+      customTemplate
+    } = config;
+    const prompt = this.buildScaffoldPrompt(description, {
+      type,
+      includeTests,
+      includeCI,
+      includeDocs,
+      includeDocker,
+      includeLinting,
+      useTypeScript,
+      features,
+      customTemplate
+    });
+    const result = await this.generateText(prompt);
+    const parsed = this.parseResponse(result.text, type);
+    return this.formatResult(parsed, outputFormat, result.text);
+  }
+  /**
+   * Build the scaffold prompt.
+   */
+  buildScaffoldPrompt(description, config) {
+    const parts = [];
+    parts.push("Generate a complete project structure for the following description:");
+    parts.push(`"${description}"`);
+    parts.push("");
+    if (config.type !== "auto") {
+      parts.push(`Framework/Type: ${config.type}`);
+    }
+    parts.push(`Language: ${config.useTypeScript ? "TypeScript" : "JavaScript/Python/Go (as appropriate)"}`);
+    const includes = [];
+    if (config.includeTests) {
+      includes.push("comprehensive test files");
+    }
+    if (config.includeCI) {
+      includes.push("GitHub Actions CI/CD workflow");
+    }
+    if (config.includeDocs) {
+      includes.push("README with setup instructions");
+    }
+    if (config.includeDocker) {
+      includes.push("Dockerfile and docker-compose.yml");
+    }
+    if (config.includeLinting) {
+      includes.push("ESLint/linting configuration");
+    }
+    if (includes.length > 0) {
+      parts.push(`Include: ${includes.join(", ")}`);
+    }
+    if (config.features.length > 0) {
+      parts.push(`Additional features: ${config.features.join(", ")}`);
+    }
+    if (config.customTemplate) {
+      parts.push("");
+      parts.push("Custom requirements:");
+      parts.push(config.customTemplate);
+    }
+    parts.push("");
+    parts.push("Respond with a JSON object in this exact format:");
+    parts.push("```json");
+    parts.push("{");
+    parts.push('  "projectName": "project-name",');
+    parts.push('  "projectType": "detected-type",');
+    parts.push('  "technologies": ["tech1", "tech2"],');
+    parts.push('  "files": [');
+    parts.push("    {");
+    parts.push('      "path": "relative/path/to/file.ts",');
+    parts.push('      "content": "full file content here",');
+    parts.push('      "description": "what this file does"');
+    parts.push("    }");
+    parts.push("  ],");
+    parts.push('  "setupCommands": ["npm install", "npm run dev"],');
+    parts.push('  "estimatedSetupTime": "5 minutes"');
+    parts.push("}");
+    parts.push("```");
+    parts.push("");
+    parts.push(
+      "Include ALL necessary files for a working project: package.json/requirements.txt, source files, config files, etc."
+    );
+    parts.push("Make sure file contents are complete and functional, not placeholders.");
+    return parts.join("\n");
+  }
+  /**
+   * Parse the model response into structured data.
+   */
+  parseResponse(text, defaultType) {
+    const jsonMatch = text.match(/```json\n?([\s\S]*?)```/) || text.match(/\{[\s\S]*"files"[\s\S]*\}/);
+    if (jsonMatch) {
+      try {
+        const json = JSON.parse(jsonMatch[1] || jsonMatch[0]);
+        const files = (json.files || []).map((f) => {
+          return {
+            path: f.path,
+            content: f.content,
+            description: f.description
+          };
+        });
+        let projectType;
+        if (json.projectType) {
+          projectType = json.projectType;
+        } else if (defaultType === "auto") {
+          projectType = this.detectProjectType(files);
+        } else {
+          projectType = defaultType;
+        }
+        return {
+          files,
+          metadata: {
+            projectType,
+            projectName: json.projectName || "my-project",
+            fileCount: files.length,
+            totalSize: files.reduce((sum, f) => sum + (f.content?.length || 0), 0),
+            estimatedSetupTime: json.estimatedSetupTime || "unknown",
+            technologies: json.technologies || [],
+            features: []
+          },
+          setupCommands: json.setupCommands || []
+        };
+      } catch {
+      }
+    }
+    return this.parseFromCodeBlocks(text, defaultType);
+  }
+  /**
+   * Parse files from markdown code blocks.
+   */
+  parseFromCodeBlocks(text, defaultType) {
+    const files = [];
+    const fileBlockRegex = /```(?:(\w+):)?([\w./-]+)\n([\s\S]*?)```/g;
+    let match = fileBlockRegex.exec(text);
+    while (match !== null) {
+      const path = match[2];
+      const content = match[3].trim();
+      if (path.includes(".")) {
+        files.push({
+          path,
+          content,
+          description: void 0
+        });
+      }
+      match = fileBlockRegex.exec(text);
+    }
+    if (files.length === 0) {
+      const genericBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
+      let blockMatch = genericBlockRegex.exec(text);
+      let index = 0;
+      while (blockMatch !== null) {
+        const lang = blockMatch[1] || "txt";
+        const content = blockMatch[2].trim();
+        if (content.length > 10) {
+          const ext = this.getExtensionForLanguage(lang);
+          files.push({
+            path: `file${index}.${ext}`,
+            content
+          });
+          index++;
+        }
+        blockMatch = genericBlockRegex.exec(text);
+      }
+    }
+    return {
+      files,
+      metadata: {
+        projectType: defaultType === "auto" ? this.detectProjectType(files) : defaultType,
+        projectName: "my-project",
+        fileCount: files.length,
+        totalSize: files.reduce((sum, f) => sum + f.content.length, 0),
+        estimatedSetupTime: "unknown",
+        technologies: [],
+        features: []
+      },
+      setupCommands: []
+    };
+  }
+  /**
+   * Detect project type from files.
+   */
+  detectProjectType(files) {
+    const paths = files.map((f) => f.path.toLowerCase());
+    const contents = files.map((f) => f.content);
+    if (paths.some((p) => p.includes("next.config"))) {
+      return "nextjs";
+    }
+    if (contents.some((c) => c.includes("from fastapi"))) {
+      return "fastapi";
+    }
+    if (contents.some((c) => c.includes("from flask"))) {
+      return "flask";
+    }
+    if (paths.some((p) => p.includes("package.json"))) {
+      const pkgFile = files.find((f) => f.path.includes("package.json"));
+      if (pkgFile) {
+        if (pkgFile.content.includes('"react"')) {
+          return "react";
+        }
+        if (pkgFile.content.includes('"vue"')) {
+          return "vue";
+        }
+        if (pkgFile.content.includes('"express"')) {
+          return "express";
+        }
+        if (pkgFile.content.includes('"fastify"')) {
+          return "fastify";
+        }
+      }
+      return "node";
+    }
+    if (paths.some((p) => p.includes("requirements.txt") || p.endsWith(".py"))) {
+      return "python";
+    }
+    if (paths.some((p) => p.includes("go.mod") || p.endsWith(".go"))) {
+      return "go";
+    }
+    if (paths.some((p) => p.includes("cargo.toml") || p.endsWith(".rs"))) {
+      return "rust";
+    }
+    return "node";
+  }
+  /**
+   * Get file extension for a language.
+   */
+  getExtensionForLanguage(lang) {
+    const map = {
+      typescript: "ts",
+      javascript: "js",
+      python: "py",
+      go: "go",
+      rust: "rs",
+      json: "json",
+      yaml: "yml",
+      markdown: "md",
+      html: "html",
+      css: "css",
+      shell: "sh",
+      bash: "sh",
+      dockerfile: "dockerfile",
+      sql: "sql"
+    };
+    return map[lang.toLowerCase()] || "txt";
+  }
+  /**
+   * Format the result based on output format.
+   */
+  formatResult(parsed, format, rawResponse) {
+    const instructions = this.generateInstructions(parsed);
+    return {
+      files: format === "instructions" ? [] : parsed.files,
+      instructions,
+      setupCommands: parsed.setupCommands,
+      metadata: parsed.metadata,
+      rawResponse: format === "json" ? rawResponse : void 0
+    };
+  }
+  /**
+   * Generate setup instructions.
+   */
+  generateInstructions(parsed) {
+    const lines = [];
+    lines.push(`# ${parsed.metadata.projectName} Setup`);
+    lines.push("");
+    lines.push(`Project type: ${parsed.metadata.projectType}`);
+    lines.push(`Files: ${parsed.metadata.fileCount}`);
+    lines.push("");
+    if (parsed.metadata.technologies.length > 0) {
+      lines.push("## Technologies");
+      lines.push(parsed.metadata.technologies.map((t) => `- ${t}`).join("\n"));
+      lines.push("");
+    }
+    lines.push("## Quick Start");
+    lines.push("");
+    lines.push("1. Create project directory:");
+    lines.push("```bash");
+    lines.push(`mkdir ${parsed.metadata.projectName}`);
+    lines.push(`cd ${parsed.metadata.projectName}`);
+    lines.push("```");
+    lines.push("");
+    lines.push("2. Create the following files:");
+    for (const file of parsed.files.slice(0, 10)) {
+      lines.push(`   - \`${file.path}\`${file.description ? `: ${file.description}` : ""}`);
+    }
+    if (parsed.files.length > 10) {
+      lines.push(`   - ... and ${parsed.files.length - 10} more files`);
+    }
+    lines.push("");
+    if (parsed.setupCommands.length > 0) {
+      lines.push("3. Run setup commands:");
+      lines.push("```bash");
+      lines.push(parsed.setupCommands.join("\n"));
+      lines.push("```");
+      lines.push("");
+    }
+    if (parsed.metadata.estimatedSetupTime !== "unknown") {
+      lines.push(`Estimated setup time: ${parsed.metadata.estimatedSetupTime}`);
+    }
+    return lines.join("\n");
+  }
+};
+function createEmptyScaffoldResult(error) {
+  return {
+    files: [],
+    instructions: `Error: ${error}`,
+    setupCommands: [],
+    metadata: {
+      projectType: "auto",
+      projectName: "unknown",
+      fileCount: 0,
+      totalSize: 0,
+      estimatedSetupTime: "unknown",
+      technologies: [],
+      features: []
+    }
+  };
+}
+
 // src/version.ts
-var VERSION = "0.4.0".length > 0 ? "0.4.0" : "0.0.0";
+var VERSION = "0.5.0".length > 0 ? "0.5.0" : "0.0.0";
 
 // src/kimi-provider.ts
 var GLOBAL_BASE_URL = "https://api.moonshot.ai/v1";
@@ -2078,6 +3897,82 @@ function createKimi(options = {}) {
   provider.rerankingModel = (modelId) => {
     throw new NoSuchModelError({ modelId, modelType: "rerankingModel" });
   };
+  provider.ensemble = async (prompt, generateFn, ensembleOptions = {}) => {
+    const { model = "kimi-k2.5", baseTemperature = 0.7, ...config } = ensembleOptions;
+    const sampler = new MultiSampler({
+      modelId: model,
+      baseTemperature
+    });
+    const wrappedGenerateFn = async (options2) => {
+      const languageModel = createChatModel(model, {});
+      const result = await generateFn(languageModel, prompt, { temperature: options2.temperature });
+      return {
+        text: result.text,
+        reasoning: result.reasoning,
+        toolCalls: result.toolCalls,
+        toolResults: result.toolResults,
+        usage: result.usage,
+        finishReason: result.finishReason ?? "stop"
+      };
+    };
+    return sampler.generate(wrappedGenerateFn, {
+      n: config.n ?? 3,
+      selectionStrategy: config.selectionStrategy ?? "best",
+      temperatureVariance: config.temperatureVariance ?? 0.1,
+      scoringHeuristic: config.scoringHeuristic ?? "confidence",
+      customScorer: config.customScorer,
+      timeoutMs: config.timeoutMs ?? 6e4,
+      allowPartialFailure: config.allowPartialFailure ?? true,
+      minSuccessfulSamples: config.minSuccessfulSamples ?? 1
+    });
+  };
+  provider.multiAgent = async (prompt, generateFn, agentOptions = {}) => {
+    const { modelSettings, ...config } = agentOptions;
+    const runner = new WorkflowRunner(generateFn);
+    return runner.run(prompt, {
+      workflow: config.workflow ?? "planner-executor",
+      modelA: config.modelA ?? "kimi-k2.5-thinking",
+      modelB: config.modelB ?? "kimi-k2.5",
+      iterations: config.iterations ?? 2,
+      validateCode: config.validateCode ?? false,
+      timeoutMs: config.timeoutMs ?? 12e4,
+      customWorkflow: config.customWorkflow,
+      verbose: config.verbose ?? false,
+      systemPrompts: config.systemPrompts
+    });
+  };
+  provider.validateCode = async (code, generateFn, validateOptions = {}) => {
+    const { model = "kimi-k2.5", modelSettings, ...config } = validateOptions;
+    const languageModel = createChatModel(model, modelSettings);
+    const llmGenerateFn = generateFn ? async (prompt) => generateFn(languageModel, prompt) : async (_prompt) => {
+      return { text: "" };
+    };
+    const validator = new CodeValidator({
+      generateText: llmGenerateFn
+    });
+    return validator.validate(code, {
+      enabled: true,
+      maxAttempts: config.maxAttempts ?? 3,
+      language: config.language ?? "auto",
+      strictness: config.strictness ?? "strict",
+      executionTimeoutMs: config.executionTimeoutMs ?? 3e4,
+      includeTests: config.includeTests ?? true,
+      returnPartialFix: config.returnPartialFix ?? true
+    });
+  };
+  provider.scaffoldProject = async (description, generateFn, scaffoldOptions = {}) => {
+    const scaffolder = new ProjectScaffolder({
+      generateText: generateFn
+    });
+    return scaffolder.scaffold(description, scaffoldOptions);
+  };
+  provider.detectTools = (prompt) => {
+    const result = detectToolsFromPrompt(prompt);
+    return {
+      webSearch: result.webSearch,
+      codeInterpreter: result.codeInterpreter
+    };
+  };
   return provider;
 }
 var kimi = createKimi();
@@ -2923,6 +4818,8 @@ function createKimiCode(options = {}) {
 }
 var kimiCode = createKimiCode();
 export {
+  CodeValidator,
+  DEFAULT_SYSTEM_PROMPTS,
   KIMI_CODE_BASE_URL,
   KIMI_CODE_DEFAULT_MODEL,
   KIMI_CODE_INTERPRETER_TOOL_NAME,
@@ -2931,22 +4828,43 @@ export {
   KimiAuthenticationError,
   KimiChatLanguageModel,
   KimiCodeLanguageModel,
+  KimiCodeValidationError,
   KimiContentFilterError,
   KimiContextLengthError,
+  KimiEnsembleTimeoutError,
+  KimiEnsembleValidationError,
   KimiError,
   KimiFileClient,
   KimiModelNotFoundError,
+  KimiMultiAgentError,
   KimiRateLimitError,
+  KimiScaffoldError,
   KimiValidationError,
+  MultiSampler,
+  ProjectScaffolder,
   SUPPORTED_FILE_EXTENSIONS,
   SUPPORTED_MIME_TYPES,
+  WorkflowRunner,
+  containsCode,
   createCodeInterpreterTool,
+  createEmptyMultiAgentResult,
+  createEmptyScaffoldResult,
+  createFailedValidationResult,
   createKimi,
   createKimiCode,
   createKimiWebSearchTool,
+  createPassedValidationResult,
+  createSingletonEnsembleResult,
   createWebSearchTool,
+  detectLanguage,
+  detectToolsFromPrompt,
+  extractCodeBlocks,
+  extractPrimaryCode,
+  generateToolGuidanceMessage,
+  getFileExtension,
   getMediaTypeFromExtension,
   getPurposeFromMediaType,
+  hasToolOptOut,
   inferKimiCodeCapabilities,
   inferModelCapabilities,
   isDocumentMediaType,
@@ -2959,6 +4877,7 @@ export {
   kimiCodeProviderOptionsSchema,
   kimiProviderOptionsSchema,
   kimiTools,
-  processAttachments
+  processAttachments,
+  shouldAutoEnableTools
 };
 //# sourceMappingURL=index.mjs.map