@infinityi/engine-lib 1.0.0

package/dist/index-64tt9696.js

@@ -0,0 +1,1796 @@
+import {
+  combine,
+  currentContext,
+  exponentialBackoff,
+  retry,
+  timeout
+} from "./index-bqg01r42.js";
+import {
+  resolveSecret
+} from "./index-xsv43c5j.js";
+import {
+  ProviderError
+} from "./index-7690reng.js";
+// node_modules/@infinityi/forge/dist/index-r6ez01fw.js
+var PROBLEM_CONTENT_TYPE = "application/problem+json";
+var DEFAULT_PROBLEM_TYPE = "about:blank";
+function normalizeProblem(input) {
+  const { type, title, status, detail, instance, ...extensions } = input;
+  const problem = {
+    ...extensions,
+    type: type ?? DEFAULT_PROBLEM_TYPE,
+    title: title ?? statusText(status),
+    status
+  };
+  if (detail !== undefined)
+    problem.detail = detail;
+  if (instance !== undefined)
+    problem.instance = instance;
+  return problem;
+}
+function renderProblem(problem, init) {
+  const normalized = normalizeProblem(problem);
+  const headers = new Headers(init?.headers);
+  headers.set("content-type", PROBLEM_CONTENT_TYPE);
+  return new Response(JSON.stringify(normalized), {
+    status: normalized.status,
+    headers
+  });
+}
+function statusText(status) {
+  return STATUS_TEXT[status] ?? (status >= 500 ? "Internal Server Error" : "Error");
+}
+var STATUS_TEXT = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  409: "Conflict",
+  410: "Gone",
+  413: "Payload Too Large",
+  415: "Unsupported Media Type",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+
+class HttpError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "HttpError";
+  }
+}
+
+class ProblemError extends HttpError {
+  problem;
+  constructor(problem, options) {
+    const normalized = normalizeProblem(problem);
+    super(normalized.detail ?? normalized.title, options);
+    this.name = "ProblemError";
+    this.problem = normalized;
+  }
+  get status() {
+    return this.problem.status;
+  }
+  toResponse() {
+    return renderProblem(this.problem);
+  }
+}
+
+class RequestError extends HttpError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RequestError";
+  }
+}
+
+class ResponseError extends HttpError {
+  status;
+  response;
+  constructor(response, message, options) {
+    super(message ?? `HTTP ${response.status}`, options);
+    this.name = "ResponseError";
+    this.status = response.status;
+    this.response = response;
+  }
+}
+
+class TimeoutError extends HttpError {
+  timeoutMs;
+  constructor(timeoutMs, options) {
+    super(`request timed out after ${timeoutMs}ms`, options);
+    this.name = "TimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+// node_modules/@infinityi/forge/dist/index-6rgawqtq.js
+function formatTraceparent(ctx) {
+  const flags = (ctx.traceFlags & 255).toString(16).padStart(2, "0");
+  return `00-${ctx.traceId}-${ctx.spanId}-${flags}`;
+}
+function formatBaggage(baggage) {
+  const parts = [];
+  for (const [key, value] of Object.entries(baggage)) {
+    parts.push(`${encodeBaggageKey(key)}=${encodeURIComponent(value)}`);
+  }
+  return parts.join(",");
+}
+function encodeBaggageKey(key) {
+  return encodeURIComponent(key);
+}
+
+// node_modules/@infinityi/forge/dist/index-0xay9896.js
+function tracedFetch(options) {
+  const tracer = options.tracer;
+  const inner = options.fetch ?? ((input, init) => fetch(input, init));
+  const buildName = options.spanName ?? ((input, init) => `HTTP ${requestMethod(input, init)}`);
+  const buildExtra = options.attributes;
+  const propagate = options.disablePropagation !== true;
+  return (input, init) => {
+    const method = requestMethod(input, init);
+    const url = requestUrl(input);
+    const attrs = {
+      "http.request.method": method
+    };
+    if (url) {
+      attrs["url.full"] = url;
+      const parsed = safeUrl(url);
+      if (parsed) {
+        attrs["server.address"] = parsed.hostname;
+        if (parsed.port)
+          attrs["server.port"] = Number(parsed.port);
+        attrs["url.scheme"] = parsed.protocol.replace(/:$/, "");
+      }
+    }
+    const extra = buildExtra ? buildExtra(input, init) : undefined;
+    if (extra) {
+      for (const k of Object.keys(extra))
+        attrs[k] = extra[k];
+    }
+    return tracer.withSpan(buildName(input, init), async (span) => {
+      span.setAttributes(attrs);
+      const nextInit = propagate ? injectHeaders(input, init, currentContext()) : init;
+      try {
+        const res = await inner(input, nextInit);
+        span.setAttribute("http.response.status_code", res.status);
+        if (res.status >= 500) {
+          span.setStatus({
+            code: "error",
+            message: `HTTP ${res.status}`
+          });
+        }
+        return res;
+      } catch (err) {
+        const errorType = err instanceof Error && err.name ? err.name : "fetch_error";
+        span.setAttribute("error.type", errorType);
+        throw err;
+      }
+    }, { kind: "client" });
+  };
+}
+function requestMethod(input, init) {
+  if (init && typeof init.method === "string")
+    return init.method.toUpperCase();
+  if (typeof input === "object" && input !== null && "method" in input) {
+    const m = input.method;
+    if (typeof m === "string")
+      return m.toUpperCase();
+  }
+  return "GET";
+}
+function requestUrl(input) {
+  if (typeof input === "string")
+    return input;
+  if (input instanceof URL)
+    return input.toString();
+  if (typeof input === "object" && input !== null && "url" in input) {
+    const u = input.url;
+    if (typeof u === "string")
+      return u;
+  }
+  return;
+}
+function safeUrl(value) {
+  try {
+    return new URL(value);
+  } catch {
+    return;
+  }
+}
+function injectHeaders(input, init, ctx) {
+  if (!ctx)
+    return init;
+  let base;
+  if (init?.headers !== undefined) {
+    base = init.headers;
+  } else if (isRequest(input)) {
+    base = input.headers;
+  }
+  const headers = new Headers(base ?? undefined);
+  headers.set("traceparent", formatTraceparent(ctx));
+  if (ctx.traceState && ctx.traceState.length > 0) {
+    headers.set("tracestate", ctx.traceState);
+  }
+  if (Object.keys(ctx.baggage).length > 0) {
+    headers.set("baggage", formatBaggage(ctx.baggage));
+  }
+  return { ...init ?? {}, headers };
+}
+function isRequest(input) {
+  return typeof Request !== "undefined" && typeof input === "object" && input !== null && input instanceof Request;
+}
+
+// node_modules/@infinityi/forge/dist/index-gw6f6j6v.js
+var jsonCodec = {
+  contentType: "application/json",
+  encode(value) {
+    if (value === undefined || value === null)
+      return;
+    return JSON.stringify(value);
+  },
+  async decode(response) {
+    if (response.status === 204 || response.status === 205) {
+      return;
+    }
+    const text = await response.text();
+    if (text.length === 0)
+      return;
+    return JSON.parse(text);
+  }
+};
+var passthroughFetch = (input, init) => fetch(input, init);
+function createHttpClient(options = {}) {
+  const resolved = resolveOptions(options);
+  const durationHistogram = resolved.telemetry?.meter?.createHistogram("http.client.request.duration", { description: "Duration of outbound HTTP client requests.", unit: "s" });
+  const wrappedFetch = resolved.telemetry?.tracer ? tracedFetch({
+    tracer: resolved.telemetry.tracer,
+    fetch: resolved.fetch
+  }) : resolved.fetch;
+  async function request(req) {
+    const method = (req.method ?? "GET").toUpperCase();
+    const url = buildUrl(resolved, req.url, req.query);
+    const { headers, body } = buildBody(resolved, req, method);
+    const serverAddress = hostOf(url);
+    const timeoutMs = req.timeoutMs ?? resolved.timeoutMs;
+    const deadline = armTimeout(timeoutMs);
+    const startedAt = performance.now();
+    let statusLabel;
+    try {
+      const response = await runFetch(resolved, wrappedFetch, {
+        url,
+        method,
+        headers,
+        body,
+        callerSignal: req.signal,
+        deadline
+      });
+      statusLabel = String(response.status);
+      return await finalize(resolved, response);
+    } catch (error) {
+      statusLabel = errorLabel(error);
+      throw error;
+    } finally {
+      deadline?.clear();
+      durationHistogram?.record((performance.now() - startedAt) / 1000, {
+        "http.request.method": method,
+        "http.response.status_code": statusLabel,
+        "server.address": serverAddress
+      });
+    }
+  }
+  const client = {
+    request,
+    get: (url, init) => request({ method: "GET", url, ...init }),
+    post: (url, body, init) => request({ method: "POST", url, body, ...init }),
+    put: (url, body, init) => request({ method: "PUT", url, body, ...init }),
+    patch: (url, body, init) => request({ method: "PATCH", url, body, ...init }),
+    delete: (url, init) => request({ method: "DELETE", url, ...init }),
+    extend: (overrides) => createHttpClient({ ...options, ...overrides })
+  };
+  return client;
+}
+function resolveOptions(options) {
+  const allowedProtocols = options.allowedProtocols ?? ["http:", "https:"];
+  if (options.baseUrl !== undefined) {
+    let baseUrl;
+    try {
+      baseUrl = new URL(options.baseUrl);
+    } catch (error) {
+      throw new RequestError(`invalid baseUrl: ${options.baseUrl}`, { cause: error });
+    }
+    if (!allowedProtocols.includes(baseUrl.protocol)) {
+      throw new RequestError(`baseUrl protocol ${baseUrl.protocol} is not in allowedProtocols`);
+    }
+  }
+  return {
+    baseUrl: options.baseUrl,
+    allowAbsoluteUrls: options.allowAbsoluteUrls ?? false,
+    allowedProtocols,
+    allowedHosts: options.allowedHosts ?? [],
+    defaultHeaders: options.defaultHeaders ?? {},
+    timeoutMs: options.timeoutMs,
+    resilience: options.resilience,
+    parseProblem: options.parseProblem ?? true,
+    throwOnError: options.throwOnError ?? true,
+    codec: options.codec ?? jsonCodec,
+    fetch: options.fetch ?? passthroughFetch,
+    telemetry: options.telemetry
+  };
+}
+async function runFetch(resolved, doFetch, args) {
+  const attempt = async (pipelineSignal) => {
+    const signal = combineSignals([
+      args.callerSignal,
+      args.deadline?.signal,
+      pipelineSignal
+    ]);
+    try {
+      return await doFetch(args.url, {
+        method: args.method,
+        headers: args.headers,
+        body: args.body,
+        signal
+      });
+    } catch (error) {
+      if (args.deadline?.timedOut) {
+        throw new TimeoutError(args.deadline.timeoutMs, { cause: error });
+      }
+      if (args.callerSignal?.aborted && isAbortError(error))
+        throw error;
+      if (error instanceof HttpError)
+        throw error;
+      throw new RequestError(messageOf(error), { cause: error });
+    }
+  };
+  if (resolved.resilience) {
+    return resolved.resilience.execute((ctx) => attempt(ctx.signal));
+  }
+  return attempt();
+}
+async function finalize(resolved, response) {
+  if (!response.ok) {
+    if (resolved.parseProblem && isProblemResponse(response)) {
+      throw await parseProblem(response);
+    }
+    if (resolved.throwOnError) {
+      throw new ResponseError(response);
+    }
+  }
+  const body = await resolved.codec.decode(response);
+  return { status: response.status, headers: response.headers, body, raw: response };
+}
+function buildBody(resolved, req, method) {
+  const headers = new Headers(resolved.defaultHeaders);
+  if (req.headers) {
+    const provided = new Headers(req.headers);
+    provided.forEach((value, key) => headers.set(key, value));
+  }
+  if (req.body === undefined || method === "GET" || method === "HEAD") {
+    return { headers, body: undefined };
+  }
+  if (isRawBody(req.body)) {
+    return { headers, body: req.body };
+  }
+  const encoded = resolved.codec.encode(req.body);
+  if (encoded !== undefined && !headers.has("content-type")) {
+    headers.set("content-type", resolved.codec.contentType);
+  }
+  return { headers, body: encoded };
+}
+function buildUrl(resolved, url, query) {
+  const { baseUrl } = resolved;
+  let resolvedUrl;
+  try {
+    resolvedUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
+  } catch (error) {
+    throw new RequestError(`invalid request url: ${url}`, { cause: error });
+  }
+  enforceUrlPolicy(resolved, resolvedUrl);
+  if (query) {
+    const params = query instanceof URLSearchParams ? query : toSearchParams(query);
+    params.forEach((value, key) => resolvedUrl.searchParams.append(key, value));
+  }
+  return resolvedUrl.toString();
+}
+function enforceUrlPolicy(resolved, url) {
+  if (!resolved.allowedProtocols.includes(url.protocol)) {
+    throw new RequestError(`unsupported request url protocol: ${url.protocol}`);
+  }
+  if (!resolved.baseUrl || resolved.allowAbsoluteUrls)
+    return;
+  const base = new URL(resolved.baseUrl);
+  if (url.origin !== base.origin && !resolved.allowedHosts.includes(url.hostname)) {
+    throw new RequestError(`request url must stay within baseUrl origin (${base.origin}): ${url.origin}`);
+  }
+}
+function toSearchParams(query) {
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined)
+      params.set(key, String(value));
+  }
+  return params;
+}
+function armTimeout(timeoutMs) {
+  if (timeoutMs === undefined)
+    return;
+  const controller = new AbortController;
+  const deadline = {
+    signal: controller.signal,
+    timeoutMs,
+    timedOut: false,
+    clear() {
+      clearTimeout(timer);
+    }
+  };
+  const timer = setTimeout(() => {
+    deadline.timedOut = true;
+    controller.abort(new TimeoutError(timeoutMs));
+  }, timeoutMs);
+  return deadline;
+}
+function combineSignals(signals) {
+  const present = signals.filter((s) => s !== undefined);
+  if (present.length === 0)
+    return;
+  if (present.length === 1)
+    return present[0];
+  return AbortSignal.any(present);
+}
+async function parseProblem(response) {
+  try {
+    const data = await response.json();
+    return new ProblemError({ ...data, status: data.status ?? response.status });
+  } catch (error) {
+    return new ProblemError({ status: response.status, detail: "malformed problem body" }, { cause: error });
+  }
+}
+function isProblemResponse(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  return contentType.toLowerCase().includes(PROBLEM_CONTENT_TYPE);
+}
+function isRawBody(body) {
+  return typeof body === "string" || body instanceof ArrayBuffer || body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams || body instanceof ReadableStream || ArrayBuffer.isView(body);
+}
+function hostOf(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+function isAbortError(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+function messageOf(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+function errorLabel(error) {
+  if (error instanceof ResponseError)
+    return String(error.status);
+  if (error instanceof ProblemError)
+    return String(error.status);
+  return "error";
+}
+
+// src/providers/http.ts
+var DEFAULT_TIMEOUT_MS = 60000;
+function statusOf(error) {
+  if (typeof error === "object" && error !== null && "status" in error) {
+    const status = error.status;
+    if (typeof status === "number")
+      return status;
+  }
+  return;
+}
+function messageOf2(error) {
+  if (error instanceof Error)
+    return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string")
+      return message;
+  }
+  return String(error);
+}
+function isTransient(error) {
+  if (error instanceof DOMException && error.name === "AbortError")
+    return false;
+  const status = statusOf(error);
+  if (status === undefined)
+    return true;
+  return status === 429 || status >= 500;
+}
+function defaultProviderResilience(timeoutMs) {
+  return combine(retry({
+    maxAttempts: 3,
+    backoff: exponentialBackoff({ initial: 250, max: 1e4 }),
+    shouldRetry: isTransient
+  }), timeout({ ms: timeoutMs }));
+}
+function createProviderHttp(opts, ctx) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const telemetry = ctx?.telemetry;
+  return createHttpClient({
+    baseUrl: opts.baseUrl.endsWith("/") ? opts.baseUrl : `${opts.baseUrl}/`,
+    defaultHeaders: opts.headers,
+    timeoutMs: opts.resilience === undefined ? undefined : timeoutMs,
+    resilience: opts.resilience ?? defaultProviderResilience(timeoutMs),
+    telemetry: telemetry ? { meter: telemetry.meter, tracer: telemetry.tracer } : undefined,
+    logger: ctx?.logger ?? telemetry?.log,
+    fetch: opts.fetch,
+    allowAbsoluteUrls: opts.allowAbsoluteUrls,
+    throwOnError: true
+  });
+}
+function joinUrl(baseUrl, path) {
+  if (/^https?:\/\//.test(path))
+    return path;
+  return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function hostOf2(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+function combineSignals2(...signals) {
+  const present = signals.filter((s) => s !== undefined);
+  if (present.length === 0)
+    return;
+  if (present.length === 1)
+    return present[0];
+  return AbortSignal.any(present);
+}
+async function openSseStream(provider, opts, req, ctx) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const pipeline = opts.resilience ?? defaultProviderResilience(timeoutMs);
+  const telemetry = ctx?.telemetry;
+  const baseFetch = opts.fetch ?? ((input, init) => fetch(input, init));
+  const fetchImpl = telemetry?.tracer ? tracedFetch({ tracer: telemetry.tracer, fetch: baseFetch }) : baseFetch;
+  const durationHistogram = telemetry?.meter?.createHistogram("http.client.request.duration", { description: "Duration of outbound HTTP client requests.", unit: "s" });
+  const url = joinUrl(opts.baseUrl, req.path);
+  const serverAddress = hostOf2(url);
+  const headers = {
+    "content-type": "application/json",
+    accept: "text/event-stream",
+    ...opts.headers
+  };
+  const startedAt = performance.now();
+  let statusLabel;
+  try {
+    const response = await pipeline.execute(async (pctx) => {
+      const response2 = await fetchImpl(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(req.body),
+        signal: combineSignals2(pctx.signal, req.signal, ctx?.signal)
+      });
+      statusLabel = String(response2.status);
+      if (!response2.ok) {
+        const detail = await response2.text().catch(() => "");
+        throw Object.assign(new Error(detail || response2.statusText), {
+          status: response2.status
+        });
+      }
+      return response2;
+    });
+    if (response.body === null) {
+      throw new ProviderError(`${provider} streaming response had no body`, {
+        provider
+      });
+    }
+    return response.body;
+  } catch (error) {
+    statusLabel ??= statusOf(error)?.toString() ?? "error";
+    throw toProviderError(provider, error);
+  } finally {
+    const attributes = {
+      "http.request.method": "POST",
+      "server.address": serverAddress
+    };
+    if (statusLabel !== undefined) {
+      attributes["http.response.status_code"] = statusLabel;
+    }
+    durationHistogram?.record((performance.now() - startedAt) / 1000, attributes);
+  }
+}
+function toProviderError(provider, error) {
+  if (error instanceof ProviderError)
+    return error;
+  const status = statusOf(error);
+  const detail = messageOf2(error);
+  const message = status !== undefined ? `${provider} request failed (HTTP ${status}): ${detail}` : `${provider} request failed: ${detail}`;
+  return new ProviderError(message, { provider, cause: error });
+}
+// src/providers/sse.ts
+async function* parseSse(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let event;
+  let data = [];
+  let completed = false;
+  const flush = () => {
+    if (data.length === 0 && event === undefined)
+      return;
+    const message = event !== undefined ? { event, data: data.join(`
+`) } : { data: data.join(`
+`) };
+    event = undefined;
+    data = [];
+    return message;
+  };
+  const consumeLine = (line) => {
+    if (line === "")
+      return flush();
+    if (line.startsWith(":"))
+      return;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let rest = colon === -1 ? "" : line.slice(colon + 1);
+    if (rest.startsWith(" "))
+      rest = rest.slice(1);
+    if (field === "event")
+      event = rest;
+    else if (field === "data")
+      data.push(rest);
+    return;
+  };
+  function* drainLines() {
+    let newlineIndex;
+    while ((newlineIndex = buffer.indexOf(`
+`)) !== -1) {
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      const message = consumeLine(line);
+      if (message !== undefined)
+        yield message;
+    }
+  }
+  try {
+    while (true) {
+      if (signal?.aborted)
+        return;
+      const { done, value } = await reader.read();
+      if (done) {
+        completed = true;
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const trailingCr = buffer.endsWith("\r");
+      const head = trailingCr ? buffer.slice(0, -1) : buffer;
+      buffer = head.replace(/\r\n?/g, `
+`) + (trailingCr ? "\r" : "");
+      yield* drainLines();
+    }
+    buffer += decoder.decode();
+    buffer = buffer.replace(/\r\n?/g, `
+`);
+    yield* drainLines();
+    if (buffer.length > 0) {
+      const message = consumeLine(buffer);
+      if (message !== undefined)
+        yield message;
+      buffer = "";
+    }
+    const tail = flush();
+    if (tail !== undefined)
+      yield tail;
+  } finally {
+    if (!completed)
+      await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
+// src/providers/adapter.ts
+function createProvider(spec) {
+  return {
+    name: spec.name,
+    defaultModel: spec.defaultModel,
+    capabilities: spec.capabilities,
+    async complete(req, ctx) {
+      const model = req.model ?? spec.defaultModel;
+      const http = createProviderHttp(spec.http, ctx);
+      const body = spec.buildBody(req, model, false);
+      try {
+        const res = await http.post(spec.completePath(model, req), body, {
+          signal: ctx?.signal
+        });
+        return spec.parseResponse(res.body, model);
+      } catch (error) {
+        throw toProviderError(spec.name, error);
+      }
+    },
+    async* stream(req, ctx) {
+      const model = req.model ?? spec.defaultModel;
+      const body = spec.buildBody(req, model, true);
+      const stream = await openSseStream(spec.name, spec.http, { path: spec.streamPath(model, req), body, signal: ctx?.signal }, ctx);
+      try {
+        yield* spec.translateStream(parseSse(stream, ctx?.signal), model);
+      } catch (error) {
+        throw toProviderError(spec.name, error);
+      }
+    }
+  };
+}
+// src/providers/shared.ts
+function imageDataUrl(part) {
+  return /^https?:\/\//.test(part.data) ? part.data : `data:${part.mimeType};base64,${part.data}`;
+}
+function systemText(messages) {
+  const parts = [];
+  for (const message of messages) {
+    if (message.role !== "system")
+      continue;
+    for (const part of message.content) {
+      if (part.type === "text")
+        parts.push(part.text);
+    }
+  }
+  return parts.length > 0 ? parts.join(`
+`) : undefined;
+}
+function withoutSystem(messages) {
+  return messages.filter((m) => m.role !== "system");
+}
+function toolResultText(part) {
+  return part.content.map((p) => p.text).join("");
+}
+var isText = (p) => p.type === "text";
+var isToolCall = (p) => p.type === "tool_call";
+var isToolResult = (p) => p.type === "tool_result";
+function stringifyArguments(value) {
+  if (typeof value === "string")
+    return value;
+  if (value === undefined)
+    return "{}";
+  return JSON.stringify(value);
+}
+
+// src/providers/openai/map.ts
+function toInputContent(part) {
+  if (part.type === "text")
+    return { type: "input_text", text: part.text };
+  if (part.type === "image") {
+    return { type: "input_image", image_url: imageDataUrl(part), detail: "auto" };
+  }
+  return;
+}
+function toInputItems(messages) {
+  const items = [];
+  for (const message of messages) {
+    if (message.role === "tool") {
+      for (const part of message.content) {
+        if (isToolResult(part)) {
+          items.push({
+            type: "function_call_output",
+            call_id: part.toolCallId,
+            output: part.content.map((p) => p.text).join("")
+          });
+        }
+      }
+      continue;
+    }
+    if (message.role === "assistant") {
+      const textParts = message.content.filter(isText).map((p) => p.text).join("");
+      if (textParts !== "")
+        items.push({ role: "assistant", content: textParts });
+      for (const part of message.content) {
+        if (isToolCall(part)) {
+          items.push({
+            type: "function_call",
+            call_id: part.id,
+            name: part.name,
+            arguments: stringifyArguments(part.arguments)
+          });
+        }
+      }
+      continue;
+    }
+    const content = message.content.map(toInputContent).filter((c) => c !== undefined);
+    items.push({ role: "user", content });
+  }
+  return items;
+}
+function toToolChoice(choice) {
+  if (typeof choice === "string")
+    return choice;
+  return { type: "function", name: choice.name };
+}
+function buildOpenAIBody(req, model, stream) {
+  const system = systemText(req.messages);
+  const body = {
+    model,
+    input: toInputItems(withoutSystem(req.messages)),
+    stream
+  };
+  if (system !== undefined)
+    body["instructions"] = system;
+  if (req.tools && req.tools.length > 0) {
+    body["tools"] = req.tools.map((t) => ({
+      type: "function",
+      name: t.name,
+      ...t.description !== undefined ? { description: t.description } : {},
+      parameters: t.parameters,
+      strict: true
+    }));
+  }
+  if (req.toolChoice !== undefined)
+    body["tool_choice"] = toToolChoice(req.toolChoice);
+  if (req.responseSchema !== undefined) {
+    body["text"] = {
+      format: {
+        type: "json_schema",
+        name: req.responseSchema.name,
+        schema: req.responseSchema.schema,
+        strict: req.responseSchema.strict ?? true
+      }
+    };
+  }
+  if (req.maxOutputTokens !== undefined)
+    body["max_output_tokens"] = req.maxOutputTokens;
+  if (req.temperature !== undefined)
+    body["temperature"] = req.temperature;
+  if (req.topP !== undefined)
+    body["top_p"] = req.topP;
+  if (req.metadata !== undefined)
+    body["metadata"] = req.metadata;
+  if (req.providerOptions !== undefined)
+    Object.assign(body, req.providerOptions);
+  return body;
+}
+function toFinishReason(response, hadToolCalls, hadRefusal) {
+  if (response.status === "failed")
+    return "error";
+  if (hadRefusal)
+    return "content_filter";
+  if (response.status === "incomplete") {
+    return response.incomplete_details?.reason === "content_filter" ? "content_filter" : "length";
+  }
+  if (hadToolCalls)
+    return "tool_calls";
+  return "stop";
+}
+function parseOpenAIResponse(raw, model) {
+  const response = raw ?? {};
+  let text = "";
+  let hadRefusal = false;
+  const toolCalls = [];
+  for (const item of response.output ?? []) {
+    if (item.type === "message") {
+      for (const part of item.content ?? []) {
+        if (part.type === "output_text" && part.text !== undefined)
+          text += part.text;
+        else if (part.type === "refusal")
+          hadRefusal = true;
+      }
+    } else if (item.type === "function_call") {
+      const argumentsText = item.arguments ?? "";
+      toolCalls.push({
+        id: item.call_id ?? item.id ?? "",
+        name: item.name ?? "",
+        arguments: parseArguments(argumentsText),
+        argumentsText
+      });
+    }
+  }
+  const content = [];
+  if (text !== "")
+    content.push({ type: "text", text });
+  for (const call of toolCalls) {
+    content.push({ type: "tool_call", id: call.id, name: call.name, arguments: call.arguments });
+  }
+  const usage = response.usage ? {
+    inputTokens: response.usage.input_tokens ?? 0,
+    outputTokens: response.usage.output_tokens ?? 0,
+    totalTokens: response.usage.total_tokens ?? (response.usage.input_tokens ?? 0) + (response.usage.output_tokens ?? 0),
+    ...response.usage.output_tokens_details?.reasoning_tokens !== undefined ? { reasoningTokens: response.usage.output_tokens_details.reasoning_tokens } : {},
+    ...response.usage.input_tokens_details?.cached_tokens !== undefined ? { cachedInputTokens: response.usage.input_tokens_details.cached_tokens } : {}
+  } : undefined;
+  return {
+    message: { role: "assistant", content },
+    toolCalls,
+    finishReason: toFinishReason(response, toolCalls.length > 0, hadRefusal),
+    ...usage !== undefined ? { usage } : {},
+    model: response.model ?? model,
+    raw
+  };
+}
+function parseArguments(text) {
+  if (text.trim() === "")
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+
+// src/providers/openai/stream.ts
+async function* translateOpenAIStream(messages, model) {
+  let nextIndex = 0;
+  const indexByItem = new Map;
+  let started = false;
+  let hadToolCalls = false;
+  let finished = false;
+  const fallbackFinishReason = () => hadToolCalls ? "tool_calls" : "stop";
+  for await (const message of messages) {
+    if (message.data === "" || message.data === "[DONE]")
+      continue;
+    let event;
+    try {
+      event = JSON.parse(message.data);
+    } catch {
+      continue;
+    }
+    switch (event.type) {
+      case "response.created":
+        if (!started) {
+          started = true;
+          yield { type: "message_start", model };
+        }
+        break;
+      case "response.output_item.added":
+        if (event.item?.type === "function_call") {
+          const index = nextIndex++;
+          hadToolCalls = true;
+          if (event.item.id !== undefined)
+            indexByItem.set(event.item.id, index);
+          yield {
+            type: "tool_call_start",
+            index,
+            id: event.item.call_id ?? event.item.id ?? "",
+            name: event.item.name ?? ""
+          };
+        }
+        break;
+      case "response.output_text.delta":
+        if (event.delta !== undefined)
+          yield { type: "text_delta", text: event.delta };
+        break;
+      case "response.function_call_arguments.delta": {
+        const index = event.item_id !== undefined ? indexByItem.get(event.item_id) : undefined;
+        if (index !== undefined && event.delta !== undefined) {
+          yield {
+            type: "tool_call_delta",
+            index,
+            argumentsTextDelta: event.delta
+          };
+        }
+        break;
+      }
+      case "response.function_call_arguments.done": {
+        const index = event.item_id !== undefined ? indexByItem.get(event.item_id) : undefined;
+        if (index !== undefined)
+          yield { type: "tool_call_end", index };
+        break;
+      }
+      case "response.completed":
+      case "response.incomplete":
+      case "response.failed": {
+        finished = true;
+        const result = parseOpenAIResponse(event.response, model);
+        yield {
+          type: "finish",
+          finishReason: result.finishReason,
+          ...result.usage !== undefined ? { usage: result.usage } : {}
+        };
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (!finished) {
+    yield { type: "finish", finishReason: fallbackFinishReason() };
+  }
+}
+
+// src/providers/openai/index.ts
+var CAPABILITIES = {
+  tools: true,
+  streaming: true,
+  multimodalInput: true,
+  parallelToolCalls: true,
+  structuredOutput: true
+};
+function createOpenAI(opts) {
+  const apiKey = resolveSecret(opts.apiKey);
+  return createProvider({
+    name: "openai",
+    defaultModel: opts.model ?? "gpt-5",
+    capabilities: CAPABILITIES,
+    http: {
+      baseUrl: opts.baseUrl ?? "https://api.openai.com/v1",
+      headers: {
+        ...opts.defaultHeaders,
+        authorization: `Bearer ${apiKey}`
+      },
+      ...opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {},
+      ...opts.resilience !== undefined ? { resilience: opts.resilience } : {},
+      ...opts.fetch !== undefined ? { fetch: opts.fetch } : {}
+    },
+    completePath: () => "responses",
+    streamPath: () => "responses",
+    buildBody: buildOpenAIBody,
+    parseResponse: parseOpenAIResponse,
+    translateStream: translateOpenAIStream
+  });
+}
+// src/providers/anthropic/map.ts
+var DEFAULT_MAX_TOKENS = 4096;
+function toImageBlock(part) {
+  const isUrl = /^https?:\/\//.test(part.data);
+  return {
+    type: "image",
+    source: isUrl ? { type: "url", url: part.data } : { type: "base64", media_type: part.mimeType, data: part.data }
+  };
+}
+function toAnthropicMessages(messages) {
+  const out = [];
+  const pushUserBlocks = (blocks) => {
+    const last = out[out.length - 1];
+    if (last && last.role === "user")
+      last.content.push(...blocks);
+    else
+      out.push({ role: "user", content: blocks });
+  };
+  for (const message of messages) {
+    if (message.role === "tool") {
+      const blocks2 = message.content.filter(isToolResult).map((part) => ({
+        type: "tool_result",
+        tool_use_id: part.toolCallId,
+        content: toolResultText(part),
+        ...part.isError !== undefined ? { is_error: part.isError } : {}
+      }));
+      pushUserBlocks(blocks2);
+      continue;
+    }
+    if (message.role === "assistant") {
+      const blocks2 = [];
+      for (const part of message.content) {
+        if (isText(part))
+          blocks2.push({ type: "text", text: part.text });
+        else if (isToolCall(part)) {
+          blocks2.push({ type: "tool_use", id: part.id, name: part.name, input: part.arguments ?? {} });
+        }
+      }
+      out.push({ role: "assistant", content: blocks2 });
+      continue;
+    }
+    const blocks = [];
+    for (const part of message.content) {
+      if (isText(part))
+        blocks.push({ type: "text", text: part.text });
+      else if (part.type === "image")
+        blocks.push(toImageBlock(part));
+    }
+    pushUserBlocks(blocks);
+  }
+  return out;
+}
+function toToolChoice2(choice) {
+  if (choice === "auto")
+    return { type: "auto" };
+  if (choice === "none")
+    return { type: "none" };
+  if (choice === "required")
+    return { type: "any" };
+  return { type: "tool", name: choice.name };
+}
+function buildAnthropicBody(req, model, stream) {
+  const system = systemText(req.messages);
+  const body = {
+    model,
+    max_tokens: req.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
+    messages: toAnthropicMessages(withoutSystem(req.messages)),
+    stream
+  };
+  if (system !== undefined)
+    body["system"] = system;
+  if (req.tools && req.tools.length > 0) {
+    body["tools"] = req.tools.map((t) => ({
+      name: t.name,
+      ...t.description !== undefined ? { description: t.description } : {},
+      input_schema: t.parameters,
+      strict: true
+    }));
+  }
+  if (req.toolChoice !== undefined)
+    body["tool_choice"] = toToolChoice2(req.toolChoice);
+  if (req.responseSchema !== undefined) {
+    body["output_config"] = {
+      format: { type: "json_schema", schema: req.responseSchema.schema }
+    };
+  }
+  if (req.temperature !== undefined)
+    body["temperature"] = req.temperature;
+  if (req.topP !== undefined)
+    body["top_p"] = req.topP;
+  if (req.stopSequences !== undefined)
+    body["stop_sequences"] = req.stopSequences;
+  if (req.metadata?.["userId"] !== undefined)
+    body["metadata"] = { user_id: req.metadata["userId"] };
+  if (req.providerOptions !== undefined)
+    Object.assign(body, req.providerOptions);
+  return body;
+}
+function mapStopReason(stopReason, hadToolCalls) {
+  switch (stopReason) {
+    case "end_turn":
+    case "stop_sequence":
+      return hadToolCalls ? "tool_calls" : "stop";
+    case "tool_use":
+      return "tool_calls";
+    case "max_tokens":
+      return "length";
+    case "refusal":
+      return "content_filter";
+    default:
+      return hadToolCalls ? "tool_calls" : "other";
+  }
+}
+function parseAnthropicResponse(raw, model) {
+  const response = raw ?? {};
+  let text = "";
+  const toolCalls = [];
+  for (const block of response.content ?? []) {
+    if (block.type === "text" && block.text !== undefined)
+      text += block.text;
+    else if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id ?? "",
+        name: block.name ?? "",
+        arguments: block.input,
+        argumentsText: JSON.stringify(block.input ?? {})
+      });
+    }
+  }
+  const content = [];
+  if (text !== "")
+    content.push({ type: "text", text });
+  for (const call of toolCalls) {
+    content.push({ type: "tool_call", id: call.id, name: call.name, arguments: call.arguments });
+  }
+  const usage = response.usage ? {
+    inputTokens: response.usage.input_tokens ?? 0,
+    outputTokens: response.usage.output_tokens ?? 0,
+    totalTokens: (response.usage.input_tokens ?? 0) + (response.usage.output_tokens ?? 0),
+    ...response.usage.cache_read_input_tokens !== undefined ? { cachedInputTokens: response.usage.cache_read_input_tokens } : {}
+  } : undefined;
+  return {
+    message: { role: "assistant", content },
+    toolCalls,
+    finishReason: mapStopReason(response.stop_reason, toolCalls.length > 0),
+    ...usage !== undefined ? { usage } : {},
+    model: response.model ?? model,
+    raw
+  };
+}
+
+// src/providers/anthropic/stream.ts
+async function* translateAnthropicStream(messages, model) {
+  const toolIndexes = new Set;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let stopReason;
+  let hadToolCalls = false;
+  let sawUsage = false;
+  let finished = false;
+  const finishEvent = (includeUsage = sawUsage) => {
+    const usage = includeUsage ? {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens
+    } : undefined;
+    return {
+      type: "finish",
+      finishReason: mapStopReason(stopReason, hadToolCalls),
+      ...usage !== undefined ? { usage } : {}
+    };
+  };
+  for await (const message of messages) {
+    if (message.data === "")
+      continue;
+    let event;
+    try {
+      event = JSON.parse(message.data);
+    } catch {
+      continue;
+    }
+    switch (event.type) {
+      case "message_start":
+        if (event.message?.usage?.input_tokens !== undefined) {
+          inputTokens = event.message.usage.input_tokens;
+          sawUsage = true;
+        }
+        yield { type: "message_start", model: event.message?.model ?? model };
+        break;
+      case "content_block_start":
+        if (event.content_block?.type === "tool_use" && event.index !== undefined) {
+          toolIndexes.add(event.index);
+          hadToolCalls = true;
+          yield {
+            type: "tool_call_start",
+            index: event.index,
+            id: event.content_block.id ?? "",
+            name: event.content_block.name ?? ""
+          };
+        }
+        break;
+      case "content_block_delta":
+        if (event.delta?.type === "text_delta" && event.delta.text !== undefined) {
+          yield { type: "text_delta", text: event.delta.text };
+        } else if (event.delta?.type === "input_json_delta" && event.index !== undefined && event.delta.partial_json !== undefined) {
+          yield {
+            type: "tool_call_delta",
+            index: event.index,
+            argumentsTextDelta: event.delta.partial_json
+          };
+        }
+        break;
+      case "content_block_stop":
+        if (event.index !== undefined && toolIndexes.has(event.index)) {
+          yield { type: "tool_call_end", index: event.index };
+        }
+        break;
+      case "message_delta":
+        if (event.delta?.stop_reason !== undefined)
+          stopReason = event.delta.stop_reason;
+        if (event.usage?.output_tokens !== undefined) {
+          outputTokens = event.usage.output_tokens;
+          sawUsage = true;
+        }
+        break;
+      case "message_stop":
+        finished = true;
+        yield finishEvent(true);
+        break;
+      default:
+        break;
+    }
+  }
+  if (!finished)
+    yield finishEvent();
+}
+
+// src/providers/anthropic/index.ts
+var DEFAULT_VERSION = "2023-06-01";
+var CAPABILITIES2 = {
+  tools: true,
+  streaming: true,
+  multimodalInput: true,
+  parallelToolCalls: true,
+  structuredOutput: true
+};
+function createAnthropic(opts) {
+  const apiKey = resolveSecret(opts.apiKey);
+  return createProvider({
+    name: "anthropic",
+    defaultModel: opts.model ?? "claude-opus-4-7",
+    capabilities: CAPABILITIES2,
+    http: {
+      baseUrl: opts.baseUrl ?? "https://api.anthropic.com/v1",
+      headers: {
+        ...opts.defaultHeaders,
+        "x-api-key": apiKey,
+        "anthropic-version": opts.version ?? DEFAULT_VERSION
+      },
+      ...opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {},
+      ...opts.resilience !== undefined ? { resilience: opts.resilience } : {},
+      ...opts.fetch !== undefined ? { fetch: opts.fetch } : {}
+    },
+    completePath: () => "messages",
+    streamPath: () => "messages",
+    buildBody: buildAnthropicBody,
+    parseResponse: parseAnthropicResponse,
+    translateStream: translateAnthropicStream
+  });
+}
+// src/providers/google/map.ts
+function toGeminiImage(part) {
+  const isUrl = /^https?:\/\//.test(part.data);
+  return isUrl ? { fileData: { mimeType: part.mimeType, fileUri: part.data } } : { inlineData: { mimeType: part.mimeType, data: part.data } };
+}
+function toolNameById(messages) {
+  const names = new Map;
+  for (const message of messages) {
+    if (message.role !== "assistant")
+      continue;
+    for (const part of message.content) {
+      if (isToolCall(part))
+        names.set(part.id, part.name);
+    }
+  }
+  return names;
+}
+function toContents(messages) {
+  const toolNames = toolNameById(messages);
+  const contents = [];
+  for (const message of messages) {
+    if (message.role === "tool") {
+      const parts2 = message.content.filter(isToolResult).map((part) => ({
+        functionResponse: {
+          id: part.toolCallId,
+          name: toolNames.get(part.toolCallId) ?? part.toolCallId,
+          response: { result: toolResultText(part) }
+        }
+      }));
+      contents.push({ role: "user", parts: parts2 });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const parts2 = [];
+      for (const part of message.content) {
+        if (isText(part))
+          parts2.push({ text: part.text });
+        else if (isToolCall(part)) {
+          parts2.push({ functionCall: { id: part.id, name: part.name, args: part.arguments ?? {} } });
+        }
+      }
+      contents.push({ role: "model", parts: parts2 });
+      continue;
+    }
+    const parts = [];
+    for (const part of message.content) {
+      if (isText(part))
+        parts.push({ text: part.text });
+      else if (part.type === "image")
+        parts.push(toGeminiImage(part));
+    }
+    contents.push({ role: "user", parts });
+  }
+  return contents;
+}
+function toToolConfig(choice) {
+  if (typeof choice === "object") {
+    return { functionCallingConfig: { mode: "ANY", allowedFunctionNames: [choice.name] } };
+  }
+  const mode = choice === "none" ? "NONE" : choice === "required" ? "ANY" : "AUTO";
+  return { functionCallingConfig: { mode } };
+}
+function buildGoogleBody(req, _model, _stream) {
+  const system = systemText(req.messages);
+  const body = {
+    contents: toContents(withoutSystem(req.messages))
+  };
+  if (system !== undefined)
+    body["systemInstruction"] = { parts: [{ text: system }] };
+  if (req.tools && req.tools.length > 0) {
+    body["tools"] = [
+      {
+        functionDeclarations: req.tools.map((t) => ({
+          name: t.name,
+          ...t.description !== undefined ? { description: t.description } : {},
+          parameters: t.parameters
+        }))
+      }
+    ];
+  }
+  if (req.toolChoice !== undefined)
+    body["toolConfig"] = toToolConfig(req.toolChoice);
+  const generationConfig = {};
+  if (req.temperature !== undefined)
+    generationConfig["temperature"] = req.temperature;
+  if (req.topP !== undefined)
+    generationConfig["topP"] = req.topP;
+  if (req.maxOutputTokens !== undefined)
+    generationConfig["maxOutputTokens"] = req.maxOutputTokens;
+  if (req.stopSequences !== undefined)
+    generationConfig["stopSequences"] = req.stopSequences;
+  if (req.responseSchema !== undefined) {
+    generationConfig["responseMimeType"] = "application/json";
+    generationConfig["responseSchema"] = req.responseSchema.schema;
+  }
+  if (Object.keys(generationConfig).length > 0)
+    body["generationConfig"] = generationConfig;
+  if (req.providerOptions !== undefined)
+    Object.assign(body, req.providerOptions);
+  return body;
+}
+function mapGoogleFinish(reason, hadToolCalls) {
+  if (hadToolCalls && (reason === undefined || reason === "STOP"))
+    return "tool_calls";
+  switch (reason) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+    case "PROHIBITED_CONTENT":
+    case "BLOCKLIST":
+    case "SPII":
+    case "IMAGE_SAFETY":
+    case "IMAGE_PROHIBITED_CONTENT":
+      return "content_filter";
+    case undefined:
+      return "stop";
+    default:
+      return "other";
+  }
+}
+function parseGoogleResponse(raw, model) {
+  const response = raw ?? {};
+  const candidate = response.candidates?.[0];
+  let text = "";
+  const toolCalls = [];
+  let index = 0;
+  for (const part of candidate?.content?.parts ?? []) {
+    if (part.text !== undefined)
+      text += part.text;
+    else if (part.functionCall !== undefined) {
+      const name = part.functionCall.name ?? "";
+      toolCalls.push({
+        id: part.functionCall.id ?? `call_${name}_${index}`,
+        name,
+        arguments: part.functionCall.args,
+        argumentsText: JSON.stringify(part.functionCall.args ?? {})
+      });
+      index += 1;
+    }
+  }
+  const content = [];
+  if (text !== "")
+    content.push({ type: "text", text });
+  for (const call of toolCalls) {
+    content.push({ type: "tool_call", id: call.id, name: call.name, arguments: call.arguments });
+  }
+  const meta = response.usageMetadata;
+  const usage = meta ? {
+    inputTokens: meta.promptTokenCount ?? 0,
+    outputTokens: meta.candidatesTokenCount ?? 0,
+    totalTokens: meta.totalTokenCount ?? (meta.promptTokenCount ?? 0) + (meta.candidatesTokenCount ?? 0),
+    ...meta.thoughtsTokenCount !== undefined ? { reasoningTokens: meta.thoughtsTokenCount } : {},
+    ...meta.cachedContentTokenCount !== undefined ? { cachedInputTokens: meta.cachedContentTokenCount } : {}
+  } : undefined;
+  return {
+    message: { role: "assistant", content },
+    toolCalls,
+    finishReason: mapGoogleFinish(candidate?.finishReason, toolCalls.length > 0),
+    ...usage !== undefined ? { usage } : {},
+    model: response.modelVersion ?? model,
+    raw
+  };
+}
+
+// src/providers/google/stream.ts
+async function* translateGoogleStream(messages, model) {
+  let started = false;
+  let toolIndex = 0;
+  let hadToolCalls = false;
+  let finishReason;
+  let usage;
+  for await (const message of messages) {
+    if (message.data === "")
+      continue;
+    let chunk;
+    try {
+      chunk = JSON.parse(message.data);
+    } catch {
+      continue;
+    }
+    if (!started) {
+      started = true;
+      yield { type: "message_start", model };
+    }
+    const candidate = chunk.candidates?.[0];
+    for (const part of candidate?.content?.parts ?? []) {
+      if (part.text !== undefined) {
+        yield { type: "text_delta", text: part.text };
+      } else if (part.functionCall !== undefined) {
+        const index = toolIndex++;
+        hadToolCalls = true;
+        const name = part.functionCall.name ?? "";
+        yield { type: "tool_call_start", index, id: part.functionCall.id ?? `call_${name}_${index}`, name };
+        yield {
+          type: "tool_call_delta",
+          index,
+          argumentsTextDelta: JSON.stringify(part.functionCall.args ?? {})
+        };
+        yield { type: "tool_call_end", index };
+      }
+    }
+    if (candidate?.finishReason !== undefined)
+      finishReason = candidate.finishReason;
+    if (chunk.usageMetadata) {
+      const meta = chunk.usageMetadata;
+      usage = {
+        inputTokens: meta.promptTokenCount ?? 0,
+        outputTokens: meta.candidatesTokenCount ?? 0,
+        totalTokens: meta.totalTokenCount ?? (meta.promptTokenCount ?? 0) + (meta.candidatesTokenCount ?? 0),
+        ...meta.thoughtsTokenCount !== undefined ? { reasoningTokens: meta.thoughtsTokenCount } : {},
+        ...meta.cachedContentTokenCount !== undefined ? { cachedInputTokens: meta.cachedContentTokenCount } : {}
+      };
+    }
+  }
+  yield {
+    type: "finish",
+    finishReason: mapGoogleFinish(finishReason, hadToolCalls),
+    ...usage !== undefined ? { usage } : {}
+  };
+}
+
+// src/providers/google/index.ts
+var CAPABILITIES3 = {
+  tools: true,
+  streaming: true,
+  multimodalInput: true,
+  parallelToolCalls: true,
+  structuredOutput: true
+};
+function createGoogle(opts) {
+  const apiKey = resolveSecret(opts.apiKey);
+  return createProvider({
+    name: "google",
+    defaultModel: opts.model ?? "gemini-2.5-pro",
+    capabilities: CAPABILITIES3,
+    http: {
+      baseUrl: opts.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta",
+      headers: {
+        ...opts.defaultHeaders,
+        "x-goog-api-key": apiKey
+      },
+      ...opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {},
+      ...opts.resilience !== undefined ? { resilience: opts.resilience } : {},
+      ...opts.fetch !== undefined ? { fetch: opts.fetch } : {}
+    },
+    completePath: (model) => `models/${model}:generateContent`,
+    streamPath: (model) => `models/${model}:streamGenerateContent?alt=sse`,
+    buildBody: buildGoogleBody,
+    parseResponse: parseGoogleResponse,
+    translateStream: translateGoogleStream
+  });
+}
+// src/providers/openai-compatible/map.ts
+function toChatMessages(messages) {
+  const out = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      out.push({ role: "system", content: message.content.filter(isText).map((p) => p.text).join(`
+`) });
+      continue;
+    }
+    if (message.role === "tool") {
+      for (const part of message.content) {
+        if (isToolResult(part)) {
+          out.push({ role: "tool", tool_call_id: part.toolCallId, content: toolResultText(part) });
+        }
+      }
+      continue;
+    }
+    if (message.role === "assistant") {
+      const text = message.content.filter(isText).map((p) => p.text).join("");
+      const toolCalls = message.content.filter(isToolCall).map((part) => ({
+        id: part.id,
+        type: "function",
+        function: { name: part.name, arguments: stringifyArguments(part.arguments) }
+      }));
+      out.push({
+        role: "assistant",
+        content: text !== "" ? text : null,
+        ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+      });
+      continue;
+    }
+    const hasImage = message.content.some((p) => p.type === "image");
+    if (hasImage) {
+      const content = [];
+      for (const part of message.content) {
+        if (part.type === "text")
+          content.push({ type: "text", text: part.text });
+        else if (part.type === "image")
+          content.push({ type: "image_url", image_url: { url: imageDataUrl(part) } });
+      }
+      out.push({ role: "user", content });
+    } else {
+      out.push({ role: "user", content: message.content.filter(isText).map((p) => p.text).join("") });
+    }
+  }
+  return out;
+}
+function toToolChoice3(choice) {
+  if (typeof choice === "string")
+    return choice;
+  return { type: "function", function: { name: choice.name } };
+}
+function buildChatBody(req, model, stream) {
+  const body = {
+    model,
+    messages: toChatMessages(req.messages),
+    stream
+  };
+  if (stream)
+    body["stream_options"] = { include_usage: true };
+  if (req.tools && req.tools.length > 0) {
+    body["tools"] = req.tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        ...t.description !== undefined ? { description: t.description } : {},
+        parameters: t.parameters
+      }
+    }));
+  }
+  if (req.toolChoice !== undefined)
+    body["tool_choice"] = toToolChoice3(req.toolChoice);
+  if (req.responseSchema !== undefined) {
+    body["response_format"] = {
+      type: "json_schema",
+      json_schema: {
+        name: req.responseSchema.name,
+        schema: req.responseSchema.schema,
+        strict: req.responseSchema.strict ?? true
+      }
+    };
+  }
+  if (req.maxOutputTokens !== undefined)
+    body["max_tokens"] = req.maxOutputTokens;
+  if (req.temperature !== undefined)
+    body["temperature"] = req.temperature;
+  if (req.topP !== undefined)
+    body["top_p"] = req.topP;
+  if (req.stopSequences !== undefined)
+    body["stop"] = req.stopSequences;
+  if (req.metadata !== undefined)
+    body["metadata"] = req.metadata;
+  if (req.providerOptions !== undefined)
+    Object.assign(body, req.providerOptions);
+  return body;
+}
+function mapChatFinish(reason, hadToolCalls) {
+  switch (reason) {
+    case "stop":
+      return hadToolCalls ? "tool_calls" : "stop";
+    case "length":
+      return "length";
+    case "tool_calls":
+    case "function_call":
+      return "tool_calls";
+    case "content_filter":
+      return "content_filter";
+    default:
+      return hadToolCalls ? "tool_calls" : "stop";
+  }
+}
+function parseChatResponse(raw, model) {
+  const response = raw ?? {};
+  const choice = response.choices?.[0];
+  const text = choice?.message?.content ?? "";
+  const toolCalls = (choice?.message?.tool_calls ?? []).map((call) => {
+    const argumentsText = call.function?.arguments ?? "";
+    return {
+      id: call.id ?? "",
+      name: call.function?.name ?? "",
+      arguments: parseArguments2(argumentsText),
+      argumentsText
+    };
+  });
+  const content = [];
+  if (text !== "")
+    content.push({ type: "text", text });
+  for (const call of toolCalls) {
+    content.push({ type: "tool_call", id: call.id, name: call.name, arguments: call.arguments });
+  }
+  const usage = response.usage ? {
+    inputTokens: response.usage.prompt_tokens ?? 0,
+    outputTokens: response.usage.completion_tokens ?? 0,
+    totalTokens: response.usage.total_tokens ?? (response.usage.prompt_tokens ?? 0) + (response.usage.completion_tokens ?? 0),
+    ...response.usage.completion_tokens_details?.reasoning_tokens !== undefined ? { reasoningTokens: response.usage.completion_tokens_details.reasoning_tokens } : {},
+    ...response.usage.prompt_tokens_details?.cached_tokens !== undefined ? { cachedInputTokens: response.usage.prompt_tokens_details.cached_tokens } : {}
+  } : undefined;
+  return {
+    message: { role: "assistant", content },
+    toolCalls,
+    finishReason: mapChatFinish(choice?.finish_reason, toolCalls.length > 0),
+    ...usage !== undefined ? { usage } : {},
+    model: response.model ?? model,
+    raw
+  };
+}
+function parseArguments2(text) {
+  if (text.trim() === "")
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+
+// src/providers/openai-compatible/stream.ts
+async function* translateChatStream(messages, model) {
+  let started = false;
+  const openTools = new Set;
+  let hadToolCalls = false;
+  let finishReason;
+  let usage;
+  for await (const message of messages) {
+    if (message.data === "" || message.data === "[DONE]")
+      continue;
+    let chunk;
+    try {
+      chunk = JSON.parse(message.data);
+    } catch {
+      continue;
+    }
+    if (!started) {
+      started = true;
+      yield { type: "message_start", model: chunk.model ?? model };
+    }
+    const choice = chunk.choices?.[0];
+    if (choice?.delta?.content !== undefined && choice.delta.content !== null) {
+      yield { type: "text_delta", text: choice.delta.content };
+    }
+    for (const call of choice?.delta?.tool_calls ?? []) {
+      const index = call.index ?? 0;
+      if (!openTools.has(index)) {
+        openTools.add(index);
+        hadToolCalls = true;
+        yield { type: "tool_call_start", index, id: call.id ?? "", name: call.function?.name ?? "" };
+      }
+      if (call.function?.arguments !== undefined && call.function.arguments !== "") {
+        yield { type: "tool_call_delta", index, argumentsTextDelta: call.function.arguments };
+      }
+    }
+    if (choice?.finish_reason !== undefined && choice.finish_reason !== null) {
+      finishReason = choice.finish_reason;
+    }
+    if (chunk.usage) {
+      usage = {
+        inputTokens: chunk.usage.prompt_tokens ?? 0,
+        outputTokens: chunk.usage.completion_tokens ?? 0,
+        totalTokens: chunk.usage.total_tokens ?? (chunk.usage.prompt_tokens ?? 0) + (chunk.usage.completion_tokens ?? 0),
+        ...chunk.usage.completion_tokens_details?.reasoning_tokens !== undefined ? { reasoningTokens: chunk.usage.completion_tokens_details.reasoning_tokens } : {},
+        ...chunk.usage.prompt_tokens_details?.cached_tokens !== undefined ? { cachedInputTokens: chunk.usage.prompt_tokens_details.cached_tokens } : {}
+      };
+    }
+  }
+  for (const index of openTools)
+    yield { type: "tool_call_end", index };
+  yield {
+    type: "finish",
+    finishReason: mapChatFinish(finishReason, hadToolCalls),
+    ...usage !== undefined ? { usage } : {}
+  };
+}
+
+// src/providers/openai-compatible/index.ts
+var DEFAULT_CAPABILITIES = {
+  tools: true,
+  streaming: true,
+  multimodalInput: true,
+  parallelToolCalls: true,
+  structuredOutput: true
+};
+function createOpenAICompatible(opts) {
+  const headers = { ...opts.defaultHeaders };
+  if (opts.apiKey !== undefined)
+    headers["authorization"] = `Bearer ${resolveSecret(opts.apiKey)}`;
+  return createProvider({
+    name: opts.name ?? "openai-compatible",
+    defaultModel: opts.model,
+    capabilities: { ...DEFAULT_CAPABILITIES, ...opts.capabilities },
+    http: {
+      baseUrl: opts.baseUrl,
+      headers,
+      ...opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {},
+      ...opts.resilience !== undefined ? { resilience: opts.resilience } : {},
+      ...opts.fetch !== undefined ? { fetch: opts.fetch } : {}
+    },
+    completePath: () => "chat/completions",
+    streamPath: () => "chat/completions",
+    buildBody: buildChatBody,
+    parseResponse: parseChatResponse,
+    translateStream: translateChatStream
+  });
+}
+export { DEFAULT_TIMEOUT_MS, defaultProviderResilience, createProviderHttp, openSseStream, toProviderError, parseSse, createProvider, createOpenAI, createAnthropic, createGoogle, createOpenAICompatible };