@standardagents/openrouter 0.11.4 → 0.11.6

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/OpenRouterProvider.ts
 import { ProviderError } from "@standardagents/spec";
 
-// src/transformers.ts
+// src/responses-transformers.ts
 function transformContentPart(part) {
   if (part.type === "text") {
     return { type: "input_text", text: part.text };
@@ -871,6 +871,548 @@ async function fetchGenerationMetadata(apiKey, generationId, baseUrl = "https://
   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"
+      }
+    };
+  }
+  return {
+    type: "text",
+    text: `[File: ${part.filename || "file"}]`
+  };
+}
+function transformChatMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map(transformChatContentPart);
+}
+function transformChatSystemMessage(msg) {
+  return {
+    role: "system",
+    content: msg.content
+  };
+}
+function transformChatUserMessage(msg) {
+  return {
+    role: "user",
+    content: transformChatMessageContent(msg.content)
+  };
+}
+function transformChatAssistantMessage(msg) {
+  const message = {
+    role: "assistant",
+    content: msg.content || null
+  };
+  if (msg.toolCalls && msg.toolCalls.length > 0) {
+    message.tool_calls = msg.toolCalls.map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: {
+        name: tc.name,
+        arguments: typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments)
+      }
+    }));
+  }
+  return message;
+}
+function transformChatToolMessage(msg) {
+  let output;
+  if (typeof msg.content === "string") {
+    output = msg.content;
+  } else if ("type" in msg.content) {
+    if (msg.content.type === "text") {
+      output = msg.content.text;
+    } else if (msg.content.type === "error") {
+      output = `Error: ${msg.content.error}`;
+    } else {
+      output = JSON.stringify(msg.content);
+    }
+  } else {
+    output = JSON.stringify(msg.content);
+  }
+  const imageAttachments = msg.attachments?.filter((a) => a.type === "image" && a.data) || [];
+  const toolMessage = {
+    role: "tool",
+    tool_call_id: msg.toolCallId,
+    content: output || (imageAttachments.length > 0 ? "Success" : "")
+  };
+  if (imageAttachments.length === 0) {
+    return { toolMessage };
+  }
+  const imageContent = [];
+  const toolName = msg.toolName || "the tool";
+  const isSingle = imageAttachments.length === 1;
+  const descriptor = isSingle ? "the file" : `${imageAttachments.length} files`;
+  const verb = isSingle ? "is" : "are";
+  imageContent.push({
+    type: "text",
+    text: `Here ${verb} ${descriptor} from ${toolName}:`
+  });
+  for (const attachment of imageAttachments) {
+    const attachmentData = attachment.data || "";
+    const imageData = attachmentData.startsWith("data:") ? attachmentData : `data:${attachment.mediaType || "image/png"};base64,${attachmentData}`;
+    imageContent.push({
+      type: "image_url",
+      image_url: {
+        url: imageData,
+        detail: "auto"
+      }
+    });
+  }
+  const syntheticUserMessage = {
+    role: "user",
+    content: imageContent
+  };
+  return { toolMessage, syntheticUserMessage };
+}
+function transformChatMessages(messages) {
+  const result = [];
+  for (const msg of messages) {
+    switch (msg.role) {
+      case "system":
+        result.push(transformChatSystemMessage(msg));
+        break;
+      case "user":
+        result.push(transformChatUserMessage(msg));
+        break;
+      case "assistant":
+        result.push(transformChatAssistantMessage(msg));
+        break;
+      case "tool": {
+        const { toolMessage, syntheticUserMessage } = transformChatToolMessage(msg);
+        result.push(toolMessage);
+        if (syntheticUserMessage) {
+          result.push(syntheticUserMessage);
+        }
+        break;
+      }
+    }
+  }
+  return result;
+}
+function transformChatTool(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
+    };
+  }
+  return {
+    type: "function",
+    function: {
+      name: tool.function.name,
+      description: tool.function.description || void 0,
+      parameters,
+      strict: true
+    }
+  };
+}
+function transformChatTools(tools) {
+  return tools.map(transformChatTool);
+}
+function transformChatToolChoice(choice) {
+  if (choice === "auto") {
+    return "auto";
+  }
+  if (choice === "none") {
+    return "none";
+  }
+  if (choice === "required") {
+    return "required";
+  }
+  if (typeof choice === "object" && "name" in choice) {
+    return { type: "function", function: { name: choice.name } };
+  }
+  return void 0;
+}
+function mapChatFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "tool_calls":
+      return "tool_calls";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content_filter";
+    case "error":
+      return "error";
+    default:
+      return "stop";
+  }
+}
+function extractChatToolCalls(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0) {
+    return void 0;
+  }
+  return toolCalls.map((tc) => {
+    let parsedArgs = {};
+    try {
+      parsedArgs = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+    } catch {
+    }
+    return {
+      id: tc.id,
+      name: tc.function.name,
+      arguments: parsedArgs
+    };
+  });
+}
+function transformChatUsage(usage, actualProvider) {
+  if (!usage) {
+    return {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0
+    };
+  }
+  const promptTokens = usage.native_tokens_prompt || usage.prompt_tokens || 0;
+  const completionTokens = usage.native_tokens_completion || usage.completion_tokens || 0;
+  const totalTokens = usage.total_tokens || promptTokens + completionTokens;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    reasoningTokens: usage.completion_tokens_details?.reasoning_tokens,
+    cachedTokens: usage.prompt_tokens_details?.cached_tokens,
+    cost: usage.cost,
+    provider: actualProvider
+  };
+}
+function extractImageFromUrl(url, index) {
+  if (url.startsWith("data:")) {
+    const 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 actualProvider = response.model?.split("/")[0] || void 0;
+  return {
+    content,
+    toolCalls,
+    images,
+    finishReason: mapChatFinishReason(choice?.finish_reason),
+    usage: transformChatUsage(response.usage, actualProvider),
+    metadata: {
+      model: response.model,
+      provider: "openrouter",
+      actualProvider,
+      requestId: response.id
+    }
+  };
+}
+function createChatStreamState() {
+  return {
+    content: "",
+    toolCalls: /* @__PURE__ */ new Map(),
+    images: [],
+    reasoningContent: "",
+    hasContent: false,
+    hasReasoning: false,
+    finishReason: null
+  };
+}
+function processChatStreamChunk(chunk, state) {
+  const chunks = [];
+  const choice = chunk.choices?.[0];
+  const delta = choice?.delta;
+  if (!delta && !choice?.finish_reason && !chunk.usage) {
+    return chunks;
+  }
+  if (delta?.content) {
+    state.hasContent = true;
+    state.content += delta.content;
+    chunks.push({ type: "content-delta", delta: delta.content });
+  }
+  if (delta?.reasoning_content) {
+    state.hasReasoning = true;
+    state.reasoningContent += delta.reasoning_content;
+    chunks.push({ type: "reasoning-delta", delta: delta.reasoning_content });
+  }
+  if (delta?.tool_calls) {
+    for (const tc of delta.tool_calls) {
+      const index = tc.index;
+      const existing = state.toolCalls.get(index);
+      if (tc.id && tc.function?.name) {
+        state.toolCalls.set(index, {
+          id: tc.id,
+          name: tc.function.name,
+          arguments: tc.function.arguments || ""
+        });
+        chunks.push({
+          type: "tool-call-start",
+          id: tc.id,
+          name: tc.function.name
+        });
+      } else if (existing && tc.function?.arguments) {
+        existing.arguments += tc.function.arguments;
+        chunks.push({
+          type: "tool-call-delta",
+          id: existing.id,
+          argumentsDelta: tc.function.arguments
+        });
+      }
+    }
+  }
+  if (delta?.images && delta.images.length > 0) {
+    for (const img of delta.images) {
+      const index = state.images.length;
+      const providerImage = extractImageFromUrl(img.image_url.url, index);
+      state.images.push(providerImage);
+      chunks.push({
+        type: "image-done",
+        index,
+        image: providerImage
+      });
+    }
+  }
+  if (choice?.finish_reason) {
+    state.finishReason = choice.finish_reason;
+    if (state.hasContent) {
+      chunks.push({ type: "content-done" });
+    }
+    if (state.hasReasoning) {
+      chunks.push({ type: "reasoning-done" });
+    }
+    for (const tc of state.toolCalls.values()) {
+      let parsedArgs = {};
+      try {
+        parsedArgs = tc.arguments ? JSON.parse(tc.arguments) : {};
+      } catch {
+      }
+      chunks.push({
+        type: "tool-call-done",
+        id: tc.id,
+        arguments: parsedArgs
+      });
+    }
+  }
+  if (chunk.usage) {
+    const actualProvider = chunk.model?.split("/")[0] || void 0;
+    chunks.push({
+      type: "finish",
+      finishReason: mapChatFinishReason(state.finishReason),
+      usage: transformChatUsage(chunk.usage, actualProvider),
+      responseId: chunk.id
+    });
+  }
+  return chunks;
+}
+function parseChatStreamEvent(jsonStr) {
+  try {
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
+  }
+}
+async function* parseChatSSEStream(response, state) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No response body");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith(":")) continue;
+        if (trimmed.startsWith("data: ")) {
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") continue;
+          const chunk = parseChatStreamEvent(data);
+          if (chunk) {
+            const providerChunks = processChatStreamChunk(chunk, state);
+            for (const c of providerChunks) {
+              yield c;
+            }
+          }
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const trimmed = buffer.trim();
+      if (trimmed.startsWith("data: ")) {
+        const data = trimmed.slice(6);
+        if (data !== "[DONE]") {
+          const chunk = parseChatStreamEvent(data);
+          if (chunk) {
+            const providerChunks = processChatStreamChunk(chunk, state);
+            for (const c of providerChunks) {
+              yield c;
+            }
+          }
+        }
+      }
+    }
+    if (state.finishReason && !state.toolCalls.size) {
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function buildChatParams(request) {
+  const messages = transformChatMessages(request.messages);
+  const params = {
+    model: request.model,
+    messages
+  };
+  if (request.tools && request.tools.length > 0) {
+    params.tools = transformChatTools(request.tools);
+    const toolChoice = transformChatToolChoice(request.toolChoice);
+    if (toolChoice !== void 0) {
+      params.tool_choice = toolChoice;
+    }
+    if (request.parallelToolCalls !== void 0) {
+      params.parallel_tool_calls = request.parallelToolCalls;
+    }
+  }
+  if (request.maxOutputTokens !== void 0) {
+    params.max_tokens = request.maxOutputTokens;
+  }
+  if (request.temperature !== void 0) {
+    params.temperature = request.temperature;
+  }
+  if (request.topP !== void 0) {
+    params.top_p = request.topP;
+  }
+  if (request.reasoning?.level !== void 0) {
+    const effortMap = {
+      10: "minimal",
+      33: "low",
+      66: "medium",
+      100: "high"
+    };
+    const effort = effortMap[request.reasoning.level];
+    if (effort) {
+      params.reasoning = { effort };
+    }
+  }
+  if (request.responseFormat) {
+    if (request.responseFormat.type === "json") {
+      if (request.responseFormat.schema) {
+        params.response_format = {
+          type: "json_schema",
+          json_schema: {
+            name: "response",
+            schema: request.responseFormat.schema,
+            strict: true
+          }
+        };
+      } else {
+        params.response_format = { type: "json_object" };
+      }
+    }
+  }
+  if (request.providerOptions) {
+    const { _metadata, ...safeOptions } = request.providerOptions;
+    Object.assign(params, safeOptions);
+  }
+  return params;
+}
+function createChatErrorChunk(error, code) {
+  return { type: "error", error, code };
+}
+function 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;
+}
+
 // src/icons.ts
 var ANTHROPIC_ICON = `<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48" fill="none">
 <rect width="48" height="48" fill="#F0EFEA"/>
@@ -1002,6 +1544,17 @@ var OpenRouterProvider = class _OpenRouterProvider {
   constructor(config) {
     this.config = config;
   }
+  /**
+   * Determine which API to use for a request.
+   * Checks request-level providerOptions first, then falls back to config.
+   * Defaults to Chat Completions (stable API).
+   */
+  getApiMode(request) {
+    if (request?.providerOptions?.useResponsesApi === true) {
+      return "responses";
+    }
+    return "chat";
+  }
   async getClient() {
     if (!this.client) {
       const { OpenRouter } = await import("@openrouter/sdk");
@@ -1138,6 +1691,53 @@ var OpenRouterProvider = class _OpenRouterProvider {
   // Generation Methods
   // ============================================================================
   async generate(request) {
+    const apiMode = this.getApiMode(request);
+    if (apiMode === "responses") {
+      return this.generateWithResponses(request);
+    }
+    return this.generateWithChat(request);
+  }
+  /**
+   * Generate using the Chat Completions API (default).
+   */
+  async generateWithChat(request) {
+    const apiKey = this.config.apiKey;
+    const baseUrl = this.config.baseUrl || "https://openrouter.ai/api/v1";
+    try {
+      const params = buildChatParams(request);
+      if (this.config.providers && this.config.providers.length > 0) {
+        params.provider = { only: this.config.providers };
+      }
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(params),
+        signal: request.signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorMessage = `OpenRouter API error: ${response.status}`;
+        try {
+          const errorJson = JSON.parse(errorText);
+          errorMessage = errorJson.error?.message || errorJson.message || errorMessage;
+        } catch {
+          errorMessage = errorText || errorMessage;
+        }
+        throw new ProviderError(errorMessage, "invalid_request", response.status);
+      }
+      const data = await response.json();
+      return transformChatResponse(data);
+    } catch (error) {
+      throw this.toProviderError(error);
+    }
+  }
+  /**
+   * Generate using the Responses API (beta).
+   */
+  async generateWithResponses(request) {
     const client = await this.getClient();
     try {
       const params = buildCreateParams(request);
@@ -1154,6 +1754,87 @@ var OpenRouterProvider = class _OpenRouterProvider {
     }
   }
   async stream(request) {
+    const apiMode = this.getApiMode(request);
+    if (apiMode === "responses") {
+      return this.streamWithResponses(request);
+    }
+    return this.streamWithChat(request);
+  }
+  /**
+   * Stream using the Chat Completions API (default).
+   */
+  async streamWithChat(request) {
+    const self = this;
+    const apiKey = this.config.apiKey;
+    const baseUrl = this.config.baseUrl || "https://openrouter.ai/api/v1";
+    try {
+      const params = buildChatParams(request);
+      if (this.config.providers && this.config.providers.length > 0) {
+        params.provider = { only: this.config.providers };
+      }
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          ...params,
+          stream: true,
+          stream_options: { include_usage: true }
+        }),
+        signal: request.signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorMessage = `OpenRouter API error: ${response.status}`;
+        try {
+          const errorJson = JSON.parse(errorText);
+          errorMessage = errorJson.error?.message || errorJson.message || errorMessage;
+        } catch {
+          errorMessage = errorText || errorMessage;
+        }
+        throw new ProviderError(errorMessage, "invalid_request", response.status);
+      }
+      return {
+        async *[Symbol.asyncIterator]() {
+          const state = createChatStreamState();
+          let finishChunk = null;
+          let responseId = null;
+          try {
+            for await (const chunk of parseChatSSEStream(response, state)) {
+              if (chunk.type === "finish") {
+                finishChunk = chunk;
+                responseId = chunk.responseId || null;
+              } else {
+                yield chunk;
+              }
+            }
+            if (finishChunk) {
+              const finishWithMeta = {
+                ...finishChunk,
+                _asyncMetadata: responseId ? {
+                  generationId: responseId,
+                  apiKey,
+                  baseUrl
+                } : void 0
+              };
+              yield finishWithMeta;
+            }
+          } catch (error) {
+            const providerError = self.toProviderError(error);
+            yield createChatErrorChunk(providerError.message, providerError.code);
+          }
+        }
+      };
+    } catch (error) {
+      throw this.toProviderError(error);
+    }
+  }
+  /**
+   * Stream using the Responses API (beta).
+   */
+  async streamWithResponses(request) {
     const self = this;
     const apiKey = this.config.apiKey;
     const baseUrl = this.config.baseUrl || "https://openrouter.ai/api/v1";
@@ -1286,19 +1967,33 @@ var OpenRouterProvider = class _OpenRouterProvider {
   // Inspection
   // ============================================================================
   /**
-   * Transform a ProviderRequest to OpenRouter Responses API format for inspection.
+   * Transform a ProviderRequest to the appropriate API format for inspection.
    * Returns the exact request body that would be sent to OpenRouter, with base64 data truncated.
    */
   async inspectRequest(request) {
-    const params = buildCreateParams(request);
+    const apiMode = this.getApiMode(request);
+    if (apiMode === "responses") {
+      const params2 = buildCreateParams(request);
+      if (this.config.providers && this.config.providers.length > 0) {
+        params2.provider = { only: this.config.providers };
+      }
+      return {
+        body: truncateBase64(params2),
+        messagesPath: "input",
+        metadata: {
+          endpoint: "https://openrouter.ai/api/v1/responses"
+        }
+      };
+    }
+    const params = buildChatParams(request);
     if (this.config.providers && this.config.providers.length > 0) {
       params.provider = { only: this.config.providers };
     }
     return {
-      body: truncateBase64(params),
-      messagesPath: "input",
+      body: truncateChatBase64(params),
+      messagesPath: "messages",
       metadata: {
-        endpoint: "https://openrouter.ai/api/v1/responses"
+        endpoint: "https://openrouter.ai/api/v1/chat/completions"
       }
     };
   }
@@ -1370,7 +2065,17 @@ var providerRoutingSchema = z.object({
 }).passthrough();
 var openrouterProviderOptions = z.object({
   /** Provider routing configuration */
-  provider: providerRoutingSchema.optional()
+  provider: providerRoutingSchema.optional(),
+  /**
+   * Use OpenRouter's Responses API (beta) instead of the Chat Completions API.
+   *
+   * By default, the provider uses the stable Chat Completions API.
+   * Set this to true to use the Responses API which has some additional
+   * features but may be less stable.
+   *
+   * @default false
+   */
+  useResponsesApi: z.boolean().optional()
 }).passthrough();
 
 // src/index.ts