@absolutejs/ai 0.0.49 → 0.0.51

package/dist/ai/providers/openrouter.js

@@ -0,0 +1,2607 @@
+// @bun
+var __require = import.meta.require;
+
+// src/ai/errors/providerError.ts
+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",
+  openrouter: "https://status.openrouter.ai"
+};
+var RETRYABLE_STATUSES = new Set([
+  408,
+  409,
+  425,
+  429,
+  500,
+  502,
+  503,
+  504,
+  529
+]);
+var CONNECTION_ERROR_PATTERNS = [
+  "econnreset",
+  "econnrefused",
+  "etimedout",
+  "enotfound",
+  "eai_again",
+  "socket hang up",
+  "fetch failed",
+  "network",
+  "terminated",
+  "timed out",
+  "timeout",
+  "and not retryable",
+  "no response body"
+];
+var isAbortError = (err) => err instanceof Error && (err.name === "AbortError" || /\babort(ed)?\b/i.test(err.message));
+var providerStatusPage = (provider) => PROVIDER_STATUS_PAGES[provider] ?? null;
+
+class ProviderError extends Error {
+  provider;
+  status;
+  type;
+  retryable;
+  metadata;
+  statusPageUrl;
+  constructor(init) {
+    super(init.message, init.cause === undefined ? undefined : { cause: init.cause });
+    this.name = "ProviderError";
+    this.provider = init.provider;
+    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) {
+    return new ProviderError({
+      message: `${capitalize(provider)} API error ${status}: ${body}`,
+      provider,
+      retryable: RETRYABLE_STATUSES.has(status),
+      status,
+      type: type ?? null
+    });
+  }
+  static from(err, provider) {
+    if (err instanceof ProviderError)
+      return err;
+    if (isAbortError(err))
+      throw err;
+    const rawMessage = err instanceof Error ? err.message : String(err ?? "");
+    const lower = rawMessage.toLowerCase();
+    const statusMatch = lower.match(/api error\s+(\d{3})/);
+    const status = statusMatch ? Number(statusMatch[1]) : null;
+    const retryable = status !== null && RETRYABLE_STATUSES.has(status) || status === null && CONNECTION_ERROR_PATTERNS.some((pattern) => lower.includes(pattern));
+    return new ProviderError({
+      cause: err,
+      message: rawMessage || `${capitalize(provider)} request failed`,
+      provider,
+      retryable,
+      status
+    });
+  }
+}
+var capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
+
+// src/ai/resilience.ts
+var DEFAULT_CONFIG = {
+  baseDelayMs: 500,
+  failureThreshold: 4,
+  maxDelayMs: 8000,
+  maxRetries: 2,
+  openMs: 30000
+};
+var config = { ...DEFAULT_CONFIG };
+var configureProviderResilience = (partial) => {
+  config = { ...config, ...partial };
+};
+var health = new Map;
+var recordFor = (provider) => {
+  const existing = health.get(provider);
+  if (existing)
+    return existing;
+  const fresh = {
+    consecutiveFailures: 0,
+    external: null,
+    lastError: null,
+    lastFailureAt: null,
+    lastSuccessAt: null,
+    nextProbeAt: null,
+    state: "closed"
+  };
+  health.set(provider, fresh);
+  return fresh;
+};
+var setProviderAvailability = (provider, status) => {
+  const record = recordFor(provider);
+  record.external = {
+    available: status.available,
+    checkedAt: Date.now(),
+    indicator: status.indicator ?? (status.available ? "operational" : "unknown"),
+    reason: status.reason ?? ""
+  };
+};
+var noteSuccess = (provider) => {
+  const record = recordFor(provider);
+  record.state = "closed";
+  record.consecutiveFailures = 0;
+  record.nextProbeAt = null;
+  record.lastError = null;
+  record.lastSuccessAt = Date.now();
+};
+var noteFailure = (provider, error) => {
+  const record = recordFor(provider);
+  record.consecutiveFailures += 1;
+  record.lastFailureAt = Date.now();
+  record.lastError = {
+    message: error.message,
+    status: error.status,
+    type: error.type
+  };
+  if (record.consecutiveFailures >= config.failureThreshold) {
+    record.state = "open";
+    record.nextProbeAt = Date.now() + config.openMs;
+  }
+};
+var snapshot = (provider, record) => ({
+  consecutiveFailures: record.consecutiveFailures,
+  external: record.external,
+  healthy: record.state === "closed" && record.external?.available !== false,
+  lastError: record.lastError,
+  lastFailureAt: record.lastFailureAt,
+  lastSuccessAt: record.lastSuccessAt,
+  nextRetryAt: record.nextProbeAt,
+  provider,
+  state: record.state,
+  statusPageUrl: providerStatusPage(provider)
+});
+function getProviderHealth(provider) {
+  if (provider !== undefined)
+    return snapshot(provider, recordFor(provider));
+  return [...health.entries()].map(([name, record]) => snapshot(name, record));
+}
+var backoffDelay = (attempt) => {
+  const exponential = config.baseDelayMs * 2 ** attempt;
+  const capped = Math.min(exponential, config.maxDelayMs);
+  return Math.round(capped / 2 + Math.random() * capped / 2);
+};
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(signal.reason ?? new Error("aborted"));
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(signal?.reason ?? new Error("aborted"));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var circuitOpen = (provider) => {
+  const record = recordFor(provider);
+  if (record.external && !record.external.available) {
+    return new ProviderError({
+      message: `${provider} API is reported down${record.external.reason ? `: ${record.external.reason}` : ""}`,
+      provider,
+      retryable: true,
+      status: null,
+      type: record.external.indicator
+    });
+  }
+  if (record.state !== "open")
+    return null;
+  if (record.nextProbeAt !== null && Date.now() >= record.nextProbeAt) {
+    record.state = "half-open";
+    return null;
+  }
+  const detail = record.lastError?.message ?? "recent failures";
+  return new ProviderError({
+    message: `${provider} is temporarily unavailable (circuit open after ${record.consecutiveFailures} failures): ${detail}`,
+    provider,
+    retryable: true,
+    status: record.lastError?.status ?? null,
+    type: record.lastError?.type ?? null
+  });
+};
+var withResilience = (provider, providerName = "unknown") => {
+  const attempt = async function* (params, attemptNo) {
+    let yielded = false;
+    try {
+      for await (const chunk of provider.stream(params)) {
+        yielded = true;
+        yield chunk;
+      }
+      noteSuccess(providerName);
+    } catch (err) {
+      const providerError = ProviderError.from(err, providerName);
+      const canRetry = !yielded && providerError.retryable && attemptNo < config.maxRetries && !params.signal?.aborted;
+      if (canRetry) {
+        await sleep(backoffDelay(attemptNo), params.signal);
+        yield* attempt(params, attemptNo + 1);
+        return;
+      }
+      if (providerError.retryable)
+        noteFailure(providerName, providerError);
+      throw providerError;
+    }
+  };
+  return {
+    stream: (params) => {
+      const tripped = circuitOpen(providerName);
+      if (tripped) {
+        return async function* () {
+          throw tripped;
+        }();
+      }
+      return attempt(params, 0);
+    }
+  };
+};
+
+// src/ai/providers/instrumentation.ts
+var instrumentAIProvider = (provider, providerName) => {
+  const resilient = withResilience(provider, providerName);
+  return {
+    stream: (params) => {
+      if (!params.onUsage && !params.onSpan) {
+        return resilient.stream(params);
+      }
+      return tapStream(resilient.stream(params), params, providerName);
+    }
+  };
+};
+async function* tapStream(source, params, providerName) {
+  const startedAt = Date.now();
+  let lastUsage;
+  try {
+    for await (const chunk of source) {
+      if (chunk.type === "done" && chunk.usage) {
+        lastUsage = chunk.usage;
+      }
+      yield chunk;
+    }
+  } finally {
+    if (lastUsage && params.onUsage) {
+      try {
+        params.onUsage({
+          ...lastUsage,
+          model: params.model,
+          provider: providerName
+        });
+      } catch {}
+    }
+    if (params.onSpan) {
+      try {
+        params.onSpan({
+          durationMs: Date.now() - startedAt,
+          model: params.model,
+          provider: providerName,
+          usage: lastUsage
+        });
+      } catch {}
+    }
+  }
+}
+
+// src/ai/providers/reasoning.ts
+var EFFORT_ORDER = [
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "max"
+];
+var ANTHROPIC_EFFORT = [/opus-4-[5-8]/, /sonnet-4-6/, /fable-5/, /mythos-5/];
+var ANTHROPIC_ADAPTIVE_ONLY = [];
+var ANTHROPIC_LEGACY_THINKING = [
+  /sonnet-4-5/,
+  /sonnet-4-0/,
+  /sonnet-4-2025/,
+  /opus-4-0/,
+  /opus-4-1/,
+  /opus-4-2025/,
+  /3-7-sonnet/
+];
+var ANTHROPIC_NO_SAMPLING = [/opus-4-[78]/, /fable-5/, /mythos-5/];
+var ANTHROPIC_MAX_EFFORT = [
+  /opus-4-[678]/,
+  /sonnet-4-6/,
+  /fable-5/,
+  /mythos-5/
+];
+var OPENAI_REASONING = [/(^|[^a-z])o[1345](-|$)/, /gpt-5/];
+var OPENAI_MINIMAL_EFFORT = [/gpt-5/];
+var matches = (model, patterns) => patterns.some((pattern) => pattern.test(model));
+var anthropicReasoningMode = (model) => {
+  if (matches(model, ANTHROPIC_EFFORT))
+    return "effort";
+  if (matches(model, ANTHROPIC_ADAPTIVE_ONLY))
+    return "adaptive";
+  if (matches(model, ANTHROPIC_LEGACY_THINKING))
+    return "legacy";
+  return "none";
+};
+var anthropicSupportsSampling = (model) => !matches(model, ANTHROPIC_NO_SAMPLING);
+var isOpenAIReasoningModel = (model) => matches(model, OPENAI_REASONING);
+var EFFORT_BUDGET = {
+  high: 16384,
+  low: 2048,
+  max: 32768,
+  medium: 8192,
+  minimal: 1024
+};
+var budgetToEffort = (budget) => {
+  if (budget <= 2048)
+    return "low";
+  if (budget <= 8192)
+    return "medium";
+  if (budget <= 16384)
+    return "high";
+  return "max";
+};
+var resolveEffort = (reasoning) => {
+  if (reasoning.effort)
+    return reasoning.effort;
+  if (typeof reasoning.budgetTokens === "number") {
+    return budgetToEffort(reasoning.budgetTokens);
+  }
+  return null;
+};
+var resolveBudgetTokens = (reasoning) => {
+  if (typeof reasoning.budgetTokens === "number")
+    return reasoning.budgetTokens;
+  if (reasoning.effort)
+    return EFFORT_BUDGET[reasoning.effort];
+  return null;
+};
+var clampEffort = (effort, allowed) => {
+  if (allowed.includes(effort))
+    return effort;
+  const idx = EFFORT_ORDER.indexOf(effort);
+  for (let lower = idx - 1;lower >= 0; lower -= 1) {
+    const candidate = EFFORT_ORDER[lower];
+    if (candidate && allowed.includes(candidate))
+      return candidate;
+  }
+  return allowed[0] ?? effort;
+};
+var anthropicEffortValue = (model, reasoning) => {
+  const effort = resolveEffort(reasoning);
+  if (!effort)
+    return null;
+  const allowed = matches(model, ANTHROPIC_MAX_EFFORT) ? ["low", "medium", "high", "max"] : ["low", "medium", "high"];
+  return clampEffort(effort, allowed);
+};
+var openaiEffortValue = (model, reasoning) => {
+  if (!isOpenAIReasoningModel(model))
+    return null;
+  const effort = resolveEffort(reasoning);
+  if (!effort)
+    return null;
+  const allowed = matches(model, OPENAI_MINIMAL_EFFORT) ? ["minimal", "low", "medium", "high"] : ["low", "medium", "high"];
+  const requested = effort === "max" ? "high" : effort;
+  return clampEffort(requested, allowed);
+};
+
+// src/ai/providers/openai.ts
+var h2IfHttps = (url) => url.startsWith("https://") ? { protocol: "http2" } : {};
+var DEFAULT_BASE_URL = "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 hasArrayContent = (msg) => typeof msg.content !== "string" && Array.isArray(msg.content);
+var buildToolMessages = (blocks) => {
+  const toolUseBlocks = blocks.filter((block) => block.type === "tool_use");
+  const toolResultBlocks = blocks.filter((block) => block.type === "tool_result");
+  const messages = [];
+  if (toolUseBlocks.length > 0) {
+    messages.push({
+      content: null,
+      role: "assistant",
+      tool_calls: toolUseBlocks.map((block) => ({
+        function: {
+          arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input),
+          name: block.name
+        },
+        id: block.id,
+        type: "function"
+      }))
+    });
+  }
+  for (const result of toolResultBlocks) {
+    messages.push({
+      content: typeof result.content === "string" ? result.content : "",
+      role: "tool",
+      tool_call_id: result.tool_use_id
+    });
+  }
+  return messages;
+};
+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) {
+    return;
+  }
+  const toolMessages = buildToolMessages(msg.content);
+  result.splice(idx, 1, ...toolMessages);
+};
+var convertSingleMessage = (result, msg, idx) => {
+  if (!msg) {
+    return;
+  }
+  processMessageAtIndex(result, msg, idx);
+};
+var convertToolResultMessages = (messages, params) => {
+  const result = [...messages];
+  for (let idx = 0;idx < params.messages.length; idx++) {
+    convertSingleMessage(result, params.messages[idx], idx);
+  }
+  return result;
+};
+var mapToolDefinitions = (tools) => tools.map((tool) => ({
+  function: {
+    description: tool.description,
+    name: tool.name,
+    parameters: tool.input_schema
+  },
+  type: "function"
+}));
+var mapContentBlockToOpenAI = (block) => {
+  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: "image_url"
+    };
+  }
+  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: "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: "video_url",
+      video_url: {
+        url: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`
+      }
+    };
+  }
+  if (block.type === "text") {
+    return { text: block.content, type: "text" };
+  }
+  return null;
+};
+var mapOpenAIContent = (msg) => {
+  if (typeof msg.content === "string") {
+    return msg.content;
+  }
+  const hasMedia = msg.content.some((block) => block.type === "image" || block.type === "document" || block.type === "audio" || block.type === "video");
+  if (!hasMedia) {
+    return null;
+  }
+  return msg.content.map(mapContentBlockToOpenAI).filter((mapped) => mapped !== null);
+};
+var buildRequestBody = (params, capabilityModel = params.model) => {
+  const messages = convertToolResultMessages(params.messages.map((msg) => ({
+    content: mapOpenAIContent(msg),
+    role: msg.role
+  })), params);
+  if (params.systemPrompt) {
+    messages.unshift({ content: params.systemPrompt, role: "system" });
+  }
+  const body = {
+    messages,
+    model: params.model,
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+  if (params.tools && params.tools.length > 0) {
+    body.tools = mapToolDefinitions(params.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 = {
+        function: { name: params.toolChoice.name },
+        type: "function"
+      };
+    }
+    if (typeof params.parallelToolCalls === "boolean") {
+      body.parallel_tool_calls = params.parallelToolCalls;
+    }
+  }
+  if (isOpenAIReasoningModel(capabilityModel)) {
+    if (typeof params.maxTokens === "number") {
+      body.max_completion_tokens = params.maxTokens;
+    }
+    if (params.reasoning) {
+      const effort = openaiEffortValue(capabilityModel, params.reasoning);
+      if (effort)
+        body.reasoning_effort = effort;
+    }
+  } else {
+    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_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.response_format = { type: params.responseFormat.type };
+    } else if (params.responseFormat.type === "json_schema") {
+      body.response_format = {
+        json_schema: {
+          name: params.responseFormat.name,
+          schema: params.responseFormat.schema,
+          strict: params.responseFormat.strict ?? true
+        },
+        type: "json_schema"
+      };
+    }
+  }
+  return body;
+};
+var parseToolInput = (rawArguments) => {
+  try {
+    return JSON.parse(rawArguments);
+  } catch {
+    return rawArguments;
+  }
+};
+var flushPendingToolCalls = function* (pendingToolCalls) {
+  for (const [, tool] of pendingToolCalls) {
+    const input = parseToolInput(tool.arguments);
+    yield {
+      id: tool.id,
+      input,
+      name: tool.name,
+      type: "tool_use"
+    };
+  }
+  pendingToolCalls.clear();
+};
+var extractUsage = (parsedUsage) => {
+  const prompt = parsedUsage.prompt_tokens ?? 0;
+  const cached = parsedUsage.cached_tokens ?? 0;
+  return {
+    cacheReadInputTokens: cached,
+    cacheWriteInputTokens: parsedUsage.cache_write_tokens || undefined,
+    costCredits: parsedUsage.cost,
+    inputTokens: Math.max(0, prompt - cached),
+    outputTokens: parsedUsage.completion_tokens ?? 0,
+    reasoningTokens: parsedUsage.reasoning_tokens || undefined,
+    upstreamInferenceCostCredits: parsedUsage.upstream_inference_cost || undefined
+  };
+};
+var resolveToolCallIndex = (toolCall) => {
+  const raw = typeof toolCall.index === "number" ? toolCall.index : NOT_FOUND;
+  return raw < 0 ? undefined : raw;
+};
+var initPendingToolCall = (toolCall, func, index, pendingToolCalls) => {
+  if (pendingToolCalls.has(index)) {
+    return;
+  }
+  const toolId = typeof toolCall.id === "string" ? toolCall.id : "";
+  const toolName = func && typeof func.name === "string" ? func.name : "";
+  pendingToolCalls.set(index, {
+    arguments: "",
+    id: toolId,
+    name: toolName
+  });
+};
+var updatePendingToolCall = (toolCall, func, pending) => {
+  if (typeof toolCall.id === "string") {
+    pending.id = toolCall.id;
+  }
+  if (func && typeof func.name === "string") {
+    pending.name = func.name;
+  }
+  if (func && typeof func.arguments === "string") {
+    pending.arguments += func.arguments;
+  }
+};
+var processToolCallDelta = (toolCall, pendingToolCalls) => {
+  const index = resolveToolCallIndex(toolCall);
+  if (index === undefined) {
+    return;
+  }
+  const func = isRecord(toolCall.function) ? toolCall.function : null;
+  initPendingToolCall(toolCall, func, index, pendingToolCalls);
+  const pending = pendingToolCalls.get(index);
+  if (!pending) {
+    return;
+  }
+  updatePendingToolCall(toolCall, func, pending);
+};
+var processToolCallDeltas = (toolCalls, pendingToolCalls) => {
+  for (const toolCall of toolCalls) {
+    processToolCallDelta(toolCall, pendingToolCalls);
+  }
+};
+var processDelta = function* (delta, pendingToolCalls) {
+  if (typeof delta.content === "string") {
+    yield { content: delta.content, type: "text" };
+  }
+  if (isRecord(delta.audio)) {
+    const audio = delta.audio;
+    if (typeof audio.data === "string" || typeof audio.transcript === "string") {
+      yield {
+        audioId: typeof audio.id === "string" ? audio.id : undefined,
+        data: typeof audio.data === "string" ? audio.data : "",
+        format: typeof audio.format === "string" ? audio.format : "pcm16",
+        transcript: typeof audio.transcript === "string" ? audio.transcript : undefined,
+        type: "audio"
+      };
+    }
+  }
+  if (isRecordArray(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")
+        continue;
+      const citation = isRecord(annotation.url_citation) ? annotation.url_citation : annotation;
+      if (typeof citation.url !== "string")
+        continue;
+      yield {
+        content: typeof citation.content === "string" ? citation.content : undefined,
+        endIndex: typeof citation.end_index === "number" ? citation.end_index : undefined,
+        startIndex: typeof citation.start_index === "number" ? citation.start_index : undefined,
+        title: typeof citation.title === "string" ? citation.title : undefined,
+        type: "citation",
+        url: citation.url
+      };
+    }
+  }
+};
+var narrowResponseMetadata = (parsed) => {
+  const providerMetadata = isRecord(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;
+  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;
+  if (delta) {
+    yield* processDelta(delta, pendingToolCalls);
+  }
+  if (choice.finish_reason === "tool_calls") {
+    yield* flushPendingToolCalls(pendingToolCalls);
+  }
+};
+var narrowUsageRecord = (parsed) => {
+  if (!isRecord(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 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({
+    cache_write_tokens: cacheWriteTokens,
+    cached_tokens: cachedTokens,
+    completion_tokens: completionTokens,
+    cost,
+    prompt_tokens: promptTokens,
+    reasoning_tokens: reasoningTokens,
+    upstream_inference_cost: upstreamInferenceCost
+  });
+  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 processSSELine = function* (line, pendingToolCalls, providerName) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("data: ")) {
+    return;
+  }
+  const data = trimmed.slice(SSE_DATA_PREFIX_LENGTH);
+  if (data === DONE_SENTINEL) {
+    yield* flushPendingToolCalls(pendingToolCalls);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return;
+  }
+  if (isRecord(parsed.error)) {
+    const error = parsed.error;
+    const metadata2 = isRecord(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({
+      message: typeof error.message === "string" ? error.message : "OpenRouter stream failed",
+      metadata: metadata2,
+      provider: providerName,
+      retryable: status === 408 || status === 409 || status === 425 || status === 429 || status !== null && status >= 500,
+      status,
+      type
+    });
+  }
+  const usageUpdate = narrowUsageRecord(parsed);
+  if (usageUpdate) {
+    yield { type: "usage_update", usage: usageUpdate };
+  }
+  const metadata = narrowResponseMetadata(parsed);
+  if (metadata) {
+    yield { metadata, type: "response_metadata" };
+  }
+  const { choices } = parsed;
+  if (!isRecordArray(choices)) {
+    return;
+  }
+  const [firstChoice] = choices;
+  if (!firstChoice) {
+    return;
+  }
+  if (isRecord(firstChoice.error)) {
+    const error = firstChoice.error;
+    const metadata2 = isRecord(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",
+      metadata: metadata2,
+      provider: providerName,
+      retryable: status === 429 || status !== null && status >= 500,
+      status,
+      type: metadata2 && typeof metadata2.error_type === "string" ? metadata2.error_type : null
+    });
+  }
+  yield* processChoice(firstChoice, pendingToolCalls);
+};
+var isUsageUpdate = (chunk) => chunk.type === "usage_update";
+var collectYieldableChunks = (line, pendingToolCalls, usageRef, metadataRef, providerName) => {
+  const allChunks = Array.from(processSSELine(line, pendingToolCalls, providerName));
+  const usageChunks = allChunks.filter(isUsageUpdate);
+  const lastUsage = usageChunks.at(NOT_FOUND);
+  if (lastUsage) {
+    usageRef.current = lastUsage.usage;
+  }
+  const metadataChunks = allChunks.filter((chunk) => chunk.type === "response_metadata");
+  const lastMetadata = metadataChunks.at(NOT_FOUND);
+  if (lastMetadata && "metadata" in lastMetadata) {
+    metadataRef.current = {
+      ...metadataRef.current,
+      ...lastMetadata.metadata,
+      providerMetadata: {
+        ...metadataRef.current?.providerMetadata,
+        ...lastMetadata.metadata.providerMetadata
+      }
+    };
+  }
+  return allChunks.filter((chunk) => !isUsageUpdate(chunk) && chunk.type !== "response_metadata");
+};
+var processSSELines = function* (lines, pendingToolCalls, usageRef, metadataRef, providerName) {
+  for (const line of lines) {
+    yield* collectYieldableChunks(line, pendingToolCalls, usageRef, metadataRef, providerName);
+  }
+};
+var processStreamValue = (value, decoder, state) => {
+  state.buffer += decoder.decode(value, { stream: true });
+  const lines = state.buffer.split(`
+`);
+  state.buffer = lines.pop() ?? "";
+  return lines;
+};
+var drainReader = 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);
+  }
+};
+var parseSSEStream = async function* (body, initialMetadata, providerName = "openai", signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  const state = {
+    buffer: "",
+    metadataRef: { current: initialMetadata },
+    pendingToolCalls: new Map,
+    providerName,
+    usageRef: { current: undefined }
+  };
+  try {
+    yield* drainReader(reader, decoder, state, signal);
+    yield {
+      metadata: state.metadataRef.current,
+      type: "done",
+      usage: state.usageRef.current
+    };
+  } finally {
+    reader.releaseLock();
+  }
+};
+var fetchOpenAIStream = async function* (baseUrl, apiKey, body, fetchImpl, headers, providerName, signal) {
+  const target = `${baseUrl}/v1/chat/completions`;
+  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} API returned no response body`,
+      provider: providerName,
+      retryable: true
+    });
+  }
+  yield* parseSSEStream(response.body, {
+    generationId: response.headers.get("X-Generation-Id") ?? undefined,
+    providerMetadata: {
+      cacheAge: response.headers.get("X-OpenRouter-Cache-Age") ?? undefined,
+      cacheSourceId: response.headers.get("X-OpenRouter-Cache-Source-Id") ?? undefined,
+      cacheStatus: response.headers.get("X-OpenRouter-Cache-Status") ?? undefined,
+      cacheTtl: response.headers.get("X-OpenRouter-Cache-TTL") ?? undefined
+    }
+  }, providerName, signal);
+};
+var openai = (config2) => {
+  const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL;
+  const fetchImpl = config2.fetch ?? globalThis.fetch;
+  const providerName = config2.providerName ?? "openai";
+  if (!config2.apiKey && !config2.tokenSource) {
+    throw new Error("openai() requires either apiKey or tokenSource");
+  }
+  const resolveKey = async () => {
+    if (config2.tokenSource) {
+      return await Promise.resolve(config2.tokenSource());
+    }
+    return config2.apiKey;
+  };
+  const resolveHeaders = async (params) => typeof config2.headers === "function" ? await config2.headers(params) : config2.headers ?? {};
+  return instrumentAIProvider({
+    stream: (params) => {
+      const openaiBody = buildRequestBody(params, config2.modelForCapabilities?.(params.model) ?? params.model);
+      const body = config2.transformRequestBody ? config2.transformRequestBody(openaiBody, params) : openaiBody;
+      return async function* () {
+        const [apiKey, headers] = await Promise.all([
+          resolveKey(),
+          resolveHeaders(params)
+        ]);
+        yield* fetchOpenAIStream(baseUrl, apiKey, body, fetchImpl, headers, providerName, params.signal);
+      }();
+    }
+  }, providerName);
+};
+
+// src/ai/providers/openaiResponses.ts
+var h2IfHttps2 = (url) => url.startsWith("https://") ? { protocol: "http2" } : {};
+var DEFAULT_BASE_URL2 = "https://api.openai.com";
+var EVENT_PREFIX_LENGTH = 7;
+var DATA_PREFIX_LENGTH = 6;
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var isRecordArray2 = (value) => Array.isArray(value) && value.length > 0 && isRecord2(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 buildRequestBody2 = (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 parseToolInput2 = (rawArguments) => {
+  try {
+    return JSON.parse(rawArguments);
+  } catch {
+    return rawArguments;
+  }
+};
+var extractUsage2 = (response) => {
+  if (!isRecord2(response.usage)) {
+    return;
+  }
+  const { usage } = response;
+  const input = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+  const cached = isRecord2(usage.input_tokens_details) && typeof usage.input_tokens_details.cached_tokens === "number" ? usage.input_tokens_details.cached_tokens : 0;
+  const outputDetails = isRecord2(usage.output_tokens_details) ? usage.output_tokens_details : undefined;
+  const inputDetails = isRecord2(usage.input_tokens_details) ? usage.input_tokens_details : undefined;
+  const costDetails = isRecord2(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 (isRecord2(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 = isRecord2(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: parseToolInput2(args),
+    name,
+    providerData: pending?.providerData ? { ...pending.providerData, arguments: args } : undefined,
+    type: "tool_use"
+  };
+};
+var processOutputItemAdded = (parsed, pendingCalls) => {
+  if (!isRecord2(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 (!isRecord2(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 (!isRecordArray2(item.content))
+      continue;
+    for (const content of item.content) {
+      if (!Array.isArray(content.annotations))
+        continue;
+      for (const annotation of content.annotations) {
+        if (!isRecord2(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 (!isRecord2(parsed.response)) {
+    yield { type: "done", usage: undefined };
+    return;
+  }
+  const { response } = parsed;
+  const usage = extractUsage2(response);
+  const metadata = extractResponseMetadata(response);
+  if (isRecordArray2(response.output)) {
+    yield* extractCitationsFromOutput(response.output);
+    yield* extractImageFromOutput(response.output);
+  }
+  yield { metadata, type: "done", usage };
+};
+var responseFailure = (eventType, parsed, providerName) => {
+  const response = isRecord2(parsed.response) ? parsed.response : parsed;
+  const error = isRecord2(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 processSSELine2 = function* (line, state) {
+  const trimmed = line.trim();
+  if (trimmed) {
+    parseSSELine(trimmed, state);
+    return;
+  }
+  yield* flushSSEBuffer(state);
+};
+var processSSELines2 = function* (lines, state) {
+  for (const line of lines) {
+    yield* processSSELine2(line, state);
+  }
+};
+var drainReader2 = 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* processSSELines2(lines, state);
+  }
+  if (textBuffer.trim()) {
+    yield* processSSELines2([textBuffer, ""], state);
+  }
+};
+var parseSSEStream2 = 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* drainReader2(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, {
+    ...h2IfHttps2(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* parseSSEStream2(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_URL2;
+  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 builtBody = buildRequestBody2(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/anthropic.ts
+var h2IfHttps3 = (url) => url.startsWith("https://") ? { protocol: "http2" } : {};
+var DEFAULT_BASE_URL3 = "https://api.anthropic.com";
+var API_VERSION = "2023-06-01";
+var DEFAULT_MAX_TOKENS = 32000;
+var EVENT_PREFIX_LENGTH2 = 7;
+var DATA_PREFIX_LENGTH2 = 6;
+var EMPTY_CHUNKS = [];
+var isRecord3 = (val) => typeof val === "object" && val !== null;
+var mapContentBlock = (block) => {
+  if (block.type === "thinking") {
+    return {
+      signature: block.signature,
+      thinking: block.thinking,
+      type: "thinking"
+    };
+  }
+  if (block.type === "image") {
+    return {
+      source: block.source,
+      type: "image"
+    };
+  }
+  if (block.type === "document") {
+    return {
+      source: block.source,
+      type: "document"
+    };
+  }
+  if (block.type === "tool_result") {
+    return {
+      content: block.content,
+      tool_use_id: block.tool_use_id,
+      type: "tool_result"
+    };
+  }
+  if (block.type === "tool_use") {
+    if (block.providerData)
+      return { ...block.providerData };
+    return {
+      id: block.id,
+      input: block.input,
+      name: block.name,
+      type: "tool_use"
+    };
+  }
+  if (block.type === "audio" || block.type === "video") {
+    throw new Error(`Anthropic does not support ${block.type} content blocks`);
+  }
+  if (block.type === "provider_data") {
+    return { ...block.data };
+  }
+  return { text: block.content, type: "text" };
+};
+var mapMessage = (msg) => ({
+  content: typeof msg.content === "string" ? msg.content : msg.content.map(mapContentBlock),
+  role: msg.role === "system" ? "user" : msg.role
+});
+var mapToolDefinition2 = (tool) => ({
+  description: tool.description,
+  input_schema: tool.input_schema,
+  name: tool.name
+});
+var cacheLastContentBlock = (msg) => {
+  const cacheControl = { type: "ephemeral" };
+  if (typeof msg.content === "string") {
+    return {
+      content: [
+        { cache_control: cacheControl, text: msg.content, type: "text" }
+      ],
+      role: msg.role
+    };
+  }
+  if (msg.content.length === 0)
+    return msg;
+  const blocks = [...msg.content];
+  blocks[blocks.length - 1] = {
+    ...blocks[blocks.length - 1],
+    cache_control: cacheControl
+  };
+  return { content: blocks, role: msg.role };
+};
+var buildRequestBody3 = (params, configuredMax, configCaching) => {
+  const caching = params.promptCaching ?? configCaching;
+  const cacheSystem = params.cacheSystemPrompt ?? caching;
+  const messages = params.messages.filter((msg) => msg.role !== "system").map(mapMessage);
+  if (caching && messages.length > 1) {
+    const last = messages[messages.length - 1];
+    if (last) {
+      messages[messages.length - 1] = cacheLastContentBlock(last);
+    }
+  }
+  const max = typeof params.maxTokens === "number" ? params.maxTokens : configuredMax;
+  const body = {
+    max_tokens: max,
+    messages,
+    model: params.model,
+    stream: true
+  };
+  if (params.systemPrompt) {
+    body.system = cacheSystem ? [
+      {
+        cache_control: { type: "ephemeral" },
+        text: params.systemPrompt,
+        type: "text"
+      }
+    ] : params.systemPrompt;
+  }
+  if (params.tools && params.tools.length > 0) {
+    const tools = params.tools.map(mapToolDefinition2);
+    if (caching) {
+      tools[tools.length - 1] = {
+        ...tools[tools.length - 1],
+        cache_control: { type: "ephemeral" }
+      };
+    }
+    body.tools = tools;
+    if (params.toolChoice === "auto" || params.toolChoice === "none") {
+      body.tool_choice = { type: params.toolChoice };
+    } else if (params.toolChoice === "required") {
+      body.tool_choice = { type: "any" };
+    } else if (params.toolChoice && typeof params.toolChoice === "object") {
+      body.tool_choice = { name: params.toolChoice.name, type: "tool" };
+    }
+  }
+  if (params.stopSequences && params.stopSequences.length > 0) {
+    body.stop_sequences = params.stopSequences;
+  }
+  const mode = params.reasoning ? anthropicReasoningMode(params.model) : "none";
+  const thinkingActive = mode !== "none";
+  if (!thinkingActive && anthropicSupportsSampling(params.model)) {
+    if (typeof params.temperature === "number") {
+      body.temperature = params.temperature;
+    }
+    if (typeof params.topP === "number")
+      body.top_p = params.topP;
+  }
+  if (mode === "effort" || mode === "adaptive") {
+    body.thinking = { type: "adaptive" };
+    if (mode === "effort" && params.reasoning) {
+      const effort = anthropicEffortValue(params.model, params.reasoning);
+      if (effort)
+        body.output_config = { effort };
+    }
+  } else if (mode === "legacy" && params.reasoning) {
+    const budget = resolveBudgetTokens(params.reasoning);
+    if (budget) {
+      body.thinking = { budget_tokens: budget, type: "enabled" };
+      body.max_tokens = Math.max(max, budget + max);
+    }
+  }
+  return body;
+};
+var classifyLine = (line) => {
+  if (line.startsWith("event: ")) {
+    return {
+      field: "event",
+      value: line.slice(EVENT_PREFIX_LENGTH2)
+    };
+  }
+  if (line.startsWith("data: ")) {
+    return {
+      field: "data",
+      value: line.slice(DATA_PREFIX_LENGTH2)
+    };
+  }
+  return;
+};
+var applyClassified = (acc, classified) => {
+  if (!classified) {
+    return acc;
+  }
+  if (classified.field === "event") {
+    return { eventData: acc.eventData, eventType: classified.value };
+  }
+  return { eventData: classified.value, eventType: acc.eventType };
+};
+var parseEventLines = (event) => event.split(`
+`).reduce((acc, line) => applyClassified(acc, classifyLine(line)), {
+  eventData: "",
+  eventType: ""
+});
+var safeParse = (text) => {
+  try {
+    const result = JSON.parse(text);
+    return result;
+  } catch {
+    return;
+  }
+};
+var tryParseJson = (text) => {
+  const result = safeParse(text);
+  if (isRecord3(result)) {
+    return result;
+  }
+  return;
+};
+var getRecord = (obj, key) => {
+  const val = obj[key];
+  if (isRecord3(val)) {
+    return val;
+  }
+  return;
+};
+var getString = (obj, key) => {
+  const val = obj[key];
+  if (typeof val === "string") {
+    return val;
+  }
+  return "";
+};
+var getNumber = (obj, key) => {
+  const val = obj[key];
+  if (typeof val === "number") {
+    return val;
+  }
+  return 0;
+};
+var handleContentBlockStart = (parsed, state) => {
+  const block = getRecord(parsed, "content_block");
+  if (block && block.type === "tool_use") {
+    state.currentToolId = getString(block, "id");
+    state.currentToolName = getString(block, "name");
+    state.toolInputJson = "";
+    state.isThinkingBlock = false;
+    state.currentProviderBlock = undefined;
+  } else if (block && block.type === "thinking") {
+    state.isThinkingBlock = true;
+    state.thinkingSignature = "";
+    state.currentProviderBlock = undefined;
+  } else {
+    state.isThinkingBlock = false;
+    state.currentProviderBlock = block && block.type !== "text" ? { ...block } : undefined;
+    state.providerBlockInputJson = "";
+  }
+};
+var handleContentBlockDelta = (parsed, state) => {
+  const delta = getRecord(parsed, "delta");
+  if (!delta) {
+    return;
+  }
+  if (delta.type === "thinking_delta") {
+    return {
+      content: getString(delta, "thinking"),
+      type: "thinking"
+    };
+  }
+  if (delta.type === "text_delta") {
+    return {
+      content: getString(delta, "text"),
+      type: "text"
+    };
+  }
+  if (delta.type === "input_json_delta") {
+    if (state.currentProviderBlock) {
+      state.providerBlockInputJson += getString(delta, "partial_json");
+    } else {
+      state.toolInputJson += getString(delta, "partial_json");
+    }
+  }
+  if (delta.type === "signature_delta") {
+    state.thinkingSignature += getString(delta, "signature");
+  }
+  return;
+};
+var handleContentBlockStop = (state) => {
+  if (state.isThinkingBlock && state.thinkingSignature) {
+    state.isThinkingBlock = false;
+    const signature = state.thinkingSignature;
+    state.thinkingSignature = "";
+    return {
+      content: "",
+      signature,
+      type: "thinking"
+    };
+  }
+  if (state.currentProviderBlock) {
+    const data = { ...state.currentProviderBlock };
+    if (state.providerBlockInputJson) {
+      data.input = tryParseJson(state.providerBlockInputJson) ?? state.providerBlockInputJson;
+    }
+    state.currentProviderBlock = undefined;
+    state.providerBlockInputJson = "";
+    return {
+      data,
+      provider: state.providerName,
+      type: "provider_event"
+    };
+  }
+  if (!state.currentToolId) {
+    return;
+  }
+  const input = tryParseJson(state.toolInputJson) ?? state.toolInputJson;
+  const chunk = {
+    id: state.currentToolId,
+    input,
+    name: state.currentToolName,
+    type: "tool_use"
+  };
+  state.currentToolId = "";
+  state.currentToolName = "";
+  state.toolInputJson = "";
+  return chunk;
+};
+var extractUsage3 = (usageRecord, existingUsage) => {
+  if (!usageRecord) {
+    return existingUsage;
+  }
+  const normalized = {
+    cacheReadInputTokens: getNumber(usageRecord, "cache_read_input_tokens") || existingUsage?.cacheReadInputTokens || 0,
+    cacheWriteInputTokens: getNumber(usageRecord, "cache_creation_input_tokens") || existingUsage?.cacheWriteInputTokens || 0,
+    inputTokens: getNumber(usageRecord, "input_tokens") || existingUsage?.inputTokens || 0,
+    outputTokens: getNumber(usageRecord, "output_tokens") || existingUsage?.outputTokens || 0,
+    costCredits: getNumber(usageRecord, "cost") || existingUsage?.costCredits,
+    reasoningTokens: getNumber(usageRecord, "reasoning_tokens") || existingUsage?.reasoningTokens,
+    upstreamInferenceCostCredits: getNumber(getRecord(usageRecord, "cost_details") ?? {}, "upstream_inference_cost") || existingUsage?.upstreamInferenceCostCredits
+  };
+  const serverToolUse = getRecord(usageRecord, "server_tool_use");
+  if (serverToolUse) {
+    normalized.serverToolUse = Object.fromEntries(Object.entries(serverToolUse).filter((entry) => typeof entry[1] === "number"));
+  }
+  return normalized;
+};
+var mergeMetadata = (source, state) => {
+  const providerMetadata = getRecord(source, "openrouter_metadata");
+  const generationId = getString(source, "id") || undefined;
+  const model = getString(source, "model") || undefined;
+  const provider = getString(source, "provider") || undefined;
+  const serviceTier = getString(source, "service_tier") || undefined;
+  if (!providerMetadata && !generationId && !model && !provider && !serviceTier)
+    return;
+  state.metadata = {
+    ...state.metadata,
+    generationId: generationId ?? state.metadata?.generationId,
+    model: model ?? state.metadata?.model,
+    provider: provider ?? state.metadata?.provider,
+    providerMetadata: {
+      ...state.metadata?.providerMetadata,
+      ...providerMetadata
+    },
+    serviceTier: serviceTier ?? state.metadata?.serviceTier
+  };
+};
+var handleMessageDelta = (parsed, state) => {
+  const deltaUsage = getRecord(parsed, "usage");
+  state.usage = extractUsage3(deltaUsage, state.usage);
+  const delta = getRecord(parsed, "delta");
+  const stopReason = delta ? getString(delta, "stop_reason") : "";
+  if (stopReason)
+    state.stopReason = stopReason;
+};
+var handleMessageStart = (parsed, state) => {
+  const message = getRecord(parsed, "message");
+  if (!message) {
+    return;
+  }
+  const startUsage = getRecord(message, "usage");
+  state.usage = extractUsage3(startUsage, state.usage);
+  mergeMetadata(message, state);
+};
+var handleError = (parsed, state) => {
+  const error = getRecord(parsed, "error");
+  const errorMessage = error ? getString(error, "message") : "";
+  const nativeErrorType = error ? getString(error, "type") : "";
+  const errorType = error ? getString(error, "error_type") || nativeErrorType : "";
+  const retryable = errorType === "provider_overloaded" || errorType === "rate_limit_exceeded" || errorType === "provider_unavailable" || errorType === "server" || nativeErrorType === "overloaded_error" || nativeErrorType === "rate_limit_error" || nativeErrorType === "api_error";
+  throw new ProviderError({
+    message: errorMessage || "Anthropic API error",
+    metadata: error,
+    provider: state.providerName,
+    retryable,
+    type: errorType || null
+  });
+};
+var processEvent = (eventType, parsed, state) => {
+  switch (eventType) {
+    case "content_block_start": {
+      handleContentBlockStart(parsed, state);
+      return;
+    }
+    case "content_block_delta": {
+      return handleContentBlockDelta(parsed, state);
+    }
+    case "content_block_stop": {
+      return handleContentBlockStop(state);
+    }
+    case "message_delta": {
+      handleMessageDelta(parsed, state);
+      mergeMetadata(parsed, state);
+      return;
+    }
+    case "message_start": {
+      handleMessageStart(parsed, state);
+      return;
+    }
+    case "message_stop": {
+      mergeMetadata(parsed, state);
+      return {
+        stopReason: state.stopReason,
+        metadata: state.metadata,
+        type: "done",
+        usage: state.usage
+      };
+    }
+    case "error": {
+      handleError(parsed, state);
+      return;
+    }
+    default: {
+      return;
+    }
+  }
+};
+var processSingleEvent = (event, state) => {
+  if (!event.trim()) {
+    return;
+  }
+  const { eventData, eventType } = parseEventLines(event);
+  if (!eventData) {
+    return;
+  }
+  const parsed = tryParseJson(eventData);
+  if (!parsed) {
+    return;
+  }
+  return processEvent(eventType, parsed, state);
+};
+var collectChunk = (event, state) => {
+  const chunk = processSingleEvent(event, state);
+  return chunk ? [chunk] : [];
+};
+var processBufferedEvents = (eventsText, state) => {
+  const events = eventsText.split(`
+
+`);
+  state.buffer = events.pop() ?? "";
+  return events.flatMap((event) => collectChunk(event, state));
+};
+var readNextChunks = async (reader, decoder, state, signal) => {
+  if (signal?.aborted) {
+    return { chunks: EMPTY_CHUNKS, done: true };
+  }
+  const { done, value } = await reader.read();
+  if (done) {
+    return { chunks: EMPTY_CHUNKS, done: true };
+  }
+  const rawText = state.buffer + decoder.decode(value, { stream: true });
+  const chunks = processBufferedEvents(rawText, state);
+  return { chunks, done: false };
+};
+var findDoneChunk = (chunks) => chunks.findIndex((c) => c.type === "done");
+var sseStreamLoop = async (reader, decoder, state, signal) => {
+  const result = await readNextChunks(reader, decoder, state, signal);
+  if (result.done) {
+    return { chunks: result.chunks, finished: true };
+  }
+  const doneIdx = findDoneChunk(result.chunks);
+  if (doneIdx >= 0) {
+    return { chunks: result.chunks.slice(0, doneIdx + 1), finished: true };
+  }
+  return { chunks: result.chunks, finished: false };
+};
+async function* streamChunks(reader, decoder, state, signal) {
+  let finished = false;
+  while (!finished) {
+    const result = await sseStreamLoop(reader, decoder, state, signal);
+    ({ finished } = result);
+    yield* result.chunks;
+  }
+}
+async function* parseSSEStream3(body, providerName, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  const state = {
+    buffer: "",
+    currentToolId: "",
+    currentToolName: "",
+    isThinkingBlock: false,
+    stopReason: "",
+    thinkingSignature: "",
+    toolInputJson: "",
+    usage: undefined,
+    providerName,
+    providerBlockInputJson: ""
+  };
+  try {
+    yield* streamChunks(reader, decoder, state, signal);
+  } finally {
+    reader.releaseLock();
+  }
+}
+var fetchAndStream = async function* (baseUrl, config2, params, configuredMax, promptCaching, providerName) {
+  const builtBody = buildRequestBody3(params, configuredMax, promptCaching);
+  const body = config2.transformRequestBody ? config2.transformRequestBody(builtBody, params) : builtBody;
+  const target = `${baseUrl}/v1/messages`;
+  const fetchImpl = config2.fetch ?? fetch;
+  const token = config2.tokenSource ? await Promise.resolve(config2.tokenSource()) : config2.apiKey;
+  const suppliedHeaders = typeof config2.headers === "function" ? await config2.headers(params) : config2.headers ?? {};
+  const requestHeaders = new Headers(suppliedHeaders);
+  requestHeaders.set("Content-Type", "application/json");
+  if (config2.authStyle === "bearer") {
+    requestHeaders.set("Authorization", `Bearer ${token}`);
+  } else {
+    requestHeaders.set("anthropic-version", API_VERSION);
+    requestHeaders.set("x-api-key", token);
+  }
+  const response = await fetchImpl(target, {
+    ...h2IfHttps3(target),
+    body: JSON.stringify(body),
+    headers: requestHeaders,
+    method: "POST",
+    signal: params.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw ProviderError.fromResponse(providerName, response.status, errorText);
+  }
+  if (!response.body) {
+    throw new ProviderError({
+      message: `${providerName} Messages API returned no response body`,
+      provider: providerName,
+      retryable: true
+    });
+  }
+  yield* parseSSEStream3(response.body, providerName, params.signal);
+};
+var anthropic = (config2) => {
+  if (!config2.apiKey && !config2.tokenSource)
+    throw new Error("anthropic() requires either apiKey or tokenSource");
+  const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL3;
+  const configuredMax = config2.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const promptCaching = config2.promptCaching ?? true;
+  const providerName = config2.providerName ?? "anthropic";
+  return instrumentAIProvider({
+    stream: (params) => fetchAndStream(baseUrl, config2, params, configuredMax, promptCaching, providerName)
+  }, providerName);
+};
+
+// src/ai/providers/openrouterClient.ts
+var DEFAULT_BASE_URL4 = "https://openrouter.ai/api/v1";
+var withoutLatestPrefix = (model) => model.startsWith("~") ? model.slice(1) : model;
+var openRouterModelMatchesRule = (model, rule) => {
+  const normalizedModel = withoutLatestPrefix(model);
+  const normalizedRule = withoutLatestPrefix(rule);
+  return normalizedRule.endsWith("/*") ? normalizedModel.startsWith(normalizedRule.slice(0, -1)) : normalizedModel === normalizedRule;
+};
+var assertAllowedModel = (model, allowedModels) => {
+  if (!allowedModels)
+    return;
+  if (allowedModels.some((rule) => openRouterModelMatchesRule(model, rule)))
+    return;
+  throw new Error(`OpenRouter model "${model}" is not allowed`);
+};
+var normalizePath = (path) => path.startsWith("/") ? path : `/${path}`;
+var encodeModelPath = (model) => model.split("/").map(encodeURIComponent).join("/");
+var withQuery = (url, query) => {
+  if (!query)
+    return url;
+  const result = new URL(url);
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined)
+      result.searchParams.set(key, String(value));
+  }
+  return result.toString();
+};
+var parseImageSSE = async function* (response) {
+  if (!response.body)
+    throw new Error("OpenRouter image stream has no body");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    for (;; ) {
+      const result = await reader.read();
+      buffer += decoder.decode(result.value, { stream: !result.done });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: "))
+          continue;
+        const data = line.slice(6);
+        if (data === "[DONE]")
+          return;
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed && typeof parsed === "object" && "type" in parsed)
+            yield parsed;
+        } catch {}
+      }
+      if (result.done)
+        break;
+    }
+    if (buffer.startsWith("data: ")) {
+      const parsed = JSON.parse(buffer.slice(6));
+      if (parsed && typeof parsed === "object" && "type" in parsed)
+        yield parsed;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+};
+var toBytes = (value) => typeof value === "string" ? new TextEncoder().encode(value) : value;
+var hexToBytes = (hex) => {
+  if (!/^[0-9a-f]+$/iu.test(hex) || hex.length % 2 !== 0)
+    return;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let index = 0;index < bytes.length; index += 1) {
+    bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+};
+var constantTimeEqual = (left, right) => {
+  if (left.length !== right.length)
+    return false;
+  let mismatch = 0;
+  for (let index = 0;index < left.length; index += 1)
+    mismatch |= (left[index] ?? 0) ^ (right[index] ?? 0);
+  return mismatch === 0;
+};
+var verifyOpenRouterWebhookSignature = async (options) => {
+  const fields = new Map(options.header.split(",").map((part) => {
+    const [key2, ...rest] = part.trim().split("=");
+    return [key2, rest.join("=")];
+  }));
+  const timestamp = fields.get("t");
+  const supplied = fields.get("v1");
+  if (!timestamp || !supplied)
+    return false;
+  const timestampNumber = Number(timestamp);
+  const now = options.nowSeconds ?? Math.floor(Date.now() / 1000);
+  const tolerance = options.toleranceSeconds ?? 300;
+  if (!Number.isFinite(timestampNumber) || Math.abs(now - timestampNumber) > tolerance)
+    return false;
+  const key = await crypto.subtle.importKey("raw", Uint8Array.from(toBytes(options.secret)).buffer, { hash: "SHA-256", name: "HMAC" }, false, ["sign"]);
+  const prefix = new TextEncoder().encode(`${timestamp},`);
+  const body = toBytes(options.body);
+  const payload = new Uint8Array(prefix.length + body.length);
+  payload.set(prefix);
+  payload.set(body, prefix.length);
+  const expected = new Uint8Array(await crypto.subtle.sign("HMAC", key, payload.buffer));
+  const suppliedBytes = hexToBytes(supplied);
+  return suppliedBytes ? constantTimeEqual(expected, suppliedBytes) : false;
+};
+var createOpenRouterClient = (config2) => {
+  if (!config2.apiKey && !config2.tokenSource)
+    throw new Error("createOpenRouterClient() requires either apiKey or tokenSource");
+  const baseUrl = (config2.baseUrl ?? DEFAULT_BASE_URL4).replace(/\/$/, "");
+  const fetchImpl = config2.fetch ?? globalThis.fetch;
+  const allowedModels = config2.allowedModels ? [...config2.allowedModels] : undefined;
+  const requestRaw = async (path, options = {}) => {
+    const token = config2.tokenSource ? await Promise.resolve(config2.tokenSource()) : config2.apiKey;
+    const suppliedHeaders = typeof config2.headers === "function" ? await config2.headers() : config2.headers ?? {};
+    const headers = new Headers(suppliedHeaders);
+    new Headers(options.headers).forEach((value, key) => headers.set(key, value));
+    headers.set("Authorization", `Bearer ${token}`);
+    let body;
+    if (options.body instanceof FormData || options.body instanceof Blob) {
+      body = options.body;
+    } else if (options.body !== undefined) {
+      headers.set("Content-Type", "application/json");
+      body = JSON.stringify(options.body);
+    }
+    const { query, ...requestInit } = options;
+    const response = await fetchImpl(withQuery(`${baseUrl}${normalizePath(path)}`, options.query), { ...requestInit, body, headers });
+    if (!response.ok) {
+      throw ProviderError.fromResponse("openrouter", response.status, await response.text());
+    }
+    return response;
+  };
+  const request = async (path, options = {}) => (await requestRaw(path, options)).json();
+  const listModels = async (query) => {
+    const result = await request("/models", { query });
+    if (!allowedModels)
+      return result;
+    return {
+      ...result,
+      data: result.data.filter((model) => allowedModels.some((rule) => openRouterModelMatchesRule(model.id, rule)))
+    };
+  };
+  const filterModelList = (result) => {
+    if (!allowedModels)
+      return result;
+    return {
+      ...result,
+      data: result.data.filter((model) => allowedModels.some((rule) => openRouterModelMatchesRule(model.id, rule)))
+    };
+  };
+  return {
+    cancelBatch: (id) => request(`/batches/${encodeURIComponent(id)}/cancel`, {
+      method: "POST"
+    }),
+    createBatch: (body) => request("/batches", { body, method: "POST" }),
+    createEmbedding: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return request("/embeddings", {
+        body,
+        method: "POST"
+      });
+    },
+    generateImage: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return request("/images", {
+        body,
+        method: "POST"
+      });
+    },
+    deleteFile: (id, workspaceId) => request(`/files/${encodeURIComponent(id)}`, { method: "DELETE", query: { workspace_id: workspaceId } }),
+    downloadFile: (id, workspaceId) => requestRaw(`/files/${encodeURIComponent(id)}/content`, {
+      query: { workspace_id: workspaceId }
+    }),
+    downloadVideo: (id, index = 0) => requestRaw(`/videos/${encodeURIComponent(id)}/content`, {
+      query: { index }
+    }),
+    generateVideo: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return request("/videos", {
+        body,
+        method: "POST"
+      });
+    },
+    getBatch: (id) => request(`/batches/${encodeURIComponent(id)}`),
+    getCredits: () => request("/credits"),
+    getCurrentKey: () => request("/key"),
+    getFile: (id, workspaceId) => request(`/files/${encodeURIComponent(id)}`, {
+      query: { workspace_id: workspaceId }
+    }),
+    getGeneration: (id) => request("/generation", {
+      query: { id }
+    }),
+    getModelEndpoints: (model) => {
+      assertAllowedModel(model, allowedModels);
+      return request(`/models/${encodeModelPath(model)}/endpoints`);
+    },
+    getModel: (model) => {
+      assertAllowedModel(model, allowedModels);
+      return request(`/model/${encodeModelPath(model)}`);
+    },
+    getImageModelEndpoints: (model) => {
+      assertAllowedModel(model, allowedModels);
+      return request(`/images/models/${encodeModelPath(model)}/endpoints`);
+    },
+    getVideo: (id) => request(`/videos/${encodeURIComponent(id)}`),
+    listImageModels: async () => filterModelList(await request("/images/models")),
+    listFiles: (query) => request("/files", { query }),
+    listModels,
+    listUserModels: async () => filterModelList(await request("/models/user")),
+    listZdrEndpoints: async () => {
+      const result = await request("/endpoints/zdr");
+      if (!allowedModels)
+        return result;
+      return {
+        ...result,
+        data: result.data.filter((endpoint) => allowedModels.some((rule) => openRouterModelMatchesRule(endpoint.model_id, rule)))
+      };
+    },
+    countModels: (outputModalities) => request("/models/count", {
+      query: { output_modalities: outputModalities }
+    }),
+    listPresets: (offset = 0, limit = 100) => request("/presets", { query: { limit, offset } }),
+    listPresetVersions: (slug, offset = 0, limit = 100) => request(`/presets/${encodeURIComponent(slug)}/versions`, { query: { limit, offset } }),
+    listProviders: () => request("/providers"),
+    listRerankModels: async () => filterModelList(await request("/rerank/models")),
+    listVideoModels: async () => filterModelList(await request("/videos/models")),
+    request,
+    requestRaw,
+    streamImage: async function* (body, options = {}) {
+      assertAllowedModel(body.model, allowedModels);
+      const response = await requestRaw("/images", {
+        ...options,
+        body: { ...body, stream: true },
+        method: "POST"
+      });
+      yield* parseImageSSE(response);
+    },
+    respond: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return body.stream ? requestRaw("/responses", { body, method: "POST" }) : request("/responses", {
+        body,
+        method: "POST"
+      });
+    },
+    rerank: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return request("/rerank", {
+        body,
+        method: "POST"
+      });
+    },
+    speak: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return requestRaw("/audio/speech", { body, method: "POST" });
+    },
+    transcribe: (body) => {
+      if (body instanceof FormData) {
+        const model = body.get("model");
+        if (typeof model !== "string")
+          throw new Error("OpenRouter transcription FormData requires model");
+        assertAllowedModel(model, allowedModels);
+      } else {
+        assertAllowedModel(body.model, allowedModels);
+      }
+      return request("/audio/transcriptions", {
+        body,
+        method: "POST"
+      });
+    },
+    uploadFile: (file, options = {}) => {
+      const body = new FormData;
+      if (options.filename)
+        body.append("file", file, options.filename);
+      else
+        body.append("file", file);
+      return request("/files", {
+        body,
+        method: "POST",
+        query: { workspace_id: options.workspaceId }
+      });
+    }
+  };
+};
+
+// src/ai/providers/openrouter.ts
+var DEFAULT_BASE_URL5 = "https://openrouter.ai/api";
+var MAX_APP_CATEGORIES = 2;
+var withoutLatestPrefix2 = (model) => model.startsWith("~") ? model.slice(1) : model;
+var modelForOpenAICapabilities = (model) => {
+  const normalized = withoutLatestPrefix2(model);
+  return normalized.startsWith("openai/") ? normalized.slice("openai/".length) : normalized;
+};
+var modelMatchesRule = (model, rule) => {
+  const normalizedModel = withoutLatestPrefix2(model);
+  const normalizedRule = withoutLatestPrefix2(rule);
+  if (normalizedRule.endsWith("/*")) {
+    return normalizedModel.startsWith(normalizedRule.slice(0, -1));
+  }
+  return normalizedModel === normalizedRule;
+};
+var providerMatchesRule = (provider, rule) => provider === rule || provider.startsWith(`${rule}/`);
+var assertNonEmptyPolicy = (label, value) => {
+  if (value && value.length === 0) {
+    throw new Error(`openrouter() ${label} must not be empty`);
+  }
+};
+var assertRoutingPolicy = (config2) => {
+  assertNonEmptyPolicy("allowedProviders", config2.allowedProviders);
+  assertNonEmptyPolicy("routing.only", config2.routing?.only);
+  assertNonEmptyPolicy("allowedPresets", config2.allowedPresets);
+  if (config2.appCategories && config2.appCategories.length > MAX_APP_CATEGORIES) {
+    throw new Error("openrouter() appCategories supports at most 2 entries");
+  }
+  if (!config2.allowedProviders)
+    return;
+  const selected = [
+    ...config2.routing?.only ?? [],
+    ...config2.routing?.order ?? []
+  ];
+  const denied = selected.find((provider) => !config2.allowedProviders.some((rule) => providerMatchesRule(provider, rule)));
+  if (denied) {
+    throw new Error(`openrouter() provider "${denied}" is outside allowedProviders`);
+  }
+};
+var assertRequestRoutingPolicy = (routing, allowedProviders) => {
+  assertRoutingPolicy({
+    allowedProviders,
+    apiKey: "policy-validation",
+    routing
+  });
+};
+var mapRouting = (routing, allowedProviders) => {
+  const only = routing?.only ?? allowedProviders;
+  const wire = {};
+  if (typeof routing?.allowFallbacks === "boolean")
+    wire.allow_fallbacks = routing.allowFallbacks;
+  if (routing?.dataCollection)
+    wire.data_collection = routing.dataCollection;
+  if (typeof routing?.enforceDistillableText === "boolean")
+    wire.enforce_distillable_text = routing.enforceDistillableText;
+  if (routing?.ignore)
+    wire.ignore = [...routing.ignore];
+  if (routing?.maxPrice)
+    wire.max_price = { ...routing.maxPrice };
+  if (only)
+    wire.only = [...only];
+  if (routing?.order)
+    wire.order = [...routing.order];
+  if (routing?.preferredMaxLatency !== undefined)
+    wire.preferred_max_latency = routing.preferredMaxLatency;
+  if (routing?.preferredMinThroughput !== undefined)
+    wire.preferred_min_throughput = routing.preferredMinThroughput;
+  if (routing?.quantizations)
+    wire.quantizations = [...routing.quantizations];
+  if (typeof routing?.requireParameters === "boolean")
+    wire.require_parameters = routing.requireParameters;
+  if (routing?.sort)
+    wire.sort = routing.sort;
+  if (typeof routing?.zdr === "boolean")
+    wire.zdr = routing.zdr;
+  return wire;
+};
+var requestOptionsFor = (params, defaults) => {
+  const supplied = params.providerOptions?.openrouter;
+  if (supplied !== undefined && (typeof supplied !== "object" || !supplied)) {
+    throw new Error("providerOptions.openrouter must be an object");
+  }
+  return {
+    ...defaults,
+    ...supplied
+  };
+};
+var resolveAttributionHeaders = async (config2, params) => {
+  const supplied = typeof config2.headers === "function" ? await config2.headers() : config2.headers ?? {};
+  const headers = new Headers(supplied);
+  if (config2.appUrl)
+    headers.set("HTTP-Referer", config2.appUrl);
+  if (config2.appName)
+    headers.set("X-OpenRouter-Title", config2.appName);
+  if (config2.appCategories?.length) {
+    headers.set("X-OpenRouter-Categories", config2.appCategories.join(","));
+  }
+  const options = requestOptionsFor(params, config2.requestOptions);
+  if (options.routerMetadata ?? true)
+    headers.set("X-OpenRouter-Metadata", "enabled");
+  if (options.sessionId)
+    headers.set("X-Session-Id", options.sessionId);
+  if (options.responseCache) {
+    headers.set("X-OpenRouter-Cache", options.responseCache.enabled ? "true" : "false");
+    if (options.responseCache.ttlSeconds !== undefined)
+      headers.set("X-OpenRouter-Cache-TTL", String(options.responseCache.ttlSeconds));
+    if (options.responseCache.clear)
+      headers.set("X-OpenRouter-Cache-Clear", "true");
+  }
+  return headers;
+};
+var SECURITY_SENSITIVE_EXTRA_BODY_FIELDS = new Set([
+  "messages",
+  "model",
+  "models",
+  "plugins",
+  "preset",
+  "provider",
+  "stream",
+  "tools"
+]);
+var assertAllowedPreset = (preset, allowedPresets) => {
+  if (!preset)
+    return;
+  if (allowedPresets?.includes(preset))
+    return;
+  throw new Error(`OpenRouter preset "${preset}" is not allowed`);
+};
+var assertIndirectModels = (value, allowedModels, key = "") => {
+  if (key === "model" && typeof value === "string")
+    assertAllowedModel2(value, allowedModels);
+  if ((key === "models" || key === "analysis_models") && Array.isArray(value)) {
+    for (const model of value) {
+      if (typeof model === "string")
+        assertAllowedModel2(model, allowedModels);
+    }
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      assertIndirectModels(item, allowedModels);
+  } else if (value && typeof value === "object") {
+    for (const [childKey, child] of Object.entries(value))
+      assertIndirectModels(child, allowedModels, childKey);
+  }
+};
+var assertRequestOptions = (options, allowedModels, allowedPresets, allowedProviders) => {
+  assertAllowedPreset(options.preset, allowedPresets);
+  assertRequestRoutingPolicy(options.routing, allowedProviders);
+  if (options.sessionId && options.sessionId.length > 256)
+    throw new Error("OpenRouter sessionId must be at most 256 characters");
+  const ttl = options.responseCache?.ttlSeconds;
+  if (ttl !== undefined && (!Number.isInteger(ttl) || ttl < 1 || ttl > 86400))
+    throw new Error("OpenRouter response-cache TTL must be 1-86400 seconds");
+  if (options.responseCache?.clear && !options.responseCache.enabled)
+    throw new Error("OpenRouter cache clear requires response caching enabled");
+  if (options.fallbackModels) {
+    if (options.fallbackModels.length === 0)
+      throw new Error("OpenRouter fallbackModels must not be empty");
+    for (const model of options.fallbackModels)
+      assertAllowedModel2(model, allowedModels);
+  }
+  assertIndirectModels(options.serverTools, allowedModels);
+  assertIndirectModels(options.messagesTools, allowedModels);
+  assertIndirectModels(options.plugins, allowedModels);
+  if (options.extraBody) {
+    const unsafe = Object.keys(options.extraBody).find((key) => SECURITY_SENSITIVE_EXTRA_BODY_FIELDS.has(key));
+    if (unsafe)
+      throw new Error(`OpenRouter extraBody cannot override "${unsafe}"`);
+  }
+};
+var assertAllowedModel2 = (model, allowedModels) => {
+  if (!allowedModels)
+    return;
+  if (allowedModels.some((rule) => modelMatchesRule(model, rule)))
+    return;
+  throw new Error(`OpenRouter model "${model}" is not allowed`);
+};
+var snapshotPolicy = (config2) => ({
+  allowedModels: config2.allowedModels ? [...config2.allowedModels] : undefined,
+  allowedPresets: config2.allowedPresets ? [...config2.allowedPresets] : undefined
+});
+var transformOpenRouterRequest = (config2, allowedModels, allowedPresets, body, params, skin = "openai") => {
+  const options = requestOptionsFor(params, config2.requestOptions);
+  assertRequestOptions(options, allowedModels, allowedPresets, config2.allowedProviders);
+  const transformed = { ...body, ...options.extraBody };
+  if (options.audioOutput) {
+    transformed.audio = options.audioOutput;
+    transformed.modalities = ["text", "audio"];
+  }
+  if (skin === "openai") {
+    const requestedReasoning = {};
+    if (params.reasoning?.budgetTokens !== undefined) {
+      requestedReasoning.max_tokens = params.reasoning.budgetTokens;
+      delete transformed.reasoning_effort;
+    } else if (params.reasoning?.effort) {
+      requestedReasoning.effort = params.reasoning.effort;
+      delete transformed.reasoning_effort;
+    }
+    if (options.reasoning) {
+      Object.assign(requestedReasoning, options.reasoning);
+      if (options.reasoning.maxTokens !== undefined) {
+        requestedReasoning.max_tokens = options.reasoning.maxTokens;
+        delete requestedReasoning.maxTokens;
+      }
+    }
+    if (Object.keys(requestedReasoning).length > 0)
+      transformed.reasoning = requestedReasoning;
+  }
+  const automaticCacheControl = params.promptCaching === true || params.cacheSystemPrompt === true ? { type: "ephemeral" } : undefined;
+  const cacheControl = options.cacheControl ?? automaticCacheControl;
+  if (cacheControl)
+    transformed.cache_control = cacheControl;
+  if (options.promptCacheKey)
+    transformed.prompt_cache_key = options.promptCacheKey;
+  if (options.promptCacheOptions)
+    transformed.prompt_cache_options = options.promptCacheOptions;
+  const routing = mapRouting({ ...config2.routing, ...options.routing }, config2.allowedProviders);
+  if (Object.keys(routing).length > 0)
+    transformed.provider = routing;
+  if (options.fallbackModels)
+    transformed.models = [...options.fallbackModels];
+  if (options.includeReasoning !== undefined)
+    transformed.include_reasoning = options.includeReasoning;
+  if (options.maxToolCalls !== undefined)
+    transformed.max_tool_calls = options.maxToolCalls;
+  if (options.plugins)
+    transformed.plugins = [...options.plugins];
+  if (options.preset)
+    transformed.preset = options.preset;
+  if (options.serverTools) {
+    transformed.tools = [
+      ...Array.isArray(transformed.tools) ? transformed.tools : [],
+      ...options.serverTools
+    ];
+  }
+  if (options.messagesTools) {
+    if (skin !== "messages")
+      throw new Error("OpenRouter messagesTools requires openrouterMessages()");
+    transformed.tools = [
+      ...Array.isArray(transformed.tools) ? transformed.tools : [],
+      ...options.messagesTools
+    ];
+  }
+  if (options.serviceTier)
+    transformed.service_tier = options.serviceTier;
+  if (options.sessionId)
+    transformed.session_id = options.sessionId;
+  if (options.stopServerToolsWhen)
+    transformed.stop_server_tools_when = options.stopServerToolsWhen;
+  if (options.trace)
+    transformed.trace = options.trace;
+  if (options.transforms)
+    transformed.transforms = [...options.transforms];
+  if (options.user)
+    transformed.user = options.user;
+  if (options.verbosity)
+    transformed.verbosity = options.verbosity;
+  return transformed;
+};
+var withOpenRouterPolicy = (provider, allowedModels, allowedPresets) => ({
+  stream: (params) => {
+    if (params.model.startsWith("@preset/")) {
+      assertAllowedPreset(params.model.slice("@preset/".length), allowedPresets);
+    } else {
+      const presetSeparator = params.model.indexOf("@preset/");
+      if (presetSeparator >= 0) {
+        assertAllowedModel2(params.model.slice(0, presetSeparator), allowedModels);
+        assertAllowedPreset(params.model.slice(presetSeparator + "@preset/".length), allowedPresets);
+      } else {
+        assertAllowedModel2(params.model, allowedModels);
+      }
+    }
+    return provider.stream(params);
+  }
+});
+var openrouter = (config2) => {
+  assertRoutingPolicy(config2);
+  const { allowedModels, allowedPresets } = snapshotPolicy(config2);
+  const provider = openai({
+    apiKey: config2.apiKey,
+    baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL5,
+    fetch: config2.fetch,
+    headers: (params) => resolveAttributionHeaders(config2, params),
+    modelForCapabilities: modelForOpenAICapabilities,
+    providerName: "openrouter",
+    tokenSource: config2.tokenSource,
+    transformRequestBody: (body, params) => transformOpenRouterRequest(config2, allowedModels, allowedPresets, body, params)
+  });
+  return withOpenRouterPolicy(provider, allowedModels, allowedPresets);
+};
+var openrouterResponses = (config2) => {
+  assertRoutingPolicy(config2);
+  const { allowedModels, allowedPresets } = snapshotPolicy(config2);
+  const provider = openaiResponses({
+    apiKey: config2.apiKey,
+    baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL5,
+    fetch: config2.fetch,
+    headers: (params) => resolveAttributionHeaders(config2, params),
+    modelForCapabilities: modelForOpenAICapabilities,
+    providerName: "openrouter",
+    tokenSource: config2.tokenSource,
+    transformRequestBody: (body, params) => transformOpenRouterRequest(config2, allowedModels, allowedPresets, body, params)
+  });
+  return withOpenRouterPolicy(provider, allowedModels, allowedPresets);
+};
+var openrouterMessages = (config2) => {
+  assertRoutingPolicy(config2);
+  const { allowedModels, allowedPresets } = snapshotPolicy(config2);
+  const provider = anthropic({
+    apiKey: config2.apiKey,
+    authStyle: "bearer",
+    baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL5,
+    fetch: config2.fetch,
+    headers: (params) => resolveAttributionHeaders(config2, params),
+    providerName: "openrouter",
+    tokenSource: config2.tokenSource,
+    transformRequestBody: (body, params) => transformOpenRouterRequest(config2, allowedModels, allowedPresets, body, params, "messages")
+  });
+  return withOpenRouterPolicy(provider, allowedModels, allowedPresets);
+};
+export {
+  verifyOpenRouterWebhookSignature,
+  openrouterResponses,
+  openrouterMessages,
+  openrouter,
+  openRouterModelMatchesRule,
+  createOpenRouterClient
+};
+
+//# debugId=29E9DB40EA495C0E64756E2164756E21
+//# sourceMappingURL=openrouter.js.map