@ai-sdk/openai-compatible 2.0.73 → 2.0.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai-compatible",
-  "version": "2.0.73",
+  "version": "2.0.75",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -36,8 +36,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "3.0.15",
-    "@ai-sdk/provider-utils": "4.0.49"
+    "@ai-sdk/provider": "3.0.16",
+    "@ai-sdk/provider-utils": "4.0.51"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/chat/openai-compatible-chat-language-model.ts

@@ -299,13 +299,16 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
     });
 
     const choice = responseBody.choices[0];
+    if (choice == null) {
+      throw new InvalidResponseDataError({
+        data: rawResponse,
+        message: 'Response did not contain any choices.',
+      });
+    }
+
     const content: Array<LanguageModelV3Content> = [];
 
-    // text content:
-    const text = choice.message.content;
-    if (text != null && text.length > 0) {
-      content.push({ type: 'text', text });
-    }
+    content.push(...convertOpenAICompatibleContent(choice.message.content));
 
     // reasoning content:
     const reasoning =
@@ -508,9 +511,12 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
 
             const delta = choice.delta;
 
-            // enqueue reasoning before text deltas:
-            const reasoningContent = delta.reasoning_content ?? delta.reasoning;
-            if (reasoningContent) {
+            const enqueueReasoningDelta = (reasoningDelta: string) => {
+              if (isActiveText) {
+                controller.enqueue({ type: 'text-end', id: 'txt-0' });
+                isActiveText = false;
+              }
+
               if (!isActiveReasoning) {
                 controller.enqueue({
                   type: 'reasoning-start',
@@ -522,12 +528,11 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
               controller.enqueue({
                 type: 'reasoning-delta',
                 id: 'reasoning-0',
-                delta: reasoningContent,
+                delta: reasoningDelta,
               });
-            }
+            };
 
-            if (delta.content) {
-              // end active reasoning block before text starts
+            const enqueueTextDelta = (textDelta: string) => {
               if (isActiveReasoning) {
                 controller.enqueue({
                   type: 'reasoning-end',
@@ -544,11 +549,27 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
               controller.enqueue({
                 type: 'text-delta',
                 id: 'txt-0',
-                delta: delta.content,
+                delta: textDelta,
               });
+            };
+
+            // enqueue reasoning before text deltas:
+            const reasoningContent = delta.reasoning_content ?? delta.reasoning;
+            if (reasoningContent) {
+              enqueueReasoningDelta(reasoningContent);
             }
 
-            if (delta.tool_calls != null) {
+            for (const contentPart of convertOpenAICompatibleContent(
+              delta.content,
+            )) {
+              if (contentPart.type === 'reasoning') {
+                enqueueReasoningDelta(contentPart.text);
+              } else {
+                enqueueTextDelta(contentPart.text);
+              }
+            }
+
+            if (delta.tool_calls != null && delta.tool_calls.length > 0) {
               // end active reasoning block before tool calls start
               if (isActiveReasoning) {
                 controller.enqueue({
@@ -815,6 +836,60 @@ const openaiCompatibleTokenUsageSchema = z
   })
   .nullish();
 
+const openAICompatibleContentSchema = z
+  .union([
+    z.string(),
+    z.array(
+      z.looseObject({
+        type: z.string(),
+      }),
+    ),
+  ])
+  .nullish();
+
+function convertOpenAICompatibleContent(
+  content: z.infer<typeof openAICompatibleContentSchema>,
+): Array<Extract<LanguageModelV3Content, { type: 'text' | 'reasoning' }>> {
+  if (content == null) {
+    return [];
+  }
+
+  if (typeof content === 'string') {
+    return content.length > 0 ? [{ type: 'text', text: content }] : [];
+  }
+
+  const result: Array<
+    Extract<LanguageModelV3Content, { type: 'text' | 'reasoning' }>
+  > = [];
+
+  for (const part of content) {
+    if (part.type === 'text' && typeof part.text === 'string') {
+      if (part.text.length > 0) {
+        result.push({ type: 'text', text: part.text });
+      }
+    } else if (part.type === 'thinking' && Array.isArray(part.thinking)) {
+      const reasoningText = part.thinking
+        .filter(
+          chunk =>
+            chunk != null &&
+            typeof chunk === 'object' &&
+            'type' in chunk &&
+            chunk.type === 'text' &&
+            'text' in chunk &&
+            typeof chunk.text === 'string',
+        )
+        .map(chunk => chunk.text)
+        .join('');
+
+      if (reasoningText.length > 0) {
+        result.push({ type: 'reasoning', text: reasoningText });
+      }
+    }
+  }
+
+  return result;
+}
+
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
 const OpenAICompatibleChatResponseSchema = z.looseObject({
@@ -825,7 +900,7 @@ const OpenAICompatibleChatResponseSchema = z.looseObject({
     z.object({
       message: z.object({
         role: z.literal('assistant').nullish(),
-        content: z.string().nullish(),
+        content: openAICompatibleContentSchema,
         reasoning_content: z.string().nullish(),
         reasoning: z.string().nullish(),
         tool_calls: z
@@ -865,7 +940,7 @@ const chunkBaseSchema = z.looseObject({
       delta: z
         .object({
           role: z.enum(['assistant', '']).nullish(),
-          content: z.string().nullish(),
+          content: openAICompatibleContentSchema,
           // Most openai-compatible models set `reasoning_content`, but some
           // providers serving `gpt-oss` set `reasoning`. See #7866
           reasoning_content: z.string().nullish(),