@standardagents/builder 0.11.4 → 0.11.6

package/dist/built-in-routes.js

@@ -2721,6 +2721,8 @@ var init_ToolExecutor = __esm({
             parentMessageId: toolMessageId,
             // Set depth one level deeper than parent
             depth: state.depth + 1,
+            // Extend promptPath with the sub-prompt name
+            promptPath: [...state.promptPath, promptDef.name],
             // Additional messages to inject
             extraMessages
           }, true);
@@ -2749,7 +2751,7 @@ var init_ToolExecutor = __esm({
             reader.releaseLock();
           }
           const childToolMessagesResult = await state.storage.sql.exec(
-            `SELECT id, content, tool_status, tool_call_id FROM messages WHERE parent_id = ? AND role = 'tool'`,
+            `SELECT id, content, tool_status, tool_call_id, name FROM messages WHERE parent_id = ? AND role = 'tool'`,
             toolMessageId
           );
           const childToolRows = childToolMessagesResult.toArray();
@@ -2781,33 +2783,64 @@ var init_ToolExecutor = __esm({
           if (toolResponseOptions.include_text_response && textContent) {
             responseParts.push(textContent);
           }
-          if (toolResponseOptions.include_tool_calls || toolResponseOptions.include_errors) {
-            const childAssistantMessagesResult = await state.storage.sql.exec(
-              `SELECT id, tool_calls FROM messages WHERE parent_id = ? AND role = 'assistant' AND tool_calls IS NOT NULL`,
-              toolMessageId
-            );
-            const childAssistantRows = childAssistantMessagesResult.toArray();
-            const toolCallsSummary = [];
-            if (toolResponseOptions.include_tool_calls && childAssistantRows.length > 0) {
-              for (const row of childAssistantRows) {
-                const toolCalls = JSON.parse(row.tool_calls);
-                for (const tc of toolCalls) {
-                  toolCallsSummary.push(
-                    `Tool Call: ${tc.function.name}(${tc.function.arguments})`
-                  );
-                }
-              }
-            }
+          if (overallStatus === "error") {
+            const failedTools = [];
+            const successfulToolNames = [];
             for (const row of childToolRows) {
-              const isError = row.content?.startsWith("Error: ");
-              if (isError && toolResponseOptions.include_errors || !isError && toolResponseOptions.include_tool_calls) {
-                toolCallsSummary.push(`Tool Response: ${row.content}`);
+              const toolName = row.name || "unknown_tool";
+              const isError = row.tool_status === "error";
+              if (isError) {
+                failedTools.push({
+                  name: toolName,
+                  content: row.content
+                });
+              } else {
+                successfulToolNames.push(toolName);
               }
             }
-            if (toolCallsSummary.length > 0) {
-              responseParts.push(
-                "Tool Executions:\n" + toolCallsSummary.join("\n")
+            if (toolResponseOptions.include_errors && failedTools.length > 0) {
+              const errorLines = failedTools.map((tool2) => {
+                let errorMsg = tool2.content;
+                if (errorMsg.startsWith("Failed to execute tool: ")) {
+                  errorMsg = errorMsg.substring("Failed to execute tool: ".length);
+                }
+                return `  ${tool2.name}: ${errorMsg}`;
+              });
+              responseParts.push(`Sub-prompt failed with ${failedTools.length} error(s):
+${errorLines.join("\n")}`);
+            }
+            if (toolResponseOptions.include_tool_calls && successfulToolNames.length > 0) {
+              responseParts.push(`Completed successfully: ${successfulToolNames.join(", ")}`);
+            }
+          } else {
+            if (toolResponseOptions.include_tool_calls || toolResponseOptions.include_errors) {
+              const childAssistantMessagesResult = await state.storage.sql.exec(
+                `SELECT id, tool_calls FROM messages WHERE parent_id = ? AND role = 'assistant' AND tool_calls IS NOT NULL`,
+                toolMessageId
               );
+              const childAssistantRows = childAssistantMessagesResult.toArray();
+              const toolCallsSummary = [];
+              if (toolResponseOptions.include_tool_calls && childAssistantRows.length > 0) {
+                for (const row of childAssistantRows) {
+                  const toolCalls = JSON.parse(row.tool_calls);
+                  for (const tc of toolCalls) {
+                    toolCallsSummary.push(
+                      `Tool Call: ${tc.function.name}(${tc.function.arguments})`
+                    );
+                  }
+                }
+              }
+              for (const row of childToolRows) {
+                const isError = row.content?.startsWith("Error: ");
+                if (isError && toolResponseOptions.include_errors || !isError && toolResponseOptions.include_tool_calls) {
+                  toolCallsSummary.push(`Tool Response: ${row.content}`);
+                }
+              }
+              if (toolCallsSummary.length > 0) {
+                responseParts.push(
+                  "Tool Executions:\n" + toolCallsSummary.join("\n")
+                );
+              }
             }
           }
           const finalResponse = responseParts.length > 0 ? responseParts.join("\n\n") : "Prompt executed successfully";
@@ -4767,6 +4800,8 @@ var init_FlowEngine = __esm({
           parentMessageId: stateInput.parentMessageId,
           depth: stateInput.depth ?? 0,
           // Default to 0 for top-level prompts
+          // Initialize promptPath from input or create new path with current prompt name
+          promptPath: stateInput.promptPath ?? [sideAPrompt.name],
           pendingMessageId: stateInput.pendingMessageId,
           abortController: stateInput.abortController,
           allowedTools: stateInput.allowedTools,
@@ -4970,6 +5005,7 @@ var init_FlowEngine = __esm({
           state.extraMessages = [];
           state.currentSide = "a";
           state.prompt = state.prompts.sideA;
+          state.promptPath = [sideAPrompt.name];
           state.pendingHandoff = void 0;
           state.emitTelemetry?.({
             type: "agent_handoff",
@@ -7215,6 +7251,9 @@ var init_ThreadStateImpl = __esm({
           metadata: void 0
         }));
       }
+      get promptPath() {
+        return this._flowState.promptPath;
+      }
       forceTurn(side) {
         this._flowState.forcedNextSide = side === "a" ? "side_a" : "side_b";
       }
@@ -20350,6 +20389,546 @@ async function fetchGenerationMetadata(apiKey, generationId, baseUrl = "https://
   }
   return null;
 }
+function transformChatContentPart(part) {
+  if (part.type === "text") {
+    return { type: "text", text: part.text };
+  }
+  if (part.type === "image") {
+    const data = part.data || "";
+    const imageUrl = data.startsWith("data:") ? data : `data:${part.mediaType || "image/png"};base64,${data}`;
+    return {
+      type: "image_url",
+      image_url: {
+        url: imageUrl,
+        detail: part.detail || "auto"
+      }
+    };
+  }
+  if (part.type === "image_url") {
+    return {
+      type: "image_url",
+      image_url: {
+        url: part.image_url?.url || "",
+        detail: part.image_url?.detail || "auto"
+      }
+    };
+  }
+  return {
+    type: "text",
+    text: `[File: ${part.filename || "file"}]`
+  };
+}
+function transformChatMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map(transformChatContentPart);
+}
+function transformChatSystemMessage(msg) {
+  return {
+    role: "system",
+    content: msg.content
+  };
+}
+function transformChatUserMessage(msg) {
+  return {
+    role: "user",
+    content: transformChatMessageContent(msg.content)
+  };
+}
+function transformChatAssistantMessage(msg) {
+  const message = {
+    role: "assistant",
+    content: msg.content || null
+  };
+  if (msg.toolCalls && msg.toolCalls.length > 0) {
+    message.tool_calls = msg.toolCalls.map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: {
+        name: tc.name,
+        arguments: typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments)
+      }
+    }));
+  }
+  return message;
+}
+function transformChatToolMessage(msg) {
+  let output;
+  if (typeof msg.content === "string") {
+    output = msg.content;
+  } else if ("type" in msg.content) {
+    if (msg.content.type === "text") {
+      output = msg.content.text;
+    } else if (msg.content.type === "error") {
+      output = `Error: ${msg.content.error}`;
+    } else {
+      output = JSON.stringify(msg.content);
+    }
+  } else {
+    output = JSON.stringify(msg.content);
+  }
+  const imageAttachments = msg.attachments?.filter((a) => a.type === "image" && a.data) || [];
+  const toolMessage = {
+    role: "tool",
+    tool_call_id: msg.toolCallId,
+    content: output || (imageAttachments.length > 0 ? "Success" : "")
+  };
+  if (imageAttachments.length === 0) {
+    return { toolMessage };
+  }
+  const imageContent = [];
+  const toolName = msg.toolName || "the tool";
+  const isSingle = imageAttachments.length === 1;
+  const descriptor = isSingle ? "the file" : `${imageAttachments.length} files`;
+  const verb = isSingle ? "is" : "are";
+  imageContent.push({
+    type: "text",
+    text: `Here ${verb} ${descriptor} from ${toolName}:`
+  });
+  for (const attachment of imageAttachments) {
+    const attachmentData = attachment.data || "";
+    const imageData = attachmentData.startsWith("data:") ? attachmentData : `data:${attachment.mediaType || "image/png"};base64,${attachmentData}`;
+    imageContent.push({
+      type: "image_url",
+      image_url: {
+        url: imageData,
+        detail: "auto"
+      }
+    });
+  }
+  const syntheticUserMessage = {
+    role: "user",
+    content: imageContent
+  };
+  return { toolMessage, syntheticUserMessage };
+}
+function transformChatMessages(messages) {
+  const result = [];
+  for (const msg of messages) {
+    switch (msg.role) {
+      case "system":
+        result.push(transformChatSystemMessage(msg));
+        break;
+      case "user":
+        result.push(transformChatUserMessage(msg));
+        break;
+      case "assistant":
+        result.push(transformChatAssistantMessage(msg));
+        break;
+      case "tool": {
+        const { toolMessage, syntheticUserMessage } = transformChatToolMessage(msg);
+        result.push(toolMessage);
+        if (syntheticUserMessage) {
+          result.push(syntheticUserMessage);
+        }
+        break;
+      }
+    }
+  }
+  return result;
+}
+function transformChatTool(tool2) {
+  const inputParams = tool2.function.parameters;
+  let parameters;
+  if (inputParams && typeof inputParams === "object") {
+    parameters = {
+      ...inputParams,
+      additionalProperties: false
+    };
+  } else {
+    parameters = {
+      type: "object",
+      properties: {},
+      required: [],
+      additionalProperties: false
+    };
+  }
+  return {
+    type: "function",
+    function: {
+      name: tool2.function.name,
+      description: tool2.function.description || void 0,
+      parameters,
+      strict: true
+    }
+  };
+}
+function transformChatTools(tools) {
+  return tools.map(transformChatTool);
+}
+function transformChatToolChoice(choice) {
+  if (choice === "auto") {
+    return "auto";
+  }
+  if (choice === "none") {
+    return "none";
+  }
+  if (choice === "required") {
+    return "required";
+  }
+  if (typeof choice === "object" && "name" in choice) {
+    return { type: "function", function: { name: choice.name } };
+  }
+  return void 0;
+}
+function mapChatFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "tool_calls":
+      return "tool_calls";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content_filter";
+    case "error":
+      return "error";
+    default:
+      return "stop";
+  }
+}
+function extractChatToolCalls(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0) {
+    return void 0;
+  }
+  return toolCalls.map((tc) => {
+    let parsedArgs = {};
+    try {
+      parsedArgs = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+    } catch {
+    }
+    return {
+      id: tc.id,
+      name: tc.function.name,
+      arguments: parsedArgs
+    };
+  });
+}
+function transformChatUsage(usage, actualProvider) {
+  if (!usage) {
+    return {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0
+    };
+  }
+  const promptTokens = usage.native_tokens_prompt || usage.prompt_tokens || 0;
+  const completionTokens = usage.native_tokens_completion || usage.completion_tokens || 0;
+  const totalTokens = usage.total_tokens || promptTokens + completionTokens;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    reasoningTokens: usage.completion_tokens_details?.reasoning_tokens,
+    cachedTokens: usage.prompt_tokens_details?.cached_tokens,
+    cost: usage.cost,
+    provider: actualProvider
+  };
+}
+function extractImageFromUrl(url, index) {
+  if (url.startsWith("data:")) {
+    const match2 = url.match(/^data:([^;]+);base64,(.+)$/);
+    if (match2) {
+      return {
+        id: `image_${index}`,
+        data: match2[2],
+        // base64 data without prefix
+        mediaType: match2[1]
+      };
+    }
+    return {
+      id: `image_${index}`,
+      data: url,
+      mediaType: "image/png"
+    };
+  }
+  return {
+    id: `image_${index}`,
+    data: url,
+    mediaType: "image/png"
+    // Default; actual type unknown without fetching
+  };
+}
+function extractChatImages(images) {
+  if (!images || images.length === 0) {
+    return void 0;
+  }
+  return images.map((img, index) => extractImageFromUrl(img.image_url.url, index));
+}
+function transformChatResponse(response) {
+  const choice = response.choices?.[0];
+  const message = choice?.message;
+  const content = message?.content || null;
+  const toolCalls = extractChatToolCalls(message?.tool_calls);
+  const images = extractChatImages(message?.images);
+  const actualProvider = response.model?.split("/")[0] || void 0;
+  return {
+    content,
+    toolCalls,
+    images,
+    finishReason: mapChatFinishReason(choice?.finish_reason),
+    usage: transformChatUsage(response.usage, actualProvider),
+    metadata: {
+      model: response.model,
+      provider: "openrouter",
+      actualProvider,
+      requestId: response.id
+    }
+  };
+}
+function createChatStreamState() {
+  return {
+    content: "",
+    toolCalls: /* @__PURE__ */ new Map(),
+    images: [],
+    reasoningContent: "",
+    hasContent: false,
+    hasReasoning: false,
+    finishReason: null
+  };
+}
+function processChatStreamChunk(chunk, state) {
+  const chunks = [];
+  const choice = chunk.choices?.[0];
+  const delta = choice?.delta;
+  if (!delta && !choice?.finish_reason && !chunk.usage) {
+    return chunks;
+  }
+  if (delta?.content) {
+    state.hasContent = true;
+    state.content += delta.content;
+    chunks.push({ type: "content-delta", delta: delta.content });
+  }
+  if (delta?.reasoning_content) {
+    state.hasReasoning = true;
+    state.reasoningContent += delta.reasoning_content;
+    chunks.push({ type: "reasoning-delta", delta: delta.reasoning_content });
+  }
+  if (delta?.tool_calls) {
+    for (const tc of delta.tool_calls) {
+      const index = tc.index;
+      const existing = state.toolCalls.get(index);
+      if (tc.id && tc.function?.name) {
+        state.toolCalls.set(index, {
+          id: tc.id,
+          name: tc.function.name,
+          arguments: tc.function.arguments || ""
+        });
+        chunks.push({
+          type: "tool-call-start",
+          id: tc.id,
+          name: tc.function.name
+        });
+      } else if (existing && tc.function?.arguments) {
+        existing.arguments += tc.function.arguments;
+        chunks.push({
+          type: "tool-call-delta",
+          id: existing.id,
+          argumentsDelta: tc.function.arguments
+        });
+      }
+    }
+  }
+  if (delta?.images && delta.images.length > 0) {
+    for (const img of delta.images) {
+      const index = state.images.length;
+      const providerImage = extractImageFromUrl(img.image_url.url, index);
+      state.images.push(providerImage);
+      chunks.push({
+        type: "image-done",
+        index,
+        image: providerImage
+      });
+    }
+  }
+  if (choice?.finish_reason) {
+    state.finishReason = choice.finish_reason;
+    if (state.hasContent) {
+      chunks.push({ type: "content-done" });
+    }
+    if (state.hasReasoning) {
+      chunks.push({ type: "reasoning-done" });
+    }
+    for (const tc of state.toolCalls.values()) {
+      let parsedArgs = {};
+      try {
+        parsedArgs = tc.arguments ? JSON.parse(tc.arguments) : {};
+      } catch {
+      }
+      chunks.push({
+        type: "tool-call-done",
+        id: tc.id,
+        arguments: parsedArgs
+      });
+    }
+  }
+  if (chunk.usage) {
+    const actualProvider = chunk.model?.split("/")[0] || void 0;
+    chunks.push({
+      type: "finish",
+      finishReason: mapChatFinishReason(state.finishReason),
+      usage: transformChatUsage(chunk.usage, actualProvider),
+      responseId: chunk.id
+    });
+  }
+  return chunks;
+}
+function parseChatStreamEvent(jsonStr) {
+  try {
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
+  }
+}
+async function* parseChatSSEStream(response, state) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No response body");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith(":")) continue;
+        if (trimmed.startsWith("data: ")) {
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") continue;
+          const chunk = parseChatStreamEvent(data);
+          if (chunk) {
+            const providerChunks = processChatStreamChunk(chunk, state);
+            for (const c of providerChunks) {
+              yield c;
+            }
+          }
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const trimmed = buffer.trim();
+      if (trimmed.startsWith("data: ")) {
+        const data = trimmed.slice(6);
+        if (data !== "[DONE]") {
+          const chunk = parseChatStreamEvent(data);
+          if (chunk) {
+            const providerChunks = processChatStreamChunk(chunk, state);
+            for (const c of providerChunks) {
+              yield c;
+            }
+          }
+        }
+      }
+    }
+    if (state.finishReason && !state.toolCalls.size) {
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function buildChatParams(request) {
+  const messages = transformChatMessages(request.messages);
+  const params = {
+    model: request.model,
+    messages
+  };
+  if (request.tools && request.tools.length > 0) {
+    params.tools = transformChatTools(request.tools);
+    const toolChoice = transformChatToolChoice(request.toolChoice);
+    if (toolChoice !== void 0) {
+      params.tool_choice = toolChoice;
+    }
+    if (request.parallelToolCalls !== void 0) {
+      params.parallel_tool_calls = request.parallelToolCalls;
+    }
+  }
+  if (request.maxOutputTokens !== void 0) {
+    params.max_tokens = request.maxOutputTokens;
+  }
+  if (request.temperature !== void 0) {
+    params.temperature = request.temperature;
+  }
+  if (request.topP !== void 0) {
+    params.top_p = request.topP;
+  }
+  if (request.reasoning?.level !== void 0) {
+    const effortMap = {
+      10: "minimal",
+      33: "low",
+      66: "medium",
+      100: "high"
+    };
+    const effort = effortMap[request.reasoning.level];
+    if (effort) {
+      params.reasoning = { effort };
+    }
+  }
+  if (request.responseFormat) {
+    if (request.responseFormat.type === "json") {
+      if (request.responseFormat.schema) {
+        params.response_format = {
+          type: "json_schema",
+          json_schema: {
+            name: "response",
+            schema: request.responseFormat.schema,
+            strict: true
+          }
+        };
+      } else {
+        params.response_format = { type: "json_object" };
+      }
+    }
+  }
+  if (request.providerOptions) {
+    const { _metadata, ...safeOptions } = request.providerOptions;
+    Object.assign(params, safeOptions);
+  }
+  return params;
+}
+function createChatErrorChunk(error, code) {
+  return { type: "error", error, code };
+}
+function isBase64Like22(str) {
+  if (str.startsWith("data:")) return true;
+  if (str.length > 200) {
+    const base64Pattern = /^[A-Za-z0-9+/]+=*$/;
+    return base64Pattern.test(str.substring(0, 200));
+  }
+  return false;
+}
+function truncateBase64String22(str, maxLength = 50) {
+  if (str.length <= maxLength) return str;
+  const preview = str.substring(0, maxLength);
+  return `${preview}...[truncated, ${str.length.toLocaleString()} chars]`;
+}
+function truncateChatBase64(obj, maxLength = 50) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj === "string") {
+    if (isBase64Like22(obj)) {
+      return truncateBase64String22(obj, maxLength);
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => truncateChatBase64(item, maxLength));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = truncateChatBase64(value, maxLength);
+    }
+    return result;
+  }
+  return obj;
+}
 function svgToDataUri2(svg) {
   const encoded = encodeURIComponent(svg).replace(/'/g, "%27").replace(/"/g, "%22");
   return `data:image/svg+xml,${encoded}`;
@@ -20481,6 +21060,17 @@ var init_dist2 = __esm({
       constructor(config) {
         this.config = config;
       }
+      /**
+       * Determine which API to use for a request.
+       * Checks request-level providerOptions first, then falls back to config.
+       * Defaults to Chat Completions (stable API).
+       */
+      getApiMode(request) {
+        if (request?.providerOptions?.useResponsesApi === true) {
+          return "responses";
+        }
+        return "chat";
+      }
       async getClient() {
         if (!this.client) {
           const { OpenRouter: OpenRouter2 } = await Promise.resolve().then(() => (init_esm(), esm_exports));
@@ -20617,6 +21207,53 @@ var init_dist2 = __esm({
       // Generation Methods
       // ============================================================================
       async generate(request) {
+        const apiMode = this.getApiMode(request);
+        if (apiMode === "responses") {
+          return this.generateWithResponses(request);
+        }
+        return this.generateWithChat(request);
+      }
+      /**
+       * Generate using the Chat Completions API (default).
+       */
+      async generateWithChat(request) {
+        const apiKey = this.config.apiKey;
+        const baseUrl = this.config.baseUrl || "https://openrouter.ai/api/v1";
+        try {
+          const params = buildChatParams(request);
+          if (this.config.providers && this.config.providers.length > 0) {
+            params.provider = { only: this.config.providers };
+          }
+          const response = await fetch(`${baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${apiKey}`
+            },
+            body: JSON.stringify(params),
+            signal: request.signal
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            let errorMessage = `OpenRouter API error: ${response.status}`;
+            try {
+              const errorJson = JSON.parse(errorText);
+              errorMessage = errorJson.error?.message || errorJson.message || errorMessage;
+            } catch {
+              errorMessage = errorText || errorMessage;
+            }
+            throw new ProviderError(errorMessage, "invalid_request", response.status);
+          }
+          const data = await response.json();
+          return transformChatResponse(data);
+        } catch (error) {
+          throw this.toProviderError(error);
+        }
+      }
+      /**
+       * Generate using the Responses API (beta).
+       */
+      async generateWithResponses(request) {
         const client = await this.getClient();
         try {
           const params = buildCreateParams2(request);
@@ -20633,6 +21270,87 @@ var init_dist2 = __esm({
         }
       }
       async stream(request) {
+        const apiMode = this.getApiMode(request);
+        if (apiMode === "responses") {
+          return this.streamWithResponses(request);
+        }
+        return this.streamWithChat(request);
+      }
+      /**
+       * Stream using the Chat Completions API (default).
+       */
+      async streamWithChat(request) {
+        const self = this;
+        const apiKey = this.config.apiKey;
+        const baseUrl = this.config.baseUrl || "https://openrouter.ai/api/v1";
+        try {
+          const params = buildChatParams(request);
+          if (this.config.providers && this.config.providers.length > 0) {
+            params.provider = { only: this.config.providers };
+          }
+          const response = await fetch(`${baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${apiKey}`
+            },
+            body: JSON.stringify({
+              ...params,
+              stream: true,
+              stream_options: { include_usage: true }
+            }),
+            signal: request.signal
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            let errorMessage = `OpenRouter API error: ${response.status}`;
+            try {
+              const errorJson = JSON.parse(errorText);
+              errorMessage = errorJson.error?.message || errorJson.message || errorMessage;
+            } catch {
+              errorMessage = errorText || errorMessage;
+            }
+            throw new ProviderError(errorMessage, "invalid_request", response.status);
+          }
+          return {
+            async *[Symbol.asyncIterator]() {
+              const state = createChatStreamState();
+              let finishChunk = null;
+              let responseId = null;
+              try {
+                for await (const chunk of parseChatSSEStream(response, state)) {
+                  if (chunk.type === "finish") {
+                    finishChunk = chunk;
+                    responseId = chunk.responseId || null;
+                  } else {
+                    yield chunk;
+                  }
+                }
+                if (finishChunk) {
+                  const finishWithMeta = {
+                    ...finishChunk,
+                    _asyncMetadata: responseId ? {
+                      generationId: responseId,
+                      apiKey,
+                      baseUrl
+                    } : void 0
+                  };
+                  yield finishWithMeta;
+                }
+              } catch (error) {
+                const providerError = self.toProviderError(error);
+                yield createChatErrorChunk(providerError.message, providerError.code);
+              }
+            }
+          };
+        } catch (error) {
+          throw this.toProviderError(error);
+        }
+      }
+      /**
+       * Stream using the Responses API (beta).
+       */
+      async streamWithResponses(request) {
         const self = this;
         const apiKey = this.config.apiKey;
         const baseUrl = this.config.baseUrl || "https://openrouter.ai/api/v1";
@@ -20765,19 +21483,33 @@ var init_dist2 = __esm({
       // Inspection
       // ============================================================================
       /**
-       * Transform a ProviderRequest to OpenRouter Responses API format for inspection.
+       * Transform a ProviderRequest to the appropriate API format for inspection.
        * Returns the exact request body that would be sent to OpenRouter, with base64 data truncated.
        */
       async inspectRequest(request) {
-        const params = buildCreateParams2(request);
+        const apiMode = this.getApiMode(request);
+        if (apiMode === "responses") {
+          const params2 = buildCreateParams2(request);
+          if (this.config.providers && this.config.providers.length > 0) {
+            params2.provider = { only: this.config.providers };
+          }
+          return {
+            body: truncateBase642(params2),
+            messagesPath: "input",
+            metadata: {
+              endpoint: "https://openrouter.ai/api/v1/responses"
+            }
+          };
+        }
+        const params = buildChatParams(request);
         if (this.config.providers && this.config.providers.length > 0) {
           params.provider = { only: this.config.providers };
         }
         return {
-          body: truncateBase642(params),
-          messagesPath: "input",
+          body: truncateChatBase64(params),
+          messagesPath: "messages",
           metadata: {
-            endpoint: "https://openrouter.ai/api/v1/responses"
+            endpoint: "https://openrouter.ai/api/v1/chat/completions"
           }
         };
       }
@@ -20846,7 +21578,17 @@ var init_dist2 = __esm({
     }).passthrough();
     openrouterProviderOptions = z.object({
       /** Provider routing configuration */
-      provider: providerRoutingSchema.optional()
+      provider: providerRoutingSchema.optional(),
+      /**
+       * Use OpenRouter's Responses API (beta) instead of the Chat Completions API.
+       *
+       * By default, the provider uses the stable Chat Completions API.
+       * Set this to true to use the Responses API which has some additional
+       * features but may be less stable.
+       *
+       * @default false
+       */
+      useResponsesApi: z.boolean().optional()
     }).passthrough();
     openrouter = Object.assign(
       (config) => new OpenRouterProvider(config),