@absolutejs/ai 0.0.49 → 0.0.51

package/dist/ai/providers/openaiResponses.js

@@ -6,7 +6,8 @@ var PROVIDER_STATUS_PAGES = {
   anthropic: "https://status.claude.com",
   gemini: "https://status.cloud.google.com",
   google: "https://status.cloud.google.com",
-  openai: "https://status.openai.com"
+  openai: "https://status.openai.com",
+  openrouter: "https://status.openrouter.ai"
 };
 var RETRYABLE_STATUSES = new Set([
   408,
@@ -42,6 +43,7 @@ class ProviderError extends Error {
   status;
   type;
   retryable;
+  metadata;
   statusPageUrl;
   constructor(init) {
     super(init.message, init.cause === undefined ? undefined : { cause: init.cause });
@@ -50,6 +52,7 @@ class ProviderError extends Error {
     this.status = init.status ?? null;
     this.type = init.type ?? null;
     this.retryable = init.retryable;
+    this.metadata = init.metadata;
     this.statusPageUrl = providerStatusPage(init.provider);
   }
   static fromResponse(provider, status, body, type) {
@@ -222,7 +225,8 @@ var withResilience = (provider, providerName = "unknown") => {
         yield* attempt(params, attemptNo + 1);
         return;
       }
-      noteFailure(providerName, providerError);
+      if (providerError.retryable)
+        noteFailure(providerName, providerError);
       throw providerError;
     }
   };
@@ -398,7 +402,7 @@ var mapBlockToResponsesFormat = (block) => {
   if (block.type === "image") {
     return {
       image_url: {
-        url: `data:${block.source.media_type};base64,${block.source.data}`
+        url: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`
       },
       type: "input_image"
     };
@@ -406,12 +410,24 @@ var mapBlockToResponsesFormat = (block) => {
   if (block.type === "document") {
     return {
       file: {
-        file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+        file_data: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`,
         filename: block.name ?? "document.pdf"
       },
       type: "input_file"
     };
   }
+  if (block.type === "audio") {
+    return {
+      input_audio: { data: block.source.data, format: block.source.format },
+      type: "input_audio"
+    };
+  }
+  if (block.type === "video") {
+    return {
+      type: "input_video",
+      video_url: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`
+    };
+  }
   return null;
 };
 var mapContentToResponsesFormat = (content) => {
@@ -423,7 +439,12 @@ var mapContentToResponsesFormat = (content) => {
 };
 var hasToolBlocks = (content) => content.some((block) => block.type === "tool_use" || block.type === "tool_result");
 var convertToolBlock = (block) => {
+  if (block.type === "provider_data" && block.provider === "openrouter") {
+    return { ...block.data };
+  }
   if (block.type === "tool_use") {
+    if (block.providerData)
+      return { ...block.providerData };
     return {
       arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input),
       call_id: block.id,
@@ -475,7 +496,7 @@ var buildTools = (tools, isImageModel) => {
   }
   return result.length > 0 ? result : undefined;
 };
-var buildRequestBody = (params, isImageModel) => {
+var buildRequestBody = (params, isImageModel, capabilityModel = params.model) => {
   const body = {
     input: buildInput(params.messages),
     model: params.model,
@@ -527,8 +548,8 @@ var buildRequestBody = (params, isImageModel) => {
       };
     }
   }
-  if (params.reasoning && isOpenAIReasoningModel(params.model)) {
-    const effort = openaiEffortValue(params.model, params.reasoning);
+  if (params.reasoning && isOpenAIReasoningModel(capabilityModel)) {
+    const effort = openaiEffortValue(capabilityModel, params.reasoning);
     if (effort) {
       body.reasoning = {
         effort,
@@ -559,11 +580,32 @@ var extractUsage = (response) => {
   const { usage } = response;
   const input = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
   const cached = isRecord(usage.input_tokens_details) && typeof usage.input_tokens_details.cached_tokens === "number" ? usage.input_tokens_details.cached_tokens : 0;
-  return {
+  const outputDetails = isRecord(usage.output_tokens_details) ? usage.output_tokens_details : undefined;
+  const inputDetails = isRecord(usage.input_tokens_details) ? usage.input_tokens_details : undefined;
+  const costDetails = isRecord(usage.cost_details) ? usage.cost_details : undefined;
+  const normalized = {
     cacheReadInputTokens: cached,
+    cacheWriteInputTokens: inputDetails && typeof inputDetails.cache_write_tokens === "number" ? inputDetails.cache_write_tokens : undefined,
+    costCredits: typeof usage.cost === "number" ? usage.cost : undefined,
     inputTokens: Math.max(0, input - cached),
-    outputTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0
+    outputTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0,
+    reasoningTokens: outputDetails && typeof outputDetails.reasoning_tokens === "number" ? outputDetails.reasoning_tokens : undefined,
+    upstreamInferenceCostCredits: costDetails && typeof costDetails.upstream_inference_cost === "number" ? costDetails.upstream_inference_cost : undefined
   };
+  if (isRecord(usage.server_tool_use)) {
+    normalized.serverToolUse = Object.fromEntries(Object.entries(usage.server_tool_use).filter((entry) => typeof entry[1] === "number"));
+  }
+  return normalized;
+};
+var extractResponseMetadata = (response) => {
+  const providerMetadata = isRecord(response.openrouter_metadata) ? response.openrouter_metadata : undefined;
+  const generationId = typeof response.id === "string" ? response.id : undefined;
+  const model = typeof response.model === "string" ? response.model : undefined;
+  const provider = typeof response.provider === "string" ? response.provider : undefined;
+  const serviceTier = typeof response.service_tier === "string" ? response.service_tier : undefined;
+  if (!providerMetadata && !generationId && !model && !provider && !serviceTier)
+    return;
+  return { generationId, model, provider, providerMetadata, serviceTier };
 };
 var extractMimeFormat = (mimeType) => {
   if (typeof mimeType !== "string") {
@@ -620,6 +662,7 @@ var processFunctionCallArgumentsDone = function* (parsed, pendingCalls) {
     id: callId || pending?.callId || itemId,
     input: parseToolInput(args),
     name,
+    providerData: pending?.providerData ? { ...pending.providerData, arguments: args } : undefined,
     type: "tool_use"
   };
 };
@@ -638,9 +681,21 @@ var processOutputItemAdded = (parsed, pendingCalls) => {
   pendingCalls.set(itemId, {
     arguments: "",
     callId,
-    name
+    name,
+    providerData: { ...item }
   });
 };
+var processOutputItemDone = function* (parsed) {
+  if (!isRecord(parsed.item) || typeof parsed.item.type !== "string")
+    return;
+  if (!parsed.item.type.startsWith("openrouter:"))
+    return;
+  yield {
+    data: { ...parsed.item },
+    provider: "openrouter",
+    type: "provider_event"
+  };
+};
 var isCompletedImageGeneration = (item) => item.type === "image_generation_call" && item.status === "completed" && typeof item.result === "string" && item.result !== "";
 var buildImageChunk = (item) => ({
   data: typeof item.result === "string" ? item.result : "",
@@ -656,6 +711,30 @@ var extractImageFromOutput = function* (output) {
     yield buildImageChunk(item);
   }
 };
+var extractCitationsFromOutput = function* (output) {
+  for (const item of output) {
+    if (!isRecordArray(item.content))
+      continue;
+    for (const content of item.content) {
+      if (!Array.isArray(content.annotations))
+        continue;
+      for (const annotation of content.annotations) {
+        if (!isRecord(annotation) || annotation.type !== "url_citation")
+          continue;
+        if (typeof annotation.url !== "string")
+          continue;
+        yield {
+          content: typeof annotation.content === "string" ? annotation.content : undefined,
+          endIndex: typeof annotation.end_index === "number" ? annotation.end_index : undefined,
+          startIndex: typeof annotation.start_index === "number" ? annotation.start_index : undefined,
+          title: typeof annotation.title === "string" ? annotation.title : undefined,
+          type: "citation",
+          url: annotation.url
+        };
+      }
+    }
+  }
+};
 var processCompleted = function* (parsed) {
   if (!isRecord(parsed.response)) {
     yield { type: "done", usage: undefined };
@@ -663,12 +742,26 @@ var processCompleted = function* (parsed) {
   }
   const { response } = parsed;
   const usage = extractUsage(response);
+  const metadata = extractResponseMetadata(response);
   if (isRecordArray(response.output)) {
+    yield* extractCitationsFromOutput(response.output);
     yield* extractImageFromOutput(response.output);
   }
-  yield { type: "done", usage };
+  yield { metadata, type: "done", usage };
 };
-var processSSEEvent = function* (eventType, parsed, pendingCalls) {
+var responseFailure = (eventType, parsed, providerName) => {
+  const response = isRecord(parsed.response) ? parsed.response : parsed;
+  const error = isRecord(response.error) ? response.error : undefined;
+  const type = typeof response.error_type === "string" ? response.error_type : error && typeof error.code === "string" ? error.code : eventType;
+  return new ProviderError({
+    message: error && typeof error.message === "string" ? error.message : `OpenRouter Responses API: ${eventType}`,
+    metadata: response,
+    provider: providerName,
+    retryable: type === "rate_limit_exceeded" || type === "provider_overloaded" || type === "provider_unavailable" || type === "server",
+    type
+  });
+};
+var processSSEEvent = function* (eventType, parsed, pendingCalls, providerName) {
   switch (eventType) {
     case "response.reasoning_summary_text.delta": {
       const delta = typeof parsed.delta === "string" ? parsed.delta : "";
@@ -689,6 +782,9 @@ var processSSEEvent = function* (eventType, parsed, pendingCalls) {
     case "response.output_item.added":
       processOutputItemAdded(parsed, pendingCalls);
       break;
+    case "response.output_item.done":
+      yield* processOutputItemDone(parsed);
+      break;
     case "response.function_call_arguments.delta":
       processFunctionCallArgumentsDelta(parsed, pendingCalls);
       break;
@@ -699,11 +795,10 @@ var processSSEEvent = function* (eventType, parsed, pendingCalls) {
       yield* processCompleted(parsed);
       break;
     case "response.failed":
-    case "response.incomplete": {
-      const respObj = isRecord(parsed.response) ? parsed.response : parsed;
-      const errMsg = isRecord(respObj.error) && typeof respObj.error.message === "string" ? respObj.error.message : `OpenAI Responses API: ${eventType}`;
-      throw new Error(errMsg);
-    }
+    case "response.incomplete":
+    case "response.error":
+    case "error":
+      throw responseFailure(eventType, parsed, providerName);
   }
 };
 var flushSSEBuffer = function* (state) {
@@ -712,7 +807,7 @@ var flushSSEBuffer = function* (state) {
   }
   const parsed = parseJSON(state.buffer);
   if (parsed) {
-    yield* processSSEEvent(state.currentEvent, parsed, state.pendingCalls);
+    yield* processSSEEvent(state.currentEvent, parsed, state.pendingCalls, state.providerName);
   }
   state.currentEvent = "";
   state.buffer = "";
@@ -750,41 +845,47 @@ var drainReader = async function* (reader, decoder, state, signal) {
     yield* processSSELines([textBuffer, ""], state);
   }
 };
-var parseSSEStream = async function* (body, signal) {
+var parseSSEStream = async function* (body, providerName, signal) {
   const reader = body.getReader();
   const decoder = new TextDecoder;
   const state = {
     buffer: "",
     currentEvent: "",
     pendingCalls: new Map,
-    usage: undefined
+    usage: undefined,
+    providerName
   };
   try {
     yield* drainReader(reader, decoder, state, signal);
+    yield* flushSSEBuffer(state);
   } finally {
     reader.releaseLock();
   }
 };
-var fetchResponsesStream = async function* (baseUrl, apiKey, body, signal) {
+var fetchResponsesStream = async function* (baseUrl, apiKey, body, fetchImpl, headers, providerName, signal) {
   const target = `${baseUrl}/v1/responses`;
-  const response = await fetch(target, {
+  const requestHeaders = new Headers(headers);
+  requestHeaders.set("Authorization", `Bearer ${apiKey}`);
+  requestHeaders.set("Content-Type", "application/json");
+  const response = await fetchImpl(target, {
     ...h2IfHttps(target),
     body: JSON.stringify(body),
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      "Content-Type": "application/json"
-    },
+    headers: requestHeaders,
     method: "POST",
     signal
   });
   if (!response.ok) {
     const errorText = await response.text();
-    throw new Error(`OpenAI Responses API error ${response.status}: ${errorText}`);
+    throw ProviderError.fromResponse(providerName, response.status, errorText);
   }
   if (!response.body) {
-    throw new Error("OpenAI Responses API returned no response body");
+    throw new ProviderError({
+      message: `${providerName} Responses API returned no response body`,
+      provider: providerName,
+      retryable: true
+    });
   }
-  yield* parseSSEStream(response.body, signal);
+  yield* parseSSEStream(response.body, providerName, signal);
 };
 var resolveImageModels = (imageModels) => {
   if (!imageModels) {
@@ -796,19 +897,32 @@ var resolveImageModels = (imageModels) => {
   return new Set(imageModels);
 };
 var openaiResponses = (config2) => {
+  if (!config2.apiKey && !config2.tokenSource)
+    throw new Error("openaiResponses() requires either apiKey or tokenSource");
   const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL;
+  const fetchImpl = config2.fetch ?? globalThis.fetch;
   const imageModels = resolveImageModels(config2.imageModels);
+  const providerName = config2.providerName ?? "openai-responses";
+  const resolveKey = async () => config2.tokenSource ? await Promise.resolve(config2.tokenSource()) : config2.apiKey;
+  const resolveHeaders = async (params) => typeof config2.headers === "function" ? await config2.headers(params) : config2.headers ?? {};
   return instrumentAIProvider({
     stream: (params) => {
       const isImageModel = imageModels.has(params.model);
-      const body = buildRequestBody(params, isImageModel);
-      return fetchResponsesStream(baseUrl, config2.apiKey, body, params.signal);
+      const builtBody = buildRequestBody(params, isImageModel, config2.modelForCapabilities?.(params.model) ?? params.model);
+      const body = config2.transformRequestBody ? config2.transformRequestBody(builtBody, params) : builtBody;
+      return async function* () {
+        const [apiKey, headers] = await Promise.all([
+          resolveKey(),
+          resolveHeaders(params)
+        ]);
+        yield* fetchResponsesStream(baseUrl, apiKey, body, fetchImpl, headers, providerName, params.signal);
+      }();
     }
-  }, "openai-responses");
+  }, providerName);
 };
 export {
   openaiResponses
 };
 
-//# debugId=4A6E4265943028D264756E2164756E21
+//# debugId=6FB19A09EAF4F0BB64756E2164756E21
 //# sourceMappingURL=openaiResponses.js.map