@yourgpt/llm-sdk 2.6.0-beta.1 → 2.6.0-beta.2

package/dist/providers/google/index.js

@@ -1,5 +1,108 @@
 'use strict';
 
+// src/core/tool-output.ts
+var imageTypes = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif"
+]);
+function normalizeToolOutput(value) {
+  const output = value;
+  if (output?.type !== "content" || !Array.isArray(output.content) || !output.content.length) {
+    throw new Error("Tool model output must contain a nonempty content array");
+  }
+  return {
+    type: "content",
+    content: output.content.map((part) => {
+      if (part?.type === "text" && typeof part.text === "string")
+        return { type: "text", text: part.text };
+      if (part?.type !== "image")
+        throw new Error("Unsupported tool output content type");
+      const sources = ["data", "url", "fileId"].filter((key) => key in part);
+      if (sources.length !== 1)
+        throw new Error(
+          "Tool image requires exactly one of data, url, or fileId"
+        );
+      if ("fileId" in part) {
+        if (part.provider !== "openai" || typeof part.fileId !== "string" || !part.fileId.trim())
+          throw new Error(
+            "Tool image file references must name the openai provider and fileId"
+          );
+        return { type: "image", fileId: part.fileId, provider: "openai" };
+      }
+      if ("url" in part) {
+        let url;
+        try {
+          url = new URL(part.url);
+        } catch {
+          throw new Error("Invalid tool image URL");
+        }
+        if (!["https:", "http:"].includes(url.protocol) || url.username || url.password)
+          throw new Error(
+            "Tool image URL must use HTTP(S) without credentials"
+          );
+        return { type: "image", url: url.href };
+      }
+      if (!("data" in part) || !imageTypes.has(part.mediaType))
+        throw new Error("Unsupported tool image media type");
+      let data = part.data instanceof Uint8Array ? Buffer.from(part.data).toString("base64") : part.data;
+      if (typeof data !== "string")
+        throw new Error("Tool image data must be base64 or bytes");
+      if (data.startsWith("data:")) {
+        const match = /^data:([^;,]+);base64,(.+)$/.exec(data);
+        if (!match || match[1] !== part.mediaType)
+          throw new Error(
+            "Tool image data URL media type does not match mediaType"
+          );
+        data = match[2];
+      }
+      if (!data.length || data.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(data))
+        throw new Error("Invalid tool image base64 data");
+      if (Buffer.byteLength(data, "base64") > 20 * 1024 * 1024)
+        throw new Error("Tool image exceeds 20 MiB");
+      if (Buffer.from(data, "base64").toString("base64") !== data)
+        throw new Error("Invalid tool image base64 data");
+      return { type: "image", data, mediaType: part.mediaType };
+    })
+  };
+}
+function toolOutputForProvider(value, provider) {
+  const output = normalizeToolOutput(value);
+  return output.content.map((part) => {
+    if (part.type === "text")
+      return {
+        type: provider === "responses" ? "input_text" : "text",
+        text: part.text
+      };
+    if (provider === "unsupported")
+      throw new Error(
+        "Image tool results require OpenAI Responses or Anthropic; this endpoint is not supported"
+      );
+    if ("fileId" in part) {
+      if (provider !== "responses")
+        throw new Error(
+          "OpenAI image file references cannot be sent to another provider"
+        );
+      return { type: "input_image", file_id: part.fileId, detail: "auto" };
+    }
+    if (provider === "responses")
+      return {
+        type: "input_image",
+        image_url: "url" in part ? part.url : `data:${part.mediaType};base64,${part.data}`,
+        detail: "auto"
+      };
+    return {
+      type: "image",
+      source: "url" in part ? { type: "url", url: part.url } : { type: "base64", media_type: part.mediaType, data: part.data }
+    };
+  });
+}
+function textToolOutput(value, fallback) {
+  if (value === void 0) return fallback;
+  return toolOutputForProvider(value, "unsupported").map((part) => part.text).join("\n");
+}
+
 // src/core/openai-parameters.ts
 function capabilities(model) {
   const gpt = /^gpt-(\d+)(?:\.(\d+))?(?:-(.+))?$/i.exec(model);
@@ -241,7 +344,7 @@ function messageToOpenAIContent(message) {
   }
   return blocks;
 }
-function formatMessagesForOpenAI(messages, systemPrompt) {
+function formatMessagesForOpenAI(messages, systemPrompt, preserveProviderMetadata = false) {
   const formatted = [];
   if (systemPrompt) {
     formatted.push({ role: "system", content: systemPrompt });
@@ -259,7 +362,8 @@ function formatMessagesForOpenAI(messages, systemPrompt) {
       const assistantMsg = {
         role: "assistant",
         // Gemini/xAI (OpenAI-compatible) reject content: "" on assistant messages with tool_calls
-        content: hasToolCalls ? msg.content || null : msg.content
+        content: hasToolCalls ? msg.content || null : msg.content,
+        ...preserveProviderMetadata && msg.providerMetadata ? { providerMetadata: msg.providerMetadata } : {}
       };
       if (hasToolCalls) {
         assistantMsg.tool_calls = msg.tool_calls;
@@ -268,7 +372,8 @@ function formatMessagesForOpenAI(messages, systemPrompt) {
     } else if (msg.role === "tool" && msg.tool_call_id) {
       formatted.push({
         role: "tool",
-        content: msg.content ?? "",
+        content: preserveProviderMetadata ? msg.content ?? "" : textToolOutput(msg.modelOutput, msg.content ?? ""),
+        ...preserveProviderMetadata && msg.modelOutput ? { modelOutput: msg.modelOutput } : {},
         tool_call_id: msg.tool_call_id
       });
     }
@@ -555,7 +660,7 @@ function formatMessagesForGoogle(messages) {
         return {
           role: "tool",
           tool_call_id: msg.toolCallId,
-          content: msg.content
+          content: textToolOutput(msg.modelOutput, msg.content)
         };
       default:
         return msg;
@@ -563,6 +668,64 @@ function formatMessagesForGoogle(messages) {
   });
 }
 
+// src/core/openai-responses.ts
+function resolveOpenAITransport(defaults, overrides) {
+  return {
+    api: overrides?.api ?? defaults.api ?? "auto",
+    responses: defaults.responses !== void 0 || overrides?.responses !== void 0 ? { ...defaults.responses, ...overrides?.responses } : void 0
+  };
+}
+function useOpenAIResponses(model, baseURL, parameters, transport, hasTools, hasReplay, nativeToolSearch = false) {
+  const api = transport.api ?? "auto";
+  if (!["auto", "chat", "responses"].includes(api)) {
+    throw new Error(`Unknown OpenAI API selection: ${api}`);
+  }
+  if (api === "chat") {
+    if (transport.responses !== void 0 || nativeToolSearch) {
+      throw new Error(
+        "Responses options and native tool search require the Responses API"
+      );
+    }
+    return false;
+  }
+  let officialEndpoint = !baseURL;
+  try {
+    officialEndpoint = !baseURL || new URL(baseURL).hostname === "api.openai.com";
+  } catch {
+  }
+  return api === "responses" || transport.responses !== void 0 || hasReplay && officialEndpoint || nativeToolSearch || hasTools && requiresOpenAIResponses(model, baseURL, parameters);
+}
+function responseMetadata(response) {
+  const output = Array.isArray(response?.output) ? response.output : [];
+  return {
+    openai: {
+      response: {
+        id: response?.id,
+        model: response?.model,
+        status: response?.status,
+        output,
+        usage: response?.usage,
+        store: response?.store,
+        refusals: output.flatMap(
+          (item) => item?.type === "message" && Array.isArray(item.content) ? item.content.filter(
+            (part) => part?.type === "refusal" && typeof part.refusal === "string"
+          ).map((part) => part.refusal) : []
+        )
+      }
+    }
+  };
+}
+function getResponseReplay(metadata) {
+  const response = metadata?.openai?.response;
+  if (response === void 0) return void 0;
+  if (!Array.isArray(response.output) || response.output.some((item) => !item || typeof item.type !== "string")) {
+    throw new Error(
+      "Invalid OpenAI Responses replay metadata: output must contain typed items"
+    );
+  }
+  return response.output;
+}
+
 // src/core/provider-error.ts
 function providerErrorEvent(error, code) {
   const details = error ?? {};
@@ -639,13 +802,16 @@ var OpenAIAdapter = class _OpenAIAdapter {
     }));
   }
   shouldUseResponsesApi(request) {
-    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(
+    return useOpenAIResponses(
       request.config?.model || this.model,
       this.config.baseUrl,
-      this.parameterOptions(request)
+      this.parameterOptions(request),
+      resolveOpenAITransport(this.config, request.config?.openai),
+      this.toolDefinitions(request).length > 0,
+      !!(request.rawMessages ?? request.messages)?.some(
+        (message) => message.providerMetadata?.openai?.response
+      ),
+      request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true && request.providerToolOptions.openai.nativeToolSearch.useResponsesApi !== false
     );
   }
   /**
@@ -678,11 +844,11 @@ var OpenAIAdapter = class _OpenAIAdapter {
     });
   }
   buildResponsesInput(request) {
-    const sourceMessages = request.rawMessages && request.rawMessages.length > 0 ? this.formatRawMessages(request.rawMessages) : formatMessagesForOpenAI(request.messages, void 0);
+    const sourceMessages = request.rawMessages && request.rawMessages.length > 0 ? this.formatRawMessages(request.rawMessages, true) : formatMessagesForOpenAI(request.messages, void 0, true);
     const input = [];
     for (const message of sourceMessages) {
       if (message.role === "system") {
-        if (!request.systemPrompt && message.content) {
+        if (message.content && message.content !== request.systemPrompt) {
           input.push({
             type: "message",
             role: "developer",
@@ -692,6 +858,11 @@ var OpenAIAdapter = class _OpenAIAdapter {
         continue;
       }
       if (message.role === "assistant") {
+        const replay = getResponseReplay(message.providerMetadata);
+        if (replay) {
+          input.push(...replay);
+          continue;
+        }
         const content = this.toResponsesContent(message.content, "assistant");
         if (typeof content === "string" ? content : Array.isArray(content) && content.length > 0) {
           input.push({
@@ -715,7 +886,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
         input.push({
           type: "function_call_output",
           call_id: message.tool_call_id,
-          output: typeof message.content === "string" ? message.content : JSON.stringify(message.content ?? null)
+          output: message.modelOutput ? toolOutputForProvider(message.modelOutput, "responses") : typeof message.content === "string" ? message.content : JSON.stringify(message.content ?? null)
         });
         continue;
       }
@@ -729,10 +900,12 @@ var OpenAIAdapter = class _OpenAIAdapter {
     return input;
   }
   /** Preserve Copilot screenshot attachments on every OpenAI transport. */
-  formatRawMessages(messages) {
+  formatRawMessages(messages, preserveProviderMetadata = false) {
     return messages.map((message) => {
-      const { attachments, ...rest } = message;
-      let content = message.content;
+      const { attachments, providerMetadata, modelOutput, ...rest } = message;
+      let content = message.role === "tool" && !preserveProviderMetadata ? textToolOutput(modelOutput, String(message.content ?? "")) : message.content;
+      if (preserveProviderMetadata && modelOutput)
+        rest.modelOutput = modelOutput;
       if (message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0 && content === "") {
         content = null;
       }
@@ -745,7 +918,11 @@ var OpenAIAdapter = class _OpenAIAdapter {
           content = [...parts, ...images];
         }
       }
-      return { ...rest, content };
+      return {
+        ...rest,
+        content,
+        ...preserveProviderMetadata && providerMetadata ? { providerMetadata } : {}
+      };
     });
   }
   /**
@@ -826,14 +1003,25 @@ var OpenAIAdapter = class _OpenAIAdapter {
       ).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: JSON.parse(item.arguments ?? "{}")
-    })) : [];
+    const seenCallIds = /* @__PURE__ */ new Set();
+    const toolCalls = Array.isArray(response?.output) ? response.output.filter((item) => item?.type === "function_call").map((item) => {
+      if (typeof item.call_id !== "string" || !item.call_id || typeof item.name !== "string" || !item.name || typeof item.arguments !== "string" || item.status && item.status !== "completed") {
+        throw new Error("Responses contains an incomplete function call");
+      }
+      if (seenCallIds.has(item.call_id))
+        throw new Error("Responses contains duplicate function call IDs");
+      seenCallIds.add(item.call_id);
+      const args = JSON.parse(item.arguments);
+      if (!args || typeof args !== "object" || Array.isArray(args))
+        throw new Error(
+          "Responses function arguments must be a JSON object"
+        );
+      return { id: item.call_id, name: item.name, args };
+    }) : [];
     return {
       content,
       toolCalls,
+      providerMetadata: responseMetadata(response),
       usage: response?.usage ? {
         promptTokens: response.usage.input_tokens ?? 0,
         completionTokens: response.usage.output_tokens ?? 0,
@@ -844,6 +1032,17 @@ var OpenAIAdapter = class _OpenAIAdapter {
   }
   buildResponsesPayload(request, stream) {
     const openaiToolOptions = request.providerToolOptions?.openai;
+    const options = resolveOpenAITransport(
+      this.config,
+      request.config?.openai
+    ).responses;
+    const parameters = buildOpenAIParameters(
+      request.config?.model || this.model,
+      request.config?.maxTokens ?? this.config.maxTokens,
+      request.config?.temperature ?? this.config.temperature,
+      this.parameterOptions(request),
+      "responses"
+    );
     const responsesTextFormat = toOpenAIResponsesTextFormat(
       request.config?.responseFormat
     );
@@ -859,13 +1058,26 @@ var OpenAIAdapter = class _OpenAIAdapter {
       ),
       tool_choice: openaiToolOptions?.toolChoice,
       parallel_tool_calls: openaiToolOptions?.parallelToolCalls,
-      ...buildOpenAIParameters(
-        modelIdForPayload,
-        request.config?.maxTokens ?? this.config.maxTokens,
-        request.config?.temperature ?? this.config.temperature,
-        this.parameterOptions(request),
-        "responses"
-      ),
+      ...parameters,
+      ...options?.reasoningSummary ? {
+        reasoning: {
+          ...parameters.reasoning,
+          summary: options.reasoningSummary
+        }
+      } : {},
+      ...options?.store !== void 0 ? { store: options.store } : {},
+      ...options?.previousResponseId !== void 0 ? { previous_response_id: options.previousResponseId } : {},
+      ...options?.promptCacheKey !== void 0 ? { prompt_cache_key: options.promptCacheKey } : {},
+      ...options?.promptCacheOptions !== void 0 ? { prompt_cache_options: options.promptCacheOptions } : {},
+      ...options?.promptCacheRetention !== void 0 ? { prompt_cache_retention: options.promptCacheRetention } : {},
+      ...options?.store === false || options?.include ? {
+        include: [
+          .../* @__PURE__ */ new Set([
+            ...options?.include ?? [],
+            ...options?.store === false ? ["reasoning.encrypted_content"] : []
+          ])
+        ]
+      } : {},
       ...responsesTextFormat ? { text: { format: responsesTextFormat } } : {},
       stream
     };
@@ -924,6 +1136,10 @@ var OpenAIAdapter = class _OpenAIAdapter {
     let usage;
     const citations = [];
     let completed = false;
+    let terminalResponse;
+    let responseIdentity = {};
+    const outputItems = /* @__PURE__ */ new Map();
+    let streamedText = "";
     function* flushToolCalls() {
       for (const call of toolCalls.values()) {
         if (!call.name)
@@ -940,17 +1156,36 @@ var OpenAIAdapter = class _OpenAIAdapter {
     for await (const event of stream) {
       throwIfAborted(request.signal);
       logProviderPayload("openai", "stream chunk", event, request.debug);
+      if (completed)
+        throw new Error("Responses stream emitted an event after completion");
       const index = event?.output_index ?? 0;
       switch (event?.type) {
+        case "response.created":
+          responseIdentity = {
+            id: event.response?.id,
+            model: event.response?.model
+          };
+          break;
+        case "response.output_item.done":
+          if (event.item) outputItems.set(index, event.item);
+          if (event.item?.type === "function_call") {
+            toolCalls.set(index, {
+              id: event.item.call_id,
+              name: event.item.name,
+              arguments: event.item.arguments
+            });
+          }
+          break;
         case "response.output_text.delta":
           if (event.delta) {
+            streamedText += 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(),
+              id: event.item.call_id ?? "",
               name: event.item.name ?? "",
               arguments: event.item.arguments ?? ""
             });
@@ -969,7 +1204,10 @@ var OpenAIAdapter = class _OpenAIAdapter {
           break;
         }
         case "response.completed": {
+          if (event.response?.status && event.response.status !== "completed")
+            throw new Error(`Responses stream ${event.response.status}`);
           completed = true;
+          terminalResponse = { ...responseIdentity, ...event.response };
           const found = this.collectResponsesCitations(
             event.response?.output,
             citations.length
@@ -1006,12 +1244,64 @@ var OpenAIAdapter = class _OpenAIAdapter {
     throwIfAborted(request.signal);
     if (!completed)
       throw new Error("Responses stream ended without a completed response");
+    const output = terminalResponse.output?.length ? terminalResponse.output : [...outputItems.entries()].sort(([a], [b]) => a - b).map(([, item]) => item);
+    if (output.some((item) => item.type === "function_call"))
+      toolCalls.clear();
+    for (const [index, item] of output.entries()) {
+      if (item.type === "function_call") {
+        toolCalls.set(index, {
+          id: item.call_id,
+          name: item.name,
+          arguments: item.arguments
+        });
+      }
+    }
+    const uniqueCalls = /* @__PURE__ */ new Map();
+    for (const call of toolCalls.values()) {
+      if (!call.id || !call.name)
+        throw new Error("Responses stream contains an incomplete tool call");
+      uniqueCalls.set(call.id, call);
+    }
+    toolCalls.clear();
+    [...uniqueCalls.values()].forEach(
+      (call, index) => toolCalls.set(index, call)
+    );
+    if (!output.length && toolCalls.size) {
+      for (const call of toolCalls.values())
+        output.push({
+          type: "function_call",
+          call_id: call.id,
+          name: call.name,
+          arguments: call.arguments
+        });
+    }
+    if (!output.length && streamedText)
+      output.push({
+        type: "message",
+        role: "assistant",
+        content: [{ type: "output_text", text: streamedText, annotations: [] }]
+      });
+    terminalResponse.output = output;
+    const finalText = this.parseResponsesResult(terminalResponse).content;
+    if (finalText.startsWith(streamedText) && finalText.length > streamedText.length) {
+      yield {
+        type: "message:delta",
+        content: finalText.slice(streamedText.length)
+      };
+    }
     yield* flushToolCalls();
     if (citations.length > 0) {
       yield { type: "citation", citations: deduplicateCitations(citations) };
     }
-    yield { type: "message:end" };
-    yield { type: "done", usage };
+    yield {
+      type: "message:end",
+      providerMetadata: responseMetadata(terminalResponse)
+    };
+    yield {
+      type: "done",
+      usage,
+      providerMetadata: responseMetadata(terminalResponse)
+    };
   }
   async *stream(request) {
     throwIfAborted(request.signal);