kimi-vercel-ai-sdk-provider 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,1317 @@
+import { LanguageModelV3, LanguageModelV3Usage, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult, ProviderV3 } from '@ai-sdk/provider';
+import { FetchFunction } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+/**
+ * Base error class for Kimi provider errors.
+ */
+declare class KimiError extends Error {
+    readonly code: string;
+    readonly statusCode?: number;
+    constructor(message: string, code: string, statusCode?: number);
+}
+/**
+ * Error thrown when authentication fails.
+ */
+declare class KimiAuthenticationError extends KimiError {
+    constructor(message?: string);
+}
+/**
+ * Error thrown when rate limit is exceeded.
+ */
+declare class KimiRateLimitError extends KimiError {
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+/**
+ * Error thrown when the request is invalid.
+ */
+declare class KimiValidationError extends KimiError {
+    constructor(message: string, param?: string);
+}
+/**
+ * Error thrown when a model is not found.
+ */
+declare class KimiModelNotFoundError extends KimiError {
+    readonly modelId: string;
+    constructor(modelId: string);
+}
+/**
+ * Error thrown when content is filtered.
+ */
+declare class KimiContentFilterError extends KimiError {
+    constructor(message?: string);
+}
+/**
+ * Error thrown when context length is exceeded.
+ */
+declare class KimiContextLengthError extends KimiError {
+    constructor(message?: string);
+}
+
+/**
+ * Core types for the Kimi provider.
+ * @module
+ */
+
+/**
+ * Available Kimi chat model IDs.
+ *
+ * @remarks
+ * - `kimi-k2.5` - Latest flagship model with multimodal support
+ * - `kimi-k2.5-thinking` - K2.5 with always-on deep reasoning
+ * - `kimi-k2-turbo` - Fast, cost-effective model
+ * - `kimi-k2-thinking` - K2 with always-on deep reasoning
+ */
+type KimiChatModelId = 'kimi-k2.5' | 'kimi-k2.5-thinking' | 'kimi-k2-turbo' | 'kimi-k2-thinking' | (string & {});
+/**
+ * Capabilities that can be detected from model ID patterns or explicitly set.
+ */
+interface KimiModelCapabilities {
+    /**
+     * Whether the model supports thinking/reasoning mode.
+     * Models with `-thinking` suffix have this enabled by default.
+     */
+    thinking?: boolean;
+    /**
+     * Whether the model always uses thinking mode (cannot be disabled).
+     * Thinking models like `kimi-k2.5-thinking` have this set to true.
+     */
+    alwaysThinking?: boolean;
+    /**
+     * Whether the model supports image inputs.
+     */
+    imageInput?: boolean;
+    /**
+     * Whether the model supports video inputs.
+     * Currently only kimi-k2.5 models support video.
+     */
+    videoInput?: boolean;
+    /**
+     * Maximum context window size in tokens.
+     */
+    maxContextSize?: number;
+    /**
+     * Whether the model supports tool/function calling.
+     */
+    toolCalling?: boolean;
+    /**
+     * Whether the model supports JSON mode.
+     */
+    jsonMode?: boolean;
+    /**
+     * Whether the model supports structured outputs.
+     */
+    structuredOutputs?: boolean;
+}
+/**
+ * Infer model capabilities from the model ID.
+ *
+ * @param modelId - The model identifier
+ * @returns Inferred capabilities based on model name patterns
+ *
+ * @example
+ * ```ts
+ * const caps = inferModelCapabilities('kimi-k2.5-thinking');
+ * // { thinking: true, alwaysThinking: true, videoInput: true, ... }
+ * ```
+ */
+declare function inferModelCapabilities(modelId: string): KimiModelCapabilities;
+/**
+ * Configuration for the chat language model.
+ * @internal
+ */
+interface KimiChatConfig {
+    provider: string;
+    baseURL: string;
+    headers: () => Record<string, string | undefined>;
+    fetch?: typeof globalThis.fetch;
+    generateId?: () => string;
+    supportsStructuredOutputs?: boolean;
+    includeUsageInStream?: boolean;
+    supportedUrls?: LanguageModelV3['supportedUrls'];
+}
+
+/**
+ * Utility functions for the Kimi provider.
+ * @module
+ */
+
+/**
+ * Extended usage information including web search and code interpreter tokens.
+ */
+interface KimiExtendedUsage extends LanguageModelV3Usage {
+    /**
+     * Tokens used by the built-in web search tool.
+     */
+    webSearchTokens?: number;
+    /**
+     * Tokens used by the built-in code interpreter.
+     */
+    codeInterpreterTokens?: number;
+}
+
+/**
+ * Built-in tools for Kimi API.
+ *
+ * Kimi provides server-side tools that can be invoked during chat completions:
+ * - `$web_search`: Search the web for information
+ * - `$code`: Execute code using Kimi's code interpreter
+ *
+ * @module
+ */
+/**
+ * Kimi's built-in web search tool identifier.
+ * This tool allows Kimi to search the web for up-to-date information.
+ */
+declare const KIMI_WEB_SEARCH_TOOL_NAME = "$web_search";
+/**
+ * Kimi's built-in code interpreter tool identifier.
+ * This tool allows Kimi to execute code and return results.
+ */
+declare const KIMI_CODE_INTERPRETER_TOOL_NAME = "$code";
+/**
+ * Configuration for Kimi's built-in web search tool.
+ */
+interface KimiWebSearchConfig {
+    /**
+     * Whether to include search results in the response.
+     * When true, the search results will be included in the tool output.
+     */
+    search_result?: boolean;
+    /**
+     * Allow additional configuration options.
+     */
+    [key: string]: unknown;
+}
+/**
+ * Configuration for Kimi's built-in code interpreter tool.
+ */
+interface KimiCodeInterpreterConfig {
+    /**
+     * Maximum execution time in seconds.
+     * Default varies by model and API tier.
+     */
+    timeout?: number;
+    /**
+     * Whether to return execution output.
+     * When true, stdout/stderr will be included in results.
+     */
+    include_output?: boolean;
+    /**
+     * Allow additional configuration options.
+     */
+    [key: string]: unknown;
+}
+/**
+ * A Kimi built-in tool definition.
+ * These are handled server-side by Kimi's API.
+ */
+interface KimiBuiltinTool {
+    type: 'builtin_function';
+    function: {
+        name: string;
+        config?: Record<string, unknown>;
+    };
+}
+/**
+ * Configuration options for the web search tool.
+ */
+interface KimiWebSearchToolOptions {
+    /**
+     * Whether the web search tool is enabled.
+     */
+    enabled: boolean;
+    /**
+     * Optional configuration for the web search tool.
+     */
+    config?: KimiWebSearchConfig;
+}
+type KimiWebSearchToolConfig = KimiWebSearchToolOptions;
+/**
+ * Create a Kimi built-in web search tool definition.
+ *
+ * @param config - Optional configuration for the web search tool
+ * @returns A built-in tool definition for $web_search
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const tool = createWebSearchTool();
+ *
+ * // With configuration
+ * const tool = createWebSearchTool({ search_result: true });
+ * ```
+ */
+declare function createWebSearchTool(config?: KimiWebSearchConfig): KimiBuiltinTool;
+declare function createKimiWebSearchTool(config?: KimiWebSearchConfig): KimiBuiltinTool;
+/**
+ * Configuration options for the code interpreter tool.
+ */
+interface KimiCodeInterpreterToolOptions {
+    /**
+     * Whether the code interpreter tool is enabled.
+     */
+    enabled: boolean;
+    /**
+     * Optional configuration for the code interpreter tool.
+     */
+    config?: KimiCodeInterpreterConfig;
+}
+/**
+ * Create a Kimi built-in code interpreter tool definition.
+ *
+ * @param config - Optional configuration for the code interpreter tool
+ * @returns A built-in tool definition for $code
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const tool = createCodeInterpreterTool();
+ *
+ * // With configuration
+ * const tool = createCodeInterpreterTool({ timeout: 30, include_output: true });
+ * ```
+ */
+declare function createCodeInterpreterTool(config?: KimiCodeInterpreterConfig): KimiBuiltinTool;
+/**
+ * Create provider-level tool definitions for use with the AI SDK.
+ * These can be passed directly to the tools option.
+ */
+declare const kimiTools: {
+    /**
+     * Create a web search tool for use with Kimi models.
+     *
+     * @param config - Optional configuration
+     * @returns A provider tool definition
+     *
+     * @example
+     * ```ts
+     * import { kimi, kimiTools } from 'ai-sdk-provider-kimi';
+     *
+     * const result = await generateText({
+     *   model: kimi('kimi-k2.5'),
+     *   tools: {
+     *     webSearch: kimiTools.webSearch(),
+     *   },
+     *   prompt: 'What are the latest AI news?',
+     * });
+     * ```
+     */
+    webSearch: (config?: KimiWebSearchConfig) => {
+        type: "provider";
+        id: string;
+        args: KimiBuiltinTool;
+    };
+    /**
+     * Create a code interpreter tool for use with Kimi models.
+     *
+     * @param config - Optional configuration
+     * @returns A provider tool definition
+     *
+     * @example
+     * ```ts
+     * import { kimi, kimiTools } from 'ai-sdk-provider-kimi';
+     *
+     * const result = await generateText({
+     *   model: kimi('kimi-k2.5'),
+     *   tools: {
+     *     codeInterpreter: kimiTools.codeInterpreter(),
+     *   },
+     *   prompt: 'Calculate the factorial of 10',
+     * });
+     * ```
+     */
+    codeInterpreter: (config?: KimiCodeInterpreterConfig) => {
+        type: "provider";
+        id: string;
+        args: KimiBuiltinTool;
+    };
+};
+
+/**
+ * Chat model settings and provider options schema.
+ * @module
+ */
+
+/**
+ * Configuration for context caching.
+ * Enables cost reduction for long, repeated prompts.
+ */
+interface KimiCachingConfig {
+    /**
+     * Enable context caching for this request.
+     */
+    enabled: boolean;
+    /**
+     * Optional cache key for identifying cached context.
+     * Use the same key across requests to hit the same cache.
+     */
+    cacheKey?: string;
+    /**
+     * Time-to-live for the cache in seconds.
+     * Defaults to API default (typically 3600 seconds / 1 hour).
+     */
+    ttlSeconds?: number;
+    /**
+     * Reset the cache even if a matching cache exists.
+     */
+    resetCache?: boolean;
+}
+/**
+ * Settings for creating a Kimi chat model instance.
+ */
+interface KimiChatSettings {
+    /**
+     * Enable JSON schema structured outputs when a schema is provided.
+     */
+    supportsStructuredOutputs?: boolean;
+    /**
+     * Request usage metrics during streaming (if supported by the API).
+     */
+    includeUsageInStream?: boolean;
+    /**
+     * Override supported URL patterns for file parts.
+     */
+    supportedUrls?: LanguageModelV3['supportedUrls'];
+    /**
+     * Enable the built-in web search tool.
+     * When true, Kimi can search the web to answer questions.
+     * You can also pass a configuration object for more control.
+     */
+    webSearch?: boolean | KimiWebSearchToolOptions;
+    /**
+     * Enable the built-in code interpreter tool.
+     * When true, Kimi can execute code to solve problems.
+     * You can also pass a configuration object for more control.
+     */
+    codeInterpreter?: boolean | KimiCodeInterpreterToolOptions;
+    /**
+     * Override inferred model capabilities.
+     */
+    capabilities?: Partial<KimiModelCapabilities>;
+    /**
+     * Enable tool choice polyfill for unsupported tool choice modes.
+     * When true (default), uses system message injection to simulate
+     * `required` and `tool` choices that Kimi doesn't natively support.
+     *
+     * @default true
+     */
+    toolChoicePolyfill?: boolean;
+    /**
+     * Enable automatic file handling for experimental_attachments.
+     * When true, PDFs and documents will be automatically uploaded
+     * to Kimi's file API and their content injected into the context.
+     *
+     * @default false
+     */
+    autoFileUpload?: boolean;
+    /**
+     * Context caching configuration.
+     * Reduces costs by up to 90% for repeated long prompts.
+     */
+    caching?: boolean | KimiCachingConfig;
+}
+/**
+ * Zod schema for caching configuration.
+ */
+declare const kimiCachingConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    cacheKey: z.ZodOptional<z.ZodString>;
+    ttlSeconds: z.ZodOptional<z.ZodNumber>;
+    resetCache: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Zod schema for validating provider options passed to individual calls.
+ */
+declare const kimiProviderOptionsSchema: z.ZodObject<{
+    user: z.ZodOptional<z.ZodString>;
+    strictJsonSchema: z.ZodOptional<z.ZodBoolean>;
+    requestId: z.ZodOptional<z.ZodString>;
+    extraHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
+    webSearch: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        enabled: z.ZodBoolean;
+        config: z.ZodOptional<z.ZodObject<{
+            search_result: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>>;
+    codeInterpreter: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        enabled: z.ZodBoolean;
+        config: z.ZodOptional<z.ZodObject<{
+            timeout: z.ZodOptional<z.ZodNumber>;
+            include_output: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>>;
+    caching: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        enabled: z.ZodBoolean;
+        cacheKey: z.ZodOptional<z.ZodString>;
+        ttlSeconds: z.ZodOptional<z.ZodNumber>;
+        resetCache: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>]>>;
+    toolChoicePolyfill: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Type for provider options passed to individual calls.
+ */
+type KimiProviderOptions = z.infer<typeof kimiProviderOptionsSchema>;
+
+/**
+ * Kimi chat language model implementation.
+ * @module
+ */
+
+/**
+ * Kimi chat language model implementing LanguageModelV3.
+ */
+declare class KimiChatLanguageModel implements LanguageModelV3 {
+    readonly specificationVersion = "v3";
+    readonly modelId: KimiChatModelId;
+    private readonly config;
+    private readonly settings;
+    private readonly generateIdFn;
+    private readonly supportsStructuredOutputs;
+    constructor(modelId: KimiChatModelId, settings: KimiChatSettings, config: KimiChatConfig);
+    get provider(): string;
+    private get providerOptionsName();
+    /**
+     * Get the inferred or configured capabilities for this model.
+     */
+    get capabilities(): {
+        thinking?: boolean;
+        alwaysThinking?: boolean;
+        imageInput?: boolean;
+        videoInput?: boolean;
+        maxContextSize?: number;
+        toolCalling?: boolean;
+        jsonMode?: boolean;
+        structuredOutputs?: boolean;
+    };
+    get supportedUrls(): Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>>;
+    private getArgs;
+    doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
+    doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
+}
+
+/**
+ * Kimi File API client for uploading and managing files.
+ * @module
+ */
+
+/**
+ * A file object returned by the Kimi File API.
+ */
+interface KimiFile {
+    /** Unique file identifier */
+    id: string;
+    /** File size in bytes */
+    bytes: number;
+    /** Unix timestamp of creation */
+    created_at: number;
+    /** Original filename */
+    filename: string;
+    /** Object type (always 'file') */
+    object: 'file';
+    /** File purpose (file-extract, image, video) */
+    purpose: 'file-extract' | 'image' | 'video';
+    /** Processing status */
+    status: 'ok' | 'error' | 'processing';
+    /** Status details if error */
+    status_details?: string;
+}
+/**
+ * Options for uploading a file.
+ */
+interface FileUploadOptions {
+    /** The file data as a Buffer, Uint8Array, or string (base64) */
+    data: Uint8Array | string;
+    /** The filename */
+    filename: string;
+    /** MIME type of the file */
+    mediaType?: string;
+    /** Purpose of the file (defaults based on mediaType) */
+    purpose?: 'file-extract' | 'image' | 'video';
+}
+/**
+ * Result of a file upload operation.
+ */
+interface FileUploadResult {
+    /** The uploaded file object */
+    file: KimiFile;
+    /** The extracted content (for file-extract purpose) */
+    content?: string;
+}
+/**
+ * Configuration for the file client.
+ */
+interface KimiFileClientConfig {
+    /** Base URL for the API */
+    baseURL: string;
+    /** Function to get authorization headers */
+    headers: () => Record<string, string | undefined>;
+    /** Custom fetch implementation */
+    fetch?: FetchFunction;
+}
+/**
+ * Client for interacting with Kimi's File API.
+ *
+ * Supports uploading files for content extraction, image understanding,
+ * and video understanding.
+ *
+ * @example
+ * ```ts
+ * const client = new KimiFileClient({
+ *   baseURL: 'https://api.moonshot.ai/v1',
+ *   headers: () => ({
+ *     Authorization: `Bearer ${apiKey}`,
+ *   }),
+ * });
+ *
+ * // Upload a PDF and extract content
+ * const result = await client.uploadAndExtract({
+ *   data: pdfBuffer,
+ *   filename: 'document.pdf',
+ *   mediaType: 'application/pdf',
+ * });
+ *
+ * console.log(result.content); // Extracted text content
+ * ```
+ */
+declare class KimiFileClient {
+    private readonly config;
+    constructor(config: KimiFileClientConfig);
+    /**
+     * Upload a file to the Kimi API.
+     */
+    upload(options: FileUploadOptions): Promise<KimiFile>;
+    /**
+     * Get the content of an uploaded file (for file-extract purpose).
+     */
+    getContent(fileId: string): Promise<string>;
+    /**
+     * Upload a file and extract its content in one operation.
+     * Only works for files with purpose="file-extract".
+     */
+    uploadAndExtract(options: FileUploadOptions): Promise<FileUploadResult>;
+    /**
+     * Get file information.
+     */
+    getFile(fileId: string): Promise<KimiFile>;
+    /**
+     * List all uploaded files.
+     */
+    listFiles(): Promise<KimiFile[]>;
+    /**
+     * Delete a file.
+     */
+    deleteFile(fileId: string): Promise<void>;
+}
+
+/**
+ * Attachment processor for experimental_attachments support.
+ * Automatically uploads files to Kimi and injects content into prompts.
+ * @module
+ */
+
+/**
+ * An attachment from experimental_attachments.
+ */
+interface Attachment {
+    /** URL of the attachment */
+    url?: string;
+    /** Name of the attachment */
+    name?: string;
+    /** MIME type */
+    contentType?: string;
+    /** Raw content data */
+    content?: Uint8Array | string;
+}
+/**
+ * Processed attachment result.
+ */
+interface ProcessedAttachment {
+    /** Original attachment */
+    original: Attachment;
+    /** Processing type */
+    type: 'text-inject' | 'image-url' | 'video-url' | 'skip';
+    /** Extracted text content (for documents) */
+    textContent?: string;
+    /** URL to use in message (for images/videos) */
+    mediaUrl?: string;
+    /** Kimi file ID (if uploaded) */
+    fileId?: string;
+    /** Error if processing failed */
+    error?: string;
+}
+/**
+ * Options for processing attachments.
+ */
+interface ProcessAttachmentsOptions {
+    /** Attachments to process */
+    attachments: Attachment[];
+    /** File client configuration */
+    clientConfig: KimiFileClientConfig;
+    /** Whether to auto-upload documents for extraction */
+    autoUploadDocuments?: boolean;
+    /** Whether to upload images to Kimi's file API */
+    uploadImages?: boolean;
+    /** Whether to delete files after extraction (cleanup) */
+    cleanupAfterExtract?: boolean;
+}
+/**
+ * Process experimental_attachments for Kimi.
+ *
+ * This function handles different attachment types:
+ * - Documents (PDF, DOC, etc.): Uploads to Kimi, extracts content, returns text to inject
+ * - Images: Returns URL for vision input
+ * - Videos: Returns URL for video input
+ *
+ * @example
+ * ```ts
+ * const processed = await processAttachments({
+ *   attachments: message.experimental_attachments ?? [],
+ *   clientConfig: {
+ *     baseURL: 'https://api.moonshot.ai/v1',
+ *     headers: () => ({ Authorization: `Bearer ${apiKey}` }),
+ *   },
+ * });
+ *
+ * // Inject document content into system messages
+ * const documentContent = processed
+ *   .filter(p => p.type === 'text-inject' && p.textContent)
+ *   .map(p => p.textContent)
+ *   .join('\n');
+ * ```
+ */
+declare function processAttachments(options: ProcessAttachmentsOptions): Promise<ProcessedAttachment[]>;
+
+/**
+ * File utility functions for Kimi API.
+ * @module
+ */
+/**
+ * File extensions supported by Kimi's file upload API.
+ */
+declare const SUPPORTED_FILE_EXTENSIONS: readonly [".pdf", ".txt", ".csv", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".md", ".epub", ".mobi", ".html", ".json", ".log", ".dot", ".ini", ".conf", ".yaml", ".yml", ".jpeg", ".jpg", ".png", ".bmp", ".gif", ".svg", ".svgz", ".webp", ".ico", ".xbm", ".dib", ".pjp", ".tif", ".tiff", ".pjpeg", ".avif", ".apng", ".jfif", ".go", ".h", ".c", ".cpp", ".cxx", ".cc", ".cs", ".java", ".js", ".css", ".jsp", ".php", ".py", ".py3", ".asp", ".ts", ".tsx"];
+/**
+ * MIME types supported by Kimi's file upload API.
+ */
+declare const SUPPORTED_MIME_TYPES: {
+    readonly 'application/pdf': "file-extract";
+    readonly 'text/plain': "file-extract";
+    readonly 'text/csv': "file-extract";
+    readonly 'application/msword': "file-extract";
+    readonly 'application/vnd.openxmlformats-officedocument.wordprocessingml.document': "file-extract";
+    readonly 'application/vnd.ms-excel': "file-extract";
+    readonly 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': "file-extract";
+    readonly 'application/vnd.ms-powerpoint': "file-extract";
+    readonly 'application/vnd.openxmlformats-officedocument.presentationml.presentation': "file-extract";
+    readonly 'text/markdown': "file-extract";
+    readonly 'text/html': "file-extract";
+    readonly 'application/json': "file-extract";
+    readonly 'application/epub+zip': "file-extract";
+    readonly 'text/yaml': "file-extract";
+    readonly 'application/x-yaml': "file-extract";
+    readonly 'text/javascript': "file-extract";
+    readonly 'text/typescript': "file-extract";
+    readonly 'text/x-python': "file-extract";
+    readonly 'text/x-java': "file-extract";
+    readonly 'text/x-c': "file-extract";
+    readonly 'text/x-c++': "file-extract";
+    readonly 'text/css': "file-extract";
+    readonly 'image/jpeg': "image";
+    readonly 'image/png': "image";
+    readonly 'image/gif': "image";
+    readonly 'image/webp': "image";
+    readonly 'image/svg+xml': "image";
+    readonly 'image/bmp': "image";
+    readonly 'image/tiff': "image";
+    readonly 'image/avif': "image";
+    readonly 'image/apng': "image";
+    readonly 'image/x-icon': "image";
+    readonly 'video/mp4': "video";
+    readonly 'video/webm': "video";
+    readonly 'video/ogg': "video";
+    readonly 'video/quicktime': "video";
+};
+type FilePurpose = 'file-extract' | 'image' | 'video';
+/**
+ * Check if a media type is for image files.
+ */
+declare function isImageMediaType(mediaType: string): boolean;
+/**
+ * Check if a media type is for video files.
+ */
+declare function isVideoMediaType(mediaType: string): boolean;
+/**
+ * Check if a media type should use file-extract purpose.
+ */
+declare function isFileExtractMediaType(mediaType: string): boolean;
+/**
+ * Check if a media type is for document files (PDFs, Word, etc.).
+ */
+declare function isDocumentMediaType(mediaType: string): boolean;
+/**
+ * Get the file purpose based on media type.
+ */
+declare function getPurposeFromMediaType(mediaType: string): FilePurpose;
+/**
+ * Get MIME type from file extension.
+ */
+declare function getMediaTypeFromExtension(extension: string): string;
+
+/**
+ * Kimi provider factory.
+ * @module
+ */
+
+/**
+ * Settings for creating a Kimi provider instance.
+ */
+interface KimiProviderSettings {
+    /**
+     * Moonshot AI API key. Defaults to the MOONSHOT_API_KEY environment variable.
+     */
+    apiKey?: string;
+    /**
+     * Base URL override. Defaults to the global or China endpoint.
+     */
+    baseURL?: string;
+    /**
+     * Select the regional endpoint when baseURL is not provided.
+     * - `global`: Use the global API endpoint (api.moonshot.ai)
+     * - `cn`: Use the China API endpoint (api.moonshot.cn)
+     *
+     * @default 'global'
+     */
+    endpoint?: 'global' | 'cn';
+    /**
+     * Default headers for all requests.
+     */
+    headers?: Record<string, string | undefined>;
+    /**
+     * Custom fetch implementation.
+     */
+    fetch?: FetchFunction;
+    /**
+     * ID generator for tool call fallback IDs.
+     */
+    generateId?: () => string;
+    /**
+     * Enable JSON schema structured outputs by default.
+     */
+    supportsStructuredOutputs?: boolean;
+    /**
+     * Include usage details in streaming responses if supported.
+     */
+    includeUsageInStream?: boolean;
+    /**
+     * Override supported URL patterns for file parts.
+     */
+    supportedUrls?: LanguageModelV3['supportedUrls'];
+}
+/**
+ * The Kimi provider interface.
+ */
+interface KimiProvider extends Omit<ProviderV3, 'specificationVersion'> {
+    specificationVersion: 'v3';
+    /**
+     * Creates a chat language model.
+     * @param modelId - The model identifier
+     * @param settings - Optional model settings
+     */
+    (modelId: KimiChatModelId, settings?: KimiChatSettings): LanguageModelV3;
+    /**
+     * Creates a chat language model.
+     * @param modelId - The model identifier
+     * @param settings - Optional model settings
+     */
+    languageModel(modelId: KimiChatModelId, settings?: KimiChatSettings): LanguageModelV3;
+    /**
+     * Creates a chat language model (alias for languageModel).
+     * @param modelId - The model identifier
+     * @param settings - Optional model settings
+     */
+    chat(modelId: KimiChatModelId, settings?: KimiChatSettings): LanguageModelV3;
+    /**
+     * Built-in tools that can be used with Kimi models.
+     */
+    tools: typeof kimiTools;
+    /**
+     * File client for uploading and extracting content from files.
+     * Pre-configured with the provider's API key and base URL.
+     *
+     * @example
+     * ```ts
+     * const kimi = createKimi();
+     * const result = await kimi.files.uploadAndExtract({
+     *   data: pdfBuffer,
+     *   filename: 'document.pdf',
+     * });
+     * console.log(result.content);
+     * ```
+     */
+    files: KimiFileClient;
+}
+/**
+ * Create a Kimi provider instance.
+ *
+ * @param options - Provider settings
+ * @returns A configured Kimi provider
+ *
+ * @example
+ * ```ts
+ * import { createKimi } from 'ai-sdk-provider-kimi';
+ *
+ * const kimi = createKimi({
+ *   apiKey: process.env.MOONSHOT_API_KEY,
+ * });
+ *
+ * const result = await generateText({
+ *   model: kimi('kimi-k2.5'),
+ *   prompt: 'Hello!',
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With web search enabled
+ * const result = await generateText({
+ *   model: kimi('kimi-k2.5', { webSearch: true }),
+ *   prompt: 'What are the latest AI news?',
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With code interpreter
+ * const result = await generateText({
+ *   model: kimi('kimi-k2.5', { codeInterpreter: true }),
+ *   prompt: 'Calculate the factorial of 20',
+ * });
+ * ```
+ */
+declare function createKimi(options?: KimiProviderSettings): KimiProvider;
+/**
+ * Default Kimi provider instance.
+ *
+ * Uses the MOONSHOT_API_KEY environment variable for authentication.
+ *
+ * @example
+ * ```ts
+ * import { kimi } from 'ai-sdk-provider-kimi';
+ *
+ * const result = await generateText({
+ *   model: kimi('kimi-k2.5'),
+ *   prompt: 'Hello!',
+ * });
+ * ```
+ */
+declare const kimi: KimiProvider;
+
+/**
+ * Types for the Kimi Code provider.
+ *
+ * Kimi Code is a premium coding service within the Kimi ecosystem that provides:
+ * - High-speed output (up to 100 tokens/s)
+ * - Extended thinking/reasoning support
+ * - Full compatibility with Claude Code and Roo Code
+ * - Anthropic-compatible API format
+ *
+ * @see https://www.kimi.com/code/docs/en/
+ * @module
+ */
+
+/**
+ * Default Kimi Code API endpoint (Anthropic-compatible).
+ * Used with Claude Code - set as ANTHROPIC_BASE_URL
+ */
+declare const KIMI_CODE_BASE_URL = "https://api.kimi.com/coding/v1";
+/**
+ * Default Kimi Code model ID.
+ * Primary coding model optimized for development tasks.
+ */
+declare const KIMI_CODE_DEFAULT_MODEL = "kimi-for-coding";
+/**
+ * Alternative model with enhanced thinking/reasoning.
+ * Can be toggled with Tab key in Claude Code.
+ */
+declare const KIMI_CODE_THINKING_MODEL = "kimi-k2-thinking";
+/**
+ * Available Kimi Code model IDs.
+ *
+ * @remarks
+ * - `kimi-for-coding` - Primary coding model optimized for development tasks
+ * - `kimi-k2-thinking` - Model with extended thinking for complex reasoning (toggle with Tab in Claude Code)
+ *
+ * @example
+ * ```ts
+ * // Default model
+ * const model = kimiCode('kimi-for-coding');
+ *
+ * // Thinking model
+ * const thinkingModel = kimiCode('kimi-k2-thinking');
+ * ```
+ */
+type KimiCodeModelId = 'kimi-for-coding' | 'kimi-k2-thinking' | (string & {});
+/**
+ * Capabilities specific to Kimi Code models.
+ * Based on Roo Code configuration documentation.
+ */
+interface KimiCodeCapabilities {
+    /**
+     * Whether the model supports extended thinking/reasoning.
+     * When enabled, use `thinking.type: 'enabled'` with `budget_tokens`.
+     */
+    extendedThinking?: boolean;
+    /**
+     * Maximum output tokens.
+     * Default: 32768 (per Roo Code docs)
+     */
+    maxOutputTokens?: number;
+    /**
+     * Maximum context window size.
+     * Default: 262144 (per Roo Code docs)
+     */
+    maxContextSize?: number;
+    /**
+     * Whether the model supports streaming.
+     * Always true for Kimi Code.
+     */
+    streaming?: boolean;
+    /**
+     * Whether the model supports tool/function calling.
+     * Always true for Kimi Code.
+     */
+    toolCalling?: boolean;
+    /**
+     * Whether the model supports image inputs.
+     */
+    imageInput?: boolean;
+}
+/**
+ * Infer model capabilities from the model ID.
+ *
+ * @param modelId - The model identifier
+ * @returns Inferred capabilities based on model name patterns
+ *
+ * @example
+ * ```ts
+ * const caps = inferKimiCodeCapabilities('kimi-k2-thinking');
+ * // caps.extendedThinking === true
+ * ```
+ */
+declare function inferKimiCodeCapabilities(modelId: string): KimiCodeCapabilities;
+/**
+ * Configuration for the Kimi Code language model.
+ * @internal
+ */
+interface KimiCodeConfig {
+    /**
+     * Provider identifier.
+     */
+    provider: string;
+    /**
+     * Base URL for the API.
+     */
+    baseURL: string;
+    /**
+     * Function to get headers for requests.
+     */
+    headers: () => Record<string, string | undefined>;
+    /**
+     * Custom fetch implementation.
+     */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * ID generator for tool call fallback IDs.
+     */
+    generateId?: () => string;
+    /**
+     * Whether to include usage in streaming responses.
+     */
+    includeUsageInStream?: boolean;
+    /**
+     * Override supported URL patterns.
+     */
+    supportedUrls?: LanguageModelV3['supportedUrls'];
+}
+/**
+ * Reasoning effort levels for extended thinking.
+ * Maps to budget_tokens for the thinking parameter.
+ *
+ * Per Roo Code docs: Enable Reasoning Effort: Medium
+ */
+type ReasoningEffort = 'low' | 'medium' | 'high';
+/**
+ * Configuration for extended thinking/reasoning.
+ * Compatible with Anthropic's thinking parameter format.
+ *
+ * @example
+ * ```ts
+ * // Enable thinking with medium effort
+ * const config: ExtendedThinkingConfig = {
+ *   enabled: true,
+ *   effort: 'medium'
+ * };
+ *
+ * // Or specify exact budget tokens
+ * const config: ExtendedThinkingConfig = {
+ *   enabled: true,
+ *   budgetTokens: 10000
+ * };
+ * ```
+ */
+interface ExtendedThinkingConfig {
+    /**
+     * Enable extended thinking mode.
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Reasoning effort level.
+     * Controls how much computation is spent on reasoning.
+     * - low: ~2048 tokens
+     * - medium: ~8192 tokens (default, recommended by Roo Code)
+     * - high: ~16384 tokens
+     * @default 'medium'
+     */
+    effort?: ReasoningEffort;
+    /**
+     * Budget tokens for thinking (alternative to effort).
+     * Higher values allow for more complex reasoning.
+     * Takes precedence over effort if both are specified.
+     */
+    budgetTokens?: number;
+}
+
+/**
+ * Settings for the Kimi Code provider.
+ *
+ * @remarks
+ * Kimi Code is compatible with Claude Code and Roo Code agents.
+ * Default settings are based on Roo Code documentation:
+ * - Max Output Tokens: 32768
+ * - Context Window Size: 262144
+ * - Reasoning Effort: Medium
+ *
+ * @see https://www.kimi.com/code/docs/en/more/third-party-agents.html
+ * @module
+ */
+
+/**
+ * Settings for creating a Kimi Code model instance.
+ */
+interface KimiCodeSettings {
+    /**
+     * Override inferred model capabilities.
+     */
+    capabilities?: KimiCodeCapabilities;
+    /**
+     * Extended thinking/reasoning configuration.
+     * When enabled, the model will show its reasoning process.
+     *
+     * @example
+     * ```ts
+     * const model = kimiCode('kimi-for-coding', {
+     *   extendedThinking: {
+     *     enabled: true,
+     *     effort: 'high'
+     *   }
+     * });
+     * ```
+     */
+    extendedThinking?: ExtendedThinkingConfig | boolean;
+    /**
+     * Whether to include usage in streaming responses.
+     */
+    includeUsageInStream?: boolean;
+    /**
+     * Override supported URL patterns.
+     */
+    supportedUrls?: Record<string, RegExp[]>;
+}
+/**
+ * Schema for Kimi Code provider options passed via providerOptions.
+ */
+declare const kimiCodeProviderOptionsSchema: z.ZodObject<{
+    extendedThinking: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
+        budgetTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+    system: z.ZodOptional<z.ZodString>;
+    stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Inferred type from the provider options schema.
+ */
+type KimiCodeProviderOptions = z.infer<typeof kimiCodeProviderOptionsSchema>;
+
+/**
+ * Kimi Code provider factory.
+ * @module
+ */
+
+/**
+ * Settings for creating a Kimi Code provider instance.
+ */
+interface KimiCodeProviderSettings {
+    /**
+     * Kimi Code API key. Defaults to the KIMI_CODE_API_KEY or KIMI_API_KEY environment variable.
+     */
+    apiKey?: string;
+    /**
+     * Base URL override. Defaults to https://api.kimi.com/coding/v1
+     */
+    baseURL?: string;
+    /**
+     * Default headers for all requests.
+     */
+    headers?: Record<string, string | undefined>;
+    /**
+     * Custom fetch implementation.
+     */
+    fetch?: FetchFunction;
+    /**
+     * ID generator for tool call fallback IDs.
+     */
+    generateId?: () => string;
+    /**
+     * Include usage details in streaming responses.
+     */
+    includeUsageInStream?: boolean;
+    /**
+     * Override supported URL patterns for file parts.
+     */
+    supportedUrls?: LanguageModelV3['supportedUrls'];
+}
+/**
+ * The Kimi Code provider interface.
+ */
+interface KimiCodeProvider extends Omit<ProviderV3, 'specificationVersion'> {
+    specificationVersion: 'v3';
+    /**
+     * Creates a Kimi Code language model.
+     * @param modelId - The model identifier (defaults to 'kimi-for-coding')
+     * @param settings - Optional model settings
+     */
+    (modelId?: KimiCodeModelId, settings?: KimiCodeSettings): LanguageModelV3;
+    /**
+     * Creates a Kimi Code language model.
+     * @param modelId - The model identifier
+     * @param settings - Optional model settings
+     */
+    languageModel(modelId: KimiCodeModelId, settings?: KimiCodeSettings): LanguageModelV3;
+    /**
+     * Creates a Kimi Code language model (alias for languageModel).
+     * @param modelId - The model identifier
+     * @param settings - Optional model settings
+     */
+    chat(modelId: KimiCodeModelId, settings?: KimiCodeSettings): LanguageModelV3;
+}
+/**
+ * Create a Kimi Code provider instance.
+ *
+ * @param options - Provider settings
+ * @returns A configured Kimi Code provider
+ *
+ * @example
+ * ```ts
+ * import { createKimiCode } from 'ai-sdk-provider-kimi';
+ *
+ * const kimiCode = createKimiCode({
+ *   apiKey: process.env.KIMI_CODE_API_KEY,
+ * });
+ *
+ * const result = await generateText({
+ *   model: kimiCode(), // Uses default 'kimi-for-coding' model
+ *   prompt: 'Write a TypeScript function to merge two sorted arrays',
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With extended thinking enabled
+ * const result = await generateText({
+ *   model: kimiCode('kimi-for-coding', {
+ *     extendedThinking: {
+ *       enabled: true,
+ *       effort: 'high'
+ *     }
+ *   }),
+ *   prompt: 'Design a distributed cache system',
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using with Claude Code compatible settings
+ * const result = await generateText({
+ *   model: kimiCode('kimi-k2-thinking'),
+ *   prompt: 'Explain and fix this bug',
+ * });
+ * ```
+ */
+declare function createKimiCode(options?: KimiCodeProviderSettings): KimiCodeProvider;
+/**
+ * Default Kimi Code provider instance.
+ *
+ * Uses the KIMI_CODE_API_KEY or KIMI_API_KEY environment variable for authentication.
+ *
+ * @example
+ * ```ts
+ * import { kimiCode } from 'ai-sdk-provider-kimi';
+ *
+ * const result = await generateText({
+ *   model: kimiCode(), // Uses default model
+ *   prompt: 'Implement a binary search tree',
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With extended thinking
+ * const result = await generateText({
+ *   model: kimiCode('kimi-for-coding', { extendedThinking: true }),
+ *   prompt: 'Design a microservices architecture',
+ * });
+ * ```
+ */
+declare const kimiCode: KimiCodeProvider;
+
+/**
+ * Kimi Code language model implementation.
+ * @module
+ */
+
+/**
+ * Kimi Code language model implementing LanguageModelV3.
+ */
+declare class KimiCodeLanguageModel implements LanguageModelV3 {
+    readonly specificationVersion = "v3";
+    readonly modelId: KimiCodeModelId;
+    private readonly config;
+    private readonly settings;
+    private readonly generateIdFn;
+    constructor(modelId: KimiCodeModelId, settings: KimiCodeSettings, config: KimiCodeConfig);
+    get provider(): string;
+    private get providerOptionsName();
+    /**
+     * Get the inferred or configured capabilities for this model.
+     */
+    get capabilities(): KimiCodeCapabilities;
+    get supportedUrls(): Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>>;
+    /**
+     * Build request arguments.
+     */
+    private getArgs;
+    doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
+    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 };