combined-ai 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1796 @@
+'use strict';
+
+// src/combine/index.ts
+var STRATEGY_NAMES = [
+  "consensus",
+  "pipeline",
+  "ensemble",
+  "broadcast"
+];
+
+// src/combine/shared.ts
+function makeEmitter(onEvent) {
+  return (event) => {
+    try {
+      onEvent?.(event);
+    } catch {
+    }
+  };
+}
+var SANITIZE_FRAMING = 'Rewrite the following answer so it reads as a single, self-contained reply addressed directly to the user. Remove any meta-commentary about how it was produced \u2014 any reference to other answers, drafts, candidates, sources, reviewers, or a synthesis or selection process (for example "this answer synthesizes the drafts", "among the candidates", or "Answer A"). Preserve the substance, wording, and length as much as possible; change only what is needed. Output only the rewritten answer, with no preamble.';
+function completionFor(request, system, messages, overrides) {
+  const completion = { messages };
+  if (system !== void 0) {
+    completion.system = system;
+  }
+  const model = overrides?.model ?? request.model;
+  if (model !== void 0) {
+    completion.model = model;
+  }
+  const maxTokens = overrides?.maxTokens ?? request.maxTokens;
+  if (maxTokens !== void 0) {
+    completion.maxTokens = maxTokens;
+  }
+  if (request.signal !== void 0) {
+    completion.signal = request.signal;
+  }
+  if (request.responseFormat !== void 0) {
+    completion.responseFormat = request.responseFormat;
+  }
+  return completion;
+}
+function composeSystem(userSystem, framing) {
+  return userSystem === void 0 ? framing : `${userSystem}
+
+${framing}`;
+}
+async function runOutcome(id, provider, run) {
+  try {
+    return { id, provider, status: "ok", result: await run() };
+  } catch (error) {
+    return {
+      id,
+      provider,
+      status: "failed",
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+async function respondAll(roster, request, emit) {
+  return Promise.all(
+    roster.map(async (entry) => {
+      const outcome = await runOutcome(
+        entry.id,
+        entry.providerName,
+        () => entry.provider.complete(
+          completionFor(request, request.system, request.messages, entry)
+        )
+      );
+      emit({
+        type: "response",
+        id: entry.id,
+        provider: entry.providerName,
+        status: outcome.status
+      });
+      return outcome;
+    })
+  );
+}
+function noResultError(message, outcomes) {
+  return aggregateError(
+    message,
+    outcomes.flatMap((o) => o.status === "failed" ? [o.error] : [])
+  );
+}
+async function sanitizeAnswer(provider, request, answer, overrides) {
+  try {
+    const result = await provider.complete(
+      completionFor(
+        request,
+        composeSystem(request.system, SANITIZE_FRAMING),
+        [{ role: "user", content: answer }],
+        overrides
+      )
+    );
+    return {
+      text: result.text.trim() === "" ? answer : result.text,
+      usage: result.usage
+    };
+  } catch {
+    return { text: answer };
+  }
+}
+function outcomeUsage(outcomes) {
+  return outcomes.map((o) => ({
+    id: o.id,
+    usage: o.status === "ok" ? o.result.usage : void 0
+  }));
+}
+function aggregateUsage(entries) {
+  const byParticipant = {};
+  const total = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  for (const { id, usage } of entries) {
+    if (usage === void 0) {
+      continue;
+    }
+    total.inputTokens += usage.inputTokens;
+    total.outputTokens += usage.outputTokens;
+    total.totalTokens += usage.totalTokens;
+    const acc = byParticipant[id];
+    byParticipant[id] = {
+      inputTokens: (acc?.inputTokens ?? 0) + usage.inputTokens,
+      outputTokens: (acc?.outputTokens ?? 0) + usage.outputTokens,
+      totalTokens: (acc?.totalTokens ?? 0) + usage.totalTokens
+    };
+  }
+  return Object.keys(byParticipant).length === 0 ? void 0 : { total, byParticipant };
+}
+function textOf(content) {
+  return typeof content === "string" ? content : content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function renderConversation(messages) {
+  if (messages.length === 1) {
+    return textOf(messages[0]?.content ?? "");
+  }
+  return messages.map(
+    (m) => `${m.role === "user" ? "User" : "Assistant"}: ${textOf(m.content)}`
+  ).join("\n\n");
+}
+
+// src/combine/broadcast.ts
+async function broadcast(roster, request, onEvent) {
+  const emit = makeEmitter(onEvent);
+  const responses = await respondAll(roster, request, emit);
+  if (!responses.some((o) => o.status === "ok")) {
+    throw noResultError(
+      "Broadcast failed: no participant returned a response.",
+      responses
+    );
+  }
+  return {
+    strategy: "broadcast",
+    responses,
+    usage: aggregateUsage(outcomeUsage(responses))
+  };
+}
+
+// src/combine/consensus.ts
+var CONCISE_DIRECTIVE = "Skip greetings, sign-offs, and preamble \u2014 begin directly with the content. Include your reasoning, assumptions, and any caveats; your reply is read by other AI assistants, not an end user, so favor complete substance over brevity of style.";
+var CRITIQUE_FRAMING = "You are one of several AI assistants that independently answered the same question. Below are all the drafts. Critically evaluate them: point out errors, gaps, and risks in each, and scrutinize the reasoning, not just the conclusions. Judge every answer on its merits regardless of which assistant wrote it, including any you may have written yourself; refer to answers by their heading. Do not write the final answer yet \u2014 produce only a critique, then end with exactly three lines:\nBEST: <heading of the strongest answer>\nKEY FIX: <the single most important improvement to it>\nCONFIDENCE: <low | medium | high>";
+var SYNTH_FRAMING = `You are the lead assistant writing the final answer to the user's question below. You are given several draft answers from other assistants, plus their critiques (each ending with that critic's pick and most important fix), as private input material \u2014 the user has not seen any of it and must not learn it exists. Use it to produce the most correct answer. Prefer correctness over popularity: a single correct draft beats a wrong majority, so adopt it and do not average conflicting claims; blend points only when they are genuinely complementary, not contradictory; if the material is inconclusive, say so plainly rather than papering over it. Judge every draft on its merits regardless of source \u2014 one may be your own, which you must not favor. Write ONLY the answer itself, addressed to the user as if answering for the first time. Do not mention or allude to this material, the other assistants, the drafting or critique process, or the existence of multiple answers, and do not use words like "candidates", "the drafts", or "the options" or labels like "Answer A"/"Answer B".`;
+var LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+async function consensus(roster, synthesizer, request, onEvent) {
+  const anonymized = (request.attribution ?? "anonymized") === "anonymized";
+  const minParticipants = request.minParticipants ?? 2;
+  const emit = makeEmitter(onEvent);
+  emit({ type: "phase", phase: "drafting" });
+  const draftSystem = composeSystem(request.system, CONCISE_DIRECTIVE);
+  const draftResults = await Promise.all(
+    roster.map(async (entry) => {
+      const outcome = await runOutcome(
+        entry.id,
+        entry.providerName,
+        () => entry.provider.complete(
+          completionFor(request, draftSystem, request.messages, entry)
+        )
+      );
+      emit({
+        type: "draft",
+        id: entry.id,
+        provider: entry.providerName,
+        status: outcome.status
+      });
+      return { entry, outcome };
+    })
+  );
+  const drafts = draftResults.map((d) => d.outcome);
+  const survivors = draftResults.flatMap(
+    (d) => d.outcome.status === "ok" && d.outcome.result.text.trim() !== "" ? [{ ...d.entry, result: d.outcome.result }] : []
+  );
+  const [firstSurvivor] = survivors;
+  if (firstSurvivor === void 0) {
+    throw noResultError(
+      "Consensus failed: no participant produced a draft.",
+      drafts
+    );
+  }
+  if (roster.length === 1) {
+    return {
+      text: firstSurvivor.result.text,
+      strategy: "consensus",
+      synthesizer: firstSurvivor.id,
+      model: firstSurvivor.result.model,
+      drafts,
+      critiques: [],
+      usage: aggregateUsage(outcomeUsage(drafts))
+    };
+  }
+  if (survivors.length < minParticipants) {
+    throw noResultError(
+      `Consensus failed: only ${String(survivors.length)} of ${String(roster.length)} participants produced a draft (minimum ${String(minParticipants)}).`,
+      drafts
+    );
+  }
+  emit({ type: "phase", phase: "critiquing" });
+  const answersBlock = renderAnswers(survivors, anonymized);
+  const question = renderConversation(request.messages);
+  const critiqueBody = `## Original question
+${question}
+
+## Drafts
+${answersBlock}`;
+  const critiqueSystem = composeSystem(
+    request.system,
+    `${CONCISE_DIRECTIVE}
+
+${CRITIQUE_FRAMING}`
+  );
+  const critiques = await Promise.all(
+    survivors.map(async (s) => {
+      const outcome = await runOutcome(
+        s.id,
+        s.providerName,
+        () => s.provider.complete(
+          completionFor(
+            request,
+            critiqueSystem,
+            [{ role: "user", content: critiqueBody }],
+            s
+          )
+        )
+      );
+      emit({
+        type: "critique",
+        id: s.id,
+        provider: s.providerName,
+        status: outcome.status
+      });
+      return outcome;
+    })
+  );
+  emit({ type: "phase", phase: "synthesizing" });
+  const critiquesRendered = renderCritiques(critiques, anonymized);
+  const critiquesBlock = critiquesRendered === "" ? "" : `
+
+## Critiques
+${critiquesRendered}`;
+  const synthBody = `${critiqueBody}${critiquesBlock}`;
+  const synthSystem = composeSystem(request.system, SYNTH_FRAMING);
+  let lastError;
+  const synthUsage = [];
+  for (const candidate of synthesizerOrder(survivors, synthesizer)) {
+    try {
+      const result = await candidate.provider.complete(
+        completionFor(
+          request,
+          synthSystem,
+          [{ role: "user", content: synthBody }],
+          candidate
+        )
+      );
+      synthUsage.push({ id: candidate.id, usage: result.usage });
+      if (result.text.trim() === "") {
+        lastError = new Error(`${candidate.id} produced an empty synthesis`);
+        continue;
+      }
+      const sanitized = await sanitizeAnswer(
+        candidate.provider,
+        request,
+        result.text,
+        candidate
+      );
+      synthUsage.push({ id: candidate.id, usage: sanitized.usage });
+      return {
+        text: sanitized.text,
+        strategy: "consensus",
+        synthesizer: candidate.id,
+        model: result.model,
+        drafts,
+        critiques,
+        usage: aggregateUsage([
+          ...outcomeUsage(drafts),
+          ...outcomeUsage(critiques),
+          ...synthUsage
+        ])
+      };
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+    }
+  }
+  throw new Error(
+    `Consensus synthesis failed for all participants: ${lastError?.message ?? "unknown error"}`
+  );
+}
+function synthesizerOrder(survivors, synthesizer) {
+  const requested = survivors.find((s) => s.id === synthesizer);
+  const rest = survivors.filter((s) => s !== requested);
+  return requested ? [requested, ...rest] : rest;
+}
+function renderAnswers(survivors, anonymized) {
+  return survivors.map((s, i) => {
+    const label = anonymized ? `Answer ${LETTERS[i] ?? `#${String(i + 1)}`}` : `Answer from ${s.id}`;
+    return `### ${label}
+${s.result.text}`;
+  }).join("\n\n");
+}
+function renderCritiques(critiques, anonymized) {
+  const blocks = [];
+  for (const [i, critique] of critiques.entries()) {
+    if (critique.status !== "ok") {
+      continue;
+    }
+    const label = anonymized ? `Critique ${LETTERS[i] ?? `#${String(i + 1)}`}` : `Critique from ${critique.id}`;
+    blocks.push(`### ${label}
+${critique.result.text}`);
+  }
+  return blocks.join("\n\n");
+}
+
+// src/combine/ensemble.ts
+async function ensemble(roster, request, onEvent) {
+  const emit = makeEmitter(onEvent);
+  const responses = await respondAll(roster, request, emit);
+  const objects = responses.flatMap(
+    (o) => o.status === "ok" && isPlainObject(o.result.parsed) ? [o.result.parsed] : []
+  );
+  if (objects.length === 0) {
+    throw noResultError(
+      "Ensemble failed: no participant returned a valid structured object.",
+      responses
+    );
+  }
+  const { merged, agreement } = mergeObjects(objects);
+  return {
+    text: JSON.stringify(merged),
+    strategy: "ensemble",
+    merged,
+    agreement,
+    responses,
+    usage: aggregateUsage(outcomeUsage(responses))
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeObjects(objects) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const object of objects) {
+    for (const [key, value] of Object.entries(object)) {
+      const values = byKey.get(key);
+      if (values === void 0) {
+        byKey.set(key, [value]);
+      } else {
+        values.push(value);
+      }
+    }
+  }
+  const merged = {};
+  const byField = {};
+  for (const [key, values] of byKey) {
+    const field = mergeField(values, objects.length);
+    merged[key] = field.value;
+    byField[key] = field.agreement;
+  }
+  const scores = Object.values(byField);
+  const overall = scores.length === 0 ? 1 : scores.reduce((a, b) => a + b, 0) / scores.length;
+  return { merged, agreement: { overall, byField } };
+}
+function mergeField(values, total) {
+  const counts = /* @__PURE__ */ new Map();
+  let mode = values[0];
+  let maxCount = 0;
+  for (const value of values) {
+    const key = stableKey(value);
+    const count = (counts.get(key) ?? 0) + 1;
+    counts.set(key, count);
+    if (count > maxCount) {
+      maxCount = count;
+      mode = value;
+    }
+  }
+  return { value: mode, agreement: maxCount / total };
+}
+function stableKey(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (!isPlainObject(val)) {
+      return val;
+    }
+    const sortedKeys = Object.keys(val).sort();
+    return Object.fromEntries(sortedKeys.map((key) => [key, val[key]]));
+  });
+}
+
+// src/combine/pipeline.ts
+var PIPELINE_FIRST_FRAMING = "You are the first stage in a pipeline of AI assistants answering the user's question below. Write the best, most complete and correct answer you can. Output only the answer itself, addressed to the user \u2014 no preamble and no notes about your process.";
+var PIPELINE_REFINE_FRAMING = "You are one stage in a pipeline of AI assistants improving an answer to the user's question. Below are the question and the current answer from an earlier stage. Treat the current answer as a strong baseline: revise the current answer only to improve its correctness and completeness \u2014 fix errors, fill genuine gaps, and sharpen unclear wording. Preserve everything that is already correct and keep its substance and length; do not drop correct content or rewrite it merely to sound different. If you cannot improve it, return it unchanged. Output only the improved answer, addressed to the user as if answering for the first time \u2014 do not mention the earlier answer, the revision, or that multiple assistants were involved.";
+async function pipeline(roster, request, onEvent) {
+  const emit = makeEmitter(onEvent);
+  const question = renderConversation(request.messages);
+  const firstSystem = composeSystem(request.system, PIPELINE_FIRST_FRAMING);
+  const refineSystem = composeSystem(request.system, PIPELINE_REFINE_FRAMING);
+  const stages = [];
+  let current;
+  for (const [index, entry] of roster.entries()) {
+    const completion = current === void 0 ? completionFor(request, firstSystem, request.messages, entry) : completionFor(
+      request,
+      refineSystem,
+      [
+        {
+          role: "user",
+          content: `## Question
+${question}
+
+## Current answer
+${current.text}`
+        }
+      ],
+      entry
+    );
+    const outcome = await runOutcome(
+      entry.id,
+      entry.providerName,
+      () => entry.provider.complete(completion)
+    );
+    stages.push(outcome);
+    emit({
+      type: "stage",
+      id: entry.id,
+      provider: entry.providerName,
+      status: outcome.status,
+      index
+    });
+    if (outcome.status === "ok" && outcome.result.text.trim() !== "") {
+      const text = outcome.result.text;
+      const needsSanitize = current !== void 0 && (text !== current.text || current.needsSanitize);
+      current = { entry, text, model: outcome.result.model, needsSanitize };
+    }
+  }
+  if (current === void 0) {
+    throw noResultError(
+      "Pipeline failed: no participant produced an answer.",
+      stages
+    );
+  }
+  const sanitized = current.needsSanitize ? await sanitizeAnswer(
+    current.entry.provider,
+    request,
+    current.text,
+    current.entry
+  ) : { text: current.text };
+  return {
+    text: sanitized.text,
+    strategy: "pipeline",
+    finalParticipant: current.entry.id,
+    model: current.model,
+    stages,
+    usage: aggregateUsage([
+      ...outcomeUsage(stages),
+      { id: current.entry.id, usage: sanitized.usage }
+    ])
+  };
+}
+
+// src/providers/extract.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function extractModel(data, fallback, field = "model") {
+  if (isRecord(data)) {
+    const value = data[field];
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return fallback;
+}
+
+// src/providers/sse.ts
+var DONE = /* @__PURE__ */ Symbol("sse-done");
+async function* sseJson(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    for (let result = await reader.read(); !result.done; result = await reader.read()) {
+      buffer += decoder.decode(result.value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const event2 = classifyLine(line);
+        if (event2 === DONE) {
+          return;
+        }
+        if (event2 !== void 0) {
+          yield event2;
+        }
+      }
+    }
+    const event = classifyLine(buffer);
+    if (event !== void 0 && event !== DONE) {
+      yield event;
+    }
+  } finally {
+    await reader.cancel();
+  }
+}
+function classifyLine(rawLine) {
+  const line = rawLine.trim();
+  if (!line.startsWith("data:")) {
+    return void 0;
+  }
+  const payload = line.slice("data:".length).trim();
+  if (payload === "") {
+    return void 0;
+  }
+  if (payload === "[DONE]") {
+    return DONE;
+  }
+  try {
+    const parsed = JSON.parse(payload);
+    return isRecord(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/providers/structured.ts
+function parseStructured(request, text) {
+  if (request.responseFormat === void 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/transport.ts
+async function providerFetch(provider, input, init) {
+  try {
+    return await fetch(input, init);
+  } catch (cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    throw new ProviderError(`${provider} request failed: ${reason}`, {
+      provider,
+      kind: "transport",
+      cause
+    });
+  }
+}
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 503, 529]);
+var DEFAULT_MAX_RETRIES = 2;
+var DEFAULT_BASE_DELAY_MS = 500;
+var MAX_BACKOFF_MS = 6e4;
+async function requestWithRetry(provider, input, init, retry) {
+  const maxRetries = Math.max(0, retry?.maxRetries ?? DEFAULT_MAX_RETRIES);
+  const baseDelayMs = retry?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+  for (let attempt = 0; ; attempt++) {
+    const response = await providerFetch(provider, input, init);
+    if (response.ok || !RETRYABLE_STATUSES.has(response.status) || attempt >= maxRetries) {
+      return response;
+    }
+    const delayMs = retryDelayMs(response, attempt, baseDelayMs);
+    await response.body?.cancel();
+    await sleep(delayMs, init.signal ?? void 0);
+  }
+}
+function retryDelayMs(response, attempt, baseDelayMs) {
+  const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+  if (retryAfter !== void 0) {
+    return Math.min(retryAfter, MAX_BACKOFF_MS);
+  }
+  return Math.min(baseDelayMs * 2 ** attempt, MAX_BACKOFF_MS);
+}
+function parseRetryAfter(value) {
+  if (value === null) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return void 0;
+  }
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1e3);
+  }
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date)) {
+    return void 0;
+  }
+  return Math.max(0, date - Date.now());
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/providers/anthropic.ts
+var DEFAULT_MODEL = "claude-opus-4-8";
+var DEFAULT_BASE_URL = "https://api.anthropic.com";
+var ANTHROPIC_VERSION = "2023-06-01";
+var DEFAULT_MAX_TOKENS = 16e3;
+var DEFAULT_STREAM_MAX_TOKENS = 64e3;
+var AnthropicProvider = class {
+  name = "anthropic";
+  #apiKey;
+  #model;
+  #baseUrl;
+  #retry;
+  constructor(options) {
+    this.#apiKey = options.apiKey;
+    this.#model = options.model ?? DEFAULT_MODEL;
+    this.#baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.#retry = options.retry;
+  }
+  async complete(request) {
+    const model = request.model ?? this.#model;
+    const response = await requestWithRetry(
+      "anthropic",
+      `${this.#baseUrl}/v1/messages`,
+      {
+        method: "POST",
+        headers: this.#headers(),
+        body: JSON.stringify(
+          this.#buildBody(request, model, DEFAULT_MAX_TOKENS, false)
+        ),
+        signal: request.signal
+      },
+      this.#retry
+    );
+    if (!response.ok) {
+      throw await apiError("anthropic", response);
+    }
+    const data = await response.json();
+    if (isRecord(data) && isRecord(data.error)) {
+      throw apiErrorFromBody("anthropic", response.status, data);
+    }
+    const rawFinishReason = extractFinishReason(data);
+    const text = extractText(data);
+    return {
+      text,
+      model: extractModel(data, model),
+      finishReason: normalizeFinishReason(rawFinishReason),
+      rawFinishReason,
+      refusal: extractRefusal(data),
+      usage: extractUsage(data),
+      parsed: parseStructured(request, text),
+      toolCalls: extractToolCalls(data)
+    };
+  }
+  async *stream(request) {
+    const model = request.model ?? this.#model;
+    const response = await requestWithRetry(
+      "anthropic",
+      `${this.#baseUrl}/v1/messages`,
+      {
+        method: "POST",
+        headers: this.#headers(),
+        body: JSON.stringify(
+          this.#buildBody(request, model, DEFAULT_STREAM_MAX_TOKENS, true)
+        ),
+        signal: request.signal
+      },
+      this.#retry
+    );
+    if (!response.ok) {
+      throw await apiError("anthropic", response);
+    }
+    if (!response.body) {
+      throw new Error("Anthropic streaming response had no body");
+    }
+    for await (const event of sseJson(response.body)) {
+      if (event.type === "message_stop") {
+        return;
+      }
+      if (event.type === "error") {
+        throw new Error(`Anthropic stream error: ${JSON.stringify(event)}`);
+      }
+      if (event.type === "content_block_delta") {
+        const delta = event.delta;
+        if (isRecord(delta) && delta.type === "text_delta" && typeof delta.text === "string") {
+          yield delta.text;
+        }
+      }
+    }
+  }
+  #headers() {
+    return {
+      "x-api-key": this.#apiKey,
+      "anthropic-version": ANTHROPIC_VERSION,
+      "content-type": "application/json"
+    };
+  }
+  #buildBody(request, model, defaultMaxTokens, stream) {
+    const body = {
+      model,
+      max_tokens: request.maxTokens ?? defaultMaxTokens,
+      messages: request.messages.map((message) => toAnthropicMessage(message))
+    };
+    if (request.system !== void 0) {
+      body.system = request.system;
+    }
+    if (request.responseFormat !== void 0) {
+      body.output_config = {
+        format: { type: "json_schema", schema: request.responseFormat.schema }
+      };
+    }
+    if (request.tools !== void 0) {
+      body.tools = request.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters
+      }));
+    }
+    if (request.toolChoice !== void 0) {
+      body.tool_choice = toAnthropicToolChoice(request.toolChoice);
+    }
+    if (stream) {
+      body.stream = true;
+    }
+    return body;
+  }
+};
+function toAnthropicToolChoice(choice) {
+  if (typeof choice === "object") {
+    return { type: "tool", name: choice.name };
+  }
+  return { type: choice };
+}
+function toAnthropicMessage(message) {
+  if (typeof message.content === "string") {
+    return { role: message.role, content: message.content };
+  }
+  const blocks = message.content.map((part) => toAnthropicBlock(part));
+  const toolResults = blocks.filter((b) => b.type === "tool_result");
+  const rest = blocks.filter((b) => b.type !== "tool_result");
+  return { role: message.role, content: [...toolResults, ...rest] };
+}
+function toAnthropicBlock(part) {
+  switch (part.type) {
+    case "text":
+      return { type: "text", text: part.text };
+    case "image":
+      return { type: "image", source: toAnthropicSource(part.source) };
+    case "file":
+      return { type: "document", source: toAnthropicSource(part.source) };
+    case "tool_use":
+      return {
+        type: "tool_use",
+        id: part.id,
+        name: part.name,
+        input: part.input
+      };
+    case "tool_result":
+      return {
+        type: "tool_result",
+        tool_use_id: part.toolUseId,
+        content: part.content,
+        ...part.isError === void 0 ? {} : { is_error: part.isError }
+      };
+  }
+}
+function toAnthropicSource(source) {
+  return source.kind === "base64" ? { type: "base64", media_type: source.mediaType, data: source.data } : { type: "url", url: source.url };
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function extractText(data) {
+  const content = isRecord(data) ? toArray(data.content) : [];
+  let text = "";
+  for (const block of content) {
+    if (isRecord(block) && block.type === "text" && typeof block.text === "string") {
+      text += block.text;
+    }
+  }
+  return text;
+}
+function extractToolCalls(data) {
+  const content = isRecord(data) ? toArray(data.content) : [];
+  const calls = [];
+  for (const block of content) {
+    if (isRecord(block) && block.type === "tool_use" && typeof block.name === "string") {
+      calls.push({
+        id: typeof block.id === "string" ? block.id : void 0,
+        name: block.name,
+        input: isRecord(block.input) ? block.input : {}
+      });
+    }
+  }
+  return calls.length > 0 ? calls : void 0;
+}
+function extractFinishReason(data) {
+  if (isRecord(data) && typeof data.stop_reason === "string") {
+    return data.stop_reason;
+  }
+  return void 0;
+}
+function normalizeFinishReason(raw) {
+  switch (raw) {
+    case void 0:
+      return void 0;
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "refusal":
+      return "content_filter";
+    case "tool_use":
+      return "tool_use";
+    default:
+      return "other";
+  }
+}
+function extractUsage(data) {
+  const usage = isRecord(data) ? data.usage : void 0;
+  if (!isRecord(usage)) {
+    return void 0;
+  }
+  const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+  const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+  return { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens };
+}
+function extractRefusal(data) {
+  const content = isRecord(data) ? toArray(data.content) : [];
+  let refusal = "";
+  for (const block of content) {
+    if (isRecord(block) && block.type === "refusal" && typeof block.text === "string") {
+      refusal += block.text;
+    }
+  }
+  return refusal === "" ? void 0 : refusal;
+}
+
+// src/providers/google.ts
+var DEFAULT_MODEL2 = "gemini-2.5-pro";
+var DEFAULT_BASE_URL2 = "https://generativelanguage.googleapis.com";
+var DEFAULT_MAX_TOKENS2 = 16e3;
+var DEFAULT_STREAM_MAX_TOKENS2 = 64e3;
+var GoogleProvider = class {
+  name = "google";
+  #apiKey;
+  #model;
+  #baseUrl;
+  #retry;
+  constructor(options) {
+    this.#apiKey = options.apiKey;
+    this.#model = options.model ?? DEFAULT_MODEL2;
+    this.#baseUrl = options.baseUrl ?? DEFAULT_BASE_URL2;
+    this.#retry = options.retry;
+  }
+  async complete(request) {
+    const model = request.model ?? this.#model;
+    const response = await requestWithRetry(
+      "google",
+      this.#url(model, false),
+      {
+        method: "POST",
+        headers: this.#headers(),
+        body: JSON.stringify(this.#buildBody(request, DEFAULT_MAX_TOKENS2)),
+        signal: request.signal
+      },
+      this.#retry
+    );
+    if (!response.ok) {
+      throw await apiError("google", response);
+    }
+    const data = await response.json();
+    if (isRecord(data) && isRecord(data.error)) {
+      throw apiErrorFromBody("google", response.status, data);
+    }
+    const rawFinishReason = extractFinishReason2(data);
+    const text = extractText2(data);
+    const toolCalls = extractToolCalls2(data);
+    const finishReason = normalizeFinishReason2(rawFinishReason);
+    return {
+      text,
+      model: extractModel(data, model, "modelVersion"),
+      // Gemini reports `STOP` even when it emits a function call, so surface
+      // `tool_use` — but only on a clean stop. A real `MAX_TOKENS`/`SAFETY` stop
+      // (e.g. truncated args) must not be masked, so keep its normalized reason.
+      finishReason: toolCalls !== void 0 && (finishReason === "stop" || finishReason === void 0) ? "tool_use" : finishReason,
+      rawFinishReason,
+      usage: extractUsage2(data),
+      parsed: parseStructured(request, text),
+      toolCalls
+    };
+  }
+  async *stream(request) {
+    const model = request.model ?? this.#model;
+    const response = await requestWithRetry(
+      "google",
+      this.#url(model, true),
+      {
+        method: "POST",
+        headers: this.#headers(),
+        body: JSON.stringify(
+          this.#buildBody(request, DEFAULT_STREAM_MAX_TOKENS2)
+        ),
+        signal: request.signal
+      },
+      this.#retry
+    );
+    if (!response.ok) {
+      throw await apiError("google", response);
+    }
+    if (!response.body) {
+      throw new Error("Google streaming response had no body");
+    }
+    for await (const event of sseJson(response.body)) {
+      if (isRecord(event.error)) {
+        throw new Error(`Google stream error: ${JSON.stringify(event)}`);
+      }
+      const text = extractText2(event);
+      if (text.length > 0) {
+        yield text;
+      }
+    }
+  }
+  /**
+   * Gemini puts the model and the action in the path (`:generateContent` vs
+   * `:streamGenerateContent`); streaming additionally needs `?alt=sse` to get an
+   * SSE body rather than a streamed JSON array.
+   */
+  #url(model, stream) {
+    const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+    return `${this.#baseUrl}/v1beta/models/${model}:${action}`;
+  }
+  #headers() {
+    return {
+      "x-goog-api-key": this.#apiKey,
+      "content-type": "application/json"
+    };
+  }
+  #buildBody(request, defaultMaxTokens) {
+    const generationConfig = {
+      maxOutputTokens: request.maxTokens ?? defaultMaxTokens
+    };
+    if (request.responseFormat !== void 0) {
+      generationConfig.responseMimeType = "application/json";
+      generationConfig.responseSchema = toGeminiSchema(
+        request.responseFormat.schema
+      );
+    }
+    const body = {
+      contents: request.messages.map((message) => toGeminiContent(message)),
+      generationConfig
+    };
+    if (request.system !== void 0) {
+      body.systemInstruction = { parts: [{ text: request.system }] };
+    }
+    if (request.tools !== void 0) {
+      body.tools = [
+        {
+          functionDeclarations: request.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: toGeminiSchema(tool.parameters)
+          }))
+        }
+      ];
+    }
+    if (request.toolChoice !== void 0) {
+      body.toolConfig = {
+        functionCallingConfig: toGeminiFunctionCallingConfig(
+          request.toolChoice
+        )
+      };
+    }
+    return body;
+  }
+};
+function toGeminiFunctionCallingConfig(choice) {
+  if (typeof choice === "object") {
+    return { mode: "ANY", allowedFunctionNames: [choice.name] };
+  }
+  const mode = { auto: "AUTO", any: "ANY", none: "NONE" }[choice];
+  return { mode };
+}
+function toGeminiSchema(schema) {
+  if (Array.isArray(schema)) {
+    return schema.map((entry) => toGeminiSchema(entry));
+  }
+  if (!isRecord(schema)) {
+    return schema;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "type" && typeof value === "string") {
+      out[key] = value.toUpperCase();
+    } else if (key === "properties" && isRecord(value)) {
+      out[key] = Object.fromEntries(
+        Object.entries(value).map(([name, propSchema]) => [
+          name,
+          toGeminiSchema(propSchema)
+        ])
+      );
+    } else if (key === "items") {
+      out[key] = toGeminiSchema(value);
+    } else if (["anyOf", "allOf", "oneOf"].includes(key) && Array.isArray(value)) {
+      out[key] = value.map((entry) => toGeminiSchema(entry));
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function toGeminiContent(message) {
+  return {
+    role: message.role === "assistant" ? "model" : "user",
+    parts: typeof message.content === "string" ? [{ text: message.content }] : message.content.map((part) => toGeminiPart(part))
+  };
+}
+function toGeminiPart(part) {
+  switch (part.type) {
+    case "text":
+      return { text: part.text };
+    case "image":
+    case "file":
+      return toGeminiMedia(part.source);
+    case "tool_use":
+      return {
+        functionCall: {
+          name: part.name,
+          ...part.id === void 0 ? {} : { id: part.id },
+          args: part.input
+        }
+      };
+    case "tool_result":
+      if (part.name === void 0) {
+        throw new Error(
+          "Gemini requires the tool name on each tool result; set ToolResultPart.name to the called tool's name."
+        );
+      }
+      return {
+        functionResponse: {
+          name: part.name,
+          ...part.toolUseId === void 0 ? {} : { id: part.toolUseId },
+          response: { result: part.content }
+        }
+      };
+  }
+}
+function toGeminiMedia(source) {
+  if (source.kind === "base64") {
+    return { inlineData: { mimeType: source.mediaType, data: source.data } };
+  }
+  return {
+    fileData: source.mediaType === void 0 ? { fileUri: source.url } : { mimeType: source.mediaType, fileUri: source.url }
+  };
+}
+function toArray2(value) {
+  return Array.isArray(value) ? value : [];
+}
+function firstCandidate(data) {
+  const candidates = isRecord(data) ? toArray2(data.candidates) : [];
+  const first = candidates[0];
+  return isRecord(first) ? first : void 0;
+}
+function firstCandidateParts(data) {
+  const content = firstCandidate(data)?.content;
+  return isRecord(content) ? toArray2(content.parts) : [];
+}
+function extractText2(data) {
+  let text = "";
+  for (const part of firstCandidateParts(data)) {
+    if (isRecord(part) && typeof part.text === "string") {
+      text += part.text;
+    }
+  }
+  return text;
+}
+function extractToolCalls2(data) {
+  const parts = firstCandidateParts(data);
+  const calls = [];
+  for (const part of parts) {
+    const call = isRecord(part) ? part.functionCall : void 0;
+    if (isRecord(call) && typeof call.name === "string") {
+      calls.push({
+        id: typeof call.id === "string" ? call.id : void 0,
+        name: call.name,
+        input: isRecord(call.args) ? call.args : {}
+      });
+    }
+  }
+  return calls.length > 0 ? calls : void 0;
+}
+function extractFinishReason2(data) {
+  const first = firstCandidate(data);
+  if (first !== void 0 && typeof first.finishReason === "string") {
+    return first.finishReason;
+  }
+  const feedback = isRecord(data) ? data.promptFeedback : void 0;
+  if (isRecord(feedback) && typeof feedback.blockReason === "string") {
+    return feedback.blockReason;
+  }
+  return void 0;
+}
+function extractUsage2(data) {
+  const usage = isRecord(data) ? data.usageMetadata : void 0;
+  if (!isRecord(usage)) {
+    return void 0;
+  }
+  const inputTokens = typeof usage.promptTokenCount === "number" ? usage.promptTokenCount : 0;
+  const outputTokens = typeof usage.candidatesTokenCount === "number" ? usage.candidatesTokenCount : 0;
+  const totalTokens = typeof usage.totalTokenCount === "number" ? usage.totalTokenCount : inputTokens + outputTokens;
+  return { inputTokens, outputTokens, totalTokens };
+}
+function normalizeFinishReason2(raw) {
+  switch (raw) {
+    case void 0:
+      return void 0;
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+    case "RECITATION":
+    case "BLOCKLIST":
+    case "PROHIBITED_CONTENT":
+    case "SPII":
+      return "content_filter";
+    default:
+      return "other";
+  }
+}
+
+// src/providers/openai.ts
+var DEFAULT_MODEL3 = "gpt-4.1";
+var DEFAULT_BASE_URL3 = "https://api.openai.com";
+var DEFAULT_MAX_TOKENS3 = 16e3;
+var DEFAULT_STREAM_MAX_TOKENS3 = 64e3;
+var OpenAIProvider = class {
+  name;
+  #apiKey;
+  #model;
+  #baseUrl;
+  #extraHeaders;
+  #retry;
+  /**
+   * `name` is the provider's identity, used as `this.name` and in error
+   * attribution (`ProviderError.provider`). It defaults to `"openai"`; the
+   * registry passes a custom name for an OpenAI-compatible gateway so its errors
+   * aren't mislabeled `"openai"`. It's a constructor argument rather than a
+   * public option because only the registry sets it — it isn't user config.
+   */
+  constructor(options, name = "openai") {
+    this.name = name;
+    this.#apiKey = options.apiKey;
+    this.#model = options.model ?? DEFAULT_MODEL3;
+    this.#baseUrl = options.baseUrl ?? DEFAULT_BASE_URL3;
+    this.#extraHeaders = options.headers;
+    this.#retry = options.retry;
+  }
+  async complete(request) {
+    const model = request.model ?? this.#model;
+    const response = await requestWithRetry(
+      this.name,
+      `${this.#baseUrl}/v1/chat/completions`,
+      {
+        method: "POST",
+        headers: this.#headers(),
+        body: JSON.stringify(
+          this.#buildBody(request, model, DEFAULT_MAX_TOKENS3, false)
+        ),
+        signal: request.signal
+      },
+      this.#retry
+    );
+    if (!response.ok) {
+      throw await apiError(this.name, response);
+    }
+    const data = await response.json();
+    if (isRecord(data) && isRecord(data.error)) {
+      throw apiErrorFromBody(this.name, response.status, data);
+    }
+    const rawFinishReason = extractFinishReason3(data);
+    const refusal = extractRefusal2(data);
+    const text = extractText3(data);
+    return {
+      text,
+      model: extractModel(data, model),
+      // A refusal is a content-filter outcome even though OpenAI still reports
+      // finish_reason: "stop", so surface it as such regardless of the raw value.
+      finishReason: refusal === void 0 ? normalizeFinishReason3(rawFinishReason) : "content_filter",
+      rawFinishReason,
+      refusal,
+      usage: extractUsage3(data),
+      parsed: parseStructured(request, text),
+      toolCalls: extractToolCalls3(data)
+    };
+  }
+  async *stream(request) {
+    const model = request.model ?? this.#model;
+    const response = await requestWithRetry(
+      this.name,
+      `${this.#baseUrl}/v1/chat/completions`,
+      {
+        method: "POST",
+        headers: this.#headers(),
+        body: JSON.stringify(
+          this.#buildBody(request, model, DEFAULT_STREAM_MAX_TOKENS3, true)
+        ),
+        signal: request.signal
+      },
+      this.#retry
+    );
+    if (!response.ok) {
+      throw await apiError(this.name, response);
+    }
+    if (!response.body) {
+      throw new Error("OpenAI streaming response had no body");
+    }
+    for await (const event of sseJson(response.body)) {
+      if (isRecord(event.error)) {
+        throw new Error(`OpenAI stream error: ${JSON.stringify(event)}`);
+      }
+      const delta = firstChoiceDelta(event);
+      if (isRecord(delta) && typeof delta.content === "string") {
+        yield delta.content;
+      }
+    }
+  }
+  #headers() {
+    return {
+      authorization: `Bearer ${this.#apiKey}`,
+      "content-type": "application/json",
+      ...this.#extraHeaders
+    };
+  }
+  #buildBody(request, model, defaultMaxTokens, stream) {
+    const body = {
+      model,
+      max_completion_tokens: request.maxTokens ?? defaultMaxTokens,
+      messages: toOpenAIMessages(request)
+    };
+    if (request.responseFormat !== void 0) {
+      body.response_format = {
+        type: "json_schema",
+        json_schema: {
+          name: request.responseFormat.name ?? "response",
+          strict: true,
+          schema: request.responseFormat.schema
+        }
+      };
+    }
+    if (request.tools !== void 0) {
+      body.tools = request.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        }
+      }));
+    }
+    if (request.toolChoice !== void 0) {
+      body.tool_choice = toOpenAIToolChoice(request.toolChoice);
+    }
+    if (stream) {
+      body.stream = true;
+    }
+    return body;
+  }
+};
+function toOpenAIToolChoice(choice) {
+  if (typeof choice === "object") {
+    return { type: "function", function: { name: choice.name } };
+  }
+  return choice === "any" ? "required" : choice;
+}
+function toOpenAIMessages(request) {
+  const messages = request.messages.flatMap(
+    (message) => toOpenAIWireMessages(message)
+  );
+  if (request.system !== void 0) {
+    messages.unshift({ role: "system", content: request.system });
+  }
+  return messages;
+}
+function toOpenAIWireMessages(message) {
+  if (typeof message.content === "string") {
+    return [{ role: message.role, content: message.content }];
+  }
+  const toolUses = message.content.filter((p) => p.type === "tool_use");
+  const toolResults = message.content.filter((p) => p.type === "tool_result");
+  const rest = message.content.filter(
+    (p) => ["text", "image", "file"].includes(p.type)
+  );
+  if (toolUses.length > 0) {
+    return [
+      {
+        role: message.role,
+        content: rest.length > 0 ? rest.map((p) => toOpenAIPart(p)) : null,
+        tool_calls: toolUses.map((u) => {
+          if (u.id === void 0) {
+            throw new Error(
+              "OpenAI requires an id on each tool call; replay the ToolCall.id you received from the model."
+            );
+          }
+          return {
+            id: u.id,
+            type: "function",
+            function: { name: u.name, arguments: JSON.stringify(u.input) }
+          };
+        })
+      }
+    ];
+  }
+  const out = toolResults.map((r) => {
+    if (r.toolUseId === void 0) {
+      throw new Error(
+        "OpenAI requires toolUseId on each tool result; set it to the id of the ToolCall you are answering."
+      );
+    }
+    return { role: "tool", tool_call_id: r.toolUseId, content: r.content };
+  });
+  if (rest.length > 0) {
+    out.push({ role: message.role, content: rest.map((p) => toOpenAIPart(p)) });
+  }
+  return out;
+}
+function toOpenAIPart(part) {
+  switch (part.type) {
+    case "text":
+      return { type: "text", text: part.text };
+    case "image":
+      return {
+        type: "image_url",
+        image_url: { url: toOpenAIUrl(part.source) }
+      };
+    case "file":
+      return { type: "file", file: toOpenAIFile(part) };
+  }
+}
+function toOpenAIUrl(source) {
+  return source.kind === "base64" ? `data:${source.mediaType};base64,${source.data}` : source.url;
+}
+function toOpenAIFile(part) {
+  if (part.source.kind !== "base64") {
+    throw new Error(
+      "OpenAI (Chat Completions) does not support a URL file source; use a base64 source."
+    );
+  }
+  const file_data = `data:${part.source.mediaType};base64,${part.source.data}`;
+  return part.filename === void 0 ? { file_data } : { filename: part.filename, file_data };
+}
+function toArray3(value) {
+  return Array.isArray(value) ? value : [];
+}
+function firstChoice(data) {
+  const choices = isRecord(data) ? toArray3(data.choices) : [];
+  const first = choices[0];
+  return isRecord(first) ? first : void 0;
+}
+function extractText3(data) {
+  const message = firstChoice(data)?.message;
+  if (isRecord(message) && typeof message.content === "string") {
+    return message.content;
+  }
+  return "";
+}
+function firstChoiceDelta(data) {
+  return firstChoice(data)?.delta;
+}
+function extractToolCalls3(data) {
+  const message = firstChoice(data)?.message;
+  const toolCalls = isRecord(message) ? toArray3(message.tool_calls) : [];
+  const calls = [];
+  for (const call of toolCalls) {
+    if (!isRecord(call) || !isRecord(call.function)) {
+      continue;
+    }
+    const fn = call.function;
+    if (typeof fn.name !== "string") {
+      continue;
+    }
+    calls.push({
+      id: typeof call.id === "string" ? call.id : void 0,
+      name: fn.name,
+      input: parseArguments(fn.arguments)
+    });
+  }
+  return calls.length > 0 ? calls : void 0;
+}
+function parseArguments(args) {
+  if (typeof args !== "string") {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(args);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function extractFinishReason3(data) {
+  const reason = firstChoice(data)?.finish_reason;
+  return typeof reason === "string" ? reason : void 0;
+}
+function normalizeFinishReason3(raw) {
+  switch (raw) {
+    case void 0:
+      return void 0;
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content_filter";
+    case "tool_calls":
+    case "function_call":
+      return "tool_use";
+    default:
+      return "other";
+  }
+}
+function extractUsage3(data) {
+  const usage = isRecord(data) ? data.usage : void 0;
+  if (!isRecord(usage)) {
+    return void 0;
+  }
+  const inputTokens = typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0;
+  const outputTokens = typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0;
+  const totalTokens = typeof usage.total_tokens === "number" ? usage.total_tokens : inputTokens + outputTokens;
+  return { inputTokens, outputTokens, totalTokens };
+}
+function extractRefusal2(data) {
+  const message = firstChoice(data)?.message;
+  if (isRecord(message) && typeof message.refusal === "string" && message.refusal !== "") {
+    return message.refusal;
+  }
+  return void 0;
+}
+
+// src/registry.ts
+var BUILT_IN_NAMES = ["anthropic", "openai", "google"];
+var ProviderRegistry = class {
+  #providers = /* @__PURE__ */ new Map();
+  /**
+   * Construct the providers present in `config`. A provider is registered only
+   * if its entry is supplied; the rest are left out.
+   */
+  constructor(config) {
+    if (config.anthropic) {
+      this.#providers.set("anthropic", new AnthropicProvider(config.anthropic));
+    }
+    if (config.openai) {
+      this.#providers.set("openai", new OpenAIProvider(config.openai));
+    }
+    if (config.google) {
+      this.#providers.set("google", new GoogleProvider(config.google));
+    }
+    if (config.custom) {
+      const builtInNames = BUILT_IN_NAMES;
+      for (const [name, custom] of Object.entries(config.custom)) {
+        if (builtInNames.includes(name)) {
+          throw new Error(
+            `Custom provider name "${name}" collides with a built-in; choose a different name.`
+          );
+        }
+        this.#providers.set(name, constructCustom(name, custom));
+      }
+    }
+  }
+  /**
+   * Return the provider registered under `name`. Throws a clear error listing
+   * the configured names if that provider was not configured.
+   */
+  select(name) {
+    const provider = this.#providers.get(name);
+    if (provider === void 0) {
+      throw new Error(
+        `No provider "${name}" configured. Configured: ${this.#configuredList()}`
+      );
+    }
+    return provider;
+  }
+  /**
+   * Combine several configured providers to cooperate on one prompt, dispatching
+   * on `request.strategy` (defaults to `"consensus"`).
+   *
+   * Generic over the strategy: `S` is inferred from the `strategy` field, so a
+   * **literal** `strategy` at the call site makes the return that strategy's
+   * concrete result (e.g. `strategy: "ensemble"` → `EnsembleResult`) — the caller
+   * does **not** narrow a union. When `strategy` is only known at runtime, `S`
+   * widens to {@link StrategyName} and the return is the full
+   * {@link CombineResult} union to narrow.
+   *
+   * The request stays the broad {@link CombineRequest} here; for compile-time
+   * enforcement of a strategy's specific options (e.g. `responseFormat` required
+   * for ensemble) call the per-strategy method ({@link ProviderRegistry.consensus},
+   * {@link ProviderRegistry.pipeline}, {@link ProviderRegistry.ensemble},
+   * {@link ProviderRegistry.broadcast}), which takes that strategy's request type.
+   */
+  async combine(request, options) {
+    const strategy = request.strategy ?? "consensus";
+    const knownStrategies = STRATEGY_NAMES;
+    if (!knownStrategies.includes(strategy)) {
+      throw new Error(
+        `Unknown combine strategy "${strategy}". Known: ${STRATEGY_NAMES.join(", ")}`
+      );
+    }
+    let result;
+    switch (strategy) {
+      case "consensus":
+        result = await this.consensus(request, options);
+        break;
+      case "pipeline":
+        result = await this.pipeline(request, options);
+        break;
+      case "ensemble":
+        result = await this.ensemble(request, options);
+        break;
+      case "broadcast":
+        result = await this.broadcast(request, options);
+        break;
+      default: {
+        const unreachable = strategy;
+        throw new Error(`Unhandled combine strategy "${String(unreachable)}"`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Run the `consensus` strategy (draft → critique → synthesize) over the
+   * configured participants. Strategy-specific: `synthesizer` (defaults to the
+   * first participant), `attribution`, `minParticipants` (default 2).
+   */
+  async consensus(request, options) {
+    const { roster, ids, firstId } = this.#prepare(request);
+    this.#rejectResponseFormat(request, "consensus");
+    this.#validateConsensusOptions(request, ids);
+    const synthesizer = request.synthesizer ?? firstId;
+    return consensus(roster, synthesizer, request, options?.onEvent);
+  }
+  /**
+   * Run the `pipeline` strategy (sequential refinement) — participants refine a
+   * running answer in roster order; the last advancing stage wins.
+   */
+  async pipeline(request, options) {
+    const { roster } = this.#prepare(request);
+    this.#rejectResponseFormat(request, "pipeline");
+    return pipeline(roster, request, options?.onEvent);
+  }
+  /**
+   * Run the `ensemble` strategy (multi-model vote on structured output) — every
+   * participant answers under `request.responseFormat`; the typed objects are
+   * merged field-wise by majority vote with a per-field agreement score.
+   */
+  async ensemble(request, options) {
+    const { roster } = this.#prepare(request);
+    const { responseFormat } = request;
+    if (responseFormat === void 0) {
+      throw new Error(
+        'The "ensemble" strategy requires a responseFormat (the JSON Schema every participant answers under).'
+      );
+    }
+    const rootType = responseFormat.schema.type;
+    if (typeof rootType === "string" && rootType !== "object") {
+      throw new Error(
+        `The "ensemble" strategy requires an object schema (its field-wise vote needs named fields); got a "${rootType}" schema.`
+      );
+    }
+    return ensemble(roster, request, options?.onEvent);
+  }
+  /**
+   * Run the `broadcast` strategy (fan-out, no combine) — every participant
+   * answers the raw prompt in parallel; all raw responses are returned.
+   */
+  async broadcast(request, options) {
+    const { roster } = this.#prepare(request);
+    this.#rejectResponseFormat(request, "broadcast");
+    return broadcast(roster, request, options?.onEvent);
+  }
+  /**
+   * Shared combine validation: normalize the participant specs, enforce ≥1
+   * participant with unique ids, require ≥1 message, and reject tool calling
+   * (no strategy supports it). Returns the resolved roster, the participant ids,
+   * and the first participant's id (the default consensus synthesizer).
+   */
+  #prepare(request) {
+    const normalized = request.participants.map(
+      (spec) => normalizeParticipant(spec)
+    );
+    const [first] = normalized;
+    if (first === void 0) {
+      throw new Error("combine requires at least one participant");
+    }
+    const ids = normalized.map((p) => p.id);
+    if (new Set(ids).size !== ids.length) {
+      throw new Error(
+        `combine participant labels must be unique: ${ids.join(", ")}. Set a distinct \`label\` when two participants share a provider and model.`
+      );
+    }
+    if (request.messages.length === 0) {
+      throw new Error("combine requires at least one message");
+    }
+    if (request.tools !== void 0 || request.toolChoice !== void 0) {
+      throw new Error(
+        "combine does not support tool calling (tools/toolChoice); use registry.select() for a single-provider tool loop."
+      );
+    }
+    const roster = normalized.map((p) => ({
+      ...p,
+      provider: this.select(p.providerName)
+    }));
+    return { roster, ids, firstId: first.id };
+  }
+  /**
+   * Reject `responseFormat` on a non-ensemble strategy. It only means something
+   * for ensemble (where every participant answers under the schema); on the prose
+   * strategies it would be silently forwarded, so reject it loudly instead.
+   */
+  #rejectResponseFormat(request, strategy) {
+    if (request.responseFormat !== void 0) {
+      throw new Error(
+        `responseFormat is only supported by the "ensemble" strategy, not "${strategy}".`
+      );
+    }
+  }
+  /** Validate the consensus-only request options (`minParticipants`, `synthesizer`). */
+  #validateConsensusOptions(request, ids) {
+    const { minParticipants } = request;
+    if (minParticipants !== void 0) {
+      if (!Number.isInteger(minParticipants) || minParticipants < 1) {
+        throw new Error("combine minParticipants must be a positive integer");
+      }
+      if (minParticipants > ids.length) {
+        throw new Error(
+          `combine minParticipants (${String(minParticipants)}) cannot exceed the number of participants (${String(ids.length)})`
+        );
+      }
+    }
+    if (request.synthesizer !== void 0 && !ids.includes(request.synthesizer)) {
+      throw new Error(
+        `Synthesizer "${request.synthesizer}" must be one of the participants: ${ids.join(", ")}`
+      );
+    }
+  }
+  /** Whether a provider is configured under `name`. */
+  has(name) {
+    return this.#providers.has(name);
+  }
+  /** The names of all configured providers. */
+  names() {
+    return [...this.#providers.keys()];
+  }
+  #configuredList() {
+    const names = this.names();
+    return names.length > 0 ? names.join(", ") : "(none)";
+  }
+};
+function normalizeParticipant(spec) {
+  if (typeof spec === "string") {
+    return { id: spec, providerName: spec };
+  }
+  if (spec.model?.trim() === "") {
+    throw new Error(
+      `combine participant for "${spec.provider}" has an empty model; omit \`model\` to use the default.`
+    );
+  }
+  if (spec.maxTokens !== void 0 && (!Number.isInteger(spec.maxTokens) || spec.maxTokens < 1)) {
+    throw new Error(
+      `combine participant for "${spec.provider}" has an invalid maxTokens (${String(spec.maxTokens)}); must be a positive integer.`
+    );
+  }
+  const id = spec.label ?? (spec.model === void 0 ? spec.provider : `${spec.provider}-${spec.model}`);
+  return {
+    id,
+    providerName: spec.provider,
+    model: spec.model,
+    maxTokens: spec.maxTokens
+  };
+}
+function constructCustom(name, custom) {
+  switch (custom.kind) {
+    case "openai-compatible":
+      return new OpenAIProvider(
+        {
+          apiKey: custom.apiKey,
+          baseUrl: custom.baseUrl,
+          model: custom.model,
+          headers: custom.headers,
+          retry: custom.retry
+        },
+        name
+      );
+    case "provider":
+      return custom.provider;
+    default: {
+      const unreachable = custom;
+      throw new Error(
+        `Unhandled custom provider kind: ${JSON.stringify(unreachable)}`
+      );
+    }
+  }
+}
+
+// src/errors.ts
+var ProviderError = class extends Error {
+  name = "ProviderError";
+  /** Which provider produced the failure. */
+  provider;
+  /** Transport failure (no response) vs API failure (error response). */
+  kind;
+  /** HTTP status for `kind: "api"`; `undefined` for transport failures. */
+  status;
+  /** Machine-readable code parsed from the error body, where the provider sends one. */
+  code;
+  /** Error category parsed from the body (Anthropic/OpenAI `type`, Gemini `status`). */
+  type;
+  /** The raw response body, for `kind: "api"`. */
+  body;
+  constructor(message, init) {
+    super(
+      message,
+      init.cause === void 0 ? void 0 : { cause: init.cause }
+    );
+    this.provider = init.provider;
+    this.kind = init.kind;
+    this.status = init.status;
+    this.code = init.code;
+    this.type = init.type;
+    this.body = init.body;
+  }
+};
+async function apiError(provider, response) {
+  const body = await response.text();
+  const { code, type } = parseErrorBody(body);
+  return new ProviderError(
+    `${provider} request failed (${String(response.status)}): ${body}`,
+    { provider, kind: "api", status: response.status, code, type, body }
+  );
+}
+function apiErrorFromBody(provider, status, data) {
+  const body = JSON.stringify(data);
+  const { code, type } = parseErrorFields(data);
+  return new ProviderError(
+    `${provider} request failed (${String(status)}): ${body}`,
+    { provider, kind: "api", status, code, type, body }
+  );
+}
+function aggregateError(message, causes) {
+  return causes.length > 0 ? new AggregateError(causes, message) : new Error(message);
+}
+function parseErrorBody(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return {};
+  }
+  return parseErrorFields(parsed);
+}
+function parseErrorFields(parsed) {
+  if (!isRecord2(parsed)) {
+    return {};
+  }
+  const error = isRecord2(parsed.error) ? parsed.error : parsed;
+  const code = typeof error.code === "string" ? error.code : void 0;
+  const type = typeof error.type === "string" ? error.type : typeof error.status === "string" ? error.status : void 0;
+  return { code, type };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+exports.ProviderError = ProviderError;
+exports.ProviderRegistry = ProviderRegistry;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map