@ai-sdk/openai 0.0.37 → 0.0.39

package/internal/dist/index.mjs

@@ -1,7 +1,7 @@
 // src/openai-chat-language-model.ts
 import {
   InvalidResponseDataError,
-  UnsupportedFunctionalityError
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
 import {
   combineHeaders,
@@ -14,8 +14,14 @@ import {
 import { z as z2 } from "zod";
 
 // src/convert-to-openai-chat-messages.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
 import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
-function convertToOpenAIChatMessages(prompt) {
+function convertToOpenAIChatMessages({
+  prompt,
+  useLegacyFunctionCalling = false
+}) {
   const messages = [];
   for (const { role, content } of prompt) {
     switch (role) {
@@ -75,20 +81,41 @@ function convertToOpenAIChatMessages(prompt) {
             }
           }
         }
-        messages.push({
-          role: "assistant",
-          content: text,
-          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
-        });
+        if (useLegacyFunctionCalling) {
+          if (toolCalls.length > 1) {
+            throw new UnsupportedFunctionalityError({
+              functionality: "useLegacyFunctionCalling with multiple tool calls in one message"
+            });
+          }
+          messages.push({
+            role: "assistant",
+            content: text,
+            function_call: toolCalls.length > 0 ? toolCalls[0].function : void 0
+          });
+        } else {
+          messages.push({
+            role: "assistant",
+            content: text,
+            tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+          });
+        }
         break;
       }
       case "tool": {
         for (const toolResponse of content) {
-          messages.push({
-            role: "tool",
-            tool_call_id: toolResponse.toolCallId,
-            content: JSON.stringify(toolResponse.result)
-          });
+          if (useLegacyFunctionCalling) {
+            messages.push({
+              role: "function",
+              name: toolResponse.toolName,
+              content: JSON.stringify(toolResponse.result)
+            });
+          } else {
+            messages.push({
+              role: "tool",
+              tool_call_id: toolResponse.toolCallId,
+              content: JSON.stringify(toolResponse.result)
+            });
+          }
         }
         break;
       }
@@ -165,11 +192,34 @@ var OpenAIChatLanguageModel = class {
     maxTokens,
     temperature,
     topP,
+    topK,
     frequencyPenalty,
     presencePenalty,
+    stopSequences,
+    responseFormat,
     seed
   }) {
     const type = mode.type;
+    const warnings = [];
+    if (topK != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "topK"
+      });
+    }
+    if (responseFormat != null && responseFormat.type === "json" && responseFormat.schema != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "responseFormat",
+        details: "JSON response format schema is not supported"
+      });
+    }
+    const useLegacyFunctionCalling = this.settings.useLegacyFunctionCalling;
+    if (useLegacyFunctionCalling && this.settings.parallelToolCalls === true) {
+      throw new UnsupportedFunctionalityError2({
+        functionality: "useLegacyFunctionCalling with parallelToolCalls"
+      });
+    }
     const baseArgs = {
       // model id:
       model: this.modelId,
@@ -185,41 +235,69 @@ var OpenAIChatLanguageModel = class {
       top_p: topP,
       frequency_penalty: frequencyPenalty,
       presence_penalty: presencePenalty,
+      stop: stopSequences,
       seed,
+      // response format:
+      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? { type: "json_object" } : void 0,
       // messages:
-      messages: convertToOpenAIChatMessages(prompt)
+      messages: convertToOpenAIChatMessages({
+        prompt,
+        useLegacyFunctionCalling
+      })
     };
     switch (type) {
       case "regular": {
-        return { ...baseArgs, ...prepareToolsAndToolChoice(mode) };
+        return {
+          args: {
+            ...baseArgs,
+            ...prepareToolsAndToolChoice({ mode, useLegacyFunctionCalling })
+          },
+          warnings
+        };
       }
       case "object-json": {
         return {
-          ...baseArgs,
-          response_format: { type: "json_object" }
+          args: {
+            ...baseArgs,
+            response_format: { type: "json_object" }
+          },
+          warnings
         };
       }
       case "object-tool": {
         return {
-          ...baseArgs,
-          tool_choice: { type: "function", function: { name: mode.tool.name } },
-          tools: [
-            {
-              type: "function",
-              function: {
+          args: useLegacyFunctionCalling ? {
+            ...baseArgs,
+            function_call: {
+              name: mode.tool.name
+            },
+            functions: [
+              {
                 name: mode.tool.name,
                 description: mode.tool.description,
                 parameters: mode.tool.parameters
               }
-            }
-          ]
+            ]
+          } : {
+            ...baseArgs,
+            tool_choice: {
+              type: "function",
+              function: { name: mode.tool.name }
+            },
+            tools: [
+              {
+                type: "function",
+                function: {
+                  name: mode.tool.name,
+                  description: mode.tool.description,
+                  parameters: mode.tool.parameters
+                }
+              }
+            ]
+          },
+          warnings
         };
       }
-      case "object-grammar": {
-        throw new UnsupportedFunctionalityError({
-          functionality: "object-grammar mode"
-        });
-      }
       default: {
         const _exhaustiveCheck = type;
         throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
@@ -228,7 +306,7 @@ var OpenAIChatLanguageModel = class {
   }
   async doGenerate(options) {
     var _a, _b;
-    const args = this.getArgs(options);
+    const { args, warnings } = this.getArgs(options);
     const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
@@ -247,7 +325,14 @@ var OpenAIChatLanguageModel = class {
     const choice = response.choices[0];
     return {
       text: (_a = choice.message.content) != null ? _a : void 0,
-      toolCalls: (_b = choice.message.tool_calls) == null ? void 0 : _b.map((toolCall) => {
+      toolCalls: this.settings.useLegacyFunctionCalling && choice.message.function_call ? [
+        {
+          toolCallType: "function",
+          toolCallId: generateId(),
+          toolName: choice.message.function_call.name,
+          args: choice.message.function_call.arguments
+        }
+      ] : (_b = choice.message.tool_calls) == null ? void 0 : _b.map((toolCall) => {
         var _a2;
         return {
           toolCallType: "function",
@@ -263,12 +348,12 @@ var OpenAIChatLanguageModel = class {
       },
       rawCall: { rawPrompt, rawSettings },
       rawResponse: { headers: responseHeaders },
-      warnings: [],
+      warnings,
       logprobs: mapOpenAIChatLogProbsOutput(choice.logprobs)
     };
   }
   async doStream(options) {
-    const args = this.getArgs(options);
+    const { args, warnings } = this.getArgs(options);
     const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
@@ -296,6 +381,7 @@ var OpenAIChatLanguageModel = class {
       completionTokens: Number.NaN
     };
     let logprobs;
+    const { useLegacyFunctionCalling } = this.settings;
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -340,8 +426,16 @@ var OpenAIChatLanguageModel = class {
                 logprobs = [];
               logprobs.push(...mappedLogprobs);
             }
-            if (delta.tool_calls != null) {
-              for (const toolCallDelta of delta.tool_calls) {
+            const mappedToolCalls = useLegacyFunctionCalling && delta.function_call != null ? [
+              {
+                type: "function",
+                id: generateId(),
+                function: delta.function_call,
+                index: 0
+              }
+            ] : delta.tool_calls;
+            if (mappedToolCalls != null) {
+              for (const toolCallDelta of mappedToolCalls) {
                 const index = toolCallDelta.index;
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.type !== "function") {
@@ -424,7 +518,7 @@ var OpenAIChatLanguageModel = class {
       ),
       rawCall: { rawPrompt, rawSettings },
       rawResponse: { headers: responseHeaders },
-      warnings: []
+      warnings
     };
   }
 };
@@ -433,17 +527,21 @@ var openAIChatResponseSchema = z2.object({
     z2.object({
       message: z2.object({
         role: z2.literal("assistant"),
-        content: z2.string().nullable().optional(),
+        content: z2.string().nullish(),
+        function_call: z2.object({
+          arguments: z2.string(),
+          name: z2.string()
+        }).nullish(),
         tool_calls: z2.array(
           z2.object({
-            id: z2.string().optional().nullable(),
+            id: z2.string().nullish(),
             type: z2.literal("function"),
             function: z2.object({
               name: z2.string(),
               arguments: z2.string()
             })
           })
-        ).optional()
+        ).nullish()
       }),
       index: z2.number(),
       logprobs: z2.object({
@@ -459,8 +557,8 @@ var openAIChatResponseSchema = z2.object({
             )
           })
         ).nullable()
-      }).nullable().optional(),
-      finish_reason: z2.string().optional().nullable()
+      }).nullish(),
+      finish_reason: z2.string().nullish()
     })
   ),
   usage: z2.object({
@@ -475,6 +573,10 @@ var openaiChatChunkSchema = z2.union([
         delta: z2.object({
           role: z2.enum(["assistant"]).optional(),
           content: z2.string().nullish(),
+          function_call: z2.object({
+            name: z2.string().optional(),
+            arguments: z2.string().optional()
+          }).nullish(),
           tool_calls: z2.array(
             z2.object({
               index: z2.number(),
@@ -512,12 +614,45 @@ var openaiChatChunkSchema = z2.union([
   }),
   openAIErrorDataSchema
 ]);
-function prepareToolsAndToolChoice(mode) {
+function prepareToolsAndToolChoice({
+  mode,
+  useLegacyFunctionCalling = 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: {
@@ -526,7 +661,6 @@ function prepareToolsAndToolChoice(mode) {
       parameters: tool.parameters
     }
   }));
-  const toolChoice = mode.toolChoice;
   if (toolChoice == null) {
     return { tools: mappedTools, tool_choice: void 0 };
   }
@@ -555,7 +689,7 @@ function prepareToolsAndToolChoice(mode) {
 
 // src/openai-completion-language-model.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders2,
@@ -568,7 +702,7 @@ import { z as z3 } from "zod";
 // src/convert-to-openai-completion-prompt.ts
 import {
   InvalidPromptError,
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } from "@ai-sdk/provider";
 function convertToOpenAICompletionPrompt({
   prompt,
@@ -601,7 +735,7 @@ function convertToOpenAICompletionPrompt({
               return part.text;
             }
             case "image": {
-              throw new UnsupportedFunctionalityError2({
+              throw new UnsupportedFunctionalityError3({
                 functionality: "images"
               });
             }
@@ -620,7 +754,7 @@ ${userMessage}
               return part.text;
             }
             case "tool-call": {
-              throw new UnsupportedFunctionalityError2({
+              throw new UnsupportedFunctionalityError3({
                 functionality: "tool-call messages"
               });
             }
@@ -633,7 +767,7 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new UnsupportedFunctionalityError2({
+        throw new UnsupportedFunctionalityError3({
           functionality: "tool messages"
         });
       }
@@ -685,13 +819,31 @@ var OpenAICompletionLanguageModel = class {
     maxTokens,
     temperature,
     topP,
+    topK,
     frequencyPenalty,
     presencePenalty,
+    stopSequences: userStopSequences,
+    responseFormat,
     seed
   }) {
     var _a;
     const type = mode.type;
+    const warnings = [];
+    if (topK != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "topK"
+      });
+    }
+    if (responseFormat != null && responseFormat.type !== "text") {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "responseFormat",
+        details: "JSON response format is not supported."
+      });
+    }
     const { prompt: completionPrompt, stopSequences } = convertToOpenAICompletionPrompt({ prompt, inputFormat });
+    const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
     const baseArgs = {
       // model id:
       model: this.modelId,
@@ -711,37 +863,32 @@ var OpenAICompletionLanguageModel = class {
       // prompt:
       prompt: completionPrompt,
       // stop sequences:
-      stop: stopSequences
+      stop: stop.length > 0 ? stop : void 0
     };
     switch (type) {
       case "regular": {
         if ((_a = mode.tools) == null ? void 0 : _a.length) {
-          throw new UnsupportedFunctionalityError3({
+          throw new UnsupportedFunctionalityError4({
             functionality: "tools"
           });
         }
         if (mode.toolChoice) {
-          throw new UnsupportedFunctionalityError3({
+          throw new UnsupportedFunctionalityError4({
             functionality: "toolChoice"
           });
         }
-        return baseArgs;
+        return { args: baseArgs, warnings };
       }
       case "object-json": {
-        throw new UnsupportedFunctionalityError3({
+        throw new UnsupportedFunctionalityError4({
           functionality: "object-json mode"
         });
       }
       case "object-tool": {
-        throw new UnsupportedFunctionalityError3({
+        throw new UnsupportedFunctionalityError4({
           functionality: "object-tool mode"
         });
       }
-      case "object-grammar": {
-        throw new UnsupportedFunctionalityError3({
-          functionality: "object-grammar mode"
-        });
-      }
       default: {
         const _exhaustiveCheck = type;
         throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
@@ -749,7 +896,7 @@ var OpenAICompletionLanguageModel = class {
     }
   }
   async doGenerate(options) {
-    const args = this.getArgs(options);
+    const { args, warnings } = this.getArgs(options);
     const { responseHeaders, value: response } = await postJsonToApi2({
       url: this.config.url({
         path: "/completions",
@@ -776,11 +923,11 @@ var OpenAICompletionLanguageModel = class {
       logprobs: mapOpenAICompletionLogProbs(choice.logprobs),
       rawCall: { rawPrompt, rawSettings },
       rawResponse: { headers: responseHeaders },
-      warnings: []
+      warnings
     };
   }
   async doStream(options) {
-    const args = this.getArgs(options);
+    const { args, warnings } = this.getArgs(options);
     const { responseHeaders, value: response } = await postJsonToApi2({
       url: this.config.url({
         path: "/completions",
@@ -788,7 +935,7 @@ var OpenAICompletionLanguageModel = class {
       }),
       headers: combineHeaders2(this.config.headers(), options.headers),
       body: {
-        ...this.getArgs(options),
+        ...args,
         stream: true,
         // only include stream_options when in strict compatibility mode:
         stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
@@ -859,7 +1006,7 @@ var OpenAICompletionLanguageModel = class {
       ),
       rawCall: { rawPrompt, rawSettings },
       rawResponse: { headers: responseHeaders },
-      warnings: []
+      warnings
     };
   }
 };