@ai-sdk/moonshotai 2.0.49 → 2.0.53

package/dist/index.mjs

@@ -24,26 +24,402 @@ import {
 
 // src/convert-to-moonshotai-chat-messages.ts
 import {
-  UnsupportedFunctionalityError
+  InvalidArgumentError,
+  InvalidPromptError,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } from "@ai-sdk/provider";
 import {
   convertBase64ToUint8Array,
   convertToBase64
 } from "@ai-sdk/provider-utils";
-function convertToMoonshotAIChatMessages(prompt) {
-  var _a;
+
+// src/moonshotai-chat-options.ts
+import { z } from "zod/v4";
+function isMoonshotAIKimiModel(modelId) {
+  return getMoonshotAIModelFamily(modelId).startsWith("kimi-");
+}
+function getMoonshotAIModelFamily(modelId) {
+  if (modelId === "kimi-k2.5") return "kimi-k2.5";
+  if (modelId === "kimi-k2.6") return "kimi-k2.6";
+  if (modelId === "kimi-k2.7-code" || modelId === "kimi-k2.7-code-highspeed") {
+    return "kimi-k2.7";
+  }
+  if (modelId === "kimi-k3") return "kimi-k3";
+  if (modelId.startsWith("moonshot-v1-")) return "moonshot-v1";
+  return "unknown";
+}
+var moonshotaiLanguageModelOptions = z.object({
+  /**
+   * Whether to use strict JSON schema validation for structured outputs.
+   *
+   * @default true
+   */
+  strictJsonSchema: z.boolean().optional(),
+  /**
+   * Whether to return log probabilities for generated tokens.
+   */
+  logprobs: z.boolean().optional(),
+  /**
+   * Number of most likely tokens to return at each token position.
+   *
+   * Setting this option automatically enables `logprobs`.
+   */
+  topLogprobs: z.number().int().min(0).max(20).optional(),
+  /**
+   * Reasoning effort for Kimi K3. Supports `low`, `high`, and `max`;
+   * defaults to `max`.
+   */
+  reasoningEffort: z.enum(["low", "high", "max"]).optional(),
+  /**
+   * Static predicted content that can accelerate responses when much of the
+   * output is known ahead of time.
+   */
+  prediction: z.object({
+    type: z.literal("content"),
+    content: z.union([
+      z.string(),
+      z.array(z.object({ type: z.literal("text"), text: z.string() }))
+    ])
+  }).optional(),
+  /**
+   * Thinking configuration for Kimi K2.x models. Kimi K2.5 and K2.6 support
+   * enabling or disabling thinking. Kimi K2.7 Code always has thinking
+   * enabled.
+   */
+  thinking: z.object({
+    type: z.enum(["enabled", "disabled"]).optional(),
+    /**
+     * @deprecated Moonshot Chat Completions does not support thinking
+     * budgets. Accepted for backwards compatibility, then omitted with a
+     * warning.
+     */
+    budgetTokens: z.number().int().min(1024).optional()
+  }).optional(),
+  /**
+   * Controls preserved reasoning behavior in multi-turn conversations.
+   * `disabled` and `interleaved` are compatibility values that leave the
+   * request unchanged. `preserved` maps to `thinking.keep: 'all'` for Kimi
+   * K2.6. Kimi K2.7 and K3 preserve reasoning by default.
+   */
+  reasoningHistory: z.enum(["disabled", "interleaved", "preserved"]).optional(),
+  /**
+   * Used to cache responses for similar requests to optimize cache hit rates.
+   * Typically a session or task id.
+   */
+  promptCacheKey: z.string().optional(),
+  /**
+   * A stable identifier used to help Moonshot detect users violating usage
+   * policies. Recommended to hash the username or email address.
+   */
+  safetyIdentifier: z.string().optional()
+});
+var moonshotaiMessageProviderOptions = z.object({
+  /**
+   * The name of the participant represented by the message.
+   *
+   * Supported on system, user, and assistant messages.
+   */
+  name: z.string().optional()
+});
+var moonshotaiAssistantMessageProviderOptions = moonshotaiMessageProviderOptions.extend({
+  /**
+   * Whether the assistant message content is a partial response that Moonshot
+   * should continue. Only supported on the final assistant message and cannot
+   * be combined with JSON object response format.
+   */
+  partial: z.literal(true).optional()
+});
+var moonshotaiDynamicToolSchema = z.object({
+  type: z.literal("function"),
+  name: z.string(),
+  description: z.string().optional(),
+  inputSchema: z.record(z.string(), z.unknown()),
+  strict: z.boolean().optional()
+});
+var moonshotaiAllMessageProviderOptions = moonshotaiAssistantMessageProviderOptions.extend({
+  /** Function tools to load at this point in a Kimi K3 conversation. */
+  tools: z.array(moonshotaiDynamicToolSchema).optional()
+});
+
+// src/moonshotai-prepare-tools.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
+
+// src/normalize-json-schema-for-mfjs.ts
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var SCHEMA_ARRAY_KEYS = ["allOf", "anyOf", "oneOf", "prefixItems"];
+var SCHEMA_MAP_KEYS = [
+  "properties",
+  "patternProperties",
+  "$defs",
+  "dependentSchemas"
+];
+var SCHEMA_SINGLE_KEYS = [
+  "additionalProperties",
+  "propertyNames",
+  "items",
+  "contains",
+  "not",
+  "if",
+  "then",
+  "else"
+];
+function normalizeJsonSchemaForMFJS(schema) {
+  return normalizeDefinition(schema, true);
+}
+function normalizeDefinition(definition, isRoot) {
+  if (typeof definition === "boolean" || !isRecord(definition)) {
+    if (isRoot) {
+      throw new UnsupportedFunctionalityError({
+        functionality: 'tool parameters must be a JSON Schema object with type "object" for moonshotai (MFJS)'
+      });
+    }
+    return definition;
+  }
+  if (isRoot && definition.type !== "object") {
+    throw new UnsupportedFunctionalityError({
+      functionality: 'tool parameters must be a JSON Schema object with type "object" for moonshotai (MFJS)'
+    });
+  }
+  const result = { ...definition };
+  if (Array.isArray(result.items)) {
+    const tuple = result.items;
+    result.prefixItems = [
+      ...Array.isArray(result.prefixItems) ? result.prefixItems : [],
+      ...tuple.map((item) => normalizeDefinition(item, false))
+    ];
+    delete result.items;
+  } else if (isRecord(result.items)) {
+    result.items = normalizeDefinition(result.items, false);
+  }
+  if (typeof result.type === "string" && Array.isArray(result.anyOf)) {
+    const parentType = result.type;
+    delete result.type;
+    result.anyOf = result.anyOf.map(
+      (branch) => isRecord(branch) && branch.type == null ? { type: parentType, ...branch } : branch
+    );
+  }
+  for (const key of SCHEMA_ARRAY_KEYS) {
+    const value = result[key];
+    if (Array.isArray(value)) {
+      result[key] = value.map((item) => normalizeDefinition(item, false));
+    }
+  }
+  for (const key of SCHEMA_MAP_KEYS) {
+    const value = result[key];
+    if (isRecord(value)) {
+      result[key] = Object.fromEntries(
+        Object.entries(value).map(([k, v]) => [
+          k,
+          normalizeDefinition(v, false)
+        ])
+      );
+    }
+  }
+  for (const key of SCHEMA_SINGLE_KEYS) {
+    const value = result[key];
+    if (isRecord(value) || typeof value === "boolean") {
+      result[key] = normalizeDefinition(value, false);
+    }
+  }
+  return result;
+}
+
+// src/moonshotai-prepare-tools.ts
+function prepareTools({
+  tools,
+  toolChoice,
+  modelId
+}) {
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
+  }
+  const moonshotTools = [];
+  for (const tool of tools) {
+    if (tool.type === "provider") {
+      toolWarnings.push({
+        type: "unsupported",
+        feature: `provider-defined tool ${tool.id}`
+      });
+    } else {
+      moonshotTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: normalizeJsonSchemaForMFJS(tool.inputSchema),
+          ...tool.strict != null ? { strict: tool.strict } : {}
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: moonshotTools, toolChoice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+      return { tools: moonshotTools, toolChoice: type, toolWarnings };
+    case "required":
+      if (modelId === "kimi-k2.6" || modelId === "kimi-k2.7-code" || modelId === "kimi-k2.7-code-highspeed") {
+        toolWarnings.push({
+          type: "unsupported",
+          feature: `tool choice "required" for model "${modelId}"`,
+          details: 'Moonshot AI rejects required tool choice for this model. The setting has been omitted; use "auto" or select a specific tool instead.'
+        });
+        return {
+          tools: moonshotTools,
+          toolChoice: void 0,
+          toolWarnings
+        };
+      }
+      return { tools: moonshotTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: moonshotTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError2({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+// src/convert-to-moonshotai-chat-messages.ts
+function parseMoonshotAIMessageProviderOptions({
+  providerOptions,
+  providerOptionsName
+}) {
+  const value = providerOptions == null ? void 0 : providerOptions[providerOptionsName];
+  if (value == null) {
+    return void 0;
+  }
+  const result = moonshotaiAllMessageProviderOptions.safeParse(value);
+  if (!result.success) {
+    throw new InvalidArgumentError({
+      argument: "providerOptions",
+      message: `invalid ${providerOptionsName} provider options`,
+      cause: result.error
+    });
+  }
+  return result.data;
+}
+var supportedImageMediaTypes = [
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/bmp",
+  "image/heic",
+  "image/heif"
+];
+var supportedVideoMediaTypes = [
+  "video/mp4",
+  "video/mpeg",
+  "video/mov",
+  "video/avi",
+  "video/x-flv",
+  "video/mpg",
+  "video/webm",
+  "video/wmv",
+  "video/3gpp"
+];
+function validateMediaType({
+  mediaType,
+  supportedMediaTypes,
+  topLevelMediaType
+}) {
+  const normalizedMediaType = mediaType === `${topLevelMediaType}/*` ? topLevelMediaType === "image" ? "image/jpeg" : "video/mp4" : mediaType;
+  if (!supportedMediaTypes.includes(normalizedMediaType)) {
+    throw new UnsupportedFunctionalityError3({
+      functionality: `file part media type ${normalizedMediaType}`
+    });
+  }
+  return normalizedMediaType;
+}
+function convertToMoonshotAIChatMessages({
+  modelId,
+  prompt,
+  providerOptionsName = "moonshotai",
+  responseFormat
+}) {
+  var _a, _b;
   const messages = [];
-  for (const { role, content } of prompt) {
+  const warnings = [];
+  const modelFamily = modelId == null ? "unknown" : getMoonshotAIModelFamily(modelId);
+  for (const [index, { role, content, providerOptions }] of prompt.entries()) {
+    const moonshotMessageOptions = parseMoonshotAIMessageProviderOptions({
+      providerOptions,
+      providerOptionsName
+    });
+    if ((moonshotMessageOptions == null ? void 0 : moonshotMessageOptions.partial) === true && role !== "assistant") {
+      throw new InvalidPromptError({
+        prompt,
+        message: "Moonshot AI Partial Mode requires `partial: true` on an assistant message."
+      });
+    }
+    if ((moonshotMessageOptions == null ? void 0 : moonshotMessageOptions.tools) != null && role !== "system") {
+      throw new InvalidPromptError({
+        prompt,
+        message: "Moonshot dynamic tools must be configured on a system message."
+      });
+    }
     switch (role) {
       case "system": {
-        messages.push({ role: "system", content });
+        if ((_a = moonshotMessageOptions == null ? void 0 : moonshotMessageOptions.tools) == null ? void 0 : _a.length) {
+          if (content.length > 0) {
+            throw new InvalidPromptError({
+              prompt,
+              message: "A Moonshot dynamic-tool system message must use empty content because the API forbids content alongside tools."
+            });
+          }
+          if (modelFamily !== "kimi-k3" && modelFamily !== "unknown") {
+            warnings.push({
+              type: "unsupported",
+              feature: `dynamic tool loading for model "${modelId}"`,
+              details: "Moonshot documents dynamic tool loading only for Kimi K3. The dynamic system message has been omitted."
+            });
+            break;
+          }
+          const { tools, toolWarnings } = prepareTools({
+            modelId: modelId != null ? modelId : "custom-model",
+            tools: moonshotMessageOptions.tools
+          });
+          warnings.push(...toolWarnings);
+          messages.push({ role: "system", tools: tools != null ? tools : [] });
+          break;
+        }
+        messages.push({
+          role: "system",
+          content,
+          ...(moonshotMessageOptions == null ? void 0 : moonshotMessageOptions.name) != null && {
+            name: moonshotMessageOptions.name
+          }
+        });
         break;
       }
       case "user": {
         if (content.length === 1 && content[0].type === "text") {
           messages.push({
             role: "user",
-            content: content[0].text
+            content: content[0].text,
+            ...(moonshotMessageOptions == null ? void 0 : moonshotMessageOptions.name) != null && {
+              name: moonshotMessageOptions.name
+            }
           });
           break;
         }
@@ -56,7 +432,11 @@ function convertToMoonshotAIChatMessages(prompt) {
               }
               case "file": {
                 if (part.mediaType.startsWith("image/")) {
-                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  const mediaType = validateMediaType({
+                    mediaType: part.mediaType,
+                    supportedMediaTypes: supportedImageMediaTypes,
+                    topLevelMediaType: "image"
+                  });
                   return {
                     type: "image_url",
                     image_url: {
@@ -65,7 +445,11 @@ function convertToMoonshotAIChatMessages(prompt) {
                   };
                 }
                 if (part.mediaType.startsWith("video/")) {
-                  const mediaType = part.mediaType === "video/*" ? "video/mp4" : part.mediaType;
+                  const mediaType = validateMediaType({
+                    mediaType: part.mediaType,
+                    supportedMediaTypes: supportedVideoMediaTypes,
+                    topLevelMediaType: "video"
+                  });
                   return {
                     type: "video_url",
                     video_url: {
@@ -82,16 +466,33 @@ function convertToMoonshotAIChatMessages(prompt) {
                     text: textContent
                   };
                 }
-                throw new UnsupportedFunctionalityError({
+                throw new UnsupportedFunctionalityError3({
                   functionality: `file part media type ${part.mediaType}`
                 });
               }
             }
-          })
+          }),
+          ...(moonshotMessageOptions == null ? void 0 : moonshotMessageOptions.name) != null && {
+            name: moonshotMessageOptions.name
+          }
         });
         break;
       }
       case "assistant": {
+        if ((moonshotMessageOptions == null ? void 0 : moonshotMessageOptions.partial) === true) {
+          if (index !== prompt.length - 1) {
+            throw new InvalidPromptError({
+              prompt,
+              message: "Moonshot AI Partial Mode requires the partial assistant message to be the final message."
+            });
+          }
+          if ((responseFormat == null ? void 0 : responseFormat.type) === "json_object") {
+            throw new InvalidPromptError({
+              prompt,
+              message: "Moonshot AI Partial Mode cannot be combined with JSON object response format."
+            });
+          }
+        }
         let text = "";
         let reasoning = "";
         const toolCalls = [];
@@ -121,12 +522,24 @@ function convertToMoonshotAIChatMessages(prompt) {
         messages.push({
           role: "assistant",
           content: toolCalls.length > 0 ? text || null : text,
+          ...(moonshotMessageOptions == null ? void 0 : moonshotMessageOptions.name) != null && {
+            name: moonshotMessageOptions.name
+          },
+          ...(moonshotMessageOptions == null ? void 0 : moonshotMessageOptions.partial) === true && {
+            partial: true
+          },
           ...reasoning.length > 0 ? { reasoning_content: reasoning } : {},
           tool_calls: toolCalls.length > 0 ? toolCalls : void 0
         });
         break;
       }
       case "tool": {
+        if ((moonshotMessageOptions == null ? void 0 : moonshotMessageOptions.name) != null) {
+          warnings.push({
+            type: "unsupported",
+            feature: "message name on tool messages"
+          });
+        }
         for (const toolResponse of content) {
           if (toolResponse.type === "tool-approval-response") {
             continue;
@@ -139,7 +552,7 @@ function convertToMoonshotAIChatMessages(prompt) {
               contentValue = output.value;
               break;
             case "execution-denied":
-              contentValue = (_a = output.reason) != null ? _a : "Tool call execution denied.";
+              contentValue = (_b = output.reason) != null ? _b : "Tool call execution denied.";
               break;
             case "content":
             case "json":
@@ -161,7 +574,7 @@ function convertToMoonshotAIChatMessages(prompt) {
       }
     }
   }
-  return messages;
+  return { messages, warnings };
 }
 
 // src/convert-moonshotai-chat-usage.ts
@@ -235,75 +648,100 @@ function mapMoonshotAIFinishReason(finishReason) {
 
 // src/moonshotai-chat-api-types.ts
 import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
-var tokenUsageSchema = z.object({
-  prompt_tokens: z.number().nullish(),
-  completion_tokens: z.number().nullish(),
-  cached_tokens: z.number().nullish(),
-  total_tokens: z.number().nullish(),
-  prompt_tokens_details: z.object({
-    cached_tokens: z.number().nullish()
+import { z as z2 } from "zod/v4";
+var tokenUsageSchema = z2.looseObject({
+  prompt_tokens: z2.number().nullish(),
+  completion_tokens: z2.number().nullish(),
+  cached_tokens: z2.number().nullish(),
+  total_tokens: z2.number().nullish(),
+  prompt_tokens_details: z2.looseObject({
+    cached_tokens: z2.number().nullish()
   }).nullish(),
-  completion_tokens_details: z.object({
-    reasoning_tokens: z.number().nullish()
+  completion_tokens_details: z2.looseObject({
+    reasoning_tokens: z2.number().nullish()
   }).nullish()
 }).nullish();
-var moonshotAIErrorSchema = z.object({
-  error: z.object({
-    message: z.string(),
-    type: z.string().nullish()
+var moonshotAIErrorSchema = z2.object({
+  error: z2.object({
+    message: z2.string(),
+    type: z2.string().nullish(),
+    code: z2.string().nullish()
   })
 });
-var moonshotAIChatResponseSchema = z.object({
-  id: z.string().nullish(),
-  created: z.number().nullish(),
-  model: z.string().nullish(),
-  choices: z.array(
-    z.object({
-      message: z.object({
-        role: z.literal("assistant").nullish(),
-        content: z.string().nullish(),
-        reasoning_content: z.string().nullish(),
-        tool_calls: z.array(
-          z.object({
-            id: z.string().nullish(),
-            function: z.object({
-              name: z.string(),
-              arguments: z.string()
+var moonshotAIChatLogprobSchema = z2.object({
+  token: z2.string(),
+  logprob: z2.number(),
+  bytes: z2.array(z2.number()).nullable(),
+  top_logprobs: z2.array(
+    z2.object({
+      token: z2.string(),
+      logprob: z2.number(),
+      bytes: z2.array(z2.number()).nullable()
+    })
+  )
+});
+var moonshotAIChatLogprobsSchema = z2.object({
+  content: z2.array(moonshotAIChatLogprobSchema).nullish()
+}).nullish();
+var moonshotAIChatResponseSchema = z2.object({
+  id: z2.string().nullish(),
+  created: z2.number().nullish(),
+  model: z2.string().nullish(),
+  object: z2.literal("chat.completion").nullish(),
+  choices: z2.array(
+    z2.object({
+      index: z2.number().nullish(),
+      message: z2.object({
+        role: z2.literal("assistant").nullish(),
+        content: z2.string().nullish(),
+        reasoning_content: z2.string().nullish(),
+        tool_calls: z2.array(
+          z2.object({
+            id: z2.string().nullish(),
+            type: z2.literal("function").nullish(),
+            function: z2.object({
+              name: z2.string(),
+              arguments: z2.string()
             })
           })
         ).nullish()
       }),
-      finish_reason: z.string().nullish()
+      logprobs: moonshotAIChatLogprobsSchema,
+      finish_reason: z2.string().nullish()
     })
   ),
   usage: tokenUsageSchema
 });
 var moonshotAIChatChunkSchema = lazySchema(
   () => zodSchema(
-    z.union([
-      z.object({
-        id: z.string().nullish(),
-        created: z.number().nullish(),
-        model: z.string().nullish(),
-        choices: z.array(
-          z.object({
-            delta: z.object({
-              role: z.literal("assistant").nullish(),
-              content: z.string().nullish(),
-              reasoning_content: z.string().nullish(),
-              tool_calls: z.array(
-                z.object({
-                  index: z.number(),
-                  id: z.string().nullish(),
-                  function: z.object({
-                    name: z.string().nullish(),
-                    arguments: z.string().nullish()
+    z2.union([
+      z2.object({
+        id: z2.string().nullish(),
+        created: z2.number().nullish(),
+        model: z2.string().nullish(),
+        object: z2.literal("chat.completion.chunk").nullish(),
+        choices: z2.array(
+          z2.object({
+            index: z2.number().nullish(),
+            delta: z2.object({
+              role: z2.literal("assistant").nullish(),
+              content: z2.string().nullish(),
+              reasoning_content: z2.string().nullish(),
+              tool_calls: z2.array(
+                z2.object({
+                  index: z2.number().nullish(),
+                  id: z2.string().nullish(),
+                  type: z2.literal("function").nullish(),
+                  function: z2.object({
+                    name: z2.string().nullish(),
+                    arguments: z2.string().nullish()
                   })
                 })
               ).nullish()
             }).nullish(),
-            finish_reason: z.string().nullish()
+            logprobs: moonshotAIChatLogprobsSchema,
+            finish_reason: z2.string().nullish(),
+            usage: tokenUsageSchema
           })
         ),
         usage: tokenUsageSchema
@@ -313,177 +751,6 @@ var moonshotAIChatChunkSchema = lazySchema(
   )
 );
 
-// src/moonshotai-chat-options.ts
-import { z as z2 } from "zod/v4";
-var moonshotaiLanguageModelOptions = z2.object({
-  /**
-   * Reasoning effort for Kimi K3.
-   */
-  reasoningEffort: z2.enum(["low", "high", "max"]).optional(),
-  thinking: z2.object({
-    type: z2.enum(["enabled", "disabled"]).optional(),
-    budgetTokens: z2.number().int().min(1024).optional()
-  }).optional(),
-  reasoningHistory: z2.enum(["disabled", "interleaved", "preserved"]).optional(),
-  /**
-   * Used to cache responses for similar requests to optimize cache hit rates.
-   * Typically a session or task id.
-   */
-  promptCacheKey: z2.string().optional(),
-  /**
-   * A stable identifier used to help Moonshot detect users violating usage
-   * policies. Recommended to hash the username or email address.
-   */
-  safetyIdentifier: z2.string().optional()
-});
-function getModelThinkingKeepSupport(modelId) {
-  return modelId === "kimi-k2.6" || modelId === "kimi-k3" || modelId.startsWith("kimi-k2.7-code");
-}
-
-// src/moonshotai-prepare-tools.ts
-import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
-} from "@ai-sdk/provider";
-
-// src/normalize-json-schema-for-mfjs.ts
-import { UnsupportedFunctionalityError as UnsupportedFunctionalityError2 } from "@ai-sdk/provider";
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var SCHEMA_ARRAY_KEYS = ["allOf", "anyOf", "oneOf", "prefixItems"];
-var SCHEMA_MAP_KEYS = [
-  "properties",
-  "patternProperties",
-  "$defs",
-  "dependentSchemas"
-];
-var SCHEMA_SINGLE_KEYS = [
-  "additionalProperties",
-  "propertyNames",
-  "items",
-  "contains",
-  "not",
-  "if",
-  "then",
-  "else"
-];
-function normalizeJsonSchemaForMFJS(schema) {
-  return normalizeDefinition(schema, true);
-}
-function normalizeDefinition(definition, isRoot) {
-  if (typeof definition === "boolean" || !isRecord(definition)) {
-    if (isRoot) {
-      throw new UnsupportedFunctionalityError2({
-        functionality: 'tool parameters must be a JSON Schema object with type "object" for moonshotai (MFJS)'
-      });
-    }
-    return definition;
-  }
-  if (isRoot && definition.type !== "object") {
-    throw new UnsupportedFunctionalityError2({
-      functionality: 'tool parameters must be a JSON Schema object with type "object" for moonshotai (MFJS)'
-    });
-  }
-  const result = { ...definition };
-  if (Array.isArray(result.items)) {
-    const tuple = result.items;
-    result.prefixItems = [
-      ...Array.isArray(result.prefixItems) ? result.prefixItems : [],
-      ...tuple.map((item) => normalizeDefinition(item, false))
-    ];
-    delete result.items;
-  } else if (isRecord(result.items)) {
-    result.items = normalizeDefinition(result.items, false);
-  }
-  if (typeof result.type === "string" && Array.isArray(result.anyOf)) {
-    const parentType = result.type;
-    delete result.type;
-    result.anyOf = result.anyOf.map(
-      (branch) => isRecord(branch) && branch.type == null ? { type: parentType, ...branch } : branch
-    );
-  }
-  for (const key of SCHEMA_ARRAY_KEYS) {
-    const value = result[key];
-    if (Array.isArray(value)) {
-      result[key] = value.map((item) => normalizeDefinition(item, false));
-    }
-  }
-  for (const key of SCHEMA_MAP_KEYS) {
-    const value = result[key];
-    if (isRecord(value)) {
-      result[key] = Object.fromEntries(
-        Object.entries(value).map(([k, v]) => [
-          k,
-          normalizeDefinition(v, false)
-        ])
-      );
-    }
-  }
-  for (const key of SCHEMA_SINGLE_KEYS) {
-    const value = result[key];
-    if (isRecord(value) || typeof value === "boolean") {
-      result[key] = normalizeDefinition(value, false);
-    }
-  }
-  return result;
-}
-
-// src/moonshotai-prepare-tools.ts
-function prepareTools({
-  tools,
-  toolChoice
-}) {
-  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
-  const toolWarnings = [];
-  if (tools == null) {
-    return { tools: void 0, toolChoice: void 0, toolWarnings };
-  }
-  const moonshotTools = [];
-  for (const tool of tools) {
-    if (tool.type === "provider") {
-      toolWarnings.push({
-        type: "unsupported",
-        feature: `provider-defined tool ${tool.id}`
-      });
-    } else {
-      moonshotTools.push({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: normalizeJsonSchemaForMFJS(tool.inputSchema),
-          ...tool.strict != null ? { strict: tool.strict } : {}
-        }
-      });
-    }
-  }
-  if (toolChoice == null) {
-    return { tools: moonshotTools, toolChoice: void 0, toolWarnings };
-  }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-    case "none":
-    case "required":
-      return { tools: moonshotTools, toolChoice: type, toolWarnings };
-    case "tool":
-      return {
-        tools: moonshotTools,
-        toolChoice: {
-          type: "function",
-          function: { name: toolChoice.toolName }
-        },
-        toolWarnings
-      };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError3({
-        functionality: `tool choice type: ${_exhaustiveCheck}`
-      });
-    }
-  }
-}
-
 // src/moonshotai-chat-language-model.ts
 var MoonshotAIChatLanguageModel = class {
   constructor(modelId, config) {
@@ -523,13 +790,12 @@ var MoonshotAIChatLanguageModel = class {
     toolChoice,
     tools
   }) {
-    var _a, _b;
+    var _a, _b, _c;
     const moonshotOptions = (_a = await parseProviderOptions({
       provider: this.providerOptionsName,
       providerOptions,
       schema: moonshotaiLanguageModelOptions
     })) != null ? _a : {};
-    const messages = convertToMoonshotAIChatMessages(prompt);
     const allWarnings = [];
     if (topK != null) {
       allWarnings.push({ type: "unsupported", feature: "topK" });
@@ -537,22 +803,141 @@ var MoonshotAIChatLanguageModel = class {
     if (seed != null) {
       allWarnings.push({ type: "unsupported", feature: "seed" });
     }
+    const supportsSamplingOptions = !isMoonshotAIKimiModel(this.modelId);
+    if (!supportsSamplingOptions && temperature != null) {
+      allWarnings.push({
+        type: "unsupported",
+        feature: "temperature",
+        details: `temperature is fixed by model "${this.modelId}" and has been omitted.`
+      });
+    }
+    if (!supportsSamplingOptions && topP != null) {
+      allWarnings.push({
+        type: "unsupported",
+        feature: "topP",
+        details: `topP is fixed by model "${this.modelId}" and has been omitted.`
+      });
+    }
+    if (!supportsSamplingOptions && frequencyPenalty != null) {
+      allWarnings.push({
+        type: "unsupported",
+        feature: "frequencyPenalty",
+        details: `frequencyPenalty is fixed by model "${this.modelId}" and has been omitted.`
+      });
+    }
+    if (!supportsSamplingOptions && presencePenalty != null) {
+      allWarnings.push({
+        type: "unsupported",
+        feature: "presencePenalty",
+        details: `presencePenalty is fixed by model "${this.modelId}" and has been omitted.`
+      });
+    }
     const {
       tools: moonshotTools,
       toolChoice: moonshotToolChoice,
       toolWarnings
-    } = prepareTools({ tools, toolChoice });
-    const thinking = moonshotOptions.thinking;
-    let keep;
-    if (moonshotOptions.reasoningHistory === "preserved") {
-      if (getModelThinkingKeepSupport(this.modelId)) {
-        keep = "all";
-      } else {
+    } = prepareTools({ tools, toolChoice, modelId: this.modelId });
+    const modelFamily = getMoonshotAIModelFamily(this.modelId);
+    const requestedThinking = moonshotOptions.thinking;
+    const requestedReasoningEffort = moonshotOptions.reasoningEffort;
+    const preserveReasoning = moonshotOptions.reasoningHistory === "preserved";
+    if ((requestedThinking == null ? void 0 : requestedThinking.budgetTokens) != null) {
+      allWarnings.push({
+        type: "other",
+        message: "providerOptions.moonshotai.thinking.budgetTokens is deprecated because Moonshot Chat Completions does not support budget_tokens. The option has been omitted."
+      });
+    }
+    let thinking;
+    let reasoningEffort;
+    const warnUnsupportedReasoningEffort = () => {
+      if (requestedReasoningEffort != null) {
         allWarnings.push({
           type: "unsupported",
-          feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`
+          feature: "reasoningEffort",
+          details: `reasoningEffort is only supported by Kimi K3 and has been omitted for model "${this.modelId}".`
         });
       }
+    };
+    switch (modelFamily) {
+      case "kimi-k3": {
+        if (requestedThinking != null) {
+          allWarnings.push({
+            type: "unsupported",
+            feature: "thinking",
+            details: "Kimi K3 always reasons and does not accept the thinking field. The option has been omitted."
+          });
+        }
+        reasoningEffort = requestedReasoningEffort;
+        break;
+      }
+      case "kimi-k2.7": {
+        warnUnsupportedReasoningEffort();
+        if ((requestedThinking == null ? void 0 : requestedThinking.type) === "disabled") {
+          allWarnings.push({
+            type: "unsupported",
+            feature: 'thinking.type "disabled"',
+            details: "Kimi K2.7 thinking cannot be disabled."
+          });
+        } else if ((requestedThinking == null ? void 0 : requestedThinking.type) === "enabled") {
+          thinking = { type: "enabled" };
+        }
+        break;
+      }
+      case "kimi-k2.6": {
+        warnUnsupportedReasoningEffort();
+        const thinkingType = requestedThinking == null ? void 0 : requestedThinking.type;
+        if (thinkingType != null || preserveReasoning) {
+          thinking = {
+            type: thinkingType != null ? thinkingType : "enabled",
+            ...preserveReasoning ? { keep: "all" } : {}
+          };
+        }
+        break;
+      }
+      case "kimi-k2.5": {
+        warnUnsupportedReasoningEffort();
+        const thinkingType = requestedThinking == null ? void 0 : requestedThinking.type;
+        if (thinkingType != null) {
+          thinking = { type: thinkingType };
+        }
+        if (preserveReasoning) {
+          allWarnings.push({
+            type: "unsupported",
+            feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`
+          });
+        }
+        break;
+      }
+      case "moonshot-v1": {
+        warnUnsupportedReasoningEffort();
+        if (requestedThinking != null) {
+          allWarnings.push({
+            type: "unsupported",
+            feature: "thinking",
+            details: `thinking is not supported by model "${this.modelId}" and has been omitted.`
+          });
+        }
+        if (preserveReasoning) {
+          allWarnings.push({
+            type: "unsupported",
+            feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`
+          });
+        }
+        break;
+      }
+      case "unknown": {
+        reasoningEffort = requestedReasoningEffort;
+        if ((requestedThinking == null ? void 0 : requestedThinking.type) != null) {
+          thinking = { type: requestedThinking.type };
+        }
+        if (preserveReasoning) {
+          allWarnings.push({
+            type: "unsupported",
+            feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`
+          });
+        }
+        break;
+      }
     }
     let response_format;
     if ((responseFormat == null ? void 0 : responseFormat.type) === "json") {
@@ -562,40 +947,44 @@ var MoonshotAIChatLanguageModel = class {
           type: "json_schema",
           json_schema: {
             name: (_b = responseFormat.name) != null ? _b : "response",
-            schema: schemaWithoutDollarSchema,
-            ...responseFormat.description != null && {
-              description: responseFormat.description
-            }
+            strict: (_c = moonshotOptions.strictJsonSchema) != null ? _c : true,
+            schema: normalizeJsonSchemaForMFJS(schemaWithoutDollarSchema)
           }
         };
       } else {
         response_format = { type: "json_object" };
       }
     }
+    const { messages, warnings: messageWarnings } = convertToMoonshotAIChatMessages({
+      modelId: this.modelId,
+      prompt,
+      providerOptionsName: this.providerOptionsName,
+      responseFormat: response_format
+    });
+    allWarnings.push(...messageWarnings);
     return {
       args: {
         model: this.modelId,
-        max_tokens: maxOutputTokens,
-        temperature,
-        top_p: topP,
-        frequency_penalty: frequencyPenalty,
-        presence_penalty: presencePenalty,
+        ...(moonshotOptions.logprobs === true || moonshotOptions.topLogprobs != null) && { logprobs: true },
+        ...moonshotOptions.topLogprobs != null && {
+          top_logprobs: moonshotOptions.topLogprobs
+        },
+        max_completion_tokens: maxOutputTokens,
+        temperature: supportsSamplingOptions ? temperature : void 0,
+        top_p: supportsSamplingOptions ? topP : void 0,
+        frequency_penalty: supportsSamplingOptions ? frequencyPenalty : void 0,
+        presence_penalty: supportsSamplingOptions ? presencePenalty : void 0,
         response_format,
         stop: stopSequences,
         messages,
         tools: moonshotTools,
         tool_choice: moonshotToolChoice,
-        ...thinking != null || keep != null ? {
-          thinking: {
-            ...(thinking == null ? void 0 : thinking.type) != null && { type: thinking.type },
-            ...(thinking == null ? void 0 : thinking.budgetTokens) !== void 0 && {
-              budget_tokens: thinking.budgetTokens
-            },
-            ...keep != null && { keep }
-          }
-        } : {},
-        ...moonshotOptions.reasoningEffort != null && {
-          reasoning_effort: moonshotOptions.reasoningEffort
+        ...moonshotOptions.prediction != null && {
+          prediction: moonshotOptions.prediction
+        },
+        ...thinking != null ? { thinking } : {},
+        ...reasoningEffort != null && {
+          reasoning_effort: reasoningEffort
         },
         ...moonshotOptions.promptCacheKey != null && {
           prompt_cache_key: moonshotOptions.promptCacheKey
@@ -655,6 +1044,21 @@ var MoonshotAIChatLanguageModel = class {
         raw: (_e = choice.finish_reason) != null ? _e : void 0
       },
       usage: convertMoonshotAIChatUsage(responseBody.usage),
+      providerMetadata: {
+        [this.providerOptionsName]: {
+          ...responseBody.object != null && {
+            responseObject: responseBody.object
+          },
+          ...choice.index != null && { choiceIndex: choice.index },
+          ...choice.message.role != null && {
+            messageRole: choice.message.role
+          },
+          ...choice.message.tool_calls != null && {
+            toolCallTypes: choice.message.tool_calls.map((toolCall) => toolCall.type).filter((type) => type != null)
+          },
+          ...choice.logprobs != null && { logprobs: choice.logprobs }
+        }
+      },
       request: { body: args },
       response: {
         ...getResponseMetadata(responseBody),
@@ -693,10 +1097,17 @@ var MoonshotAIChatLanguageModel = class {
       unified: "other",
       raw: void 0
     };
-    let usage = void 0;
+    let topLevelUsage = void 0;
+    let choiceUsage = void 0;
+    const contentLogprobs = [];
+    const providerOptionsName = this.providerOptionsName;
     let isFirstChunk = true;
     let isActiveReasoning = false;
     let isActiveText = false;
+    let responseObject;
+    let choiceIndex;
+    let messageRole;
+    const toolCallTypes = /* @__PURE__ */ new Map();
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -704,7 +1115,7 @@ var MoonshotAIChatLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a2, _b2, _c, _d, _e, _f;
+            var _a2, _b2, _c, _d, _e, _f, _g, _h;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
@@ -716,7 +1127,7 @@ var MoonshotAIChatLanguageModel = class {
             const value = chunk.value;
             if ("error" in value) {
               finishReason = { unified: "error", raw: void 0 };
-              controller.enqueue({ type: "error", error: value.error.message });
+              controller.enqueue({ type: "error", error: value.error });
               return;
             }
             if (isFirstChunk) {
@@ -727,19 +1138,34 @@ var MoonshotAIChatLanguageModel = class {
               });
             }
             if (value.usage != null) {
-              usage = value.usage;
+              topLevelUsage = value.usage;
+            }
+            if (value.object != null) {
+              responseObject = value.object;
             }
             const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.usage) != null) {
+              choiceUsage = choice.usage;
+            }
+            if ((choice == null ? void 0 : choice.index) != null) {
+              choiceIndex = choice.index;
+            }
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
               finishReason = {
                 unified: mapMoonshotAIFinishReason(choice.finish_reason),
                 raw: choice.finish_reason
               };
             }
+            if (((_a2 = choice == null ? void 0 : choice.logprobs) == null ? void 0 : _a2.content) != null) {
+              contentLogprobs.push(...choice.logprobs.content);
+            }
             if ((choice == null ? void 0 : choice.delta) == null) {
               return;
             }
             const delta = choice.delta;
+            if (delta.role != null) {
+              messageRole = delta.role;
+            }
             const reasoningContent = delta.reasoning_content;
             if (reasoningContent) {
               if (!isActiveReasoning) {
@@ -781,8 +1207,14 @@ var MoonshotAIChatLanguageModel = class {
                 });
                 isActiveReasoning = false;
               }
-              for (const toolCallDelta of delta.tool_calls) {
-                const index = toolCallDelta.index;
+              for (const [
+                fallbackIndex,
+                toolCallDelta
+              ] of delta.tool_calls.entries()) {
+                const index = (_b2 = toolCallDelta.index) != null ? _b2 : fallbackIndex;
+                if (toolCallDelta.type != null) {
+                  toolCallTypes.set(index, toolCallDelta.type);
+                }
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.id == null) {
                     throw new InvalidResponseDataError({
@@ -790,7 +1222,7 @@ var MoonshotAIChatLanguageModel = class {
                       message: `Expected 'id' to be a string.`
                     });
                   }
-                  if (((_a2 = toolCallDelta.function) == null ? void 0 : _a2.name) == null) {
+                  if (((_c = toolCallDelta.function) == null ? void 0 : _c.name) == null) {
                     throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
@@ -806,12 +1238,12 @@ var MoonshotAIChatLanguageModel = class {
                     type: "function",
                     function: {
                       name: toolCallDelta.function.name,
-                      arguments: (_b2 = toolCallDelta.function.arguments) != null ? _b2 : ""
+                      arguments: (_d = toolCallDelta.function.arguments) != null ? _d : ""
                     },
                     hasFinished: false
                   };
                   const toolCall2 = toolCalls[index];
-                  if (((_c = toolCall2.function) == null ? void 0 : _c.name) != null && ((_d = toolCall2.function) == null ? void 0 : _d.arguments) != null && toolCall2.function.arguments.length > 0) {
+                  if (((_e = toolCall2.function) == null ? void 0 : _e.name) != null && ((_f = toolCall2.function) == null ? void 0 : _f.arguments) != null && toolCall2.function.arguments.length > 0) {
                     controller.enqueue({
                       type: "tool-input-delta",
                       id: toolCall2.id,
@@ -824,13 +1256,13 @@ var MoonshotAIChatLanguageModel = class {
                 if (toolCall.hasFinished) {
                   continue;
                 }
-                if (((_e = toolCallDelta.function) == null ? void 0 : _e.arguments) != null) {
+                if (((_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null) {
                   toolCall.function.arguments += toolCallDelta.function.arguments;
                 }
                 controller.enqueue({
                   type: "tool-input-delta",
                   id: toolCall.id,
-                  delta: (_f = toolCallDelta.function.arguments) != null ? _f : ""
+                  delta: (_h = toolCallDelta.function.arguments) != null ? _h : ""
                 });
               }
             }
@@ -859,7 +1291,22 @@ var MoonshotAIChatLanguageModel = class {
             controller.enqueue({
               type: "finish",
               finishReason,
-              usage: convertMoonshotAIChatUsage(usage)
+              usage: convertMoonshotAIChatUsage(topLevelUsage != null ? topLevelUsage : choiceUsage),
+              providerMetadata: {
+                [providerOptionsName]: {
+                  ...responseObject != null && { responseObject },
+                  ...choiceIndex != null && { choiceIndex },
+                  ...messageRole != null && { messageRole },
+                  ...toolCallTypes.size > 0 && {
+                    toolCallTypes: [...toolCallTypes.entries()].sort(([left], [right]) => left - right).map(([, type]) => type)
+                  },
+                  ...contentLogprobs.length > 0 && {
+                    logprobs: {
+                      content: contentLogprobs
+                    }
+                  }
+                }
+              }
             });
           }
         })
@@ -871,13 +1318,12 @@ var MoonshotAIChatLanguageModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "2.0.49" : "0.0.0-test";
+var VERSION = true ? "2.0.53" : "0.0.0-test";
 
 // src/moonshotai-provider.ts
 var defaultBaseURL = "https://api.moonshot.ai/v1";
 function getModelStructuredOutputSupport(modelId) {
-  if (modelId.startsWith("kimi-k")) return true;
-  return false;
+  return modelId.startsWith("kimi-k") || modelId === "moonshot-v1-8k" || modelId === "moonshot-v1-32k" || modelId === "moonshot-v1-128k" || modelId === "moonshot-v1-auto" || modelId === "moonshot-v1-8k-vision-preview" || modelId === "moonshot-v1-32k-vision-preview" || modelId === "moonshot-v1-128k-vision-preview";
 }
 function createMoonshotAI(options = {}) {
   var _a;