@yourgpt/llm-sdk 2.5.1-beta.5 → 2.6.0-beta.0

package/dist/adapters/index.mjs

@@ -102,14 +102,19 @@ 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
     );
   }
+  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 normalized;
 }
 function isOpenAIReasoningModel(modelId) {
@@ -505,18 +510,79 @@ var OpenAIAdapter = class _OpenAIAdapter {
     return this.client;
   }
   shouldUseResponsesApi(request) {
-    return request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true && request.providerToolOptions.openai.nativeToolSearch.useResponsesApi !== false && Array.isArray(request.toolDefinitions) && request.toolDefinitions.length > 0;
+    const hasTools = Array.isArray(request.toolDefinitions) && request.toolDefinitions.length > 0;
+    if (!hasTools) return false;
+    if (request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true && request.providerToolOptions.openai.nativeToolSearch.useResponsesApi !== false) {
+      return true;
+    }
+    return this.requiresResponsesApiForTools(
+      request.config?.model || this.model
+    );
+  }
+  /**
+   * Whether this model rejects function tools on /v1/chat/completions.
+   *
+   * Applies to OpenAI proper only — the adapter is reused for OpenAI-compatible
+   * providers (Azure, xAI, Google, Fireworks) whose endpoints have no such
+   * restriction and may not implement /v1/responses at all.
+   */
+  requiresResponsesApiForTools(modelId) {
+    if (!modelId) return false;
+    if (!/^gpt-5\.(?:[4-9]|\d{2,})/i.test(modelId)) return false;
+    const baseUrl = this.config.baseUrl;
+    if (!baseUrl) return true;
+    try {
+      return new URL(baseUrl).hostname === "api.openai.com";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 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 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",
@@ -542,15 +608,67 @@ 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) {
+  /**
+   * 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,
@@ -565,10 +683,18 @@ 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,
@@ -591,59 +717,139 @@ 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 ?? []),
+      tools: this.buildResponsesTools(
+        request.toolDefinitions ?? [],
+        request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true,
+        this.buildResponsesWebSearchTool(request)
+      ),
       tool_choice: openaiToolOptions?.toolChoice === "required" ? "required" : openaiToolOptions?.toolChoice === "auto" ? "auto" : void 0,
       parallel_tool_calls: openaiToolOptions?.parallelToolCalls,
-      temperature: request.config?.temperature ?? this.config.temperature,
+      // Reasoning models reject `temperature` outright — sending it would swap one
+      // 400 for another. isOpenAIReasoningModel already encodes that family test.
+      ...isOpenAIReasoningModel(modelIdForPayload) ? {} : {
+        temperature: request.config?.temperature ?? this.config.temperature
+      },
       max_output_tokens: request.config?.maxTokens ?? this.config.maxTokens,
       ...responsesTextFormat ? { text: { format: responsesTextFormat } } : {},
-      stream: false
+      stream
     };
+    return payload;
+  }
+  async completeWithResponses(request) {
+    const client = await this.getClient();
+    const payload = this.buildResponsesPayload(request, false);
     logProviderPayload("openai", "request payload", payload, request.debug);
     const response = await client.responses.create(payload);
     logProviderPayload("openai", "response payload", response, request.debug);
     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();
+    const payload = this.buildResponsesPayload(request, true);
+    logProviderPayload("openai", "request payload", payload, request.debug);
+    const stream = await client.responses.create(payload);
+    const toolCalls = /* @__PURE__ */ new Map();
+    let usage;
+    const citations = [];
+    function* flushToolCalls() {
+      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) {
+      if (request.signal?.aborted) break;
+      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":
+        case "response.incomplete": {
+          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 "error":
+        case "response.failed":
+          throw new Error(
+            event.message ?? event.response?.error?.message ?? "Responses stream failed"
+          );
+      }
+    }
+    yield* flushToolCalls();
+    if (citations.length > 0) {
+      yield { type: "citation", citations: deduplicateCitations(citations) };
+    }
+    yield { type: "message:end" };
+    yield { type: "done", usage };
+  }
   async *stream(request) {
     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 {

package/dist/index.js

@@ -1052,6 +1052,14 @@ var StreamResult = class {
         }
         if (event.requiresAction) {
           collected.requiresAction = true;
+          const resolvedToolIds = new Set(
+            (event.messages ?? []).filter((m) => m.role === "tool" && m.tool_call_id).map((m) => m.tool_call_id)
+          );
+          if (resolvedToolIds.size > 0) {
+            collected.toolCalls = collected.toolCalls.filter(
+              (tc) => !resolvedToolIds.has(tc.id)
+            );
+          }
         }
         if (event.usage) {
           this.capturedUsage = event.usage;
@@ -2203,7 +2211,13 @@ var Runtime = class {
       // Not used when rawMessages is provided
       rawMessages: request.messages,
       actions: nativeToolSearch ? void 0 : this.convertToolsToActions(effectiveSelectedTools),
-      toolDefinitions: nativeToolSearch ? effectiveSelectedTools : void 0,
+      // Always supplied. `actions` drives the Chat Completions path; adapters
+      // that must use /v1/responses (native tool search, or gpt-5.4+ where
+      // Chat Completions rejects function tools alongside reasoning) need the
+      // richer ToolDefinition shape. Gating this on nativeToolSearch meant the
+      // reasoning-model route could never see any tools, so it silently never
+      // engaged and those requests still 400'd on Chat Completions.
+      toolDefinitions: effectiveSelectedTools,
       systemPrompt,
       config: request.config,
       signal,
@@ -2353,6 +2367,49 @@ var Runtime = class {
       const clientToolCalls = toolCalls.filter(
         (tc) => !serverToolIds.has(tc.id)
       );
+      const serverToolResultMessages = serverToolResults.map((tr) => {
+        const aiContent = buildToolResultForAI(tr.tool, tr.result, tr.args);
+        const content = typeof aiContent === "string" ? aiContent : JSON.stringify(serializeToolResultContent(aiContent));
+        return {
+          role: "tool",
+          content,
+          tool_call_id: tr.id
+        };
+      });
+      if (serverToolResults.length > 0 && clientToolCalls.length > 0) {
+        if (debug) {
+          console.log(
+            `[Copilot SDK] Mixed turn: ${serverToolResults.length} server + ${clientToolCalls.length} client tool(s). Suspending for client tools.`
+          );
+        }
+        const assistantMessage = {
+          role: "assistant",
+          content: accumulatedText || null,
+          tool_calls: toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.args)
+            },
+            ...tc.extra_content ? { extra_content: tc.extra_content } : {}
+          }))
+        };
+        newMessages.push(assistantMessage);
+        newMessages.push(...serverToolResultMessages);
+        yield {
+          type: "tool_calls",
+          toolCalls: clientToolCalls,
+          assistantMessage
+        };
+        yield {
+          type: "done",
+          requiresAction: true,
+          messages: newMessages,
+          usage: adapterUsage
+        };
+        return;
+      }
       if (serverToolResults.length > 0) {
         if (debug) {
           console.log(
@@ -2375,17 +2432,7 @@ var Runtime = class {
             };
           })
         };
-        const toolResultMessages = serverToolResults.map(
-          (tr) => {
-            const aiContent = buildToolResultForAI(tr.tool, tr.result, tr.args);
-            const content = typeof aiContent === "string" ? aiContent : JSON.stringify(serializeToolResultContent(aiContent));
-            return {
-              role: "tool",
-              content,
-              tool_call_id: tr.id
-            };
-          }
-        );
+        const toolResultMessages = serverToolResultMessages;
         newMessages.push(assistantWithToolCalls);
         newMessages.push(...toolResultMessages);
         const messagesWithResults = [
@@ -2532,7 +2579,13 @@ var Runtime = class {
         messages: [],
         rawMessages: conversationMessages,
         actions: nativeToolSearch ? void 0 : this.convertToolsToActions(effectiveSelectedTools),
-        toolDefinitions: nativeToolSearch ? effectiveSelectedTools : void 0,
+        // Always supplied. `actions` drives the Chat Completions path; adapters
+        // that must use /v1/responses (native tool search, or gpt-5.4+ where
+        // Chat Completions rejects function tools alongside reasoning) need the
+        // richer ToolDefinition shape. Gating this on nativeToolSearch meant the
+        // reasoning-model route could never see any tools, so it silently never
+        // engaged and those requests still 400'd on Chat Completions.
+        toolDefinitions: effectiveSelectedTools,
         systemPrompt,
         config: request.config,
         signal,
@@ -2640,6 +2693,48 @@ var Runtime = class {
               }
             }
           }
+          const serverToolResultMessages = serverToolResults.map((tr) => {
+            const aiContent = buildToolResultForAI(
+              tr.tool,
+              tr.result,
+              tr.args
+            );
+            const content = typeof aiContent === "string" ? aiContent : JSON.stringify(serializeToolResultContent(aiContent));
+            return {
+              role: "tool",
+              content,
+              tool_call_id: tr.id
+            };
+          });
+          if (serverToolResults.length > 0 && clientToolCalls.length > 0) {
+            const assistantMessage = {
+              role: "assistant",
+              content: result.content || null,
+              tool_calls: result.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                  name: tc.name,
+                  arguments: JSON.stringify(tc.args)
+                },
+                ...tc.extra_content ? { extra_content: tc.extra_content } : {}
+              }))
+            };
+            newMessages.push(assistantMessage);
+            newMessages.push(...serverToolResultMessages);
+            yield {
+              type: "tool_calls",
+              toolCalls: clientToolCalls,
+              assistantMessage
+            };
+            yield {
+              type: "done",
+              requiresAction: true,
+              messages: newMessages,
+              usage: accumulatedUsage.total_tokens > 0 ? accumulatedUsage : void 0
+            };
+            return;
+          }
           if (serverToolResults.length > 0) {
             const assistantWithToolCalls = {
               role: "assistant",
@@ -2654,19 +2749,7 @@ var Runtime = class {
                 ...tc.extra_content ? { extra_content: tc.extra_content } : {}
               }))
             };
-            const toolResultMessages = serverToolResults.map((tr) => {
-              const aiContent = buildToolResultForAI(
-                tr.tool,
-                tr.result,
-                tr.args
-              );
-              const content = typeof aiContent === "string" ? aiContent : JSON.stringify(serializeToolResultContent(aiContent));
-              return {
-                role: "tool",
-                content,
-                tool_call_id: tr.id
-              };
-            });
+            const toolResultMessages = serverToolResultMessages;
             newMessages.push(assistantWithToolCalls);
             newMessages.push(...toolResultMessages);
             conversationMessages = [
@@ -3005,10 +3088,23 @@ var Runtime = class {
               result: event.result || event.error
             });
             break;
-          case "done":
+          case "done": {
             messages = event.messages || [];
             requiresAction = event.requiresAction || false;
+            if (requiresAction) {
+              const resolvedToolIds = new Set(
+                messages.filter((m) => m.role === "tool" && m.tool_call_id).map((m) => m.tool_call_id)
+              );
+              if (resolvedToolIds.size > 0) {
+                for (let i = toolCalls.length - 1; i >= 0; i--) {
+                  if (resolvedToolIds.has(toolCalls[i].id)) {
+                    toolCalls.splice(i, 1);
+                  }
+                }
+              }
+            }
             break;
+          }
           case "error":
             error = { message: event.message, code: event.code };
             break;