@tanstack/openai-base 0.9.9 → 0.9.11

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

@@ -1,967 +1,849 @@
+import { makeStructuredOutputCompatible } from "../utils/schema-converter.js";
+import { buildChatCompletionsUsage } from "../usage.js";
+import { extractRequestOptions } from "../utils/request-options.js";
+import { convertToolsToChatCompletionsFormat } from "./chat-completions-tool-converter.js";
 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
+//#region src/adapters/chat-completions-text.ts
+/**
+* Shared implementation of the OpenAI Chat Completions API. Holds the
+* stream-accumulator + AG-UI lifecycle logic and calls the OpenAI SDK
+* directly. Subclasses (ai-openai, ai-grok, ai-groq) construct an OpenAI
+* client with their provider-specific `baseURL` / headers and pass it in.
+*/
+var OpenAIBaseChatCompletionsTextAdapter = class 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,
+				...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 rawText = (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))).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 ? "..." : ""}`);
+			}
+			return {
+				data: this.transformStructuredOutput(parsed),
+				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) {}
+	/**
+	* 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,
+			...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";
+			return {
+				type: "image_url",
+				image_url: {
+					url: part.source.type === "data" && !imageValue.startsWith("data:") ? `data:${imageMime};base64,${imageValue}` : imageValue,
+					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("");
+	}
 };
-//# sourceMappingURL=chat-completions-text.js.map
+//#endregion
+export { OpenAIBaseChatCompletionsTextAdapter };
+
+//# sourceMappingURL=chat-completions-text.js.map