@ai-sdk/moonshotai 3.0.31 → 3.0.32

package/dist/index.js

@@ -7,16 +7,183 @@ import {
   withoutTrailingSlash,
   withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
 
 // src/moonshotai-chat-language-model.ts
-import { OpenAICompatibleChatLanguageModel } from "@ai-sdk/openai-compatible";
 import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  createLanguageModelResponseMetadata as getResponseMetadata,
+  generateId,
+  isCustomReasoning,
+  mapReasoningToProviderEffort,
+  parseProviderOptions,
+  postJsonToApi,
   serializeModelOptions,
+  StreamingToolCallTracker,
   WORKFLOW_SERIALIZE,
   WORKFLOW_DESERIALIZE
 } from "@ai-sdk/provider-utils";
 
+// src/convert-to-moonshotai-chat-messages.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import {
+  convertBase64ToUint8Array,
+  convertToBase64,
+  getTopLevelMediaType,
+  resolveFullMediaType
+} from "@ai-sdk/provider-utils";
+function convertToMoonshotAIChatMessages(prompt) {
+  var _a;
+  const messages = [];
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        messages.push({ role: "system", content });
+        break;
+      }
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({
+            role: "user",
+            content: content[0].text
+          });
+          break;
+        }
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            switch (part.type) {
+              case "text": {
+                return { type: "text", text: part.text };
+              }
+              case "file": {
+                switch (part.data.type) {
+                  case "reference": {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "file parts with provider references"
+                    });
+                  }
+                  case "text": {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "text file parts"
+                    });
+                  }
+                  case "url":
+                  case "data": {
+                    const topLevel = getTopLevelMediaType(part.mediaType);
+                    if (topLevel === "image") {
+                      return {
+                        type: "image_url",
+                        image_url: {
+                          url: part.data.type === "url" ? part.data.url.toString() : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`
+                        }
+                      };
+                    }
+                    if (topLevel === "video") {
+                      return {
+                        type: "video_url",
+                        video_url: {
+                          url: part.data.type === "url" ? part.data.url.toString() : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`
+                        }
+                      };
+                    }
+                    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 UnsupportedFunctionalityError({
+                      functionality: `file part media type ${part.mediaType}`
+                    });
+                  }
+                }
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        let reasoning = "";
+        const toolCalls = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "reasoning": {
+              reasoning += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                }
+              });
+              break;
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: toolCalls.length > 0 ? text || null : text,
+          ...reasoning.length > 0 ? { reasoning_content: reasoning } : {},
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+        });
+        break;
+      }
+      case "tool": {
+        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 = (_a = output.reason) != null ? _a : "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;
+}
+
 // src/convert-moonshotai-chat-usage.ts
 import { createNullLanguageModelUsage } from "@ai-sdk/provider-utils";
 function convertMoonshotAIChatUsage(usage) {
@@ -44,8 +211,207 @@ function convertMoonshotAIChatUsage(usage) {
   };
 }
 
+// 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";
+  }
+}
+
+// src/moonshotai-chat-api-types.ts
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var tokenUsageSchema = z.object({
+  prompt_tokens: z.number().nullish(),
+  completion_tokens: z.number().nullish(),
+  cached_tokens: z.number().nullish(),
+  total_tokens: z.number().nullish(),
+  prompt_tokens_details: z.object({
+    cached_tokens: z.number().nullish()
+  }).nullish(),
+  completion_tokens_details: z.object({
+    reasoning_tokens: z.number().nullish()
+  }).nullish()
+}).nullish();
+var moonshotAIErrorSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    type: z.string().nullish()
+  })
+});
+var moonshotAIChatResponseSchema = z.object({
+  id: z.string().nullish(),
+  created: z.number().nullish(),
+  model: z.string().nullish(),
+  choices: z.array(
+    z.object({
+      message: z.object({
+        role: z.literal("assistant").nullish(),
+        content: z.string().nullish(),
+        reasoning_content: z.string().nullish(),
+        tool_calls: z.array(
+          z.object({
+            id: z.string().nullish(),
+            function: z.object({
+              name: z.string(),
+              arguments: z.string()
+            })
+          })
+        ).nullish()
+      }),
+      finish_reason: z.string().nullish()
+    })
+  ),
+  usage: tokenUsageSchema
+});
+var moonshotAIChatChunkSchema = lazySchema(
+  () => zodSchema(
+    z.union([
+      z.object({
+        id: z.string().nullish(),
+        created: z.number().nullish(),
+        model: z.string().nullish(),
+        choices: z.array(
+          z.object({
+            delta: z.object({
+              role: z.literal("assistant").nullish(),
+              content: z.string().nullish(),
+              reasoning_content: z.string().nullish(),
+              tool_calls: z.array(
+                z.object({
+                  index: z.number(),
+                  id: z.string().nullish(),
+                  function: z.object({
+                    name: z.string().nullish(),
+                    arguments: z.string().nullish()
+                  })
+                })
+              ).nullish()
+            }).nullish(),
+            finish_reason: z.string().nullish()
+          })
+        ),
+        usage: tokenUsageSchema
+      }),
+      moonshotAIErrorSchema
+    ])
+  )
+);
+
+// src/moonshotai-chat-options.ts
+import { z as z2 } from "zod/v4";
+var moonshotaiLanguageModelOptions = z2.object({
+  /**
+   * Reasoning effort for Kimi K3.
+   */
+  reasoningEffort: z2.enum(["low", "high", "max"]).optional(),
+  thinking: z2.object({
+    type: z2.enum(["enabled", "disabled"]).optional(),
+    budgetTokens: z2.number().int().min(1024).optional()
+  }).optional(),
+  reasoningHistory: z2.enum(["disabled", "interleaved", "preserved"]).optional(),
+  /**
+   * Used to cache responses for similar requests to optimize cache hit rates.
+   * Typically a session or task id.
+   */
+  promptCacheKey: z2.string().optional(),
+  /**
+   * A stable identifier used to help Moonshot detect users violating usage
+   * policies. Recommended to hash the username or email address.
+   */
+  safetyIdentifier: z2.string().optional()
+});
+function getModelThinkingKeepSupport(modelId) {
+  return modelId === "kimi-k2.6" || modelId === "kimi-k3" || modelId.startsWith("kimi-k2.7-code");
+}
+
+// src/moonshotai-prepare-tools.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
+function prepareTools({
+  tools,
+  toolChoice
+}) {
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
+  }
+  const moonshotTools = [];
+  for (const tool of tools) {
+    if (tool.type === "provider") {
+      toolWarnings.push({
+        type: "unsupported",
+        feature: `provider-defined tool ${tool.id}`
+      });
+    } else {
+      moonshotTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          ...tool.strict != null ? { strict: tool.strict } : {}
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: moonshotTools, toolChoice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: moonshotTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: moonshotTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError2({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
 // src/moonshotai-chat-language-model.ts
-var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel extends OpenAICompatibleChatLanguageModel {
+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,
@@ -55,54 +421,336 @@ var MoonshotAIChatLanguageModel = class _MoonshotAIChatLanguageModel extends Ope
   static [WORKFLOW_DESERIALIZE](options) {
     return new _MoonshotAIChatLanguageModel(options.modelId, options.config);
   }
-  constructor(modelId, config) {
-    super(modelId, 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
+  }) {
+    var _a, _b, _c;
+    const moonshotOptions = (_a = await parseProviderOptions({
+      provider: this.providerOptionsName,
+      providerOptions,
+      schema: moonshotaiLanguageModelOptions
+    })) != null ? _a : {};
+    const messages = convertToMoonshotAIChatMessages(prompt);
+    const allWarnings = [];
+    if (topK != null) {
+      allWarnings.push({ type: "unsupported", feature: "topK" });
+    }
+    if (seed != null) {
+      allWarnings.push({ type: "unsupported", feature: "seed" });
+    }
+    const {
+      tools: moonshotTools,
+      toolChoice: moonshotToolChoice,
+      toolWarnings
+    } = prepareTools({ tools, toolChoice });
+    const thinking = moonshotOptions.thinking;
+    let keep;
+    if (moonshotOptions.reasoningHistory === "preserved") {
+      if (getModelThinkingKeepSupport(this.modelId)) {
+        keep = "all";
+      } else {
+        allWarnings.push({
+          type: "unsupported",
+          feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`
+        });
+      }
+    }
+    if (reasoning === "none") {
+      allWarnings.push({
+        type: "unsupported",
+        feature: 'reasoning "none" (use providerOptions.moonshotai.thinking to control thinking)'
+      });
+    }
+    const reasoningEffort = (_b = moonshotOptions.reasoningEffort) != null ? _b : isCustomReasoning(reasoning) && reasoning !== "none" ? mapReasoningToProviderEffort({
+      reasoning,
+      effortMap: {
+        minimal: "low",
+        low: "low",
+        medium: "high",
+        high: "high",
+        xhigh: "max"
+      },
+      warnings: allWarnings
+    }) : void 0;
+    let response_format;
+    if ((responseFormat == null ? void 0 : responseFormat.type) === "json") {
+      if (this.config.supportsStructuredOutputs === true && responseFormat.schema != null) {
+        const { $schema: _$schema, ...schemaWithoutDollarSchema } = responseFormat.schema;
+        response_format = {
+          type: "json_schema",
+          json_schema: {
+            name: (_c = responseFormat.name) != null ? _c : "response",
+            schema: schemaWithoutDollarSchema,
+            ...responseFormat.description != null && {
+              description: responseFormat.description
+            }
+          }
+        };
+      } else {
+        response_format = { type: "json_object" };
+      }
+    }
+    return {
+      args: {
+        model: this.modelId,
+        max_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        response_format,
+        stop: stopSequences,
+        messages,
+        tools: moonshotTools,
+        tool_choice: moonshotToolChoice,
+        ...thinking != null || keep != null ? {
+          thinking: {
+            ...(thinking == null ? void 0 : thinking.type) != null && { type: thinking.type },
+            ...(thinking == null ? void 0 : thinking.budgetTokens) !== void 0 && {
+              budget_tokens: thinking.budgetTokens
+            },
+            ...keep != null && { keep }
+          }
+        } : {},
+        ...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) {
-    var _a, _b;
-    const result = await super.doGenerate(options);
-    const usage = (_b = (_a = result.response) == null ? void 0 : _a.body) == null ? void 0 : _b.usage;
+    var _a, _b, _c, _d, _e;
+    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((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), 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: (_c = toolCall.id) != null ? _c : generateId(),
+          toolName: toolCall.function.name,
+          input: (_d = toolCall.function.arguments) != null ? _d : ""
+        });
+      }
+    }
+    const text = choice.message.content;
+    if (text != null && text.length > 0) {
+      content.push({ type: "text", text });
+    }
     return {
-      ...result,
-      usage: convertMoonshotAIChatUsage(usage)
+      content,
+      finishReason: {
+        unified: mapMoonshotAIFinishReason(choice.finish_reason),
+        raw: (_e = choice.finish_reason) != null ? _e : void 0
+      },
+      usage: convertMoonshotAIChatUsage(responseBody.usage),
+      request: { body: args },
+      response: {
+        ...getResponseMetadata(responseBody),
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      warnings
     };
   }
   async doStream(options) {
-    const result = await super.doStream(options);
+    var _a, _b;
+    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((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), 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 usage = void 0;
+    let isFirstChunk = true;
+    let isActiveReasoning = false;
+    let isActiveText = false;
     return {
-      ...result,
-      stream: result.stream.pipeThrough(
+      stream: response.pipeThrough(
         new TransformStream({
+          start(controller) {
+            toolCallTracker = new StreamingToolCallTracker(controller, {
+              generateId
+            });
+            controller.enqueue({ type: "stream-start", warnings });
+          },
           transform(chunk, controller) {
-            if (chunk.type === "finish" && chunk.usage) {
+            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: value.error.message });
+              return;
+            }
+            if (isFirstChunk) {
+              isFirstChunk = false;
+              controller.enqueue({
+                type: "response-metadata",
+                ...getResponseMetadata(value)
+              });
+            }
+            if (value.usage != null) {
+              usage = value.usage;
+            }
+            const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.finish_reason) != null) {
+              finishReason = {
+                unified: mapMoonshotAIFinishReason(choice.finish_reason),
+                raw: choice.finish_reason
+              };
+            }
+            if ((choice == null ? void 0 : choice.delta) == null) {
+              return;
+            }
+            const delta = choice.delta;
+            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({
-                ...chunk,
-                usage: convertMoonshotAIChatUsage(chunk.usage.raw)
+                type: "text-delta",
+                id: "txt-0",
+                delta: delta.content
               });
-            } else {
-              controller.enqueue(chunk);
             }
+            if (delta.tool_calls != null) {
+              if (isActiveReasoning) {
+                controller.enqueue({
+                  type: "reasoning-end",
+                  id: "reasoning-0"
+                });
+                isActiveReasoning = false;
+              }
+              for (const toolCallDelta of delta.tool_calls) {
+                toolCallTracker.processDelta(toolCallDelta);
+              }
+            }
+          },
+          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(usage)
+            });
           }
         })
-      )
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
     };
   }
 };
 
 // src/version.ts
-var VERSION = true ? "3.0.31" : "0.0.0-test";
+var VERSION = true ? "3.0.32" : "0.0.0-test";
 
 // src/moonshotai-provider.ts
-var moonshotaiErrorSchema = z.object({
-  error: z.object({
-    message: z.string(),
-    type: z.string().nullish()
-  })
-});
-var moonshotaiErrorStructure = {
-  errorSchema: moonshotaiErrorSchema,
-  errorToMessage: (data) => data.error.message
-};
 var defaultBaseURL = "https://api.moonshot.ai/v1";
 function getModelStructuredOutputSupport(modelId) {
   if (modelId.startsWith("kimi-k")) return true;
@@ -122,49 +770,14 @@ function createMoonshotAI(options = {}) {
     },
     `ai-sdk/moonshotai/${VERSION}`
   );
-  const getCommonModelConfig = (modelType) => ({
-    provider: `moonshotai.${modelType}`,
-    url: ({ path }) => `${baseURL}${path}`,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
   const createChatModel = (modelId) => {
     return new MoonshotAIChatLanguageModel(modelId, {
-      ...getCommonModelConfig("chat"),
+      provider: "moonshotai.chat",
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
       includeUsage: true,
-      errorStructure: moonshotaiErrorStructure,
-      supportsStructuredOutputs: getModelStructuredOutputSupport(modelId),
-      transformRequestBody: (args) => {
-        var _a2, _b;
-        const thinking = args.thinking;
-        const reasoningHistory = args.reasoningHistory;
-        const { thinking: _, reasoningHistory: __, ...rest } = args;
-        const schema = (_b = (_a2 = rest.response_format) == null ? void 0 : _a2.json_schema) == null ? void 0 : _b.schema;
-        if (schema != null) {
-          const { $schema: _$schema, ...schemaWithoutDollarSchema } = schema;
-          rest.response_format = {
-            ...rest.response_format,
-            json_schema: {
-              ...rest.response_format.json_schema,
-              schema: schemaWithoutDollarSchema
-            }
-          };
-        }
-        return {
-          ...rest,
-          ...thinking && {
-            thinking: {
-              type: thinking.type,
-              ...thinking.budgetTokens !== void 0 && {
-                budget_tokens: thinking.budgetTokens
-              }
-            }
-          },
-          ...reasoningHistory && {
-            reasoning_history: reasoningHistory
-          }
-        };
-      }
+      supportsStructuredOutputs: getModelStructuredOutputSupport(modelId)
     });
   };
   const provider = (modelId) => createChatModel(modelId);