@ai-sdk/moonshotai 3.0.60 → 3.0.61

package/dist/index.js

@@ -1,1405 +1,1146 @@
-// src/moonshotai-provider.ts
-import {
-  NoSuchModelError
-} from "@ai-sdk/provider";
-import {
-  loadApiKey,
-  withoutTrailingSlash,
-  withUserAgentSuffix
-} from "@ai-sdk/provider-utils";
-
-// src/moonshotai-chat-language-model.ts
-import {
-  combineHeaders,
-  createEventSourceResponseHandler,
-  createJsonErrorResponseHandler,
-  createJsonResponseHandler,
-  createLanguageModelResponseMetadata as getResponseMetadata,
-  createProviderStreamError,
-  generateId,
-  isCustomReasoning,
-  mapReasoningToProviderEffort,
-  parseProviderOptions as parseProviderOptions2,
-  postJsonToApi,
-  serializeModelOptions,
-  StreamingToolCallTracker,
-  WORKFLOW_SERIALIZE,
-  WORKFLOW_DESERIALIZE
-} from "@ai-sdk/provider-utils";
-
-// src/convert-to-moonshotai-chat-messages.ts
-import {
-  InvalidPromptError,
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
-} from "@ai-sdk/provider";
-import {
-  convertBase64ToUint8Array,
-  convertToBase64,
-  getTopLevelMediaType,
-  parseProviderOptions,
-  resolveProviderReference,
-  resolveFullMediaType
-} from "@ai-sdk/provider-utils";
-
-// src/moonshotai-chat-options.ts
+import { InvalidPromptError, NoSuchModelError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
+import { StreamingToolCallTracker, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertBase64ToUint8Array, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createNullLanguageModelUsage, createProviderStreamError, generateId, getTopLevelMediaType, isCustomReasoning, isRecord, lazySchema, loadApiKey, mapReasoningToProviderEffort, parseProviderOptions, postJsonToApi, resolveFullMediaType, resolveProviderReference, serializeModelOptions, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
+//#region src/moonshotai-chat-options.ts
 function isMoonshotAIKimiModel(modelId) {
-  return getMoonshotAIModelFamily(modelId).startsWith("kimi-");
+	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";
+	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()
+const 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 moonshotaiAllMessageProviderOptions = moonshotaiAssistantMessageProviderOptions.extend({
-  /** Function tools to load at this point in a Kimi K3 conversation. */
-  tools: z.array(moonshotaiDynamicToolSchema).optional()
+const moonshotaiAssistantMessageProviderOptions = z.object({ 
+/**
+* The name of the participant represented by the message.
+*
+* Supported on system, user, and assistant messages.
+*/
+name: z.string().optional() }).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() });
+const 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()
 });
-
-// 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"
+const moonshotaiAllMessageProviderOptions = moonshotaiAssistantMessageProviderOptions.extend({ 
+/** Function tools to load at this point in a Kimi K3 conversation. */
+tools: z.array(moonshotaiDynamicToolSchema).optional() });
+//#endregion
+//#region src/normalize-json-schema-for-mfjs.ts
+const SCHEMA_ARRAY_KEYS = [
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+];
+const SCHEMA_MAP_KEYS = [
+	"properties",
+	"patternProperties",
+	"$defs",
+	"dependentSchemas"
 ];
-var SCHEMA_SINGLE_KEYS = [
-  "additionalProperties",
-  "propertyNames",
-  "items",
-  "contains",
-  "not",
-  "if",
-  "then",
-  "else"
+const SCHEMA_SINGLE_KEYS = [
+	"additionalProperties",
+	"propertyNames",
+	"items",
+	"contains",
+	"not",
+	"if",
+	"then",
+	"else"
 ];
+/**
+* Normalizes a JSON Schema to the subset Moonshot's MFJS validator accepts:
+* `object` root required, tuple `items` become `prefixItems`, and `type` next
+* to `anyOf` moves into the branches. Everything else passes through. The
+* full original schema is still used for AI SDK result validation.
+*/
 function normalizeJsonSchemaForMFJS(schema) {
-  return normalizeDefinition(schema, true);
+	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;
+	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?.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}`
-      });
-    }
-  }
+//#endregion
+//#region src/moonshotai-prepare-tools.ts
+function prepareTools({ tools, toolChoice, modelId }) {
+	tools = 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: throw new UnsupportedFunctionalityError({ functionality: `tool choice type: ${type}` });
+	}
 }
-
-// src/convert-to-moonshotai-chat-messages.ts
-var supportedImageMediaTypes = [
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp",
-  "image/bmp",
-  "image/heic",
-  "image/heif"
+//#endregion
+//#region src/convert-to-moonshotai-chat-messages.ts
+const 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"
+const 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)}`;
+function formatMediaUrl({ part, supportedMediaTypes, topLevelMediaType }) {
+	if (part.data.type !== "url" && part.data.type !== "data") throw new UnsupportedFunctionalityError({ 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 UnsupportedFunctionalityError({ 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
-}) {
-  const messages = [];
-  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?.partial === true && role !== "assistant") {
-      throw new InvalidPromptError({
-        prompt,
-        message: "Moonshot AI Partial Mode requires `partial: true` on an assistant message."
-      });
-    }
-    if (moonshotMessageOptions?.tools != null && role !== "system") {
-      throw new InvalidPromptError({
-        prompt,
-        message: "Moonshot dynamic tools must be configured on a system message."
-      });
-    }
-    switch (role) {
-      case "system": {
-        if (moonshotMessageOptions?.tools?.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 ?? "custom-model",
-            tools: moonshotMessageOptions.tools
-          });
-          warnings.push(...toolWarnings);
-          messages.push({ role: "system", tools: tools ?? [] });
-          break;
-        }
-        messages.push({
-          role: "system",
-          content,
-          ...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,
-            ...moonshotMessageOptions?.name != null && {
-              name: moonshotMessageOptions.name
-            }
-          });
-          break;
-        }
-        messages.push({
-          role: "user",
-          content: content.map((part) => {
-            switch (part.type) {
-              case "text": {
-                return { type: "text", text: part.text };
-              }
-              case "file": {
-                const topLevel = getTopLevelMediaType(part.mediaType);
-                switch (part.data.type) {
-                  case "reference": {
-                    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": {
-                    if (topLevel === "text") {
-                      return {
-                        type: "text",
-                        text: part.data.text
-                      };
-                    }
-                    throw new UnsupportedFunctionalityError3({
-                      functionality: `file part media type ${part.mediaType}`
-                    });
-                  }
-                  case "url":
-                  case "data": {
-                    if (topLevel === "image") {
-                      return {
-                        type: "image_url",
-                        image_url: {
-                          url: formatMediaUrl({
-                            part,
-                            supportedMediaTypes: supportedImageMediaTypes,
-                            topLevelMediaType: "image"
-                          })
-                        }
-                      };
-                    }
-                    if (topLevel === "video") {
-                      return {
-                        type: "video_url",
-                        video_url: {
-                          url: formatMediaUrl({
-                            part,
-                            supportedMediaTypes: supportedVideoMediaTypes,
-                            topLevelMediaType: "video"
-                          })
-                        }
-                      };
-                    }
-                    if (topLevel === "text") {
-                      const textContent = part.data.type === "url" ? part.data.url.toString() : typeof part.data.data === "string" ? new TextDecoder().decode(
-                        convertBase64ToUint8Array(part.data.data)
-                      ) : new TextDecoder().decode(part.data.data);
-                      return {
-                        type: "text",
-                        text: textContent
-                      };
-                    }
-                    throw new UnsupportedFunctionalityError3({
-                      functionality: `file part media type ${part.mediaType}`
-                    });
-                  }
-                }
-              }
-            }
-          }),
-          ...moonshotMessageOptions?.name != null && {
-            name: moonshotMessageOptions.name
-          }
-        });
-        break;
-      }
-      case "assistant": {
-        if (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?.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 = [];
-        for (const part of content) {
-          switch (part.type) {
-            case "text": {
-              text += part.text;
-              break;
-            }
-            case "reasoning": {
-              reasoning += part.text;
-              break;
-            }
-            case "tool-call": {
-              toolCalls.push({
-                id: part.toolCallId,
-                type: "function",
-                function: {
-                  name: part.toolName,
-                  arguments: JSON.stringify(part.input)
-                }
-              });
-              break;
-            }
-          }
-        }
-        messages.push({
-          role: "assistant",
-          content: toolCalls.length > 0 ? text || null : text,
-          ...moonshotMessageOptions?.name != null && {
-            name: moonshotMessageOptions.name
-          },
-          ...moonshotMessageOptions?.partial === true && {
-            partial: true
-          },
-          ...reasoning.length > 0 ? { reasoning_content: reasoning } : {},
-          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
-        });
-        break;
-      }
-      case "tool": {
-        if (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;
-          }
-          const output = toolResponse.output;
-          let contentValue;
-          switch (output.type) {
-            case "text":
-            case "error-text":
-              contentValue = output.value;
-              break;
-            case "execution-denied":
-              contentValue = output.reason ?? "Tool call execution denied.";
-              break;
-            case "content":
-            case "json":
-            case "error-json":
-              contentValue = JSON.stringify(output.value);
-              break;
-          }
-          messages.push({
-            role: "tool",
-            tool_call_id: toolResponse.toolCallId,
-            content: contentValue
-          });
-        }
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = role;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-      }
-    }
-  }
-  return { messages, warnings };
+async function convertToMoonshotAIChatMessages({ modelId, prompt, providerOptionsName = "moonshotai", responseFormat }) {
+	const messages = [];
+	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?.partial === true && role !== "assistant") throw new InvalidPromptError({
+			prompt,
+			message: "Moonshot AI Partial Mode requires `partial: true` on an assistant message."
+		});
+		if (moonshotMessageOptions?.tools != null && role !== "system") throw new InvalidPromptError({
+			prompt,
+			message: "Moonshot dynamic tools must be configured on a system message."
+		});
+		switch (role) {
+			case "system":
+				if (moonshotMessageOptions?.tools?.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 ?? "custom-model",
+						tools: moonshotMessageOptions.tools
+					});
+					warnings.push(...toolWarnings);
+					messages.push({
+						role: "system",
+						tools: tools ?? []
+					});
+					break;
+				}
+				messages.push({
+					role: "system",
+					content,
+					...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,
+						...moonshotMessageOptions?.name != null && { name: moonshotMessageOptions.name }
+					});
+					break;
+				}
+				messages.push({
+					role: "user",
+					content: content.map((part) => {
+						switch (part.type) {
+							case "text": return {
+								type: "text",
+								text: part.text
+							};
+							case "file": {
+								const topLevel = getTopLevelMediaType(part.mediaType);
+								switch (part.data.type) {
+									case "reference": {
+										if (topLevel !== "image" && topLevel !== "video") throw new UnsupportedFunctionalityError({ functionality: `file part media type ${part.mediaType}` });
+										const reference = resolveProviderReference({
+											reference: part.data.reference,
+											provider: "moonshotai"
+										});
+										if (!reference.startsWith("ms://")) throw new UnsupportedFunctionalityError({ 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":
+										if (topLevel === "text") return {
+											type: "text",
+											text: part.data.text
+										};
+										throw new UnsupportedFunctionalityError({ functionality: `file part media type ${part.mediaType}` });
+									case "url":
+									case "data":
+										if (topLevel === "image") return {
+											type: "image_url",
+											image_url: { url: formatMediaUrl({
+												part,
+												supportedMediaTypes: supportedImageMediaTypes,
+												topLevelMediaType: "image"
+											}) }
+										};
+										if (topLevel === "video") return {
+											type: "video_url",
+											video_url: { url: formatMediaUrl({
+												part,
+												supportedMediaTypes: supportedVideoMediaTypes,
+												topLevelMediaType: "video"
+											}) }
+										};
+										if (topLevel === "text") return {
+											type: "text",
+											text: part.data.type === "url" ? part.data.url.toString() : typeof part.data.data === "string" ? new TextDecoder().decode(convertBase64ToUint8Array(part.data.data)) : new TextDecoder().decode(part.data.data)
+										};
+										throw new UnsupportedFunctionalityError({ functionality: `file part media type ${part.mediaType}` });
+								}
+							}
+						}
+					}),
+					...moonshotMessageOptions?.name != null && { name: moonshotMessageOptions.name }
+				});
+				break;
+			case "assistant": {
+				if (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?.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 = [];
+				for (const part of content) switch (part.type) {
+					case "text":
+						text += part.text;
+						break;
+					case "reasoning":
+						reasoning += part.text;
+						break;
+					case "tool-call": toolCalls.push({
+						id: part.toolCallId,
+						type: "function",
+						function: {
+							name: part.toolName,
+							arguments: JSON.stringify(part.input)
+						}
+					});
+				}
+				messages.push({
+					role: "assistant",
+					content: toolCalls.length > 0 ? text || null : text,
+					...moonshotMessageOptions?.name != null && { name: moonshotMessageOptions.name },
+					...moonshotMessageOptions?.partial === true && { partial: true },
+					...reasoning.length > 0 ? { reasoning_content: reasoning } : {},
+					tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+				});
+				break;
+			}
+			case "tool":
+				if (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;
+					const output = toolResponse.output;
+					let contentValue;
+					switch (output.type) {
+						case "text":
+						case "error-text":
+							contentValue = output.value;
+							break;
+						case "execution-denied":
+							contentValue = output.reason ?? "Tool call execution denied.";
+							break;
+						case "content":
+						case "json":
+						case "error-json": contentValue = JSON.stringify(output.value);
+					}
+					messages.push({
+						role: "tool",
+						tool_call_id: toolResponse.toolCallId,
+						content: contentValue
+					});
+				}
+				break;
+			default: throw new Error(`Unsupported role: ${role}`);
+		}
+	}
+	return {
+		messages,
+		warnings
+	};
 }
-
-// src/convert-moonshotai-chat-usage.ts
-import { createNullLanguageModelUsage } from "@ai-sdk/provider-utils";
+//#endregion
+//#region src/convert-moonshotai-chat-usage.ts
 function convertMoonshotAIChatUsage(usage) {
-  if (usage == null) {
-    return createNullLanguageModelUsage();
-  }
-  const promptTokens = usage.prompt_tokens ?? 0;
-  const completionTokens = usage.completion_tokens ?? 0;
-  const cacheReadTokens = usage.cached_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? 0;
-  const reasoningTokens = usage.completion_tokens_details?.reasoning_tokens ?? 0;
-  return {
-    inputTokens: {
-      total: promptTokens,
-      noCache: promptTokens - cacheReadTokens,
-      cacheRead: cacheReadTokens,
-      cacheWrite: void 0
-    },
-    outputTokens: {
-      total: completionTokens,
-      text: Math.max(0, completionTokens - reasoningTokens),
-      reasoning: reasoningTokens
-    },
-    raw: usage
-  };
+	if (usage == null) return createNullLanguageModelUsage();
+	const promptTokens = usage.prompt_tokens ?? 0;
+	const completionTokens = usage.completion_tokens ?? 0;
+	const cacheReadTokens = usage.cached_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? 0;
+	const reasoningTokens = usage.completion_tokens_details?.reasoning_tokens ?? 0;
+	return {
+		inputTokens: {
+			total: promptTokens,
+			noCache: promptTokens - cacheReadTokens,
+			cacheRead: cacheReadTokens,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: completionTokens,
+			text: Math.max(0, completionTokens - reasoningTokens),
+			reasoning: reasoningTokens
+		},
+		raw: usage
+	};
 }
-
-// src/map-moonshotai-finish-reason.ts
+//#endregion
+//#region src/map-moonshotai-finish-reason.ts
 function mapMoonshotAIFinishReason(finishReason) {
-  switch (finishReason) {
-    case "stop":
-      return "stop";
-    case "length":
-      return "length";
-    case "content_filter":
-      return "content-filter";
-    case "function_call":
-    case "tool_calls":
-      return "tool-calls";
-    default:
-      return "other";
-  }
+	switch (finishReason) {
+		case "stop": return "stop";
+		case "length": return "length";
+		case "content_filter": return "content-filter";
+		case "function_call":
+		case "tool_calls": return "tool-calls";
+		default: return "other";
+	}
 }
-
-// src/moonshotai-chat-api-types.ts
-import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
-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: z2.looseObject({
-    reasoning_tokens: z2.number().nullish()
-  }).nullish()
+//#endregion
+//#region src/moonshotai-chat-api-types.ts
+const tokenUsageSchema = z.looseObject({
+	prompt_tokens: z.number().nullish(),
+	completion_tokens: z.number().nullish(),
+	cached_tokens: z.number().nullish(),
+	total_tokens: z.number().nullish(),
+	prompt_tokens_details: z.looseObject({ cached_tokens: z.number().nullish() }).nullish(),
+	completion_tokens_details: z.looseObject({ reasoning_tokens: z.number().nullish() }).nullish()
 }).nullish();
-var moonshotAIErrorSchema = z2.object({
-  error: z2.object({
-    message: z2.string(),
-    type: z2.string().nullish(),
-    code: z2.string().nullish()
-  })
+const moonshotAIErrorSchema = z.object({ error: z.object({
+	message: z.string(),
+	type: z.string().nullish(),
+	code: z.string().nullish()
+}) });
+const moonshotAIChatLogprobSchema = z.object({
+	token: z.string(),
+	logprob: z.number(),
+	bytes: z.array(z.number()).nullable(),
+	top_logprobs: z.array(z.object({
+		token: z.string(),
+		logprob: z.number(),
+		bytes: z.array(z.number()).nullable()
+	}))
 });
-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()
-      }),
-      logprobs: moonshotAIChatLogprobsSchema,
-      finish_reason: z2.string().nullish()
-    })
-  ),
-  usage: tokenUsageSchema
+const moonshotAIChatLogprobsSchema = z.object({ content: z.array(moonshotAIChatLogprobSchema).nullish() }).nullish();
+const moonshotAIChatResponseSchema = z.object({
+	id: z.string().nullish(),
+	created: z.number().nullish(),
+	model: z.string().nullish(),
+	object: z.literal("chat.completion").nullish(),
+	choices: z.array(z.object({
+		index: z.number().nullish(),
+		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(),
+				type: z.literal("function").nullish(),
+				function: z.object({
+					name: z.string(),
+					arguments: z.string()
+				})
+			})).nullish()
+		}),
+		logprobs: moonshotAIChatLogprobsSchema,
+		finish_reason: z.string().nullish()
+	})),
+	usage: tokenUsageSchema
 });
-var moonshotAIChatChunkSchema = lazySchema(
-  () => zodSchema(
-    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(),
-            logprobs: moonshotAIChatLogprobsSchema,
-            finish_reason: z2.string().nullish(),
-            usage: tokenUsageSchema
-          })
-        ),
-        usage: tokenUsageSchema
-      }),
-      moonshotAIErrorSchema
-    ])
-  )
-);
-
-// src/moonshotai-chat-language-model.ts
+const moonshotAIChatChunkSchema = lazySchema(() => zodSchema(z.union([z.object({
+	id: z.string().nullish(),
+	created: z.number().nullish(),
+	model: z.string().nullish(),
+	object: z.literal("chat.completion.chunk").nullish(),
+	choices: z.array(z.object({
+		index: z.number().nullish(),
+		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().nullish(),
+				id: z.string().nullish(),
+				type: z.literal("function").nullish(),
+				function: z.object({
+					name: z.string().nullish(),
+					arguments: z.string().nullish()
+				})
+			})).nullish()
+		}).nullish(),
+		logprobs: moonshotAIChatLogprobsSchema,
+		finish_reason: z.string().nullish(),
+		usage: tokenUsageSchema
+	})),
+	usage: tokenUsageSchema
+}), moonshotAIErrorSchema])));
+//#endregion
+//#region src/moonshotai-chat-language-model.ts
 function createMoonshotAIStreamError(error, data) {
-  return createProviderStreamError({
-    message: error.message,
-    type: error.type ?? void 0,
-    code: error.code ?? void 0,
-    ...getMoonshotAIStreamErrorMetadata(error.type),
-    data
-  });
+	return createProviderStreamError({
+		message: error.message,
+		type: error.type ?? void 0,
+		code: error.code ?? void 0,
+		...getMoonshotAIStreamErrorMetadata(error.type),
+		data
+	});
 }
 function getMoonshotAIStreamErrorMetadata(type) {
-  switch (type) {
-    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 {};
-  }
+	switch (type) {
+		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 {};
+	}
 }
-var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    // Moonshot AI does not fetch external URLs; the AI SDK downloads and
-    // inlines URL file parts instead. ms:// file references from the Moonshot
-    // Files API are passed through natively.
-    this.supportedUrls = {
-      "image/*": [/^ms:\/\//],
-      "video/*": [/^ms:\/\//]
-    };
-    this.modelId = modelId;
-    this.config = config;
-    this.failedResponseHandler = createJsonErrorResponseHandler({
-      errorSchema: moonshotAIErrorSchema,
-      errorToMessage: (error) => error.error.message
-    });
-  }
-  static [WORKFLOW_SERIALIZE](model) {
-    return serializeModelOptions({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE](options) {
-    return new _MoonshotAIChatLanguageModel(options.modelId, options.config);
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  get providerOptionsName() {
-    return this.config.provider.split(".")[0].trim();
-  }
-  async getArgs({
-    prompt,
-    maxOutputTokens,
-    temperature,
-    topP,
-    topK,
-    frequencyPenalty,
-    presencePenalty,
-    reasoning,
-    providerOptions,
-    stopSequences,
-    responseFormat,
-    seed,
-    toolChoice,
-    tools
-  }) {
-    const moonshotOptions = await parseProviderOptions2({
-      provider: this.providerOptionsName,
-      providerOptions,
-      schema: moonshotaiLanguageModelOptions
-    }) ?? {};
-    const allWarnings = [];
-    if (topK != null) {
-      allWarnings.push({ type: "unsupported", feature: "topK" });
-    }
-    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, modelId: this.modelId });
-    const modelFamily = getMoonshotAIModelFamily(this.modelId);
-    const requestedThinking = moonshotOptions.thinking;
-    const requestedReasoningEffort = moonshotOptions.reasoningEffort;
-    const preserveReasoning = moonshotOptions.reasoningHistory === "preserved";
-    if (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: "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 ?? (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?.type === "disabled" || reasoning === "none") {
-          allWarnings.push({
-            type: "unsupported",
-            feature: requestedThinking?.type === "disabled" ? 'thinking.type "disabled"' : 'reasoning "none"',
-            details: "Kimi K2.7 thinking cannot be disabled."
-          });
-        } else if (requestedThinking?.type === "enabled") {
-          thinking = { type: "enabled" };
-        }
-        break;
-      }
-      case "kimi-k2.6": {
-        warnUnsupportedReasoningEffort();
-        const thinkingType = requestedThinking?.type ?? (isCustomReasoning(reasoning) ? reasoning === "none" ? "disabled" : "enabled" : void 0);
-        if (thinkingType != null || preserveReasoning) {
-          thinking = {
-            type: thinkingType ?? "enabled",
-            ...preserveReasoning ? { keep: "all" } : {}
-          };
-        }
-        break;
-      }
-      case "kimi-k2.5": {
-        warnUnsupportedReasoningEffort();
-        const thinkingType = requestedThinking?.type ?? (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 ?? (isCustomReasoning(reasoning) && reasoning !== "none" ? mapReasoningToProviderEffort({
-          reasoning,
-          effortMap: {
-            minimal: "low",
-            low: "low",
-            medium: "high",
-            high: "high",
-            xhigh: "max"
-          },
-          warnings: allWarnings
-        }) : void 0);
-        if (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?.type === "json") {
-      if (this.config.supportsStructuredOutputs === true && responseFormat.schema != null) {
-        const { $schema: _$schema, ...schemaWithoutDollarSchema } = responseFormat.schema;
-        response_format = {
-          type: "json_schema",
-          json_schema: {
-            name: responseFormat.name ?? "response",
-            strict: moonshotOptions.strictJsonSchema ?? 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,
-        ...(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,
-        ...moonshotOptions.prediction != null && {
-          prediction: moonshotOptions.prediction
-        },
-        ...thinking != null ? { thinking } : {},
-        ...reasoningEffort != null && {
-          reasoning_effort: reasoningEffort
-        },
-        ...moonshotOptions.promptCacheKey != null && {
-          prompt_cache_key: moonshotOptions.promptCacheKey
-        },
-        ...moonshotOptions.safetyIdentifier != null && {
-          safety_identifier: moonshotOptions.safetyIdentifier
-        }
-      },
-      warnings: [...allWarnings, ...toolWarnings]
-    };
-  }
-  async doGenerate(options) {
-    const { args, warnings } = await this.getArgs({ ...options });
-    const {
-      responseHeaders,
-      value: responseBody,
-      rawValue: rawResponse
-    } = await postJsonToApi({
-      url: this.config.url({
-        path: "/chat/completions",
-        modelId: this.modelId
-      }),
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body: args,
-      failedResponseHandler: this.failedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        moonshotAIChatResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    const choice = responseBody.choices[0];
-    const content = [];
-    const reasoning = choice.message.reasoning_content;
-    if (reasoning != null && reasoning.length > 0) {
-      content.push({ type: "reasoning", text: reasoning });
-    }
-    if (choice.message.tool_calls != null) {
-      for (const toolCall of choice.message.tool_calls) {
-        content.push({
-          type: "tool-call",
-          toolCallId: toolCall.id || generateId(),
-          toolName: toolCall.function.name,
-          input: toolCall.function.arguments ?? ""
-        });
-      }
-    }
-    const text = choice.message.content;
-    if (text != null && text.length > 0) {
-      content.push({ type: "text", text });
-    }
-    return {
-      content,
-      finishReason: {
-        unified: mapMoonshotAIFinishReason(choice.finish_reason),
-        raw: choice.finish_reason ?? 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),
-        headers: responseHeaders,
-        body: rawResponse
-      },
-      warnings
-    };
-  }
-  async doStream(options) {
-    const { args, warnings } = await this.getArgs({ ...options });
-    const body = {
-      ...args,
-      stream: true,
-      ...this.config.includeUsage && {
-        stream_options: { include_usage: true }
-      }
-    };
-    const { responseHeaders, value: response } = await postJsonToApi({
-      url: this.config.url({
-        path: "/chat/completions",
-        modelId: this.modelId
-      }),
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body,
-      failedResponseHandler: this.failedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler(
-        moonshotAIChatChunkSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    let toolCallTracker;
-    let finishReason = {
-      unified: "other",
-      raw: 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({
-          start(controller) {
-            toolCallTracker = new StreamingToolCallTracker(controller, {
-              generateId
-            });
-            controller.enqueue({ type: "stream-start", warnings });
-          },
-          transform(chunk, controller) {
-            if (options.includeRawChunks) {
-              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
-            }
-            if (!chunk.success) {
-              finishReason = { unified: "error", raw: void 0 };
-              controller.enqueue({ type: "error", error: chunk.error });
-              return;
-            }
-            const value = chunk.value;
-            if ("error" in value) {
-              finishReason = { unified: "error", raw: void 0 };
-              controller.enqueue({
-                type: "error",
-                error: createMoonshotAIStreamError(value.error, value)
-              });
-              return;
-            }
-            if (isFirstChunk) {
-              isFirstChunk = false;
-              controller.enqueue({
-                type: "response-metadata",
-                ...getResponseMetadata(value)
-              });
-            }
-            if (value.usage != null) {
-              topLevelUsage = value.usage;
-            }
-            if (value.object != null) {
-              responseObject = value.object;
-            }
-            const choice = value.choices[0];
-            if (choice?.usage != null) {
-              choiceUsage = choice.usage;
-            }
-            if (choice?.index != null) {
-              choiceIndex = choice.index;
-            }
-            if (choice?.finish_reason != null) {
-              finishReason = {
-                unified: mapMoonshotAIFinishReason(choice.finish_reason),
-                raw: choice.finish_reason
-              };
-            }
-            if (choice?.logprobs?.content != null) {
-              contentLogprobs.push(...choice.logprobs.content);
-            }
-            if (choice?.delta == null) {
-              return;
-            }
-            const delta = choice.delta;
-            if (delta.role != null) {
-              messageRole = delta.role;
-            }
-            const reasoningContent = delta.reasoning_content;
-            if (reasoningContent) {
-              if (!isActiveReasoning) {
-                controller.enqueue({
-                  type: "reasoning-start",
-                  id: "reasoning-0"
-                });
-                isActiveReasoning = true;
-              }
-              controller.enqueue({
-                type: "reasoning-delta",
-                id: "reasoning-0",
-                delta: reasoningContent
-              });
-            }
-            if (delta.content) {
-              if (!isActiveText) {
-                controller.enqueue({ type: "text-start", id: "txt-0" });
-                isActiveText = true;
-              }
-              if (isActiveReasoning) {
-                controller.enqueue({
-                  type: "reasoning-end",
-                  id: "reasoning-0"
-                });
-                isActiveReasoning = false;
-              }
-              controller.enqueue({
-                type: "text-delta",
-                id: "txt-0",
-                delta: delta.content
-              });
-            }
-            if (delta.tool_calls != null && delta.tool_calls.length > 0) {
-              if (isActiveReasoning) {
-                controller.enqueue({
-                  type: "reasoning-end",
-                  id: "reasoning-0"
-                });
-                isActiveReasoning = false;
-              }
-              for (const [index, toolCallDelta] of delta.tool_calls.entries()) {
-                const toolCallIndex = toolCallDelta.index ?? index;
-                if (toolCallDelta.type != null) {
-                  toolCallTypes.set(toolCallIndex, toolCallDelta.type);
-                }
-                toolCallTracker.processDelta({
-                  ...toolCallDelta,
-                  index: toolCallIndex
-                });
-              }
-            }
-          },
-          flush(controller) {
-            if (isActiveReasoning) {
-              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
-            }
-            if (isActiveText) {
-              controller.enqueue({ type: "text-end", id: "txt-0" });
-            }
-            toolCallTracker.flush();
-            controller.enqueue({
-              type: "finish",
-              finishReason,
-              usage: convertMoonshotAIChatUsage(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)
-                  }
-                }
-              }
-            });
-          }
-        })
-      ),
-      request: { body },
-      response: { headers: responseHeaders }
-    };
-  }
+var MoonshotAIChatLanguageModel = class MoonshotAIChatLanguageModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new MoonshotAIChatLanguageModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.supportedUrls = {
+			"image/*": [/^ms:\/\//],
+			"video/*": [/^ms:\/\//]
+		};
+		this.modelId = modelId;
+		this.config = config;
+		this.failedResponseHandler = createJsonErrorResponseHandler({
+			errorSchema: moonshotAIErrorSchema,
+			errorToMessage: (error) => error.error.message
+		});
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	get providerOptionsName() {
+		return this.config.provider.split(".")[0].trim();
+	}
+	async getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, reasoning, providerOptions, stopSequences, responseFormat, seed, toolChoice, tools }) {
+		const moonshotOptions = await parseProviderOptions({
+			provider: this.providerOptionsName,
+			providerOptions,
+			schema: moonshotaiLanguageModelOptions
+		}) ?? {};
+		const allWarnings = [];
+		if (topK != null) allWarnings.push({
+			type: "unsupported",
+			feature: "topK"
+		});
+		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,
+			modelId: this.modelId
+		});
+		const modelFamily = getMoonshotAIModelFamily(this.modelId);
+		const requestedThinking = moonshotOptions.thinking;
+		const requestedReasoningEffort = moonshotOptions.reasoningEffort;
+		const preserveReasoning = moonshotOptions.reasoningHistory === "preserved";
+		if (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: "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 ?? (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?.type === "disabled" || reasoning === "none") allWarnings.push({
+					type: "unsupported",
+					feature: requestedThinking?.type === "disabled" ? "thinking.type \"disabled\"" : "reasoning \"none\"",
+					details: "Kimi K2.7 thinking cannot be disabled."
+				});
+				else if (requestedThinking?.type === "enabled") thinking = { type: "enabled" };
+				break;
+			case "kimi-k2.6": {
+				warnUnsupportedReasoningEffort();
+				const thinkingType = requestedThinking?.type ?? (isCustomReasoning(reasoning) ? reasoning === "none" ? "disabled" : "enabled" : void 0);
+				if (thinkingType != null || preserveReasoning) thinking = {
+					type: thinkingType ?? "enabled",
+					...preserveReasoning ? { keep: "all" } : {}
+				};
+				break;
+			}
+			case "kimi-k2.5": {
+				warnUnsupportedReasoningEffort();
+				const thinkingType = requestedThinking?.type ?? (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 ?? (isCustomReasoning(reasoning) && reasoning !== "none" ? mapReasoningToProviderEffort({
+					reasoning,
+					effortMap: {
+						minimal: "low",
+						low: "low",
+						medium: "high",
+						high: "high",
+						xhigh: "max"
+					},
+					warnings: allWarnings
+				}) : void 0);
+				if (requestedThinking?.type != null) thinking = { type: requestedThinking.type };
+				if (preserveReasoning) allWarnings.push({
+					type: "unsupported",
+					feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`
+				});
+		}
+		let response_format;
+		if (responseFormat?.type === "json") {
+			if (this.config.supportsStructuredOutputs === true && responseFormat.schema != null) {
+				const { $schema: _$schema, ...schemaWithoutDollarSchema } = responseFormat.schema;
+				response_format = {
+					type: "json_schema",
+					json_schema: {
+						name: responseFormat.name ?? "response",
+						strict: moonshotOptions.strictJsonSchema ?? 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,
+				...(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,
+				...moonshotOptions.prediction != null && { prediction: moonshotOptions.prediction },
+				...thinking != null ? { thinking } : {},
+				...reasoningEffort != null && { reasoning_effort: reasoningEffort },
+				...moonshotOptions.promptCacheKey != null && { prompt_cache_key: moonshotOptions.promptCacheKey },
+				...moonshotOptions.safetyIdentifier != null && { safety_identifier: moonshotOptions.safetyIdentifier }
+			},
+			warnings: [...allWarnings, ...toolWarnings]
+		};
+	}
+	async doGenerate(options) {
+		const { args, warnings } = await this.getArgs({ ...options });
+		const { responseHeaders, value: responseBody, rawValue: rawResponse } = await postJsonToApi({
+			url: this.config.url({
+				path: "/chat/completions",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body: args,
+			failedResponseHandler: this.failedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(moonshotAIChatResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const choice = responseBody.choices[0];
+		const content = [];
+		const reasoning = choice.message.reasoning_content;
+		if (reasoning != null && reasoning.length > 0) content.push({
+			type: "reasoning",
+			text: reasoning
+		});
+		if (choice.message.tool_calls != null) for (const toolCall of choice.message.tool_calls) content.push({
+			type: "tool-call",
+			toolCallId: toolCall.id || generateId(),
+			toolName: toolCall.function.name,
+			input: toolCall.function.arguments ?? ""
+		});
+		const text = choice.message.content;
+		if (text != null && text.length > 0) content.push({
+			type: "text",
+			text
+		});
+		return {
+			content,
+			finishReason: {
+				unified: mapMoonshotAIFinishReason(choice.finish_reason),
+				raw: choice.finish_reason ?? 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: {
+				...createLanguageModelResponseMetadata(responseBody),
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = await this.getArgs({ ...options });
+		const body = {
+			...args,
+			stream: true,
+			...this.config.includeUsage && { stream_options: { include_usage: true } }
+		};
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: this.config.url({
+				path: "/chat/completions",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body,
+			failedResponseHandler: this.failedResponseHandler,
+			successfulResponseHandler: createEventSourceResponseHandler(moonshotAIChatChunkSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		let toolCallTracker;
+		let finishReason = {
+			unified: "other",
+			raw: 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({
+				start(controller) {
+					toolCallTracker = new StreamingToolCallTracker(controller, { generateId });
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						finishReason = {
+							unified: "error",
+							raw: void 0
+						};
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const value = chunk.value;
+					if ("error" in value) {
+						finishReason = {
+							unified: "error",
+							raw: void 0
+						};
+						controller.enqueue({
+							type: "error",
+							error: createMoonshotAIStreamError(value.error, value)
+						});
+						return;
+					}
+					if (isFirstChunk) {
+						isFirstChunk = false;
+						controller.enqueue({
+							type: "response-metadata",
+							...createLanguageModelResponseMetadata(value)
+						});
+					}
+					if (value.usage != null) topLevelUsage = value.usage;
+					if (value.object != null) responseObject = value.object;
+					const choice = value.choices[0];
+					if (choice?.usage != null) choiceUsage = choice.usage;
+					if (choice?.index != null) choiceIndex = choice.index;
+					if (choice?.finish_reason != null) finishReason = {
+						unified: mapMoonshotAIFinishReason(choice.finish_reason),
+						raw: choice.finish_reason
+					};
+					if (choice?.logprobs?.content != null) contentLogprobs.push(...choice.logprobs.content);
+					if (choice?.delta == null) return;
+					const delta = choice.delta;
+					if (delta.role != null) messageRole = delta.role;
+					const reasoningContent = delta.reasoning_content;
+					if (reasoningContent) {
+						if (!isActiveReasoning) {
+							controller.enqueue({
+								type: "reasoning-start",
+								id: "reasoning-0"
+							});
+							isActiveReasoning = true;
+						}
+						controller.enqueue({
+							type: "reasoning-delta",
+							id: "reasoning-0",
+							delta: reasoningContent
+						});
+					}
+					if (delta.content) {
+						if (!isActiveText) {
+							controller.enqueue({
+								type: "text-start",
+								id: "txt-0"
+							});
+							isActiveText = true;
+						}
+						if (isActiveReasoning) {
+							controller.enqueue({
+								type: "reasoning-end",
+								id: "reasoning-0"
+							});
+							isActiveReasoning = false;
+						}
+						controller.enqueue({
+							type: "text-delta",
+							id: "txt-0",
+							delta: delta.content
+						});
+					}
+					if (delta.tool_calls != null && delta.tool_calls.length > 0) {
+						if (isActiveReasoning) {
+							controller.enqueue({
+								type: "reasoning-end",
+								id: "reasoning-0"
+							});
+							isActiveReasoning = false;
+						}
+						for (const [index, toolCallDelta] of delta.tool_calls.entries()) {
+							const toolCallIndex = toolCallDelta.index ?? index;
+							if (toolCallDelta.type != null) toolCallTypes.set(toolCallIndex, toolCallDelta.type);
+							toolCallTracker.processDelta({
+								...toolCallDelta,
+								index: toolCallIndex
+							});
+						}
+					}
+				},
+				flush(controller) {
+					if (isActiveReasoning) controller.enqueue({
+						type: "reasoning-end",
+						id: "reasoning-0"
+					});
+					if (isActiveText) controller.enqueue({
+						type: "text-end",
+						id: "txt-0"
+					});
+					toolCallTracker.flush();
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage: convertMoonshotAIChatUsage(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) }
+						} }
+					});
+				}
+			})),
+			request: { body },
+			response: { headers: responseHeaders }
+		};
+	}
 };
-
-// src/version.ts
-var VERSION = true ? "3.0.60" : "0.0.0-test";
-
-// src/moonshotai-provider.ts
-var defaultBaseURL = "https://api.moonshot.ai/v1";
+//#endregion
+//#region src/version.ts
+const VERSION = "3.0.61";
+//#endregion
+//#region src/moonshotai-provider.ts
+const 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";
+	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 = {}) {
-  const baseURL = withoutTrailingSlash(options.baseURL ?? defaultBaseURL);
-  const getHeaders = () => withUserAgentSuffix(
-    {
-      Authorization: `Bearer ${loadApiKey({
-        apiKey: options.apiKey,
-        environmentVariableName: "MOONSHOT_API_KEY",
-        description: "Moonshot API key"
-      })}`,
-      ...options.headers
-    },
-    `ai-sdk-moonshotai/${VERSION}`
-  );
-  const createChatModel = (modelId) => {
-    return new MoonshotAIChatLanguageModel(modelId, {
-      provider: "moonshotai.chat",
-      url: ({ path }) => `${baseURL}${path}`,
-      headers: getHeaders,
-      fetch: options.fetch,
-      includeUsage: true,
-      supportsStructuredOutputs: getModelStructuredOutputSupport(modelId)
-    });
-  };
-  const provider = (modelId) => createChatModel(modelId);
-  provider.specificationVersion = "v4";
-  provider.chatModel = createChatModel;
-  provider.languageModel = createChatModel;
-  provider.embeddingModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
-  };
-  provider.imageModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
-  };
-  return provider;
+	const baseURL = withoutTrailingSlash(options.baseURL ?? defaultBaseURL);
+	const getHeaders = () => withUserAgentSuffix({
+		Authorization: `Bearer ${loadApiKey({
+			apiKey: options.apiKey,
+			environmentVariableName: "MOONSHOT_API_KEY",
+			description: "Moonshot API key"
+		})}`,
+		...options.headers
+	}, `ai-sdk-moonshotai/${VERSION}`);
+	const createChatModel = (modelId) => {
+		return new MoonshotAIChatLanguageModel(modelId, {
+			provider: "moonshotai.chat",
+			url: ({ path }) => `${baseURL}${path}`,
+			headers: getHeaders,
+			fetch: options.fetch,
+			includeUsage: true,
+			supportsStructuredOutputs: getModelStructuredOutputSupport(modelId)
+		});
+	};
+	const provider = (modelId) => createChatModel(modelId);
+	provider.specificationVersion = "v4";
+	provider.chatModel = createChatModel;
+	provider.languageModel = createChatModel;
+	provider.embeddingModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "embeddingModel"
+		});
+	};
+	provider.imageModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "imageModel"
+		});
+	};
+	return provider;
 }
-var moonshotai = createMoonshotAI();
-export {
-  VERSION,
-  createMoonshotAI,
-  moonshotai
-};
+const moonshotai = createMoonshotAI();
+//#endregion
+export { VERSION, createMoonshotAI, moonshotai };
+
 //# sourceMappingURL=index.js.map