@tanstack/openai-base 0.2.1 → 0.3.1

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

@@ -1,28 +1,26 @@
+import { EventType } from "@tanstack/ai";
 import { BaseTextAdapter } from "@tanstack/ai/adapters";
 import { toRunErrorPayload } from "@tanstack/ai/adapter-internals";
 import { generateId, transformNullsToUndefined } from "@tanstack/ai-utils";
-import { createOpenAICompatibleClient } from "../utils/client.js";
 import { extractRequestOptions } from "../utils/request-options.js";
 import { makeStructuredOutputCompatible } from "../utils/schema-converter.js";
 import { convertToolsToChatCompletionsFormat } from "./chat-completions-tool-converter.js";
-const asChunk = (chunk) => chunk;
-class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
-  constructor(config, model, name = "openai-compatible") {
+class OpenAIBaseChatCompletionsTextAdapter extends BaseTextAdapter {
+  constructor(model, name, client) {
     super({}, model);
     this.kind = "text";
     this.name = name;
-    this.client = createOpenAICompatibleClient(config);
+    this.client = client;
   }
   async *chatStream(options) {
-    const requestParams = this.mapOptionsToRequest(options);
-    const timestamp = Date.now();
     const aguiState = {
       runId: generateId(this.name),
+      threadId: options.threadId ?? generateId(this.name),
       messageId: generateId(this.name),
-      timestamp,
       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 }
@@ -43,20 +41,23 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
       );
       if (!aguiState.hasEmittedRunStarted) {
         aguiState.hasEmittedRunStarted = true;
-        yield asChunk({
-          type: "RUN_STARTED",
+        yield {
+          type: EventType.RUN_STARTED,
           runId: aguiState.runId,
+          threadId: aguiState.threadId,
           model: options.model,
-          timestamp
-        });
+          timestamp: Date.now(),
+          parentRunId: options.parentRunId
+        };
       }
-      yield asChunk({
-        type: "RUN_ERROR",
-        runId: aguiState.runId,
+      yield {
+        type: EventType.RUN_ERROR,
         model: options.model,
-        timestamp,
+        timestamp: Date.now(),
+        message: errorPayload.message,
+        code: errorPayload.code,
         error: errorPayload
-      });
+      };
       options.logger.errors(`${this.name}.chatStream fatal`, {
         error: errorPayload,
         source: `${this.name}.chatStream`
@@ -107,7 +108,12 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
         },
         extractRequestOptions(chatOptions.request)
       );
-      const rawText = response.choices[0]?.message.content || "";
+      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);
@@ -116,7 +122,7 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
           `Failed to parse structured output as JSON. Content: ${rawText.slice(0, 200)}${rawText.length > 200 ? "..." : ""}`
         );
       }
-      const transformed = transformNullsToUndefined(parsed);
+      const transformed = this.transformStructuredOutput(parsed);
       return {
         data: transformed,
         rawText
@@ -129,6 +135,286 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
       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: {
+            promptTokens: lastUsage.prompt_tokens,
+            completionTokens: lastUsage.completion_tokens,
+            totalTokens: lastUsage.total_tokens
+          }
+        }
+      };
+    } 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`
+      );
+      yield {
+        type: EventType.RUN_ERROR,
+        runId: aguiState.runId,
+        model: lastModel || chatOptions.model,
+        timestamp,
+        message: errorPayload.message,
+        code: isAbort ? "aborted" : errorPayload.code,
+        error: { ...errorPayload, ...isAbort && { code: "aborted" } }
+      };
+      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.
@@ -136,18 +422,41 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
   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 converts `null` values to `undefined` so
+   * the result aligns with the original Zod schema's optional-field
+   * semantics. Subclasses with different conventions (OpenRouter historically
+   * preserves nulls) can override.
+   */
+  transformStructuredOutput(parsed) {
+    return transformNullsToUndefined(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 = "";
-    const timestamp = aguiState.timestamp;
     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) {
@@ -164,12 +473,50 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
         }
         if (!aguiState.hasEmittedRunStarted) {
           aguiState.hasEmittedRunStarted = true;
-          yield asChunk({
-            type: "RUN_STARTED",
+          yield {
+            type: EventType.RUN_STARTED,
             runId: aguiState.runId,
+            threadId: aguiState.threadId,
             model: chunk.model || options.model,
-            timestamp
-          });
+            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;
@@ -177,25 +524,50 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
         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 asChunk({
-              type: "TEXT_MESSAGE_START",
+            yield {
+              type: EventType.TEXT_MESSAGE_START,
               messageId: aguiState.messageId,
               model: chunk.model || options.model,
-              timestamp,
+              timestamp: Date.now(),
               role: "assistant"
-            });
+            };
           }
           accumulatedContent += deltaContent;
-          yield asChunk({
-            type: "TEXT_MESSAGE_CONTENT",
+          yield {
+            type: EventType.TEXT_MESSAGE_CONTENT,
             messageId: aguiState.messageId,
             model: chunk.model || options.model,
-            timestamp,
+            timestamp: Date.now(),
             delta: deltaContent,
             content: accumulatedContent
-          });
+          };
         }
         if (deltaToolCalls) {
           for (const toolCallDelta of deltaToolCalls) {
@@ -220,24 +592,24 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
             }
             if (toolCall.id && toolCall.name && !toolCall.started) {
               toolCall.started = true;
-              yield asChunk({
-                type: "TOOL_CALL_START",
+              yield {
+                type: EventType.TOOL_CALL_START,
                 toolCallId: toolCall.id,
                 toolCallName: toolCall.name,
                 toolName: toolCall.name,
                 model: chunk.model || options.model,
-                timestamp,
+                timestamp: Date.now(),
                 index
-              });
+              };
             }
             if (toolCallDelta.function?.arguments && toolCall.started) {
-              yield asChunk({
-                type: "TOOL_CALL_ARGS",
+              yield {
+                type: EventType.TOOL_CALL_ARGS,
                 toolCallId: toolCall.id,
                 model: chunk.model || options.model,
-                timestamp,
+                timestamp: Date.now(),
                 delta: toolCallDelta.function.arguments
-              });
+              };
             }
           }
         }
@@ -267,26 +639,26 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
                   parsedInput = {};
                 }
               }
-              yield asChunk({
-                type: "TOOL_CALL_END",
+              yield {
+                type: EventType.TOOL_CALL_END,
                 toolCallId: toolCall.id,
                 toolCallName: toolCall.name,
                 toolName: toolCall.name,
                 model: chunk.model || options.model,
-                timestamp,
+                timestamp: Date.now(),
                 input: parsedInput
-              });
+              };
               emittedAnyToolCallEnd = true;
             }
             toolCallsInProgress.clear();
           }
           if (hasEmittedTextMessageStart) {
-            yield asChunk({
-              type: "TEXT_MESSAGE_END",
+            yield {
+              type: EventType.TEXT_MESSAGE_END,
               messageId: aguiState.messageId,
               model: chunk.model || options.model,
-              timestamp
-            });
+              timestamp: Date.now()
+            };
             hasEmittedTextMessageStart = false;
           }
           pendingFinishReason = choice.finish_reason;
@@ -301,44 +673,83 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
             try {
               const parsed = JSON.parse(toolCall.arguments);
               parsedInput = parsed && typeof parsed === "object" ? parsed : {};
-            } catch {
+            } 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 asChunk({
-            type: "TOOL_CALL_END",
+          yield {
+            type: EventType.TOOL_CALL_END,
             toolCallId: toolCall.id,
             toolCallName: toolCall.name,
             toolName: toolCall.name,
             model: lastModel || options.model,
-            timestamp,
+            timestamp: Date.now(),
             input: parsedInput
-          });
+          };
           pendingToolCount += 1;
           emittedAnyToolCallEnd = true;
         }
         toolCallsInProgress.clear();
         if (hasEmittedTextMessageStart) {
-          yield asChunk({
-            type: "TEXT_MESSAGE_END",
+          yield {
+            type: EventType.TEXT_MESSAGE_END,
             messageId: aguiState.messageId,
             model: lastModel || options.model,
-            timestamp
-          });
+            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 ?? "stop";
-        yield asChunk({
-          type: "RUN_FINISHED",
+        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,
+          timestamp: Date.now(),
           usage: lastUsage ? {
             promptTokens: lastUsage.prompt_tokens || 0,
             completionTokens: lastUsage.completion_tokens || 0,
             totalTokens: lastUsage.total_tokens || 0
           } : void 0,
           finishReason
-        });
+        };
       }
     } catch (error) {
       const errorPayload = toRunErrorPayload(
@@ -349,13 +760,14 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
         error: errorPayload,
         source: `${this.name}.processStreamChunks`
       });
-      yield asChunk({
-        type: "RUN_ERROR",
-        runId: aguiState.runId,
+      yield {
+        type: EventType.RUN_ERROR,
         model: options.model,
-        timestamp,
+        timestamp: Date.now(),
+        message: errorPayload.message,
+        code: errorPayload.code,
         error: errorPayload
-      });
+      };
     }
   }
   /**
@@ -509,6 +921,6 @@ class OpenAICompatibleChatCompletionsTextAdapter extends BaseTextAdapter {
   }
 }
 export {
-  OpenAICompatibleChatCompletionsTextAdapter
+  OpenAIBaseChatCompletionsTextAdapter
 };
 //# sourceMappingURL=chat-completions-text.js.map