@ai-sdk/moonshotai 0.0.20 → 0.0.24

package/dist/index.js

@@ -26,12 +26,15 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/moonshotai-provider.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_v4 = require("zod/v4");
+var import_provider3 = require("@ai-sdk/provider");
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_v43 = require("zod/v4");
 
 // src/moonshotai-chat-language-model.ts
 var import_openai_compatible = require("@ai-sdk/openai-compatible");
+var import_provider2 = require("@ai-sdk/provider");
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_v42 = require("zod/v4");
 
 // src/convert-moonshotai-chat-usage.ts
 function convertMoonshotAIChatUsage(usage) {
@@ -54,37 +57,767 @@ function convertMoonshotAIChatUsage(usage) {
   };
 }
 
+// src/moonshotai-chat-metadata-extractor.ts
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function getFirstChoice(value) {
+  const choices = value.choices;
+  return Array.isArray(choices) && isRecord(choices[0]) ? choices[0] : void 0;
+}
+function getToolCallTypes(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  return value.flatMap(
+    (toolCall) => isRecord(toolCall) && toolCall.type === "function" ? [toolCall.type] : []
+  );
+}
+function extractMetadata(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const choice = getFirstChoice(value);
+  const message = choice != null && isRecord(choice.message) ? choice.message : void 0;
+  const toolCallTypes = getToolCallTypes(message == null ? void 0 : message.tool_calls);
+  return {
+    ...value.object === "chat.completion" && {
+      responseObject: value.object
+    },
+    ...typeof (choice == null ? void 0 : choice.index) === "number" && {
+      choiceIndex: choice.index
+    },
+    ...(message == null ? void 0 : message.role) === "assistant" && {
+      messageRole: message.role
+    },
+    ...toolCallTypes != null && { toolCallTypes }
+  };
+}
+var moonshotAIChatMetadataExtractor = {
+  async extractMetadata({ parsedBody }) {
+    return { moonshotai: extractMetadata(parsedBody) };
+  },
+  createStreamExtractor() {
+    let responseObject;
+    let choiceIndex;
+    let messageRole;
+    const toolCallTypes = /* @__PURE__ */ new Map();
+    return {
+      processChunk(parsedChunk) {
+        if (!isRecord(parsedChunk)) {
+          return;
+        }
+        if (parsedChunk.object === "chat.completion.chunk") {
+          responseObject = parsedChunk.object;
+        }
+        const choice = getFirstChoice(parsedChunk);
+        if (typeof (choice == null ? void 0 : choice.index) === "number") {
+          choiceIndex = choice.index;
+        }
+        const delta = choice != null && isRecord(choice.delta) ? choice.delta : void 0;
+        if ((delta == null ? void 0 : delta.role) === "assistant") {
+          messageRole = delta.role;
+        }
+        if (Array.isArray(delta == null ? void 0 : delta.tool_calls)) {
+          for (const [fallbackIndex, toolCall] of delta.tool_calls.entries()) {
+            if (!isRecord(toolCall) || toolCall.type !== "function") {
+              continue;
+            }
+            const index = typeof toolCall.index === "number" ? toolCall.index : fallbackIndex;
+            toolCallTypes.set(index, toolCall.type);
+          }
+        }
+      },
+      buildMetadata() {
+        return {
+          moonshotai: {
+            ...responseObject != null && { responseObject },
+            ...choiceIndex != null && { choiceIndex },
+            ...messageRole != null && { messageRole },
+            ...toolCallTypes.size > 0 && {
+              toolCallTypes: [...toolCallTypes.entries()].sort(([left], [right]) => left - right).map(([, type]) => type)
+            }
+          }
+        };
+      }
+    };
+  }
+};
+
+// src/moonshotai-chat-options.ts
+var import_v4 = require("zod/v4");
+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";
+}
+function isMoonshotAIKimiModel(modelId) {
+  return getMoonshotAIModelFamily(modelId).startsWith("kimi-");
+}
+var moonshotaiProviderOptions = import_v4.z.object({
+  /**
+   * Whether to use strict JSON schema validation for structured outputs.
+   *
+   * @default true
+   */
+  strictJsonSchema: import_v4.z.boolean().optional(),
+  /**
+   * Whether to return log probabilities for generated tokens.
+   */
+  logprobs: import_v4.z.boolean().optional(),
+  /**
+   * Number of most likely tokens to return at each token position.
+   *
+   * Setting this option automatically enables `logprobs`.
+   */
+  topLogprobs: import_v4.z.number().int().min(0).max(20).optional(),
+  /**
+   * Reasoning effort for Kimi K3. Supports `low`, `high`, and `max`;
+   * defaults to `max`.
+   */
+  reasoningEffort: import_v4.z.enum(["low", "high", "max"]).optional(),
+  /**
+   * Static predicted content that can accelerate responses when much of the
+   * output is known ahead of time.
+   */
+  prediction: import_v4.z.object({
+    type: import_v4.z.literal("content"),
+    content: import_v4.z.union([
+      import_v4.z.string(),
+      import_v4.z.array(import_v4.z.object({ type: import_v4.z.literal("text"), text: import_v4.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: import_v4.z.object({
+    type: import_v4.z.enum(["enabled", "disabled"]).optional(),
+    /**
+     * @deprecated Moonshot Chat Completions does not support thinking
+     * budgets. Accepted for backwards compatibility, then omitted with a
+     * warning.
+     */
+    budgetTokens: import_v4.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: import_v4.z.enum(["disabled", "interleaved", "preserved"]).optional()
+});
+var moonshotaiMessageProviderOptions = import_v4.z.object({
+  /**
+   * The name of the participant represented by the message.
+   *
+   * Supported on system, user, and assistant messages.
+   */
+  name: import_v4.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: import_v4.z.literal(true).optional()
+});
+var moonshotaiDynamicToolSchema = import_v4.z.object({
+  type: import_v4.z.literal("function"),
+  name: import_v4.z.string(),
+  description: import_v4.z.string().optional(),
+  inputSchema: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()),
+  strict: import_v4.z.boolean().optional()
+});
+var moonshotaiAllMessageProviderOptions = moonshotaiAssistantMessageProviderOptions.extend({
+  /** Function tools to load at this point in a Kimi K3 conversation. */
+  tools: import_v4.z.array(moonshotaiDynamicToolSchema).optional()
+});
+
+// src/normalize-json-schema-for-mfjs.ts
+var import_provider = require("@ai-sdk/provider");
+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 isRecord2(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeJsonSchemaForMFJS(schema) {
+  return normalizeDefinition(schema, true);
+}
+function normalizeDefinition(definition, isRoot) {
+  if (typeof definition === "boolean" || !isRecord2(definition)) {
+    if (isRoot) {
+      throw new import_provider.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 import_provider.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 (isRecord2(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) => isRecord2(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 (isRecord2(value)) {
+      result[key] = Object.fromEntries(
+        Object.entries(value).map(([key2, item]) => [
+          key2,
+          normalizeDefinition(item, false)
+        ])
+      );
+    }
+  }
+  for (const key of SCHEMA_SINGLE_KEYS) {
+    const value = result[key];
+    if (isRecord2(value) || typeof value === "boolean") {
+      result[key] = normalizeDefinition(value, false);
+    }
+  }
+  return result;
+}
+
 // src/moonshotai-chat-language-model.ts
+function transformMoonshotRequestBody(args) {
+  var _a, _b, _c;
+  const {
+    strictJsonSchema,
+    max_tokens: maxTokens,
+    logprobs,
+    topLogprobs,
+    ...transformedArgs
+  } = args;
+  const moonshotArgs = {
+    ...transformedArgs,
+    ...(logprobs === true || topLogprobs != null) && { logprobs: true },
+    ...topLogprobs != null && { top_logprobs: topLogprobs },
+    ...maxTokens != null ? { max_completion_tokens: maxTokens } : {}
+  };
+  if (Array.isArray(moonshotArgs.messages)) {
+    moonshotArgs.messages = moonshotArgs.messages.map(
+      (message) => {
+        if (message.role !== "system" || !Array.isArray(message.tools)) {
+          return message;
+        }
+        const { content: _content, ...dynamicToolMessage } = message;
+        return dynamicToolMessage;
+      }
+    );
+  }
+  const responseFormat = moonshotArgs.response_format;
+  if ((responseFormat == null ? void 0 : responseFormat.type) === "json_object" && ((_a = moonshotArgs.messages) == null ? void 0 : _a.some(
+    (message) => message.partial === true
+  ))) {
+    throw new import_provider2.InvalidPromptError({
+      prompt: args.messages,
+      message: "Moonshot AI Partial Mode cannot be combined with JSON object response format."
+    });
+  }
+  if ((responseFormat == null ? void 0 : responseFormat.type) !== "json_schema" || ((_b = responseFormat.json_schema) == null ? void 0 : _b.schema) == null) {
+    return moonshotArgs;
+  }
+  const { $schema: _$schema, ...schemaWithoutDollarSchema } = responseFormat.json_schema.schema;
+  return {
+    ...moonshotArgs,
+    response_format: {
+      type: "json_schema",
+      json_schema: {
+        name: (_c = responseFormat.json_schema.name) != null ? _c : "response",
+        strict: strictJsonSchema != null ? strictJsonSchema : true,
+        schema: normalizeJsonSchemaForMFJS(schemaWithoutDollarSchema)
+      }
+    }
+  };
+}
+var moonshotAIValidatedOptionsSchema = moonshotaiProviderOptions.pick({
+  logprobs: true,
+  topLogprobs: true,
+  prediction: true
+});
+async function validateProviderOptions(options) {
+  await (0, import_provider_utils.parseProviderOptions)({
+    provider: "moonshotai",
+    providerOptions: options.providerOptions,
+    schema: moonshotAIValidatedOptionsSchema
+  });
+}
+async function prepareMessageOptions({
+  modelId,
+  options
+}) {
+  var _a, _b, _c, _d;
+  const prompt = [];
+  const warnings = [];
+  for (const [index, message] of options.prompt.entries()) {
+    const messageOptions = await (0, import_provider_utils.parseProviderOptions)({
+      provider: "moonshotai",
+      providerOptions: message.providerOptions,
+      schema: moonshotaiAllMessageProviderOptions
+    });
+    if ((messageOptions == null ? void 0 : messageOptions.partial) === true && message.role !== "assistant") {
+      throw new import_provider2.InvalidPromptError({
+        prompt: options.prompt,
+        message: "Moonshot AI Partial Mode requires `partial: true` on an assistant message."
+      });
+    }
+    if ((messageOptions == null ? void 0 : messageOptions.tools) != null && message.role !== "system") {
+      throw new import_provider2.InvalidPromptError({
+        prompt: options.prompt,
+        message: "Moonshot dynamic tools must be configured on a system message."
+      });
+    }
+    if ((messageOptions == null ? void 0 : messageOptions.partial) === true && index !== options.prompt.length - 1) {
+      throw new import_provider2.InvalidPromptError({
+        prompt: options.prompt,
+        message: "Moonshot AI Partial Mode requires the partial assistant message to be the final message."
+      });
+    }
+    if (((_a = messageOptions == null ? void 0 : messageOptions.tools) == null ? void 0 : _a.length) && message.role === "system") {
+      if (message.content.length > 0) {
+        throw new import_provider2.InvalidPromptError({
+          prompt: options.prompt,
+          message: "A Moonshot dynamic-tool system message must use empty content because the API forbids content alongside tools."
+        });
+      }
+      const modelFamily = getMoonshotAIModelFamily(modelId);
+      if (modelFamily !== "kimi-k3" && modelFamily !== "unknown") {
+        warnings.push({
+          type: "other",
+          message: `Moonshot documents dynamic tool loading only for Kimi K3. The dynamic system message has been omitted for model "${modelId}".`
+        });
+        continue;
+      }
+      prompt.push({
+        ...message,
+        providerOptions: {
+          ...message.providerOptions,
+          openaiCompatible: {
+            ...(_b = message.providerOptions) == null ? void 0 : _b.openaiCompatible,
+            tools: messageOptions.tools.map((tool) => ({
+              type: "function",
+              function: {
+                name: tool.name,
+                ...tool.description != null ? { description: tool.description } : {},
+                parameters: normalizeJsonSchemaForMFJS(
+                  tool.inputSchema
+                ),
+                ...tool.strict != null ? { strict: tool.strict } : {}
+              }
+            }))
+          }
+        }
+      });
+      continue;
+    }
+    if ((messageOptions == null ? void 0 : messageOptions.name) == null && (messageOptions == null ? void 0 : messageOptions.partial) !== true) {
+      prompt.push(message);
+      continue;
+    }
+    if (message.role === "tool" && (messageOptions == null ? void 0 : messageOptions.name) != null) {
+      warnings.push({
+        type: "other",
+        message: "Moonshot AI does not support message names on tool messages. The name has been omitted."
+      });
+      prompt.push(message);
+      continue;
+    }
+    const openAICompatibleOptions = {
+      ...(_c = message.providerOptions) == null ? void 0 : _c.openaiCompatible,
+      ...messageOptions.name != null && { name: messageOptions.name },
+      ...messageOptions.partial === true && { partial: true }
+    };
+    if (message.role === "user" && message.content.length === 1 && message.content[0].type === "text") {
+      const textPart = message.content[0];
+      prompt.push({
+        ...message,
+        content: [
+          {
+            ...textPart,
+            providerOptions: {
+              ...textPart.providerOptions,
+              openaiCompatible: {
+                ...openAICompatibleOptions,
+                ...(_d = textPart.providerOptions) == null ? void 0 : _d.openaiCompatible,
+                ...messageOptions.name != null && {
+                  name: messageOptions.name
+                }
+              }
+            }
+          }
+        ]
+      });
+      continue;
+    }
+    prompt.push({
+      ...message,
+      providerOptions: {
+        ...message.providerOptions,
+        openaiCompatible: openAICompatibleOptions
+      }
+    });
+  }
+  return {
+    options: { ...options, prompt },
+    warnings
+  };
+}
+var moonshotAIChatLogprobSchema = import_v42.z.object({
+  token: import_v42.z.string(),
+  logprob: import_v42.z.number(),
+  bytes: import_v42.z.array(import_v42.z.number()).nullable(),
+  top_logprobs: import_v42.z.array(
+    import_v42.z.object({
+      token: import_v42.z.string(),
+      logprob: import_v42.z.number(),
+      bytes: import_v42.z.array(import_v42.z.number()).nullable()
+    })
+  )
+});
+var moonshotAIChatLogprobsSchema = import_v42.z.object({
+  content: import_v42.z.array(moonshotAIChatLogprobSchema).nullish()
+}).nullish();
+function extractMoonshotAIChatLogprobs(value) {
+  var _a, _b, _c;
+  const result = moonshotAIChatLogprobsSchema.safeParse(
+    (_b = (_a = value == null ? void 0 : value.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.logprobs
+  );
+  return result.success ? (_c = result.data) != null ? _c : void 0 : void 0;
+}
+function prepareSamplingOptions({
+  modelId,
+  options
+}) {
+  if (!isMoonshotAIKimiModel(modelId)) {
+    return { options, warnings: [] };
+  }
+  const warnings = [];
+  const samplingSettings = [
+    ["temperature", options.temperature],
+    ["topP", options.topP],
+    ["frequencyPenalty", options.frequencyPenalty],
+    ["presencePenalty", options.presencePenalty]
+  ];
+  for (const [setting, value] of samplingSettings) {
+    if (value != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting,
+        details: `${setting} is fixed by model "${modelId}" and has been omitted.`
+      });
+    }
+  }
+  return {
+    options: {
+      ...options,
+      temperature: void 0,
+      topP: void 0,
+      frequencyPenalty: void 0,
+      presencePenalty: void 0
+    },
+    warnings
+  };
+}
+function prepareToolChoiceOptions({
+  modelId,
+  options
+}) {
+  var _a;
+  if (((_a = options.toolChoice) == null ? void 0 : _a.type) !== "required" || !["kimi-k2.6", "kimi-k2.7"].includes(getMoonshotAIModelFamily(modelId))) {
+    return { options, warnings: [] };
+  }
+  return {
+    options: { ...options, toolChoice: void 0 },
+    warnings: [
+      {
+        type: "unsupported-setting",
+        setting: "toolChoice",
+        details: `toolChoice "required" is not supported by model "${modelId}" and has been omitted; use "auto" or select a specific tool instead.`
+      }
+    ]
+  };
+}
+function prepareReasoningOptions({
+  modelId,
+  options
+}) {
+  var _a;
+  const providerOptions = (_a = options.providerOptions) == null ? void 0 : _a.moonshotai;
+  if (providerOptions == null || typeof providerOptions !== "object" || Array.isArray(providerOptions)) {
+    return { options, warnings: [] };
+  }
+  const moonshotOptions = providerOptions;
+  const {
+    reasoningEffort: requestedReasoningEffort,
+    thinking: requestedThinking,
+    reasoningHistory,
+    ...otherMoonshotOptions
+  } = moonshotOptions;
+  const preserveReasoning = reasoningHistory === "preserved";
+  const warnings = [];
+  if ((requestedThinking == null ? void 0 : requestedThinking.budgetTokens) != null) {
+    warnings.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) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "providerOptions",
+        details: `providerOptions.moonshotai.reasoningEffort is only supported by Kimi K3 and has been omitted for model "${modelId}".`
+      });
+    }
+  };
+  switch (getMoonshotAIModelFamily(modelId)) {
+    case "kimi-k3": {
+      if (requestedThinking != null) {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "providerOptions",
+          details: "Kimi K3 always reasons and does not accept providerOptions.moonshotai.thinking. The option has been omitted."
+        });
+      }
+      reasoningEffort = requestedReasoningEffort;
+      break;
+    }
+    case "kimi-k2.7": {
+      warnUnsupportedReasoningEffort();
+      if ((requestedThinking == null ? void 0 : requestedThinking.type) === "disabled") {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "providerOptions",
+          details: "Kimi K2.7 thinking cannot be disabled. providerOptions.moonshotai.thinking has been omitted."
+        });
+      } 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();
+      if ((requestedThinking == null ? void 0 : requestedThinking.type) != null) {
+        thinking = { type: requestedThinking.type };
+      }
+      if (preserveReasoning) {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "providerOptions",
+          details: `providerOptions.moonshotai.reasoningHistory 'preserved' is not supported by model "${modelId}" and has been omitted.`
+        });
+      }
+      break;
+    }
+    case "moonshot-v1": {
+      warnUnsupportedReasoningEffort();
+      if (requestedThinking != null) {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "providerOptions",
+          details: `providerOptions.moonshotai.thinking is not supported by model "${modelId}" and has been omitted.`
+        });
+      }
+      if (preserveReasoning) {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "providerOptions",
+          details: `providerOptions.moonshotai.reasoningHistory 'preserved' is not supported by model "${modelId}" and has been omitted.`
+        });
+      }
+      break;
+    }
+    case "unknown": {
+      reasoningEffort = requestedReasoningEffort;
+      if ((requestedThinking == null ? void 0 : requestedThinking.type) != null) {
+        thinking = { type: requestedThinking.type };
+      }
+      if (preserveReasoning) {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "providerOptions",
+          details: `providerOptions.moonshotai.reasoningHistory 'preserved' is not supported by model "${modelId}" and has been omitted.`
+        });
+      }
+      break;
+    }
+  }
+  return {
+    options: {
+      ...options,
+      providerOptions: {
+        ...options.providerOptions,
+        moonshotai: {
+          ...otherMoonshotOptions,
+          ...reasoningEffort != null ? { reasoningEffort } : {},
+          ...thinking != null ? { thinking } : {}
+        }
+      }
+    },
+    warnings
+  };
+}
 var MoonshotAIChatLanguageModel = class extends import_openai_compatible.OpenAICompatibleChatLanguageModel {
   constructor(modelId, config) {
-    super(modelId, config);
+    super(modelId, {
+      ...config,
+      metadataExtractor: moonshotAIChatMetadataExtractor,
+      transformRequestBody: (args) => {
+        var _a, _b;
+        return transformMoonshotRequestBody(
+          (_b = (_a = config.transformRequestBody) == null ? void 0 : _a.call(config, args)) != null ? _b : args
+        );
+      }
+    });
   }
   async doGenerate(options) {
-    var _a, _b;
-    const result = await super.doGenerate(options);
+    var _a, _b, _c, _d;
+    const { options: messageOptions, warnings: messageWarnings } = await prepareMessageOptions({ modelId: this.modelId, options });
+    await validateProviderOptions(messageOptions);
+    const { options: samplingOptions, warnings: samplingWarnings } = prepareSamplingOptions({
+      modelId: this.modelId,
+      options: messageOptions
+    });
+    const { options: sanitizedOptions, warnings: reasoningWarnings } = prepareReasoningOptions({
+      modelId: this.modelId,
+      options: samplingOptions
+    });
+    const { options: toolChoiceOptions, warnings: toolChoiceWarnings } = prepareToolChoiceOptions({
+      modelId: this.modelId,
+      options: sanitizedOptions
+    });
+    const result = await super.doGenerate(toolChoiceOptions);
     const usage = (_b = (_a = result.response) == null ? void 0 : _a.body) == null ? void 0 : _b.usage;
+    const logprobs = extractMoonshotAIChatLogprobs((_c = result.response) == null ? void 0 : _c.body);
     return {
       ...result,
-      usage: convertMoonshotAIChatUsage(usage)
+      usage: convertMoonshotAIChatUsage(usage),
+      providerMetadata: {
+        ...result.providerMetadata,
+        moonshotai: {
+          ...(_d = result.providerMetadata) == null ? void 0 : _d.moonshotai,
+          ...logprobs != null && { logprobs }
+        }
+      },
+      warnings: [
+        ...result.warnings,
+        ...messageWarnings,
+        ...samplingWarnings,
+        ...reasoningWarnings,
+        ...toolChoiceWarnings
+      ]
     };
   }
   async doStream(options) {
+    const { options: messageOptions, warnings: messageWarnings } = await prepareMessageOptions({ modelId: this.modelId, options });
+    await validateProviderOptions(messageOptions);
     const originalIncludeRawChunks = options.includeRawChunks;
+    const { options: samplingOptions, warnings: samplingWarnings } = prepareSamplingOptions({
+      modelId: this.modelId,
+      options: messageOptions
+    });
+    const { options: sanitizedOptions, warnings: reasoningWarnings } = prepareReasoningOptions({
+      modelId: this.modelId,
+      options: samplingOptions
+    });
+    const { options: toolChoiceOptions, warnings: toolChoiceWarnings } = prepareToolChoiceOptions({
+      modelId: this.modelId,
+      options: sanitizedOptions
+    });
     const result = await super.doStream({
-      ...options,
+      ...toolChoiceOptions,
       includeRawChunks: true
     });
     let rawUsage = void 0;
+    const contentLogprobs = [];
     return {
       ...result,
       stream: result.stream.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
+            var _a;
+            if (chunk.type === "stream-start") {
+              controller.enqueue({
+                ...chunk,
+                warnings: [
+                  ...chunk.warnings,
+                  ...messageWarnings,
+                  ...samplingWarnings,
+                  ...reasoningWarnings,
+                  ...toolChoiceWarnings
+                ]
+              });
+              return;
+            }
             if (chunk.type === "raw") {
               const rawValue = chunk.rawValue;
               if ((rawValue == null ? void 0 : rawValue.usage) != null) {
                 rawUsage = rawValue.usage;
               }
+              const logprobs = extractMoonshotAIChatLogprobs(rawValue);
+              if ((logprobs == null ? void 0 : logprobs.content) != null) {
+                contentLogprobs.push(...logprobs.content);
+              }
               if (originalIncludeRawChunks) {
                 controller.enqueue(chunk);
               }
@@ -93,7 +826,16 @@ var MoonshotAIChatLanguageModel = class extends import_openai_compatible.OpenAIC
             if (chunk.type === "finish") {
               controller.enqueue({
                 ...chunk,
-                usage: rawUsage ? convertMoonshotAIChatUsage(rawUsage) : chunk.usage
+                usage: rawUsage ? convertMoonshotAIChatUsage(rawUsage) : chunk.usage,
+                providerMetadata: {
+                  ...chunk.providerMetadata,
+                  moonshotai: {
+                    ...(_a = chunk.providerMetadata) == null ? void 0 : _a.moonshotai,
+                    ...contentLogprobs.length > 0 && {
+                      logprobs: { content: contentLogprobs }
+                    }
+                  }
+                }
               });
               return;
             }
@@ -106,13 +848,14 @@ var MoonshotAIChatLanguageModel = class extends import_openai_compatible.OpenAIC
 };
 
 // src/version.ts
-var VERSION = true ? "0.0.20" : "0.0.0-test";
+var VERSION = true ? "0.0.24" : "0.0.0-test";
 
 // src/moonshotai-provider.ts
-var moonshotaiErrorSchema = import_v4.z.object({
-  error: import_v4.z.object({
-    message: import_v4.z.string(),
-    type: import_v4.z.string().nullish()
+var moonshotaiErrorSchema = import_v43.z.object({
+  error: import_v43.z.object({
+    message: import_v43.z.string(),
+    type: import_v43.z.string().nullish(),
+    code: import_v43.z.string().nullish()
   })
 });
 var moonshotaiErrorStructure = {
@@ -120,12 +863,15 @@ var moonshotaiErrorStructure = {
   errorToMessage: (data) => data.error.message
 };
 var defaultBaseURL = "https://api.moonshot.ai/v1";
+function getModelStructuredOutputSupport(modelId) {
+  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;
-  const baseURL = (0, import_provider_utils.withoutTrailingSlash)((_a = options.baseURL) != null ? _a : defaultBaseURL);
-  const getHeaders = () => (0, import_provider_utils.withUserAgentSuffix)(
+  const baseURL = (0, import_provider_utils2.withoutTrailingSlash)((_a = options.baseURL) != null ? _a : defaultBaseURL);
+  const getHeaders = () => (0, import_provider_utils2.withUserAgentSuffix)(
     {
-      Authorization: `Bearer ${(0, import_provider_utils.loadApiKey)({
+      Authorization: `Bearer ${(0, import_provider_utils2.loadApiKey)({
         apiKey: options.apiKey,
         environmentVariableName: "MOONSHOT_API_KEY",
         description: "Moonshot API key"
@@ -144,7 +890,8 @@ function createMoonshotAI(options = {}) {
     return new MoonshotAIChatLanguageModel(modelId, {
       ...getCommonModelConfig("chat"),
       includeUsage: true,
-      errorStructure: moonshotaiErrorStructure
+      errorStructure: moonshotaiErrorStructure,
+      supportsStructuredOutputs: getModelStructuredOutputSupport(modelId)
     });
   };
   const provider = (modelId) => createChatModel(modelId);
@@ -152,10 +899,10 @@ function createMoonshotAI(options = {}) {
   provider.chatModel = createChatModel;
   provider.languageModel = createChatModel;
   provider.textEmbeddingModel = (modelId) => {
-    throw new import_provider.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+    throw new import_provider3.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
   };
   provider.imageModel = (modelId) => {
-    throw new import_provider.NoSuchModelError({ modelId, modelType: "imageModel" });
+    throw new import_provider3.NoSuchModelError({ modelId, modelType: "imageModel" });
   };
   return provider;
 }