@ai-sdk/openai 0.0.68 → 0.0.71

package/dist/index.mjs

@@ -4,7 +4,7 @@ import { loadApiKey, withoutTrailingSlash } from "@ai-sdk/provider-utils";
 // src/openai-chat-language-model.ts
 import {
   InvalidResponseDataError,
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } from "@ai-sdk/provider";
 import {
   combineHeaders,
@@ -222,6 +222,109 @@ function getResponseMetadata({
   };
 }
 
+// src/openai-prepare-tools.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
+function prepareTools({
+  mode,
+  useLegacyFunctionCalling = false,
+  structuredOutputs = false
+}) {
+  var _a;
+  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, tool_choice: void 0, toolWarnings };
+  }
+  const toolChoice = mode.toolChoice;
+  if (useLegacyFunctionCalling) {
+    const openaiFunctions = [];
+    for (const tool of tools) {
+      if (tool.type === "provider-defined") {
+        toolWarnings.push({ type: "unsupported-tool", tool });
+      } else {
+        openaiFunctions.push({
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        });
+      }
+    }
+    if (toolChoice == null) {
+      return {
+        functions: openaiFunctions,
+        function_call: void 0,
+        toolWarnings
+      };
+    }
+    const type2 = toolChoice.type;
+    switch (type2) {
+      case "auto":
+      case "none":
+      case void 0:
+        return {
+          functions: openaiFunctions,
+          function_call: void 0,
+          toolWarnings
+        };
+      case "required":
+        throw new UnsupportedFunctionalityError2({
+          functionality: "useLegacyFunctionCalling and toolChoice: required"
+        });
+      default:
+        return {
+          functions: openaiFunctions,
+          function_call: { name: toolChoice.toolName },
+          toolWarnings
+        };
+    }
+  }
+  const openaiTools = [];
+  for (const tool of tools) {
+    if (tool.type === "provider-defined") {
+      toolWarnings.push({ type: "unsupported-tool", tool });
+    } else {
+      openaiTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+          strict: structuredOutputs === true ? true : void 0
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiTools, tool_choice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiTools, tool_choice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiTools,
+        tool_choice: {
+          type: "function",
+          function: {
+            name: toolChoice.toolName
+          }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError2({
+        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
 // src/openai-chat-language-model.ts
 var OpenAIChatLanguageModel = class {
   constructor(modelId, settings, config) {
@@ -277,12 +380,12 @@ var OpenAIChatLanguageModel = class {
     }
     const useLegacyFunctionCalling = this.settings.useLegacyFunctionCalling;
     if (useLegacyFunctionCalling && this.settings.parallelToolCalls === true) {
-      throw new UnsupportedFunctionalityError2({
+      throw new UnsupportedFunctionalityError3({
         functionality: "useLegacyFunctionCalling with parallelToolCalls"
       });
     }
     if (useLegacyFunctionCalling && this.settings.structuredOutputs === true) {
-      throw new UnsupportedFunctionalityError2({
+      throw new UnsupportedFunctionalityError3({
         functionality: "structuredOutputs with useLegacyFunctionCalling"
       });
     }
@@ -323,23 +426,27 @@ var OpenAIChatLanguageModel = class {
     }
     switch (type) {
       case "regular": {
+        const { tools, tool_choice, functions, function_call, toolWarnings } = prepareTools({
+          mode,
+          useLegacyFunctionCalling,
+          structuredOutputs: this.settings.structuredOutputs
+        });
         return {
           args: {
             ...baseArgs,
-            ...prepareToolsAndToolChoice({
-              mode,
-              useLegacyFunctionCalling,
-              structuredOutputs: this.settings.structuredOutputs
-            })
+            tools,
+            tool_choice,
+            functions,
+            function_call
           },
-          warnings
+          warnings: [...warnings, ...toolWarnings]
         };
       }
       case "object-json": {
         return {
           args: {
             ...baseArgs,
-            response_format: this.settings.structuredOutputs === true ? {
+            response_format: this.settings.structuredOutputs === true && mode.schema != null ? {
               type: "json_schema",
               json_schema: {
                 schema: mode.schema,
@@ -395,14 +502,14 @@ var OpenAIChatLanguageModel = class {
   }
   async doGenerate(options) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
-    const { args, warnings } = this.getArgs(options);
+    const { args: body, warnings } = this.getArgs(options);
     const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
       headers: combineHeaders(this.config.headers(), options.headers),
-      body: args,
+      body,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
         openAIChatResponseSchema
@@ -410,7 +517,7 @@ var OpenAIChatLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { messages: rawPrompt, ...rawSettings } = args;
+    const { messages: rawPrompt, ...rawSettings } = body;
     const choice = response.choices[0];
     let providerMetadata;
     if (((_b = (_a = response.usage) == null ? void 0 : _a.completion_tokens_details) == null ? void 0 : _b.reasoning_tokens) != null || ((_d = (_c = response.usage) == null ? void 0 : _c.prompt_tokens_details) == null ? void 0 : _d.cached_tokens) != null) {
@@ -447,6 +554,7 @@ var OpenAIChatLanguageModel = class {
       },
       rawCall: { rawPrompt, rawSettings },
       rawResponse: { headers: responseHeaders },
+      request: { body: JSON.stringify(body) },
       response: getResponseMetadata(response),
       warnings,
       logprobs: mapOpenAIChatLogProbsOutput(choice.logprobs),
@@ -491,18 +599,19 @@ var OpenAIChatLanguageModel = class {
       };
     }
     const { args, warnings } = this.getArgs(options);
+    const body = {
+      ...args,
+      stream: true,
+      // only include stream_options when in strict compatibility mode:
+      stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
+    };
     const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
       headers: combineHeaders(this.config.headers(), options.headers),
-      body: {
-        ...args,
-        stream: true,
-        // only include stream_options when in strict compatibility mode:
-        stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
-      },
+      body,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
         openaiChatChunkSchema
@@ -679,6 +788,7 @@ var OpenAIChatLanguageModel = class {
       ),
       rawCall: { rawPrompt, rawSettings },
       rawResponse: { headers: responseHeaders },
+      request: { body: JSON.stringify(body) },
       warnings
     };
   }
@@ -785,80 +895,6 @@ var openaiChatChunkSchema = z2.union([
   }),
   openAIErrorDataSchema
 ]);
-function prepareToolsAndToolChoice({
-  mode,
-  useLegacyFunctionCalling = false,
-  structuredOutputs = false
-}) {
-  var _a;
-  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
-  if (tools == null) {
-    return { tools: void 0, tool_choice: void 0 };
-  }
-  const toolChoice = mode.toolChoice;
-  if (useLegacyFunctionCalling) {
-    const mappedFunctions = tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters
-    }));
-    if (toolChoice == null) {
-      return { functions: mappedFunctions, function_call: void 0 };
-    }
-    const type2 = toolChoice.type;
-    switch (type2) {
-      case "auto":
-      case "none":
-      case void 0:
-        return {
-          functions: mappedFunctions,
-          function_call: void 0
-        };
-      case "required":
-        throw new UnsupportedFunctionalityError2({
-          functionality: "useLegacyFunctionCalling and toolChoice: required"
-        });
-      default:
-        return {
-          functions: mappedFunctions,
-          function_call: { name: toolChoice.toolName }
-        };
-    }
-  }
-  const mappedTools = tools.map((tool) => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters,
-      strict: structuredOutputs === true ? true : void 0
-    }
-  }));
-  if (toolChoice == null) {
-    return { tools: mappedTools, tool_choice: void 0 };
-  }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-    case "none":
-    case "required":
-      return { tools: mappedTools, tool_choice: type };
-    case "tool":
-      return {
-        tools: mappedTools,
-        tool_choice: {
-          type: "function",
-          function: {
-            name: toolChoice.toolName
-          }
-        }
-      };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new Error(`Unsupported tool choice type: ${_exhaustiveCheck}`);
-    }
-  }
-}
 function isReasoningModel(modelId) {
   return modelId.startsWith("o1-");
 }
@@ -868,7 +904,7 @@ function isAudioModel(modelId) {
 
 // src/openai-completion-language-model.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError5
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders2,
@@ -881,7 +917,7 @@ import { z as z3 } from "zod";
 // src/convert-to-openai-completion-prompt.ts
 import {
   InvalidPromptError,
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
 } from "@ai-sdk/provider";
 function convertToOpenAICompletionPrompt({
   prompt,
@@ -914,7 +950,7 @@ function convertToOpenAICompletionPrompt({
               return part.text;
             }
             case "image": {
-              throw new UnsupportedFunctionalityError3({
+              throw new UnsupportedFunctionalityError4({
                 functionality: "images"
               });
             }
@@ -933,7 +969,7 @@ ${userMessage}
               return part.text;
             }
             case "tool-call": {
-              throw new UnsupportedFunctionalityError3({
+              throw new UnsupportedFunctionalityError4({
                 functionality: "tool-call messages"
               });
             }
@@ -946,7 +982,7 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new UnsupportedFunctionalityError3({
+        throw new UnsupportedFunctionalityError4({
           functionality: "tool messages"
         });
       }
@@ -1047,24 +1083,24 @@ var OpenAICompletionLanguageModel = class {
     switch (type) {
       case "regular": {
         if ((_a = mode.tools) == null ? void 0 : _a.length) {
-          throw new UnsupportedFunctionalityError4({
+          throw new UnsupportedFunctionalityError5({
             functionality: "tools"
           });
         }
         if (mode.toolChoice) {
-          throw new UnsupportedFunctionalityError4({
+          throw new UnsupportedFunctionalityError5({
             functionality: "toolChoice"
           });
         }
         return { args: baseArgs, warnings };
       }
       case "object-json": {
-        throw new UnsupportedFunctionalityError4({
+        throw new UnsupportedFunctionalityError5({
           functionality: "object-json mode"
         });
       }
       case "object-tool": {
-        throw new UnsupportedFunctionalityError4({
+        throw new UnsupportedFunctionalityError5({
           functionality: "object-tool mode"
         });
       }
@@ -1103,23 +1139,25 @@ var OpenAICompletionLanguageModel = class {
       rawCall: { rawPrompt, rawSettings },
       rawResponse: { headers: responseHeaders },
       response: getResponseMetadata(response),
-      warnings
+      warnings,
+      request: { body: JSON.stringify(args) }
     };
   }
   async doStream(options) {
     const { args, warnings } = this.getArgs(options);
+    const body = {
+      ...args,
+      stream: true,
+      // only include stream_options when in strict compatibility mode:
+      stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
+    };
     const { responseHeaders, value: response } = await postJsonToApi2({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
       headers: combineHeaders2(this.config.headers(), options.headers),
-      body: {
-        ...args,
-        stream: true,
-        // only include stream_options when in strict compatibility mode:
-        stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
-      },
+      body,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler2(
         openaiCompletionChunkSchema
@@ -1193,7 +1231,8 @@ var OpenAICompletionLanguageModel = class {
       ),
       rawCall: { rawPrompt, rawSettings },
       rawResponse: { headers: responseHeaders },
-      warnings
+      warnings,
+      request: { body: JSON.stringify(body) }
     };
   }
 };