@yourgpt/llm-sdk 2.5.1-beta.6 → 2.6.0-beta.1

package/dist/adapters/index.js

@@ -1,5 +1,56 @@
 'use strict';
 
+// src/core/openai-parameters.ts
+function capabilities(model) {
+  const gpt = /^gpt-(\d+)(?:\.(\d+))?(?:-(.+))?$/i.exec(model);
+  const major = Number(gpt?.[1] ?? 0);
+  const minor = Number(gpt?.[2] ?? 0);
+  const chat = gpt?.[3]?.startsWith("chat") ?? false;
+  const reasoning = /^o\d+(?:-|$)/i.test(model) || major >= 5 && !chat;
+  const supportsNone = major === 5 && minor >= 1 && !chat || /^gpt-6-(?:sol|luna)(?:-\d{4}-\d{2}-\d{2})?$/i.test(model);
+  return { major, minor, reasoning, supportsNone };
+}
+function requiresOpenAIResponses(model, baseUrl, options = {}) {
+  if (options.parameterPolicy === "passthrough") return false;
+  const c = capabilities(model);
+  if (!c.reasoning || options.reasoningEffort === "none") return false;
+  if (!(c.major >= 6 || c.major === 5 && c.minor >= 4)) return false;
+  if (!baseUrl) return true;
+  try {
+    return new URL(baseUrl).hostname === "api.openai.com";
+  } catch {
+    return false;
+  }
+}
+function buildOpenAIParameters(model, maxTokens, temperature, options = {}, api = "chat") {
+  const c = capabilities(model ?? "");
+  const normalize = options.parameterPolicy !== "passthrough";
+  const effort = options.reasoningEffort;
+  if (normalize && c.reasoning && effort === "none" && !c.supportsNone) {
+    throw new Error(`${model} does not support reasoningEffort: none`);
+  }
+  if (normalize && c.major >= 6 && effort === "minimal") {
+    throw new Error(`${model} does not support reasoningEffort: minimal`);
+  }
+  const result = {
+    [api === "responses" ? "max_output_tokens" : normalize && c.reasoning ? "max_completion_tokens" : "max_tokens"]: maxTokens
+  };
+  if (effort !== void 0) {
+    if (api === "responses") result.reasoning = { effort };
+    else result.reasoning_effort = effort;
+  }
+  if (temperature !== void 0) {
+    if (!normalize || !c.reasoning || effort === "none" && c.supportsNone) {
+      result.temperature = temperature;
+    } else {
+      (options.onWarning ?? console.warn)(
+        `[llm-sdk] ${model}: omitted temperature because reasoning is enabled.`
+      );
+    }
+  }
+  return result;
+}
+
 // src/adapters/base.ts
 function stringifyForDebug(value) {
   return JSON.stringify(
@@ -104,25 +155,20 @@ function normalizeObjectJsonSchema(schema) {
       (value) => typeof value === "string"
     ) : [];
     normalized.required = Array.from(/* @__PURE__ */ new Set([...required, ...propertyKeys]));
-    if (normalized.additionalProperties === void 0) {
-      normalized.additionalProperties = false;
-    }
+    normalized.additionalProperties = false;
   } else if (type === "array" && normalized.items && typeof normalized.items === "object") {
     normalized.items = normalizeObjectJsonSchema(
       normalized.items
     );
   }
-  return normalized;
-}
-function isOpenAIReasoningModel(modelId) {
-  if (!modelId) return false;
-  return /^(o1|o3|o4|gpt-5)/i.test(modelId);
-}
-function buildOpenAITokenParams(modelId, maxTokens, temperature) {
-  if (isOpenAIReasoningModel(modelId)) {
-    return { max_completion_tokens: maxTokens };
+  for (const keyword of ["anyOf", "oneOf", "allOf"]) {
+    const branches = normalized[keyword];
+    if (!Array.isArray(branches)) continue;
+    normalized[keyword] = branches.map(
+      (branch) => branch && typeof branch === "object" ? normalizeObjectJsonSchema(branch) : branch
+    );
   }
-  return { max_tokens: maxTokens, temperature };
+  return normalized;
 }
 function stripSchemaKeys(schema, keysToDrop, options = {}) {
   if (Array.isArray(schema)) {
@@ -470,6 +516,28 @@ function formatMessagesForOpenAI(messages, systemPrompt) {
   return formatted;
 }
 
+// src/core/provider-error.ts
+function providerErrorEvent(error, code) {
+  const details = error ?? {};
+  const event = {
+    type: "error",
+    message: error instanceof Error ? error.message : String(error),
+    code,
+    ...typeof details.status === "number" ? { status: details.status } : {},
+    ...typeof details.code === "string" ? { providerCode: details.code } : {},
+    ...typeof details.param === "string" ? { param: details.param } : {},
+    ...typeof details.request_id === "string" ? { requestId: details.request_id } : {}
+  };
+  Object.defineProperty(event, "cause", { value: error, enumerable: false });
+  return event;
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  throw error;
+}
+
 // src/core/utils.ts
 function generateId(prefix = "id") {
   return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
@@ -501,24 +569,84 @@ var OpenAIAdapter = class _OpenAIAdapter {
       const { default: OpenAI } = await import('openai');
       this.client = new OpenAI({
         apiKey: this.config.apiKey,
-        baseURL: this.config.baseUrl
+        baseURL: this.config.baseUrl,
+        organization: this.config.organization,
+        defaultHeaders: this.config.headers
       });
     }
     return this.client;
   }
+  parameterOptions(request) {
+    return {
+      ...this.config,
+      reasoningEffort: request.config?.reasoningEffort ?? this.config.reasoningEffort
+    };
+  }
+  toolDefinitions(request) {
+    if (request.toolDefinitions?.length) return request.toolDefinitions;
+    return formatTools(request.actions ?? []).map((tool) => ({
+      name: tool.function.name,
+      description: tool.function.description ?? "",
+      location: "server",
+      inputSchema: tool.function.parameters
+    }));
+  }
   shouldUseResponsesApi(request) {
-    return request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true && request.providerToolOptions.openai.nativeToolSearch.useResponsesApi !== false && Array.isArray(request.toolDefinitions) && request.toolDefinitions.length > 0;
+    if (this.toolDefinitions(request).length === 0) return false;
+    if (request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true && request.providerToolOptions.openai.nativeToolSearch.useResponsesApi !== false)
+      return true;
+    return requiresOpenAIResponses(
+      request.config?.model || this.model,
+      this.config.baseUrl,
+      this.parameterOptions(request)
+    );
+  }
+  /**
+   * Convert one message's content to Responses content parts.
+   *
+   * The Responses API does not accept Chat Completions content blocks: input
+   * parts are `input_text` / `input_image` (with a bare `image_url` string)
+   * rather than `text` / `image_url: { url }`. Passing the Chat Completions
+   * shape through unchanged makes the API reject the request, so anything
+   * array-shaped has to be translated rather than forwarded.
+   */
+  toResponsesContent(content, role) {
+    const textType = role === "assistant" ? "output_text" : "input_text";
+    if (typeof content === "string") return content;
+    if (!Array.isArray(content)) {
+      return content == null ? "" : JSON.stringify(content);
+    }
+    return content.map((part) => {
+      const p = part;
+      if (p?.type === "text") return { type: textType, text: p.text ?? "" };
+      if (p?.type === "image_url") {
+        const url = typeof p.image_url === "string" ? p.image_url : p.image_url?.url;
+        return {
+          type: "input_image",
+          image_url: url,
+          ...p.image_url?.detail ? { detail: p.image_url.detail } : {}
+        };
+      }
+      return p;
+    });
   }
   buildResponsesInput(request) {
-    const sourceMessages = request.rawMessages && request.rawMessages.length > 0 ? request.rawMessages : formatMessagesForOpenAI(request.messages, void 0);
+    const sourceMessages = request.rawMessages && request.rawMessages.length > 0 ? this.formatRawMessages(request.rawMessages) : formatMessagesForOpenAI(request.messages, void 0);
     const input = [];
     for (const message of sourceMessages) {
       if (message.role === "system") {
+        if (!request.systemPrompt && message.content) {
+          input.push({
+            type: "message",
+            role: "developer",
+            content: this.toResponsesContent(message.content, "developer")
+          });
+        }
         continue;
       }
       if (message.role === "assistant") {
-        const content = typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content : message.content ? JSON.stringify(message.content) : "";
-        if (content) {
+        const content = this.toResponsesContent(message.content, "assistant");
+        if (typeof content === "string" ? content : Array.isArray(content) && content.length > 0) {
           input.push({
             type: "message",
             role: "assistant",
@@ -544,15 +672,87 @@ var OpenAIAdapter = class _OpenAIAdapter {
         });
         continue;
       }
+      const role = message.role === "developer" ? "developer" : "user";
       input.push({
         type: "message",
-        role: message.role === "developer" ? "developer" : "user",
-        content: typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content : JSON.stringify(message.content ?? "")
+        role,
+        content: this.toResponsesContent(message.content, role)
       });
     }
     return input;
   }
-  buildResponsesTools(tools) {
+  /** Preserve Copilot screenshot attachments on every OpenAI transport. */
+  formatRawMessages(messages) {
+    return messages.map((message) => {
+      const { attachments, ...rest } = message;
+      let content = message.content;
+      if (message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0 && content === "") {
+        content = null;
+      }
+      if (Array.isArray(attachments) && attachments.length > 0) {
+        const images = attachments.filter((attachment) => attachment && typeof attachment === "object").map(
+          (attachment) => attachmentToOpenAIImage(attachment)
+        ).filter((image) => image !== null);
+        if (images.length > 0) {
+          const parts = Array.isArray(content) ? content : content ? [{ type: "text", text: content }] : [];
+          content = [...parts, ...images];
+        }
+      }
+      return { ...rest, content };
+    });
+  }
+  /**
+   * Build the web_search tool for the Responses API, or undefined when web
+   * search is off.
+   *
+   * The Chat Completions path uses `web_search_preview`; the Responses API
+   * names the same built-in `web_search`. Without this, enabling web search
+   * alongside a gpt-5.4+ function tool silently did nothing, because routing
+   * to /v1/responses skipped the Chat Completions tool assembly entirely.
+   */
+  buildResponsesWebSearchTool(request) {
+    const webSearchConfig = request.webSearch ?? this.config.webSearch;
+    if (!webSearchConfig) return void 0;
+    const tool = { type: "web_search" };
+    const wsConfig = typeof webSearchConfig === "object" ? webSearchConfig : {};
+    if (wsConfig.userLocation) {
+      tool.search_context_size = "medium";
+    }
+    return tool;
+  }
+  /**
+   * Extract url_citation annotations from Responses output items.
+   *
+   * Annotations hang off the output_text content parts rather than arriving as
+   * their own stream events, so both the streaming and non-streaming paths read
+   * them from the same place.
+   */
+  collectResponsesCitations(output, startIndex = 0) {
+    if (!Array.isArray(output)) return [];
+    const citations = [];
+    let index = startIndex;
+    for (const item of output) {
+      if (item?.type !== "message" || !Array.isArray(item.content)) continue;
+      for (const part of item.content) {
+        if (!Array.isArray(part?.annotations)) continue;
+        for (const annotation of part.annotations) {
+          const url = annotation?.url;
+          if (annotation?.type !== "url_citation" || !url) continue;
+          index++;
+          const domain = extractDomain(url);
+          citations.push({
+            index,
+            url,
+            title: annotation.title || domain,
+            domain,
+            favicon: domain ? `https://www.google.com/s2/favicons?domain=${domain}&sz=32` : void 0
+          });
+        }
+      }
+    }
+    return citations;
+  }
+  buildResponsesTools(tools, includeToolSearch, webSearchTool) {
     const nativeTools = tools.filter((tool) => tool.available !== false).map((tool) => ({
       type: "function",
       name: tool.name,
@@ -567,20 +767,22 @@ var OpenAIAdapter = class _OpenAIAdapter {
       strict: true,
       defer_loading: tool.deferLoading === true
     }));
-    return [{ type: "tool_search" }, ...nativeTools];
+    const builtins = [];
+    if (includeToolSearch) builtins.push({ type: "tool_search" });
+    if (webSearchTool) builtins.push(webSearchTool);
+    return [...builtins, ...nativeTools];
   }
   parseResponsesResult(response) {
-    const content = typeof response?.output_text === "string" ? response.output_text : "";
+    const textFromOutput = Array.isArray(response?.output) ? response.output.filter((item) => item?.type === "message").flatMap(
+      (item) => Array.isArray(item.content) ? item.content.filter(
+        (part) => part?.type === "output_text" && typeof part.text === "string"
+      ).map((part) => part.text) : []
+    ).join("") : "";
+    const content = textFromOutput || (typeof response?.output_text === "string" ? response.output_text : "");
     const toolCalls = Array.isArray(response?.output) ? response.output.filter((item) => item?.type === "function_call").map((item) => ({
       id: item.call_id ?? item.id ?? generateToolCallId(),
       name: item.name,
-      args: (() => {
-        try {
-          return JSON.parse(item.arguments ?? "{}");
-        } catch {
-          return {};
-        }
-      })()
+      args: JSON.parse(item.arguments ?? "{}")
     })) : [];
     return {
       content,
@@ -593,102 +795,194 @@ var OpenAIAdapter = class _OpenAIAdapter {
       rawResponse: response
     };
   }
-  async completeWithResponses(request) {
-    const client = await this.getClient();
+  buildResponsesPayload(request, stream) {
     const openaiToolOptions = request.providerToolOptions?.openai;
     const responsesTextFormat = toOpenAIResponsesTextFormat(
       request.config?.responseFormat
     );
+    const modelIdForPayload = request.config?.model || this.model;
     const payload = {
-      model: request.config?.model || this.model,
+      model: modelIdForPayload,
       instructions: request.systemPrompt,
       input: this.buildResponsesInput(request),
-      tools: this.buildResponsesTools(request.toolDefinitions ?? []),
-      tool_choice: openaiToolOptions?.toolChoice === "required" ? "required" : openaiToolOptions?.toolChoice === "auto" ? "auto" : void 0,
+      tools: this.buildResponsesTools(
+        this.toolDefinitions(request),
+        request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true,
+        this.buildResponsesWebSearchTool(request)
+      ),
+      tool_choice: openaiToolOptions?.toolChoice,
       parallel_tool_calls: openaiToolOptions?.parallelToolCalls,
-      temperature: request.config?.temperature ?? this.config.temperature,
-      max_output_tokens: request.config?.maxTokens ?? this.config.maxTokens,
+      ...buildOpenAIParameters(
+        modelIdForPayload,
+        request.config?.maxTokens ?? this.config.maxTokens,
+        request.config?.temperature ?? this.config.temperature,
+        this.parameterOptions(request),
+        "responses"
+      ),
       ...responsesTextFormat ? { text: { format: responsesTextFormat } } : {},
-      stream: false
+      stream
     };
+    return payload;
+  }
+  async completeWithResponses(request) {
+    const client = await this.getClient();
+    throwIfAborted(request.signal);
+    const payload = this.buildResponsesPayload(request, false);
     logProviderPayload("openai", "request payload", payload, request.debug);
-    const response = await client.responses.create(payload);
+    if (!client.responses?.create)
+      throw new Error(
+        "This OpenAI client does not support Responses; install an openai version with Responses support."
+      );
+    const response = await client.responses.create(payload, {
+      signal: request.signal
+    });
+    throwIfAborted(request.signal);
     logProviderPayload("openai", "response payload", response, request.debug);
+    if (response.status && response.status !== "completed") {
+      throw Object.assign(
+        new Error(
+          response.error?.message ?? `Responses request ${response.status}`
+        ),
+        response.error
+      );
+    }
     return this.parseResponsesResult(response);
   }
+  /**
+   * Stream from /v1/responses as real SSE.
+   *
+   * The Responses API emits semantic events rather than Chat Completions
+   * deltas, so the interesting ones are:
+   *   response.output_text.delta       — incremental assistant text
+   *   response.output_item.added       — a function_call item begins (name/id)
+   *   response.function_call_arguments.delta / .done — tool arguments
+   *   response.completed               — terminal, carries usage
+   *
+   * Tool calls are buffered and flushed as contiguous start→args→end triples
+   * because the runtime pairs action:args with the action:end that follows it.
+   */
+  async *streamWithResponses(request) {
+    const client = await this.getClient();
+    throwIfAborted(request.signal);
+    const payload = this.buildResponsesPayload(request, true);
+    logProviderPayload("openai", "request payload", payload, request.debug);
+    if (!client.responses?.create)
+      throw new Error(
+        "This OpenAI client does not support Responses; install an openai version with Responses support."
+      );
+    const stream = await client.responses.create(payload, {
+      signal: request.signal
+    });
+    const toolCalls = /* @__PURE__ */ new Map();
+    let usage;
+    const citations = [];
+    let completed = false;
+    function* flushToolCalls() {
+      for (const call of toolCalls.values()) {
+        if (!call.name)
+          throw new Error("Responses tool call is missing its name");
+        JSON.parse(call.arguments || "{}");
+      }
+      for (const call of toolCalls.values()) {
+        yield { type: "action:start", id: call.id, name: call.name };
+        yield { type: "action:args", id: call.id, args: call.arguments };
+        yield { type: "action:end", id: call.id, name: call.name };
+      }
+      toolCalls.clear();
+    }
+    for await (const event of stream) {
+      throwIfAborted(request.signal);
+      logProviderPayload("openai", "stream chunk", event, request.debug);
+      const index = event?.output_index ?? 0;
+      switch (event?.type) {
+        case "response.output_text.delta":
+          if (event.delta) {
+            yield { type: "message:delta", content: event.delta };
+          }
+          break;
+        case "response.output_item.added":
+          if (event.item?.type === "function_call") {
+            toolCalls.set(index, {
+              id: event.item.call_id ?? event.item.id ?? generateToolCallId(),
+              name: event.item.name ?? "",
+              arguments: event.item.arguments ?? ""
+            });
+          }
+          break;
+        case "response.function_call_arguments.delta": {
+          const existing = toolCalls.get(index);
+          if (existing && event.delta) existing.arguments += event.delta;
+          break;
+        }
+        case "response.function_call_arguments.done": {
+          const existing = toolCalls.get(index);
+          if (existing && typeof event.arguments === "string") {
+            existing.arguments = event.arguments;
+          }
+          break;
+        }
+        case "response.completed": {
+          completed = true;
+          const found = this.collectResponsesCitations(
+            event.response?.output,
+            citations.length
+          );
+          if (found.length > 0) citations.push(...found);
+          const u = event.response?.usage;
+          if (u) {
+            usage = {
+              prompt_tokens: u.input_tokens ?? 0,
+              completion_tokens: u.output_tokens ?? 0,
+              total_tokens: u.total_tokens ?? (u.input_tokens ?? 0) + (u.output_tokens ?? 0)
+            };
+          }
+          break;
+        }
+        case "response.incomplete":
+          throw new Error(
+            `Responses stream incomplete: ${event.response?.incomplete_details?.reason ?? "unknown reason"}`
+          );
+        case "error":
+        case "response.failed": {
+          const details = event.response?.error ?? event;
+          throw Object.assign(
+            new Error(details.message ?? "Responses stream failed"),
+            {
+              code: details.code,
+              param: details.param,
+              status: details.status
+            }
+          );
+        }
+      }
+    }
+    throwIfAborted(request.signal);
+    if (!completed)
+      throw new Error("Responses stream ended without a completed response");
+    yield* flushToolCalls();
+    if (citations.length > 0) {
+      yield { type: "citation", citations: deduplicateCitations(citations) };
+    }
+    yield { type: "message:end" };
+    yield { type: "done", usage };
+  }
   async *stream(request) {
+    throwIfAborted(request.signal);
     if (this.shouldUseResponsesApi(request)) {
       const messageId2 = generateMessageId();
       yield { type: "message:start", id: messageId2 };
       try {
-        const result = await this.completeWithResponses(request);
-        if (result.content) {
-          yield { type: "message:delta", content: result.content };
-        }
-        for (const toolCall of result.toolCalls) {
-          yield {
-            type: "action:start",
-            id: toolCall.id,
-            name: toolCall.name
-          };
-          yield {
-            type: "action:args",
-            id: toolCall.id,
-            args: JSON.stringify(toolCall.args)
-          };
-        }
-        yield { type: "message:end" };
-        yield {
-          type: "done",
-          usage: result.usage ? {
-            prompt_tokens: result.usage.promptTokens,
-            completion_tokens: result.usage.completionTokens,
-            total_tokens: result.usage.totalTokens
-          } : void 0
-        };
+        yield* this.streamWithResponses(request);
         return;
       } catch (error) {
-        yield {
-          type: "error",
-          message: error instanceof Error ? error.message : "Unknown error",
-          code: "OPENAI_RESPONSES_ERROR"
-        };
+        yield providerErrorEvent(error, "OPENAI_RESPONSES_ERROR");
         return;
       }
     }
     const client = await this.getClient();
     let messages;
     if (request.rawMessages && request.rawMessages.length > 0) {
-      const processedMessages = request.rawMessages.map((msg) => {
-        if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0 && msg.content === "") {
-          return { ...msg, content: null };
-        }
-        const hasAttachments = msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0;
-        if (hasAttachments) {
-          const content = [];
-          if (msg.content) {
-            content.push({ type: "text", text: msg.content });
-          }
-          for (const attachment of msg.attachments) {
-            if (attachment.type === "image") {
-              let imageUrl;
-              if (attachment.url) {
-                imageUrl = attachment.url;
-              } else if (attachment.data) {
-                imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
-              } else {
-                continue;
-              }
-              content.push({
-                type: "image_url",
-                image_url: { url: imageUrl, detail: "auto" }
-              });
-            }
-          }
-          return { ...msg, content, attachments: void 0 };
-        }
-        return msg;
-      });
+      const processedMessages = this.formatRawMessages(request.rawMessages);
       if (request.systemPrompt) {
         const hasSystem = processedMessages.some((m) => m.role === "system");
         if (!hasSystem) {
@@ -708,7 +1002,16 @@ var OpenAIAdapter = class _OpenAIAdapter {
         request.systemPrompt
       );
     }
-    const tools = request.actions?.length ? formatTools(request.actions) : [];
+    const tools = request.toolDefinitions?.length ? request.toolDefinitions.filter((tool) => tool.available !== false).map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: normalizeObjectJsonSchema(
+          tool.inputSchema
+        )
+      }
+    })) : formatTools(request.actions ?? []);
     const webSearchConfig = request.webSearch ?? this.config.webSearch;
     if (webSearchConfig) {
       const webSearchTool = {
@@ -737,26 +1040,28 @@ var OpenAIAdapter = class _OpenAIAdapter {
         tools: tools.length > 0 ? tools : void 0,
         tool_choice: tools.length > 0 ? toolChoice : void 0,
         parallel_tool_calls: tools.length > 0 ? openaiToolOptions?.parallelToolCalls : void 0,
-        ...buildOpenAITokenParams(
+        ...buildOpenAIParameters(
           modelIdForPayload,
           request.config?.maxTokens ?? this.config.maxTokens,
-          request.config?.temperature ?? this.config.temperature
+          request.config?.temperature ?? this.config.temperature,
+          this.parameterOptions(request)
         ),
         response_format: toOpenAIResponseFormat(request.config?.responseFormat),
         stream: true,
         stream_options: { include_usage: true }
       };
       logProviderPayload("openai", "request payload", payload, request.debug);
-      const stream = await client.chat.completions.create(payload);
-      let currentToolCall = null;
+      const stream = await client.chat.completions.create(payload, {
+        signal: request.signal
+      });
+      const toolCalls = /* @__PURE__ */ new Map();
+      let finishReason;
       const collectedCitations = [];
       let citationIndex = 0;
       let usage;
       for await (const chunk of stream) {
         logProviderPayload("openai", "stream chunk", chunk, request.debug);
-        if (request.signal?.aborted) {
-          break;
-        }
+        throwIfAborted(request.signal);
         const delta = chunk.choices[0]?.delta;
         const choice = chunk.choices[0];
         if (delta?.content) {
@@ -779,38 +1084,19 @@ var OpenAIAdapter = class _OpenAIAdapter {
             }
           }
         }
-        if (delta?.tool_calls) {
-          for (const toolCall of delta.tool_calls) {
-            if (toolCall.id) {
-              if (currentToolCall) {
-                yield {
-                  type: "action:args",
-                  id: currentToolCall.id,
-                  args: currentToolCall.arguments
-                };
-                yield {
-                  type: "action:end",
-                  id: currentToolCall.id,
-                  name: currentToolCall.name
-                };
-              }
-              const tcExtraContent = toolCall.extra_content;
-              currentToolCall = {
-                id: toolCall.id,
-                name: toolCall.function?.name || "",
-                arguments: toolCall.function?.arguments || "",
-                ...tcExtraContent ? { extra_content: tcExtraContent } : {}
-              };
-              yield {
-                type: "action:start",
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                ...currentToolCall.extra_content ? { extra_content: currentToolCall.extra_content } : {}
-              };
-            } else if (currentToolCall && toolCall.function?.arguments) {
-              currentToolCall.arguments += toolCall.function.arguments;
-            }
-          }
+        for (const part of delta?.tool_calls ?? []) {
+          const index = part.index ?? 0;
+          const call = toolCalls.get(index) ?? {
+            id: "",
+            name: "",
+            arguments: ""
+          };
+          if (part.id) call.id = part.id;
+          if (part.function?.name) call.name += part.function.name;
+          if (part.function?.arguments)
+            call.arguments += part.function.arguments;
+          if (part.extra_content) call.extra_content = part.extra_content;
+          toolCalls.set(index, call);
         }
         if (chunk.usage) {
           usage = {
@@ -819,21 +1105,28 @@ var OpenAIAdapter = class _OpenAIAdapter {
             total_tokens: chunk.usage.total_tokens
           };
         }
-        if (choice?.finish_reason) {
-          if (currentToolCall) {
-            yield {
-              type: "action:args",
-              id: currentToolCall.id,
-              args: currentToolCall.arguments
-            };
-            yield {
-              type: "action:end",
-              id: currentToolCall.id,
-              name: currentToolCall.name
-            };
-            currentToolCall = null;
-          }
-        }
+        if (choice?.finish_reason) finishReason = choice.finish_reason;
+      }
+      throwIfAborted(request.signal);
+      if (!finishReason)
+        throw new Error("OpenAI stream ended without a finish reason");
+      if (toolCalls.size && !["tool_calls", "function_call"].includes(finishReason)) {
+        throw new Error("OpenAI stream ended with incomplete tool calls");
+      }
+      for (const call of toolCalls.values()) {
+        if (!call.id || !call.name)
+          throw new Error("OpenAI stream contains an incomplete tool call");
+        JSON.parse(call.arguments || "{}");
+      }
+      for (const call of toolCalls.values()) {
+        yield {
+          type: "action:start",
+          id: call.id,
+          name: call.name,
+          ...call.extra_content ? { extra_content: call.extra_content } : {}
+        };
+        yield { type: "action:args", id: call.id, args: call.arguments };
+        yield { type: "action:end", id: call.id, name: call.name };
       }
       if (collectedCitations.length > 0) {
         const uniqueCitations = deduplicateCitations(collectedCitations);
@@ -842,26 +1135,18 @@ var OpenAIAdapter = class _OpenAIAdapter {
       yield { type: "message:end" };
       yield { type: "done", usage };
     } catch (error) {
-      yield {
-        type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: `${this.provider.toUpperCase()}_ERROR`
-      };
+      yield providerErrorEvent(error, `${this.provider.toUpperCase()}_ERROR`);
     }
   }
   async complete(request) {
+    throwIfAborted(request.signal);
     if (this.shouldUseResponsesApi(request)) {
       return this.completeWithResponses(request);
     }
     const client = await this.getClient();
     let messages;
     if (request.rawMessages && request.rawMessages.length > 0) {
-      const sanitized = request.rawMessages.map((msg) => {
-        if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0 && msg.content === "") {
-          return { ...msg, content: null };
-        }
-        return msg;
-      });
+      const sanitized = this.formatRawMessages(request.rawMessages);
       if (request.systemPrompt && !sanitized.some((message2) => message2.role === "system")) {
         messages = [
           { role: "system", content: request.systemPrompt },
@@ -876,7 +1161,16 @@ var OpenAIAdapter = class _OpenAIAdapter {
         request.systemPrompt
       );
     }
-    const tools = request.actions?.length ? formatTools(request.actions) : [];
+    const tools = request.toolDefinitions?.length ? request.toolDefinitions.filter((tool) => tool.available !== false).map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: normalizeObjectJsonSchema(
+          tool.inputSchema
+        )
+      }
+    })) : formatTools(request.actions ?? []);
     const openaiToolOptions = request.providerToolOptions?.openai;
     const toolChoice = openaiToolOptions?.toolChoice && typeof openaiToolOptions.toolChoice === "object" ? {
       type: "function",
@@ -891,16 +1185,19 @@ var OpenAIAdapter = class _OpenAIAdapter {
       tools: tools.length > 0 ? tools : void 0,
       tool_choice: tools.length > 0 ? toolChoice : void 0,
       parallel_tool_calls: tools.length > 0 ? openaiToolOptions?.parallelToolCalls : void 0,
-      ...buildOpenAITokenParams(
+      ...buildOpenAIParameters(
         modelIdForCompletePayload,
         request.config?.maxTokens ?? this.config.maxTokens,
-        request.config?.temperature ?? this.config.temperature
+        request.config?.temperature ?? this.config.temperature,
+        this.parameterOptions(request)
       ),
       response_format: toOpenAIResponseFormat(request.config?.responseFormat),
       stream: false
     };
     logProviderPayload("openai", "request payload", payload, request.debug);
-    const response = await client.chat.completions.create(payload);
+    const response = await client.chat.completions.create(payload, {
+      signal: request.signal
+    });
     logProviderPayload("openai", "response payload", response, request.debug);
     const choice = response.choices?.[0];
     const message = choice?.message;