@tanstack/openai-base 0.1.0 → 0.2.1

package/dist/esm/adapters/responses-text.js

@@ -1,8 +1,11 @@
 import { BaseTextAdapter } from "@tanstack/ai/adapters";
+import { toRunErrorPayload } from "@tanstack/ai/adapter-internals";
 import { generateId, transformNullsToUndefined } from "@tanstack/ai-utils";
 import { createOpenAICompatibleClient } from "../utils/client.js";
+import { extractRequestOptions } from "../utils/request-options.js";
 import { makeStructuredOutputCompatible } from "../utils/schema-converter.js";
 import { convertToolsToResponsesFormat } from "./responses-tool-converter.js";
+const asChunk = (chunk) => chunk;
 class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
   constructor(config, model, name = "openai-compatible-responses") {
     super({}, model);
@@ -21,15 +24,16 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
       hasEmittedRunStarted: false
     };
     try {
+      options.logger.request(
+        `activity=chat provider=${this.name} model=${this.model} messages=${options.messages.length} tools=${options.tools?.length ?? 0} stream=true`,
+        { provider: this.name, model: this.model }
+      );
       const response = await this.client.responses.create(
         {
           ...requestParams,
           stream: true
         },
-        {
-          headers: options.request?.headers,
-          signal: options.request?.signal
-        }
+        extractRequestOptions(options.request)
       );
       yield* this.processStreamChunks(
         response,
@@ -38,32 +42,30 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
         aguiState
       );
     } catch (error) {
-      const err = error;
+      const errorPayload = toRunErrorPayload(
+        error,
+        `${this.name}.chatStream failed`
+      );
       if (!aguiState.hasEmittedRunStarted) {
         aguiState.hasEmittedRunStarted = true;
-        yield {
+        yield asChunk({
           type: "RUN_STARTED",
           runId: aguiState.runId,
           model: options.model,
           timestamp
-        };
+        });
       }
-      yield {
+      yield asChunk({
         type: "RUN_ERROR",
         runId: aguiState.runId,
         model: options.model,
         timestamp,
-        error: {
-          message: err.message || "Unknown error",
-          code: err.code
-        }
-      };
-      console.error(
-        `>>> [${this.name}] chatStream: Fatal error during response creation <<<`
-      );
-      console.error(">>> Error message:", err.message);
-      console.error(">>> Error stack:", err.stack);
-      console.error(">>> Full error:", err);
+        error: errorPayload
+      });
+      options.logger.errors(`${this.name}.chatStream fatal`, {
+        error: errorPayload,
+        source: `${this.name}.chatStream`
+      });
     }
   }
   /**
@@ -83,12 +85,23 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
     const requestParams = this.mapOptionsToRequest(chatOptions);
     const jsonSchema = this.makeStructuredOutputCompatible(
       outputSchema,
-      outputSchema.required || []
+      outputSchema.required
     );
     try {
+      const {
+        stream: _stream,
+        stream_options: _streamOptions,
+        ...cleanParams
+      } = requestParams;
+      void _stream;
+      void _streamOptions;
+      chatOptions.logger.request(
+        `activity=structuredOutput provider=${this.name} model=${this.model} messages=${chatOptions.messages.length}`,
+        { provider: this.name, model: this.model }
+      );
       const response = await this.client.responses.create(
         {
-          ...requestParams,
+          ...cleanParams,
           stream: false,
           // Configure structured output via text.format
           text: {
@@ -100,10 +113,7 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
             }
           }
         },
-        {
-          headers: chatOptions.request?.headers,
-          signal: chatOptions.request?.signal
-        }
+        extractRequestOptions(chatOptions.request)
       );
       const rawText = this.extractTextFromResponse(
         response
@@ -122,11 +132,10 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
         rawText
       };
     } catch (error) {
-      const err = error;
-      console.error(
-        `>>> [${this.name}] structuredOutput: Error during response creation <<<`
-      );
-      console.error(">>> Error message:", err.message);
+      chatOptions.logger.errors(`${this.name}.structuredOutput fatal`, {
+        error: toRunErrorPayload(error, `${this.name}.structuredOutput failed`),
+        source: `${this.name}.structuredOutput`
+      });
       throw error;
     }
   }
@@ -143,15 +152,23 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
    */
   extractTextFromResponse(response) {
     let textContent = "";
+    let refusal;
     for (const item of response.output) {
       if (item.type === "message") {
         for (const part of item.content) {
           if (part.type === "output_text") {
             textContent += part.text;
+          } else {
+            refusal = part.refusal || refusal || "Refused without explanation";
           }
         }
       }
     }
+    if (!textContent && refusal !== void 0) {
+      const err = new Error(`Model refused to respond: ${refusal}`);
+      err.code = "refusal";
+      throw err;
+    }
     return textContent;
   }
   /**
@@ -173,110 +190,126 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
     let accumulatedContent = "";
     let accumulatedReasoning = "";
     const timestamp = aguiState.timestamp;
-    let chunkCount = 0;
     let hasStreamedContentDeltas = false;
     let hasStreamedReasoningDeltas = false;
     let model = options.model;
     let stepId = null;
     let hasEmittedTextMessageStart = false;
     let hasEmittedStepStarted = false;
+    let runFinishedEmitted = false;
     try {
       for await (const chunk of stream) {
-        chunkCount++;
+        options.logger.provider(`provider=${this.name} type=${chunk.type}`, {
+          provider: this.name,
+          type: chunk.type
+        });
         if (!aguiState.hasEmittedRunStarted) {
           aguiState.hasEmittedRunStarted = true;
-          yield {
+          yield asChunk({
             type: "RUN_STARTED",
             runId: aguiState.runId,
             model: model || options.model,
             timestamp
-          };
+          });
         }
         const handleContentPart = (contentPart) => {
           if (contentPart.type === "output_text") {
             accumulatedContent += contentPart.text || "";
-            return {
+            return asChunk({
               type: "TEXT_MESSAGE_CONTENT",
               messageId: aguiState.messageId,
               model: model || options.model,
               timestamp,
               delta: contentPart.text || "",
               content: accumulatedContent
-            };
+            });
           }
           if (contentPart.type === "reasoning_text") {
             accumulatedReasoning += contentPart.text || "";
-            return {
+            if (!stepId) {
+              stepId = generateId(this.name);
+            }
+            return asChunk({
               type: "STEP_FINISHED",
-              stepId: stepId || generateId(this.name),
+              stepId,
               model: model || options.model,
               timestamp,
               delta: contentPart.text || "",
               content: accumulatedReasoning
-            };
+            });
           }
-          return {
+          const isRefusal = contentPart.type === "refusal";
+          const message = isRefusal ? contentPart.refusal || "Refused without explanation" : `Unsupported response content_part type: ${contentPart.type}`;
+          return asChunk({
             type: "RUN_ERROR",
             runId: aguiState.runId,
             model: model || options.model,
             timestamp,
             error: {
-              message: contentPart.refusal || "Unknown refusal"
+              message,
+              code: isRefusal ? "refusal" : contentPart.type
             }
-          };
+          });
         };
         if (chunk.type === "response.created" || chunk.type === "response.incomplete" || chunk.type === "response.failed") {
           model = chunk.response.model;
+        }
+        if (chunk.type === "response.created") {
           hasStreamedContentDeltas = false;
           hasStreamedReasoningDeltas = false;
           hasEmittedTextMessageStart = false;
           hasEmittedStepStarted = false;
           accumulatedContent = "";
           accumulatedReasoning = "";
-          if (chunk.response.error) {
-            yield {
-              type: "RUN_ERROR",
-              runId: aguiState.runId,
-              model: chunk.response.model,
-              timestamp,
-              error: chunk.response.error
-            };
-          }
-          if (chunk.response.incomplete_details) {
-            yield {
-              type: "RUN_ERROR",
-              runId: aguiState.runId,
+        }
+        if (chunk.type === "response.failed" || chunk.type === "response.incomplete") {
+          if (hasEmittedTextMessageStart) {
+            yield asChunk({
+              type: "TEXT_MESSAGE_END",
+              messageId: aguiState.messageId,
               model: chunk.response.model,
-              timestamp,
-              error: {
-                message: chunk.response.incomplete_details.reason ?? ""
-              }
-            };
+              timestamp
+            });
+            hasEmittedTextMessageStart = false;
           }
+          const errorMessage = chunk.response.error?.message || chunk.response.incomplete_details?.reason || (chunk.type === "response.failed" ? "Response failed" : "Response ended incomplete");
+          const errorCode = chunk.response.error?.code || (chunk.response.incomplete_details ? "incomplete" : void 0);
+          yield asChunk({
+            type: "RUN_ERROR",
+            runId: aguiState.runId,
+            model: chunk.response.model,
+            timestamp,
+            error: {
+              message: errorMessage,
+              ...errorCode !== void 0 && { code: errorCode }
+            }
+          });
+          runFinishedEmitted = true;
+          return;
         }
         if (chunk.type === "response.output_text.delta" && chunk.delta) {
           const textDelta = Array.isArray(chunk.delta) ? chunk.delta.join("") : typeof chunk.delta === "string" ? chunk.delta : "";
           if (textDelta) {
             if (!hasEmittedTextMessageStart) {
               hasEmittedTextMessageStart = true;
-              yield {
+              yield asChunk({
                 type: "TEXT_MESSAGE_START",
                 messageId: aguiState.messageId,
                 model: model || options.model,
                 timestamp,
                 role: "assistant"
-              };
+              });
             }
             accumulatedContent += textDelta;
             hasStreamedContentDeltas = true;
-            yield {
+            yield asChunk({
               type: "TEXT_MESSAGE_CONTENT",
               messageId: aguiState.messageId,
               model: model || options.model,
               timestamp,
               delta: textDelta,
               content: accumulatedContent
-            };
+            });
           }
         }
         if (chunk.type === "response.reasoning_text.delta" && chunk.delta) {
@@ -285,24 +318,24 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
             if (!hasEmittedStepStarted) {
               hasEmittedStepStarted = true;
               stepId = generateId(this.name);
-              yield {
+              yield asChunk({
                 type: "STEP_STARTED",
                 stepId,
                 model: model || options.model,
                 timestamp,
                 stepType: "thinking"
-              };
+              });
             }
             accumulatedReasoning += reasoningDelta;
             hasStreamedReasoningDeltas = true;
-            yield {
+            yield asChunk({
               type: "STEP_FINISHED",
               stepId: stepId || generateId(this.name),
               model: model || options.model,
               timestamp,
               delta: reasoningDelta,
               content: accumulatedReasoning
-            };
+            });
           }
         }
         if (chunk.type === "response.reasoning_summary_text.delta" && chunk.delta) {
@@ -311,50 +344,60 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
             if (!hasEmittedStepStarted) {
               hasEmittedStepStarted = true;
               stepId = generateId(this.name);
-              yield {
+              yield asChunk({
                 type: "STEP_STARTED",
                 stepId,
                 model: model || options.model,
                 timestamp,
                 stepType: "thinking"
-              };
+              });
             }
             accumulatedReasoning += summaryDelta;
             hasStreamedReasoningDeltas = true;
-            yield {
+            yield asChunk({
               type: "STEP_FINISHED",
               stepId: stepId || generateId(this.name),
               model: model || options.model,
               timestamp,
               delta: summaryDelta,
               content: accumulatedReasoning
-            };
+            });
           }
         }
         if (chunk.type === "response.content_part.added") {
           const contentPart = chunk.part;
           if (contentPart.type === "output_text" && !hasEmittedTextMessageStart) {
             hasEmittedTextMessageStart = true;
-            yield {
+            yield asChunk({
               type: "TEXT_MESSAGE_START",
               messageId: aguiState.messageId,
               model: model || options.model,
               timestamp,
               role: "assistant"
-            };
+            });
           }
           if (contentPart.type === "reasoning_text" && !hasEmittedStepStarted) {
             hasEmittedStepStarted = true;
             stepId = generateId(this.name);
-            yield {
+            yield asChunk({
               type: "STEP_STARTED",
               stepId,
               model: model || options.model,
               timestamp,
               stepType: "thinking"
-            };
+            });
+          }
+          if (contentPart.type === "output_text") {
+            hasStreamedContentDeltas = true;
+          } else if (contentPart.type === "reasoning_text") {
+            hasStreamedReasoningDeltas = true;
+          }
+          const partChunk = handleContentPart(contentPart);
+          yield partChunk;
+          if (partChunk.type === "RUN_ERROR") {
+            runFinishedEmitted = true;
+            return;
           }
-          yield handleContentPart(contentPart);
         }
         if (chunk.type === "response.content_part.done") {
           const contentPart = chunk.part;
@@ -364,76 +407,121 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
           if (contentPart.type === "reasoning_text" && hasStreamedReasoningDeltas) {
             continue;
           }
-          yield handleContentPart(contentPart);
+          const doneChunk = handleContentPart(contentPart);
+          yield doneChunk;
+          if (doneChunk.type === "RUN_ERROR") {
+            runFinishedEmitted = true;
+            return;
+          }
         }
         if (chunk.type === "response.output_item.added") {
           const item = chunk.item;
-          if (item.type === "function_call") {
-            const itemId = item.id || item.call_id;
-            const callId = item.call_id || item.id || "";
-            if (!toolCallMetadata.has(itemId)) {
-              toolCallMetadata.set(itemId, {
-                index: chunk.output_index,
-                name: item.name || "",
-                callId,
-                started: false
+          if (item.type === "function_call" && item.id) {
+            const existing = toolCallMetadata.get(item.id);
+            if (!existing?.started) {
+              if (!existing) {
+                toolCallMetadata.set(item.id, {
+                  index: chunk.output_index,
+                  name: item.name || "",
+                  started: false
+                });
+              }
+              yield asChunk({
+                type: "TOOL_CALL_START",
+                toolCallId: item.id,
+                toolCallName: item.name || "",
+                toolName: item.name || "",
+                model: model || options.model,
+                timestamp,
+                index: chunk.output_index
               });
+              toolCallMetadata.get(item.id).started = true;
             }
-            yield {
-              type: "TOOL_CALL_START",
-              toolCallId: callId,
-              toolName: item.name || "",
-              model: model || options.model,
-              timestamp,
-              index: chunk.output_index
-            };
-            toolCallMetadata.get(itemId).started = true;
           }
         }
         if (chunk.type === "response.function_call_arguments.delta" && chunk.delta) {
           const metadata = toolCallMetadata.get(chunk.item_id);
-          yield {
+          if (!metadata?.started) {
+            options.logger.errors(
+              `${this.name}.processStreamChunks orphan function_call_arguments.delta`,
+              {
+                source: `${this.name}.processStreamChunks`,
+                toolCallId: chunk.item_id,
+                rawDelta: chunk.delta
+              }
+            );
+            continue;
+          }
+          yield asChunk({
             type: "TOOL_CALL_ARGS",
-            toolCallId: metadata?.callId || chunk.item_id,
+            toolCallId: chunk.item_id,
             model: model || options.model,
             timestamp,
-            delta: chunk.delta,
-            args: metadata ? void 0 : chunk.delta
-          };
+            delta: chunk.delta
+          });
         }
         if (chunk.type === "response.function_call_arguments.done") {
           const { item_id } = chunk;
           const metadata = toolCallMetadata.get(item_id);
-          const name = metadata?.name || "";
-          const callId = metadata?.callId || item_id;
+          if (!metadata?.started) {
+            options.logger.errors(
+              `${this.name}.processStreamChunks orphan function_call_arguments.done`,
+              {
+                source: `${this.name}.processStreamChunks`,
+                toolCallId: item_id,
+                rawArguments: chunk.arguments
+              }
+            );
+            continue;
+          }
+          const name = metadata.name || "";
           let parsedInput = {};
-          try {
-            parsedInput = chunk.arguments ? JSON.parse(chunk.arguments) : {};
-          } catch {
-            parsedInput = {};
+          if (chunk.arguments) {
+            try {
+              const parsed = JSON.parse(chunk.arguments);
+              parsedInput = parsed && typeof parsed === "object" ? parsed : {};
+            } catch (parseError) {
+              options.logger.errors(
+                `${this.name}.processStreamChunks tool-args JSON parse failed`,
+                {
+                  error: toRunErrorPayload(
+                    parseError,
+                    `tool ${name} (${item_id}) returned malformed JSON arguments`
+                  ),
+                  source: `${this.name}.processStreamChunks`,
+                  toolCallId: item_id,
+                  toolName: name,
+                  rawArguments: chunk.arguments
+                }
+              );
+              parsedInput = {};
+            }
           }
-          yield {
+          yield asChunk({
             type: "TOOL_CALL_END",
-            toolCallId: callId,
+            toolCallId: item_id,
+            toolCallName: name,
             toolName: name,
             model: model || options.model,
             timestamp,
             input: parsedInput
-          };
+          });
         }
         if (chunk.type === "response.completed") {
           if (hasEmittedTextMessageStart) {
-            yield {
+            yield asChunk({
               type: "TEXT_MESSAGE_END",
               messageId: aguiState.messageId,
               model: model || options.model,
               timestamp
-            };
+            });
+            hasEmittedTextMessageStart = false;
           }
           const hasFunctionCalls = chunk.response.output.some(
             (item) => item.type === "function_call"
           );
-          yield {
+          const finishReason = hasFunctionCalls ? "tool_calls" : chunk.response.incomplete_details?.reason ?? "stop";
+          yield asChunk({
             type: "RUN_FINISHED",
             runId: aguiState.runId,
             model: model || options.model,
@@ -443,11 +531,12 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
               completionTokens: chunk.response.usage?.output_tokens || 0,
               totalTokens: chunk.response.usage?.total_tokens || 0
             },
-            finishReason: hasFunctionCalls ? "tool_calls" : "stop"
-          };
+            finishReason
+          });
+          runFinishedEmitted = true;
         }
         if (chunk.type === "error") {
-          yield {
+          yield asChunk({
             type: "RUN_ERROR",
             runId: aguiState.runId,
             model: model || options.model,
@@ -456,22 +545,44 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
               message: chunk.message,
               code: chunk.code ?? void 0
             }
-          };
+          });
+          runFinishedEmitted = true;
+        }
+      }
+      if (!runFinishedEmitted && aguiState.hasEmittedRunStarted) {
+        if (hasEmittedTextMessageStart) {
+          yield asChunk({
+            type: "TEXT_MESSAGE_END",
+            messageId: aguiState.messageId,
+            model: model || options.model,
+            timestamp
+          });
         }
+        yield asChunk({
+          type: "RUN_FINISHED",
+          runId: aguiState.runId,
+          model: model || options.model,
+          timestamp,
+          usage: void 0,
+          finishReason: toolCallMetadata.size > 0 ? "tool_calls" : "stop"
+        });
       }
     } catch (error) {
-      const err = error;
-      console.error(`[${this.name}] Stream ended with error:`, err.message);
-      yield {
+      const errorPayload = toRunErrorPayload(
+        error,
+        `${this.name}.processStreamChunks failed`
+      );
+      options.logger.errors(`${this.name}.processStreamChunks fatal`, {
+        error: errorPayload,
+        source: `${this.name}.processStreamChunks`
+      });
+      yield asChunk({
         type: "RUN_ERROR",
         runId: aguiState.runId,
         model: options.model,
         timestamp,
-        error: {
-          message: err.message || "Unknown error occurred",
-          code: err.code
-        }
-      };
+        error: errorPayload
+      });
     }
   }
   /**
@@ -486,15 +597,23 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
     ) : void 0;
     const modelOptions = options.modelOptions;
     return {
-      model: options.model,
-      temperature: options.temperature,
-      max_output_tokens: options.maxTokens,
-      top_p: options.topP,
-      metadata: options.metadata,
-      instructions: options.systemPrompts?.join("\n"),
       ...modelOptions,
+      model: options.model,
+      ...options.temperature !== void 0 && {
+        temperature: options.temperature
+      },
+      ...options.maxTokens !== void 0 && {
+        max_output_tokens: options.maxTokens
+      },
+      ...options.topP !== void 0 && { top_p: options.topP },
+      ...options.metadata !== void 0 && { metadata: options.metadata },
+      ...options.systemPrompts && options.systemPrompts.length > 0 && {
+        instructions: options.systemPrompts.join("\n")
+      },
       input,
-      tools
+      // Conditional spread: `tools: undefined` would clobber any
+      // modelOptions.tools the caller set above.
+      ...tools && tools.length > 0 && { tools }
     };
   }
   /**
@@ -548,7 +667,9 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
         inputContent.push(this.convertContentPartToInput(part));
       }
       if (inputContent.length === 0) {
-        inputContent.push({ type: "input_text", text: "" });
+        throw new Error(
+          `User message for ${this.name} has no content parts. Empty user messages would produce a paid request with no input; provide at least one text/image/audio part or omit the message.`
+        );
       }
       result.push({
         type: "message",
@@ -580,7 +701,8 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
           };
         }
         const imageValue = part.source.value;
-        const imageUrl = imageValue.startsWith("data:") ? imageValue : `data:${part.source.mimeType};base64,${imageValue}`;
+        const imageMime = part.source.mimeType || "application/octet-stream";
+        const imageUrl = imageValue.startsWith("data:") ? imageValue : `data:${imageMime};base64,${imageValue}`;
         return {
           type: "input_image",
           image_url: imageUrl,
@@ -594,9 +716,12 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
             file_url: part.source.value
           };
         }
+        const audioValue = part.source.value;
+        const audioMime = part.source.mimeType || "application/octet-stream";
+        const audioFileData = audioValue.startsWith("data:") ? audioValue : `data:${audioMime};base64,${audioValue}`;
         return {
           type: "input_file",
-          file_data: part.source.value
+          file_data: audioFileData
         };
       }
       default: