@standardagents/builder 0.11.4 → 0.11.5

package/dist/built-in-routes.js

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