@tanstack/openai-base 0.9.3 → 0.9.5

package/dist/esm/adapters/chat-completions-text.js

@@ -0,0 +1,967 @@
+import { EventType, normalizeSystemPrompts } from "@tanstack/ai";
+import { BaseTextAdapter } from "@tanstack/ai/adapters";
+import { toRunErrorPayload, toRunErrorRawEvent } from "@tanstack/ai/adapter-internals";
+import { generateId } from "@tanstack/ai-utils";
+import { extractRequestOptions } from "../utils/request-options.js";
+import { makeStructuredOutputCompatible } from "../utils/schema-converter.js";
+import { buildChatCompletionsUsage } from "../usage.js";
+import { convertToolsToChatCompletionsFormat } from "./chat-completions-tool-converter.js";
+class OpenAIBaseChatCompletionsTextAdapter extends BaseTextAdapter {
+  kind = "text";
+  name;
+  client;
+  constructor(model, name, client) {
+    super({}, model);
+    this.name = name;
+    this.client = client;
+  }
+  async *chatStream(options) {
+    const aguiState = {
+      runId: generateId(this.name),
+      threadId: options.threadId ?? generateId(this.name),
+      messageId: generateId(this.name),
+      hasEmittedRunStarted: false
+    };
+    try {
+      const requestParams = this.mapOptionsToRequest(options);
+      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 stream = await this.client.chat.completions.create(
+        {
+          ...requestParams,
+          stream: true,
+          stream_options: { include_usage: true }
+        },
+        extractRequestOptions(options.request)
+      );
+      yield* this.processStreamChunks(stream, options, aguiState);
+    } catch (error) {
+      const errorPayload = toRunErrorPayload(
+        error,
+        `${this.name}.chatStream failed`
+      );
+      const rawEvent = toRunErrorRawEvent(error);
+      if (!aguiState.hasEmittedRunStarted) {
+        aguiState.hasEmittedRunStarted = true;
+        yield {
+          type: EventType.RUN_STARTED,
+          runId: aguiState.runId,
+          threadId: aguiState.threadId,
+          model: options.model,
+          timestamp: Date.now(),
+          parentRunId: options.parentRunId
+        };
+      }
+      yield {
+        type: EventType.RUN_ERROR,
+        model: options.model,
+        timestamp: Date.now(),
+        message: errorPayload.message,
+        code: errorPayload.code,
+        // Forward the provider's structured error body so consumers can recover
+        // the upstream detail the `{ message, code }` payload drops. Omitted
+        // when the error carried no provider body (see toRunErrorRawEvent).
+        ...rawEvent !== void 0 && { rawEvent },
+        error: {
+          message: errorPayload.message,
+          code: errorPayload.code
+        }
+      };
+      options.logger.errors(`${this.name}.chatStream fatal`, {
+        error: errorPayload,
+        source: `${this.name}.chatStream`
+      });
+    }
+  }
+  /**
+   * Generate structured output using the provider's JSON Schema response format.
+   * Uses stream: false to get the complete response in one call.
+   *
+   * OpenAI-compatible APIs have strict requirements for structured output:
+   * - All properties must be in the `required` array
+   * - Optional fields should have null added to their type union
+   * - additionalProperties must be false for all objects
+   *
+   * The outputSchema is already JSON Schema (converted in the ai layer).
+   * We apply provider-specific transformations for structured output compatibility.
+   */
+  async structuredOutput(options) {
+    const { chatOptions, outputSchema } = options;
+    const requestParams = this.mapOptionsToRequest(chatOptions);
+    const jsonSchema = this.makeStructuredOutputCompatible(
+      outputSchema,
+      outputSchema.required
+    );
+    try {
+      const {
+        stream_options: _,
+        stream: __,
+        ...cleanParams
+      } = requestParams;
+      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.chat.completions.create(
+        {
+          ...cleanParams,
+          stream: false,
+          response_format: {
+            type: "json_schema",
+            json_schema: {
+              name: "structured_output",
+              schema: jsonSchema,
+              strict: true
+            }
+          }
+        },
+        extractRequestOptions(chatOptions.request)
+      );
+      const rawText = response.choices[0]?.message.content;
+      if (typeof rawText !== "string" || rawText.length === 0) {
+        throw new Error(
+          `${this.name}.structuredOutput: response contained no content`
+        );
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(rawText);
+      } catch {
+        throw new Error(
+          `Failed to parse structured output as JSON. Content: ${rawText.slice(0, 200)}${rawText.length > 200 ? "..." : ""}`
+        );
+      }
+      const transformed = this.transformStructuredOutput(parsed);
+      return {
+        data: transformed,
+        rawText
+      };
+    } catch (error) {
+      chatOptions.logger.errors(`${this.name}.structuredOutput fatal`, {
+        error: toRunErrorPayload(error, `${this.name}.structuredOutput failed`),
+        source: `${this.name}.structuredOutput`
+      });
+      throw error;
+    }
+  }
+  /**
+   * Stream structured output. Single Chat Completions request with
+   * `response_format: json_schema` + `stream: true`. Emits the standard
+   * AG-UI lifecycle (`RUN_STARTED` → `REASONING_*?` → `TEXT_MESSAGE_*`
+   * carrying raw JSON deltas → terminal `CUSTOM 'structured-output.complete'`
+   * → `RUN_FINISHED`). Subclasses use the same SDK-call / reasoning /
+   * structured-output-transform hooks as `chatStream` / `structuredOutput` —
+   * no per-subclass override should be needed.
+   */
+  async *structuredOutputStream(options) {
+    const { chatOptions, outputSchema } = options;
+    const requestParams = this.mapOptionsToRequest(chatOptions);
+    const jsonSchema = this.makeStructuredOutputCompatible(
+      outputSchema,
+      outputSchema.required
+    );
+    const timestamp = Date.now();
+    const aguiState = {
+      runId: generateId(this.name),
+      threadId: chatOptions.threadId ?? generateId(this.name),
+      messageId: generateId(this.name),
+      timestamp,
+      hasEmittedRunStarted: false
+    };
+    let accumulatedContent = "";
+    let accumulatedReasoning = "";
+    let hasEmittedTextMessageStart = false;
+    let reasoningMessageId;
+    let hasClosedReasoning = false;
+    let stepId;
+    let lastModel;
+    let lastUsage;
+    const closeReasoningLifecycle = (function* () {
+      if (reasoningMessageId && !hasClosedReasoning) {
+        hasClosedReasoning = true;
+        yield {
+          type: EventType.REASONING_MESSAGE_END,
+          messageId: reasoningMessageId,
+          model: lastModel || chatOptions.model,
+          timestamp
+        };
+        yield {
+          type: EventType.REASONING_END,
+          messageId: reasoningMessageId,
+          model: lastModel || chatOptions.model,
+          timestamp
+        };
+        if (stepId) {
+          yield {
+            type: EventType.STEP_FINISHED,
+            stepName: stepId,
+            stepId,
+            model: lastModel || chatOptions.model,
+            timestamp,
+            content: accumulatedReasoning
+          };
+        }
+      }
+    }).bind(this);
+    try {
+      const {
+        stream_options: _so,
+        stream: _s,
+        tools: _t,
+        ...cleanParams
+      } = requestParams;
+      chatOptions.logger.request(
+        `activity=structuredOutputStream provider=${this.name} model=${this.model} messages=${chatOptions.messages.length}`,
+        { provider: this.name, model: this.model }
+      );
+      const stream = await this.client.chat.completions.create(
+        {
+          ...cleanParams,
+          stream: true,
+          stream_options: { include_usage: true },
+          response_format: {
+            type: "json_schema",
+            json_schema: {
+              name: "structured_output",
+              schema: jsonSchema,
+              strict: true
+            }
+          }
+        },
+        extractRequestOptions(chatOptions.request)
+      );
+      for await (const chunk of stream) {
+        const choiceForLog = chunk.choices[0];
+        chatOptions.logger.provider(
+          `provider=${this.name} finish_reason=${choiceForLog?.finish_reason ?? "none"} hasContent=${!!choiceForLog?.delta.content} hasUsage=${!!chunk.usage}`,
+          { provider: this.name, model: chunk.model }
+        );
+        if (chunk.model) lastModel = chunk.model;
+        const usage = chunk.usage ?? chunk.x_groq?.usage;
+        if (usage) lastUsage = usage;
+        if (!aguiState.hasEmittedRunStarted) {
+          aguiState.hasEmittedRunStarted = true;
+          yield {
+            type: EventType.RUN_STARTED,
+            runId: aguiState.runId,
+            threadId: aguiState.threadId,
+            model: chunk.model || chatOptions.model,
+            timestamp,
+            parentRunId: chatOptions.parentRunId
+          };
+        }
+        const reasoning = this.extractReasoning(chunk);
+        if (reasoning && reasoning.text) {
+          if (!reasoningMessageId) {
+            reasoningMessageId = generateId(this.name);
+            stepId = generateId(this.name);
+            yield {
+              type: EventType.REASONING_START,
+              messageId: reasoningMessageId,
+              model: chunk.model || chatOptions.model,
+              timestamp
+            };
+            yield {
+              type: EventType.REASONING_MESSAGE_START,
+              messageId: reasoningMessageId,
+              role: "reasoning",
+              model: chunk.model || chatOptions.model,
+              timestamp
+            };
+            yield {
+              type: EventType.STEP_STARTED,
+              stepName: stepId,
+              stepId,
+              model: chunk.model || chatOptions.model,
+              timestamp,
+              stepType: "thinking"
+            };
+          }
+          accumulatedReasoning += reasoning.text;
+          yield {
+            type: EventType.REASONING_MESSAGE_CONTENT,
+            messageId: reasoningMessageId,
+            delta: reasoning.text,
+            model: chunk.model || chatOptions.model,
+            timestamp
+          };
+        }
+        const choice = chunk.choices[0];
+        if (!choice) continue;
+        const deltaContent = choice.delta.content;
+        if (deltaContent) {
+          yield* closeReasoningLifecycle();
+          if (!hasEmittedTextMessageStart) {
+            hasEmittedTextMessageStart = true;
+            yield {
+              type: EventType.TEXT_MESSAGE_START,
+              messageId: aguiState.messageId,
+              model: chunk.model || chatOptions.model,
+              timestamp,
+              role: "assistant"
+            };
+          }
+          accumulatedContent += deltaContent;
+          yield {
+            type: EventType.TEXT_MESSAGE_CONTENT,
+            messageId: aguiState.messageId,
+            model: chunk.model || chatOptions.model,
+            timestamp,
+            delta: deltaContent,
+            content: accumulatedContent
+          };
+        }
+      }
+      yield* closeReasoningLifecycle();
+      if (hasEmittedTextMessageStart) {
+        yield {
+          type: EventType.TEXT_MESSAGE_END,
+          messageId: aguiState.messageId,
+          model: lastModel || chatOptions.model,
+          timestamp
+        };
+      }
+      if (accumulatedContent.length === 0) {
+        yield {
+          type: EventType.RUN_ERROR,
+          runId: aguiState.runId,
+          model: lastModel || chatOptions.model,
+          timestamp,
+          message: `${this.name}.structuredOutputStream: response contained no content`,
+          code: "empty-response",
+          error: {
+            message: `${this.name}.structuredOutputStream: response contained no content`,
+            code: "empty-response"
+          }
+        };
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(accumulatedContent);
+      } catch {
+        yield {
+          type: EventType.RUN_ERROR,
+          runId: aguiState.runId,
+          model: lastModel || chatOptions.model,
+          timestamp,
+          message: `Failed to parse structured output as JSON. Content: ${accumulatedContent.slice(0, 200)}${accumulatedContent.length > 200 ? "..." : ""}`,
+          code: "parse-error",
+          error: {
+            message: "Failed to parse structured output as JSON",
+            code: "parse-error"
+          }
+        };
+        return;
+      }
+      const transformed = this.transformStructuredOutput(parsed);
+      yield {
+        type: EventType.CUSTOM,
+        name: "structured-output.complete",
+        value: {
+          object: transformed,
+          raw: accumulatedContent,
+          ...accumulatedReasoning ? { reasoning: accumulatedReasoning } : {}
+        },
+        model: lastModel || chatOptions.model,
+        timestamp
+      };
+      yield {
+        type: EventType.RUN_FINISHED,
+        runId: aguiState.runId,
+        threadId: aguiState.threadId,
+        model: lastModel || chatOptions.model,
+        timestamp,
+        finishReason: "stop",
+        ...lastUsage && {
+          usage: buildChatCompletionsUsage(lastUsage)
+        }
+      };
+    } catch (error) {
+      if (!aguiState.hasEmittedRunStarted) {
+        aguiState.hasEmittedRunStarted = true;
+        yield {
+          type: EventType.RUN_STARTED,
+          runId: aguiState.runId,
+          threadId: aguiState.threadId,
+          model: chatOptions.model,
+          timestamp,
+          parentRunId: chatOptions.parentRunId
+        };
+      }
+      const isAbort = this.isAbortError(error);
+      const errorPayload = toRunErrorPayload(
+        error,
+        `${this.name}.structuredOutputStream failed`
+      );
+      const resolvedCode = isAbort ? "aborted" : errorPayload.code;
+      const rawEvent = isAbort ? void 0 : toRunErrorRawEvent(error);
+      yield {
+        type: EventType.RUN_ERROR,
+        runId: aguiState.runId,
+        model: lastModel || chatOptions.model,
+        timestamp,
+        message: errorPayload.message,
+        ...resolvedCode !== void 0 && { code: resolvedCode },
+        ...rawEvent !== void 0 && { rawEvent },
+        error: {
+          message: errorPayload.message,
+          ...resolvedCode !== void 0 && { code: resolvedCode }
+        }
+      };
+      chatOptions.logger.errors(`${this.name}.structuredOutputStream fatal`, {
+        error: errorPayload,
+        source: `${this.name}.structuredOutputStream`
+      });
+    }
+  }
+  /**
+   * Cross-SDK abort detection for `structuredOutputStream`. Default duck-types
+   * on `name === 'APIUserAbortError'` (OpenAI SDK), `code === 'ERR_CANCELED'`,
+   * and standard `AbortError`s. Subclasses with proprietary error types (e.g.
+   * `@openrouter/sdk`'s `RequestAbortedError`) override to extend the check.
+   */
+  isAbortError(error) {
+    if (!error || typeof error !== "object") return false;
+    const e = error;
+    return e.name === "APIUserAbortError" || e.name === "AbortError" || e.code === "ERR_CANCELED";
+  }
+  /**
+   * Applies provider-specific transformations for structured output compatibility.
+   * Override this in subclasses to handle provider-specific quirks.
+   */
+  makeStructuredOutputCompatible(schema, originalRequired) {
+    return makeStructuredOutputCompatible(schema, originalRequired);
+  }
+  /**
+   * Extract reasoning content from a stream chunk. Default returns
+   * `undefined` because the OpenAI Chat Completions chunk shape doesn't
+   * carry reasoning. The chunk param is typed `unknown` so an override can
+   * narrow to its own SDK chunk type without an `as` dance — the base only
+   * passes through `processStreamChunks`'s structurally-iterated chunk.
+   */
+  extractReasoning(_chunk) {
+    return void 0;
+  }
+  /**
+   * Final shaping pass applied to parsed structured-output JSON before it is
+   * returned to the caller. Default is a passthrough.
+   *
+   * Provider `null`s are no longer stripped here: strict-mode null-widening is
+   * now undone precisely by the engine (`undoNullWidening`, driven by the
+   * schema's null-widening map) the moment the result is captured, so a blind
+   * `transformNullsToUndefined` at the adapter would only destroy genuine
+   * `.nullable()` nulls. Subclasses may still override to remap or reshape the
+   * provider's structured output.
+   */
+  transformStructuredOutput(parsed) {
+    return parsed;
+  }
+  /**
+   * Processes streamed chunks from the Chat Completions API and yields AG-UI events.
+   * Override this in subclasses to handle provider-specific stream behavior.
+   */
+  async *processStreamChunks(stream, options, aguiState) {
+    let accumulatedContent = "";
+    let hasEmittedTextMessageStart = false;
+    let lastModel;
+    let lastUsage;
+    let pendingFinishReason;
+    const toolCallsInProgress = /* @__PURE__ */ new Map();
+    let reasoningMessageId;
+    let hasClosedReasoning = false;
+    let stepId;
+    let accumulatedReasoning = "";
+    let emittedAnyToolCallEnd = false;
+    try {
+      for await (const chunk of stream) {
+        const choiceForLog = chunk.choices[0];
+        options.logger.provider(
+          `provider=${this.name} finish_reason=${choiceForLog?.finish_reason ?? "none"} hasContent=${!!choiceForLog?.delta.content} hasToolCalls=${!!choiceForLog?.delta.tool_calls} hasUsage=${!!chunk.usage}`,
+          { provider: this.name, model: chunk.model }
+        );
+        if (chunk.usage) {
+          lastUsage = chunk.usage;
+        }
+        if (chunk.model) {
+          lastModel = chunk.model;
+        }
+        if (!aguiState.hasEmittedRunStarted) {
+          aguiState.hasEmittedRunStarted = true;
+          yield {
+            type: EventType.RUN_STARTED,
+            runId: aguiState.runId,
+            threadId: aguiState.threadId,
+            model: chunk.model || options.model,
+            timestamp: Date.now(),
+            parentRunId: options.parentRunId
+          };
+        }
+        const reasoning = this.extractReasoning(chunk);
+        if (reasoning && reasoning.text) {
+          if (!reasoningMessageId) {
+            reasoningMessageId = generateId(this.name);
+            stepId = generateId(this.name);
+            yield {
+              type: EventType.REASONING_START,
+              messageId: reasoningMessageId,
+              model: chunk.model || options.model,
+              timestamp: Date.now()
+            };
+            yield {
+              type: EventType.REASONING_MESSAGE_START,
+              messageId: reasoningMessageId,
+              role: "reasoning",
+              model: chunk.model || options.model,
+              timestamp: Date.now()
+            };
+            yield {
+              type: EventType.STEP_STARTED,
+              stepName: stepId,
+              stepId,
+              model: chunk.model || options.model,
+              timestamp: Date.now(),
+              stepType: "thinking"
+            };
+          }
+          accumulatedReasoning += reasoning.text;
+          yield {
+            type: EventType.REASONING_MESSAGE_CONTENT,
+            messageId: reasoningMessageId,
+            delta: reasoning.text,
+            model: chunk.model || options.model,
+            timestamp: Date.now()
+          };
+        }
+        const choice = chunk.choices[0];
+        if (!choice) continue;
+        const delta = choice.delta;
+        const deltaContent = delta.content;
+        const deltaToolCalls = delta.tool_calls;
+        if (deltaContent) {
+          if (reasoningMessageId && !hasClosedReasoning) {
+            hasClosedReasoning = true;
+            yield {
+              type: EventType.REASONING_MESSAGE_END,
+              messageId: reasoningMessageId,
+              model: chunk.model || options.model,
+              timestamp: Date.now()
+            };
+            yield {
+              type: EventType.REASONING_END,
+              messageId: reasoningMessageId,
+              model: chunk.model || options.model,
+              timestamp: Date.now()
+            };
+            if (stepId) {
+              yield {
+                type: EventType.STEP_FINISHED,
+                stepName: stepId,
+                stepId,
+                model: chunk.model || options.model,
+                timestamp: Date.now(),
+                content: accumulatedReasoning
+              };
+            }
+          }
+          if (!hasEmittedTextMessageStart) {
+            hasEmittedTextMessageStart = true;
+            yield {
+              type: EventType.TEXT_MESSAGE_START,
+              messageId: aguiState.messageId,
+              model: chunk.model || options.model,
+              timestamp: Date.now(),
+              role: "assistant"
+            };
+          }
+          accumulatedContent += deltaContent;
+          yield {
+            type: EventType.TEXT_MESSAGE_CONTENT,
+            messageId: aguiState.messageId,
+            model: chunk.model || options.model,
+            timestamp: Date.now(),
+            delta: deltaContent,
+            content: accumulatedContent
+          };
+        }
+        if (deltaToolCalls) {
+          for (const toolCallDelta of deltaToolCalls) {
+            const index = toolCallDelta.index;
+            let toolCall = toolCallsInProgress.get(index);
+            if (!toolCall) {
+              toolCall = {
+                id: toolCallDelta.id || "",
+                name: toolCallDelta.function?.name || "",
+                arguments: "",
+                started: false
+              };
+              toolCallsInProgress.set(index, toolCall);
+            }
+            if (toolCallDelta.id) {
+              toolCall.id = toolCallDelta.id;
+            }
+            if (toolCallDelta.function?.name) {
+              toolCall.name = toolCallDelta.function.name;
+            }
+            if (toolCallDelta.function?.arguments) {
+              toolCall.arguments += toolCallDelta.function.arguments;
+            }
+            if (toolCall.id && toolCall.name && !toolCall.started) {
+              toolCall.started = true;
+              yield {
+                type: EventType.TOOL_CALL_START,
+                toolCallId: toolCall.id,
+                toolCallName: toolCall.name,
+                toolName: toolCall.name,
+                parentMessageId: aguiState.messageId,
+                model: chunk.model || options.model,
+                timestamp: Date.now(),
+                index
+              };
+            }
+            if (toolCallDelta.function?.arguments && toolCall.started) {
+              yield {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: toolCall.id,
+                model: chunk.model || options.model,
+                timestamp: Date.now(),
+                delta: toolCallDelta.function.arguments
+              };
+            }
+          }
+        }
+        if (choice.finish_reason) {
+          if (choice.finish_reason === "tool_calls" || toolCallsInProgress.size > 0) {
+            for (const [, toolCall] of toolCallsInProgress) {
+              if (!toolCall.started) continue;
+              let parsedInput = {};
+              if (toolCall.arguments) {
+                try {
+                  const parsed = JSON.parse(toolCall.arguments);
+                  parsedInput = parsed && typeof parsed === "object" ? parsed : {};
+                } catch (parseError) {
+                  options.logger.errors(
+                    `${this.name}.processStreamChunks tool-args JSON parse failed`,
+                    {
+                      error: toRunErrorPayload(
+                        parseError,
+                        `tool ${toolCall.name} (${toolCall.id}) returned malformed JSON arguments`
+                      ),
+                      source: `${this.name}.processStreamChunks`,
+                      toolCallId: toolCall.id,
+                      toolName: toolCall.name,
+                      rawArguments: toolCall.arguments
+                    }
+                  );
+                  parsedInput = {};
+                }
+              }
+              yield {
+                type: EventType.TOOL_CALL_END,
+                toolCallId: toolCall.id,
+                toolCallName: toolCall.name,
+                toolName: toolCall.name,
+                model: chunk.model || options.model,
+                timestamp: Date.now(),
+                input: parsedInput
+              };
+              emittedAnyToolCallEnd = true;
+            }
+            toolCallsInProgress.clear();
+          }
+          if (hasEmittedTextMessageStart) {
+            yield {
+              type: EventType.TEXT_MESSAGE_END,
+              messageId: aguiState.messageId,
+              model: chunk.model || options.model,
+              timestamp: Date.now()
+            };
+            hasEmittedTextMessageStart = false;
+          }
+          pendingFinishReason = choice.finish_reason;
+        }
+      }
+      if (aguiState.hasEmittedRunStarted) {
+        let pendingToolCount = 0;
+        for (const [, toolCall] of toolCallsInProgress) {
+          if (!toolCall.started) continue;
+          let parsedInput = {};
+          if (toolCall.arguments) {
+            try {
+              const parsed = JSON.parse(toolCall.arguments);
+              parsedInput = parsed && typeof parsed === "object" ? parsed : {};
+            } catch (parseError) {
+              options.logger.errors(
+                `${this.name}.processStreamChunks tool-args JSON parse failed (drain)`,
+                {
+                  error: toRunErrorPayload(
+                    parseError,
+                    `tool ${toolCall.name} (${toolCall.id}) returned malformed JSON arguments`
+                  ),
+                  source: `${this.name}.processStreamChunks`,
+                  toolCallId: toolCall.id,
+                  toolName: toolCall.name,
+                  rawArguments: toolCall.arguments
+                }
+              );
+              parsedInput = {};
+            }
+          }
+          yield {
+            type: EventType.TOOL_CALL_END,
+            toolCallId: toolCall.id,
+            toolCallName: toolCall.name,
+            toolName: toolCall.name,
+            model: lastModel || options.model,
+            timestamp: Date.now(),
+            input: parsedInput
+          };
+          pendingToolCount += 1;
+          emittedAnyToolCallEnd = true;
+        }
+        toolCallsInProgress.clear();
+        if (hasEmittedTextMessageStart) {
+          yield {
+            type: EventType.TEXT_MESSAGE_END,
+            messageId: aguiState.messageId,
+            model: lastModel || options.model,
+            timestamp: Date.now()
+          };
+        }
+        if (reasoningMessageId && !hasClosedReasoning) {
+          hasClosedReasoning = true;
+          yield {
+            type: EventType.REASONING_MESSAGE_END,
+            messageId: reasoningMessageId,
+            model: lastModel || options.model,
+            timestamp: Date.now()
+          };
+          yield {
+            type: EventType.REASONING_END,
+            messageId: reasoningMessageId,
+            model: lastModel || options.model,
+            timestamp: Date.now()
+          };
+          if (stepId) {
+            yield {
+              type: EventType.STEP_FINISHED,
+              stepName: stepId,
+              stepId,
+              model: lastModel || options.model,
+              timestamp: Date.now(),
+              content: accumulatedReasoning
+            };
+          }
+        }
+        const finishReason = emittedAnyToolCallEnd ? "tool_calls" : pendingFinishReason === "tool_calls" ? "stop" : pendingFinishReason === "function_call" ? "tool_calls" : pendingFinishReason ?? "stop";
+        yield {
+          type: EventType.RUN_FINISHED,
+          runId: aguiState.runId,
+          threadId: aguiState.threadId,
+          model: lastModel || options.model,
+          timestamp: Date.now(),
+          ...lastUsage && {
+            usage: buildChatCompletionsUsage(lastUsage)
+          },
+          finishReason
+        };
+      }
+    } catch (error) {
+      const errorPayload = toRunErrorPayload(
+        error,
+        `${this.name}.processStreamChunks failed`
+      );
+      const rawEvent = toRunErrorRawEvent(error);
+      options.logger.errors(`${this.name}.processStreamChunks fatal`, {
+        error: errorPayload,
+        source: `${this.name}.processStreamChunks`
+      });
+      yield {
+        type: EventType.RUN_ERROR,
+        model: options.model,
+        timestamp: Date.now(),
+        message: errorPayload.message,
+        ...errorPayload.code !== void 0 && { code: errorPayload.code },
+        ...rawEvent !== void 0 && { rawEvent },
+        error: {
+          message: errorPayload.message,
+          ...errorPayload.code !== void 0 && { code: errorPayload.code }
+        }
+      };
+    }
+  }
+  /**
+   * Maps common TextOptions to Chat Completions API request format.
+   * Override this in subclasses to add provider-specific options.
+   */
+  mapOptionsToRequest(options) {
+    const tools = options.tools ? convertToolsToChatCompletionsFormat(
+      options.tools,
+      this.makeStructuredOutputCompatible.bind(this)
+    ) : void 0;
+    const messages = [];
+    const systemPrompts = normalizeSystemPrompts(options.systemPrompts);
+    if (systemPrompts.length > 0) {
+      messages.push({
+        role: "system",
+        content: systemPrompts.map((p) => p.content).join("\n")
+      });
+    }
+    for (const message of options.messages) {
+      messages.push(this.convertMessage(message));
+    }
+    const modelOptions = options.modelOptions;
+    const combinedSchema = options.outputSchema;
+    const responseFormat = combinedSchema ? {
+      response_format: {
+        type: "json_schema",
+        json_schema: {
+          name: "structured_output",
+          schema: this.makeStructuredOutputCompatible(
+            combinedSchema,
+            Array.isArray(combinedSchema.required) ? combinedSchema.required : void 0
+          ),
+          strict: true
+        }
+      }
+    } : void 0;
+    return {
+      ...modelOptions,
+      model: options.model,
+      messages,
+      // Conditional spread: `tools: undefined` would clobber any
+      // modelOptions.tools the caller set above.
+      ...tools && tools.length > 0 && {
+        tools
+      },
+      ...responseFormat ?? {},
+      stream: true
+    };
+  }
+  /**
+   * Modern OpenAI-compatible Chat Completions APIs support `tools` and
+   * `response_format: json_schema` together in a single streaming request
+   * (per issue #605). Subclasses can override — Groq, for instance, must
+   * return `false` because its API rejects schema + tools + stream with a
+   * 400.
+   */
+  supportsCombinedToolsAndSchema() {
+    return true;
+  }
+  /**
+   * Converts a single ModelMessage to the Chat Completions API message format.
+   * Override this in subclasses to handle provider-specific message formats.
+   */
+  convertMessage(message) {
+    if (message.role === "tool") {
+      return {
+        role: "tool",
+        tool_call_id: message.toolCallId || "",
+        content: typeof message.content === "string" ? message.content : JSON.stringify(message.content)
+      };
+    }
+    if (message.role === "assistant") {
+      const toolCalls = message.toolCalls?.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.function.name,
+          arguments: typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
+        }
+      }));
+      const hasToolCalls = !!toolCalls && toolCalls.length > 0;
+      const textContent = this.extractTextContent(message.content);
+      return {
+        role: "assistant",
+        content: hasToolCalls && !textContent ? null : textContent,
+        ...hasToolCalls ? { tool_calls: toolCalls } : {}
+      };
+    }
+    const contentParts = this.normalizeContent(message.content);
+    if (contentParts.length === 1 && contentParts[0]?.type === "text") {
+      const text = contentParts[0].content;
+      if (text.length === 0) {
+        throw new Error(
+          `User message for ${this.name} has empty text content. Empty user messages would produce a paid request with no input; provide non-empty content or omit the message.`
+        );
+      }
+      return {
+        role: "user",
+        content: text
+      };
+    }
+    const parts = [];
+    for (const part of contentParts) {
+      const converted = this.convertContentPart(part);
+      if (!converted) {
+        throw new Error(
+          `Unsupported content part type for ${this.name}: ${part.type}. Override convertContentPart() in a subclass to handle this type, or remove it from the message.`
+        );
+      }
+      parts.push(converted);
+    }
+    if (parts.length === 0) {
+      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.`
+      );
+    }
+    return {
+      role: "user",
+      content: parts
+    };
+  }
+  /**
+   * Converts a single ContentPart to the Chat Completions API content part format.
+   * Override this in subclasses to handle additional content types or provider-specific metadata.
+   */
+  convertContentPart(part) {
+    if (part.type === "text") {
+      return { type: "text", text: part.content };
+    }
+    if (part.type === "image") {
+      const imageMetadata = part.metadata;
+      const imageValue = part.source.value;
+      const imageMime = part.source.mimeType || "application/octet-stream";
+      const imageUrl = part.source.type === "data" && !imageValue.startsWith("data:") ? `data:${imageMime};base64,${imageValue}` : imageValue;
+      return {
+        type: "image_url",
+        image_url: {
+          url: imageUrl,
+          detail: imageMetadata?.detail || "auto"
+        }
+      };
+    }
+    return null;
+  }
+  /**
+   * Normalizes message content to an array of ContentPart.
+   * Handles backward compatibility with string content.
+   */
+  normalizeContent(content) {
+    if (content === null) {
+      return [];
+    }
+    if (typeof content === "string") {
+      return [{ type: "text", content }];
+    }
+    return content;
+  }
+  /**
+   * Extracts text content from a content value that may be string, null, or ContentPart array.
+   */
+  extractTextContent(content) {
+    if (content === null) {
+      return "";
+    }
+    if (typeof content === "string") {
+      return content;
+    }
+    return content.filter((p) => p.type === "text").map((p) => p.content).join("");
+  }
+}
+export {
+  OpenAIBaseChatCompletionsTextAdapter
+};
+//# sourceMappingURL=chat-completions-text.js.map