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

package/dist/index.d.ts

@@ -1,7 +1,1238 @@
-import { LanguageModelV3, LanguageModelV3Usage, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult, ProviderV3 } from '@ai-sdk/provider';
+import { LanguageModelV3ToolCall, LanguageModelV3ToolResult, LanguageModelV3, LanguageModelV3Usage, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult, ProviderV3 } from '@ai-sdk/provider';
 import { FetchFunction } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
+/**
+ * Types for code validation functionality.
+ * @module
+ */
+/**
+ * Supported programming languages for code validation.
+ */
+type SupportedLanguage = 'javascript' | 'typescript' | 'python' | 'java' | 'cpp' | 'go' | 'rust' | 'ruby' | 'php' | 'auto';
+/**
+ * Validation strictness levels.
+ */
+type ValidationStrictness = 'lenient' | 'strict' | 'maximum';
+/**
+ * Configuration for code validation.
+ */
+interface CodeValidationConfig {
+    /**
+     * Enable automatic code validation.
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * Maximum number of attempts to fix errors.
+     * @default 3
+     */
+    maxAttempts?: number;
+    /**
+     * Language to validate (auto-detected if not specified).
+     * @default 'auto'
+     */
+    language?: SupportedLanguage;
+    /**
+     * Timeout for each code execution attempt (ms).
+     * @default 30000
+     */
+    executionTimeoutMs?: number;
+    /**
+     * Whether to include test cases in validation.
+     * If true, the provider will look for test patterns in the prompt.
+     * @default true
+     */
+    includeTests?: boolean;
+    /**
+     * Validation strictness.
+     * - 'lenient': Check for runtime errors only
+     * - 'strict': Check syntax + runtime + style
+     * - 'maximum': Also verify output correctness
+     * @default 'strict'
+     */
+    strictness?: ValidationStrictness;
+    /**
+     * Custom validation function for specialized needs.
+     */
+    customValidator?: (code: string, language: string) => Promise<ValidationResult>;
+    /**
+     * Whether to return the fixed code even if validation fails.
+     * @default true
+     */
+    returnPartialFix?: boolean;
+}
+/**
+ * Types of validation errors.
+ */
+type ValidationErrorType = 'syntax' | 'runtime' | 'timeout' | 'test' | 'style' | 'logic';
+/**
+ * Severity of validation errors.
+ */
+type ValidationSeverity = 'error' | 'warning' | 'info';
+/**
+ * A single validation error.
+ */
+interface ValidationError {
+    /**
+     * Type of the error.
+     */
+    type: ValidationErrorType;
+    /**
+     * Error message.
+     */
+    message: string;
+    /**
+     * Line number where the error occurred (1-indexed).
+     */
+    line?: number;
+    /**
+     * Column number where the error occurred (1-indexed).
+     */
+    column?: number;
+    /**
+     * Severity of the error.
+     */
+    severity: ValidationSeverity;
+    /**
+     * The problematic code snippet.
+     */
+    snippet?: string;
+    /**
+     * Suggested fix (if available).
+     */
+    suggestion?: string;
+}
+/**
+ * Result of validating and potentially fixing code.
+ */
+interface ValidationResult {
+    /**
+     * Whether the final code is valid.
+     */
+    valid: boolean;
+    /**
+     * All errors encountered during validation.
+     */
+    errors: ValidationError[];
+    /**
+     * Warnings that don't prevent execution.
+     */
+    warnings: ValidationError[];
+    /**
+     * Output from successful execution (if any).
+     */
+    output?: string;
+    /**
+     * Time taken for execution (ms).
+     */
+    executionTimeMs?: number;
+    /**
+     * Number of validation/fix attempts made.
+     */
+    attempts: number;
+    /**
+     * The final code after any fixes.
+     */
+    finalCode: string;
+    /**
+     * The original code before any fixes.
+     */
+    originalCode: string;
+    /**
+     * Language that was detected/used.
+     */
+    language: string;
+    /**
+     * History of code changes during fix attempts.
+     */
+    fixHistory?: FixAttempt[];
+}
+/**
+ * A single fix attempt.
+ */
+interface FixAttempt {
+    /**
+     * Attempt number (1-indexed).
+     */
+    attempt: number;
+    /**
+     * The code before this fix.
+     */
+    codeBefore: string;
+    /**
+     * The code after this fix.
+     */
+    codeAfter: string;
+    /**
+     * Errors that were addressed.
+     */
+    errorsAddressed: ValidationError[];
+    /**
+     * Whether this fix resolved all errors.
+     */
+    success: boolean;
+}
+/**
+ * Result of language detection.
+ */
+interface LanguageDetectionResult {
+    /**
+     * Detected language.
+     */
+    language: SupportedLanguage;
+    /**
+     * Confidence score (0-1).
+     */
+    confidence: number;
+    /**
+     * Indicators that led to this detection.
+     */
+    indicators: string[];
+}
+/**
+ * Result of code extraction from text.
+ */
+interface CodeExtractionResult {
+    /**
+     * Extracted code blocks.
+     */
+    blocks: CodeBlock[];
+    /**
+     * Whether any code was found.
+     */
+    hasCode: boolean;
+}
+/**
+ * A code block extracted from text.
+ */
+interface CodeBlock {
+    /**
+     * The code content.
+     */
+    code: string;
+    /**
+     * Language annotation (if provided).
+     */
+    language?: string;
+    /**
+     * Start position in the original text.
+     */
+    startIndex: number;
+    /**
+     * End position in the original text.
+     */
+    endIndex: number;
+}
+
+/**
+ * Code validator implementation.
+ * @module
+ */
+
+/**
+ * Function to generate text from a model.
+ */
+type GenerateTextFunction$2 = (prompt: string) => Promise<{
+    text: string;
+    toolCalls?: unknown[];
+    toolResults?: unknown[];
+}>;
+/**
+ * Options for creating a code validator.
+ */
+interface CodeValidatorOptions {
+    /**
+     * Function to generate text (for fix attempts).
+     */
+    generateText: GenerateTextFunction$2;
+    /**
+     * Function to execute code using the code interpreter.
+     * Should return output or throw on error.
+     */
+    executeCode?: (code: string, language: string) => Promise<string>;
+}
+/**
+ * Validates code and attempts to fix errors automatically.
+ *
+ * @example
+ * ```ts
+ * const validator = new CodeValidator({
+ *   generateText: async (prompt) => {
+ *     const result = await generateText({ model, prompt });
+ *     return { text: result.text };
+ *   },
+ * });
+ *
+ * const result = await validator.validate(code, {
+ *   enabled: true,
+ *   maxAttempts: 3,
+ *   language: 'javascript',
+ * });
+ * ```
+ */
+declare class CodeValidator {
+    private generateText;
+    private executeCode?;
+    constructor(options: CodeValidatorOptions);
+    /**
+     * 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
+     */
+    validate(code: string, config: CodeValidationConfig, originalPrompt?: string): Promise<ValidationResult>;
+    /**
+     * Validate code without attempting fixes.
+     */
+    private validateCode;
+    /**
+     * Perform static analysis on code.
+     */
+    private performStaticAnalysis;
+    /**
+     * Analyze JavaScript/TypeScript code.
+     */
+    private analyzeJavaScript;
+    /**
+     * Analyze Python code.
+     */
+    private analyzePython;
+    /**
+     * Generic code analysis.
+     */
+    private analyzeGeneric;
+    /**
+     * Check bracket balance in code.
+     */
+    private checkBracketBalance;
+    /**
+     * Detect runtime errors from execution output.
+     */
+    private detectRuntimeErrors;
+    /**
+     * Use LLM to validate code.
+     */
+    private validateWithLLM;
+    /**
+     * Attempt to fix errors in code.
+     */
+    private attemptFix;
+}
+/**
+ * Create a simple validation result for code that passed without issues.
+ */
+declare function createPassedValidationResult(code: string, language: string, output?: string): ValidationResult;
+/**
+ * Create a validation result for code that failed.
+ */
+declare function createFailedValidationResult(code: string, language: string, errors: ValidationError[]): ValidationResult;
+
+/**
+ * Language detection and code extraction utilities.
+ * @module
+ */
+
+/**
+ * Detect the programming language of a code snippet.
+ *
+ * @param code - The code to analyze
+ * @returns Detection result with language, confidence, and indicators
+ */
+declare function detectLanguage(code: string): LanguageDetectionResult;
+/**
+ * Extract code blocks from text (including markdown code fences).
+ *
+ * @param text - Text that may contain code blocks
+ * @returns Extraction result with code blocks
+ */
+declare function extractCodeBlocks(text: string): CodeExtractionResult;
+/**
+ * Extract the primary code block from text.
+ * Returns the largest/most significant code block.
+ *
+ * @param text - Text that may contain code blocks
+ * @returns The primary code or undefined if no code found
+ */
+declare function extractPrimaryCode(text: string): string | undefined;
+/**
+ * Check if text contains code.
+ *
+ * @param text - Text to check
+ * @returns True if text contains code
+ */
+declare function containsCode(text: string): boolean;
+/**
+ * Get file extension for a language.
+ *
+ * @param language - The programming language
+ * @returns File extension (without dot)
+ */
+declare function getFileExtension(language: SupportedLanguage): string;
+
+/**
+ * Types for ensemble/multi-sampling functionality.
+ * @module
+ */
+
+/**
+ * Simple usage type compatible with common AI SDK patterns.
+ * This is independent from the provider-specific V3Usage type.
+ */
+interface LanguageModelUsage$1 {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+/**
+ * Re-export types for convenience.
+ */
+type ToolCall = LanguageModelV3ToolCall;
+type ToolResult = LanguageModelV3ToolResult;
+/**
+ * Selection strategy for choosing the best response from multiple samples.
+ */
+type SelectionStrategy = 'first' | 'vote' | 'best' | 'all';
+/**
+ * Scoring heuristic for the 'best' selection strategy.
+ */
+type ScoringHeuristic = 'length' | 'confidence' | 'code' | 'custom';
+/**
+ * Configuration for ensemble/multi-sampling.
+ */
+interface EnsembleConfig {
+    /**
+     * Number of parallel samples to generate.
+     * @default 3
+     */
+    n: number;
+    /**
+     * Strategy for selecting the best result.
+     * - 'first': Return the first successful response
+     * - 'vote': Return the most common answer (majority voting)
+     * - 'best': Use heuristic scoring to pick the best
+     * - 'all': Return all responses (for manual selection)
+     * @default 'best'
+     */
+    selectionStrategy?: SelectionStrategy;
+    /**
+     * Temperature variation for diversity.
+     * Each sample gets temperature = baseTemp + (i * variance)
+     * @default 0.1
+     */
+    temperatureVariance?: number;
+    /**
+     * For 'best' strategy, the scoring heuristic.
+     * - 'length': Prefer shorter responses
+     * - 'confidence': Prefer responses with higher token count
+     * - 'code': Prefer responses with fewer error patterns
+     * - 'custom': Use custom scorer function
+     * @default 'confidence'
+     */
+    scoringHeuristic?: ScoringHeuristic;
+    /**
+     * Custom scoring function for 'custom' heuristic.
+     * Higher scores are better.
+     */
+    customScorer?: (response: EnsembleResponse) => number;
+    /**
+     * Maximum time to wait for all samples (ms).
+     * @default 60000
+     */
+    timeoutMs?: number;
+    /**
+     * Whether to continue if some samples fail.
+     * @default true
+     */
+    allowPartialFailure?: boolean;
+    /**
+     * Minimum number of successful samples required.
+     * Only relevant when allowPartialFailure is true.
+     * @default 1
+     */
+    minSuccessfulSamples?: number;
+}
+/**
+ * A single response from the ensemble.
+ */
+interface EnsembleResponse {
+    /**
+     * The generated text.
+     */
+    text: string;
+    /**
+     * Reasoning content (for thinking models).
+     */
+    reasoning?: string;
+    /**
+     * Tool calls made during generation.
+     */
+    toolCalls?: ToolCall[];
+    /**
+     * Results of tool executions.
+     */
+    toolResults?: ToolResult[];
+    /**
+     * Token usage for this response.
+     */
+    usage?: LanguageModelUsage$1;
+    /**
+     * Score assigned to this response (if scoring was applied).
+     */
+    score?: number;
+    /**
+     * Index of this sample in the ensemble.
+     */
+    sampleIndex: number;
+    /**
+     * Temperature used for this sample.
+     */
+    temperature: number;
+    /**
+     * Reason the generation finished.
+     */
+    finishReason: string;
+    /**
+     * Whether this sample completed successfully.
+     */
+    success: boolean;
+    /**
+     * Error message if the sample failed.
+     */
+    error?: string;
+    /**
+     * Time taken to generate this response (ms).
+     */
+    durationMs?: number;
+}
+/**
+ * Metadata about the ensemble execution.
+ */
+interface EnsembleMetadata {
+    /**
+     * Number of samples requested.
+     */
+    nRequested: number;
+    /**
+     * Number of samples that completed successfully.
+     */
+    nCompleted: number;
+    /**
+     * Number of samples that failed.
+     */
+    nFailed: number;
+    /**
+     * Selection strategy used.
+     */
+    selectionStrategy: SelectionStrategy;
+    /**
+     * Index of the winning sample.
+     */
+    winningIndex: number;
+    /**
+     * Scores of all samples (if scoring was applied).
+     */
+    scores?: number[];
+    /**
+     * Total time for ensemble execution (ms).
+     */
+    durationMs: number;
+    /**
+     * Model ID used.
+     */
+    modelId: string;
+    /**
+     * Aggregated token usage across all samples.
+     */
+    totalUsage: LanguageModelUsage$1;
+}
+/**
+ * Result of an ensemble generation.
+ */
+interface EnsembleResult {
+    /**
+     * The selected best response text.
+     */
+    text: string;
+    /**
+     * Reasoning content from the best response.
+     */
+    reasoning?: string;
+    /**
+     * Tool calls from the best response.
+     */
+    toolCalls?: ToolCall[];
+    /**
+     * Tool results from the best response.
+     */
+    toolResults?: ToolResult[];
+    /**
+     * Token usage from the best response.
+     */
+    usage: LanguageModelUsage$1;
+    /**
+     * All generated responses (populated for 'all' strategy).
+     */
+    alternatives?: EnsembleResponse[];
+    /**
+     * Metadata about the ensemble execution.
+     */
+    metadata: EnsembleMetadata;
+}
+
+/**
+ * Multi-sampler implementation for ensemble generation.
+ * @module
+ */
+
+/**
+ * A function that generates a single response.
+ */
+type GenerateFunction = (options: {
+    temperature: number;
+    sampleIndex: number;
+}) => Promise<{
+    text: string;
+    reasoning?: string;
+    toolCalls?: unknown[];
+    toolResults?: unknown[];
+    usage?: LanguageModelUsage$1;
+    finishReason: string;
+}>;
+/**
+ * Options for creating a multi-sampler.
+ */
+interface MultiSamplerOptions {
+    /**
+     * The model ID being used.
+     */
+    modelId: string;
+    /**
+     * Base temperature for generation.
+     */
+    baseTemperature?: number;
+}
+/**
+ * Multi-sampler for generating multiple responses and selecting the best one.
+ *
+ * @example
+ * ```ts
+ * const sampler = new MultiSampler({ modelId: 'kimi-k2.5' });
+ * const result = await sampler.generate(generateFn, {
+ *   n: 3,
+ *   selectionStrategy: 'best',
+ *   scoringHeuristic: 'code',
+ * });
+ * ```
+ */
+declare class MultiSampler {
+    private modelId;
+    private baseTemperature;
+    constructor(options: MultiSamplerOptions);
+    /**
+     * Generate multiple samples and select the best one.
+     *
+     * @param generateFn - Function to generate a single response
+     * @param config - Ensemble configuration
+     * @returns The ensemble result
+     */
+    generate(generateFn: GenerateFunction, config: EnsembleConfig): Promise<EnsembleResult>;
+    /**
+     * Select the best response based on the strategy.
+     */
+    private selectBest;
+    /**
+     * Calculate score for a response based on the heuristic.
+     */
+    private calculateScore;
+    /**
+     * Score code quality based on heuristics.
+     */
+    private scoreCodeQuality;
+    /**
+     * Select the most common response (majority voting).
+     */
+    private majorityVote;
+    /**
+     * Aggregate usage across all responses.
+     */
+    private aggregateUsage;
+}
+/**
+ * Create a simple ensemble result from a single response.
+ * Useful for when ensemble is disabled but consistent return types are needed.
+ */
+declare function createSingletonEnsembleResult(response: {
+    text: string;
+    reasoning?: string;
+    toolCalls?: unknown[];
+    toolResults?: unknown[];
+    usage?: LanguageModelUsage$1;
+    finishReason: string;
+}, modelId: string, durationMs: number): EnsembleResult;
+
+/**
+ * Types for multi-agent collaboration functionality.
+ * @module
+ */
+/**
+ * Simple usage type compatible with common AI SDK patterns.
+ * This is independent from the provider-specific V3Usage type.
+ */
+interface LanguageModelUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+/**
+ * Available multi-agent workflow types.
+ */
+type WorkflowType = 'planner-executor' | 'proposer-critic' | 'debate' | 'custom';
+/**
+ * Configuration for multi-agent collaboration.
+ */
+interface MultiAgentConfig {
+    /**
+     * Multi-agent workflow type.
+     * - 'planner-executor': One agent plans, another executes
+     * - 'proposer-critic': One proposes, another critiques and refines
+     * - 'debate': Multiple agents debate and converge on answer
+     * - 'custom': Use custom workflow
+     * @default 'planner-executor'
+     */
+    workflow: WorkflowType;
+    /**
+     * Model for the first agent (typically thinking/planning).
+     * @default 'kimi-k2.5-thinking'
+     */
+    modelA?: string;
+    /**
+     * Model for the second agent (typically coding/action).
+     * @default 'kimi-k2.5'
+     */
+    modelB?: string;
+    /**
+     * Number of refinement iterations for proposer-critic.
+     * @default 2
+     */
+    iterations?: number;
+    /**
+     * Include code validation in the workflow.
+     * @default false
+     */
+    validateCode?: boolean;
+    /**
+     * Maximum time for the entire workflow (ms).
+     * @default 120000
+     */
+    timeoutMs?: number;
+    /**
+     * Custom workflow function.
+     */
+    customWorkflow?: (prompt: string, context: WorkflowContext) => Promise<MultiAgentResult>;
+    /**
+     * Enable verbose logging of intermediate steps.
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * System prompts for agents.
+     */
+    systemPrompts?: {
+        planner?: string;
+        executor?: string;
+        proposer?: string;
+        critic?: string;
+    };
+}
+/**
+ * A single step in the multi-agent workflow.
+ */
+interface AgentStep {
+    /**
+     * Agent identifier (A, B, or custom name).
+     */
+    agent: string;
+    /**
+     * Role of the agent in this step.
+     */
+    role: 'planner' | 'executor' | 'proposer' | 'critic' | 'validator' | 'custom';
+    /**
+     * Action performed.
+     */
+    action: string;
+    /**
+     * Input provided to the agent.
+     */
+    input?: string;
+    /**
+     * Output from the agent.
+     */
+    output: string;
+    /**
+     * Timestamp when this step completed.
+     */
+    timestamp: number;
+    /**
+     * Duration of this step (ms).
+     */
+    durationMs: number;
+    /**
+     * Token usage for this step.
+     */
+    usage?: LanguageModelUsage;
+    /**
+     * Model used for this step.
+     */
+    model?: string;
+}
+/**
+ * Metadata about the multi-agent execution.
+ */
+interface MultiAgentMetadata {
+    /**
+     * Workflow type used.
+     */
+    workflow: WorkflowType;
+    /**
+     * Total number of iterations/steps.
+     */
+    iterations: number;
+    /**
+     * Total duration (ms).
+     */
+    durationMs: number;
+    /**
+     * Models used in the workflow.
+     */
+    models: string[];
+    /**
+     * Whether code validation was enabled.
+     */
+    validationEnabled: boolean;
+    /**
+     * Whether the workflow completed successfully.
+     */
+    success: boolean;
+    /**
+     * Error message if workflow failed.
+     */
+    error?: string;
+}
+/**
+ * Result of a multi-agent collaboration.
+ */
+interface MultiAgentResult {
+    /**
+     * The final generated text.
+     */
+    text: string;
+    /**
+     * Reasoning/plan from the planning phase.
+     */
+    reasoning?: string;
+    /**
+     * All intermediate steps in the workflow.
+     */
+    intermediateSteps: AgentStep[];
+    /**
+     * Aggregated token usage.
+     */
+    usage: LanguageModelUsage;
+    /**
+     * Metadata about the execution.
+     */
+    metadata: MultiAgentMetadata;
+    /**
+     * Code validation result (if enabled).
+     */
+    validation?: {
+        valid: boolean;
+        errors: string[];
+        finalCode?: string;
+    };
+}
+/**
+ * Context passed to workflow functions.
+ */
+interface WorkflowContext {
+    /**
+     * Function to generate text with model A.
+     */
+    generateWithModelA: (prompt: string) => Promise<GenerateResult>;
+    /**
+     * Function to generate text with model B.
+     */
+    generateWithModelB: (prompt: string) => Promise<GenerateResult>;
+    /**
+     * Function to validate code.
+     */
+    validateCode?: (code: string) => Promise<{
+        valid: boolean;
+        errors: string[];
+        fixedCode?: string;
+    }>;
+    /**
+     * Configuration for the workflow.
+     */
+    config: MultiAgentConfig;
+    /**
+     * Add a step to the history.
+     */
+    addStep: (step: Omit<AgentStep, 'timestamp' | 'durationMs'>) => void;
+}
+/**
+ * Result of a generation call.
+ */
+interface GenerateResult {
+    text: string;
+    reasoning?: string;
+    usage?: LanguageModelUsage;
+    toolCalls?: unknown[];
+    toolResults?: unknown[];
+}
+/**
+ * Default system prompts for different agent roles.
+ */
+declare const DEFAULT_SYSTEM_PROMPTS: {
+    readonly planner: "You are a system architect and planner. Your role is to:\n1. Analyze the problem thoroughly\n2. Break it down into clear, actionable steps\n3. Consider edge cases and potential issues\n4. Provide a detailed implementation plan\n\nFormat your response as a numbered list of steps that can be followed to implement the solution.";
+    readonly executor: "You are an expert implementer. Your role is to:\n1. Follow the provided plan precisely\n2. Write clean, well-documented code\n3. Handle edge cases mentioned in the plan\n4. Ensure the implementation is complete and functional\n\nProvide only the implementation code with necessary comments.";
+    readonly proposer: "You are a solution architect. Your role is to:\n1. Analyze the problem carefully\n2. Propose a complete solution\n3. Consider best practices and patterns\n4. Write clean, maintainable code\n\nProvide your solution with explanations for key design decisions.";
+    readonly critic: "You are a code reviewer and critic. Your role is to:\n1. Review the proposed solution critically\n2. Identify any bugs, errors, or issues\n3. Suggest improvements for performance and readability\n4. Verify edge cases are handled\n\nProvide specific, actionable feedback. Be thorough but constructive.";
+};
+
+/**
+ * Multi-agent workflow implementations.
+ * @module
+ */
+
+/**
+ * Function type for generating text.
+ */
+type GenerateTextFunction$1 = (modelId: string, prompt: string, systemPrompt?: string) => Promise<GenerateResult>;
+/**
+ * Function type for validating code.
+ */
+type ValidateCodeFunction = (code: string) => Promise<{
+    valid: boolean;
+    errors: string[];
+    fixedCode?: string;
+}>;
+/**
+ * Runner for multi-agent workflows.
+ */
+declare class WorkflowRunner {
+    private generateText;
+    private validateCode?;
+    constructor(generateText: GenerateTextFunction$1, validateCode?: ValidateCodeFunction);
+    /**
+     * Run a multi-agent workflow.
+     */
+    run(prompt: string, config: MultiAgentConfig): Promise<MultiAgentResult>;
+    /**
+     * Planner-Executor workflow.
+     */
+    private runPlannerExecutor;
+    /**
+     * Proposer-Critic workflow.
+     */
+    private runProposerCritic;
+    /**
+     * Debate workflow.
+     */
+    private runDebate;
+    /**
+     * Custom workflow.
+     */
+    private runCustom;
+    /**
+     * Build metadata for result.
+     */
+    private buildMetadata;
+    /**
+     * Add usage stats.
+     */
+    private addUsage;
+}
+/**
+ * Create an empty multi-agent result.
+ */
+declare function createEmptyMultiAgentResult(workflow: MultiAgentConfig['workflow'], error: string): MultiAgentResult;
+
+/**
+ * Types for project scaffolding functionality.
+ * @module
+ */
+/**
+ * Supported project types/frameworks.
+ */
+type ProjectType = 'nextjs' | 'react' | 'vue' | 'node' | 'express' | 'fastify' | 'python' | 'fastapi' | 'flask' | 'go' | 'rust' | 'auto';
+/**
+ * Output format for scaffolded projects.
+ */
+type OutputFormat = 'files' | 'json' | 'instructions';
+/**
+ * Configuration for project scaffolding.
+ */
+interface ScaffoldConfig {
+    /**
+     * Project type/framework.
+     * @default 'auto'
+     */
+    type?: ProjectType;
+    /**
+     * Include testing setup.
+     * @default true
+     */
+    includeTests?: boolean;
+    /**
+     * Include CI/CD configuration (e.g., GitHub Actions).
+     * @default false
+     */
+    includeCI?: boolean;
+    /**
+     * Include documentation (README, API docs).
+     * @default true
+     */
+    includeDocs?: boolean;
+    /**
+     * Include Docker configuration.
+     * @default false
+     */
+    includeDocker?: boolean;
+    /**
+     * Include ESLint/Prettier configuration.
+     * @default true
+     */
+    includeLinting?: boolean;
+    /**
+     * Output format.
+     * @default 'files'
+     */
+    outputFormat?: OutputFormat;
+    /**
+     * TypeScript vs JavaScript (for applicable frameworks).
+     * @default true
+     */
+    useTypeScript?: boolean;
+    /**
+     * Additional features to include.
+     */
+    features?: string[];
+    /**
+     * Custom template or instructions to include.
+     */
+    customTemplate?: string;
+}
+/**
+ * A single file in the scaffolded project.
+ */
+interface ProjectFile {
+    /**
+     * Relative path from project root.
+     */
+    path: string;
+    /**
+     * File contents.
+     */
+    content: string;
+    /**
+     * Description of the file's purpose.
+     */
+    description?: string;
+    /**
+     * Whether this is a binary file (base64 encoded).
+     */
+    binary?: boolean;
+}
+/**
+ * Metadata about the scaffolded project.
+ */
+interface ProjectMetadata {
+    /**
+     * Detected or specified project type.
+     */
+    projectType: ProjectType;
+    /**
+     * Project name (derived from description).
+     */
+    projectName: string;
+    /**
+     * Number of files generated.
+     */
+    fileCount: number;
+    /**
+     * Total size of all files (bytes).
+     */
+    totalSize: number;
+    /**
+     * Estimated setup time.
+     */
+    estimatedSetupTime: string;
+    /**
+     * Main technologies/dependencies used.
+     */
+    technologies: string[];
+    /**
+     * Features included in the project.
+     */
+    features: string[];
+}
+/**
+ * Result of scaffolding a project.
+ */
+interface ScaffoldResult {
+    /**
+     * Generated project files.
+     */
+    files: ProjectFile[];
+    /**
+     * Setup instructions for the user.
+     */
+    instructions: string;
+    /**
+     * Commands to run for setup.
+     */
+    setupCommands: string[];
+    /**
+     * Project metadata.
+     */
+    metadata: ProjectMetadata;
+    /**
+     * Raw response from the model (for debugging).
+     */
+    rawResponse?: string;
+}
+/**
+ * A project template definition.
+ */
+interface ProjectTemplate {
+    /**
+     * Template identifier.
+     */
+    id: string;
+    /**
+     * Human-readable name.
+     */
+    name: string;
+    /**
+     * Template description.
+     */
+    description: string;
+    /**
+     * Project type this template is for.
+     */
+    projectType: ProjectType;
+    /**
+     * Base files that are always included.
+     */
+    baseFiles: ProjectFile[];
+    /**
+     * Optional files based on configuration.
+     */
+    optionalFiles?: {
+        condition: keyof ScaffoldConfig;
+        files: ProjectFile[];
+    }[];
+    /**
+     * Default setup commands.
+     */
+    setupCommands: string[];
+    /**
+     * Technologies used.
+     */
+    technologies: string[];
+}
+
+/**
+ * Project scaffolder implementation.
+ * @module
+ */
+
+/**
+ * Function type for generating text.
+ */
+type GenerateTextFunction = (prompt: string) => Promise<{
+    text: string;
+}>;
+/**
+ * Options for creating a scaffolder.
+ */
+interface ScaffolderOptions {
+    /**
+     * Function to generate text from the model.
+     */
+    generateText: GenerateTextFunction;
+    /**
+     * Default model ID to use.
+     */
+    modelId?: string;
+}
+/**
+ * Scaffolder for generating project structures.
+ *
+ * @example
+ * ```ts
+ * const scaffolder = new ProjectScaffolder({
+ *   generateText: async (prompt) => {
+ *     const result = await generateText({ model, prompt });
+ *     return { text: result.text };
+ *   },
+ * });
+ *
+ * const project = await scaffolder.scaffold(
+ *   'A REST API for todo management',
+ *   { type: 'express', includeTests: true }
+ * );
+ * ```
+ */
+declare class ProjectScaffolder {
+    private generateText;
+    constructor(options: ScaffolderOptions);
+    /**
+     * 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
+     */
+    scaffold(description: string, config?: ScaffoldConfig): Promise<ScaffoldResult>;
+    /**
+     * Build the scaffold prompt.
+     */
+    private buildScaffoldPrompt;
+    /**
+     * Parse the model response into structured data.
+     */
+    private parseResponse;
+    /**
+     * Parse files from markdown code blocks.
+     */
+    private parseFromCodeBlocks;
+    /**
+     * Detect project type from files.
+     */
+    private detectProjectType;
+    /**
+     * Get file extension for a language.
+     */
+    private getExtensionForLanguage;
+    /**
+     * Format the result based on output format.
+     */
+    private formatResult;
+    /**
+     * Generate setup instructions.
+     */
+    private generateInstructions;
+}
+/**
+ * Create an empty scaffold result.
+ */
+declare function createEmptyScaffoldResult(error: string): ScaffoldResult;
+
 /**
  * Base error class for Kimi provider errors.
  */
@@ -48,6 +1279,46 @@ declare class KimiContentFilterError extends KimiError {
 declare class KimiContextLengthError extends KimiError {
     constructor(message?: string);
 }
+/**
+ * Error thrown when ensemble configuration is invalid.
+ */
+declare class KimiEnsembleValidationError extends KimiError {
+    readonly config: unknown;
+    readonly modelId: string;
+    constructor(message: string, config: unknown, modelId: string);
+}
+/**
+ * Error thrown when ensemble generation times out.
+ */
+declare class KimiEnsembleTimeoutError extends KimiError {
+    readonly completedSamples: number;
+    readonly requestedSamples: number;
+    constructor(message: string, completedSamples: number, requestedSamples: number);
+}
+/**
+ * Error thrown when a multi-agent workflow fails.
+ */
+declare class KimiMultiAgentError extends KimiError {
+    readonly workflow: string;
+    readonly step: number;
+    readonly stepError?: Error;
+    constructor(message: string, workflow: string, step: number, stepError?: Error);
+}
+/**
+ * Error thrown when code validation fails.
+ */
+declare class KimiCodeValidationError extends KimiError {
+    readonly validationErrors: string[];
+    readonly attempts: number;
+    constructor(message: string, validationErrors: string[], attempts: number);
+}
+/**
+ * Error thrown when project scaffolding fails.
+ */
+declare class KimiScaffoldError extends KimiError {
+    readonly projectType?: string;
+    constructor(message: string, projectType?: string);
+}
 
 /**
  * Core types for the Kimi provider.
@@ -103,6 +1374,21 @@ interface KimiModelCapabilities {
      * Whether the model supports structured outputs.
      */
     structuredOutputs?: boolean;
+    /**
+     * Default temperature for the model.
+     * Thinking models require temperature=1.0 for optimal reasoning.
+     */
+    defaultTemperature?: number;
+    /**
+     * Whether temperature is locked (cannot be changed).
+     * Thinking models have this set to true.
+     */
+    temperatureLocked?: boolean;
+    /**
+     * Default max output tokens for the model.
+     * Thinking models need higher limits to avoid truncated reasoning.
+     */
+    defaultMaxOutputTokens?: number;
 }
 /**
  * Infer model capabilities from the model ID.
@@ -110,10 +1396,25 @@ interface KimiModelCapabilities {
  * @param modelId - The model identifier
  * @returns Inferred capabilities based on model name patterns
  *
+ * @remarks
+ * This function automatically detects model capabilities and sets
+ * appropriate defaults:
+ * - Thinking models (`-thinking` suffix) get temperature=1.0 locked
+ * - Thinking models get 32k default max_tokens to avoid truncation
+ * - K2.5 models get video input support
+ *
  * @example
  * ```ts
  * const caps = inferModelCapabilities('kimi-k2.5-thinking');
- * // { thinking: true, alwaysThinking: true, videoInput: true, ... }
+ * // {
+ * //   thinking: true,
+ * //   alwaysThinking: true,
+ * //   videoInput: true,
+ * //   temperatureLocked: true,
+ * //   defaultTemperature: 1.0,
+ * //   defaultMaxOutputTokens: 32768,
+ * //   ...
+ * // }
  * ```
  */
 declare function inferModelCapabilities(modelId: string): KimiModelCapabilities;
@@ -151,6 +1452,89 @@ interface KimiExtendedUsage extends LanguageModelV3Usage {
     codeInterpreterTokens?: number;
 }
 
+/**
+ * Auto-detection utilities for enabling tools based on prompt content.
+ * @module
+ */
+/**
+ * Result of auto-detecting which tools should be enabled.
+ */
+interface AutoDetectToolsResult {
+    /**
+     * Whether web search should be enabled.
+     */
+    webSearch: boolean;
+    /**
+     * Whether code interpreter should be enabled.
+     */
+    codeInterpreter: boolean;
+    /**
+     * Confidence score (0-1) for web search detection.
+     */
+    webSearchConfidence: number;
+    /**
+     * Confidence score (0-1) for code interpreter detection.
+     */
+    codeInterpreterConfidence: number;
+    /**
+     * Patterns that matched for web search.
+     */
+    webSearchMatches: string[];
+    /**
+     * Patterns that matched for code interpreter.
+     */
+    codeInterpreterMatches: string[];
+}
+/**
+ * Configuration for auto-detect behavior.
+ */
+interface AutoDetectConfig {
+    /**
+     * Minimum confidence threshold to enable a tool.
+     * @default 0.3
+     */
+    confidenceThreshold?: number;
+    /**
+     * Whether to include partial matches in detection.
+     * @default true
+     */
+    includePartialMatches?: boolean;
+}
+/**
+ * Automatically detect which tools should be enabled based on prompt content.
+ *
+ * @param prompt - The user's prompt text
+ * @param config - Optional detection configuration
+ * @returns Detection result with tool recommendations
+ *
+ * @example
+ * ```ts
+ * const result = detectToolsFromPrompt('What is the current price of Bitcoin?');
+ * // result.webSearch === true
+ * // result.webSearchConfidence === 0.95
+ * ```
+ */
+declare function detectToolsFromPrompt(prompt: string, config?: AutoDetectConfig): AutoDetectToolsResult;
+/**
+ * Simple version that just returns boolean flags.
+ * Useful for quick checks without detailed confidence info.
+ *
+ * @param prompt - The user's prompt text
+ * @returns Object with boolean flags for each tool
+ */
+declare function shouldAutoEnableTools(prompt: string): {
+    webSearch: boolean;
+    codeInterpreter: boolean;
+};
+/**
+ * Check if a prompt explicitly mentions not wanting tool usage.
+ * Useful for respecting user preferences.
+ */
+declare function hasToolOptOut(prompt: string): {
+    webSearch: boolean;
+    codeInterpreter: boolean;
+};
+
 /**
  * Built-in tools for Kimi API.
  *
@@ -331,6 +1715,45 @@ declare const kimiTools: {
     };
 };
 
+/**
+ * Tool preparation utilities for Kimi API.
+ * @module
+ */
+
+/**
+ * Options for generating tool guidance messages.
+ */
+interface ToolGuidanceOptions {
+    /**
+     * The tool names available.
+     */
+    toolNames: string[];
+    /**
+     * The type of tool choice.
+     */
+    choiceType: 'required' | 'tool';
+    /**
+     * The specific tool name if choiceType is 'tool'.
+     */
+    targetTool?: string;
+    /**
+     * Optional context from the user's prompt to include.
+     */
+    promptContext?: string;
+    /**
+     * Whether to include detailed tool descriptions.
+     * @default true
+     */
+    includeDescriptions?: boolean;
+}
+/**
+ * Generate a comprehensive tool guidance message.
+ *
+ * @param options - Options for generating the message
+ * @returns The generated system message
+ */
+declare function generateToolGuidanceMessage(options: ToolGuidanceOptions): string;
+
 /**
  * Chat model settings and provider options schema.
  * @module
@@ -413,6 +1836,14 @@ 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;
 }
 /**
  * Zod schema for caching configuration.
@@ -452,6 +1883,7 @@ declare const kimiProviderOptionsSchema: z.ZodObject<{
         resetCache: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>]>>;
     toolChoicePolyfill: z.ZodOptional<z.ZodBoolean>;
+    autoEnableTools: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 /**
  * Type for provider options passed to individual calls.
@@ -488,6 +1920,9 @@ declare class KimiChatLanguageModel implements LanguageModelV3 {
         toolCalling?: boolean;
         jsonMode?: boolean;
         structuredOutputs?: boolean;
+        defaultTemperature?: number;
+        temperatureLocked?: boolean;
+        defaultMaxOutputTokens?: number;
     };
     get supportedUrls(): Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>>;
     private getArgs;
@@ -495,6 +1930,107 @@ declare class KimiChatLanguageModel implements LanguageModelV3 {
     doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
 }
 
+/**
+ * File content caching for efficient re-use of uploaded files.
+ * @module
+ */
+/**
+ * Entry in the file cache.
+ */
+interface FileCacheEntry {
+    /** The Kimi file ID */
+    fileId: string;
+    /** Extracted text content (for documents) */
+    content?: string;
+    /** Unix timestamp of creation */
+    createdAt: number;
+    /** File purpose */
+    purpose: 'file-extract' | 'image' | 'video';
+}
+/**
+ * Options for configuring the file cache.
+ */
+interface FileCacheOptions {
+    /**
+     * Maximum number of entries in the cache.
+     * When exceeded, least recently used entries are evicted.
+     * @default 100
+     */
+    maxSize?: number;
+    /**
+     * Time-to-live for cache entries in milliseconds.
+     * Entries older than this are considered stale.
+     * @default 3600000 (1 hour)
+     */
+    ttlMs?: number;
+}
+/**
+ * A simple LRU (Least Recently Used) cache for file content.
+ *
+ * This cache helps avoid re-uploading the same files multiple times
+ * by storing the mapping between content hashes and Kimi file IDs.
+ *
+ * @example
+ * ```ts
+ * const cache = new FileCache({ maxSize: 50, ttlMs: 30 * 60 * 1000 });
+ *
+ * // Check if we have this file cached
+ * const cached = cache.get(contentHash);
+ * if (cached) {
+ *   console.log('Using cached file:', cached.fileId);
+ * }
+ *
+ * // Store a new file
+ * cache.set(contentHash, {
+ *   fileId: 'file_abc123',
+ *   content: 'extracted text...',
+ *   purpose: 'file-extract',
+ *   createdAt: Date.now()
+ * });
+ * ```
+ */
+declare class FileCache {
+    private readonly maxSize;
+    private readonly ttlMs;
+    private readonly cache;
+    constructor(options?: FileCacheOptions);
+    /**
+     * Get a cached entry by content hash.
+     * Returns undefined if not found or expired.
+     * Moves the entry to the end (most recently used).
+     */
+    get(contentHash: string): FileCacheEntry | undefined;
+    /**
+     * Set a cache entry.
+     * Evicts the least recently used entry if cache is full.
+     */
+    set(contentHash: string, entry: FileCacheEntry): void;
+    /**
+     * Check if an entry exists and is not expired.
+     */
+    has(contentHash: string): boolean;
+    /**
+     * Delete a specific entry.
+     */
+    delete(contentHash: string): boolean;
+    /**
+     * Clear all entries.
+     */
+    clear(): void;
+    /**
+     * Get the current cache size.
+     */
+    get size(): number;
+    /**
+     * Remove all expired entries.
+     */
+    prune(): number;
+    /**
+     * Check if an entry is expired.
+     */
+    private isExpired;
+}
+
 /**
  * Kimi File API client for uploading and managing files.
  * @module
@@ -659,6 +2195,13 @@ interface ProcessAttachmentsOptions {
     uploadImages?: boolean;
     /** Whether to delete files after extraction (cleanup) */
     cleanupAfterExtract?: boolean;
+    /**
+     * Enable caching of uploaded files.
+     * When true, uses the default global cache.
+     * When a FileCache instance, uses that cache.
+     * @default false
+     */
+    cache?: boolean | FileCache;
 }
 /**
  * Process experimental_attachments for Kimi.
@@ -812,6 +2355,99 @@ interface KimiProviderSettings {
      */
     supportedUrls?: LanguageModelV3['supportedUrls'];
 }
+/**
+ * Generate function signature for ensemble and convenience methods.
+ * Takes a model and prompt and returns generation results.
+ */
+type ProviderGenerateFunction = (model: LanguageModelV3, prompt: string, options?: {
+    temperature?: number;
+}) => Promise<{
+    text: string;
+    reasoning?: string;
+    toolCalls?: unknown[];
+    toolResults?: unknown[];
+    usage?: LanguageModelUsage$1;
+    finishReason?: string;
+}>;
+/**
+ * Options for ensemble generation.
+ */
+interface EnsembleOptions extends Partial<EnsembleConfig> {
+    /**
+     * Model to use for generation. Defaults to 'kimi-k2.5'.
+     */
+    model?: KimiChatModelId;
+    /**
+     * Base temperature for generation.
+     * @default 0.7
+     */
+    baseTemperature?: number;
+}
+/**
+ * Options for multi-agent workflows.
+ */
+interface MultiAgentOptions extends Partial<MultiAgentConfig> {
+    /**
+     * Default model settings to apply.
+     */
+    modelSettings?: KimiChatSettings;
+}
+/**
+ * Options for code validation.
+ */
+interface ValidateCodeOptions {
+    /**
+     * Model to use for LLM-based validation. Defaults to 'kimi-k2.5'.
+     */
+    model?: KimiChatModelId;
+    /**
+     * Model settings to apply.
+     */
+    modelSettings?: KimiChatSettings;
+    /**
+     * Maximum number of attempts to fix errors.
+     * @default 3
+     */
+    maxAttempts?: number;
+    /**
+     * Language to validate (auto-detected if not specified).
+     * @default 'auto'
+     */
+    language?: 'javascript' | 'typescript' | 'python' | 'java' | 'cpp' | 'go' | 'rust' | 'ruby' | 'php' | 'auto';
+    /**
+     * Validation strictness level.
+     * @default 'strict'
+     */
+    strictness?: 'lenient' | 'strict' | 'maximum';
+    /**
+     * Timeout for each code execution attempt (ms).
+     * @default 30000
+     */
+    executionTimeoutMs?: number;
+    /**
+     * Whether to include test cases in validation.
+     * @default true
+     */
+    includeTests?: boolean;
+    /**
+     * Whether to return the fixed code even if validation fails.
+     * @default true
+     */
+    returnPartialFix?: boolean;
+}
+/**
+ * Options for project scaffolding.
+ */
+interface ScaffoldProjectOptions extends ScaffoldConfig {
+    /**
+     * Model to use for generation. Defaults to 'kimi-k2.5'.
+     */
+    model?: KimiChatModelId;
+    /**
+     * Model settings to apply.
+     */
+    modelSettings?: KimiChatSettings;
+}
 /**
  * The Kimi provider interface.
  */
@@ -854,6 +2490,117 @@ interface KimiProvider extends Omit<ProviderV3, 'specificationVersion'> {
      * ```
      */
     files: KimiFileClient;
+    /**
+     * Generate multiple samples and select the best one using ensemble techniques.
+     *
+     * @param prompt - The prompt to generate from
+     * @param generateFn - Function that generates text (from AI SDK)
+     * @param options - Ensemble configuration options
+     * @returns The best response based on the selection strategy
+     *
+     * @example
+     * ```ts
+     * import { generateText } from 'ai';
+     *
+     * const result = await kimi.ensemble(
+     *   'Write a function to sort an array',
+     *   async (model, prompt, opts) => {
+     *     const result = await generateText({ model, prompt, temperature: opts?.temperature });
+     *     return { text: result.text, usage: result.usage };
+     *   },
+     *   { n: 3, selectionStrategy: 'best', scoringHeuristic: 'code' }
+     * );
+     * ```
+     */
+    ensemble(prompt: string, generateFn: ProviderGenerateFunction, options?: EnsembleOptions): Promise<EnsembleResult>;
+    /**
+     * Run a multi-agent workflow for complex tasks.
+     *
+     * @param prompt - The task description
+     * @param generateFn - Function that generates text (from AI SDK)
+     * @param options - Multi-agent workflow configuration
+     * @returns The result of the multi-agent collaboration
+     *
+     * @example
+     * ```ts
+     * const result = await kimi.multiAgent(
+     *   'Build a REST API for user authentication',
+     *   async (modelId, prompt) => {
+     *     const result = await generateText({ model: kimi(modelId), prompt });
+     *     return { text: result.text };
+     *   },
+     *   { workflow: 'planner-executor' }
+     * );
+     * ```
+     */
+    multiAgent(prompt: string, generateFn: GenerateTextFunction$1, options?: MultiAgentOptions): Promise<MultiAgentResult>;
+    /**
+     * Validate code for syntax errors and common issues.
+     *
+     * @param code - The code to validate
+     * @param generateFn - Optional function for LLM-based validation
+     * @param options - Validation configuration
+     * @returns Validation result with errors and optionally fixed code
+     *
+     * @example
+     * ```ts
+     * const result = await kimi.validateCode(
+     *   'function test() { return 42 }',
+     *   async (model, prompt) => {
+     *     const result = await generateText({ model, prompt });
+     *     return { text: result.text };
+     *   },
+     *   { language: 'javascript', strictness: 'strict' }
+     * );
+     * ```
+     */
+    validateCode(code: string, generateFn?: (model: LanguageModelV3, prompt: string) => Promise<{
+        text: string;
+    }>, options?: ValidateCodeOptions): Promise<ValidationResult>;
+    /**
+     * Generate a complete project scaffold from a description.
+     *
+     * @param description - Description of the project to create
+     * @param generateFn - Function that generates text (from AI SDK)
+     * @param options - Scaffold configuration
+     * @returns Generated project files and setup instructions
+     *
+     * @example
+     * ```ts
+     * const result = await kimi.scaffoldProject(
+     *   'A Next.js app with authentication and database',
+     *   async (prompt) => {
+     *     const result = await generateText({ model: kimi('kimi-k2.5'), prompt });
+     *     return { text: result.text };
+     *   },
+     *   { type: 'nextjs', includeTests: true, includeDocker: true }
+     * );
+     * ```
+     */
+    scaffoldProject(description: string, generateFn: (prompt: string) => Promise<{
+        text: string;
+    }>, options?: ScaffoldProjectOptions): Promise<ScaffoldResult>;
+    /**
+     * Auto-detect which tools should be enabled based on prompt content.
+     *
+     * @param prompt - The user's prompt
+     * @returns Object with webSearch and codeInterpreter booleans
+     *
+     * @example
+     * ```ts
+     * const tools = kimi.detectTools('What is the current Bitcoin price?');
+     * // { webSearch: true, codeInterpreter: false }
+     *
+     * const model = kimi('kimi-k2.5', {
+     *   webSearch: tools.webSearch,
+     *   codeInterpreter: tools.codeInterpreter
+     * });
+     * ```
+     */
+    detectTools(prompt: string): {
+        webSearch: boolean;
+        codeInterpreter: boolean;
+    };
 }
 /**
  * Create a Kimi provider instance.
@@ -1320,4 +3067,4 @@ declare class KimiCodeLanguageModel implements LanguageModelV3 {
     doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
 }
 
-export { type Attachment, type ExtendedThinkingConfig, type FileUploadOptions, type FileUploadResult, KIMI_CODE_BASE_URL, KIMI_CODE_DEFAULT_MODEL, KIMI_CODE_INTERPRETER_TOOL_NAME, KIMI_CODE_THINKING_MODEL, KIMI_WEB_SEARCH_TOOL_NAME, KimiAuthenticationError, type KimiBuiltinTool, type KimiCachingConfig, KimiChatLanguageModel, type KimiChatModelId, type KimiChatSettings, type KimiCodeCapabilities, type KimiCodeInterpreterConfig, type KimiCodeInterpreterToolOptions, KimiCodeLanguageModel, type KimiCodeModelId, type KimiCodeProvider, type KimiCodeProviderOptions, type KimiCodeProviderSettings, type KimiCodeSettings, KimiContentFilterError, KimiContextLengthError, KimiError, type KimiExtendedUsage, type KimiFile, KimiFileClient, type KimiFileClientConfig, type KimiModelCapabilities, KimiModelNotFoundError, type KimiProvider, type KimiProviderOptions, type KimiProviderSettings, KimiRateLimitError, KimiValidationError, type KimiWebSearchConfig, type KimiWebSearchToolConfig, type KimiWebSearchToolOptions, type ProcessedAttachment, type ReasoningEffort, SUPPORTED_FILE_EXTENSIONS, SUPPORTED_MIME_TYPES, createCodeInterpreterTool, createKimi, createKimiCode, createKimiWebSearchTool, createWebSearchTool, getMediaTypeFromExtension, getPurposeFromMediaType, inferKimiCodeCapabilities, inferModelCapabilities, isDocumentMediaType, isFileExtractMediaType, isImageMediaType, isVideoMediaType, kimi, kimiCachingConfigSchema, kimiCode, kimiCodeProviderOptionsSchema, kimiProviderOptionsSchema, kimiTools, processAttachments };
+export { type AgentStep, type Attachment, type AutoDetectConfig, type AutoDetectToolsResult, type CodeBlock, type CodeExtractionResult, type CodeValidationConfig, CodeValidator, type CodeValidatorOptions, DEFAULT_SYSTEM_PROMPTS, type EnsembleConfig, type EnsembleMetadata, type EnsembleOptions, type EnsembleResponse, type EnsembleResult, type ExtendedThinkingConfig, type FileUploadOptions, type FileUploadResult, type FixAttempt, type GenerateFunction, type GenerateResult, KIMI_CODE_BASE_URL, KIMI_CODE_DEFAULT_MODEL, KIMI_CODE_INTERPRETER_TOOL_NAME, KIMI_CODE_THINKING_MODEL, KIMI_WEB_SEARCH_TOOL_NAME, KimiAuthenticationError, type KimiBuiltinTool, type KimiCachingConfig, KimiChatLanguageModel, type KimiChatModelId, type KimiChatSettings, type KimiCodeCapabilities, type KimiCodeInterpreterConfig, type KimiCodeInterpreterToolOptions, KimiCodeLanguageModel, type KimiCodeModelId, type KimiCodeProvider, type KimiCodeProviderOptions, type KimiCodeProviderSettings, type KimiCodeSettings, KimiCodeValidationError, KimiContentFilterError, KimiContextLengthError, KimiEnsembleTimeoutError, KimiEnsembleValidationError, KimiError, type KimiExtendedUsage, type KimiFile, KimiFileClient, type KimiFileClientConfig, type KimiModelCapabilities, KimiModelNotFoundError, KimiMultiAgentError, type KimiProvider, type KimiProviderOptions, type KimiProviderSettings, KimiRateLimitError, KimiScaffoldError, KimiValidationError, type KimiWebSearchConfig, type KimiWebSearchToolConfig, type KimiWebSearchToolOptions, type LanguageDetectionResult, type MultiAgentConfig, type MultiAgentMetadata, type MultiAgentOptions, type MultiAgentResult, MultiSampler, type MultiSamplerOptions, type OutputFormat, type ProcessedAttachment, type ProjectFile, type ProjectMetadata, ProjectScaffolder, type ProjectTemplate, type ProjectType, type ProviderGenerateFunction, type ReasoningEffort, SUPPORTED_FILE_EXTENSIONS, SUPPORTED_MIME_TYPES, type ScaffoldConfig, type ScaffoldProjectOptions, type ScaffoldResult, type ScoringHeuristic, type SelectionStrategy, type SupportedLanguage, type ToolGuidanceOptions, type ValidateCodeOptions, type ValidationError, type ValidationErrorType, type ValidationResult, type ValidationSeverity, type ValidationStrictness, type WorkflowContext, WorkflowRunner, type WorkflowType, containsCode, createCodeInterpreterTool, createEmptyMultiAgentResult, createEmptyScaffoldResult, createFailedValidationResult, createKimi, createKimiCode, createKimiWebSearchTool, createPassedValidationResult, createSingletonEnsembleResult, createWebSearchTool, detectLanguage, detectToolsFromPrompt, extractCodeBlocks, extractPrimaryCode, generateToolGuidanceMessage, getFileExtension, getMediaTypeFromExtension, getPurposeFromMediaType, hasToolOptOut, inferKimiCodeCapabilities, inferModelCapabilities, isDocumentMediaType, isFileExtractMediaType, isImageMediaType, isVideoMediaType, kimi, kimiCachingConfigSchema, kimiCode, kimiCodeProviderOptionsSchema, kimiProviderOptionsSchema, kimiTools, processAttachments, shouldAutoEnableTools };