@absolutejs/ai 0.0.55 → 0.0.57

package/dist/ai/providers/openai.js

@@ -1,6 +1,286 @@
 // @bun
 var __require = import.meta.require;
 
+// src/ai/inputCapacity.ts
+class AIInputError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AIInputError";
+  }
+}
+var positiveTokenLimit = (value) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
+    throw new AIInputError("capacity_unavailable", "The provider did not supply a valid model limit.");
+  return value;
+};
+var inputTokenCount = (value) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+    throw new AIInputError("capacity_unavailable", "The provider did not supply a valid token count.");
+  return value;
+};
+var inspectAIInput = async (provider, params) => {
+  params.signal?.throwIfAborted();
+  if (!provider.inputCapacity)
+    throw new AIInputError("capacity_unavailable", "This provider does not expose model capacity and token counting.");
+  const [limits, tokens] = await Promise.all([
+    provider.inputCapacity.getLimits(params),
+    provider.inputCapacity.countTokens(params)
+  ]);
+  const inputTokens = inputTokenCount(tokens);
+  const outputTokens = positiveTokenLimit(provider.inputCapacity.outputTokens?.(params) ?? params.maxTokens ?? limits.maxOutputTokens);
+  const maxInputTokens = positiveTokenLimit(limits.maxInputTokens);
+  const maxOutputTokens = positiveTokenLimit(limits.maxOutputTokens);
+  const availableInputTokens = Math.max(0, Math.min(maxInputTokens, limits.contextWindowTokens === undefined ? maxInputTokens : positiveTokenLimit(limits.contextWindowTokens) - outputTokens));
+  return {
+    limits,
+    inputTokens,
+    outputTokens,
+    availableInputTokens,
+    fits: outputTokens <= maxOutputTokens && inputTokens <= availableInputTokens
+  };
+};
+var cacheModelLimits = (load, ttlMs = 300000) => {
+  const cache = new Map;
+  return async (params) => {
+    const entry = cache.get(params.model);
+    if (entry && Date.now() - entry.at < ttlMs)
+      return entry.limits;
+    const limits = await load(params);
+    positiveTokenLimit(limits.maxInputTokens);
+    positiveTokenLimit(limits.maxOutputTokens);
+    if (cache.size >= 100)
+      cache.clear();
+    cache.set(params.model, { at: Date.now(), limits });
+    return limits;
+  };
+};
+var capacityJson = async (response) => {
+  if (!response.ok)
+    throw new AIInputError("capacity_unavailable", `Model capacity request failed (${response.status}).`);
+  const value = await response.json();
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new AIInputError("capacity_unavailable", "Model capacity response was invalid.");
+  return value;
+};
+
+// src/ai/providers/openaiCapacity.ts
+var LIMITS = {
+  "gpt-4.1": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4.1-2025-04-14": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4.1-mini": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4.1-mini-2025-04-14": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4.1-nano": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4.1-nano-2025-04-14": {
+    maxInputTokens: 1047576,
+    contextWindowTokens: 1047576,
+    maxOutputTokens: 32768
+  },
+  "gpt-4o": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  },
+  "gpt-4o-mini": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  },
+  "gpt-4o-mini-2024-07-18": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  },
+  "gpt-5": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5-mini": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5-mini-2025-08-07": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5-nano": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5-nano-2025-08-07": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.4-mini": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.4-nano": {
+    maxInputTokens: 272000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.1": {
+    maxInputTokens: 400000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.1-2025-11-13": {
+    maxInputTokens: 400000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.2": {
+    maxInputTokens: 400000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.2-2025-12-11": {
+    maxInputTokens: 400000,
+    contextWindowTokens: 400000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.4": {
+    maxInputTokens: 1050000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.4-2026-03-05": {
+    maxInputTokens: 1050000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.5": {
+    maxInputTokens: 1050000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-6-astra": {
+    maxInputTokens: 922000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.6-sol": {
+    maxInputTokens: 922000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.6-terra": {
+    maxInputTokens: 922000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  "gpt-5.6-luna": {
+    maxInputTokens: 922000,
+    contextWindowTokens: 1050000,
+    maxOutputTokens: 128000
+  },
+  o3: {
+    maxInputTokens: 200000,
+    contextWindowTokens: 200000,
+    maxOutputTokens: 1e5
+  },
+  "o3-2025-04-16": {
+    maxInputTokens: 200000,
+    contextWindowTokens: 200000,
+    maxOutputTokens: 1e5
+  },
+  "o4-mini": {
+    maxInputTokens: 200000,
+    contextWindowTokens: 200000,
+    maxOutputTokens: 1e5
+  },
+  "o4-mini-2025-04-16": {
+    maxInputTokens: 200000,
+    contextWindowTokens: 200000,
+    maxOutputTokens: 1e5
+  },
+  "gpt-5-chat-latest": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  },
+  "gpt-5.1-chat-latest": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  },
+  "gpt-5.2-chat-latest": {
+    maxInputTokens: 128000,
+    contextWindowTokens: 128000,
+    maxOutputTokens: 16384
+  }
+};
+var openaiInputCapacity = (config) => ({
+  outputTokens: (params) => {
+    const value = config.body(params).max_output_tokens;
+    return value === undefined ? undefined : positiveTokenLimit(value);
+  },
+  getLimits: async (params) => {
+    if (config.modelLimits)
+      return config.modelLimits(params);
+    if (new URL(config.baseUrl).origin !== "https://api.openai.com")
+      throw new AIInputError("capacity_unavailable", "This compatible endpoint must expose its own model capacity.");
+    const limits = LIMITS[params.model];
+    if (!limits)
+      throw new AIInputError("capacity_unavailable", `Model limits are unavailable for ${params.model}; no character limit has been substituted.`);
+    return { ...limits };
+  },
+  countTokens: async (params) => {
+    const headers = new Headers(await config.headers(params));
+    headers.set("Authorization", `Bearer ${await config.key()}`);
+    headers.set("Content-Type", "application/json");
+    const body = config.body(params);
+    const counted = {};
+    for (const key of [
+      "model",
+      "input",
+      "instructions",
+      "tools",
+      "tool_choice",
+      "reasoning",
+      "text",
+      "parallel_tool_calls"
+    ])
+      if (body[key] !== undefined)
+        counted[key] = body[key];
+    const response = await config.fetch(`${config.baseUrl}/v1/responses/input_tokens`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(counted),
+      signal: params.signal ? AbortSignal.any([params.signal, AbortSignal.timeout(15000)]) : AbortSignal.timeout(15000)
+    });
+    return inputTokenCount((await capacityJson(response)).input_tokens);
+  }
+});
+
 // src/ai/errors/providerError.ts
 var PROVIDER_STATUS_PAGES = {
   anthropic: "https://status.claude.com",
@@ -231,6 +511,7 @@ var withResilience = (provider, providerName = "unknown") => {
     }
   };
   return {
+    ...provider,
     stream: (params) => {
       const tripped = circuitOpen(providerName);
       if (tripped) {
@@ -247,6 +528,7 @@ var withResilience = (provider, providerName = "unknown") => {
 var instrumentAIProvider = (provider, providerName) => {
   const resilient = withResilience(provider, providerName);
   return {
+    ...provider,
     stream: (params) => {
       if (!params.onUsage && !params.onSpan) {
         return resilient.stream(params);
@@ -388,14 +670,558 @@ var openaiEffortValue = (model, reasoning) => {
   return clampEffort(requested, allowed);
 };
 
-// src/ai/providers/openai.ts
+// src/ai/providers/openaiResponses.ts
 var h2IfHttps = (url) => url.startsWith("https://") ? { protocol: "http2" } : {};
 var DEFAULT_BASE_URL = "https://api.openai.com";
+var EVENT_PREFIX_LENGTH = 7;
+var DATA_PREFIX_LENGTH = 6;
+var isRecord = (value) => typeof value === "object" && value !== null;
+var isRecordArray = (value) => Array.isArray(value) && value.length > 0 && isRecord(value[0]);
+var mapBlockToResponsesFormat = (block) => {
+  if (block.type === "text") {
+    return { text: block.content, type: "input_text" };
+  }
+  if (block.type === "image") {
+    return {
+      image_url: {
+        url: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`
+      },
+      type: "input_image"
+    };
+  }
+  if (block.type === "document") {
+    return {
+      file: {
+        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) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = content.map(mapBlockToResponsesFormat).filter((mapped) => mapped !== null);
+  return parts.length > 0 ? parts : "";
+};
+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,
+      name: block.name,
+      type: "function_call"
+    };
+  }
+  if (block.type === "tool_result") {
+    return {
+      call_id: block.tool_use_id,
+      output: typeof block.content === "string" ? block.content : "",
+      type: "function_call_output"
+    };
+  }
+  return null;
+};
+var convertToolBlocks = (content) => content.map(convertToolBlock).filter((converted) => converted !== null);
+var convertMessage = (msg) => {
+  if (typeof msg.content !== "string" && Array.isArray(msg.content) && hasToolBlocks(msg.content)) {
+    return convertToolBlocks(msg.content);
+  }
+  const content = mapContentToResponsesFormat(msg.content);
+  return [
+    {
+      content,
+      role: msg.role === "system" ? "developer" : msg.role,
+      type: "message"
+    }
+  ];
+};
+var buildInput = (messages) => {
+  const input = [];
+  for (const msg of messages) {
+    input.push(...convertMessage(msg));
+  }
+  return input;
+};
+var mapToolDefinition = (tool) => ({
+  description: tool.description,
+  name: tool.name,
+  parameters: tool.input_schema,
+  type: "function"
+});
+var buildTools = (tools, isImageModel) => {
+  const mapped = tools ? tools.map(mapToolDefinition) : [];
+  const result = [...mapped];
+  if (isImageModel) {
+    result.push({ type: "image_generation" });
+  }
+  return result.length > 0 ? result : undefined;
+};
+var buildResponsesRequestBody = (params, isImageModel, capabilityModel = params.model) => {
+  const body = {
+    input: buildInput(params.messages),
+    model: params.model,
+    stream: true
+  };
+  if (params.systemPrompt) {
+    body.instructions = params.systemPrompt;
+  }
+  const tools = buildTools(params.tools, isImageModel);
+  if (tools) {
+    body.tools = tools;
+    if (params.toolChoice === "auto" || params.toolChoice === "none" || params.toolChoice === "required") {
+      body.tool_choice = params.toolChoice;
+    } else if (params.toolChoice && typeof params.toolChoice === "object") {
+      body.tool_choice = {
+        name: params.toolChoice.name,
+        type: "function"
+      };
+    }
+    if (typeof params.parallelToolCalls === "boolean") {
+      body.parallel_tool_calls = params.parallelToolCalls;
+    }
+  }
+  if (typeof params.temperature === "number")
+    body.temperature = params.temperature;
+  if (typeof params.topP === "number")
+    body.top_p = params.topP;
+  if (typeof params.maxTokens === "number")
+    body.max_output_tokens = params.maxTokens;
+  if (params.stopSequences && params.stopSequences.length > 0)
+    body.stop = params.stopSequences;
+  if (typeof params.seed === "number")
+    body.seed = params.seed;
+  if (typeof params.frequencyPenalty === "number")
+    body.frequency_penalty = params.frequencyPenalty;
+  if (typeof params.presencePenalty === "number")
+    body.presence_penalty = params.presencePenalty;
+  if (params.responseFormat) {
+    if (params.responseFormat.type === "text" || params.responseFormat.type === "json_object") {
+      body.text = { format: { type: params.responseFormat.type } };
+    } else if (params.responseFormat.type === "json_schema") {
+      body.text = {
+        format: {
+          name: params.responseFormat.name,
+          schema: params.responseFormat.schema,
+          strict: params.responseFormat.strict ?? true,
+          type: "json_schema"
+        }
+      };
+    }
+  }
+  if (params.reasoning && isOpenAIReasoningModel(capabilityModel)) {
+    const effort = openaiEffortValue(capabilityModel, params.reasoning);
+    if (effort) {
+      body.reasoning = {
+        effort,
+        summary: "auto"
+      };
+    }
+  }
+  return body;
+};
+var parseJSON = (data) => {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+};
+var parseToolInput = (rawArguments) => {
+  try {
+    return JSON.parse(rawArguments);
+  } catch {
+    return rawArguments;
+  }
+};
+var extractUsage = (response) => {
+  if (!isRecord(response.usage)) {
+    return;
+  }
+  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;
+  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,
+    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") {
+    return "png";
+  }
+  if (mimeType.includes("jpeg"))
+    return "jpeg";
+  if (mimeType.includes("webp"))
+    return "webp";
+  return "png";
+};
+var processTextDelta = function* (parsed) {
+  if (typeof parsed.delta === "string") {
+    yield { content: parsed.delta, type: "text" };
+  }
+};
+var processPartialImage = function* (parsed) {
+  const itemId = typeof parsed.item_id === "string" ? parsed.item_id : undefined;
+  const b64 = typeof parsed.partial_image_b64 === "string" ? parsed.partial_image_b64 : undefined;
+  if (b64) {
+    yield {
+      data: b64,
+      format: "png",
+      imageId: itemId,
+      isPartial: true,
+      type: "image"
+    };
+  }
+};
+var processFunctionCallArgumentsDelta = (parsed, pendingCalls) => {
+  const itemId = typeof parsed.item_id === "string" ? parsed.item_id : "";
+  const callId = typeof parsed.call_id === "string" ? parsed.call_id : "";
+  const delta = typeof parsed.arguments_delta === "string" ? parsed.arguments_delta : "";
+  const existing = pendingCalls.get(itemId);
+  if (existing) {
+    existing.arguments += delta;
+  } else {
+    pendingCalls.set(itemId, {
+      arguments: delta,
+      callId,
+      name: ""
+    });
+  }
+};
+var processFunctionCallArgumentsDone = function* (parsed, pendingCalls) {
+  const itemId = typeof parsed.item_id === "string" ? parsed.item_id : "";
+  const callId = typeof parsed.call_id === "string" ? parsed.call_id : "";
+  const fullArgs = typeof parsed.arguments === "string" ? parsed.arguments : "";
+  const pending = pendingCalls.get(itemId);
+  const name = pending?.name ?? "";
+  const args = fullArgs || pending?.arguments || "";
+  pendingCalls.delete(itemId);
+  yield {
+    id: callId || pending?.callId || itemId,
+    input: parseToolInput(args),
+    name,
+    providerData: pending?.providerData ? { ...pending.providerData, arguments: args } : undefined,
+    type: "tool_use"
+  };
+};
+var processOutputItemAdded = (parsed, pendingCalls) => {
+  if (!isRecord(parsed.item)) {
+    return;
+  }
+  const { item } = parsed;
+  const itemId = typeof item.id === "string" ? item.id : "";
+  const itemType = typeof item.type === "string" ? item.type : "";
+  if (itemType !== "function_call") {
+    return;
+  }
+  const callId = typeof item.call_id === "string" ? item.call_id : "";
+  const name = typeof item.name === "string" ? item.name : "";
+  pendingCalls.set(itemId, {
+    arguments: "",
+    callId,
+    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 : "",
+  format: extractMimeFormat(item.output_format),
+  imageId: typeof item.id === "string" ? item.id : undefined,
+  isPartial: false,
+  revisedPrompt: typeof item.revised_prompt === "string" ? item.revised_prompt : undefined,
+  type: "image"
+});
+var extractImageFromOutput = function* (output) {
+  const completedImages = output.filter(isCompletedImageGeneration);
+  for (const item of completedImages) {
+    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 };
+    return;
+  }
+  const { response } = parsed;
+  const usage = extractUsage(response);
+  const metadata = extractResponseMetadata(response);
+  if (isRecordArray(response.output)) {
+    yield* extractCitationsFromOutput(response.output);
+    yield* extractImageFromOutput(response.output);
+  }
+  yield { metadata, type: "done", usage };
+};
+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 : "";
+      if (!delta)
+        break;
+      yield {
+        content: delta,
+        type: "thinking"
+      };
+      break;
+    }
+    case "response.output_text.delta":
+      yield* processTextDelta(parsed);
+      break;
+    case "response.image_generation_call.partial_image":
+      yield* processPartialImage(parsed);
+      break;
+    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;
+    case "response.function_call_arguments.done":
+      yield* processFunctionCallArgumentsDone(parsed, pendingCalls);
+      break;
+    case "response.completed":
+      yield* processCompleted(parsed);
+      break;
+    case "response.failed":
+    case "response.incomplete":
+    case "response.error":
+    case "error":
+      throw responseFailure(eventType, parsed, providerName);
+  }
+};
+var flushSSEBuffer = function* (state) {
+  if (!state.currentEvent || !state.buffer) {
+    return;
+  }
+  const parsed = parseJSON(state.buffer);
+  if (parsed) {
+    yield* processSSEEvent(state.currentEvent, parsed, state.pendingCalls, state.providerName);
+  }
+  state.currentEvent = "";
+  state.buffer = "";
+};
+var parseSSELine = (trimmed, state) => {
+  if (trimmed.startsWith("event: ")) {
+    state.currentEvent = trimmed.slice(EVENT_PREFIX_LENGTH);
+  } else if (trimmed.startsWith("data: ")) {
+    state.buffer = trimmed.slice(DATA_PREFIX_LENGTH);
+  }
+};
+var processSSELine = function* (line, state) {
+  const trimmed = line.trim();
+  if (trimmed) {
+    parseSSELine(trimmed, state);
+    return;
+  }
+  yield* flushSSEBuffer(state);
+};
+var processSSELines = function* (lines, state) {
+  for (const line of lines) {
+    yield* processSSELine(line, state);
+  }
+};
+var drainReader = async function* (reader, decoder, state, signal) {
+  let textBuffer = "";
+  for (let result = await reader.read();!result.done && !signal?.aborted; result = await reader.read()) {
+    textBuffer += decoder.decode(result.value, { stream: true });
+    const lines = textBuffer.split(`
+`);
+    textBuffer = lines.pop() ?? "";
+    yield* processSSELines(lines, state);
+  }
+  if (textBuffer.trim()) {
+    yield* processSSELines([textBuffer, ""], state);
+  }
+};
+var parseSSEStream = async function* (body, providerName, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  const state = {
+    buffer: "",
+    currentEvent: "",
+    pendingCalls: new Map,
+    usage: undefined,
+    providerName
+  };
+  try {
+    yield* drainReader(reader, decoder, state, signal);
+    yield* flushSSEBuffer(state);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var fetchResponsesStream = async function* (baseUrl, apiKey, body, fetchImpl, headers, providerName, signal) {
+  const target = `${baseUrl}/v1/responses`;
+  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: requestHeaders,
+    method: "POST",
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw ProviderError.fromResponse(providerName, response.status, errorText);
+  }
+  if (!response.body) {
+    throw new ProviderError({
+      message: `${providerName} Responses API returned no response body`,
+      provider: providerName,
+      retryable: true
+    });
+  }
+  yield* parseSSEStream(response.body, providerName, signal);
+};
+var resolveImageModels = (imageModels) => {
+  if (!imageModels) {
+    return new Set;
+  }
+  if (imageModels instanceof Set) {
+    return 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({
+    inputCapacity: openaiInputCapacity({
+      baseUrl,
+      fetch: fetchImpl,
+      key: resolveKey,
+      headers: resolveHeaders,
+      modelLimits: config2.modelLimits,
+      body: (params) => {
+        const built = buildResponsesRequestBody(params, imageModels.has(params.model), config2.modelForCapabilities?.(params.model) ?? params.model);
+        return config2.transformRequestBody ? config2.transformRequestBody(built, params) : built;
+      }
+    }),
+    stream: (params) => {
+      const isImageModel = imageModels.has(params.model);
+      const builtBody = buildResponsesRequestBody(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);
+      }();
+    }
+  }, providerName);
+};
+
+// src/ai/providers/openai.ts
+var h2IfHttps2 = (url) => url.startsWith("https://") ? { protocol: "http2" } : {};
+var DEFAULT_BASE_URL2 = "https://api.openai.com";
 var SSE_DATA_PREFIX_LENGTH = 6;
 var DONE_SENTINEL = "[DONE]";
 var NOT_FOUND = -1;
-var isRecord = (value) => typeof value === "object" && value !== null;
-var isRecordArray = (value) => Array.isArray(value) && value.length > 0 && isRecord(value[0]);
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var isRecordArray2 = (value) => Array.isArray(value) && value.length > 0 && isRecord2(value[0]);
 var hasArrayContent = (msg) => typeof msg.content !== "string" && Array.isArray(msg.content);
 var buildToolMessages = (blocks) => {
   const toolUseBlocks = blocks.filter((block) => block.type === "tool_use");
@@ -428,8 +1254,8 @@ var processMessageAtIndex = (result, msg, idx) => {
   if (!hasArrayContent(msg)) {
     return;
   }
-  const hasToolBlocks = msg.content.some((block) => block.type === "tool_use" || block.type === "tool_result");
-  if (!hasToolBlocks) {
+  const hasToolBlocks2 = msg.content.some((block) => block.type === "tool_use" || block.type === "tool_result");
+  if (!hasToolBlocks2) {
     return;
   }
   const toolMessages = buildToolMessages(msg.content);
@@ -573,7 +1399,7 @@ var buildRequestBody = (params, capabilityModel = params.model) => {
   }
   return body;
 };
-var parseToolInput = (rawArguments) => {
+var parseToolInput2 = (rawArguments) => {
   try {
     return JSON.parse(rawArguments);
   } catch {
@@ -582,7 +1408,7 @@ var parseToolInput = (rawArguments) => {
 };
 var flushPendingToolCalls = function* (pendingToolCalls) {
   for (const [, tool] of pendingToolCalls) {
-    const input = parseToolInput(tool.arguments);
+    const input = parseToolInput2(tool.arguments);
     yield {
       id: tool.id,
       input,
@@ -592,7 +1418,7 @@ var flushPendingToolCalls = function* (pendingToolCalls) {
   }
   pendingToolCalls.clear();
 };
-var extractUsage = (parsedUsage) => {
+var extractUsage2 = (parsedUsage) => {
   const prompt = parsedUsage.prompt_tokens ?? 0;
   const cached = parsedUsage.cached_tokens ?? 0;
   return {
@@ -637,7 +1463,7 @@ var processToolCallDelta = (toolCall, pendingToolCalls) => {
   if (index === undefined) {
     return;
   }
-  const func = isRecord(toolCall.function) ? toolCall.function : null;
+  const func = isRecord2(toolCall.function) ? toolCall.function : null;
   initPendingToolCall(toolCall, func, index, pendingToolCalls);
   const pending = pendingToolCalls.get(index);
   if (!pending) {
@@ -654,7 +1480,7 @@ var processDelta = function* (delta, pendingToolCalls) {
   if (typeof delta.content === "string") {
     yield { content: delta.content, type: "text" };
   }
-  if (isRecord(delta.audio)) {
+  if (isRecord2(delta.audio)) {
     const audio = delta.audio;
     if (typeof audio.data === "string" || typeof audio.transcript === "string") {
       yield {
@@ -666,14 +1492,14 @@ var processDelta = function* (delta, pendingToolCalls) {
       };
     }
   }
-  if (isRecordArray(delta.tool_calls)) {
+  if (isRecordArray2(delta.tool_calls)) {
     processToolCallDeltas(delta.tool_calls, pendingToolCalls);
   }
   if (Array.isArray(delta.annotations)) {
     for (const annotation of delta.annotations) {
-      if (!isRecord(annotation) || annotation.type !== "url_citation")
+      if (!isRecord2(annotation) || annotation.type !== "url_citation")
         continue;
-      const citation = isRecord(annotation.url_citation) ? annotation.url_citation : annotation;
+      const citation = isRecord2(annotation.url_citation) ? annotation.url_citation : annotation;
       if (typeof citation.url !== "string")
         continue;
       yield {
@@ -688,19 +1514,19 @@ var processDelta = function* (delta, pendingToolCalls) {
   }
 };
 var narrowResponseMetadata = (parsed) => {
-  const providerMetadata = isRecord(parsed.openrouter_metadata) ? parsed.openrouter_metadata : undefined;
+  const providerMetadata = isRecord2(parsed.openrouter_metadata) ? parsed.openrouter_metadata : undefined;
   const generationId = typeof parsed.id === "string" ? parsed.id : undefined;
   const model = typeof parsed.model === "string" ? parsed.model : undefined;
   const serviceTier = typeof parsed.service_tier === "string" ? parsed.service_tier : undefined;
-  const selected = providerMetadata && isRecord(providerMetadata.endpoints) ? providerMetadata.endpoints.available : undefined;
-  const selectedEndpoint = Array.isArray(selected) ? selected.find((entry) => isRecord(entry) && entry.selected === true) : undefined;
-  const provider = isRecord(selectedEndpoint) && typeof selectedEndpoint.provider === "string" ? selectedEndpoint.provider : undefined;
+  const selected = providerMetadata && isRecord2(providerMetadata.endpoints) ? providerMetadata.endpoints.available : undefined;
+  const selectedEndpoint = Array.isArray(selected) ? selected.find((entry) => isRecord2(entry) && entry.selected === true) : undefined;
+  const provider = isRecord2(selectedEndpoint) && typeof selectedEndpoint.provider === "string" ? selectedEndpoint.provider : undefined;
   if (!providerMetadata && !generationId && !model && !serviceTier)
     return;
   return { generationId, model, provider, providerMetadata, serviceTier };
 };
 var processChoice = function* (choice, pendingToolCalls) {
-  const delta = isRecord(choice.delta) ? choice.delta : null;
+  const delta = isRecord2(choice.delta) ? choice.delta : null;
   if (delta) {
     yield* processDelta(delta, pendingToolCalls);
   }
@@ -709,18 +1535,18 @@ var processChoice = function* (choice, pendingToolCalls) {
   }
 };
 var narrowUsageRecord = (parsed) => {
-  if (!isRecord(parsed.usage)) {
+  if (!isRecord2(parsed.usage)) {
     return;
   }
   const { usage } = parsed;
   const promptTokens = typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0;
   const completionTokens = typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0;
-  const cachedTokens = isRecord(usage.prompt_tokens_details) && typeof usage.prompt_tokens_details.cached_tokens === "number" ? usage.prompt_tokens_details.cached_tokens : 0;
-  const cacheWriteTokens = isRecord(usage.prompt_tokens_details) && typeof usage.prompt_tokens_details.cache_write_tokens === "number" ? usage.prompt_tokens_details.cache_write_tokens : 0;
-  const reasoningTokens = isRecord(usage.completion_tokens_details) && typeof usage.completion_tokens_details.reasoning_tokens === "number" ? usage.completion_tokens_details.reasoning_tokens : 0;
+  const cachedTokens = isRecord2(usage.prompt_tokens_details) && typeof usage.prompt_tokens_details.cached_tokens === "number" ? usage.prompt_tokens_details.cached_tokens : 0;
+  const cacheWriteTokens = isRecord2(usage.prompt_tokens_details) && typeof usage.prompt_tokens_details.cache_write_tokens === "number" ? usage.prompt_tokens_details.cache_write_tokens : 0;
+  const reasoningTokens = isRecord2(usage.completion_tokens_details) && typeof usage.completion_tokens_details.reasoning_tokens === "number" ? usage.completion_tokens_details.reasoning_tokens : 0;
   const cost = typeof usage.cost === "number" ? usage.cost : undefined;
-  const upstreamInferenceCost = isRecord(usage.cost_details) && typeof usage.cost_details.upstream_inference_cost === "number" ? usage.cost_details.upstream_inference_cost : undefined;
-  const normalized = extractUsage({
+  const upstreamInferenceCost = isRecord2(usage.cost_details) && typeof usage.cost_details.upstream_inference_cost === "number" ? usage.cost_details.upstream_inference_cost : undefined;
+  const normalized = extractUsage2({
     cache_write_tokens: cacheWriteTokens,
     cached_tokens: cachedTokens,
     completion_tokens: completionTokens,
@@ -729,12 +1555,12 @@ var narrowUsageRecord = (parsed) => {
     reasoning_tokens: reasoningTokens,
     upstream_inference_cost: upstreamInferenceCost
   });
-  if (isRecord(usage.server_tool_use)) {
+  if (isRecord2(usage.server_tool_use)) {
     normalized.serverToolUse = Object.fromEntries(Object.entries(usage.server_tool_use).filter((entry) => typeof entry[1] === "number"));
   }
   return normalized;
 };
-var processSSELine = function* (line, pendingToolCalls, providerName) {
+var processSSELine2 = function* (line, pendingToolCalls, providerName) {
   const trimmed = line.trim();
   if (!trimmed || !trimmed.startsWith("data: ")) {
     return;
@@ -750,9 +1576,9 @@ var processSSELine = function* (line, pendingToolCalls, providerName) {
   } catch {
     return;
   }
-  if (isRecord(parsed.error)) {
+  if (isRecord2(parsed.error)) {
     const error = parsed.error;
-    const metadata2 = isRecord(error.metadata) ? error.metadata : undefined;
+    const metadata2 = isRecord2(error.metadata) ? error.metadata : undefined;
     const status = typeof error.code === "number" ? error.code : null;
     const type = metadata2 && typeof metadata2.error_type === "string" ? metadata2.error_type : typeof error.error_type === "string" ? error.error_type : null;
     throw new ProviderError({
@@ -773,16 +1599,16 @@ var processSSELine = function* (line, pendingToolCalls, providerName) {
     yield { metadata, type: "response_metadata" };
   }
   const { choices } = parsed;
-  if (!isRecordArray(choices)) {
+  if (!isRecordArray2(choices)) {
     return;
   }
   const [firstChoice] = choices;
   if (!firstChoice) {
     return;
   }
-  if (isRecord(firstChoice.error)) {
+  if (isRecord2(firstChoice.error)) {
     const error = firstChoice.error;
-    const metadata2 = isRecord(error.metadata) ? error.metadata : undefined;
+    const metadata2 = isRecord2(error.metadata) ? error.metadata : undefined;
     const status = typeof error.code === "number" ? error.code : null;
     throw new ProviderError({
       message: typeof error.message === "string" ? error.message : "OpenRouter stream failed",
@@ -797,7 +1623,7 @@ var processSSELine = function* (line, pendingToolCalls, providerName) {
 };
 var isUsageUpdate = (chunk) => chunk.type === "usage_update";
 var collectYieldableChunks = (line, pendingToolCalls, usageRef, metadataRef, providerName) => {
-  const allChunks = Array.from(processSSELine(line, pendingToolCalls, providerName));
+  const allChunks = Array.from(processSSELine2(line, pendingToolCalls, providerName));
   const usageChunks = allChunks.filter(isUsageUpdate);
   const lastUsage = usageChunks.at(NOT_FOUND);
   if (lastUsage) {
@@ -817,7 +1643,7 @@ var collectYieldableChunks = (line, pendingToolCalls, usageRef, metadataRef, pro
   }
   return allChunks.filter((chunk) => !isUsageUpdate(chunk) && chunk.type !== "response_metadata");
 };
-var processSSELines = function* (lines, pendingToolCalls, usageRef, metadataRef, providerName) {
+var processSSELines2 = function* (lines, pendingToolCalls, usageRef, metadataRef, providerName) {
   for (const line of lines) {
     yield* collectYieldableChunks(line, pendingToolCalls, usageRef, metadataRef, providerName);
   }
@@ -829,13 +1655,13 @@ var processStreamValue = (value, decoder, state) => {
   state.buffer = lines.pop() ?? "";
   return lines;
 };
-var drainReader = async function* (reader, decoder, state, signal) {
+var drainReader2 = async function* (reader, decoder, state, signal) {
   for (let result = await reader.read();!result.done && !signal?.aborted; result = await reader.read()) {
     const lines = processStreamValue(result.value, decoder, state);
-    yield* processSSELines(lines, state.pendingToolCalls, state.usageRef, state.metadataRef, state.providerName);
+    yield* processSSELines2(lines, state.pendingToolCalls, state.usageRef, state.metadataRef, state.providerName);
   }
 };
-var parseSSEStream = async function* (body, initialMetadata, providerName = "openai", signal) {
+var parseSSEStream2 = async function* (body, initialMetadata, providerName = "openai", signal) {
   const reader = body.getReader();
   const decoder = new TextDecoder;
   const state = {
@@ -846,7 +1672,7 @@ var parseSSEStream = async function* (body, initialMetadata, providerName = "ope
     usageRef: { current: undefined }
   };
   try {
-    yield* drainReader(reader, decoder, state, signal);
+    yield* drainReader2(reader, decoder, state, signal);
     yield {
       metadata: state.metadataRef.current,
       type: "done",
@@ -862,7 +1688,7 @@ var fetchOpenAIStream = async function* (baseUrl, apiKey, body, fetchImpl, heade
   requestHeaders.set("Authorization", `Bearer ${apiKey}`);
   requestHeaders.set("Content-Type", "application/json");
   const response = await fetchImpl(target, {
-    ...h2IfHttps(target),
+    ...h2IfHttps2(target),
     body: JSON.stringify(body),
     headers: requestHeaders,
     method: "POST",
@@ -879,7 +1705,7 @@ var fetchOpenAIStream = async function* (baseUrl, apiKey, body, fetchImpl, heade
       retryable: true
     });
   }
-  yield* parseSSEStream(response.body, {
+  yield* parseSSEStream2(response.body, {
     generationId: response.headers.get("X-Generation-Id") ?? undefined,
     providerMetadata: {
       cacheAge: response.headers.get("X-OpenRouter-Cache-Age") ?? undefined,
@@ -890,7 +1716,7 @@ var fetchOpenAIStream = async function* (baseUrl, apiKey, body, fetchImpl, heade
   }, providerName, signal);
 };
 var openai = (config2) => {
-  const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL;
+  const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL2;
   const fetchImpl = config2.fetch ?? globalThis.fetch;
   const providerName = config2.providerName ?? "openai";
   if (!config2.apiKey && !config2.tokenSource) {
@@ -904,6 +1730,14 @@ var openai = (config2) => {
   };
   const resolveHeaders = async (params) => typeof config2.headers === "function" ? await config2.headers(params) : config2.headers ?? {};
   return instrumentAIProvider({
+    inputCapacity: config2.transformRequestBody ? undefined : openaiInputCapacity({
+      baseUrl,
+      fetch: fetchImpl,
+      key: resolveKey,
+      headers: resolveHeaders,
+      modelLimits: config2.modelLimits,
+      body: (params) => buildResponsesRequestBody(params, false, config2.modelForCapabilities?.(params.model) ?? params.model)
+    }),
     stream: (params) => {
       const openaiBody = buildRequestBody(params, config2.modelForCapabilities?.(params.model) ?? params.model);
       const body = config2.transformRequestBody ? config2.transformRequestBody(openaiBody, params) : openaiBody;
@@ -921,5 +1755,5 @@ export {
   openai
 };
 
-//# debugId=89626FDD4663206064756E2164756E21
+//# debugId=D8DCEEFFFA068E6864756E2164756E21
 //# sourceMappingURL=openai.js.map