@ai-sdk/moonshotai 3.0.38 → 3.0.41

package/dist/index.js

@@ -15,10 +15,11 @@ import {
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
   createLanguageModelResponseMetadata as getResponseMetadata,
+  createProviderStreamError,
   generateId,
   isCustomReasoning,
   mapReasoningToProviderEffort,
-  parseProviderOptions,
+  parseProviderOptions as parseProviderOptions2,
   postJsonToApi,
   serializeModelOptions,
   StreamingToolCallTracker,
@@ -28,28 +29,391 @@ import {
 
 // src/convert-to-moonshotai-chat-messages.ts
 import {
-  UnsupportedFunctionalityError
+  InvalidPromptError,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } from "@ai-sdk/provider";
 import {
   convertBase64ToUint8Array,
   convertToBase64,
   getTopLevelMediaType,
+  parseProviderOptions,
+  resolveProviderReference,
   resolveFullMediaType
 } 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";
+import { isRecord } from "@ai-sdk/provider-utils";
+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
+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 formatMediaUrl({
+  part,
+  supportedMediaTypes,
+  topLevelMediaType
+}) {
+  if (part.data.type !== "url" && part.data.type !== "data") {
+    throw new UnsupportedFunctionalityError3({
+      functionality: `file part data type ${part.data.type}`
+    });
+  }
+  const mediaType = part.data.type === "url" ? part.mediaType : resolveFullMediaType({ part });
+  if (!supportedMediaTypes.includes(mediaType) && !(part.data.type === "url" && (mediaType === topLevelMediaType || mediaType === `${topLevelMediaType}/*`))) {
+    throw new UnsupportedFunctionalityError3({
+      functionality: `file part media type ${mediaType}`
+    });
+  }
+  return part.data.type === "url" ? part.data.url.toString() : `data:${mediaType};base64,${convertToBase64(part.data.data)}`;
+}
+async 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 = await parseProviderOptions({
+      provider: providerOptionsName,
+      providerOptions,
+      schema: moonshotaiAllMessageProviderOptions
+    });
+    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;
         }
@@ -61,25 +425,53 @@ function convertToMoonshotAIChatMessages(prompt) {
                 return { type: "text", text: part.text };
               }
               case "file": {
+                const topLevel = getTopLevelMediaType(part.mediaType);
                 switch (part.data.type) {
                   case "reference": {
-                    throw new UnsupportedFunctionalityError({
-                      functionality: "file parts with provider references"
+                    if (topLevel !== "image" && topLevel !== "video") {
+                      throw new UnsupportedFunctionalityError3({
+                        functionality: `file part media type ${part.mediaType}`
+                      });
+                    }
+                    const reference = resolveProviderReference({
+                      reference: part.data.reference,
+                      provider: "moonshotai"
                     });
+                    if (!reference.startsWith("ms://")) {
+                      throw new UnsupportedFunctionalityError3({
+                        functionality: "Moonshot file provider references without an ms:// URL"
+                      });
+                    }
+                    return topLevel === "image" ? {
+                      type: "image_url",
+                      image_url: { url: reference }
+                    } : {
+                      type: "video_url",
+                      video_url: { url: reference }
+                    };
                   }
                   case "text": {
-                    throw new UnsupportedFunctionalityError({
-                      functionality: "text file parts"
+                    if (topLevel === "text") {
+                      return {
+                        type: "text",
+                        text: part.data.text
+                      };
+                    }
+                    throw new UnsupportedFunctionalityError3({
+                      functionality: `file part media type ${part.mediaType}`
                     });
                   }
                   case "url":
                   case "data": {
-                    const topLevel = getTopLevelMediaType(part.mediaType);
                     if (topLevel === "image") {
                       return {
                         type: "image_url",
                         image_url: {
-                          url: part.data.type === "url" ? part.data.url.toString() : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`
+                          url: formatMediaUrl({
+                            part,
+                            supportedMediaTypes: supportedImageMediaTypes,
+                            topLevelMediaType: "image"
+                          })
                         }
                       };
                     }
@@ -87,7 +479,11 @@ function convertToMoonshotAIChatMessages(prompt) {
                       return {
                         type: "video_url",
                         video_url: {
-                          url: part.data.type === "url" ? part.data.url.toString() : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`
+                          url: formatMediaUrl({
+                            part,
+                            supportedMediaTypes: supportedVideoMediaTypes,
+                            topLevelMediaType: "video"
+                          })
                         }
                       };
                     }
@@ -100,18 +496,35 @@ 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 = [];
@@ -141,12 +554,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;
@@ -159,7 +584,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":
@@ -181,7 +606,7 @@ function convertToMoonshotAIChatMessages(prompt) {
       }
     }
   }
-  return messages;
+  return { messages, warnings };
 }
 
 // src/convert-moonshotai-chat-usage.ts
@@ -230,75 +655,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
@@ -308,176 +758,48 @@ 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";
-import { isRecord } from "@ai-sdk/provider-utils";
-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-chat-language-model.ts
+function createMoonshotAIStreamError(error, data) {
+  var _a, _b;
+  return createProviderStreamError({
+    message: error.message,
+    type: (_a = error.type) != null ? _a : void 0,
+    code: (_b = error.code) != null ? _b : void 0,
+    ...getMoonshotAIStreamErrorMetadata(error.type),
+    data
+  });
 }
-
-// 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;
+function getMoonshotAIStreamErrorMetadata(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}`
-      });
-    }
+    case "rate_limit_exceeded":
+    case "rate_limit_error":
+      return { statusCode: 429, isRetryable: true };
+    case "server_error":
+    case "api_error":
+    case "internal_server_error":
+      return { statusCode: 500, isRetryable: true };
+    case "overloaded_error":
+    case "service_unavailable":
+      return { statusCode: 503, isRetryable: true };
+    case "timeout":
+    case "timeout_error":
+      return { statusCode: 504, isRetryable: true };
+    case "authentication_error":
+    case "invalid_api_key":
+      return { statusCode: 401, isRetryable: false };
+    case "permission_error":
+      return { statusCode: 403, isRetryable: false };
+    case "not_found_error":
+    case "model_not_found":
+      return { statusCode: 404, isRetryable: false };
+    case "bad_request":
+    case "context_length_exceeded":
+    case "invalid_request_error":
+      return { statusCode: 400, isRetryable: false };
+    default:
+      return {};
   }
 }
-
-// src/moonshotai-chat-language-model.ts
 var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
@@ -526,13 +848,12 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
     toolChoice,
     tools
   }) {
-    var _a, _b, _c;
-    const moonshotOptions = (_a = await parseProviderOptions({
+    var _a, _b, _c, _d, _e;
+    const moonshotOptions = (_a = await parseProviderOptions2({
       provider: this.providerOptionsName,
       providerOptions,
       schema: moonshotaiLanguageModelOptions
     })) != null ? _a : {};
-    const messages = convertToMoonshotAIChatMessages(prompt);
     const allWarnings = [];
     if (topK != null) {
       allWarnings.push({ type: "unsupported", feature: "topK" });
@@ -540,40 +861,184 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
     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: "deprecated",
+        setting: "providerOptions.moonshotai.thinking.budgetTokens",
+        message: "Moonshot Chat Completions does not support budget_tokens. Remove budgetTokens; 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."
+          });
+        }
+        if (reasoning === "none") {
+          allWarnings.push({
+            type: "unsupported",
+            feature: 'reasoning "none"',
+            details: "Kimi K3 reasoning cannot be disabled."
+          });
+        }
+        reasoningEffort = requestedReasoningEffort != null ? requestedReasoningEffort : isCustomReasoning(reasoning) && reasoning !== "none" ? mapReasoningToProviderEffort({
+          reasoning,
+          effortMap: {
+            minimal: "low",
+            low: "low",
+            medium: "high",
+            high: "high",
+            xhigh: "max"
+          },
+          warnings: allWarnings
+        }) : void 0;
+        break;
+      }
+      case "kimi-k2.7": {
+        warnUnsupportedReasoningEffort();
+        if ((requestedThinking == null ? void 0 : requestedThinking.type) === "disabled" || reasoning === "none") {
+          allWarnings.push({
+            type: "unsupported",
+            feature: (requestedThinking == null ? void 0 : requestedThinking.type) === "disabled" ? 'thinking.type "disabled"' : 'reasoning "none"',
+            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 = (_b = requestedThinking == null ? void 0 : requestedThinking.type) != null ? _b : isCustomReasoning(reasoning) ? reasoning === "none" ? "disabled" : "enabled" : void 0;
+        if (thinkingType != null || preserveReasoning) {
+          thinking = {
+            type: thinkingType != null ? thinkingType : "enabled",
+            ...preserveReasoning ? { keep: "all" } : {}
+          };
+        }
+        break;
+      }
+      case "kimi-k2.5": {
+        warnUnsupportedReasoningEffort();
+        const thinkingType = (_c = requestedThinking == null ? void 0 : requestedThinking.type) != null ? _c : isCustomReasoning(reasoning) ? reasoning === "none" ? "disabled" : "enabled" : void 0;
+        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 (isCustomReasoning(reasoning) && reasoning !== "none") {
+          allWarnings.push({
+            type: "unsupported",
+            feature: "reasoning",
+            details: `reasoning is not supported by model "${this.modelId}".`
+          });
+        }
+        if (preserveReasoning) {
+          allWarnings.push({
+            type: "unsupported",
+            feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`
+          });
+        }
+        break;
+      }
+      case "unknown": {
+        if (reasoning === "none") {
+          allWarnings.push({
+            type: "unsupported",
+            feature: 'reasoning "none"',
+            details: "Use providerOptions.moonshotai.thinking to control thinking on custom models."
+          });
+        }
+        reasoningEffort = requestedReasoningEffort != null ? requestedReasoningEffort : isCustomReasoning(reasoning) && reasoning !== "none" ? mapReasoningToProviderEffort({
+          reasoning,
+          effortMap: {
+            minimal: "low",
+            low: "low",
+            medium: "high",
+            high: "high",
+            xhigh: "max"
+          },
+          warnings: allWarnings
+        }) : void 0;
+        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;
+      }
     }
-    if (reasoning === "none") {
-      allWarnings.push({
-        type: "unsupported",
-        feature: 'reasoning "none" (use providerOptions.moonshotai.thinking to control thinking)'
-      });
-    }
-    const reasoningEffort = (_b = moonshotOptions.reasoningEffort) != null ? _b : isCustomReasoning(reasoning) && reasoning !== "none" ? mapReasoningToProviderEffort({
-      reasoning,
-      effortMap: {
-        minimal: "low",
-        low: "low",
-        medium: "high",
-        high: "high",
-        xhigh: "max"
-      },
-      warnings: allWarnings
-    }) : void 0;
     let response_format;
     if ((responseFormat == null ? void 0 : responseFormat.type) === "json") {
       if (this.config.supportsStructuredOutputs === true && responseFormat.schema != null) {
@@ -581,39 +1046,43 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
         response_format = {
           type: "json_schema",
           json_schema: {
-            name: (_c = responseFormat.name) != null ? _c : "response",
-            schema: schemaWithoutDollarSchema,
-            ...responseFormat.description != null && {
-              description: responseFormat.description
-            }
+            name: (_d = responseFormat.name) != null ? _d : "response",
+            strict: (_e = moonshotOptions.strictJsonSchema) != null ? _e : true,
+            schema: normalizeJsonSchemaForMFJS(schemaWithoutDollarSchema)
           }
         };
       } else {
         response_format = { type: "json_object" };
       }
     }
+    const { messages, warnings: messageWarnings } = await 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.prediction != null && {
+          prediction: moonshotOptions.prediction
+        },
+        ...thinking != null ? { thinking } : {},
         ...reasoningEffort != null && {
           reasoning_effort: reasoningEffort
         },
@@ -675,6 +1144,21 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
         raw: (_d = choice.finish_reason) != null ? _d : void 0
       },
       usage: convertMoonshotAIChatUsage(responseBody.usage),
+      providerMetadata: {
+        [this.providerOptionsName]: {
+          ...choice.logprobs != null && { logprobs: choice.logprobs },
+          ...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)
+          }
+        }
+      },
       request: { body: args },
       response: {
         ...getResponseMetadata(responseBody),
@@ -713,10 +1197,17 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
       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({
@@ -727,6 +1218,7 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
+            var _a2, _b2;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
@@ -738,7 +1230,10 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
             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: createMoonshotAIStreamError(value.error, value)
+              });
               return;
             }
             if (isFirstChunk) {
@@ -749,19 +1244,34 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
               });
             }
             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) {
@@ -803,8 +1313,15 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
                 });
                 isActiveReasoning = false;
               }
-              for (const toolCallDelta of delta.tool_calls) {
-                toolCallTracker.processDelta(toolCallDelta);
+              for (const [index, toolCallDelta] of delta.tool_calls.entries()) {
+                const toolCallIndex = (_b2 = toolCallDelta.index) != null ? _b2 : index;
+                if (toolCallDelta.type != null) {
+                  toolCallTypes.set(toolCallIndex, toolCallDelta.type);
+                }
+                toolCallTracker.processDelta({
+                  ...toolCallDelta,
+                  index: toolCallIndex
+                });
               }
             }
           },
@@ -819,7 +1336,20 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
             controller.enqueue({
               type: "finish",
               finishReason,
-              usage: convertMoonshotAIChatUsage(usage)
+              usage: convertMoonshotAIChatUsage(topLevelUsage != null ? topLevelUsage : choiceUsage),
+              providerMetadata: {
+                [providerOptionsName]: {
+                  ...contentLogprobs.length > 0 && {
+                    logprobs: { content: contentLogprobs }
+                  },
+                  ...responseObject != null && { responseObject },
+                  ...choiceIndex != null && { choiceIndex },
+                  ...messageRole != null && { messageRole },
+                  ...toolCallTypes.size > 0 && {
+                    toolCallTypes: [...toolCallTypes.entries()].sort(([left], [right]) => left - right).map(([, type]) => type)
+                  }
+                }
+              }
             });
           }
         })
@@ -831,13 +1361,12 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
 };
 
 // src/version.ts
-var VERSION = true ? "3.0.38" : "0.0.0-test";
+var VERSION = true ? "3.0.41" : "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;