npm - @standardagents/openrouter - Versions diffs - 0.14.1 → 0.15.0 - Mend

@standardagents/openrouter 0.14.1 → 0.15.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.js CHANGED Viewed

@@ -1,98 +1,231 @@
 // src/OpenRouterProvider.ts
-import { ProviderError } from "@standardagents/spec";
+import { ProviderError, defineTool } from "@standardagents/spec";
+import { z } from "zod";
-// src/responses-transformers.ts
-function transformContentPart(part) {
+// src/server-tools.ts
+var OPENROUTER_SERVER_TOOL_NAMES = [
+  "web_search",
+  "web_fetch",
+  "datetime",
+  "image_generation"
+];
+function isOpenRouterServerToolName(name) {
+  return OPENROUTER_SERVER_TOOL_NAMES.includes(name);
+}
+function isOpenRouterServerTool(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const type = value.type;
+  return typeof type === "string" && type.startsWith("openrouter:") && isOpenRouterServerToolName(type.slice("openrouter:".length));
+}
+function isOpenRouterProviderTool(tool) {
+  return tool.executionMode === "provider" && tool.executionProvider === "openrouter" && isOpenRouterServerToolName(tool.function.name);
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function getServerToolParameters(providerOptions, toolName) {
+  const rawConfig = providerOptions?.serverTools ?? providerOptions?.server_tools;
+  if (!isRecord(rawConfig)) return void 0;
+  const rawParameters = rawConfig[toolName];
+  if (!isRecord(rawParameters) || Object.keys(rawParameters).length === 0) {
+    return void 0;
+  }
+  return rawParameters;
+}
+function toOpenRouterServerTool(name, parameters) {
+  return {
+    type: `openrouter:${name}`,
+    ...parameters ? { parameters } : {}
+  };
+}
+function splitOpenRouterProviderOptions(providerOptions) {
+  if (!providerOptions) return void 0;
+  const {
+    serverTools: _serverTools,
+    server_tools: _serverToolsSnake,
+    _metadata,
+    ...rest
+  } = providerOptions;
+  return Object.keys(rest).length > 0 ? rest : void 0;
+}
+function serverToolNameFromUsageKey(key) {
+  if (!key.endsWith("_requests")) return void 0;
+  const name = key.slice(0, -"_requests".length);
+  return isOpenRouterServerToolName(name) ? name : void 0;
+}
+function extractServerToolUse(usage) {
+  if (!isRecord(usage)) return void 0;
+  const raw = usage.server_tool_use ?? usage.serverToolUse;
+  return isRecord(raw) ? raw : void 0;
+}
+function providerToolResultsFromServerToolUse(usage) {
+  const serverToolUse = extractServerToolUse(usage);
+  if (!serverToolUse) return void 0;
+  const results = [];
+  for (const [key, value] of Object.entries(serverToolUse)) {
+    const name = serverToolNameFromUsageKey(key);
+    const count = typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+    if (!name || count === 0) continue;
+    for (let index = 0; index < count; index += 1) {
+      results.push({
+        name,
+        type: name,
+        provider: "openrouter",
+        id: `openrouter:${name}:${index + 1}`,
+        status: "completed",
+        metadata: {
+          usageKey: key,
+          index: index + 1,
+          total: count
+        }
+      });
+    }
+  }
+  return results.length > 0 ? results : void 0;
+}
+function extractWebSearchCitations(value) {
+  if (!Array.isArray(value)) return [];
+  const citations = [];
+  for (const annotation of value) {
+    if (!isRecord(annotation)) continue;
+    const rawCitation = annotation.url_citation ?? annotation.urlCitation;
+    if (!isRecord(rawCitation)) continue;
+    const url = rawCitation.url;
+    if (typeof url !== "string" || url.length === 0) continue;
+    citations.push({
+      type: typeof annotation.type === "string" ? annotation.type : void 0,
+      url,
+      title: typeof rawCitation.title === "string" ? rawCitation.title : void 0,
+      content: typeof rawCitation.content === "string" ? rawCitation.content : void 0,
+      startIndex: readNumber(rawCitation.start_index ?? rawCitation.startIndex),
+      endIndex: readNumber(rawCitation.end_index ?? rawCitation.endIndex)
+    });
+  }
+  return citations;
+}
+function providerToolResultFromWebSearchCitations(citations, responseId) {
+  if (citations.length === 0) return void 0;
+  return {
+    name: "web_search",
+    type: "web_search",
+    provider: "openrouter",
+    id: responseId ? `openrouter:web_search:${responseId}` : "openrouter:web_search:annotations",
+    status: "completed",
+    result: {
+      actions: [
+        {
+          type: "search",
+          sources: citations.map((citation) => ({
+            type: citation.type,
+            url: citation.url,
+            title: citation.title
+          }))
+        }
+      ]
+    },
+    metadata: {
+      source: "annotations",
+      citationCount: citations.length
+    }
+  };
+}
+function providerToolResultsFromServerToolUseOrCitations(usage, citations, responseId) {
+  const usageResults = providerToolResultsFromServerToolUse(usage);
+  const annotationResult = providerToolResultFromWebSearchCitations(citations, responseId);
+  if (usageResults && usageResults.length > 0) {
+    if (annotationResult && !usageResults.some((tool) => tool.name === "web_search")) {
+      return [...usageResults, annotationResult];
+    }
+    return usageResults;
+  }
+  return annotationResult ? [annotationResult] : void 0;
+}
+function providerToolDoneChunksFromServerToolUseOrCitations(usage, citations, responseId) {
+  return (providerToolResultsFromServerToolUseOrCitations(usage, citations, responseId) ?? []).map((tool) => ({
+    type: "provider-tool-done",
+    tool
+  }));
+}
+// src/chat-completions-transformers.ts
+function transformChatContentPart(part) {
   if (part.type === "text") {
-    return { type: "input_text", text: part.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: "input_image",
-      image_url: imageUrl,
-      detail: part.detail || "auto"
+      type: "image_url",
+      image_url: {
+        url: imageUrl,
+        detail: part.detail || "auto"
+      }
     };
   }
   if (part.type === "image_url") {
-    const url = part.image_url?.url || "";
-    const detail = part.image_url?.detail || "auto";
     return {
-      type: "input_image",
-      image_url: url,
-      detail
+      type: "image_url",
+      image_url: {
+        url: part.image_url?.url || "",
+        detail: part.image_url?.detail || "auto"
+      }
     };
   }
   return {
-    type: "input_text",
+    type: "text",
     text: `[File: ${part.filename || "file"}]`
   };
 }
-function transformMessageContent(content) {
+function transformChatMessageContent(content) {
   if (typeof content === "string") {
     return content;
   }
-  return content.map(transformContentPart);
+  return content.map(transformChatContentPart);
 }
-function transformUserMessage(msg) {
-  const content = transformMessageContent(msg.content);
+function transformChatSystemMessage(msg) {
+  return {
+    role: "system",
+    content: msg.content
+  };
+}
+function transformChatUserMessage(msg) {
   return {
     role: "user",
-    content: typeof content === "string" ? content : content
+    content: transformChatMessageContent(msg.content)
   };
 }
-function transformAssistantMessage(msg) {
-  const items = [];
-  const reasoningDetails = msg.reasoningDetails;
-  if (reasoningDetails && reasoningDetails.length > 0) {
-    const summaryTexts = [];
-    let encryptedContent;
-    for (const detail of reasoningDetails) {
-      if (detail.type === "reasoning.text") {
-        summaryTexts.push({ type: "summary_text", text: detail.text });
-      } else if (detail.type === "reasoning.encrypted") {
-        encryptedContent = detail.text;
-      }
-    }
-    if (summaryTexts.length > 0) {
-      const reasoningItem = {
-        type: "reasoning",
-        id: "",
-        summary: summaryTexts,
-        ...encryptedContent ? { encrypted_content: encryptedContent } : {}
-      };
-      items.push(reasoningItem);
-    }
-  }
-  if (msg.content) {
-    const outputMessage = {
-      type: "message",
-      role: "assistant",
-      id: "",
-      status: "completed",
-      content: [{ type: "output_text", text: msg.content, annotations: [] }]
-    };
-    items.push(outputMessage);
-  }
+function transformChatAssistantMessage(msg) {
+  const message = {
+    role: "assistant",
+    content: msg.content || null
+  };
   if (msg.toolCalls && msg.toolCalls.length > 0) {
-    for (const tc of msg.toolCalls) {
-      const functionCall = {
-        type: "function_call",
-        id: `fc_${tc.id}`,
-        // Unique output item ID (prefixed to distinguish from call_id)
-        call_id: tc.id,
+    message.tool_calls = msg.toolCalls.map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: {
         name: tc.name,
-        arguments: JSON.stringify(tc.arguments),
-        status: "completed"
-        // Mark as completed since this is from history
-      };
-      items.push(functionCall);
-    }
+        arguments: typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments)
+      }
+    }));
   }
-  return items;
+  if (msg.reasoningDetails && msg.reasoningDetails.length > 0) {
+    message.reasoning_details = msg.reasoningDetails.map((detail) => {
+      if (detail.type === "text") {
+        return { type: "reasoning.text", text: detail.text, format: detail.format };
+      } else if (detail.type === "summary") {
+        return { type: "reasoning.summary", summary: detail.text, format: detail.format };
+      }
+      return { type: "reasoning.encrypted", data: detail.data, id: detail.id, format: detail.format };
+    });
+  }
+  return message;
 }
-function transformToolMessage(msg) {
+function transformChatToolMessage(msg) {
   let output;
   if (typeof msg.content === "string") {
     output = msg.content;
@@ -108,13 +241,13 @@ function transformToolMessage(msg) {
     output = JSON.stringify(msg.content);
   }
   const imageAttachments = msg.attachments?.filter((a) => a.type === "image" && a.data) || [];
-  const toolOutput = {
-    type: "function_call_output",
-    call_id: msg.toolCallId,
-    output: output || (imageAttachments.length > 0 ? "Success" : "")
+  const toolMessage = {
+    role: "tool",
+    tool_call_id: msg.toolCallId,
+    content: output || (imageAttachments.length > 0 ? "Success" : "")
   };
   if (imageAttachments.length === 0) {
-    return { toolOutput };
+    return { toolMessage };
   }
   const imageContent = [];
   const toolName = msg.toolName || "the tool";
@@ -122,87 +255,111 @@ function transformToolMessage(msg) {
   const descriptor = isSingle ? "the file" : `${imageAttachments.length} files`;
   const verb = isSingle ? "is" : "are";
   imageContent.push({
-    type: "input_text",
+    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: "input_image",
-      image_url: imageData,
-      detail: "auto"
+      type: "image_url",
+      image_url: {
+        url: imageData,
+        detail: "auto"
+      }
     });
   }
   const syntheticUserMessage = {
     role: "user",
     content: imageContent
   };
-  return { toolOutput, syntheticUserMessage };
+  return { toolMessage, syntheticUserMessage };
 }
-function transformMessages(messages) {
-  let instructions;
-  const input = [];
+function transformChatMessages(messages) {
+  const result = [];
   for (const msg of messages) {
     switch (msg.role) {
       case "system":
-        instructions = instructions ? `${instructions}
-${msg.content}` : msg.content;
-        input.push({
-          type: "message",
-          role: "system",
-          content: msg.content
-        });
+        result.push(transformChatSystemMessage(msg));
         break;
       case "user":
-        input.push(transformUserMessage(msg));
+        result.push(transformChatUserMessage(msg));
         break;
       case "assistant":
-        input.push(...transformAssistantMessage(msg));
+        result.push(transformChatAssistantMessage(msg));
         break;
       case "tool": {
-        const result = transformToolMessage(msg);
-        input.push(result.toolOutput);
-        if (result.syntheticUserMessage) {
-          input.push(result.syntheticUserMessage);
+        const { toolMessage, syntheticUserMessage } = transformChatToolMessage(msg);
+        result.push(toolMessage);
+        if (syntheticUserMessage) {
+          result.push(syntheticUserMessage);
         }
         break;
       }
     }
   }
-  return { input, instructions };
+  return result;
 }
-function transformTool(tool) {
-  const inputParams = tool.function.parameters;
-  let parameters;
-  if (inputParams && typeof inputParams === "object") {
-    parameters = {
-      ...inputParams,
-      additionalProperties: false
-    };
-  } else {
-    parameters = {
-      type: "object",
-      properties: {},
-      required: [],
-      additionalProperties: false
-    };
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeStrictJsonSchema(schema) {
+  if (Array.isArray(schema)) {
+    return schema.map((item) => normalizeStrictJsonSchema(item));
+  }
+  if (!isRecord2(schema)) {
+    return schema;
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(schema)) {
+    normalized[key] = normalizeStrictJsonSchema(value);
+  }
+  const properties = isRecord2(normalized.properties) ? normalized.properties : void 0;
+  const type = normalized.type;
+  const isObjectSchema = type === "object" || Array.isArray(type) && type.includes("object") || !!properties;
+  if (isObjectSchema) {
+    if (normalized.type === void 0) {
+      normalized.type = "object";
+    }
+    normalized.properties = properties || {};
+    normalized.required = Object.keys(normalized.properties);
+    normalized.additionalProperties = false;
+  }
+  return normalized;
+}
+function normalizeStrictToolParameters(parameters) {
+  const base = isRecord2(parameters) ? { ...parameters } : {};
+  if (base.type === void 0) {
+    base.type = "object";
   }
+  if (base.properties === void 0) {
+    base.properties = {};
+  }
+  return normalizeStrictJsonSchema(base);
+}
+function transformChatTool(tool, providerOptions) {
+  if (isOpenRouterProviderTool(tool)) {
+    const parameters2 = getServerToolParameters(providerOptions, tool.function.name);
+    return toOpenRouterServerTool(tool.function.name, parameters2);
+  }
+  const inputParams = tool.function.parameters;
+  const parameters = normalizeStrictToolParameters(inputParams);
   return {
     type: "function",
-    name: tool.function.name,
-    description: tool.function.description || void 0,
-    parameters,
-    strict: true
+    function: {
+      name: tool.function.name,
+      description: tool.function.description || void 0,
+      parameters,
+      strict: true
+    }
   };
 }
-function transformTools(tools) {
-  return tools.map(transformTool);
+function transformChatTools(tools, providerOptions) {
+  return tools.map((tool) => transformChatTool(tool, providerOptions));
 }
-function transformToolChoice(choice) {
+function transformChatToolChoice(choice) {
   if (choice === "auto") {
-    return "auto";
+    return void 0;
   }
   if (choice === "none") {
     return "none";
@@ -211,109 +368,44 @@ function transformToolChoice(choice) {
     return "required";
   }
   if (typeof choice === "object" && "name" in choice) {
-    return { type: "function", name: choice.name };
+    return { type: "function", function: { name: choice.name } };
   }
-  return "auto";
+  return void 0;
 }
-function mapFinishReason(response) {
-  if (response.status === "failed") {
-    return "error";
-  }
-  if (response.status === "incomplete") {
-    if (response.incompleteDetails?.reason === "max_output_tokens") {
+function mapChatFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "tool_calls":
+      return "tool_calls";
+    case "length":
       return "length";
-    }
-    if (response.incompleteDetails?.reason === "content_filter") {
+    case "content_filter":
       return "content_filter";
-    }
+    case "error":
+      return "error";
+    default:
+      return "stop";
   }
-  const hasToolCalls = response.output.some(
-    (item) => item.type === "function_call"
-  );
-  if (hasToolCalls) {
-    return "tool_calls";
-  }
-  return "stop";
-}
-function extractTextContent(output) {
-  const textParts = [];
-  for (const item of output) {
-    if (item.type === "message" && item.role === "assistant") {
-      for (const content of item.content) {
-        if (content.type === "output_text") {
-          textParts.push(content.text);
-        }
-      }
-    }
-  }
-  return textParts.length > 0 ? textParts.join("") : null;
 }
-function extractToolCalls(output) {
-  const toolCalls = [];
-  for (const item of output) {
-    if (item.type === "function_call") {
-      let parsedArgs = {};
-      try {
-        parsedArgs = item.arguments ? JSON.parse(item.arguments) : {};
-      } catch {
-      }
-      toolCalls.push({
-        id: item.callId,
-        name: item.name,
-        arguments: parsedArgs
-      });
-    }
+function extractChatToolCalls(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0) {
+    return void 0;
   }
-  return toolCalls.length > 0 ? toolCalls : void 0;
-}
-function extractImages(output) {
-  const images = [];
-  for (const item of output) {
-    const itemAny = item;
-    if (itemAny.type === "image_generation_call" && itemAny.result) {
-      const imageData = itemAny.result;
-      const isDataUrl = imageData.startsWith("data:");
-      const isHttpUrl = imageData.startsWith("http://") || imageData.startsWith("https://");
-      let mediaType = "image/png";
-      if (isDataUrl) {
-        const match = imageData.match(/^data:([^;,]+)/);
-        if (match) {
-          mediaType = match[1];
-        }
-      }
-      images.push({
-        id: itemAny.id || void 0,
-        data: imageData,
-        mediaType,
-        // Include revised prompt if available
-        revisedPrompt: itemAny.revised_prompt || itemAny.revisedPrompt || void 0
-      });
-    }
-    if (itemAny.type === "message" && itemAny.content && Array.isArray(itemAny.content)) {
-      for (const content of itemAny.content) {
-        if (content.type === "output_image" || content.type === "image") {
-          const imageData = content.image || content.data || content.url || content.image_url;
-          if (imageData) {
-            let mediaType = content.media_type || content.mediaType || "image/png";
-            if (typeof imageData === "string" && imageData.startsWith("data:")) {
-              const match = imageData.match(/^data:([^;,]+)/);
-              if (match) {
-                mediaType = match[1];
-              }
-            }
-            images.push({
-              id: content.id || void 0,
-              data: imageData,
-              mediaType
-            });
-          }
-        }
-      }
+  return toolCalls.map((tc) => {
+    let parsedArgs = {};
+    try {
+      parsedArgs = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+    } catch {
     }
-  }
-  return images.length > 0 ? images : void 0;
+    return {
+      id: tc.id,
+      name: tc.function.name,
+      arguments: parsedArgs
+    };
+  });
 }
-function transformUsage(usage, actualProvider) {
+function transformChatUsage(usage, actualProvider) {
   if (!usage) {
     return {
       promptTokens: 0,
@@ -321,32 +413,69 @@ function transformUsage(usage, actualProvider) {
       totalTokens: 0
     };
   }
-  const inputTokens = usage.native_tokens_prompt || usage.nativeTokensPrompt || usage.input_tokens || usage.inputTokens || 0;
-  const outputTokens = usage.native_tokens_completion || usage.nativeTokensCompletion || usage.output_tokens || usage.outputTokens || 0;
-  const totalTokens = usage.total_tokens || usage.totalTokens || 0;
-  const reasoningTokens = usage.output_tokens_details?.reasoning_tokens || usage.outputTokensDetails?.reasoningTokens;
-  const cachedTokens = usage.input_tokens_details?.cached_tokens || usage.inputTokensDetails?.cachedTokens;
+  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: inputTokens,
-    completionTokens: outputTokens,
-    totalTokens: totalTokens || inputTokens + outputTokens,
-    reasoningTokens,
-    cachedTokens,
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    reasoningTokens: usage.completion_tokens_details?.reasoning_tokens,
+    cachedTokens: usage.prompt_tokens_details?.cached_tokens,
     cost: usage.cost,
     provider: actualProvider
   };
 }
-function transformResponse(response) {
-  const content = extractTextContent(response.output);
-  const toolCalls = extractToolCalls(response.output);
-  const images = extractImages(response.output);
+function extractImageFromUrl(url, index) {
+  if (url.startsWith("data:")) {
+    const match = url.match(/^data:([^;]+);base64,(.+)$/);
+    if (match) {
+      return {
+        id: `image_${index}`,
+        data: match[2],
+        // base64 data without prefix
+        mediaType: match[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 webSearchCitations = extractWebSearchCitations(message?.annotations);
+  const providerTools = providerToolResultsFromServerToolUseOrCitations(
+    response.usage,
+    webSearchCitations,
+    response.id
+  );
   const actualProvider = response.model?.split("/")[0] || void 0;
   return {
     content,
     toolCalls,
     images,
-    finishReason: mapFinishReason(response),
-    usage: transformUsage(response.usage, actualProvider),
+    providerTools,
+    finishReason: mapChatFinishReason(choice?.finish_reason),
+    usage: transformChatUsage(response.usage, actualProvider),
     metadata: {
       model: response.model,
       provider: "openrouter",
@@ -355,373 +484,271 @@ function transformResponse(response) {
     }
   };
 }
-function extractReasoningDetails(output, streamedReasoningContent) {
-  const details = [];
-  if (output && Array.isArray(output)) {
-    for (const item of output) {
-      const itemAny = item;
-      if (itemAny.type === "reasoning") {
-        if (itemAny.summary && Array.isArray(itemAny.summary)) {
-          for (const step of itemAny.summary) {
-            if (typeof step === "string") {
-              details.push({ type: "reasoning.text", text: step });
-            }
-          }
-        }
-        if (details.length === 0 && itemAny.encrypted_content) {
-          details.push({ type: "reasoning.encrypted", text: itemAny.encrypted_content });
-        }
-        if (itemAny.content) {
-          if (typeof itemAny.content === "string") {
-            details.push({ type: "reasoning.text", text: itemAny.content });
-          } else if (Array.isArray(itemAny.content)) {
-            for (const part of itemAny.content) {
-              if (part.text) {
-                details.push({ type: "reasoning.text", text: part.text });
-              }
-            }
-          }
-        }
-      }
-      if (itemAny.type === "message" && itemAny.content && Array.isArray(itemAny.content)) {
-        for (const part of itemAny.content) {
-          if (part.type === "reasoning" || part.type === "reasoning_text") {
-            details.push({ type: "reasoning.text", text: part.text || "" });
-          }
-        }
-      }
-    }
-  }
-  if (details.length === 0 && streamedReasoningContent) {
-    details.push({ type: "reasoning.text", text: streamedReasoningContent });
-  }
-  return details.length > 0 ? details : void 0;
-}
-function buildCreateParams(request) {
-  const { input, instructions } = transformMessages(request.messages);
-  const params = {
-    model: request.model,
-    input,
-    store: false
-    // Always stateless
+function createChatStreamState() {
+  return {
+    content: "",
+    toolCalls: /* @__PURE__ */ new Map(),
+    images: [],
+    reasoningContent: "",
+    hasContent: false,
+    hasReasoning: false,
+    finishReason: null,
+    reasoningDetails: [],
+    webSearchCitations: []
   };
-  if (instructions) {
-    params.instructions = instructions;
-  }
-  if (request.tools && request.tools.length > 0) {
-    params.tools = transformTools(request.tools);
-    if (request.toolChoice !== void 0) {
-      params.toolChoice = transformToolChoice(request.toolChoice);
-    }
-    if (request.parallelToolCalls !== void 0) {
-      params.parallelToolCalls = request.parallelToolCalls;
-    }
+}
+function accumulateReasoningDetail(state, detail) {
+  const idx = detail.index ?? 0;
+  const textContent = detail.text || detail.summary || "";
+  const detailType = detail.type === "reasoning.summary" ? "summary" : "text";
+  const existing = state.reasoningDetails.find(
+    (d) => d.type === detailType && d._index === idx
+  );
+  if (existing && existing.text !== void 0) {
+    existing.text += textContent;
+  } else {
+    state.reasoningDetails.push({
+      type: detailType,
+      text: textContent,
+      format: detail.format,
+      _index: idx
+    });
   }
-  if (request.maxOutputTokens !== void 0) {
-    params.maxOutputTokens = request.maxOutputTokens;
+}
+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 (request.temperature !== void 0) {
-    params.temperature = request.temperature;
+  if (delta?.content) {
+    state.hasContent = true;
+    state.content += delta.content;
+    chunks.push({ type: "content-delta", delta: delta.content });
+  }
+  const reasoningText = delta?.reasoning ?? delta?.reasoning_content;
+  if (reasoningText) {
+    state.hasReasoning = true;
+    state.reasoningContent += reasoningText;
+    chunks.push({ type: "reasoning-delta", delta: reasoningText });
+  }
+  if (delta?.reasoning_details && Array.isArray(delta.reasoning_details)) {
+    for (const detail of delta.reasoning_details) {
+      if (detail.type === "reasoning.text") {
+        accumulateReasoningDetail(state, detail);
+      } else if (detail.type === "reasoning.summary") {
+        accumulateReasoningDetail(state, detail);
+      } else if (detail.type === "reasoning.encrypted") {
+        state.reasoningDetails.push({
+          type: "encrypted",
+          id: detail.id,
+          data: detail.data,
+          format: detail.format
+        });
+      }
+    }
+  }
+  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
+      });
+    }
+  }
+  const webSearchCitations = extractWebSearchCitations(delta?.annotations);
+  if (webSearchCitations.length > 0) {
+    state.webSearchCitations.push(...webSearchCitations);
+  }
+  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) {
+    chunks.push(...providerToolDoneChunksFromServerToolUseOrCitations(
+      chunk.usage,
+      state.webSearchCitations,
+      chunk.id
+    ));
+    const actualProvider = chunk.model?.split("/")[0] || void 0;
+    const reasoningDetails = state.reasoningDetails.length > 0 ? state.reasoningDetails.map(({ _index, ...d }) => d) : void 0;
+    chunks.push({
+      type: "finish",
+      finishReason: mapChatFinishReason(state.finishReason),
+      usage: transformChatUsage(chunk.usage, actualProvider),
+      reasoningDetails
+    });
+  }
+  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, request.providerOptions);
+    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.topP = request.topP;
+    params.top_p = request.topP;
   }
   if (request.reasoning?.level !== void 0) {
     const effortMap = {
       10: "minimal",
-      // Basic reasoning
       33: "low",
-      // Light reasoning
       66: "medium",
-      // Balanced reasoning
       100: "high"
-      // Deep reasoning
     };
     const effort = effortMap[request.reasoning.level];
     if (effort) {
-      params.reasoning = {
-        effort
-      };
+      params.reasoning = { effort };
     }
   }
   if (request.responseFormat) {
     if (request.responseFormat.type === "json") {
       if (request.responseFormat.schema) {
-        params.text = {
-          format: {
-            type: "json_schema",
+        params.response_format = {
+          type: "json_schema",
+          json_schema: {
             name: "response",
             schema: request.responseFormat.schema,
             strict: true
           }
         };
       } else {
-        params.text = {
-          format: { type: "json_object" }
-        };
+        params.response_format = { type: "json_object" };
       }
     }
   }
-  if (request.providerOptions) {
-    Object.assign(params, request.providerOptions);
+  const safeOptions = splitOpenRouterProviderOptions(
+    request.providerOptions
+  );
+  if (safeOptions) {
+    Object.assign(params, safeOptions);
   }
   return params;
 }
-function createStreamState() {
-  return {
-    toolCalls: /* @__PURE__ */ new Map(),
-    reasoningContent: "",
-    hasContent: false,
-    hasReasoning: false,
-    currentItemId: null,
-    imageGenerations: /* @__PURE__ */ new Map()
-  };
-}
-function processStreamEvent(event, state) {
-  const chunks = [];
-  switch (event.type) {
-    // Text content streaming
-    case "response.output_text.delta":
-      state.hasContent = true;
-      chunks.push({ type: "content-delta", delta: event.delta });
-      break;
-    case "response.output_text.done":
-      break;
-    // Reasoning streaming - OpenRouter uses 'response.reasoning.delta'
-    // Note: SDK types may not include reasoning events, so we check dynamically
-    case "response.reasoning_text.delta":
-      state.hasReasoning = true;
-      state.reasoningContent += event.delta;
-      chunks.push({ type: "reasoning-delta", delta: event.delta });
-      break;
-    case "response.reasoning_text.done":
-      break;
-    // Function call and image generation streaming
-    case "response.output_item.added":
-      if (event.item.type === "function_call") {
-        const callId = event.item.callId || event.item.call_id || "";
-        const name = event.item.name || "";
-        state.toolCalls.set(callId, {
-          id: callId,
-          name,
-          arguments: ""
-        });
-        chunks.push({
-          type: "tool-call-start",
-          id: callId,
-          name
-        });
-      }
-      if (event.item.type === "image_generation_call") {
-        const itemAny = event.item;
-        const imageId = itemAny.id || itemAny.call_id || itemAny.callId || `img-${state.imageGenerations.size}`;
-        state.imageGenerations.set(imageId, {
-          id: imageId,
-          data: "",
-          status: "in_progress"
-        });
-      }
-      break;
-    case "response.output_item.done": {
-      const itemAny = event.item;
-      if (itemAny.type === "image_generation_call" && itemAny.result) {
-        const imageId = itemAny.id || itemAny.call_id || itemAny.callId || "";
-        const imageData = itemAny.result;
-        let mediaType = "image/png";
-        if (imageData.startsWith("data:")) {
-          const match = imageData.match(/^data:([^;,]+)/);
-          if (match) mediaType = match[1];
-        }
-        const existing = state.imageGenerations.get(imageId);
-        if (existing) {
-          existing.data = imageData;
-          existing.status = "completed";
-        }
-        const imageIndex = Array.from(state.imageGenerations.keys()).indexOf(imageId);
-        chunks.push({
-          type: "image-done",
-          index: imageIndex >= 0 ? imageIndex : state.imageGenerations.size - 1,
-          image: {
-            id: imageId || void 0,
-            data: imageData,
-            mediaType,
-            revisedPrompt: itemAny.revised_prompt || itemAny.revisedPrompt || void 0
-          }
-        });
-      }
-      break;
-    }
-    case "response.function_call_arguments.delta": {
-      const itemId = event.itemId || event.item_id || "";
-      const deltaToolCall = Array.from(state.toolCalls.values()).find(
-        (tc) => tc.id === itemId
-      );
-      if (deltaToolCall) {
-        deltaToolCall.arguments += event.delta;
-        chunks.push({
-          type: "tool-call-delta",
-          id: deltaToolCall.id,
-          argumentsDelta: event.delta
-        });
-      }
-      break;
-    }
-    case "response.function_call_arguments.done": {
-      const itemId = event.itemId || event.item_id || "";
-      const doneToolCall = Array.from(state.toolCalls.values()).find(
-        (tc) => tc.id === itemId
-      );
-      if (doneToolCall) {
-        let parsedArgs = {};
-        try {
-          parsedArgs = doneToolCall.arguments ? JSON.parse(doneToolCall.arguments) : {};
-        } catch {
-        }
-        chunks.push({
-          type: "tool-call-done",
-          id: doneToolCall.id,
-          arguments: parsedArgs
-        });
-      }
-      break;
-    }
-    // Response completion
-    case "response.completed": {
-      if (state.hasContent) {
-        chunks.push({ type: "content-done" });
-      }
-      if (state.hasReasoning) {
-        chunks.push({ type: "reasoning-done" });
-      }
-      const completedProvider = event.response.model?.split("/")[0] || void 0;
-      const reasoningDetails = extractReasoningDetails(event.response.output, state.reasoningContent);
-      const generatedImages = extractImages(event.response.output);
-      if (generatedImages && generatedImages.length > 0) {
-        for (let i = 0; i < generatedImages.length; i++) {
-          const img = generatedImages[i];
-          const alreadyEmitted = img.id && state.imageGenerations.get(img.id)?.status === "completed";
-          if (!alreadyEmitted) {
-            chunks.push({
-              type: "image-done",
-              index: i,
-              image: img
-            });
-          }
-        }
-      }
-      chunks.push({
-        type: "finish",
-        finishReason: mapFinishReason(event.response),
-        usage: transformUsage(event.response.usage, completedProvider),
-        responseId: event.response.id,
-        // Used to fetch generation metadata after stream
-        reasoningDetails
-      });
-      break;
-    }
-    case "response.failed":
-      chunks.push({
-        type: "error",
-        error: event.response.error?.message || "Response generation failed",
-        code: event.response.error?.code
-      });
-      break;
-    case "response.incomplete": {
-      if (state.hasContent) {
-        chunks.push({ type: "content-done" });
-      }
-      if (state.hasReasoning) {
-        chunks.push({ type: "reasoning-done" });
-      }
-      const incompleteProvider = event.response.model?.split("/")[0] || void 0;
-      const incompleteReasoningDetails = extractReasoningDetails(event.response.output, state.reasoningContent);
-      const incompleteImages = extractImages(event.response.output);
-      if (incompleteImages && incompleteImages.length > 0) {
-        for (let i = 0; i < incompleteImages.length; i++) {
-          const img = incompleteImages[i];
-          const alreadyEmitted = img.id && state.imageGenerations.get(img.id)?.status === "completed";
-          if (!alreadyEmitted) {
-            chunks.push({
-              type: "image-done",
-              index: i,
-              image: img
-            });
-          }
-        }
-      }
-      chunks.push({
-        type: "finish",
-        finishReason: mapFinishReason(event.response),
-        usage: transformUsage(event.response.usage, incompleteProvider),
-        responseId: event.response.id,
-        // Used to fetch generation metadata after stream
-        reasoningDetails: incompleteReasoningDetails
-      });
-      break;
-    }
-    // Handle reasoning and image events dynamically (SDK types may not include them)
-    default: {
-      const eventType = event.type;
-      const eventAny = event;
-      if (eventType === "response.reasoning.delta") {
-        state.hasReasoning = true;
-        state.reasoningContent += eventAny.delta || "";
-        chunks.push({ type: "reasoning-delta", delta: eventAny.delta || "" });
-      }
-      if (eventType === "response.image_generation_call.partial_image" || eventType === "response.image_generation.partial") {
-        const imageId = eventAny.item_id || eventAny.itemId || eventAny.id || "";
-        const partialData = eventAny.partial_image || eventAny.delta || eventAny.data || "";
-        const existing = state.imageGenerations.get(imageId);
-        if (existing) {
-          existing.data += partialData;
-        } else {
-          state.imageGenerations.set(imageId, {
-            id: imageId,
-            data: partialData,
-            status: "generating"
-          });
-        }
-        const imageIndex = Array.from(state.imageGenerations.keys()).indexOf(imageId);
-        chunks.push({
-          type: "image-delta",
-          index: imageIndex >= 0 ? imageIndex : state.imageGenerations.size - 1,
-          data: partialData
-        });
-      }
-      if (eventType === "response.image_generation_call.completed" || eventType === "response.image_generation.done") {
-        const imageId = eventAny.item_id || eventAny.itemId || eventAny.id || "";
-        const imageData = eventAny.result || eventAny.image || eventAny.data || "";
-        if (imageData) {
-          let mediaType = "image/png";
-          if (imageData.startsWith("data:")) {
-            const match = imageData.match(/^data:([^;,]+)/);
-            if (match) mediaType = match[1];
-          }
-          const existing = state.imageGenerations.get(imageId);
-          if (existing) {
-            existing.data = imageData;
-            existing.status = "completed";
-          }
-          const imageIndex = Array.from(state.imageGenerations.keys()).indexOf(imageId);
-          chunks.push({
-            type: "image-done",
-            index: imageIndex >= 0 ? imageIndex : state.imageGenerations.size - 1,
-            image: {
-              id: imageId || void 0,
-              data: imageData,
-              mediaType,
-              revisedPrompt: eventAny.revised_prompt || eventAny.revisedPrompt || void 0
-            }
-          });
-        }
-      }
-      break;
-    }
-  }
-  return chunks;
-}
-function createErrorChunk(error, code) {
-  return { type: "error", error, code };
+function createChatErrorChunk(error, code) {
+  return { type: "error", error, code };
 }
 function isBase64Like(str) {
   if (str.startsWith("data:")) return true;
@@ -736,7 +763,7 @@ function truncateBase64String(str, maxLength = 50) {
   const preview = str.substring(0, maxLength);
   return `${preview}...[truncated, ${str.length.toLocaleString()} chars]`;
 }
-function truncateBase64(obj, maxLength = 50) {
+function truncateChatBase64(obj, maxLength = 50) {
   if (obj === null || obj === void 0) {
     return obj;
   }
@@ -747,206 +774,113 @@ function truncateBase64(obj, maxLength = 50) {
     return obj;
   }
   if (Array.isArray(obj)) {
-    return obj.map((item) => truncateBase64(item, maxLength));
+    return obj.map((item) => truncateChatBase64(item, maxLength));
   }
   if (typeof obj === "object") {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
-      result[key] = truncateBase64(value, maxLength);
+      result[key] = truncateChatBase64(value, maxLength);
     }
     return result;
   }
   return obj;
 }
-function parseRawStreamEvent(jsonStr) {
-  try {
-    const event = JSON.parse(jsonStr);
-    return event;
-  } catch {
-    return null;
+// src/responses-transformers.ts
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function transformContentPart(part) {
+  if (part.type === "text") {
+    return { type: "input_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: "input_image",
+      image_url: imageUrl,
+      detail: part.detail || "auto"
+    };
+  }
+  if (part.type === "image_url") {
+    const url = part.image_url?.url || "";
+    const detail = part.image_url?.detail || "auto";
+    return {
+      type: "input_image",
+      image_url: url,
+      detail
+    };
   }
+  return {
+    type: "input_text",
+    text: `[File: ${part.filename || "file"}]`
+  };
 }
-async function* parseSSEStream(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 event = parseRawStreamEvent(data);
-          if (event) {
-            const chunks = processStreamEvent(event, state);
-            for (const chunk of chunks) {
-              yield chunk;
-            }
-          }
-        }
-      }
-    }
-    if (buffer.trim()) {
-      const trimmed = buffer.trim();
-      if (trimmed.startsWith("data: ")) {
-        const data = trimmed.slice(6);
-        if (data !== "[DONE]") {
-          const event = parseRawStreamEvent(data);
-          if (event) {
-            const chunks = processStreamEvent(event, state);
-            for (const chunk of chunks) {
-              yield chunk;
-            }
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
+function transformMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
   }
+  return content.map(transformContentPart);
 }
-async function fetchGenerationMetadata(apiKey, generationId, baseUrl = "https://openrouter.ai/api/v1", signal) {
-  const url = `${baseUrl}/generation?id=${encodeURIComponent(generationId)}`;
-  const maxRetries = 3;
-  const delays = [500, 1e3, 2e3];
-  for (let attempt = 0; attempt < maxRetries; attempt++) {
-    try {
-      if (attempt > 0) {
-        await new Promise((resolve) => setTimeout(resolve, delays[attempt - 1]));
-      }
-      const response = await fetch(url, {
-        method: "GET",
-        headers: {
-          "Authorization": `Bearer ${apiKey}`
-        },
-        signal
-      });
-      if (response.status === 404 && attempt < maxRetries - 1) {
-        continue;
-      }
-      if (!response.ok) {
-        console.error(`Failed to fetch generation metadata: ${response.status}`);
-        return null;
-      }
-      const result = await response.json();
-      if (result.error) {
-        console.error("Generation metadata error:", result.error.message);
-        return null;
-      }
-      const data = result.data;
-      if (!data) {
-        return null;
+function transformUserMessage(msg) {
+  const content = transformMessageContent(msg.content);
+  return {
+    role: "user",
+    content: typeof content === "string" ? content : content
+  };
+}
+function transformAssistantMessage(msg) {
+  const items = [];
+  const reasoningDetails = msg.reasoningDetails;
+  if (reasoningDetails && reasoningDetails.length > 0) {
+    const summaryTexts = [];
+    let encryptedContent;
+    for (const detail of reasoningDetails) {
+      if (detail.type === "reasoning.text") {
+        summaryTexts.push({ type: "summary_text", text: detail.text });
+      } else if (detail.type === "reasoning.encrypted") {
+        encryptedContent = detail.text;
       }
-      return {
-        id: data.id || generationId,
-        totalCost: data.total_cost || 0,
-        promptTokens: data.tokens_prompt || 0,
-        completionTokens: data.tokens_completion || 0,
-        nativePromptTokens: data.native_tokens_prompt,
-        nativeCompletionTokens: data.native_tokens_completion,
-        providerName: data.provider_name || "unknown",
-        latency: data.latency || data.generation_time,
-        model: data.model,
-        finishReason: data.finish_reason,
-        createdAt: data.created_at
+    }
+    if (summaryTexts.length > 0) {
+      const reasoningItem = {
+        type: "reasoning",
+        id: "",
+        summary: summaryTexts,
+        ...encryptedContent ? { encrypted_content: encryptedContent } : {}
       };
-    } catch (error) {
-      if (attempt < maxRetries - 1) {
-        continue;
-      }
-      console.error("Error fetching generation metadata:", error);
-      return null;
+      items.push(reasoningItem);
     }
   }
-  return null;
-}
-// src/chat-completions-transformers.ts
-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"
-      }
+  if (msg.content) {
+    const outputMessage = {
+      type: "message",
+      role: "assistant",
+      id: "",
+      status: "completed",
+      content: [{ type: "output_text", text: msg.content, annotations: [] }]
     };
+    items.push(outputMessage);
   }
-  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: {
+    for (const tc of msg.toolCalls) {
+      const functionCall = {
+        type: "function_call",
+        id: `fc_${tc.id}`,
+        // Unique output item ID (prefixed to distinguish from call_id)
+        call_id: tc.id,
         name: tc.name,
-        arguments: typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments)
-      }
-    }));
-  }
-  if (msg.reasoningDetails && msg.reasoningDetails.length > 0) {
-    message.reasoning_details = msg.reasoningDetails.map((detail) => {
-      if (detail.type === "text") {
-        return { type: "reasoning.text", text: detail.text, format: detail.format };
-      } else if (detail.type === "summary") {
-        return { type: "reasoning.summary", summary: detail.text, format: detail.format };
-      }
-      return { type: "reasoning.encrypted", data: detail.data, id: detail.id, format: detail.format };
-    });
+        arguments: JSON.stringify(tc.arguments),
+        status: "completed"
+        // Mark as completed since this is from history
+      };
+      items.push(functionCall);
+    }
   }
-  return message;
+  return items;
 }
-function transformChatToolMessage(msg) {
+function transformToolMessage(msg) {
   let output;
   if (typeof msg.content === "string") {
     output = msg.content;
@@ -962,13 +896,13 @@ function transformChatToolMessage(msg) {
     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" : "")
+  const toolOutput = {
+    type: "function_call_output",
+    call_id: msg.toolCallId,
+    output: output || (imageAttachments.length > 0 ? "Success" : "")
   };
   if (imageAttachments.length === 0) {
-    return { toolMessage };
+    return { toolOutput };
   }
   const imageContent = [];
   const toolName = msg.toolName || "the tool";
@@ -976,81 +910,76 @@ function transformChatToolMessage(msg) {
   const descriptor = isSingle ? "the file" : `${imageAttachments.length} files`;
   const verb = isSingle ? "is" : "are";
   imageContent.push({
-    type: "text",
+    type: "input_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"
-      }
+      type: "input_image",
+      image_url: imageData,
+      detail: "auto"
     });
   }
   const syntheticUserMessage = {
     role: "user",
     content: imageContent
   };
-  return { toolMessage, syntheticUserMessage };
+  return { toolOutput, syntheticUserMessage };
 }
-function transformChatMessages(messages) {
-  const result = [];
+function transformMessages(messages) {
+  let instructions;
+  const input = [];
   for (const msg of messages) {
     switch (msg.role) {
       case "system":
-        result.push(transformChatSystemMessage(msg));
+        instructions = instructions ? `${instructions}
+${msg.content}` : msg.content;
+        input.push({
+          type: "message",
+          role: "system",
+          content: msg.content
+        });
         break;
       case "user":
-        result.push(transformChatUserMessage(msg));
+        input.push(transformUserMessage(msg));
         break;
       case "assistant":
-        result.push(transformChatAssistantMessage(msg));
+        input.push(...transformAssistantMessage(msg));
         break;
       case "tool": {
-        const { toolMessage, syntheticUserMessage } = transformChatToolMessage(msg);
-        result.push(toolMessage);
-        if (syntheticUserMessage) {
-          result.push(syntheticUserMessage);
+        const result = transformToolMessage(msg);
+        input.push(result.toolOutput);
+        if (result.syntheticUserMessage) {
+          input.push(result.syntheticUserMessage);
         }
         break;
       }
     }
   }
-  return result;
+  return { input, instructions };
 }
-function transformChatTool(tool) {
-  const inputParams = tool.function.parameters;
-  let parameters;
-  if (inputParams && typeof inputParams === "object") {
-    parameters = {
-      ...inputParams,
-      additionalProperties: false
-    };
-  } else {
-    parameters = {
-      type: "object",
-      properties: {},
-      required: [],
-      additionalProperties: false
-    };
+function transformTool(tool, providerOptions) {
+  if (isOpenRouterProviderTool(tool)) {
+    const parameters2 = getServerToolParameters(providerOptions, tool.function.name);
+    return toOpenRouterServerTool(tool.function.name, parameters2);
   }
+  const inputParams = tool.function.parameters;
+  const parameters = normalizeStrictToolParameters(inputParams);
   return {
     type: "function",
-    function: {
-      name: tool.function.name,
-      description: tool.function.description || void 0,
-      parameters,
-      strict: true
-    }
+    name: tool.function.name,
+    description: tool.function.description || void 0,
+    parameters,
+    strict: true
   };
 }
-function transformChatTools(tools) {
-  return tools.map(transformChatTool);
+function transformTools(tools, providerOptions) {
+  return tools.map((tool) => transformTool(tool, providerOptions));
 }
-function transformChatToolChoice(choice) {
+function transformToolChoice(choice) {
   if (choice === "auto") {
     return "auto";
   }
@@ -1061,44 +990,123 @@ function transformChatToolChoice(choice) {
     return "required";
   }
   if (typeof choice === "object" && "name" in choice) {
-    return { type: "function", function: { name: choice.name } };
+    return { type: "function", name: choice.name };
   }
-  return void 0;
+  return "auto";
 }
-function mapChatFinishReason(finishReason) {
-  switch (finishReason) {
-    case "stop":
-      return "stop";
-    case "tool_calls":
-      return "tool_calls";
-    case "length":
+function mapFinishReason(response) {
+  if (response.status === "failed") {
+    return "error";
+  }
+  if (response.status === "incomplete") {
+    if (response.incompleteDetails?.reason === "max_output_tokens") {
       return "length";
-    case "content_filter":
+    }
+    if (response.incompleteDetails?.reason === "content_filter") {
       return "content_filter";
-    case "error":
-      return "error";
-    default:
-      return "stop";
+    }
+  }
+  const hasToolCalls = response.output.some(
+    (item) => item.type === "function_call"
+  );
+  if (hasToolCalls) {
+    return "tool_calls";
   }
+  return "stop";
 }
-function extractChatToolCalls(toolCalls) {
-  if (!toolCalls || toolCalls.length === 0) {
-    return void 0;
+function extractTextContent(output) {
+  const textParts = [];
+  for (const item of output) {
+    if (item.type === "message" && item.role === "assistant") {
+      for (const content of item.content) {
+        if (content.type === "output_text") {
+          textParts.push(content.text);
+        }
+      }
+    }
   }
-  return toolCalls.map((tc) => {
-    let parsedArgs = {};
-    try {
-      parsedArgs = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
-    } catch {
+  return textParts.length > 0 ? textParts.join("") : null;
+}
+function extractResponseWebSearchCitations(output) {
+  const citations = [];
+  for (const item of output) {
+    if (item.type !== "message" || !isRecord3(item) || !Array.isArray(item.content)) {
+      continue;
     }
-    return {
-      id: tc.id,
-      name: tc.function.name,
-      arguments: parsedArgs
-    };
-  });
+    for (const content of item.content) {
+      if (!isRecord3(content)) continue;
+      const contentRecord = content;
+      citations.push(...extractWebSearchCitations(contentRecord.annotations));
+    }
+  }
+  return citations;
 }
-function transformChatUsage(usage, actualProvider) {
+function extractToolCalls(output) {
+  const toolCalls = [];
+  for (const item of output) {
+    if (item.type === "function_call") {
+      let parsedArgs = {};
+      try {
+        parsedArgs = item.arguments ? JSON.parse(item.arguments) : {};
+      } catch {
+      }
+      toolCalls.push({
+        id: item.callId,
+        name: item.name,
+        arguments: parsedArgs
+      });
+    }
+  }
+  return toolCalls.length > 0 ? toolCalls : void 0;
+}
+function extractImages(output) {
+  const images = [];
+  for (const item of output) {
+    const itemAny = item;
+    if (itemAny.type === "image_generation_call" && itemAny.result) {
+      const imageData = itemAny.result;
+      const isDataUrl = imageData.startsWith("data:");
+      const isHttpUrl = imageData.startsWith("http://") || imageData.startsWith("https://");
+      let mediaType = "image/png";
+      if (isDataUrl) {
+        const match = imageData.match(/^data:([^;,]+)/);
+        if (match) {
+          mediaType = match[1];
+        }
+      }
+      images.push({
+        id: itemAny.id || void 0,
+        data: imageData,
+        mediaType,
+        // Include revised prompt if available
+        revisedPrompt: itemAny.revised_prompt || itemAny.revisedPrompt || void 0
+      });
+    }
+    if (itemAny.type === "message" && itemAny.content && Array.isArray(itemAny.content)) {
+      for (const content of itemAny.content) {
+        if (content.type === "output_image" || content.type === "image") {
+          const imageData = content.image || content.data || content.url || content.image_url;
+          if (imageData) {
+            let mediaType = content.media_type || content.mediaType || "image/png";
+            if (typeof imageData === "string" && imageData.startsWith("data:")) {
+              const match = imageData.match(/^data:([^;,]+)/);
+              if (match) {
+                mediaType = match[1];
+              }
+            }
+            images.push({
+              id: content.id || void 0,
+              data: imageData,
+              mediaType
+            });
+          }
+        }
+      }
+    }
+  }
+  return images.length > 0 ? images : void 0;
+}
+function transformUsage(usage, actualProvider) {
   if (!usage) {
     return {
       promptTokens: 0,
@@ -1106,62 +1114,39 @@ function transformChatUsage(usage, actualProvider) {
       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;
+  const inputTokens = usage.native_tokens_prompt || usage.nativeTokensPrompt || usage.input_tokens || usage.inputTokens || 0;
+  const outputTokens = usage.native_tokens_completion || usage.nativeTokensCompletion || usage.output_tokens || usage.outputTokens || 0;
+  const totalTokens = usage.total_tokens || usage.totalTokens || 0;
+  const reasoningTokens = usage.output_tokens_details?.reasoning_tokens || usage.outputTokensDetails?.reasoningTokens;
+  const cachedTokens = usage.input_tokens_details?.cached_tokens || usage.inputTokensDetails?.cachedTokens;
   return {
-    promptTokens,
-    completionTokens,
-    totalTokens,
-    reasoningTokens: usage.completion_tokens_details?.reasoning_tokens,
-    cachedTokens: usage.prompt_tokens_details?.cached_tokens,
+    promptTokens: inputTokens,
+    completionTokens: outputTokens,
+    totalTokens: totalTokens || inputTokens + outputTokens,
+    reasoningTokens,
+    cachedTokens,
     cost: usage.cost,
     provider: actualProvider
   };
 }
-function extractImageFromUrl(url, index) {
-  if (url.startsWith("data:")) {
-    const match = url.match(/^data:([^;]+);base64,(.+)$/);
-    if (match) {
-      return {
-        id: `image_${index}`,
-        data: match[2],
-        // base64 data without prefix
-        mediaType: match[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);
+function transformResponse(response) {
+  const content = extractTextContent(response.output);
+  const toolCalls = extractToolCalls(response.output);
+  const images = extractImages(response.output);
+  const webSearchCitations = extractResponseWebSearchCitations(response.output);
+  const providerTools = providerToolResultsFromServerToolUseOrCitations(
+    response.usage,
+    webSearchCitations,
+    response.id
+  );
   const actualProvider = response.model?.split("/")[0] || void 0;
   return {
     content,
     toolCalls,
     images,
-    finishReason: mapChatFinishReason(choice?.finish_reason),
-    usage: transformChatUsage(response.usage, actualProvider),
+    providerTools,
+    finishReason: mapFinishReason(response),
+    usage: transformUsage(response.usage, actualProvider),
     metadata: {
       model: response.model,
       provider: "openrouter",
@@ -1170,148 +1155,431 @@ function transformChatResponse(response) {
     }
   };
 }
-function createChatStreamState() {
-  return {
-    content: "",
-    toolCalls: /* @__PURE__ */ new Map(),
-    images: [],
-    reasoningContent: "",
-    hasContent: false,
-    hasReasoning: false,
-    finishReason: null,
-    reasoningDetails: []
-  };
+function extractReasoningDetails(output, streamedReasoningContent) {
+  const details = [];
+  if (output && Array.isArray(output)) {
+    for (const item of output) {
+      const itemAny = item;
+      if (itemAny.type === "reasoning") {
+        if (itemAny.summary && Array.isArray(itemAny.summary)) {
+          for (const step of itemAny.summary) {
+            if (typeof step === "string") {
+              details.push({ type: "reasoning.text", text: step });
+            }
+          }
+        }
+        if (details.length === 0 && itemAny.encrypted_content) {
+          details.push({ type: "reasoning.encrypted", text: itemAny.encrypted_content });
+        }
+        if (itemAny.content) {
+          if (typeof itemAny.content === "string") {
+            details.push({ type: "reasoning.text", text: itemAny.content });
+          } else if (Array.isArray(itemAny.content)) {
+            for (const part of itemAny.content) {
+              if (part.text) {
+                details.push({ type: "reasoning.text", text: part.text });
+              }
+            }
+          }
+        }
+      }
+      if (itemAny.type === "message" && itemAny.content && Array.isArray(itemAny.content)) {
+        for (const part of itemAny.content) {
+          if (part.type === "reasoning" || part.type === "reasoning_text") {
+            details.push({ type: "reasoning.text", text: part.text || "" });
+          }
+        }
+      }
+    }
+  }
+  if (details.length === 0 && streamedReasoningContent) {
+    details.push({ type: "reasoning.text", text: streamedReasoningContent });
+  }
+  return details.length > 0 ? details : void 0;
 }
-function accumulateReasoningDetail(state, detail) {
-  const idx = detail.index ?? 0;
-  const textContent = detail.text || detail.summary || "";
-  const detailType = detail.type === "reasoning.summary" ? "summary" : "text";
-  const existing = state.reasoningDetails.find(
-    (d) => d.type === detailType && d._index === idx
-  );
-  if (existing && existing.text !== void 0) {
-    existing.text += textContent;
-  } else {
-    state.reasoningDetails.push({
-      type: detailType,
-      text: textContent,
-      format: detail.format,
-      _index: idx
-    });
+function buildCreateParams(request) {
+  const { input, instructions } = transformMessages(request.messages);
+  const params = {
+    model: request.model,
+    input,
+    store: false
+    // Always stateless
+  };
+  if (instructions) {
+    params.instructions = instructions;
   }
-}
-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 (request.tools && request.tools.length > 0) {
+    params.tools = transformTools(request.tools, request.providerOptions);
+    if (request.toolChoice !== void 0) {
+      params.toolChoice = transformToolChoice(request.toolChoice);
+    }
+    if (request.parallelToolCalls !== void 0) {
+      params.parallelToolCalls = request.parallelToolCalls;
+    }
   }
-  if (delta?.content) {
-    state.hasContent = true;
-    state.content += delta.content;
-    chunks.push({ type: "content-delta", delta: delta.content });
+  if (request.maxOutputTokens !== void 0) {
+    params.maxOutputTokens = request.maxOutputTokens;
   }
-  const reasoningText = delta?.reasoning ?? delta?.reasoning_content;
-  if (reasoningText) {
-    state.hasReasoning = true;
-    state.reasoningContent += reasoningText;
-    chunks.push({ type: "reasoning-delta", delta: reasoningText });
+  if (request.temperature !== void 0) {
+    params.temperature = request.temperature;
   }
-  if (delta?.reasoning_details && Array.isArray(delta.reasoning_details)) {
-    for (const detail of delta.reasoning_details) {
-      if (detail.type === "reasoning.text") {
-        accumulateReasoningDetail(state, detail);
-      } else if (detail.type === "reasoning.summary") {
-        accumulateReasoningDetail(state, detail);
-      } else if (detail.type === "reasoning.encrypted") {
-        state.reasoningDetails.push({
-          type: "encrypted",
-          id: detail.id,
-          data: detail.data,
-          format: detail.format
-        });
+  if (request.topP !== void 0) {
+    params.topP = request.topP;
+  }
+  if (request.reasoning?.level !== void 0) {
+    const effortMap = {
+      10: "minimal",
+      // Basic reasoning
+      33: "low",
+      // Light reasoning
+      66: "medium",
+      // Balanced reasoning
+      100: "high"
+      // Deep reasoning
+    };
+    const effort = effortMap[request.reasoning.level];
+    if (effort) {
+      params.reasoning = {
+        effort
+      };
+    }
+  }
+  if (request.responseFormat) {
+    if (request.responseFormat.type === "json") {
+      if (request.responseFormat.schema) {
+        params.text = {
+          format: {
+            type: "json_schema",
+            name: "response",
+            schema: request.responseFormat.schema,
+            strict: true
+          }
+        };
+      } else {
+        params.text = {
+          format: { type: "json_object" }
+        };
       }
     }
   }
-  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 || ""
+  const providerOptions = splitOpenRouterProviderOptions(
+    request.providerOptions
+  );
+  if (providerOptions) {
+    Object.assign(params, providerOptions);
+  }
+  return params;
+}
+function createStreamState() {
+  return {
+    toolCalls: /* @__PURE__ */ new Map(),
+    reasoningContent: "",
+    hasContent: false,
+    hasReasoning: false,
+    currentItemId: null,
+    imageGenerations: /* @__PURE__ */ new Map()
+  };
+}
+function processStreamEvent(event, state) {
+  const chunks = [];
+  switch (event.type) {
+    // Text content streaming
+    case "response.output_text.delta":
+      state.hasContent = true;
+      chunks.push({ type: "content-delta", delta: event.delta });
+      break;
+    case "response.output_text.done":
+      break;
+    // Reasoning streaming - OpenRouter uses 'response.reasoning.delta'
+    // Note: SDK types may not include reasoning events, so we check dynamically
+    case "response.reasoning_text.delta":
+      state.hasReasoning = true;
+      state.reasoningContent += event.delta;
+      chunks.push({ type: "reasoning-delta", delta: event.delta });
+      break;
+    case "response.reasoning_text.done":
+      break;
+    // Function call and image generation streaming
+    case "response.output_item.added":
+      if (event.item.type === "function_call") {
+        const callId = event.item.callId || event.item.call_id || "";
+        const name = event.item.name || "";
+        state.toolCalls.set(callId, {
+          id: callId,
+          name,
+          arguments: ""
         });
         chunks.push({
           type: "tool-call-start",
-          id: tc.id,
-          name: tc.function.name
+          id: callId,
+          name
         });
-      } else if (existing && tc.function?.arguments) {
-        existing.arguments += tc.function.arguments;
+      }
+      if (event.item.type === "image_generation_call") {
+        const itemAny = event.item;
+        const imageId = itemAny.id || itemAny.call_id || itemAny.callId || `img-${state.imageGenerations.size}`;
+        state.imageGenerations.set(imageId, {
+          id: imageId,
+          data: "",
+          status: "in_progress"
+        });
+      }
+      break;
+    case "response.output_item.done": {
+      const itemAny = event.item;
+      if (itemAny.type === "image_generation_call" && itemAny.result) {
+        const imageId = itemAny.id || itemAny.call_id || itemAny.callId || "";
+        const imageData = itemAny.result;
+        let mediaType = "image/png";
+        if (imageData.startsWith("data:")) {
+          const match = imageData.match(/^data:([^;,]+)/);
+          if (match) mediaType = match[1];
+        }
+        const existing = state.imageGenerations.get(imageId);
+        if (existing) {
+          existing.data = imageData;
+          existing.status = "completed";
+        }
+        const imageIndex = Array.from(state.imageGenerations.keys()).indexOf(imageId);
+        chunks.push({
+          type: "image-done",
+          index: imageIndex >= 0 ? imageIndex : state.imageGenerations.size - 1,
+          image: {
+            id: imageId || void 0,
+            data: imageData,
+            mediaType,
+            revisedPrompt: itemAny.revised_prompt || itemAny.revisedPrompt || void 0
+          }
+        });
+      }
+      break;
+    }
+    case "response.function_call_arguments.delta": {
+      const itemId = event.itemId || event.item_id || "";
+      const deltaToolCall = Array.from(state.toolCalls.values()).find(
+        (tc) => tc.id === itemId
+      );
+      if (deltaToolCall) {
+        deltaToolCall.arguments += event.delta;
         chunks.push({
           type: "tool-call-delta",
-          id: existing.id,
-          argumentsDelta: tc.function.arguments
+          id: deltaToolCall.id,
+          argumentsDelta: event.delta
+        });
+      }
+      break;
+    }
+    case "response.function_call_arguments.done": {
+      const itemId = event.itemId || event.item_id || "";
+      const doneToolCall = Array.from(state.toolCalls.values()).find(
+        (tc) => tc.id === itemId
+      );
+      if (doneToolCall) {
+        let parsedArgs = {};
+        try {
+          parsedArgs = doneToolCall.arguments ? JSON.parse(doneToolCall.arguments) : {};
+        } catch {
+        }
+        chunks.push({
+          type: "tool-call-done",
+          id: doneToolCall.id,
+          arguments: parsedArgs
         });
       }
+      break;
     }
+    // Response completion
+    case "response.completed": {
+      if (state.hasContent) {
+        chunks.push({ type: "content-done" });
+      }
+      if (state.hasReasoning) {
+        chunks.push({ type: "reasoning-done" });
+      }
+      const completedProvider = event.response.model?.split("/")[0] || void 0;
+      const reasoningDetails = extractReasoningDetails(event.response.output, state.reasoningContent);
+      const generatedImages = extractImages(event.response.output);
+      if (generatedImages && generatedImages.length > 0) {
+        for (let i = 0; i < generatedImages.length; i++) {
+          const img = generatedImages[i];
+          const alreadyEmitted = img.id && state.imageGenerations.get(img.id)?.status === "completed";
+          if (!alreadyEmitted) {
+            chunks.push({
+              type: "image-done",
+              index: i,
+              image: img
+            });
+          }
+        }
+      }
+      chunks.push(...providerToolDoneChunksFromServerToolUseOrCitations(
+        event.response.usage,
+        extractResponseWebSearchCitations(event.response.output),
+        event.response.id
+      ));
+      chunks.push({
+        type: "finish",
+        finishReason: mapFinishReason(event.response),
+        usage: transformUsage(event.response.usage, completedProvider),
+        responseId: event.response.id,
+        // Used to fetch generation metadata after stream
+        reasoningDetails
+      });
+      break;
+    }
+    case "response.failed":
+      chunks.push({
+        type: "error",
+        error: event.response.error?.message || "Response generation failed",
+        code: event.response.error?.code
+      });
+      break;
+    case "response.incomplete": {
+      if (state.hasContent) {
+        chunks.push({ type: "content-done" });
+      }
+      if (state.hasReasoning) {
+        chunks.push({ type: "reasoning-done" });
+      }
+      const incompleteProvider = event.response.model?.split("/")[0] || void 0;
+      const incompleteReasoningDetails = extractReasoningDetails(event.response.output, state.reasoningContent);
+      const incompleteImages = extractImages(event.response.output);
+      if (incompleteImages && incompleteImages.length > 0) {
+        for (let i = 0; i < incompleteImages.length; i++) {
+          const img = incompleteImages[i];
+          const alreadyEmitted = img.id && state.imageGenerations.get(img.id)?.status === "completed";
+          if (!alreadyEmitted) {
+            chunks.push({
+              type: "image-done",
+              index: i,
+              image: img
+            });
+          }
+        }
+      }
+      chunks.push(...providerToolDoneChunksFromServerToolUseOrCitations(
+        event.response.usage,
+        extractResponseWebSearchCitations(event.response.output),
+        event.response.id
+      ));
+      chunks.push({
+        type: "finish",
+        finishReason: mapFinishReason(event.response),
+        usage: transformUsage(event.response.usage, incompleteProvider),
+        responseId: event.response.id,
+        // Used to fetch generation metadata after stream
+        reasoningDetails: incompleteReasoningDetails
+      });
+      break;
+    }
+    // Handle reasoning and image events dynamically (SDK types may not include them)
+    default: {
+      const eventType = event.type;
+      const eventAny = event;
+      if (eventType === "response.reasoning.delta") {
+        state.hasReasoning = true;
+        state.reasoningContent += eventAny.delta || "";
+        chunks.push({ type: "reasoning-delta", delta: eventAny.delta || "" });
+      }
+      if (eventType === "response.image_generation_call.partial_image" || eventType === "response.image_generation.partial") {
+        const imageId = eventAny.item_id || eventAny.itemId || eventAny.id || "";
+        const partialData = eventAny.partial_image || eventAny.delta || eventAny.data || "";
+        const existing = state.imageGenerations.get(imageId);
+        if (existing) {
+          existing.data += partialData;
+        } else {
+          state.imageGenerations.set(imageId, {
+            id: imageId,
+            data: partialData,
+            status: "generating"
+          });
+        }
+        const imageIndex = Array.from(state.imageGenerations.keys()).indexOf(imageId);
+        chunks.push({
+          type: "image-delta",
+          index: imageIndex >= 0 ? imageIndex : state.imageGenerations.size - 1,
+          data: partialData
+        });
+      }
+      if (eventType === "response.image_generation_call.completed" || eventType === "response.image_generation.done") {
+        const imageId = eventAny.item_id || eventAny.itemId || eventAny.id || "";
+        const imageData = eventAny.result || eventAny.image || eventAny.data || "";
+        if (imageData) {
+          let mediaType = "image/png";
+          if (imageData.startsWith("data:")) {
+            const match = imageData.match(/^data:([^;,]+)/);
+            if (match) mediaType = match[1];
+          }
+          const existing = state.imageGenerations.get(imageId);
+          if (existing) {
+            existing.data = imageData;
+            existing.status = "completed";
+          }
+          const imageIndex = Array.from(state.imageGenerations.keys()).indexOf(imageId);
+          chunks.push({
+            type: "image-done",
+            index: imageIndex >= 0 ? imageIndex : state.imageGenerations.size - 1,
+            image: {
+              id: imageId || void 0,
+              data: imageData,
+              mediaType,
+              revisedPrompt: eventAny.revised_prompt || eventAny.revisedPrompt || void 0
+            }
+          });
+        }
+      }
+      break;
+    }
+  }
+  return chunks;
+}
+function createErrorChunk(error, code) {
+  return { type: "error", error, code };
+}
+function isBase64Like2(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 truncateBase64String2(str, maxLength = 50) {
+  if (str.length <= maxLength) return str;
+  const preview = str.substring(0, maxLength);
+  return `${preview}...[truncated, ${str.length.toLocaleString()} chars]`;
+}
+function truncateBase64(obj, maxLength = 50) {
+  if (obj === null || obj === void 0) {
+    return obj;
   }
-  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 (typeof obj === "string") {
+    if (isBase64Like2(obj)) {
+      return truncateBase64String2(obj, maxLength);
     }
+    return obj;
   }
-  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 (Array.isArray(obj)) {
+    return obj.map((item) => truncateBase64(item, maxLength));
   }
-  if (chunk.usage) {
-    const actualProvider = chunk.model?.split("/")[0] || void 0;
-    const reasoningDetails = state.reasoningDetails.length > 0 ? state.reasoningDetails.map(({ _index, ...d }) => d) : void 0;
-    chunks.push({
-      type: "finish",
-      finishReason: mapChatFinishReason(state.finishReason),
-      usage: transformChatUsage(chunk.usage, actualProvider),
-      reasoningDetails
-    });
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = truncateBase64(value, maxLength);
+    }
+    return result;
   }
-  return chunks;
+  return obj;
 }
-function parseChatStreamEvent(jsonStr) {
+function parseRawStreamEvent(jsonStr) {
   try {
-    return JSON.parse(jsonStr);
+    const event = JSON.parse(jsonStr);
+    return event;
   } catch {
     return null;
   }
 }
-async function* parseChatSSEStream(response, state) {
+async function* parseSSEStream(response, state) {
   const reader = response.body?.getReader();
   if (!reader) {
     throw new Error("No response body");
@@ -1331,11 +1599,11 @@ async function* parseChatSSEStream(response, state) {
         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;
+          const event = parseRawStreamEvent(data);
+          if (event) {
+            const chunks = processStreamEvent(event, state);
+            for (const chunk of chunks) {
+              yield chunk;
             }
           }
         }
@@ -1346,118 +1614,74 @@ async function* parseChatSSEStream(response, state) {
       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;
+          const event = parseRawStreamEvent(data);
+          if (event) {
+            const chunks = processStreamEvent(event, state);
+            for (const chunk of chunks) {
+              yield chunk;
             }
           }
         }
       }
     }
-    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" };
+async function fetchGenerationMetadata(apiKey, generationId, baseUrl = "https://openrouter.ai/api/v1", signal) {
+  const url = `${baseUrl}/generation?id=${encodeURIComponent(generationId)}`;
+  const maxRetries = 3;
+  const delays = [500, 1e3, 2e3];
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      if (attempt > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delays[attempt - 1]));
       }
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`
+        },
+        signal
+      });
+      if (response.status === 404 && attempt < maxRetries - 1) {
+        continue;
+      }
+      if (!response.ok) {
+        console.error(`Failed to fetch generation metadata: ${response.status}`);
+        return null;
+      }
+      const result = await response.json();
+      if (result.error) {
+        console.error("Generation metadata error:", result.error.message);
+        return null;
+      }
+      const data = result.data;
+      if (!data) {
+        return null;
+      }
+      return {
+        id: data.id || generationId,
+        totalCost: data.total_cost || 0,
+        promptTokens: data.tokens_prompt || 0,
+        completionTokens: data.tokens_completion || 0,
+        nativePromptTokens: data.native_tokens_prompt,
+        nativeCompletionTokens: data.native_tokens_completion,
+        providerName: data.provider_name || "unknown",
+        latency: data.latency || data.generation_time,
+        model: data.model,
+        finishReason: data.finish_reason,
+        createdAt: data.created_at
+      };
+    } catch (error) {
+      if (attempt < maxRetries - 1) {
+        continue;
+      }
+      console.error("Error fetching generation metadata:", error);
+      return null;
     }
   }
-  if (request.providerOptions) {
-    const { _metadata, ...safeOptions } = request.providerOptions;
-    Object.assign(params, safeOptions);
-  }
-  return params;
-}
-function createChatErrorChunk(error, code) {
-  return { type: "error", error, code };
-}
-function isBase64Like2(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 truncateBase64String2(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 (isBase64Like2(obj)) {
-      return truncateBase64String2(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;
+  return null;
 }
 // src/vendor-icons/google.svg
@@ -1594,6 +1818,40 @@ var OpenRouterProvider = class _OpenRouterProvider {
   constructor(config) {
     this.config = config;
   }
+  static SERVER_TOOL_RESULT = {
+    status: "success",
+    result: "Handled by OpenRouter"
+  };
+  static TOOLS = {
+    web_search: defineTool({
+      description: "Search the web for up-to-date information using OpenRouter server-side web search",
+      args: z.object({}),
+      execute: async () => _OpenRouterProvider.SERVER_TOOL_RESULT,
+      executionMode: "provider",
+      executionProvider: "openrouter"
+    }),
+    web_fetch: defineTool({
+      description: "Fetch and extract content from URLs using OpenRouter server-side web fetch",
+      args: z.object({}),
+      execute: async () => _OpenRouterProvider.SERVER_TOOL_RESULT,
+      executionMode: "provider",
+      executionProvider: "openrouter"
+    }),
+    datetime: defineTool({
+      description: "Get the current date and time using OpenRouter server-side datetime",
+      args: z.object({}),
+      execute: async () => _OpenRouterProvider.SERVER_TOOL_RESULT,
+      executionMode: "provider",
+      executionProvider: "openrouter"
+    }),
+    image_generation: defineTool({
+      description: "Generate images using OpenRouter server-side image generation",
+      args: z.object({}),
+      execute: async () => _OpenRouterProvider.SERVER_TOOL_RESULT,
+      executionMode: "provider",
+      executionProvider: "openrouter"
+    })
+  };
   /**
    * Determine which API to use for a request.
    * Checks request-level providerOptions first, then falls back to config.
@@ -1616,9 +1874,44 @@ var OpenRouterProvider = class _OpenRouterProvider {
     }
     return this.client;
   }
+  applyConfiguredProvidersToResponses(params) {
+    if (this.config.providers && this.config.providers.length > 0) {
+      params.provider = { only: this.config.providers };
+    }
+  }
+  hasOpenRouterServerTools(params) {
+    return params.tools?.some(isOpenRouterServerTool) ?? false;
+  }
+  toSdkResponsesRequest(params) {
+    const { tools, ...rest } = params;
+    if (!tools) {
+      return rest;
+    }
+    const sdkTools = tools.filter(
+      (tool) => !isOpenRouterServerTool(tool)
+    );
+    return {
+      ...rest,
+      tools: sdkTools
+    };
+  }
+  async throwOpenRouterFetchError(response) {
+    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);
+  }
   supportsModel(_modelId) {
     return true;
   }
+  getTools(_modelId) {
+    return { ..._OpenRouterProvider.TOOLS };
+  }
   /**
    * Get the icon for a model as a data URI.
    * Extracts the AI lab/organization from the model ID prefix and returns
@@ -1788,14 +2081,33 @@ var OpenRouterProvider = class _OpenRouterProvider {
    * Generate using the Responses API (beta).
    */
   async generateWithResponses(request) {
-    const client = await this.getClient();
+    const apiKey = this.config.apiKey;
+    const baseUrl = this.config.baseUrl || "https://openrouter.ai/api/v1";
     try {
       const params = buildCreateParams(request);
-      if (this.config.providers && this.config.providers.length > 0) {
-        params.provider = { only: this.config.providers };
+      this.applyConfiguredProvidersToResponses(params);
+      if (this.hasOpenRouterServerTools(params)) {
+        const response2 = await fetch(`${baseUrl}/responses`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            ...params,
+            stream: false
+          }),
+          signal: request.signal
+        });
+        if (!response2.ok) {
+          await this.throwOpenRouterFetchError(response2);
+        }
+        const data = await response2.json();
+        return transformResponse(data);
       }
+      const client = await this.getClient();
       const response = await client.beta.responses.send({
-        ...params,
+        ...this.toSdkResponsesRequest(params),
         stream: false
       });
       return transformResponse(response);
@@ -1890,9 +2202,7 @@ var OpenRouterProvider = class _OpenRouterProvider {
     const baseUrl = this.config.baseUrl || "https://openrouter.ai/api/v1";
     try {
       const params = buildCreateParams(request);
-      if (this.config.providers && this.config.providers.length > 0) {
-        params.provider = { only: this.config.providers };
-      }
+      this.applyConfiguredProvidersToResponses(params);
       const response = await fetch(`${baseUrl}/responses`, {
         method: "POST",
         headers: {
@@ -2050,52 +2360,52 @@ var OpenRouterProvider = class _OpenRouterProvider {
 };
 // src/providerOptions.ts
-import { z } from "zod";
-var percentileSchema = z.union([
-  z.number(),
-  z.object({
-    p50: z.number().optional(),
-    p75: z.number().optional(),
-    p90: z.number().optional(),
-    p99: z.number().optional()
+import { z as z2 } from "zod";
+var percentileSchema = z2.union([
+  z2.number(),
+  z2.object({
+    p50: z2.number().optional(),
+    p75: z2.number().optional(),
+    p90: z2.number().optional(),
+    p99: z2.number().optional()
   })
 ]);
-var providerRoutingSchema = z.object({
+var providerRoutingSchema = z2.object({
   /** Provider slugs to try in order (e.g., ['anthropic', 'openai']) */
-  order: z.array(z.string()).optional(),
+  order: z2.array(z2.string()).optional(),
   /** Allow fallback to other providers if preferred unavailable (default: true) */
-  allow_fallbacks: z.boolean().optional(),
+  allow_fallbacks: z2.boolean().optional(),
   /** Only use providers that support all parameters in the request */
-  require_parameters: z.boolean().optional(),
+  require_parameters: z2.boolean().optional(),
   /** Control data storage policies: 'allow' or 'deny' */
-  data_collection: z.enum(["allow", "deny"]).optional(),
+  data_collection: z2.enum(["allow", "deny"]).optional(),
   /** Restrict to Zero Data Retention endpoints only */
-  zdr: z.boolean().optional(),
+  zdr: z2.boolean().optional(),
   /** Restrict to these providers only (exclusive list) */
-  only: z.array(z.string()).optional(),
+  only: z2.array(z2.string()).optional(),
   /** Skip these providers */
-  ignore: z.array(z.string()).optional(),
+  ignore: z2.array(z2.string()).optional(),
   /** Sort providers by price, throughput, or latency */
-  sort: z.union([
-    z.enum(["price", "throughput", "latency"]),
-    z.object({
-      by: z.enum(["price", "throughput", "latency"]),
-      partition: z.enum(["model", "none"]).optional()
+  sort: z2.union([
+    z2.enum(["price", "throughput", "latency"]),
+    z2.object({
+      by: z2.enum(["price", "throughput", "latency"]),
+      partition: z2.enum(["model", "none"]).optional()
     })
   ]).optional(),
   /** Maximum price constraints (hard limit - request fails if no provider meets threshold) */
-  max_price: z.object({
+  max_price: z2.object({
     /** Max price per million prompt tokens */
-    prompt: z.number().optional(),
+    prompt: z2.number().optional(),
     /** Max price per million completion tokens */
-    completion: z.number().optional(),
+    completion: z2.number().optional(),
     /** Max price per request */
-    request: z.number().optional(),
+    request: z2.number().optional(),
     /** Max price per image */
-    image: z.number().optional()
+    image: z2.number().optional()
   }).optional(),
   /** Allowed quantization levels */
-  quantizations: z.array(z.enum([
+  quantizations: z2.array(z2.enum([
     "int4",
     "int8",
     "fp4",
@@ -2111,9 +2421,16 @@ var providerRoutingSchema = z.object({
   /** Maximum latency in seconds (soft preference) */
   preferred_max_latency: percentileSchema.optional(),
   /** Restrict to models allowing text distillation */
-  enforce_distillable_text: z.boolean().optional()
+  enforce_distillable_text: z2.boolean().optional()
 }).passthrough();
-var openrouterProviderOptions = z.object({
+var serverToolParametersSchema = z2.record(z2.string(), z2.unknown());
+var serverToolsSchema = z2.object({
+  web_search: serverToolParametersSchema.optional(),
+  web_fetch: serverToolParametersSchema.optional(),
+  datetime: serverToolParametersSchema.optional(),
+  image_generation: serverToolParametersSchema.optional()
+}).partial();
+var openrouterProviderOptions = z2.object({
   /** Provider routing configuration */
   provider: providerRoutingSchema.optional(),
   /**
@@ -2125,7 +2442,14 @@ var openrouterProviderOptions = z.object({
    *
    * @default false
    */
-  useResponsesApi: z.boolean().optional()
+  useResponsesApi: z2.boolean().optional(),
+  /**
+   * Parameters for OpenRouter provider-executed server tools.
+   *
+   * Tool availability is controlled by model `providerTools`; this object only
+   * supplies per-tool OpenRouter options.
+   */
+  serverTools: serverToolsSchema.optional()
 }).passthrough();
 // src/index.ts