kimi-vercel-ai-sdk-provider 0.2.0

package/dist/index.mjs

@@ -0,0 +1,2734 @@
+// src/kimi-provider.ts
+import { NoSuchModelError } from "@ai-sdk/provider";
+import {
+  loadApiKey,
+  loadOptionalSetting,
+  withUserAgentSuffix,
+  withoutTrailingSlash
+} from "@ai-sdk/provider-utils";
+
+// src/chat/kimi-chat-language-model.ts
+import {
+  InvalidResponseDataError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  isParsableJson,
+  parseProviderOptions,
+  postJsonToApi,
+  removeUndefinedEntries
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
+
+// src/core/errors.ts
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var kimiErrorSchema = z.union([
+  z.object({
+    error: z.object({
+      message: z.string(),
+      type: z.string().nullish(),
+      param: z.any().nullish(),
+      code: z.union([z.string(), z.number()]).nullish(),
+      request_id: z.string().nullish()
+    })
+  }),
+  z.object({
+    message: z.string()
+  })
+]);
+var kimiFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: kimiErrorSchema,
+  errorToMessage: (error) => {
+    if ("error" in error) {
+      return error.error.message;
+    }
+    return error.message;
+  },
+  isRetryable: (response) => response.status === 408 || response.status === 409 || response.status === 429 || response.status >= 500
+});
+var KimiError = class extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.name = "KimiError";
+    this.code = code;
+    this.statusCode = statusCode;
+  }
+};
+var KimiAuthenticationError = class extends KimiError {
+  constructor(message = "Invalid API key or authentication failed") {
+    super(message, "authentication_error", 401);
+    this.name = "KimiAuthenticationError";
+  }
+};
+var KimiRateLimitError = class extends KimiError {
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, "rate_limit_error", 429);
+    this.name = "KimiRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var KimiValidationError = class extends KimiError {
+  constructor(message, param) {
+    super(param ? `${message} (param: ${param})` : message, "validation_error", 400);
+    this.name = "KimiValidationError";
+  }
+};
+var KimiModelNotFoundError = class extends KimiError {
+  constructor(modelId) {
+    super(`Model '${modelId}' not found`, "model_not_found", 404);
+    this.name = "KimiModelNotFoundError";
+    this.modelId = modelId;
+  }
+};
+var KimiContentFilterError = class extends KimiError {
+  constructor(message = "Content was filtered due to policy violation") {
+    super(message, "content_filter", 400);
+    this.name = "KimiContentFilterError";
+  }
+};
+var KimiContextLengthError = class extends KimiError {
+  constructor(message = "Context length exceeded") {
+    super(message, "context_length_exceeded", 400);
+    this.name = "KimiContextLengthError";
+  }
+};
+
+// src/core/types.ts
+function inferModelCapabilities(modelId) {
+  const isThinkingModel = modelId.includes("-thinking");
+  const isK25Model = modelId.includes("k2.5") || modelId.includes("k2-5");
+  return {
+    thinking: isThinkingModel,
+    alwaysThinking: isThinkingModel,
+    imageInput: true,
+    // All Kimi models support images
+    videoInput: isK25Model,
+    // Only K2.5 models support video
+    maxContextSize: 256e3,
+    // 256k context window
+    toolCalling: true,
+    jsonMode: true,
+    structuredOutputs: true
+  };
+}
+
+// src/core/utils.ts
+function mapKimiFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+function convertKimiUsage(usage, webSearchTokens, codeInterpreterTokens) {
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      },
+      raw: void 0,
+      ...webSearchTokens != null ? { webSearchTokens } : {},
+      ...codeInterpreterTokens != null ? { codeInterpreterTokens } : {}
+    };
+  }
+  const promptTokens = usage.prompt_tokens ?? 0;
+  const completionTokens = usage.completion_tokens ?? 0;
+  const cacheReadTokens = usage.prompt_tokens_details?.cached_tokens ?? 0;
+  const reasoningTokens = usage.completion_tokens_details?.reasoning_tokens ?? 0;
+  const rawUsage = {
+    prompt_tokens: usage.prompt_tokens ?? void 0,
+    completion_tokens: usage.completion_tokens ?? void 0,
+    total_tokens: usage.total_tokens ?? void 0,
+    ...usage.prompt_tokens_details ? {
+      prompt_tokens_details: {
+        cached_tokens: usage.prompt_tokens_details.cached_tokens ?? void 0
+      }
+    } : {},
+    ...usage.completion_tokens_details ? {
+      completion_tokens_details: {
+        reasoning_tokens: usage.completion_tokens_details.reasoning_tokens ?? void 0
+      }
+    } : {}
+  };
+  return {
+    inputTokens: {
+      total: promptTokens,
+      noCache: promptTokens - cacheReadTokens,
+      cacheRead: cacheReadTokens,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: completionTokens,
+      text: completionTokens - reasoningTokens,
+      reasoning: reasoningTokens
+    },
+    raw: rawUsage,
+    ...webSearchTokens != null ? { webSearchTokens } : {},
+    ...codeInterpreterTokens != null ? { codeInterpreterTokens } : {}
+  };
+}
+function getResponseMetadata(response) {
+  return {
+    id: response.id ?? void 0,
+    modelId: response.model ?? void 0,
+    timestamp: response.created != null ? new Date(response.created * 1e3) : void 0
+  };
+}
+function getKimiRequestId(headers) {
+  if (!headers) {
+    return void 0;
+  }
+  const lowerHeaders = Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+  return lowerHeaders["x-request-id"] || lowerHeaders["x-trace-id"] || lowerHeaders["x-moonshot-request-id"];
+}
+function extractMessageContent(message) {
+  let text = "";
+  let reasoning = "";
+  if (typeof message.content === "string") {
+    text = message.content;
+  } else if (Array.isArray(message.content)) {
+    for (const part of message.content) {
+      if (part && typeof part === "object") {
+        const candidate = part;
+        if (candidate.type === "text" && typeof candidate.text === "string") {
+          text += candidate.text;
+        }
+        if (candidate.type === "thinking" && typeof candidate.thinking === "string") {
+          reasoning += candidate.thinking;
+        }
+        if (candidate.type === "reasoning" && typeof candidate.text === "string") {
+          reasoning += candidate.text;
+        }
+      }
+    }
+  }
+  if (typeof message.reasoning_content === "string") {
+    reasoning += message.reasoning_content;
+  }
+  if (typeof message.reasoning === "string") {
+    reasoning += message.reasoning;
+  }
+  return { text, reasoning };
+}
+
+// src/tools/builtin-tools.ts
+var KIMI_WEB_SEARCH_TOOL_NAME = "$web_search";
+var KIMI_CODE_INTERPRETER_TOOL_NAME = "$code";
+function createWebSearchTool(config) {
+  return {
+    type: "builtin_function",
+    function: {
+      name: KIMI_WEB_SEARCH_TOOL_NAME,
+      ...config ? { config } : {}
+    }
+  };
+}
+function createKimiWebSearchTool(config) {
+  return createWebSearchTool(config);
+}
+function createCodeInterpreterTool(config) {
+  return {
+    type: "builtin_function",
+    function: {
+      name: KIMI_CODE_INTERPRETER_TOOL_NAME,
+      ...config ? { config } : {}
+    }
+  };
+}
+function isBuiltinToolName(toolName) {
+  return toolName.startsWith("$");
+}
+var 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) => {
+    return {
+      type: "provider",
+      id: "kimi.webSearch",
+      args: createWebSearchTool(config)
+    };
+  },
+  /**
+   * 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) => {
+    return {
+      type: "provider",
+      id: "kimi.codeInterpreter",
+      args: createCodeInterpreterTool(config)
+    };
+  }
+};
+
+// src/tools/prepare-tools.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+function prepareKimiTools({
+  tools,
+  toolChoice,
+  webSearch,
+  codeInterpreter,
+  toolChoicePolyfill = true
+}) {
+  tools = tools?.length ? tools : void 0;
+  const toolWarnings = [];
+  const kimiTools2 = [];
+  if (webSearch) {
+    const config = typeof webSearch === "boolean" ? void 0 : webSearch.config;
+    kimiTools2.push(createWebSearchTool(config));
+  }
+  if (codeInterpreter) {
+    const config = typeof codeInterpreter === "boolean" ? void 0 : codeInterpreter.config;
+    kimiTools2.push(createCodeInterpreterTool(config));
+  }
+  if (tools != null) {
+    for (const tool of tools) {
+      if (tool.type === "provider") {
+        const builtinTool = tryConvertToKimiBuiltinTool(tool);
+        if (builtinTool) {
+          kimiTools2.push(builtinTool);
+          continue;
+        }
+        toolWarnings.push({
+          type: "unsupported",
+          feature: `provider-defined tool ${tool.id}`
+        });
+        continue;
+      }
+      kimiTools2.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          ...tool.strict != null ? { strict: tool.strict } : {}
+        }
+      });
+    }
+  }
+  if (kimiTools2.length === 0) {
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
+  }
+  if (toolChoice == null) {
+    return { tools: kimiTools2, toolChoice: void 0, toolWarnings };
+  }
+  switch (toolChoice.type) {
+    case "auto":
+    case "none":
+      return { tools: kimiTools2, toolChoice: toolChoice.type, toolWarnings };
+    case "required": {
+      if (toolChoicePolyfill) {
+        const toolNames = kimiTools2.map((t) => t.type === "function" ? t.function.name : t.function.name).join(", ");
+        const systemMessage = generateRequiredToolMessage(toolNames);
+        toolWarnings.push({
+          type: "compatibility",
+          feature: "toolChoice.required",
+          details: "Using tool choice polyfill with system message injection."
+        });
+        return {
+          tools: kimiTools2,
+          toolChoice: "auto",
+          toolWarnings,
+          toolChoiceSystemMessage: systemMessage
+        };
+      }
+      toolWarnings.push({
+        type: "compatibility",
+        feature: "toolChoice.required",
+        details: "Moonshot does not support required tool choice. Falling back to auto."
+      });
+      return { tools: kimiTools2, toolChoice: "auto", toolWarnings };
+    }
+    case "tool": {
+      if (toolChoicePolyfill) {
+        const systemMessage = generateSpecificToolMessage(toolChoice.toolName);
+        toolWarnings.push({
+          type: "compatibility",
+          feature: `toolChoice.tool:${toolChoice.toolName}`,
+          details: "Using tool choice polyfill with system message injection."
+        });
+        return {
+          tools: kimiTools2,
+          toolChoice: "auto",
+          toolWarnings,
+          toolChoiceSystemMessage: systemMessage
+        };
+      }
+      toolWarnings.push({
+        type: "compatibility",
+        feature: `toolChoice.tool:${toolChoice.toolName}`,
+        details: "Moonshot does not support forcing a specific tool. Falling back to auto."
+      });
+      return { tools: kimiTools2, toolChoice: "auto", toolWarnings };
+    }
+    default: {
+      const _exhaustiveCheck = toolChoice;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+function generateRequiredToolMessage(toolNames) {
+  return `IMPORTANT INSTRUCTION: You MUST use one of the available tools (${toolNames}) to respond to the user's request. Do NOT provide a direct text response without first calling a tool. Always invoke a tool to complete this task.`;
+}
+function generateSpecificToolMessage(toolName) {
+  return `IMPORTANT INSTRUCTION: You MUST use the "${toolName}" tool to respond to this request. Do NOT use any other tool or provide a direct text response. Call the "${toolName}" tool with appropriate parameters.`;
+}
+function tryConvertToKimiBuiltinTool(tool) {
+  if (!tool.id.startsWith("kimi.")) {
+    return void 0;
+  }
+  const args = tool.args;
+  if (args && typeof args === "object" && "type" in args && args.type === "builtin_function" && "function" in args && typeof args.function === "object") {
+    const fn = args.function;
+    if (typeof fn.name === "string") {
+      return {
+        type: "builtin_function",
+        function: {
+          name: fn.name,
+          ...fn.config ? { config: fn.config } : {}
+        }
+      };
+    }
+  }
+  return void 0;
+}
+
+// src/chat/kimi-chat-messages.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
+import { convertToBase64 } from "@ai-sdk/provider-utils";
+var SUPPORTED_IMAGE_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp", "image/*"];
+var SUPPORTED_VIDEO_TYPES = ["video/mp4", "video/webm", "video/ogg", "video/*"];
+function convertToKimiChatMessages(prompt) {
+  const messages = [];
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        messages.push({ role: "system", content });
+        break;
+      }
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({ role: "user", content: content[0].text });
+          break;
+        }
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            switch (part.type) {
+              case "text":
+                return { type: "text", text: part.text };
+              case "file": {
+                if (isImageMediaType(part.mediaType)) {
+                  return convertImagePart(part);
+                }
+                if (isVideoMediaType(part.mediaType)) {
+                  return convertVideoPart(part);
+                }
+                if (part.mediaType.startsWith("text/")) {
+                  const text = part.data instanceof URL ? part.data.toString() : typeof part.data === "string" ? part.data : new TextDecoder().decode(part.data);
+                  return { type: "text", text };
+                }
+                throw new UnsupportedFunctionalityError2({
+                  functionality: `file part media type ${part.mediaType}`
+                });
+              }
+              default: {
+                const _exhaustiveCheck = part;
+                throw new Error(`Unsupported part type: ${_exhaustiveCheck}`);
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        let reasoning = "";
+        const toolCalls = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "reasoning": {
+              reasoning += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                }
+              });
+              break;
+            }
+            case "file": {
+              break;
+            }
+            case "tool-result": {
+              break;
+            }
+            default: {
+              const _exhaustiveCheck = part;
+              throw new Error(`Unsupported assistant part: ${_exhaustiveCheck}`);
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: text.length > 0 ? text : null,
+          ...reasoning.length > 0 ? { reasoning_content: reasoning } : {},
+          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          if (toolResponse.type === "tool-approval-response") {
+            continue;
+          }
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: serializeToolResult(toolResponse)
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return messages;
+}
+function isImageMediaType(mediaType) {
+  return mediaType.startsWith("image/") || SUPPORTED_IMAGE_TYPES.includes(mediaType);
+}
+function isVideoMediaType(mediaType) {
+  return mediaType.startsWith("video/") || SUPPORTED_VIDEO_TYPES.includes(mediaType);
+}
+function convertImagePart(part) {
+  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+  const url = part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`;
+  return { type: "image_url", image_url: { url } };
+}
+function convertVideoPart(part) {
+  if (!(part.data instanceof URL)) {
+    throw new UnsupportedFunctionalityError2({
+      functionality: "inline video data (video must be provided as a URL)"
+    });
+  }
+  return { type: "video_url", video_url: { url: part.data.toString() } };
+}
+function serializeToolResult(toolResponse) {
+  const { toolName } = toolResponse;
+  const output = toolResponse.output;
+  if (isBuiltinToolName(toolName)) {
+    return serializeBuiltinToolResult(output);
+  }
+  switch (output.type) {
+    case "text":
+    case "error-text":
+      return output.value;
+    case "execution-denied":
+      return output.reason ?? "Tool execution denied.";
+    case "json":
+    case "error-json":
+    case "content":
+      return JSON.stringify(output.value);
+    default: {
+      const _exhaustiveCheck = output;
+      return JSON.stringify(_exhaustiveCheck);
+    }
+  }
+}
+function serializeBuiltinToolResult(output) {
+  switch (output.type) {
+    case "text":
+    case "error-text":
+      return output.value;
+    case "json":
+    case "error-json":
+    case "content":
+      return JSON.stringify(output.value);
+    case "execution-denied":
+      return output.reason ?? "Tool execution denied.";
+    default: {
+      const _exhaustiveCheck = output;
+      return JSON.stringify(_exhaustiveCheck);
+    }
+  }
+}
+
+// src/chat/kimi-chat-response.ts
+function extractWebSearchTokens(toolCalls) {
+  return extractBuiltinToolTokens(toolCalls, KIMI_WEB_SEARCH_TOOL_NAME);
+}
+function extractCodeInterpreterTokens(toolCalls) {
+  return extractBuiltinToolTokens(toolCalls, KIMI_CODE_INTERPRETER_TOOL_NAME);
+}
+function extractBuiltinToolTokens(toolCalls, toolName) {
+  if (!toolCalls) {
+    return void 0;
+  }
+  let totalTokens = 0;
+  let foundTool = false;
+  for (const toolCall of toolCalls) {
+    if (toolCall.function.name === toolName) {
+      foundTool = true;
+      if (toolCall.function.arguments) {
+        try {
+          const args = JSON.parse(toolCall.function.arguments);
+          if (typeof args.total_tokens === "number") {
+            totalTokens += args.total_tokens;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return foundTool ? totalTokens : void 0;
+}
+
+// src/chat/kimi-chat-settings.ts
+import { z as z2 } from "zod/v4";
+var kimiCachingConfigSchema = z2.object({
+  enabled: z2.boolean(),
+  cacheKey: z2.string().optional(),
+  ttlSeconds: z2.number().optional(),
+  resetCache: z2.boolean().optional()
+});
+var kimiProviderOptionsSchema = z2.object({
+  /**
+   * A unique identifier representing your end-user.
+   */
+  user: z2.string().optional(),
+  /**
+   * Whether to use strict JSON schema validation when supported.
+   */
+  strictJsonSchema: z2.boolean().optional(),
+  /**
+   * Optional request ID to correlate logs.
+   */
+  requestId: z2.string().optional(),
+  /**
+   * Optional extra headers for this call.
+   */
+  extraHeaders: z2.record(z2.string(), z2.string()).optional(),
+  /**
+   * Whether the provider should allow parallel tool calls.
+   */
+  parallelToolCalls: z2.boolean().optional(),
+  /**
+   * Enable or configure the built-in web search tool for this request.
+   * This allows Kimi to search the web to help answer questions.
+   */
+  webSearch: z2.union([
+    z2.boolean(),
+    z2.object({
+      enabled: z2.boolean(),
+      config: z2.object({
+        search_result: z2.boolean().optional()
+      }).optional()
+    })
+  ]).optional(),
+  /**
+   * Enable or configure the built-in code interpreter tool for this request.
+   * This allows Kimi to execute code to help solve problems.
+   */
+  codeInterpreter: z2.union([
+    z2.boolean(),
+    z2.object({
+      enabled: z2.boolean(),
+      config: z2.object({
+        timeout: z2.number().optional(),
+        include_output: z2.boolean().optional()
+      }).optional()
+    })
+  ]).optional(),
+  /**
+   * Enable or configure context caching for this request.
+   * Reduces costs for repeated long prompts.
+   */
+  caching: z2.union([z2.boolean(), kimiCachingConfigSchema]).optional(),
+  /**
+   * Enable tool choice polyfill for this request.
+   */
+  toolChoicePolyfill: z2.boolean().optional()
+});
+
+// src/chat/kimi-chat-language-model.ts
+var KimiChatLanguageModel = class {
+  constructor(modelId, settings, config) {
+    this.specificationVersion = "v3";
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+    this.generateIdFn = config.generateId ?? generateId;
+    this.supportsStructuredOutputs = config.supportsStructuredOutputs ?? false;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  /**
+   * Get the inferred or configured capabilities for this model.
+   */
+  get capabilities() {
+    const inferred = inferModelCapabilities(this.modelId);
+    return {
+      ...inferred,
+      ...this.settings.capabilities
+    };
+  }
+  get supportedUrls() {
+    const caps = this.capabilities;
+    const patterns = {
+      "image/*": [/^https?:\/\/.*$/i]
+    };
+    if (caps.videoInput) {
+      patterns["video/*"] = [/^https?:\/\/.*$/i];
+    }
+    return this.settings.supportedUrls ?? this.config.supportedUrls ?? patterns;
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    responseFormat,
+    seed,
+    providerOptions,
+    tools,
+    toolChoice
+  }) {
+    const warnings = [];
+    const deprecatedOptions = await parseProviderOptions({
+      provider: "moonshot",
+      providerOptions,
+      schema: kimiProviderOptionsSchema
+    });
+    if (deprecatedOptions != null) {
+      warnings.push({
+        type: "other",
+        message: "The 'moonshot' key in providerOptions is deprecated. Use 'kimi' instead."
+      });
+    }
+    const providerOptionsName = this.providerOptionsName;
+    const kimiOptions = await parseProviderOptions({
+      provider: providerOptionsName,
+      providerOptions,
+      schema: kimiProviderOptionsSchema
+    });
+    const options = {
+      ...deprecatedOptions ?? {},
+      ...kimiOptions ?? {}
+    };
+    if (topK != null) {
+      warnings.push({ type: "unsupported", feature: "topK" });
+    }
+    const strictJsonSchema = options.strictJsonSchema ?? true;
+    if (responseFormat?.type === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
+      warnings.push({
+        type: "unsupported",
+        feature: "responseFormat",
+        details: "JSON schema response format requires structured outputs support."
+      });
+    }
+    const webSearch = resolveBuiltinToolConfig(this.settings.webSearch, options.webSearch);
+    const codeInterpreter = resolveBuiltinToolConfig(this.settings.codeInterpreter, options.codeInterpreter);
+    const toolChoicePolyfill = options.toolChoicePolyfill ?? this.settings.toolChoicePolyfill ?? true;
+    const {
+      tools: kimiTools2,
+      toolChoice: kimiToolChoice,
+      toolWarnings,
+      toolChoiceSystemMessage
+    } = prepareKimiTools({
+      tools,
+      toolChoice,
+      webSearch,
+      codeInterpreter,
+      toolChoicePolyfill
+    });
+    const caching = resolveCachingConfig(this.settings.caching, options.caching);
+    const cachingHeaders = buildCachingHeaders(caching);
+    const passthroughOptions = getPassthroughOptions({
+      providerOptions,
+      providerOptionsName,
+      deprecatedProviderOptionsName: "moonshot",
+      knownKeys: Object.keys(kimiProviderOptionsSchema.shape)
+    });
+    const messages = convertToKimiChatMessages(prompt);
+    if (toolChoiceSystemMessage) {
+      messages.unshift({ role: "system", content: toolChoiceSystemMessage });
+    }
+    const body = removeUndefinedEntries({
+      model: this.modelId,
+      messages,
+      max_tokens: maxOutputTokens,
+      temperature,
+      top_p: topP,
+      frequency_penalty: frequencyPenalty,
+      presence_penalty: presencePenalty,
+      stop: stopSequences,
+      seed,
+      response_format: responseFormat?.type === "json" ? this.supportsStructuredOutputs && responseFormat.schema != null ? {
+        type: "json_schema",
+        json_schema: {
+          schema: responseFormat.schema,
+          strict: strictJsonSchema,
+          name: responseFormat.name ?? "response",
+          description: responseFormat.description
+        }
+      } : { type: "json_object" } : void 0,
+      tools: kimiTools2,
+      tool_choice: kimiToolChoice,
+      user: options.user,
+      ...kimiTools2 != null && options.parallelToolCalls != null ? { parallel_tool_calls: options.parallelToolCalls } : {},
+      ...passthroughOptions
+    });
+    const requestHeaders = {
+      ...options.requestId ? { "X-Request-ID": options.requestId } : {},
+      ...options.extraHeaders ?? {},
+      ...cachingHeaders
+    };
+    return {
+      body,
+      warnings: [...warnings, ...toolWarnings],
+      requestHeaders
+    };
+  }
+  async doGenerate(options) {
+    const { body, warnings, requestHeaders } = await this.getArgs(options);
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await postJsonToApi({
+      url: `${this.config.baseURL}/chat/completions`,
+      headers: combineHeaders(this.config.headers(), requestHeaders, options.headers),
+      body,
+      failedResponseHandler: kimiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(kimiChatResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = response.choices[0];
+    const content = [];
+    const { text, reasoning } = extractMessageContent(choice.message);
+    if (reasoning.length > 0) {
+      content.push({ type: "reasoning", text: reasoning });
+    }
+    if (text.length > 0) {
+      content.push({ type: "text", text });
+    }
+    if (choice.message.tool_calls != null) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: toolCall.id ?? this.generateIdFn(),
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments ?? ""
+        });
+      }
+    }
+    const webSearchTokens = extractWebSearchTokens(choice.message.tool_calls);
+    const codeInterpreterTokens = extractCodeInterpreterTokens(choice.message.tool_calls);
+    const providerMetadata = buildProviderMetadata({
+      providerOptionsName: this.providerOptionsName,
+      responseHeaders,
+      webSearchTokens,
+      codeInterpreterTokens
+    });
+    return {
+      content,
+      finishReason: {
+        unified: mapKimiFinishReason(choice.finish_reason),
+        raw: choice.finish_reason ?? void 0
+      },
+      usage: convertKimiUsage(response.usage, webSearchTokens, codeInterpreterTokens),
+      ...providerMetadata ? { providerMetadata } : {},
+      request: { body },
+      response: {
+        ...getResponseMetadata(response),
+        headers: responseHeaders,
+        body: rawValue
+      },
+      warnings
+    };
+  }
+  async doStream(options) {
+    const { body, warnings, requestHeaders } = await this.getArgs(options);
+    const streamBody = {
+      ...body,
+      stream: true,
+      stream_options: this.config.includeUsageInStream ? { include_usage: true } : void 0
+    };
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: `${this.config.baseURL}/chat/completions`,
+      headers: combineHeaders(this.config.headers(), requestHeaders, options.headers),
+      body: streamBody,
+      failedResponseHandler: kimiFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(kimiChatChunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const requestId = getKimiRequestId(responseHeaders);
+    let finishReason = {
+      unified: "other",
+      raw: void 0
+    };
+    let usage;
+    let isFirstChunk = true;
+    let isActiveText = false;
+    let isActiveReasoning = false;
+    const toolCalls = [];
+    const providerOptionsName = this.providerOptionsName;
+    const _generateIdFn = this.generateIdFn;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
+            if (!chunk.success) {
+              finishReason = { unified: "error", raw: void 0 };
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            if ("error" in chunk.value) {
+              finishReason = { unified: "error", raw: void 0 };
+              const error = chunk.value.error;
+              controller.enqueue({
+                type: "error",
+                error: error?.message ?? chunk.value
+              });
+              return;
+            }
+            const value = chunk.value;
+            if (isFirstChunk) {
+              isFirstChunk = false;
+              controller.enqueue({
+                type: "response-metadata",
+                ...getResponseMetadata(value)
+              });
+            }
+            if (value.usage != null) {
+              usage = value.usage;
+            }
+            const choice = value.choices[0];
+            if (!choice) {
+              return;
+            }
+            if (choice.finish_reason != null) {
+              finishReason = {
+                unified: mapKimiFinishReason(choice.finish_reason),
+                raw: choice.finish_reason ?? void 0
+              };
+            }
+            const delta = choice.delta;
+            if (!delta) {
+              return;
+            }
+            const reasoningDelta = delta.reasoning_content ?? delta.reasoning;
+            if (reasoningDelta) {
+              if (!isActiveReasoning) {
+                if (isActiveText) {
+                  controller.enqueue({ type: "text-end", id: "text-0" });
+                  isActiveText = false;
+                }
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: "reasoning-0"
+                });
+                isActiveReasoning = true;
+              }
+              controller.enqueue({
+                type: "reasoning-delta",
+                id: "reasoning-0",
+                delta: reasoningDelta
+              });
+            }
+            if (delta.content) {
+              if (isActiveReasoning) {
+                controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+                isActiveReasoning = false;
+              }
+              if (!isActiveText) {
+                controller.enqueue({ type: "text-start", id: "text-0" });
+                isActiveText = true;
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: "text-0",
+                delta: delta.content
+              });
+            }
+            if (delta.tool_calls != null) {
+              if (isActiveReasoning) {
+                controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+                isActiveReasoning = false;
+              }
+              for (const toolCallDelta of delta.tool_calls) {
+                const index = toolCallDelta.index ?? toolCalls.length;
+                if (toolCalls[index] == null) {
+                  if (toolCallDelta.id == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: "Expected 'id' to be a string."
+                    });
+                  }
+                  if (toolCallDelta.function?.name == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: "Expected 'function.name' to be a string."
+                    });
+                  }
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCallDelta.id,
+                    toolName: toolCallDelta.function.name
+                  });
+                  toolCalls[index] = {
+                    id: toolCallDelta.id,
+                    type: "function",
+                    function: {
+                      name: toolCallDelta.function.name,
+                      arguments: toolCallDelta.function.arguments ?? ""
+                    },
+                    hasFinished: false
+                  };
+                  const toolCall2 = toolCalls[index];
+                  if (toolCall2.function.arguments.length > 0) {
+                    controller.enqueue({
+                      type: "tool-input-delta",
+                      id: toolCall2.id,
+                      delta: toolCall2.function.arguments
+                    });
+                  }
+                  if (isParsableJson(toolCall2.function.arguments)) {
+                    controller.enqueue({ type: "tool-input-end", id: toolCall2.id });
+                    controller.enqueue({
+                      type: "tool-call",
+                      toolCallId: toolCall2.id,
+                      toolName: toolCall2.function.name,
+                      input: toolCall2.function.arguments
+                    });
+                    toolCall2.hasFinished = true;
+                  }
+                  continue;
+                }
+                const toolCall = toolCalls[index];
+                if (toolCall.hasFinished) {
+                  continue;
+                }
+                if (toolCallDelta.function?.arguments != null) {
+                  toolCall.function.arguments += toolCallDelta.function.arguments;
+                }
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.id,
+                  delta: toolCallDelta.function?.arguments ?? ""
+                });
+                if (isParsableJson(toolCall.function.arguments)) {
+                  controller.enqueue({ type: "tool-input-end", id: toolCall.id });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.function.name,
+                    input: toolCall.function.arguments
+                  });
+                  toolCall.hasFinished = true;
+                }
+              }
+            }
+          },
+          flush(controller) {
+            if (isActiveReasoning) {
+              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+              isActiveReasoning = false;
+            }
+            if (isActiveText) {
+              controller.enqueue({ type: "text-end", id: "text-0" });
+              isActiveText = false;
+            }
+            for (const toolCall of toolCalls.filter((call) => !call.hasFinished)) {
+              controller.enqueue({ type: "tool-input-end", id: toolCall.id });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: toolCall.id,
+                toolName: toolCall.function.name,
+                input: toolCall.function.arguments
+              });
+            }
+            const webSearchTokens = extractWebSearchTokens(toolCalls);
+            const codeInterpreterTokens = extractCodeInterpreterTokens(toolCalls);
+            const providerMetadata = requestId || webSearchTokens != null || codeInterpreterTokens != null ? {
+              [providerOptionsName]: {
+                ...requestId ? { requestId } : {},
+                ...webSearchTokens != null ? { webSearchTokens } : {},
+                ...codeInterpreterTokens != null ? { codeInterpreterTokens } : {}
+              }
+            } : void 0;
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage: convertKimiUsage(usage, webSearchTokens, codeInterpreterTokens),
+              ...providerMetadata ? { providerMetadata } : {}
+            });
+          }
+        })
+      ),
+      request: { body: streamBody },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+function buildProviderMetadata({
+  providerOptionsName,
+  responseHeaders,
+  webSearchTokens,
+  codeInterpreterTokens
+}) {
+  const requestId = getKimiRequestId(responseHeaders);
+  if (!requestId && webSearchTokens == null && codeInterpreterTokens == null) {
+    return void 0;
+  }
+  return {
+    [providerOptionsName]: {
+      ...requestId ? { requestId } : {},
+      ...webSearchTokens != null ? { webSearchTokens } : {},
+      ...codeInterpreterTokens != null ? { codeInterpreterTokens } : {}
+    }
+  };
+}
+function getPassthroughOptions({
+  providerOptions,
+  providerOptionsName,
+  deprecatedProviderOptionsName,
+  knownKeys
+}) {
+  const rawOptions = [providerOptions?.[deprecatedProviderOptionsName], providerOptions?.[providerOptionsName]].filter(
+    (entry) => entry != null && typeof entry === "object"
+  );
+  const passthrough = {};
+  for (const options of rawOptions) {
+    for (const [key, value] of Object.entries(options ?? {})) {
+      if (!knownKeys.includes(key)) {
+        passthrough[key] = value;
+      }
+    }
+  }
+  return passthrough;
+}
+function resolveBuiltinToolConfig(settingsConfig, optionsConfig) {
+  if (optionsConfig != null) {
+    if (typeof optionsConfig === "boolean") {
+      return optionsConfig ? { enabled: true } : void 0;
+    }
+    const config = optionsConfig;
+    return config.enabled ? optionsConfig : void 0;
+  }
+  if (settingsConfig != null) {
+    if (typeof settingsConfig === "boolean") {
+      return settingsConfig ? { enabled: true } : void 0;
+    }
+    const config = settingsConfig;
+    return config.enabled ? settingsConfig : void 0;
+  }
+  return void 0;
+}
+function resolveCachingConfig(settingsConfig, optionsConfig) {
+  const config = optionsConfig ?? settingsConfig;
+  if (config == null) {
+    return void 0;
+  }
+  if (typeof config === "boolean") {
+    return config ? { enabled: true } : void 0;
+  }
+  return config.enabled ? config : void 0;
+}
+function buildCachingHeaders(caching) {
+  if (!caching?.enabled) {
+    return {};
+  }
+  const headers = {
+    "X-Kimi-Cache": "enabled"
+  };
+  if (caching.cacheKey) {
+    headers["X-Kimi-Cache-Key"] = caching.cacheKey;
+  }
+  if (caching.ttlSeconds) {
+    headers["X-Kimi-Cache-TTL"] = String(caching.ttlSeconds);
+  }
+  if (caching.resetCache) {
+    headers["X-Kimi-Cache-Reset"] = "true";
+  }
+  return headers;
+}
+var kimiTokenUsageSchema = z3.object({
+  prompt_tokens: z3.number().nullish(),
+  completion_tokens: z3.number().nullish(),
+  total_tokens: z3.number().nullish(),
+  prompt_tokens_details: z3.object({
+    cached_tokens: z3.number().nullish()
+  }).nullish(),
+  completion_tokens_details: z3.object({
+    reasoning_tokens: z3.number().nullish()
+  }).nullish()
+}).nullish();
+var kimiChatResponseSchema = z3.looseObject({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      message: z3.object({
+        role: z3.string().nullish(),
+        content: z3.union([z3.string(), z3.array(z3.any())]).nullish(),
+        reasoning_content: z3.string().nullish(),
+        reasoning: z3.string().nullish(),
+        tool_calls: z3.array(
+          z3.object({
+            id: z3.string().nullish(),
+            function: z3.object({
+              name: z3.string(),
+              arguments: z3.string().nullish()
+            })
+          })
+        ).nullish()
+      }),
+      finish_reason: z3.string().nullish()
+    })
+  ),
+  usage: kimiTokenUsageSchema
+});
+var kimiChatChunkBaseSchema = z3.looseObject({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      delta: z3.object({
+        role: z3.enum(["assistant"]).nullish(),
+        content: z3.string().nullish(),
+        reasoning_content: z3.string().nullish(),
+        reasoning: z3.string().nullish(),
+        tool_calls: z3.array(
+          z3.object({
+            index: z3.number().nullish(),
+            id: z3.string().nullish(),
+            function: z3.object({
+              name: z3.string().nullish(),
+              arguments: z3.string().nullish()
+            })
+          })
+        ).nullish()
+      }).nullish(),
+      finish_reason: z3.string().nullish()
+    })
+  ),
+  usage: kimiTokenUsageSchema
+});
+var kimiChatChunkSchema = z3.union([kimiChatChunkBaseSchema, kimiErrorSchema]);
+
+// src/files/file-utils.ts
+var SUPPORTED_FILE_EXTENSIONS = [
+  // Documents
+  ".pdf",
+  ".txt",
+  ".csv",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".md",
+  ".epub",
+  ".mobi",
+  ".html",
+  ".json",
+  ".log",
+  ".dot",
+  ".ini",
+  ".conf",
+  ".yaml",
+  ".yml",
+  // Images
+  ".jpeg",
+  ".jpg",
+  ".png",
+  ".bmp",
+  ".gif",
+  ".svg",
+  ".svgz",
+  ".webp",
+  ".ico",
+  ".xbm",
+  ".dib",
+  ".pjp",
+  ".tif",
+  ".tiff",
+  ".pjpeg",
+  ".avif",
+  ".apng",
+  ".jfif",
+  // Code files
+  ".go",
+  ".h",
+  ".c",
+  ".cpp",
+  ".cxx",
+  ".cc",
+  ".cs",
+  ".java",
+  ".js",
+  ".css",
+  ".jsp",
+  ".php",
+  ".py",
+  ".py3",
+  ".asp",
+  ".ts",
+  ".tsx"
+];
+var SUPPORTED_MIME_TYPES = {
+  // Documents
+  "application/pdf": "file-extract",
+  "text/plain": "file-extract",
+  "text/csv": "file-extract",
+  "application/msword": "file-extract",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "file-extract",
+  "application/vnd.ms-excel": "file-extract",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "file-extract",
+  "application/vnd.ms-powerpoint": "file-extract",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "file-extract",
+  "text/markdown": "file-extract",
+  "text/html": "file-extract",
+  "application/json": "file-extract",
+  "application/epub+zip": "file-extract",
+  "text/yaml": "file-extract",
+  "application/x-yaml": "file-extract",
+  // Code files (treated as text)
+  "text/javascript": "file-extract",
+  "text/typescript": "file-extract",
+  "text/x-python": "file-extract",
+  "text/x-java": "file-extract",
+  "text/x-c": "file-extract",
+  "text/x-c++": "file-extract",
+  "text/css": "file-extract",
+  // Images
+  "image/jpeg": "image",
+  "image/png": "image",
+  "image/gif": "image",
+  "image/webp": "image",
+  "image/svg+xml": "image",
+  "image/bmp": "image",
+  "image/tiff": "image",
+  "image/avif": "image",
+  "image/apng": "image",
+  "image/x-icon": "image",
+  // Videos
+  "video/mp4": "video",
+  "video/webm": "video",
+  "video/ogg": "video",
+  "video/quicktime": "video"
+};
+function isImageMediaType2(mediaType) {
+  return mediaType.startsWith("image/");
+}
+function isVideoMediaType2(mediaType) {
+  return mediaType.startsWith("video/");
+}
+function isFileExtractMediaType(mediaType) {
+  if (mediaType in SUPPORTED_MIME_TYPES) {
+    return SUPPORTED_MIME_TYPES[mediaType] === "file-extract";
+  }
+  if (mediaType.startsWith("text/") || mediaType === "application/pdf") {
+    return true;
+  }
+  return false;
+}
+function isDocumentMediaType(mediaType) {
+  const documentTypes = [
+    "application/pdf",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "application/epub+zip"
+  ];
+  return documentTypes.includes(mediaType);
+}
+function getPurposeFromMediaType(mediaType) {
+  if (isImageMediaType2(mediaType)) {
+    return "image";
+  }
+  if (isVideoMediaType2(mediaType)) {
+    return "video";
+  }
+  return "file-extract";
+}
+function getMediaTypeFromExtension(extension) {
+  const ext = extension.toLowerCase().startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`;
+  const extensionToMime = {
+    // Documents
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".csv": "text/csv",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".md": "text/markdown",
+    ".html": "text/html",
+    ".json": "application/json",
+    ".epub": "application/epub+zip",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml",
+    ".log": "text/plain",
+    ".ini": "text/plain",
+    ".conf": "text/plain",
+    // Code
+    ".js": "text/javascript",
+    ".ts": "text/typescript",
+    ".tsx": "text/typescript",
+    ".py": "text/x-python",
+    ".java": "text/x-java",
+    ".c": "text/x-c",
+    ".cpp": "text/x-c++",
+    ".h": "text/x-c",
+    ".css": "text/css",
+    ".go": "text/plain",
+    ".php": "text/plain",
+    // Images
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".bmp": "image/bmp",
+    ".tif": "image/tiff",
+    ".tiff": "image/tiff",
+    ".avif": "image/avif",
+    ".apng": "image/apng",
+    ".ico": "image/x-icon",
+    // Videos
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".ogg": "video/ogg",
+    ".mov": "video/quicktime"
+  };
+  return extensionToMime[ext] ?? "application/octet-stream";
+}
+function getExtensionFromPath(path) {
+  const match = path.match(/\.([^./?#]+)(?:[?#]|$)/);
+  return match ? `.${match[1].toLowerCase()}` : null;
+}
+
+// src/files/kimi-file-client.ts
+var KimiFileClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Upload a file to the Kimi API.
+   */
+  async upload(options) {
+    const { data, filename, mediaType, purpose } = options;
+    const resolvedMediaType = mediaType ?? getMediaTypeFromExtension(getExtensionFromPath(filename) ?? "") ?? "application/octet-stream";
+    const resolvedPurpose = purpose ?? getPurposeFromMediaType(resolvedMediaType);
+    const formData = new FormData();
+    const fileData = typeof data === "string" ? base64ToUint8Array(data) : data;
+    const blob = new Blob([new Uint8Array(fileData).buffer], { type: resolvedMediaType });
+    formData.append("file", blob, filename);
+    formData.append("purpose", resolvedPurpose);
+    const fetchFn = this.config.fetch ?? fetch;
+    const headers = this.config.headers();
+    const response = await fetchFn(`${this.config.baseURL}/files`, {
+      method: "POST",
+      headers: {
+        ...Object.fromEntries(
+          Object.entries(headers).filter((entry) => entry[1] !== void 0)
+        )
+        // Don't set Content-Type - let the browser set it with boundary for FormData
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Failed to upload file: ${response.status} ${response.statusText} - ${errorBody}`);
+    }
+    return await response.json();
+  }
+  /**
+   * Get the content of an uploaded file (for file-extract purpose).
+   */
+  async getContent(fileId) {
+    const fetchFn = this.config.fetch ?? fetch;
+    const headers = this.config.headers();
+    const response = await fetchFn(`${this.config.baseURL}/files/${fileId}/content`, {
+      method: "GET",
+      headers: Object.fromEntries(
+        Object.entries(headers).filter((entry) => entry[1] !== void 0)
+      )
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Failed to get file content: ${response.status} ${response.statusText} - ${errorBody}`);
+    }
+    return response.text();
+  }
+  /**
+   * Upload a file and extract its content in one operation.
+   * Only works for files with purpose="file-extract".
+   */
+  async uploadAndExtract(options) {
+    const file = await this.upload({
+      ...options,
+      purpose: options.purpose ?? "file-extract"
+    });
+    let currentFile = file;
+    let attempts = 0;
+    const maxAttempts = 30;
+    const pollInterval = 1e3;
+    while (currentFile.status === "processing" && attempts < maxAttempts) {
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      currentFile = await this.getFile(file.id);
+      attempts++;
+    }
+    if (currentFile.status === "error") {
+      throw new Error(`File processing failed: ${currentFile.status_details ?? "Unknown error"}`);
+    }
+    if (currentFile.status === "processing") {
+      throw new Error("File processing timed out");
+    }
+    let content;
+    if (currentFile.purpose === "file-extract") {
+      content = await this.getContent(file.id);
+    }
+    return { file: currentFile, content };
+  }
+  /**
+   * Get file information.
+   */
+  async getFile(fileId) {
+    const fetchFn = this.config.fetch ?? fetch;
+    const headers = this.config.headers();
+    const response = await fetchFn(`${this.config.baseURL}/files/${fileId}`, {
+      method: "GET",
+      headers: Object.fromEntries(
+        Object.entries(headers).filter((entry) => entry[1] !== void 0)
+      )
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Failed to get file: ${response.status} ${response.statusText} - ${errorBody}`);
+    }
+    return await response.json();
+  }
+  /**
+   * List all uploaded files.
+   */
+  async listFiles() {
+    const fetchFn = this.config.fetch ?? fetch;
+    const headers = this.config.headers();
+    const response = await fetchFn(`${this.config.baseURL}/files`, {
+      method: "GET",
+      headers: Object.fromEntries(
+        Object.entries(headers).filter((entry) => entry[1] !== void 0)
+      )
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Failed to list files: ${response.status} ${response.statusText} - ${errorBody}`);
+    }
+    const result = await response.json();
+    return result.data;
+  }
+  /**
+   * Delete a file.
+   */
+  async deleteFile(fileId) {
+    const fetchFn = this.config.fetch ?? fetch;
+    const headers = this.config.headers();
+    const response = await fetchFn(`${this.config.baseURL}/files/${fileId}`, {
+      method: "DELETE",
+      headers: Object.fromEntries(
+        Object.entries(headers).filter((entry) => entry[1] !== void 0)
+      )
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Failed to delete file: ${response.status} ${response.statusText} - ${errorBody}`);
+    }
+  }
+};
+function base64ToUint8Array(base64) {
+  const base64Data = base64.includes(",") ? base64.split(",")[1] : base64;
+  const binaryString = atob(base64Data);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+
+// src/files/attachment-processor.ts
+async function processAttachments(options) {
+  const {
+    attachments,
+    clientConfig,
+    autoUploadDocuments = true,
+    uploadImages = false,
+    cleanupAfterExtract = false
+  } = options;
+  const results = [];
+  const client = new KimiFileClient(clientConfig);
+  for (const attachment of attachments) {
+    try {
+      const processed = await processAttachment(attachment, client, {
+        autoUploadDocuments,
+        uploadImages,
+        cleanupAfterExtract
+      });
+      results.push(processed);
+    } catch (error) {
+      results.push({
+        original: attachment,
+        type: "skip",
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+async function processAttachment(attachment, client, options) {
+  const contentType = resolveContentType(attachment);
+  if (isImageMediaType2(contentType)) {
+    if (options.uploadImages && attachment.content) {
+      const result = await client.upload({
+        data: attachment.content,
+        filename: attachment.name ?? "image.jpg",
+        mediaType: contentType,
+        purpose: "image"
+      });
+      return {
+        original: attachment,
+        type: "image-url",
+        fileId: result.id,
+        mediaUrl: attachment.url
+      };
+    }
+    return {
+      original: attachment,
+      type: "image-url",
+      mediaUrl: attachment.url
+    };
+  }
+  if (isVideoMediaType2(contentType)) {
+    return {
+      original: attachment,
+      type: "video-url",
+      mediaUrl: attachment.url
+    };
+  }
+  if (options.autoUploadDocuments && (isDocumentMediaType(contentType) || isFileExtractMediaType(contentType))) {
+    let data;
+    if (attachment.content) {
+      data = attachment.content;
+    } else if (attachment.url) {
+      const response = await fetch(attachment.url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch attachment: ${response.status}`);
+      }
+      data = new Uint8Array(await response.arrayBuffer());
+    } else {
+      return {
+        original: attachment,
+        type: "skip",
+        error: "No content or URL provided for document attachment"
+      };
+    }
+    const result = await client.uploadAndExtract({
+      data,
+      filename: attachment.name ?? guessFilename(attachment, contentType),
+      mediaType: contentType,
+      purpose: "file-extract"
+    });
+    if (options.cleanupAfterExtract && result.file.id) {
+      try {
+        await client.deleteFile(result.file.id);
+      } catch {
+      }
+    }
+    return {
+      original: attachment,
+      type: "text-inject",
+      textContent: result.content,
+      fileId: result.file.id
+    };
+  }
+  return {
+    original: attachment,
+    type: "skip",
+    error: `Unsupported content type: ${contentType}`
+  };
+}
+function resolveContentType(attachment) {
+  if (attachment.contentType) {
+    return attachment.contentType;
+  }
+  const path = attachment.name ?? attachment.url;
+  if (path) {
+    const ext = getExtensionFromPath(path);
+    if (ext) {
+      return getMediaTypeFromExtension(ext);
+    }
+  }
+  return "application/octet-stream";
+}
+function guessFilename(attachment, contentType) {
+  if (attachment.name) {
+    return attachment.name;
+  }
+  if (attachment.url) {
+    const urlPath = attachment.url.split("?")[0];
+    const segments = urlPath.split("/");
+    const lastSegment = segments[segments.length - 1];
+    if (lastSegment && lastSegment.includes(".")) {
+      return lastSegment;
+    }
+  }
+  const extensionMap = {
+    "application/pdf": "document.pdf",
+    "text/plain": "document.txt",
+    "application/msword": "document.doc",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "document.docx",
+    "image/jpeg": "image.jpg",
+    "image/png": "image.png"
+  };
+  return extensionMap[contentType] ?? "file.bin";
+}
+
+// src/version.ts
+var VERSION = "0.2.0".length > 0 ? "0.2.0" : "0.0.0";
+
+// src/kimi-provider.ts
+var GLOBAL_BASE_URL = "https://api.moonshot.ai/v1";
+var CN_BASE_URL = "https://api.moonshot.cn/v1";
+function createKimi(options = {}) {
+  const resolvedBaseURL = loadOptionalSetting({
+    settingValue: options.baseURL,
+    environmentVariableName: "MOONSHOT_BASE_URL"
+  }) ?? (options.endpoint === "cn" ? CN_BASE_URL : GLOBAL_BASE_URL);
+  const baseURL = withoutTrailingSlash(resolvedBaseURL) ?? GLOBAL_BASE_URL;
+  const getHeaders = () => withUserAgentSuffix(
+    {
+      Authorization: `Bearer ${loadApiKey({
+        apiKey: options.apiKey,
+        environmentVariableName: "MOONSHOT_API_KEY",
+        description: "Moonshot"
+      })}`,
+      ...options.headers
+    },
+    `ai-sdk/kimi/${VERSION}`
+  );
+  const createChatModel = (modelId, settings = {}) => new KimiChatLanguageModel(modelId, settings, {
+    provider: "kimi.chat",
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch,
+    generateId: options.generateId,
+    supportsStructuredOutputs: settings.supportsStructuredOutputs ?? options.supportsStructuredOutputs,
+    includeUsageInStream: settings.includeUsageInStream ?? options.includeUsageInStream,
+    supportedUrls: settings.supportedUrls ?? options.supportedUrls
+  });
+  const provider = (modelId, settings) => {
+    if (new.target) {
+      throw new Error("The Kimi provider function cannot be called with new.");
+    }
+    return createChatModel(modelId, settings);
+  };
+  provider.specificationVersion = "v3";
+  provider.languageModel = createChatModel;
+  provider.chat = createChatModel;
+  provider.tools = kimiTools;
+  provider.files = new KimiFileClient({
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  provider.embeddingModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
+  };
+  provider.imageModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
+  provider.rerankingModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "rerankingModel" });
+  };
+  return provider;
+}
+var kimi = createKimi();
+
+// src/code/kimi-code-language-model.ts
+import {
+  combineHeaders as combineHeaders2,
+  createEventSourceResponseHandler as createEventSourceResponseHandler2,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  generateId as generateId2,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi as postJsonToApi2,
+  removeUndefinedEntries as removeUndefinedEntries2
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
+
+// src/code/kimi-code-messages.ts
+import { UnsupportedFunctionalityError as UnsupportedFunctionalityError3 } from "@ai-sdk/provider";
+import { convertToBase64 as convertToBase642 } from "@ai-sdk/provider-utils";
+async function convertToKimiCodePrompt(prompt) {
+  let systemMessage;
+  const messages = [];
+  for (const message of prompt) {
+    switch (message.role) {
+      case "system": {
+        const systemText = typeof message.content === "string" ? message.content : "";
+        systemMessage = systemMessage ? `${systemMessage}
+
+${systemText}` : systemText;
+        break;
+      }
+      case "user": {
+        const content = [];
+        for (const part of message.content) {
+          switch (part.type) {
+            case "text":
+              content.push({ type: "text", text: part.text });
+              break;
+            case "file":
+              if (part.mediaType?.startsWith("image/")) {
+                content.push(await convertFilePart(part));
+              } else {
+                throw new UnsupportedFunctionalityError3({
+                  functionality: `file type: ${part.mediaType}`
+                });
+              }
+              break;
+            default:
+              throw new UnsupportedFunctionalityError3({
+                functionality: `user content part type: ${part.type}`
+              });
+          }
+        }
+        messages.push({
+          role: "user",
+          content: content.length === 1 && content[0].type === "text" ? content[0].text : content
+        });
+        break;
+      }
+      case "assistant": {
+        const content = [];
+        for (const part of message.content) {
+          switch (part.type) {
+            case "text":
+              content.push({ type: "text", text: part.text });
+              break;
+            case "tool-call":
+              content.push({
+                type: "tool_use",
+                id: part.toolCallId,
+                name: part.toolName,
+                input: typeof part.input === "string" ? JSON.parse(part.input) : part.input
+              });
+              break;
+            case "reasoning":
+              if (part.text) {
+                content.push({ type: "text", text: `<thinking>${part.text}</thinking>` });
+              }
+              break;
+            default:
+              throw new UnsupportedFunctionalityError3({
+                functionality: `assistant content part type: ${part.type}`
+              });
+          }
+        }
+        if (content.length > 0) {
+          messages.push({
+            role: "assistant",
+            content: content.length === 1 && content[0].type === "text" ? content[0].text : content
+          });
+        }
+        break;
+      }
+      case "tool": {
+        const toolResults = [];
+        for (const part of message.content) {
+          if (part.type === "tool-result") {
+            toolResults.push(convertToolResultPart(part));
+          }
+        }
+        if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
+          messages.push({
+            role: "user",
+            content: toolResults
+          });
+        } else {
+          const lastMessage = messages[messages.length - 1];
+          if (lastMessage?.role === "user" && Array.isArray(lastMessage.content)) {
+            lastMessage.content.push(...toolResults);
+          } else {
+            messages.push({
+              role: "user",
+              content: toolResults
+            });
+          }
+        }
+        break;
+      }
+      default:
+        throw new UnsupportedFunctionalityError3({
+          functionality: `message role: ${message.role}`
+        });
+    }
+  }
+  return {
+    system: systemMessage,
+    messages
+  };
+}
+async function convertFilePart(part) {
+  const mediaType = part.mediaType ?? "image/png";
+  if (part.data instanceof URL) {
+    return {
+      type: "image",
+      source: {
+        type: "url",
+        url: part.data.toString()
+      }
+    };
+  }
+  if (typeof part.data === "string") {
+    if (part.data.startsWith("http://") || part.data.startsWith("https://")) {
+      return {
+        type: "image",
+        source: {
+          type: "url",
+          url: part.data
+        }
+      };
+    }
+    if (part.data.startsWith("data:")) {
+      const [header, data] = part.data.split(",");
+      const extractedMimeType = header.match(/data:([^;]+)/)?.[1] ?? mediaType;
+      return {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: extractedMimeType,
+          data
+        }
+      };
+    }
+    return {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: mediaType,
+        data: part.data
+      }
+    };
+  }
+  const base64 = convertToBase642(part.data);
+  return {
+    type: "image",
+    source: {
+      type: "base64",
+      media_type: mediaType,
+      data: base64
+    }
+  };
+}
+function convertToolResultPart(part) {
+  const output = part.output;
+  let content;
+  let isError = false;
+  switch (output.type) {
+    case "text":
+      content = String(output.value ?? "");
+      break;
+    case "error-text":
+      content = String(output.value ?? "");
+      isError = true;
+      break;
+    case "execution-denied":
+      content = output.reason ?? "Tool execution denied.";
+      isError = true;
+      break;
+    case "json":
+    case "content":
+      content = JSON.stringify(output.value);
+      break;
+    case "error-json":
+      content = JSON.stringify(output.value);
+      isError = true;
+      break;
+    default:
+      content = JSON.stringify(output);
+  }
+  return {
+    type: "tool_result",
+    tool_use_id: part.toolCallId,
+    content,
+    is_error: isError || void 0
+  };
+}
+
+// src/code/kimi-code-settings.ts
+import { z as z4 } from "zod/v4";
+var kimiCodeProviderOptionsSchema = z4.object({
+  /**
+   * Extended thinking configuration.
+   */
+  extendedThinking: z4.union([
+    z4.boolean(),
+    z4.object({
+      enabled: z4.boolean().optional(),
+      effort: z4.enum(["low", "medium", "high"]).optional(),
+      budgetTokens: z4.number().optional()
+    })
+  ]).optional(),
+  /**
+   * System prompt to prepend.
+   */
+  system: z4.string().optional(),
+  /**
+   * Custom stop sequences.
+   */
+  stopSequences: z4.array(z4.string()).optional()
+});
+function normalizeExtendedThinkingConfig(config) {
+  if (config === void 0) {
+    return void 0;
+  }
+  if (typeof config === "boolean") {
+    return config ? { enabled: true, effort: "medium" } : { enabled: false };
+  }
+  return {
+    enabled: config.enabled ?? true,
+    effort: config.effort ?? "medium",
+    budgetTokens: config.budgetTokens
+  };
+}
+function effortToBudgetTokens(effort) {
+  switch (effort) {
+    case "low":
+      return 2048;
+    case "medium":
+      return 8192;
+    case "high":
+      return 16384;
+    default:
+      return 8192;
+  }
+}
+
+// src/code/kimi-code-types.ts
+var KIMI_CODE_BASE_URL = "https://api.kimi.com/coding/v1";
+var KIMI_CODE_DEFAULT_MODEL = "kimi-for-coding";
+var KIMI_CODE_THINKING_MODEL = "kimi-k2-thinking";
+var KIMI_CODE_DEFAULT_MAX_TOKENS = 32768;
+var KIMI_CODE_DEFAULT_CONTEXT_WINDOW = 262144;
+function inferKimiCodeCapabilities(modelId) {
+  const isThinkingModel = modelId.includes("-thinking") || modelId.includes("k2-thinking");
+  return {
+    extendedThinking: isThinkingModel,
+    maxOutputTokens: KIMI_CODE_DEFAULT_MAX_TOKENS,
+    maxContextSize: KIMI_CODE_DEFAULT_CONTEXT_WINDOW,
+    streaming: true,
+    toolCalling: true,
+    imageInput: true
+  };
+}
+
+// src/code/kimi-code-language-model.ts
+var kimiCodeErrorSchema = z5.union([
+  z5.object({
+    error: z5.object({
+      message: z5.string(),
+      type: z5.string().nullish(),
+      code: z5.union([z5.string(), z5.number()]).nullish()
+    })
+  }),
+  z5.object({
+    message: z5.string()
+  })
+]);
+var kimiCodeTextContentSchema = z5.object({
+  type: z5.literal("text"),
+  text: z5.string()
+});
+var kimiCodeThinkingContentSchema = z5.object({
+  type: z5.literal("thinking"),
+  thinking: z5.string()
+});
+var kimiCodeToolUseContentSchema = z5.object({
+  type: z5.literal("tool_use"),
+  id: z5.string(),
+  name: z5.string(),
+  input: z5.record(z5.string(), z5.unknown())
+});
+var kimiCodeContentBlockSchema = z5.union([
+  kimiCodeTextContentSchema,
+  kimiCodeThinkingContentSchema,
+  kimiCodeToolUseContentSchema
+]);
+var kimiCodeResponseSchema = z5.object({
+  id: z5.string().optional(),
+  type: z5.string().optional(),
+  model: z5.string().optional(),
+  stop_reason: z5.string().nullish(),
+  stop_sequence: z5.string().nullish(),
+  content: z5.array(kimiCodeContentBlockSchema),
+  usage: z5.object({
+    input_tokens: z5.number().optional(),
+    output_tokens: z5.number().optional(),
+    cache_read_input_tokens: z5.number().optional(),
+    cache_creation_input_tokens: z5.number().optional()
+  }).optional()
+});
+var kimiCodeStreamChunkSchema = z5.object({
+  type: z5.string(),
+  index: z5.number().optional(),
+  message: z5.object({
+    id: z5.string().optional(),
+    type: z5.string().optional(),
+    model: z5.string().optional(),
+    content: z5.array(z5.unknown()).optional(),
+    stop_reason: z5.string().nullish(),
+    stop_sequence: z5.string().nullish(),
+    usage: z5.object({
+      input_tokens: z5.number().optional(),
+      output_tokens: z5.number().optional()
+    }).optional()
+  }).optional(),
+  content_block: z5.object({
+    type: z5.string(),
+    text: z5.string().optional(),
+    thinking: z5.string().optional(),
+    id: z5.string().optional(),
+    name: z5.string().optional(),
+    input: z5.record(z5.string(), z5.unknown()).optional()
+  }).optional(),
+  delta: z5.object({
+    type: z5.string().optional(),
+    text: z5.string().optional(),
+    thinking: z5.string().optional(),
+    partial_json: z5.string().optional(),
+    stop_reason: z5.string().optional(),
+    stop_sequence: z5.string().optional()
+  }).optional(),
+  usage: z5.object({
+    input_tokens: z5.number().optional(),
+    output_tokens: z5.number().optional()
+  }).optional()
+});
+var kimiCodeFailedResponseHandler = createJsonErrorResponseHandler2({
+  errorSchema: kimiCodeErrorSchema,
+  errorToMessage: (error) => {
+    if ("error" in error) {
+      return error.error.message;
+    }
+    return error.message;
+  },
+  isRetryable: (response) => response.status === 408 || response.status === 409 || response.status === 429 || response.status >= 500
+});
+function mapStopReason(stopReason) {
+  switch (stopReason) {
+    case "end_turn":
+    case "stop_sequence":
+      return { unified: "stop", raw: stopReason };
+    case "tool_use":
+      return { unified: "tool-calls", raw: stopReason };
+    case "max_tokens":
+      return { unified: "length", raw: stopReason };
+    default:
+      return { unified: "other", raw: stopReason ?? void 0 };
+  }
+}
+function convertUsage(usage) {
+  const inputTokens = usage?.input_tokens ?? 0;
+  const outputTokens = usage?.output_tokens ?? 0;
+  const cacheRead = usage?.cache_read_input_tokens ?? 0;
+  return {
+    inputTokens: {
+      total: inputTokens,
+      cacheRead,
+      cacheWrite: usage?.cache_creation_input_tokens,
+      noCache: inputTokens - cacheRead
+    },
+    outputTokens: {
+      total: outputTokens,
+      text: outputTokens,
+      reasoning: 0
+    },
+    raw: usage
+  };
+}
+function convertTools(tools) {
+  if (!tools || tools.length === 0) {
+    return void 0;
+  }
+  return tools.map((tool) => {
+    return {
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.inputSchema ?? { type: "object", properties: {} }
+    };
+  });
+}
+var KimiCodeLanguageModel = class {
+  constructor(modelId, settings, config) {
+    this.specificationVersion = "v3";
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+    this.generateIdFn = config.generateId ?? generateId2;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get providerOptionsName() {
+    return "kimiCode";
+  }
+  /**
+   * Get the inferred or configured capabilities for this model.
+   */
+  get capabilities() {
+    const inferred = inferKimiCodeCapabilities(this.modelId);
+    return {
+      ...inferred,
+      ...this.settings.capabilities
+    };
+  }
+  get supportedUrls() {
+    const patterns = {
+      "image/*": [/^https?:\/\/.*$/i]
+    };
+    return this.settings.supportedUrls ?? this.config.supportedUrls ?? patterns;
+  }
+  /**
+   * Build request arguments.
+   */
+  async getArgs(options) {
+    const { prompt, maxOutputTokens, temperature, topP, topK, stopSequences, tools, toolChoice, providerOptions } = options;
+    const warnings = [];
+    const kimiCodeOptions = await parseProviderOptions2({
+      provider: this.providerOptionsName,
+      providerOptions,
+      schema: kimiCodeProviderOptionsSchema
+    });
+    const extendedThinking = normalizeExtendedThinkingConfig(kimiCodeOptions?.extendedThinking) ?? normalizeExtendedThinkingConfig(this.settings.extendedThinking);
+    if (topK != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "topK"
+      });
+    }
+    const { system, messages } = await convertToKimiCodePrompt(prompt);
+    let toolChoiceParam;
+    if (toolChoice != null) {
+      switch (toolChoice.type) {
+        case "auto":
+          toolChoiceParam = { type: "auto" };
+          break;
+        case "none":
+          toolChoiceParam = { type: "none" };
+          break;
+        case "required":
+          toolChoiceParam = { type: "any" };
+          break;
+        case "tool":
+          toolChoiceParam = { type: "tool", name: toolChoice.toolName };
+          break;
+      }
+    }
+    const functionTools = tools?.filter((t) => t.type === "function");
+    const body = removeUndefinedEntries2({
+      model: this.modelId,
+      system: kimiCodeOptions?.system ?? system,
+      messages,
+      max_tokens: maxOutputTokens ?? this.capabilities.maxOutputTokens ?? 32768,
+      temperature,
+      top_p: topP,
+      stop_sequences: kimiCodeOptions?.stopSequences ?? stopSequences,
+      tools: convertTools(functionTools),
+      tool_choice: toolChoiceParam,
+      // Extended thinking parameters
+      ...extendedThinking?.enabled && {
+        thinking: {
+          type: "enabled",
+          budget_tokens: extendedThinking.budgetTokens ?? effortToBudgetTokens(extendedThinking.effort ?? "medium")
+        }
+      }
+    });
+    const requestHeaders = {
+      ...options.headers ?? {}
+    };
+    return {
+      body,
+      warnings,
+      requestHeaders
+    };
+  }
+  async doGenerate(options) {
+    const { body, warnings, requestHeaders } = await this.getArgs(options);
+    const {
+      responseHeaders,
+      value: rawResponse,
+      rawValue
+    } = await postJsonToApi2({
+      url: `${this.config.baseURL}/messages`,
+      headers: combineHeaders2(this.config.headers(), requestHeaders, options.headers),
+      body,
+      failedResponseHandler: kimiCodeFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler2(kimiCodeResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const response = rawResponse;
+    const content = [];
+    for (const block of response.content) {
+      switch (block.type) {
+        case "text":
+          content.push({ type: "text", text: block.text });
+          break;
+        case "thinking":
+          content.push({
+            type: "reasoning",
+            text: block.thinking
+          });
+          break;
+        case "tool_use":
+          content.push({
+            type: "tool-call",
+            toolCallId: block.id,
+            toolName: block.name,
+            input: JSON.stringify(block.input)
+          });
+          break;
+      }
+    }
+    const providerMetadata = {
+      [this.providerOptionsName]: {
+        requestId: responseHeaders?.["x-request-id"] ?? void 0,
+        modelId: response.model,
+        stopReason: response.stop_reason,
+        stopSequence: response.stop_sequence
+      }
+    };
+    return {
+      content,
+      finishReason: mapStopReason(response.stop_reason),
+      usage: convertUsage(response.usage),
+      providerMetadata,
+      request: { body },
+      response: {
+        id: response.id,
+        modelId: response.model,
+        headers: responseHeaders,
+        body: rawValue
+      },
+      warnings
+    };
+  }
+  async doStream(options) {
+    const { body, warnings, requestHeaders } = await this.getArgs(options);
+    const streamBody = {
+      ...body,
+      stream: true
+    };
+    const { responseHeaders, value: response } = await postJsonToApi2({
+      url: `${this.config.baseURL}/messages`,
+      headers: combineHeaders2(this.config.headers(), requestHeaders, options.headers),
+      body: streamBody,
+      failedResponseHandler: kimiCodeFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler2(kimiCodeStreamChunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const providerOptionsName = this.providerOptionsName;
+    const generateIdFn = this.generateIdFn;
+    const capturedResponseHeaders = responseHeaders;
+    let currentBlockType;
+    let currentToolCallId;
+    let currentToolName;
+    let accumulatedToolInput = "";
+    let finishReason = { unified: "other", raw: void 0 };
+    let usage;
+    let responseId;
+    let responseModel;
+    let isActiveText = false;
+    let isActiveReasoning = false;
+    let hasToolCallFinished = false;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            if (!chunk.success) {
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const data = chunk.value;
+            switch (data.type) {
+              case "message_start":
+                if (data.message) {
+                  responseId = data.message.id;
+                  responseModel = data.message.model;
+                  if (data.message.usage) {
+                    usage = convertUsage(data.message.usage);
+                  }
+                  controller.enqueue({
+                    type: "response-metadata",
+                    id: responseId,
+                    modelId: responseModel
+                  });
+                }
+                break;
+              case "content_block_start":
+                if (data.content_block) {
+                  currentBlockType = data.content_block.type;
+                  if (data.content_block.type === "tool_use") {
+                    currentToolCallId = data.content_block.id ?? generateIdFn();
+                    currentToolName = data.content_block.name;
+                    accumulatedToolInput = "";
+                    hasToolCallFinished = false;
+                    if (isActiveText) {
+                      controller.enqueue({ type: "text-end", id: "text-0" });
+                      isActiveText = false;
+                    }
+                    if (isActiveReasoning) {
+                      controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+                      isActiveReasoning = false;
+                    }
+                    controller.enqueue({
+                      type: "tool-input-start",
+                      id: currentToolCallId,
+                      toolName: currentToolName ?? ""
+                    });
+                  } else if (data.content_block.type === "text") {
+                    if (!isActiveText) {
+                      if (isActiveReasoning) {
+                        controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+                        isActiveReasoning = false;
+                      }
+                      controller.enqueue({ type: "text-start", id: "text-0" });
+                      isActiveText = true;
+                    }
+                  } else if (data.content_block.type === "thinking") {
+                    if (!isActiveReasoning) {
+                      if (isActiveText) {
+                        controller.enqueue({ type: "text-end", id: "text-0" });
+                        isActiveText = false;
+                      }
+                      controller.enqueue({ type: "reasoning-start", id: "reasoning-0" });
+                      isActiveReasoning = true;
+                    }
+                  }
+                }
+                break;
+              case "content_block_delta":
+                if (data.delta) {
+                  if (data.delta.type === "text_delta" && data.delta.text) {
+                    if (!isActiveText) {
+                      if (isActiveReasoning) {
+                        controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+                        isActiveReasoning = false;
+                      }
+                      controller.enqueue({ type: "text-start", id: "text-0" });
+                      isActiveText = true;
+                    }
+                    controller.enqueue({
+                      type: "text-delta",
+                      id: "text-0",
+                      delta: data.delta.text
+                    });
+                  } else if (data.delta.type === "thinking_delta" && data.delta.thinking) {
+                    if (!isActiveReasoning) {
+                      if (isActiveText) {
+                        controller.enqueue({ type: "text-end", id: "text-0" });
+                        isActiveText = false;
+                      }
+                      controller.enqueue({ type: "reasoning-start", id: "reasoning-0" });
+                      isActiveReasoning = true;
+                    }
+                    controller.enqueue({
+                      type: "reasoning-delta",
+                      id: "reasoning-0",
+                      delta: data.delta.thinking
+                    });
+                  } else if (data.delta.type === "input_json_delta" && data.delta.partial_json) {
+                    accumulatedToolInput += data.delta.partial_json;
+                    controller.enqueue({
+                      type: "tool-input-delta",
+                      id: currentToolCallId ?? "",
+                      delta: data.delta.partial_json
+                    });
+                  }
+                }
+                break;
+              case "content_block_stop":
+                if (currentBlockType === "tool_use" && currentToolCallId && !hasToolCallFinished) {
+                  controller.enqueue({ type: "tool-input-end", id: currentToolCallId });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: currentToolCallId,
+                    toolName: currentToolName ?? "",
+                    input: accumulatedToolInput
+                  });
+                  hasToolCallFinished = true;
+                } else if (currentBlockType === "text" && isActiveText) {
+                  controller.enqueue({ type: "text-end", id: "text-0" });
+                  isActiveText = false;
+                } else if (currentBlockType === "thinking" && isActiveReasoning) {
+                  controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+                  isActiveReasoning = false;
+                }
+                currentBlockType = void 0;
+                currentToolCallId = void 0;
+                currentToolName = void 0;
+                accumulatedToolInput = "";
+                break;
+              case "message_delta":
+                if (data.delta?.stop_reason) {
+                  finishReason = mapStopReason(data.delta.stop_reason);
+                }
+                if (data.usage) {
+                  usage = convertUsage(data.usage);
+                }
+                break;
+              case "message_stop":
+                if (isActiveText) {
+                  controller.enqueue({ type: "text-end", id: "text-0" });
+                }
+                if (isActiveReasoning) {
+                  controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+                }
+                controller.enqueue({
+                  type: "finish",
+                  finishReason,
+                  usage: usage ?? convertUsage({}),
+                  providerMetadata: {
+                    [providerOptionsName]: {
+                      requestId: capturedResponseHeaders?.["x-request-id"] ?? void 0,
+                      modelId: responseModel
+                    }
+                  }
+                });
+                break;
+              case "error":
+                controller.enqueue({
+                  type: "error",
+                  error: new Error(
+                    data.error?.message ?? "Unknown streaming error"
+                  )
+                });
+                break;
+            }
+          }
+        })
+      ),
+      request: { body: streamBody },
+      response: {
+        headers: responseHeaders
+      }
+    };
+  }
+};
+
+// src/code/kimi-code-provider.ts
+import { NoSuchModelError as NoSuchModelError2 } from "@ai-sdk/provider";
+import {
+  loadOptionalSetting as loadOptionalSetting2,
+  withUserAgentSuffix as withUserAgentSuffix2,
+  withoutTrailingSlash as withoutTrailingSlash2
+} from "@ai-sdk/provider-utils";
+function createKimiCode(options = {}) {
+  const resolvedBaseURL = loadOptionalSetting2({
+    settingValue: options.baseURL,
+    environmentVariableName: "KIMI_CODE_BASE_URL"
+  }) ?? KIMI_CODE_BASE_URL;
+  const baseURL = withoutTrailingSlash2(resolvedBaseURL) ?? KIMI_CODE_BASE_URL;
+  const getHeaders = () => {
+    let apiKey = options.apiKey;
+    if (!apiKey) {
+      apiKey = process.env.KIMI_CODE_API_KEY ?? process.env.KIMI_API_KEY;
+    }
+    if (!apiKey) {
+      throw new Error(
+        "Kimi Code API key is required. Set the KIMI_CODE_API_KEY or KIMI_API_KEY environment variable, or pass the apiKey option."
+      );
+    }
+    return withUserAgentSuffix2(
+      {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        ...options.headers
+      },
+      `ai-sdk/kimi-code/${VERSION}`
+    );
+  };
+  const createCodeModel = (modelId = KIMI_CODE_DEFAULT_MODEL, settings = {}) => new KimiCodeLanguageModel(modelId, settings, {
+    provider: "kimi.code",
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch,
+    generateId: options.generateId,
+    includeUsageInStream: settings.includeUsageInStream ?? options.includeUsageInStream,
+    supportedUrls: settings.supportedUrls ?? options.supportedUrls
+  });
+  const provider = (modelId = KIMI_CODE_DEFAULT_MODEL, settings) => {
+    if (new.target) {
+      throw new Error("The Kimi Code provider function cannot be called with new.");
+    }
+    return createCodeModel(modelId, settings);
+  };
+  provider.specificationVersion = "v3";
+  provider.languageModel = createCodeModel;
+  provider.chat = createCodeModel;
+  provider.embeddingModel = (modelId) => {
+    throw new NoSuchModelError2({ modelId, modelType: "embeddingModel" });
+  };
+  provider.imageModel = (modelId) => {
+    throw new NoSuchModelError2({ modelId, modelType: "imageModel" });
+  };
+  provider.rerankingModel = (modelId) => {
+    throw new NoSuchModelError2({ modelId, modelType: "rerankingModel" });
+  };
+  return provider;
+}
+var kimiCode = createKimiCode();
+export {
+  KIMI_CODE_BASE_URL,
+  KIMI_CODE_DEFAULT_MODEL,
+  KIMI_CODE_INTERPRETER_TOOL_NAME,
+  KIMI_CODE_THINKING_MODEL,
+  KIMI_WEB_SEARCH_TOOL_NAME,
+  KimiAuthenticationError,
+  KimiChatLanguageModel,
+  KimiCodeLanguageModel,
+  KimiContentFilterError,
+  KimiContextLengthError,
+  KimiError,
+  KimiFileClient,
+  KimiModelNotFoundError,
+  KimiRateLimitError,
+  KimiValidationError,
+  SUPPORTED_FILE_EXTENSIONS,
+  SUPPORTED_MIME_TYPES,
+  createCodeInterpreterTool,
+  createKimi,
+  createKimiCode,
+  createKimiWebSearchTool,
+  createWebSearchTool,
+  getMediaTypeFromExtension,
+  getPurposeFromMediaType,
+  inferKimiCodeCapabilities,
+  inferModelCapabilities,
+  isDocumentMediaType,
+  isFileExtractMediaType,
+  isImageMediaType2 as isImageMediaType,
+  isVideoMediaType2 as isVideoMediaType,
+  kimi,
+  kimiCachingConfigSchema,
+  kimiCode,
+  kimiCodeProviderOptionsSchema,
+  kimiProviderOptionsSchema,
+  kimiTools,
+  processAttachments
+};
+//# sourceMappingURL=index.mjs.map