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

package/dist/providers/openrouter/index.js

@@ -91,14 +91,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) {
@@ -527,18 +532,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",
@@ -564,15 +630,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,
@@ -587,10 +705,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,
@@ -613,59 +739,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 {