@dogpile/sdk 0.1.0

package/dist/browser/index.js

@@ -0,0 +1,4493 @@
+const dogpileErrorCodes = [
+  "invalid-configuration",
+  "aborted",
+  "timeout",
+  "provider-authentication",
+  "provider-invalid-request",
+  "provider-invalid-response",
+  "provider-not-found",
+  "provider-rate-limited",
+  "provider-timeout",
+  "provider-unavailable",
+  "provider-unsupported",
+  "provider-error",
+  "unknown"
+];
+class DogpileErrorImpl extends Error {
+  name = "DogpileError";
+  /** Stable machine-readable error code. */
+  code;
+  /** Whether caller retry policy may safely retry the same operation. */
+  retryable;
+  /** Configured provider id associated with the failure, when available. */
+  providerId;
+  /** Optional serializable diagnostic detail. */
+  detail;
+  /** Original thrown value, if Dogpile wrapped a lower-level failure. */
+  cause;
+  constructor(options) {
+    super(options.message);
+    this.code = options.code;
+    if (options.retryable !== void 0) {
+      this.retryable = options.retryable;
+    }
+    if (options.providerId !== void 0) {
+      this.providerId = options.providerId;
+    }
+    if (options.detail !== void 0) {
+      this.detail = options.detail;
+    }
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Cross-realm guard for Dogpile public errors.
+   */
+  static isInstance(error) {
+    if (error instanceof DogpileErrorImpl) {
+      return true;
+    }
+    if (!isRecord$2(error)) {
+      return false;
+    }
+    return error.name === "DogpileError" && isDogpileErrorCode(error.code) && typeof error.message === "string";
+  }
+  /**
+   * JSON-safe representation for logs, traces, and observability tools.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      ...this.retryable !== void 0 ? { retryable: this.retryable } : {},
+      ...this.providerId !== void 0 ? { providerId: this.providerId } : {},
+      ...this.detail !== void 0 ? { detail: this.detail } : {}
+    };
+  }
+}
+const DogpileError = DogpileErrorImpl;
+function isDogpileErrorCode(value) {
+  return typeof value === "string" && dogpileErrorCodes.includes(value);
+}
+function isRecord$2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeProtocol(protocol) {
+  if (typeof protocol !== "string") {
+    return protocol;
+  }
+  switch (protocol) {
+    case "sequential":
+      return { kind: "sequential", maxTurns: 3 };
+    case "coordinator":
+      return { kind: "coordinator", maxTurns: 3 };
+    case "broadcast":
+      return { kind: "broadcast", maxRounds: 2 };
+    case "shared":
+      return { kind: "shared", maxTurns: 3 };
+  }
+}
+function defaultAgents() {
+  return [
+    { id: "agent-1", role: "planner", instructions: "Frame the mission and identify the important constraints." },
+    { id: "agent-2", role: "critic", instructions: "Stress-test the previous contribution and improve weak spots." },
+    { id: "agent-3", role: "synthesizer", instructions: "Produce the final useful answer from the accumulated work." }
+  ];
+}
+function orderAgentsForTemperature(agents, temperature, seed) {
+  if (temperature !== 0) {
+    return agents;
+  }
+  if (seed !== void 0) {
+    return [...agents].sort((left, right) => compareAgentsBySeededSelection(left, right, seed));
+  }
+  return [...agents].sort(compareAgentsByStableIdentity);
+}
+function compareAgentsBySeededSelection(left, right, seed) {
+  const leftScore = deterministicSelectionScore(seed, left);
+  const rightScore = deterministicSelectionScore(seed, right);
+  if (leftScore !== rightScore) {
+    return leftScore - rightScore;
+  }
+  return compareAgentsByStableIdentity(left, right);
+}
+function deterministicSelectionScore(seed, agent) {
+  return stableHash(`${String(seed)}\0${agent.id}\0${agent.role}\0${agent.instructions ?? ""}`);
+}
+function stableHash(input) {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function compareAgentsByStableIdentity(left, right) {
+  const idOrder = left.id.localeCompare(right.id);
+  if (idOrder !== 0) {
+    return idOrder;
+  }
+  const roleOrder = left.role.localeCompare(right.role);
+  if (roleOrder !== 0) {
+    return roleOrder;
+  }
+  return (left.instructions ?? "").localeCompare(right.instructions ?? "");
+}
+function tierTemperature(tier) {
+  switch (tier) {
+    case "fast":
+      return 0;
+    case "balanced":
+      return 0.2;
+    case "quality":
+      return 0.4;
+  }
+}
+function emptyCost() {
+  return { usd: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+}
+function addCost(left, right) {
+  return {
+    usd: left.usd + right.usd,
+    inputTokens: left.inputTokens + right.inputTokens,
+    outputTokens: left.outputTokens + right.outputTokens,
+    totalTokens: left.totalTokens + right.totalTokens
+  };
+}
+function createTranscriptLink(transcript) {
+  return {
+    kind: "trace-transcript",
+    entryCount: transcript.length,
+    lastEntryIndex: transcript.length === 0 ? null : transcript.length - 1
+  };
+}
+function createRunEventLog(runId, protocol, events) {
+  return {
+    kind: "run-event-log",
+    runId,
+    protocol,
+    eventTypes: events.map((event) => event.type),
+    eventCount: events.length,
+    events
+  };
+}
+function createRunUsage(cost) {
+  return {
+    usd: cost.usd,
+    inputTokens: cost.inputTokens,
+    outputTokens: cost.outputTokens,
+    totalTokens: cost.totalTokens
+  };
+}
+function createRunAccounting(options) {
+  const usage = createRunUsage(options.cost);
+  return {
+    kind: "run-accounting",
+    tier: options.tier,
+    ...options.budget ? { budget: options.budget } : {},
+    ...options.termination ? { termination: options.termination } : {},
+    usage,
+    cost: options.cost,
+    budgetStateChanges: createReplayTraceBudgetStateChanges(options.events),
+    ...options.budget?.maxUsd !== void 0 ? { usdCapUtilization: options.budget.maxUsd === 0 ? 0 : options.cost.usd / options.budget.maxUsd } : {},
+    ...options.budget?.maxTokens !== void 0 ? {
+      totalTokenCapUtilization: options.budget.maxTokens === 0 ? 0 : options.cost.totalTokens / options.budget.maxTokens
+    } : {}
+  };
+}
+function createRunMetadata(options) {
+  const firstEvent = options.events[0];
+  const lastEvent = options.events.at(-1);
+  return {
+    runId: options.runId,
+    protocol: options.protocol,
+    tier: options.tier,
+    modelProviderId: options.modelProviderId,
+    agentsUsed: options.agentsUsed,
+    startedAt: firstEvent?.at ?? "",
+    completedAt: lastEvent?.at ?? ""
+  };
+}
+function createReplayTraceRunInputs(options) {
+  return {
+    kind: "replay-trace-run-inputs",
+    intent: options.intent,
+    protocol: options.protocol,
+    tier: options.tier,
+    modelProviderId: options.modelProviderId,
+    agents: options.agents,
+    temperature: options.temperature
+  };
+}
+function createReplayTraceBudget(options) {
+  return {
+    kind: "replay-trace-budget",
+    tier: options.tier,
+    ...options.caps ? { caps: options.caps } : {},
+    ...options.termination ? { termination: options.termination } : {}
+  };
+}
+function createReplayTraceBudgetStateChanges(events) {
+  return events.flatMap((event, eventIndex) => {
+    switch (event.type) {
+      case "agent-turn":
+      case "broadcast":
+      case "final":
+        return [
+          {
+            kind: "replay-trace-budget-state-change",
+            eventIndex,
+            eventType: event.type,
+            at: event.at,
+            cost: event.cost
+          }
+        ];
+      case "budget-stop":
+        return [
+          {
+            kind: "replay-trace-budget-state-change",
+            eventIndex,
+            eventType: event.type,
+            at: event.at,
+            cost: event.cost,
+            iteration: event.iteration,
+            elapsedMs: event.elapsedMs,
+            budgetReason: event.reason
+          }
+        ];
+      case "role-assignment":
+      case "model-request":
+      case "model-response":
+      case "model-output-chunk":
+      case "tool-call":
+      case "tool-result":
+        return [];
+    }
+  });
+}
+function createReplayTraceSeed(seed) {
+  if (seed === void 0) {
+    return {
+      kind: "replay-trace-seed",
+      source: "none",
+      value: null
+    };
+  }
+  return {
+    kind: "replay-trace-seed",
+    source: "caller",
+    value: seed
+  };
+}
+function createReplayTraceProtocolDecision(protocol, event, eventIndex, options = {}) {
+  const base = {
+    kind: "replay-trace-protocol-decision",
+    eventIndex,
+    eventType: event.type,
+    protocol,
+    decision: options.decision ?? defaultProtocolDecision(event),
+    at: event.at,
+    ...options.turn !== void 0 ? { turn: options.turn } : {},
+    ...options.phase !== void 0 ? { phase: options.phase } : {},
+    ...options.round !== void 0 ? { round: options.round } : {},
+    ...options.transcriptEntryCount !== void 0 ? { transcriptEntryCount: options.transcriptEntryCount } : {},
+    ...options.contributionCount !== void 0 ? { contributionCount: options.contributionCount } : {}
+  };
+  switch (event.type) {
+    case "role-assignment":
+      return {
+        ...base,
+        agentId: event.agentId,
+        role: event.role
+      };
+    case "model-request":
+      return {
+        ...base,
+        agentId: event.agentId,
+        role: event.role,
+        callId: event.callId,
+        providerId: event.providerId,
+        input: event.request.messages.map((message) => message.content).join("\n")
+      };
+    case "model-response":
+      return {
+        ...base,
+        agentId: event.agentId,
+        role: event.role,
+        callId: event.callId,
+        providerId: event.providerId,
+        output: event.response.text
+      };
+    case "model-output-chunk":
+      return {
+        ...base,
+        agentId: event.agentId,
+        role: event.role,
+        input: event.input,
+        output: event.output
+      };
+    case "tool-call":
+      return {
+        ...base,
+        toolCallId: event.toolCallId,
+        tool: event.tool,
+        input: stableJsonStringify(event.input),
+        ...eventAgentScope(event)
+      };
+    case "tool-result":
+      return {
+        ...base,
+        toolCallId: event.toolCallId,
+        tool: event.tool,
+        output: stableJsonStringify(event.result),
+        ...eventAgentScope(event)
+      };
+    case "agent-turn":
+      return {
+        ...base,
+        agentId: event.agentId,
+        role: event.role,
+        input: event.input,
+        output: event.output,
+        cost: event.cost
+      };
+    case "broadcast":
+      return {
+        ...base,
+        round: event.round,
+        contributionCount: options.contributionCount ?? event.contributions.length,
+        cost: event.cost
+      };
+    case "budget-stop":
+      return {
+        ...base,
+        cost: event.cost,
+        budgetReason: event.reason
+      };
+    case "final":
+      return {
+        ...base,
+        output: event.output,
+        cost: event.cost
+      };
+  }
+}
+function defaultProtocolDecision(event) {
+  switch (event.type) {
+    case "role-assignment":
+      return "assign-role";
+    case "model-request":
+      return "start-model-call";
+    case "model-response":
+      return "complete-model-call";
+    case "model-output-chunk":
+      return "observe-model-output";
+    case "tool-call":
+      return "start-tool-call";
+    case "tool-result":
+      return "complete-tool-call";
+    case "agent-turn":
+      return "select-agent-turn";
+    case "broadcast":
+      return "collect-broadcast-round";
+    case "budget-stop":
+      return "stop-for-budget";
+    case "final":
+      return "finalize-output";
+  }
+}
+function eventAgentScope(event) {
+  return {
+    ...event.agentId !== void 0 ? { agentId: event.agentId } : {},
+    ...event.role !== void 0 ? { role: event.role } : {}
+  };
+}
+function createReplayTraceFinalOutput(output, event) {
+  if (event.type === "final") {
+    return {
+      kind: "replay-trace-final-output",
+      output,
+      cost: event.cost,
+      completedAt: event.at,
+      transcript: event.transcript
+    };
+  }
+  return {
+    kind: "replay-trace-final-output",
+    output,
+    cost: emptyCost(),
+    completedAt: event.at,
+    transcript: {
+      kind: "trace-transcript",
+      entryCount: 0,
+      lastEntryIndex: null
+    }
+  };
+}
+function nextProviderCallId(runId, providerCalls) {
+  return `${runId}:provider-call:${providerCalls.length + 1}`;
+}
+function canonicalizeRunResult(result) {
+  const trace = canonicalizeSerializable(result.trace);
+  const eventLog = {
+    eventCount: trace.events.length,
+    eventTypes: trace.events.map((event) => event.type),
+    events: trace.events,
+    kind: "run-event-log",
+    protocol: trace.protocol,
+    runId: trace.runId
+  };
+  const canonicalResult = {
+    accounting: canonicalizeSerializable(result.accounting),
+    cost: canonicalizeSerializable(result.cost),
+    ...result.evaluation !== void 0 ? { evaluation: canonicalizeSerializable(result.evaluation) } : {},
+    eventLog,
+    metadata: canonicalizeSerializable(result.metadata),
+    output: result.output,
+    ...result.quality !== void 0 ? { quality: canonicalizeSerializable(result.quality) } : {},
+    trace,
+    transcript: trace.transcript,
+    usage: canonicalizeSerializable(result.usage)
+  };
+  return canonicalResult;
+}
+function stableJsonStringify(value) {
+  return JSON.stringify(canonicalizeSerializable(value));
+}
+function canonicalizeSerializable(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalizeSerializable(item));
+  }
+  if (typeof value === "number") {
+    if (Object.is(value, -0)) {
+      return 0;
+    }
+    if (!Number.isFinite(value)) {
+      return null;
+    }
+    return value;
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const input = value;
+  const output = {};
+  for (const key of Object.keys(input).sort()) {
+    const child = input[key];
+    if (child !== void 0) {
+      output[key] = canonicalizeSerializable(child);
+    }
+  }
+  return output;
+}
+function throwIfAborted(signal, providerId) {
+  if (!signal?.aborted) {
+    return;
+  }
+  throw createAbortErrorFromSignal(signal, providerId);
+}
+function createAbortError(providerId, detail, cause) {
+  return new DogpileError({
+    code: "aborted",
+    message: "The operation was aborted.",
+    retryable: false,
+    providerId,
+    ...{},
+    ...cause !== void 0 ? { cause } : {}
+  });
+}
+function createAbortErrorFromSignal(signal, providerId) {
+  if (DogpileError.isInstance(signal.reason)) {
+    return signal.reason;
+  }
+  return createAbortError(providerId, void 0, signal.reason);
+}
+function createTimeoutError(providerId, timeoutMs) {
+  return new DogpileError({
+    code: "timeout",
+    message: `The operation timed out after ${timeoutMs}ms.`,
+    retryable: true,
+    providerId,
+    detail: {
+      timeoutMs
+    }
+  });
+}
+function parseAgentDecision(output) {
+  const selectedRole = matchLine(output, /^role_selected:\s*(.+)$/imu);
+  const participation = matchLine(output, /^participation:\s*(contribute|abstain)$/imu);
+  const rationale = matchLine(output, /^rationale:\s*(.+)$/imu);
+  const contribution = matchContribution(output);
+  if (!selectedRole || !participation || !isAgentParticipation(participation) || !rationale || !contribution) {
+    return void 0;
+  }
+  return {
+    selectedRole,
+    participation,
+    rationale,
+    contribution
+  };
+}
+function isParticipatingDecision(decision) {
+  return decision?.participation !== "abstain";
+}
+function matchLine(output, pattern) {
+  const match = output.match(pattern);
+  return match?.[1]?.trim();
+}
+function matchContribution(output) {
+  const match = output.match(/^contribution:\s*\n([\s\S]*)$/imu);
+  const contribution = match?.[1]?.trim();
+  return contribution && contribution.length > 0 ? contribution : void 0;
+}
+function isAgentParticipation(value) {
+  return value === "contribute" || value === "abstain";
+}
+async function generateModelTurn(options) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let response;
+  throwIfAborted(options.request.signal, options.model.id);
+  if (!options.model.stream) {
+    response = await options.model.generate(options.request);
+    throwIfAborted(options.request.signal, options.model.id);
+    recordProviderCall(response, startedAt, options);
+    return response;
+  }
+  let text = "";
+  let chunkIndex = 0;
+  let usage;
+  let costUsd;
+  let finishReason;
+  let toolRequests;
+  let metadata;
+  for await (const chunk of options.model.stream(options.request)) {
+    throwIfAborted(options.request.signal, options.model.id);
+    text += chunk.text;
+    options.emit({
+      type: "model-output-chunk",
+      runId: options.runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId: options.agent.id,
+      role: options.agent.role,
+      input: options.input,
+      chunkIndex,
+      text: chunk.text,
+      output: text
+    });
+    chunkIndex += 1;
+    if (chunk.usage) {
+      usage = chunk.usage;
+    }
+    if (chunk.costUsd !== void 0) {
+      costUsd = chunk.costUsd;
+    }
+    if (chunk.finishReason !== void 0) {
+      finishReason = chunk.finishReason;
+    }
+    if (chunk.toolRequests !== void 0) {
+      toolRequests = chunk.toolRequests;
+    }
+    if (chunk.metadata !== void 0) {
+      metadata = chunk.metadata;
+    }
+  }
+  response = {
+    text,
+    ...finishReason !== void 0 ? { finishReason } : {},
+    ...toolRequests && toolRequests.length > 0 ? { toolRequests } : {},
+    ...usage ? { usage } : {},
+    ...costUsd !== void 0 ? { costUsd } : {},
+    ...metadata !== void 0 ? { metadata } : {}
+  };
+  throwIfAborted(options.request.signal, options.model.id);
+  recordProviderCall(response, startedAt, options);
+  return response;
+}
+function recordProviderCall(response, startedAt, options) {
+  options.onProviderCall?.({
+    kind: "replay-trace-provider-call",
+    callId: options.callId,
+    providerId: options.model.id,
+    startedAt,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    agentId: options.agent.id,
+    role: options.agent.role,
+    request: requestForTrace(options.request),
+    response
+  });
+}
+function requestForTrace(request) {
+  return {
+    messages: request.messages,
+    temperature: request.temperature,
+    metadata: request.metadata
+  };
+}
+function budget(options) {
+  return {
+    kind: "budget",
+    ...options
+  };
+}
+function convergence(options) {
+  return {
+    kind: "convergence",
+    ...options
+  };
+}
+function judge(options) {
+  return {
+    kind: "judge",
+    ...options
+  };
+}
+function firstOf(...conditions) {
+  if (conditions.length === 0) {
+    throw new RangeError("firstOf requires at least one termination condition.");
+  }
+  return {
+    kind: "firstOf",
+    conditions
+  };
+}
+function evaluateTermination(condition, context) {
+  switch (condition.kind) {
+    case "budget":
+      return evaluateBudget(condition, context);
+    case "firstOf":
+      return evaluateFirstOf(condition, context).decision;
+    case "convergence":
+      return evaluateConvergence(condition, context);
+    case "judge":
+      return evaluateJudge(condition, context);
+  }
+}
+function evaluateFirstOf(condition, context) {
+  const evaluated = [];
+  for (const [index, child] of condition.conditions.entries()) {
+    const decision = evaluateTermination(child, context);
+    evaluated.push(decision);
+    if (decision.type === "stop") {
+      return {
+        kind: "firstOf-output",
+        decision,
+        winningConditionIndex: index,
+        evaluated
+      };
+    }
+  }
+  return {
+    kind: "firstOf-output",
+    decision: { type: "continue", condition },
+    winningConditionIndex: null,
+    evaluated
+  };
+}
+function evaluateTerminationStop(condition, context) {
+  if (condition.kind === "firstOf") {
+    const output = evaluateFirstOf(condition, context);
+    if (output.decision.type !== "stop" || output.winningConditionIndex === null) {
+      return null;
+    }
+    const winningCondition = condition.conditions[output.winningConditionIndex];
+    if (!winningCondition) {
+      throw new RangeError("firstOf stop referenced a missing winning condition.");
+    }
+    return stopRecord(condition, output.decision, {
+      kind: "firstOf-stop",
+      winningConditionIndex: output.winningConditionIndex,
+      winningCondition,
+      firedCondition: output.decision.condition,
+      evaluated: output.evaluated
+    });
+  }
+  const decision = evaluateTermination(condition, context);
+  if (decision.type !== "stop") {
+    return null;
+  }
+  return stopRecord(condition, decision);
+}
+function combineTerminationDecisions(decisions) {
+  const stopDecisions = decisions.filter((decision) => decision.type === "stop");
+  if (stopDecisions.length === 0) {
+    const firstDecision = decisions[0];
+    if (!firstDecision) {
+      throw new RangeError("combineTerminationDecisions requires at least one decision.");
+    }
+    return firstDecision;
+  }
+  return stopDecisions.reduce(
+    (winner, candidate) => stopPrecedence(candidate.normalizedReason) < stopPrecedence(winner.normalizedReason) ? candidate : winner
+  );
+}
+function evaluateBudget(condition, context) {
+  const iteration = context.iteration ?? context.transcript.length;
+  const elapsedMs2 = context.elapsedMs ?? 0;
+  const costStop = stopIfReached(condition, "maxUsd", "cost", context.cost.usd);
+  if (costStop) {
+    return costStop;
+  }
+  const tokenStop = stopIfReached(condition, "maxTokens", "tokens", context.cost.totalTokens);
+  if (tokenStop) {
+    return tokenStop;
+  }
+  const iterationStop = stopIfReached(condition, "maxIterations", "iterations", iteration);
+  if (iterationStop) {
+    return iterationStop;
+  }
+  const timeoutStop = stopIfReached(condition, "timeoutMs", "timeout", elapsedMs2);
+  if (timeoutStop) {
+    return timeoutStop;
+  }
+  return { type: "continue", condition };
+}
+function evaluateConvergence(condition, context) {
+  const stableTurns = Math.max(1, Math.ceil(condition.stableTurns));
+  if (context.transcript.length < stableTurns) {
+    return { type: "continue", condition };
+  }
+  const recentEntries = context.transcript.slice(-stableTurns);
+  const recentOutputs = recentEntries.map((entry) => entry.output);
+  const similarities = consecutiveSimilarities(recentEntries);
+  const observedSimilarity = similarities.length === 0 ? 1 : Math.min(...similarities);
+  if (observedSimilarity < condition.minSimilarity) {
+    return { type: "continue", condition };
+  }
+  return {
+    type: "stop",
+    condition,
+    reason: "convergence",
+    normalizedReason: "convergence",
+    detail: {
+      protocol: context.protocol,
+      stableTurns,
+      minSimilarity: condition.minSimilarity,
+      observedSimilarity,
+      outputs: recentOutputs
+    }
+  };
+}
+function evaluateJudge(condition, context) {
+  const decision = context.judgeDecision ?? scoreDecisionFromQuality(context.quality);
+  if (!decision) {
+    return { type: "continue", condition };
+  }
+  switch (decision.type) {
+    case "accept":
+      return judgeStop(condition, "accepted", decision);
+    case "reject":
+      return judgeStop(condition, "rejected", decision);
+    case "score": {
+      const minScore = condition.minScore;
+      if (minScore !== void 0 && decision.score < minScore) {
+        return { type: "continue", condition };
+      }
+      return judgeStop(condition, "score-threshold", decision, minScore);
+    }
+  }
+}
+function stopIfReached(condition, cap, reason, observed) {
+  const limit = condition[cap];
+  if (limit === void 0 || observed < limit) {
+    return null;
+  }
+  return {
+    type: "stop",
+    condition,
+    reason: "budget",
+    normalizedReason: normalizeBudgetStopReason(reason),
+    budgetReason: reason,
+    detail: {
+      cap,
+      limit,
+      observed
+    }
+  };
+}
+function scoreDecisionFromQuality(quality) {
+  if (quality === void 0) {
+    return null;
+  }
+  return {
+    type: "score",
+    score: quality
+  };
+}
+function judgeStop(condition, judgeReason, decision, minScore) {
+  return {
+    type: "stop",
+    condition,
+    reason: "judge",
+    normalizedReason: normalizeJudgeStopReason(judgeReason),
+    judgeReason,
+    detail: judgeStopDetail(decision, minScore)
+  };
+}
+function normalizeBudgetStopReason(reason) {
+  switch (reason) {
+    case "cost":
+      return "budget:cost";
+    case "tokens":
+      return "budget:tokens";
+    case "iterations":
+      return "budget:iterations";
+    case "timeout":
+      return "budget:timeout";
+  }
+}
+function normalizeJudgeStopReason(reason) {
+  switch (reason) {
+    case "accepted":
+      return "judge:accepted";
+    case "rejected":
+      return "judge:rejected";
+    case "score-threshold":
+      return "judge:score-threshold";
+  }
+}
+function stopPrecedence(reason) {
+  if (reason.startsWith("budget:")) {
+    return 0;
+  }
+  if (reason.startsWith("judge:")) {
+    return 1;
+  }
+  return 2;
+}
+function judgeStopDetail(decision, minScore) {
+  return {
+    decision: decision.type,
+    ...decision.score !== void 0 ? { score: decision.score } : {},
+    ...minScore !== void 0 ? { minScore } : {},
+    ...decision.rationale !== void 0 ? { rationale: decision.rationale } : {},
+    ...decision.metadata !== void 0 ? { metadata: decision.metadata } : {}
+  };
+}
+function stopRecord(rootCondition, decision, firstOfRecord) {
+  return {
+    kind: "termination-stop",
+    rootCondition,
+    firedCondition: decision.condition,
+    reason: decision.reason,
+    normalizedReason: decision.normalizedReason,
+    ...decision.budgetReason !== void 0 ? { budgetReason: decision.budgetReason } : {},
+    ...decision.judgeReason !== void 0 ? { judgeReason: decision.judgeReason } : {},
+    ...decision.detail !== void 0 ? { detail: decision.detail } : {},
+    ...firstOfRecord !== void 0 ? { firstOf: firstOfRecord } : {}
+  };
+}
+function consecutiveSimilarities(entries) {
+  const similarities = [];
+  for (let index = 1; index < entries.length; index += 1) {
+    const previous = entries[index - 1];
+    const current = entries[index];
+    if (previous && current) {
+      similarities.push(outputSimilarity(previous.output, current.output));
+    }
+  }
+  return similarities;
+}
+function outputSimilarity(left, right) {
+  const normalizedLeft = normalizeOutput(left);
+  const normalizedRight = normalizeOutput(right);
+  if (normalizedLeft === normalizedRight) {
+    return 1;
+  }
+  const leftTokens = tokenize(normalizedLeft);
+  const rightTokens = tokenize(normalizedRight);
+  if (leftTokens.length === 0 || rightTokens.length === 0) {
+    return 0;
+  }
+  const leftSet = new Set(leftTokens);
+  const rightSet = new Set(rightTokens);
+  let intersection = 0;
+  for (const token of leftSet) {
+    if (rightSet.has(token)) {
+      intersection += 1;
+    }
+  }
+  const union = (/* @__PURE__ */ new Set([...leftSet, ...rightSet])).size;
+  return union === 0 ? 0 : intersection / union;
+}
+function normalizeOutput(output) {
+  return output.trim().toLowerCase();
+}
+function tokenize(output) {
+  return output.split(/[^a-z0-9]+/u).filter((token) => token.length > 0);
+}
+const protocolNames = ["coordinator", "sequential", "broadcast", "shared"];
+const budgetTiers = ["fast", "balanced", "quality"];
+function validateDogpileOptions(options) {
+  requireRecord(options, "options");
+  validateMissionIntent(options.intent);
+  if (options.protocol !== void 0) {
+    validateProtocolSelection(options.protocol, "protocol");
+  }
+  if (options.tier !== void 0) {
+    validateBudgetTier(options.tier, "tier");
+  }
+  validateModelProviderRegistration(options.model, "model");
+  validateOptionalAgents(options.agents, "agents");
+  validateOptionalRuntimeTools(options.tools, "tools");
+  validateOptionalTemperature(options.temperature, "temperature");
+  validateOptionalBudgetCaps(options.budget, "budget");
+  validateOptionalTerminationCondition(options.terminate, "terminate");
+  validateOptionalFunction(options.evaluate, "evaluate");
+  validateOptionalSeed(options.seed, "seed");
+  validateOptionalAbortSignal(options.signal, "signal");
+}
+function validateMissionIntent(intent, path = "intent") {
+  validateNonEmptyString(intent, path, "intent is required.");
+}
+function validateEngineOptions(options) {
+  requireRecord(options, "options");
+  validateProtocolSelection(options.protocol, "protocol");
+  validateBudgetTier(options.tier, "tier");
+  validateModelProviderRegistration(options.model, "model");
+  validateOptionalAgents(options.agents, "agents");
+  validateOptionalRuntimeTools(options.tools, "tools");
+  validateOptionalTemperature(options.temperature, "temperature");
+  validateOptionalBudgetCaps(options.budget, "budget");
+  validateOptionalTerminationCondition(options.terminate, "terminate");
+  validateOptionalFunction(options.evaluate, "evaluate");
+  validateOptionalSeed(options.seed, "seed");
+  validateOptionalAbortSignal(options.signal, "signal");
+}
+function validateProtocolSelection(value, path) {
+  if (typeof value === "string") {
+    if (!isProtocolName(value)) {
+      invalidConfiguration({
+        path,
+        rule: "enum",
+        message: "protocol must be one of coordinator, sequential, broadcast, or shared.",
+        expected: protocolNames.join(" | "),
+        actual: value
+      });
+    }
+    return;
+  }
+  validateProtocolConfig(value, path);
+}
+function validateProtocolConfig(value, path) {
+  const record = requireRecord(value, path);
+  const kind = record.kind;
+  if (!isProtocolName(kind)) {
+    invalidConfiguration({
+      path: `${path}.kind`,
+      rule: "enum",
+      message: "protocol config kind must be one of coordinator, sequential, broadcast, or shared.",
+      expected: protocolNames.join(" | "),
+      actual: kind
+    });
+  }
+  switch (kind) {
+    case "coordinator":
+    case "sequential":
+    case "shared":
+      validateOptionalPositiveInteger(record.maxTurns, `${path}.maxTurns`);
+      if (kind === "shared") {
+        validateOptionalString(record.organizationalMemory, `${path}.organizationalMemory`);
+      }
+      return;
+    case "broadcast":
+      validateOptionalPositiveInteger(record.maxRounds, `${path}.maxRounds`);
+      return;
+  }
+}
+function validateBudgetTier(value, path) {
+  if (!isBudgetTier(value)) {
+    invalidConfiguration({
+      path,
+      rule: "enum",
+      message: "tier must be one of fast, balanced, or quality.",
+      expected: budgetTiers.join(" | "),
+      actual: value
+    });
+  }
+}
+function validateModelProviderRegistration(value, path = "model") {
+  const record = requireRecord(value, path);
+  validateNonEmptyString(record.id, `${path}.id`, "model.id is required.");
+  validateFunction(record.generate, `${path}.generate`);
+  validateOptionalFunction(record.stream, `${path}.stream`);
+}
+function validateOptionalAgents(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  if (!Array.isArray(value)) {
+    invalidConfiguration({
+      path,
+      rule: "array",
+      message: "agents must be an array when provided.",
+      expected: "readonly AgentSpec[]",
+      actual: value
+    });
+  }
+  if (value.length === 0) {
+    invalidConfiguration({
+      path,
+      rule: "array",
+      message: "agents must contain at least one participant when provided.",
+      expected: "non-empty readonly AgentSpec[]",
+      actual: value
+    });
+  }
+  value.forEach((agent, index) => {
+    const agentPath = `${path}[${index}]`;
+    const record = requireRecord(agent, agentPath);
+    validateNonEmptyString(record.id, `${agentPath}.id`, "agent.id is required.");
+    validateNonEmptyString(record.role, `${agentPath}.role`, "agent.role is required.");
+    validateOptionalString(record.instructions, `${agentPath}.instructions`);
+  });
+}
+function validateOptionalRuntimeTools(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  validateRuntimeToolRegistrations(value, path);
+}
+function validateRuntimeToolRegistrations(value, path = "tools") {
+  if (!Array.isArray(value)) {
+    invalidConfiguration({
+      path,
+      rule: "array",
+      message: "tools must be an array when provided.",
+      expected: "readonly RuntimeTool[]",
+      actual: value
+    });
+  }
+  value.forEach((tool, index) => validateRuntimeTool(tool, `${path}[${index}]`));
+}
+function validateRuntimeTool(value, path) {
+  const record = requireRecord(value, path);
+  const identity = requireRecord(record.identity, `${path}.identity`);
+  validateNonEmptyString(identity.id, `${path}.identity.id`, "tool identity id is required.");
+  validateNonEmptyString(identity.name, `${path}.identity.name`, "tool identity name is required.");
+  validateOptionalString(identity.namespace, `${path}.identity.namespace`);
+  validateOptionalString(identity.version, `${path}.identity.version`);
+  validateOptionalString(identity.description, `${path}.identity.description`);
+  const inputSchema = requireRecord(record.inputSchema, `${path}.inputSchema`);
+  if (inputSchema.kind !== "json-schema") {
+    invalidConfiguration({
+      path: `${path}.inputSchema.kind`,
+      rule: "runtime-tool",
+      message: "tool inputSchema.kind must be json-schema.",
+      expected: "json-schema",
+      actual: inputSchema.kind
+    });
+  }
+  validateJsonObject(inputSchema.schema, `${path}.inputSchema.schema`);
+  validateOptionalString(inputSchema.description, `${path}.inputSchema.description`);
+  validateOptionalArray(record.permissions, `${path}.permissions`);
+  validateOptionalFunction(record.validateInput, `${path}.validateInput`);
+  validateFunction(record.execute, `${path}.execute`);
+}
+function validateOptionalBudgetCaps(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  validateBudgetCaps(value, path);
+}
+function validateBudgetCaps(value, path) {
+  const record = requireRecord(value, path);
+  validateOptionalNonNegativeNumber(record.maxUsd, `${path}.maxUsd`);
+  validateOptionalNonNegativeInteger(record.maxTokens, `${path}.maxTokens`);
+  validateOptionalNonNegativeInteger(record.maxIterations, `${path}.maxIterations`);
+  validateOptionalNonNegativeInteger(record.timeoutMs, `${path}.timeoutMs`);
+  validateOptionalNumberInRange(record.qualityWeight, `${path}.qualityWeight`, 0, 1);
+}
+function validateOptionalTerminationCondition(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  validateTerminationCondition(value, path, /* @__PURE__ */ new Set());
+}
+function validateTerminationCondition(value, path, stack) {
+  const record = requireRecord(value, path);
+  if (stack.has(record)) {
+    invalidConfiguration({
+      path,
+      rule: "termination-condition",
+      message: "termination conditions must not contain cycles.",
+      expected: "acyclic termination condition",
+      actual: value
+    });
+  }
+  stack.add(record);
+  try {
+    switch (record.kind) {
+      case "budget":
+        validateBudgetCaps(record, path);
+        return;
+      case "convergence":
+        validatePositiveInteger(record.stableTurns, `${path}.stableTurns`);
+        validateNumberInRange(record.minSimilarity, `${path}.minSimilarity`, 0, 1);
+        return;
+      case "judge":
+        validateJudgeRubric(record.rubric, `${path}.rubric`);
+        validateOptionalNumberInRange(record.minScore, `${path}.minScore`, 0, 1);
+        return;
+      case "firstOf":
+        validateFirstOfConditions(record.conditions, `${path}.conditions`, stack);
+        return;
+      default:
+        invalidConfiguration({
+          path: `${path}.kind`,
+          rule: "termination-condition",
+          message: "termination condition kind must be budget, convergence, judge, or firstOf.",
+          expected: "budget | convergence | judge | firstOf",
+          actual: record.kind
+        });
+    }
+  } finally {
+    stack.delete(record);
+  }
+}
+function validateFirstOfConditions(value, path, stack) {
+  if (!Array.isArray(value)) {
+    invalidConfiguration({
+      path,
+      rule: "array",
+      message: "firstOf conditions must be a non-empty array.",
+      expected: "non-empty termination condition array",
+      actual: value
+    });
+  }
+  if (value.length === 0) {
+    invalidConfiguration({
+      path,
+      rule: "array",
+      message: "firstOf conditions must contain at least one condition.",
+      expected: "non-empty termination condition array",
+      actual: value
+    });
+  }
+  value.forEach((condition, index) => {
+    validateTerminationCondition(condition, `${path}[${index}]`, stack);
+  });
+}
+function validateJudgeRubric(value, path) {
+  if (typeof value === "string") {
+    validateNonEmptyString(value, path, "judge rubric must not be empty.");
+    return;
+  }
+  validateJsonObject(value, path);
+}
+function validateOptionalTemperature(value, path) {
+  validateOptionalNumberInRange(value, path, 0, 2);
+}
+function validateOptionalSeed(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value === "string") {
+    return;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return;
+  }
+  invalidConfiguration({
+    path,
+    rule: "finite-number",
+    message: "seed must be a string or finite number when provided.",
+    expected: "string or finite number",
+    actual: value
+  });
+}
+function validateJsonObject(value, path) {
+  if (!isJsonValue$1(value, /* @__PURE__ */ new Set()) || !isRecord$1(value)) {
+    invalidConfiguration({
+      path,
+      rule: "json-object",
+      message: "value must be a JSON-compatible object.",
+      expected: "JSON-compatible object",
+      actual: value
+    });
+  }
+}
+function isJsonValue$1(value, stack) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return true;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value);
+  }
+  if (Array.isArray(value)) {
+    if (stack.has(value)) {
+      return false;
+    }
+    stack.add(value);
+    const valid = value.every((child) => isJsonValue$1(child, stack));
+    stack.delete(value);
+    return valid;
+  }
+  if (isRecord$1(value)) {
+    if (stack.has(value)) {
+      return false;
+    }
+    stack.add(value);
+    const valid = Object.values(value).every((child) => isJsonValue$1(child, stack));
+    stack.delete(value);
+    return valid;
+  }
+  return false;
+}
+function validateOptionalString(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "string") {
+    invalidConfiguration({
+      path,
+      rule: "non-empty-string",
+      message: "value must be a string when provided.",
+      expected: "string",
+      actual: value
+    });
+  }
+}
+function validateNonEmptyString(value, path, message) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    invalidConfiguration({
+      path,
+      rule: "non-empty-string",
+      message,
+      expected: "non-empty string",
+      actual: value
+    });
+  }
+}
+function validateOptionalFunction(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  validateFunction(value, path);
+}
+function validateFunction(value, path) {
+  if (typeof value !== "function") {
+    invalidConfiguration({
+      path,
+      rule: "function",
+      message: "value must be a function.",
+      expected: "function",
+      actual: value
+    });
+  }
+}
+function validateOptionalArray(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  if (!Array.isArray(value)) {
+    invalidConfiguration({
+      path,
+      rule: "array",
+      message: "value must be an array when provided.",
+      expected: "array",
+      actual: value
+    });
+  }
+}
+function validateOptionalAbortSignal(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  if (!isAbortSignalLike(value)) {
+    invalidConfiguration({
+      path,
+      rule: "abort-signal",
+      message: "value must be an AbortSignal when provided.",
+      expected: "AbortSignal",
+      actual: value
+    });
+  }
+}
+function isAbortSignalLike(value) {
+  if (!isRecord$1(value)) {
+    return false;
+  }
+  return typeof value.aborted === "boolean" && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function";
+}
+function validateOptionalPositiveInteger(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  validatePositiveInteger(value, path);
+}
+function validatePositiveInteger(value, path) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    invalidConfiguration({
+      path,
+      rule: "positive-integer",
+      message: "value must be a positive integer.",
+      expected: "integer >= 1",
+      actual: value
+    });
+  }
+}
+function validateOptionalNonNegativeInteger(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    invalidConfiguration({
+      path,
+      rule: "non-negative-integer",
+      message: "value must be a non-negative integer.",
+      expected: "integer >= 0",
+      actual: value
+    });
+  }
+}
+function validateOptionalNonNegativeNumber(value, path) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    invalidConfiguration({
+      path,
+      rule: "non-negative-number",
+      message: "value must be a non-negative finite number.",
+      expected: "finite number >= 0",
+      actual: value
+    });
+  }
+}
+function validateOptionalNumberInRange(value, path, min, max) {
+  if (value === void 0) {
+    return;
+  }
+  validateNumberInRange(value, path, min, max);
+}
+function validateNumberInRange(value, path, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) {
+    invalidConfiguration({
+      path,
+      rule: "range",
+      message: `value must be a finite number in the inclusive range ${min}..${max}.`,
+      expected: `finite number in ${min}..${max}`,
+      actual: value
+    });
+  }
+}
+function requireRecord(value, path) {
+  if (!isRecord$1(value)) {
+    invalidConfiguration({
+      path,
+      rule: "object",
+      message: "value must be an object.",
+      expected: "object",
+      actual: value
+    });
+  }
+  return value;
+}
+function invalidConfiguration(options) {
+  throw new DogpileError({
+    code: "invalid-configuration",
+    message: `Invalid Dogpile configuration at ${options.path}: ${options.message}`,
+    retryable: false,
+    detail: {
+      kind: "configuration-validation",
+      path: options.path,
+      rule: options.rule,
+      expected: options.expected,
+      received: describeValue(options.actual)
+    }
+  });
+}
+function isProtocolName(value) {
+  return typeof value === "string" && protocolNames.includes(value);
+}
+function isBudgetTier(value) {
+  return typeof value === "string" && budgetTiers.includes(value);
+}
+function isRecord$1(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describeValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return String(value);
+  }
+  return typeof value;
+}
+const webSearchIdentity = {
+  id: "dogpile.tools.webSearch",
+  namespace: "dogpile",
+  name: "webSearch",
+  version: "1.0.0",
+  description: "Search the web through a caller-provided fetch-compatible search adapter."
+};
+const codeExecIdentity = {
+  id: "dogpile.tools.codeExec",
+  namespace: "dogpile",
+  name: "codeExec",
+  version: "1.0.0",
+  description: "Execute code through a caller-provided sandbox adapter."
+};
+const webSearchInputSchema = {
+  kind: "json-schema",
+  description: "Web search query and optional result cap.",
+  schema: {
+    type: "object",
+    properties: {
+      query: { type: "string" },
+      maxResults: { type: "number", minimum: 1 }
+    },
+    required: ["query"],
+    additionalProperties: false
+  }
+};
+const codeExecInputSchema = {
+  kind: "json-schema",
+  description: "Code snippet plus language and optional timeout.",
+  schema: {
+    type: "object",
+    properties: {
+      language: {
+        type: "string",
+        enum: ["javascript", "typescript", "python", "bash", "shell"]
+      },
+      code: { type: "string" },
+      timeoutMs: { type: "number", minimum: 1 }
+    },
+    required: ["language", "code"],
+    additionalProperties: false
+  }
+};
+const webSearchPermissions = [
+  {
+    kind: "network",
+    allowPrivateNetwork: false
+  }
+];
+const codeExecPermissions = [
+  {
+    kind: "code-execution",
+    sandbox: "caller-provided",
+    languages: ["javascript", "typescript", "python", "bash", "shell"],
+    allowNetwork: false
+  }
+];
+const codeExecLanguages = ["javascript", "typescript", "python", "bash", "shell"];
+function builtInDogpileToolIdentity(name) {
+  return name === "webSearch" ? webSearchIdentity : codeExecIdentity;
+}
+function builtInDogpileToolInputSchema(name) {
+  return name === "webSearch" ? webSearchInputSchema : codeExecInputSchema;
+}
+function builtInDogpileToolPermissions(name) {
+  return name === "webSearch" ? webSearchPermissions : codeExecPermissions;
+}
+function validateBuiltInDogpileToolInput(name, input) {
+  const issues = name === "webSearch" ? validateWebSearchInput(input) : validateCodeExecInput(input);
+  return issues.length === 0 ? { type: "valid" } : { type: "invalid", issues };
+}
+function createRuntimeToolExecutor(options) {
+  validateRuntimeToolRegistrations(options.tools);
+  const tools = Array.from(options.tools);
+  let callCount = 0;
+  return {
+    tools,
+    async execute(request) {
+      const tool = tools.find((candidate) => candidate.identity.id === request.toolId);
+      const identity = tool?.identity ?? {
+        id: request.toolId,
+        name: request.toolId
+      };
+      const callIndex = callCount;
+      callCount += 1;
+      const toolCallId = request.toolCallId ?? options.makeToolCallId?.(identity, callIndex) ?? defaultToolCallId(options.runId, callIndex);
+      const context = createExecutionContext(options, request, toolCallId);
+      options.emit?.({
+        type: "tool-call",
+        runId: options.runId,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        toolCallId,
+        tool: identity,
+        input: request.input,
+        ...request.agentId ? { agentId: request.agentId } : {},
+        ...request.role ? { role: request.role } : {}
+      });
+      const result = await executeRuntimeTool(tool, identity, request.input, context);
+      options.emit?.({
+        type: "tool-result",
+        runId: options.runId,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        toolCallId,
+        tool: identity,
+        result,
+        ...request.agentId ? { agentId: request.agentId } : {},
+        ...request.role ? { role: request.role } : {}
+      });
+      return result;
+    }
+  };
+}
+function runtimeToolManifest(tools) {
+  return tools.map((tool) => {
+    const inputSchema = {
+      kind: tool.inputSchema.kind,
+      schema: tool.inputSchema.schema,
+      ...tool.inputSchema.description ? { description: tool.inputSchema.description } : {}
+    };
+    return {
+      identity: runtimeToolIdentityManifest(tool.identity),
+      inputSchema,
+      permissions: Array.from(tool.permissions ?? []).map(runtimeToolPermissionManifest)
+    };
+  });
+}
+function runtimeToolAvailability(tools) {
+  const manifest = runtimeToolManifest(tools);
+  return manifest.length > 0 ? { tools: manifest } : {};
+}
+async function executeModelResponseToolRequests(options) {
+  const toolCalls = [];
+  for (const request of options.response.toolRequests ?? []) {
+    const result = await options.executor.execute({
+      ...request,
+      agentId: request.agentId ?? options.agentId,
+      role: request.role ?? options.role,
+      turn: request.turn ?? options.turn,
+      metadata: mergeToolMetadata(options.metadata, request.metadata)
+    });
+    toolCalls.push({
+      toolCallId: result.toolCallId,
+      tool: result.tool,
+      input: request.input,
+      result
+    });
+  }
+  return toolCalls;
+}
+function runtimeToolIdentityManifest(identity) {
+  return {
+    id: identity.id,
+    name: identity.name,
+    ...identity.namespace ? { namespace: identity.namespace } : {},
+    ...identity.version ? { version: identity.version } : {},
+    ...identity.description ? { description: identity.description } : {}
+  };
+}
+function runtimeToolPermissionManifest(permission) {
+  if (permission.kind === "network") {
+    return {
+      kind: permission.kind,
+      ...permission.allowHosts ? { allowHosts: Array.from(permission.allowHosts) } : {},
+      ...permission.allowPrivateNetwork === void 0 ? {} : { allowPrivateNetwork: permission.allowPrivateNetwork }
+    };
+  }
+  if (permission.kind === "code-execution") {
+    return {
+      kind: permission.kind,
+      sandbox: permission.sandbox,
+      ...permission.languages ? { languages: Array.from(permission.languages) } : {},
+      ...permission.allowNetwork === void 0 ? {} : { allowNetwork: permission.allowNetwork }
+    };
+  }
+  return {
+    kind: permission.kind,
+    name: permission.name,
+    ...permission.description ? { description: permission.description } : {},
+    ...permission.metadata ? { metadata: permission.metadata } : {}
+  };
+}
+function validateCodeExecAdapterInput(input, options) {
+  const issues = [...validateCodeExecInput(input)];
+  const languages = options.languages ?? codeExecLanguages;
+  if (typeof input.language === "string" && isCodeExecLanguage(input.language) && !languages.includes(input.language)) {
+    issues.push({
+      code: "invalid-value",
+      path: "language",
+      message: "codeExec.language is not enabled for this adapter.",
+      detail: {
+        allowed: Array.from(languages)
+      }
+    });
+  }
+  const effectiveTimeoutMs = input.timeoutMs ?? options.defaultTimeoutMs;
+  if (effectiveTimeoutMs !== void 0 && options.maxTimeoutMs !== void 0 && Number.isFinite(effectiveTimeoutMs) && Number.isFinite(options.maxTimeoutMs) && effectiveTimeoutMs > options.maxTimeoutMs) {
+    issues.push({
+      code: "out-of-range",
+      path: input.timeoutMs === void 0 ? "defaultTimeoutMs" : "timeoutMs",
+      message: `codeExec.timeoutMs must be less than or equal to ${options.maxTimeoutMs}.`,
+      detail: {
+        maximum: options.maxTimeoutMs
+      }
+    });
+  }
+  return issues.length === 0 ? { type: "valid" } : { type: "invalid", issues };
+}
+function createExecutionContext(options, request, toolCallId) {
+  return {
+    runId: options.runId,
+    toolCallId,
+    protocol: options.protocol,
+    tier: options.tier,
+    ...request.agentId ? { agentId: request.agentId } : {},
+    ...request.role ? { role: request.role } : {},
+    ...request.turn !== void 0 ? { turn: request.turn } : {},
+    ...options.getTrace ? { trace: options.getTrace() } : {},
+    ...request.abortSignal ?? options.abortSignal ? { abortSignal: request.abortSignal ?? options.abortSignal } : {},
+    ...options.metadata || request.metadata ? { metadata: mergeToolMetadata(options.metadata, request.metadata) } : {}
+  };
+}
+async function executeRuntimeTool(tool, identity, input, context) {
+  if (!tool) {
+    return {
+      type: "error",
+      toolCallId: context.toolCallId,
+      tool: identity,
+      error: {
+        code: "unavailable",
+        message: `Runtime tool "${identity.id}" is not registered.`,
+        retryable: false
+      }
+    };
+  }
+  const validation = validateRuntimeToolInput(tool, input);
+  if (validation.type === "invalid") {
+    return {
+      type: "error",
+      toolCallId: context.toolCallId,
+      tool: identity,
+      error: {
+        code: "invalid-input",
+        message: "Runtime tool input failed validation.",
+        retryable: false,
+        detail: {
+          issues: validation.issues.map((issue) => ({
+            code: issue.code,
+            path: issue.path,
+            message: issue.message,
+            ...issue.detail ? { detail: issue.detail } : {}
+          }))
+        }
+      }
+    };
+  }
+  try {
+    return await tool.execute(input, context);
+  } catch (error) {
+    return {
+      type: "error",
+      toolCallId: context.toolCallId,
+      tool: identity,
+      error: normalizeRuntimeToolAdapterError(error)
+    };
+  }
+}
+function validateRuntimeToolInput(tool, input) {
+  if (typeof tool.validateInput !== "function") {
+    return { type: "valid" };
+  }
+  return tool.validateInput(input);
+}
+function mergeToolMetadata(base, request) {
+  return {
+    ...base ?? {},
+    ...request ?? {}
+  };
+}
+function defaultToolCallId(runId, callIndex) {
+  return `${runId}:tool-${callIndex + 1}`;
+}
+function normalizeRuntimeToolAdapterError(error) {
+  if (isRuntimeToolAdapterError(error)) {
+    return error;
+  }
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return {
+      code: "aborted",
+      message: error.message || "Tool execution was aborted.",
+      retryable: true,
+      detail: {
+        name: error.name
+      }
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      code: "backend-error",
+      message: error.message,
+      retryable: false,
+      detail: {
+        name: error.name
+      }
+    };
+  }
+  return {
+    code: "unknown",
+    message: "Tool execution failed with a non-Error value.",
+    retryable: false,
+    detail: {
+      valueType: typeof error
+    }
+  };
+}
+function createWebSearchToolAdapter(options) {
+  const identity = mergeIdentity(webSearchIdentity, options.identity);
+  return normalizeBuiltInDogpileTool({
+    name: "webSearch",
+    ...options.identity ? { identity: options.identity } : {},
+    ...options.permissions ? { permissions: options.permissions } : {},
+    async execute(input, context) {
+      const fetchImplementation = options.fetch ?? globalThis.fetch;
+      if (!fetchImplementation) {
+        return {
+          type: "error",
+          toolCallId: context.toolCallId,
+          tool: identity,
+          error: {
+            code: "unavailable",
+            message: "No fetch implementation is available for webSearch.",
+            retryable: false
+          }
+        };
+      }
+      const request = options.buildRequest ? options.buildRequest(input, context) : defaultWebSearchRequest(options, input);
+      const response = await fetchImplementation(request.url, {
+        ...request.init,
+        ...context.abortSignal ? { signal: context.abortSignal } : {}
+      });
+      if (!response.ok) {
+        throw {
+          code: response.status >= 500 ? "unavailable" : "backend-error",
+          message: `Web search backend returned HTTP ${response.status}.`,
+          retryable: response.status === 408 || response.status === 429 || response.status >= 500,
+          detail: {
+            status: response.status,
+            statusText: response.statusText
+          }
+        };
+      }
+      const output = options.parseResponse ? await options.parseResponse(response, input, context) : await defaultWebSearchResponseParser(response);
+      return {
+        type: "success",
+        toolCallId: context.toolCallId,
+        tool: identity,
+        output
+      };
+    }
+  });
+}
+function createCodeExecToolAdapter(options) {
+  const identity = mergeIdentity(codeExecIdentity, options.identity);
+  const permissions = options.permissions ?? codeExecPermissionsFor(options.languages ?? codeExecLanguages, options.allowNetwork ?? false);
+  const inputSchema = codeExecInputSchemaFor(options.languages ?? codeExecLanguages);
+  return {
+    identity,
+    inputSchema,
+    permissions,
+    validateInput: (input) => validateCodeExecAdapterInput(input, options),
+    async execute(input, context) {
+      const validation = validateCodeExecAdapterInput(input, options);
+      if (validation.type === "invalid") {
+        return {
+          type: "error",
+          toolCallId: context.toolCallId,
+          tool: identity,
+          error: {
+            code: "invalid-input",
+            message: "Invalid codeExec tool input.",
+            retryable: false,
+            detail: {
+              issues: validation.issues
+            }
+          }
+        };
+      }
+      const timeoutMs = input.timeoutMs ?? options.defaultTimeoutMs;
+      const executionInput = timeoutMs === void 0 ? input : {
+        ...input,
+        timeoutMs
+      };
+      try {
+        const output = await executeSandboxWithPolicy(options.execute, executionInput, context, timeoutMs);
+        return {
+          type: "success",
+          toolCallId: context.toolCallId,
+          tool: identity,
+          output
+        };
+      } catch (error) {
+        return {
+          type: "error",
+          toolCallId: context.toolCallId,
+          tool: identity,
+          error: normalizeRuntimeToolAdapterError(error)
+        };
+      }
+    }
+  };
+}
+function normalizeBuiltInDogpileTool(definition) {
+  switch (definition.name) {
+    case "webSearch": {
+      const identity = mergeIdentity(webSearchIdentity, definition.identity);
+      const permissions = definition.permissions ?? webSearchPermissions;
+      const tool = {
+        identity,
+        inputSchema: definition.inputSchema ?? webSearchInputSchema,
+        permissions,
+        validateInput: (input) => validateBuiltInDogpileToolInput("webSearch", input),
+        execute: (input, context) => executeBuiltInTool(identity, definition.execute, input, context, "webSearch")
+      };
+      return tool;
+    }
+    case "codeExec": {
+      const identity = mergeIdentity(codeExecIdentity, definition.identity);
+      const permissions = definition.permissions ?? codeExecPermissions;
+      const tool = {
+        identity,
+        inputSchema: definition.inputSchema ?? codeExecInputSchema,
+        permissions,
+        validateInput: (input) => validateBuiltInDogpileToolInput("codeExec", input),
+        execute: (input, context) => executeBuiltInTool(identity, definition.execute, input, context, "codeExec")
+      };
+      return tool;
+    }
+  }
+}
+function normalizeBuiltInDogpileTools(tools) {
+  const normalized = [];
+  if (tools.webSearch) {
+    normalized.push(normalizeBuiltInDogpileTool(asWebSearchDefinition(tools.webSearch)));
+  }
+  if (tools.codeExec) {
+    normalized.push(normalizeBuiltInDogpileTool(asCodeExecDefinition(tools.codeExec)));
+  }
+  return normalized;
+}
+async function executeBuiltInTool(identity, execute, input, context, name) {
+  const validation = validateBuiltInDogpileToolInput(
+    name,
+    input
+  );
+  if (validation.type === "invalid") {
+    return {
+      type: "error",
+      toolCallId: context.toolCallId,
+      tool: identity,
+      error: {
+        code: "invalid-input",
+        message: `Invalid ${name} tool input.`,
+        retryable: false,
+        detail: {
+          issues: validation.issues
+        }
+      }
+    };
+  }
+  try {
+    return await execute(input, context);
+  } catch (error) {
+    return {
+      type: "error",
+      toolCallId: context.toolCallId,
+      tool: identity,
+      error: normalizeRuntimeToolAdapterError(error)
+    };
+  }
+}
+function asWebSearchDefinition(tool) {
+  return typeof tool === "function" ? { name: "webSearch", execute: tool } : tool;
+}
+function asCodeExecDefinition(tool) {
+  return typeof tool === "function" ? { name: "codeExec", execute: tool } : tool;
+}
+function mergeIdentity(defaultIdentity, options) {
+  if (!options) {
+    return defaultIdentity;
+  }
+  return {
+    ...defaultIdentity,
+    ...options.namespace !== void 0 ? { namespace: options.namespace } : {},
+    ...options.version !== void 0 ? { version: options.version } : {},
+    ...options.description !== void 0 ? { description: options.description } : {}
+  };
+}
+function defaultWebSearchRequest(options, input, _context) {
+  const url = new URL(String(options.endpoint));
+  url.searchParams.set("q", input.query);
+  url.searchParams.set("limit", String(input.maxResults ?? options.defaultMaxResults ?? 10));
+  return {
+    url,
+    init: {
+      method: "GET",
+      ...options.headers ? { headers: options.headers } : {}
+    }
+  };
+}
+async function defaultWebSearchResponseParser(response) {
+  const payload = await response.json();
+  const resultValues = Array.isArray(payload) ? payload : isJsonObject(payload) && Array.isArray(payload.results) ? payload.results : void 0;
+  if (!resultValues) {
+    throw {
+      code: "backend-error",
+      message: "Web search backend response must contain a results array.",
+      retryable: false
+    };
+  }
+  return {
+    results: resultValues.map(normalizeWebSearchResult)
+  };
+}
+function codeExecPermissionsFor(languages, allowNetwork) {
+  return [
+    {
+      kind: "code-execution",
+      sandbox: "caller-provided",
+      languages,
+      allowNetwork
+    }
+  ];
+}
+function codeExecInputSchemaFor(languages) {
+  return {
+    kind: "json-schema",
+    ...codeExecInputSchema.description ? { description: codeExecInputSchema.description } : {},
+    schema: {
+      type: "object",
+      properties: {
+        language: {
+          type: "string",
+          enum: Array.from(languages)
+        },
+        code: { type: "string" },
+        timeoutMs: { type: "number", minimum: 1 }
+      },
+      required: ["language", "code"],
+      additionalProperties: false
+    }
+  };
+}
+async function executeSandboxWithPolicy(execute, input, context, timeoutMs) {
+  if (context.abortSignal?.aborted) {
+    throw {
+      code: "aborted",
+      message: "Code execution was aborted before the sandbox started.",
+      retryable: true
+    };
+  }
+  const execution = Promise.resolve().then(() => execute(input, context));
+  if (timeoutMs === void 0 && context.abortSignal === void 0) {
+    return await execution;
+  }
+  return await new Promise((resolve, reject) => {
+    let timeoutId;
+    const cleanup = () => {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+      context.abortSignal?.removeEventListener("abort", abortHandler);
+    };
+    const abortHandler = () => {
+      cleanup();
+      reject({
+        code: "aborted",
+        message: "Code execution was aborted.",
+        retryable: true
+      });
+    };
+    if (context.abortSignal) {
+      context.abortSignal.addEventListener("abort", abortHandler, { once: true });
+    }
+    if (timeoutMs !== void 0) {
+      timeoutId = setTimeout(() => {
+        cleanup();
+        reject({
+          code: "timeout",
+          message: `Code execution exceeded timeout of ${timeoutMs}ms.`,
+          retryable: true,
+          detail: {
+            timeoutMs
+          }
+        });
+      }, timeoutMs);
+    }
+    execution.then(
+      (output) => {
+        cleanup();
+        resolve(output);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+  });
+}
+function normalizeWebSearchResult(value) {
+  if (!isJsonObject(value)) {
+    throw {
+      code: "backend-error",
+      message: "Web search result must be a JSON object.",
+      retryable: false
+    };
+  }
+  const title = jsonString(value.title, "title");
+  const url = jsonString(value.url, "url");
+  const snippet = optionalJsonString(value.snippet, "snippet");
+  const metadata = optionalJsonObject(value.metadata, "metadata");
+  return {
+    title,
+    url,
+    ...snippet !== void 0 ? { snippet } : {},
+    ...metadata !== void 0 ? { metadata } : {}
+  };
+}
+function jsonString(value, fieldName) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw {
+      code: "backend-error",
+      message: `Web search result ${fieldName} must be a non-empty string.`,
+      retryable: false
+    };
+  }
+  return value;
+}
+function optionalJsonString(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw {
+      code: "backend-error",
+      message: `Web search result ${fieldName} must be a string when present.`,
+      retryable: false
+    };
+  }
+  return value;
+}
+function optionalJsonObject(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isJsonObject(value)) {
+    throw {
+      code: "backend-error",
+      message: `Web search result ${fieldName} must be a JSON object when present.`,
+      retryable: false
+    };
+  }
+  return value;
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateWebSearchInput(input) {
+  const issues = [];
+  if (typeof input.query !== "string") {
+    issues.push({
+      code: input.query === void 0 ? "missing-field" : "invalid-type",
+      path: "query",
+      message: "webSearch.query must be a string."
+    });
+  } else if (input.query.trim().length === 0) {
+    issues.push({
+      code: "invalid-value",
+      path: "query",
+      message: "webSearch.query must not be empty."
+    });
+  }
+  if (input.maxResults !== void 0) {
+    if (typeof input.maxResults !== "number" || !Number.isFinite(input.maxResults)) {
+      issues.push({
+        code: "invalid-type",
+        path: "maxResults",
+        message: "webSearch.maxResults must be a finite number."
+      });
+    } else if (input.maxResults < 1) {
+      issues.push({
+        code: "out-of-range",
+        path: "maxResults",
+        message: "webSearch.maxResults must be greater than or equal to 1.",
+        detail: {
+          minimum: 1
+        }
+      });
+    }
+  }
+  return issues;
+}
+function validateCodeExecInput(input) {
+  const issues = [];
+  if (typeof input.language !== "string") {
+    issues.push({
+      code: input.language === void 0 ? "missing-field" : "invalid-type",
+      path: "language",
+      message: "codeExec.language must be a string."
+    });
+  } else if (!isCodeExecLanguage(input.language)) {
+    issues.push({
+      code: "invalid-value",
+      path: "language",
+      message: "codeExec.language must be one of javascript, typescript, python, bash, or shell.",
+      detail: {
+        allowed: ["javascript", "typescript", "python", "bash", "shell"]
+      }
+    });
+  }
+  if (typeof input.code !== "string") {
+    issues.push({
+      code: input.code === void 0 ? "missing-field" : "invalid-type",
+      path: "code",
+      message: "codeExec.code must be a string."
+    });
+  }
+  if (input.timeoutMs !== void 0) {
+    if (typeof input.timeoutMs !== "number" || !Number.isFinite(input.timeoutMs)) {
+      issues.push({
+        code: "invalid-type",
+        path: "timeoutMs",
+        message: "codeExec.timeoutMs must be a finite number."
+      });
+    } else if (input.timeoutMs < 1) {
+      issues.push({
+        code: "out-of-range",
+        path: "timeoutMs",
+        message: "codeExec.timeoutMs must be greater than or equal to 1.",
+        detail: {
+          minimum: 1
+        }
+      });
+    }
+  }
+  return issues;
+}
+function isCodeExecLanguage(value) {
+  return value === "javascript" || value === "typescript" || value === "python" || value === "bash" || value === "shell";
+}
+function isRuntimeToolAdapterError(error) {
+  if (typeof error !== "object" || error === null || !("code" in error) || !("message" in error)) {
+    return false;
+  }
+  const candidate = error;
+  return isRuntimeToolAdapterErrorCode(candidate.code) && typeof candidate.message === "string";
+}
+function isRuntimeToolAdapterErrorCode(value) {
+  return value === "invalid-input" || value === "permission-denied" || value === "timeout" || value === "aborted" || value === "unavailable" || value === "backend-error" || value === "unknown";
+}
+async function runBroadcast(options) {
+  const runId = createRunId$3();
+  const events = [];
+  const transcript = [];
+  const protocolDecisions = [];
+  const providerCalls = [];
+  let totalCost = emptyCost();
+  const maxRounds = options.protocol.maxRounds ?? 2;
+  let firstRoundContributions = [];
+  let lastContributions = [];
+  const startedAtMs = nowMs$3();
+  let stopped = false;
+  let termination;
+  const emit = (event) => {
+    events.push(event);
+    options.emit?.(event);
+  };
+  const recordProtocolDecision = (event, decisionOptions) => {
+    protocolDecisions.push(
+      createReplayTraceProtocolDecision("broadcast", event, events.length - 1, decisionOptions)
+    );
+  };
+  const toolExecutor = createRuntimeToolExecutor({
+    runId,
+    protocol: "broadcast",
+    tier: options.tier,
+    tools: options.tools,
+    emit(event) {
+      emit(event);
+      recordProtocolDecision(event);
+    },
+    getTrace: () => ({ events, transcript }),
+    ...options.signal !== void 0 ? { abortSignal: options.signal } : {}
+  });
+  const toolAvailability = runtimeToolAvailability(toolExecutor.tools);
+  throwIfAborted(options.signal, options.model.id);
+  for (const agent of options.agents) {
+    const event = {
+      type: "role-assignment",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId: agent.id,
+      role: agent.role
+    };
+    emit(event);
+    recordProtocolDecision(event);
+  }
+  for (let round = 1; round <= maxRounds; round += 1) {
+    if (stopIfNeeded()) {
+      break;
+    }
+    const providerCallSlots = [];
+    const turnResults = await Promise.all(
+      options.agents.map(async (agent, agentIndex) => {
+        const turn = transcript.length + agentIndex + 1;
+        const input = buildBroadcastInput(options.intent, round, maxRounds, firstRoundContributions);
+        const request = {
+          temperature: options.temperature,
+          ...options.signal !== void 0 ? { signal: options.signal } : {},
+          metadata: {
+            runId,
+            protocol: "broadcast",
+            agentId: agent.id,
+            role: agent.role,
+            tier: options.tier,
+            round,
+            ...toolAvailability
+          },
+          messages: [
+            {
+              role: "system",
+              content: buildSystemPrompt$3(agent)
+            },
+            {
+              role: "user",
+              content: input
+            }
+          ]
+        };
+        const response = await generateModelTurn({
+          model: options.model,
+          request,
+          runId,
+          agent,
+          input,
+          emit,
+          callId: providerCallIdFor$2(runId, providerCalls.length + agentIndex + 1),
+          onProviderCall(call) {
+            providerCallSlots[agentIndex] = call;
+          }
+        });
+        const decision = parseAgentDecision(response.text);
+        const toolCalls = await executeModelResponseToolRequests({
+          response,
+          executor: toolExecutor,
+          agentId: agent.id,
+          role: agent.role,
+          turn,
+          metadata: {
+            round
+          }
+        });
+        throwIfAborted(options.signal, options.model.id);
+        return {
+          agent,
+          agentIndex,
+          turn,
+          input,
+          response,
+          decision,
+          toolCalls,
+          turnCost: responseCost$3(response)
+        };
+      })
+    );
+    providerCalls.push(...providerCallSlots.filter((call) => call !== void 0));
+    const contributions = [];
+    for (const result of turnResults) {
+      totalCost = addCost(totalCost, result.turnCost);
+      transcript.push({
+        agentId: result.agent.id,
+        role: result.agent.role,
+        input: result.input,
+        output: result.response.text,
+        ...result.decision !== void 0 ? { decision: result.decision } : {},
+        ...result.toolCalls.length > 0 ? { toolCalls: result.toolCalls } : {}
+      });
+      contributions.push({
+        agentId: result.agent.id,
+        role: result.agent.role,
+        output: result.response.text,
+        ...result.decision !== void 0 ? { decision: result.decision } : {}
+      });
+      const event = {
+        type: "agent-turn",
+        runId,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        agentId: result.agent.id,
+        role: result.agent.role,
+        input: result.input,
+        output: result.response.text,
+        ...result.decision !== void 0 ? { decision: result.decision } : {},
+        cost: totalCost
+      };
+      emit(event);
+      recordProtocolDecision(event, {
+        round,
+        turn: result.turn,
+        transcriptEntryCount: transcript.length,
+        contributionCount: result.agentIndex + 1
+      });
+    }
+    if (contributions.length === 0) {
+      break;
+    }
+    if (round === 1) {
+      firstRoundContributions = contributions;
+    }
+    lastContributions = contributions;
+    const broadcast = {
+      type: "broadcast",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      round,
+      contributions,
+      cost: totalCost
+    };
+    emit(broadcast);
+    recordProtocolDecision(broadcast, {
+      round,
+      transcriptEntryCount: transcript.length,
+      contributionCount: contributions.length
+    });
+    if (stopIfNeeded()) {
+      break;
+    }
+  }
+  const output = synthesizeBroadcastOutput(lastContributions);
+  throwIfAborted(options.signal, options.model.id);
+  const final = {
+    type: "final",
+    runId,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    output,
+    cost: totalCost,
+    transcript: createTranscriptLink(transcript),
+    ...termination !== void 0 ? { termination } : {}
+  };
+  emit(final);
+  recordProtocolDecision(final, {
+    transcriptEntryCount: transcript.length
+  });
+  const finalEvent = events.at(-1);
+  return {
+    output,
+    eventLog: createRunEventLog(runId, "broadcast", events),
+    trace: {
+      schemaVersion: "1.0",
+      runId,
+      protocol: "broadcast",
+      tier: options.tier,
+      modelProviderId: options.model.id,
+      agentsUsed: options.agents,
+      inputs: createReplayTraceRunInputs({
+        intent: options.intent,
+        protocol: options.protocol,
+        tier: options.tier,
+        modelProviderId: options.model.id,
+        agents: options.agents,
+        temperature: options.temperature
+      }),
+      budget: createReplayTraceBudget({
+        tier: options.tier,
+        ...options.budget ? { caps: options.budget } : {},
+        ...options.terminate ? { termination: options.terminate } : {}
+      }),
+      budgetStateChanges: createReplayTraceBudgetStateChanges(events),
+      seed: createReplayTraceSeed(options.seed),
+      protocolDecisions,
+      providerCalls,
+      finalOutput: createReplayTraceFinalOutput(output, finalEvent ?? {
+        type: "final",
+        at: "",
+        cost: totalCost,
+        transcript: createTranscriptLink(transcript)
+      }),
+      events,
+      transcript
+    },
+    transcript,
+    usage: createRunUsage(totalCost),
+    metadata: createRunMetadata({
+      runId,
+      protocol: "broadcast",
+      tier: options.tier,
+      modelProviderId: options.model.id,
+      agentsUsed: options.agents,
+      events
+    }),
+    accounting: createRunAccounting({
+      tier: options.tier,
+      ...options.budget ? { budget: options.budget } : {},
+      ...options.terminate ? { termination: options.terminate } : {},
+      cost: totalCost,
+      events
+    }),
+    cost: totalCost
+  };
+  function stopIfNeeded() {
+    throwIfAborted(options.signal, options.model.id);
+    if (stopped || !options.terminate) {
+      return stopped;
+    }
+    const stopRecord2 = evaluateTerminationStop(options.terminate, {
+      protocol: "broadcast",
+      tier: options.tier,
+      cost: totalCost,
+      transcript,
+      iteration: transcript.length,
+      elapsedMs: elapsedMs$3(startedAtMs)
+    });
+    if (!stopRecord2) {
+      return false;
+    }
+    stopped = true;
+    termination = stopRecord2;
+    if (stopRecord2.reason === "budget") {
+      emitBudgetStop(stopRecord2);
+    }
+    return true;
+  }
+  function emitBudgetStop(record) {
+    const event = {
+      type: "budget-stop",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: record.budgetReason ?? "cost",
+      cost: totalCost,
+      iteration: transcript.length,
+      elapsedMs: elapsedMs$3(startedAtMs),
+      detail: record.detail ?? {}
+    };
+    emit(event);
+    recordProtocolDecision(event, {
+      transcriptEntryCount: transcript.length
+    });
+  }
+}
+function buildSystemPrompt$3(agent) {
+  const instruction = agent.instructions ? `
+Instructions: ${agent.instructions}` : "";
+  return `You are ${agent.id}, acting as ${agent.role} in a Broadcast multi-agent protocol.${instruction}`;
+}
+function buildBroadcastInput(intent, round, maxRounds, firstRoundContributions) {
+  if (maxRounds === 1) {
+    return `Mission: ${intent}
+Broadcast round ${round}: contribute independently before synthesis.`;
+  }
+  if (round === 1) {
+    return `Mission: ${intent}
+Broadcast round 1: broadcast your intended role and participation decision. Do not produce the final plan yet.`;
+  }
+  const intentions = firstRoundContributions.map((contribution) => `${contribution.role}:${contribution.agentId} => ${contribution.output}`).join("\n");
+  return `Mission: ${intent}
+
+Round 1 intentions:
+${intentions || "(none)"}
+
+Broadcast round ${round}: make your final contribution or abstention decision informed by all round 1 intentions.`;
+}
+function synthesizeBroadcastOutput(contributions) {
+  return contributions.map((entry) => `${entry.role}:${entry.agentId} => ${entry.output}`).join("\n");
+}
+function responseCost$3(response) {
+  return {
+    usd: response.costUsd ?? 0,
+    inputTokens: response.usage?.inputTokens ?? 0,
+    outputTokens: response.usage?.outputTokens ?? 0,
+    totalTokens: response.usage?.totalTokens ?? 0
+  };
+}
+function createRunId$3() {
+  const random = globalThis.crypto?.randomUUID?.();
+  return random ?? `run-${Date.now().toString(36)}`;
+}
+function nowMs$3() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function elapsedMs$3(startedAtMs) {
+  return Math.max(0, nowMs$3() - startedAtMs);
+}
+function providerCallIdFor$2(runId, oneBasedIndex) {
+  return `${runId}:provider-call:${oneBasedIndex}`;
+}
+async function runCoordinator(options) {
+  const runId = createRunId$2();
+  const events = [];
+  const transcript = [];
+  const protocolDecisions = [];
+  const providerCalls = [];
+  let totalCost = emptyCost();
+  const maxTurns = options.protocol.maxTurns ?? options.agents.length;
+  const activeAgents = options.agents.slice(0, maxTurns);
+  const coordinator = activeAgents[0];
+  const startedAtMs = nowMs$2();
+  let stopped = false;
+  let termination;
+  const emit = (event) => {
+    events.push(event);
+    options.emit?.(event);
+  };
+  const recordProtocolDecision = (event, decisionOptions) => {
+    protocolDecisions.push(
+      createReplayTraceProtocolDecision("coordinator", event, events.length - 1, decisionOptions)
+    );
+  };
+  const toolExecutor = createRuntimeToolExecutor({
+    runId,
+    protocol: "coordinator",
+    tier: options.tier,
+    tools: options.tools,
+    emit(event) {
+      emit(event);
+      recordProtocolDecision(event);
+    },
+    getTrace: () => ({ events, transcript }),
+    ...options.signal !== void 0 ? { abortSignal: options.signal } : {}
+  });
+  const toolAvailability = runtimeToolAvailability(toolExecutor.tools);
+  throwIfAborted(options.signal, options.model.id);
+  for (const agent of activeAgents) {
+    const event = {
+      type: "role-assignment",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId: agent.id,
+      role: agent.role
+    };
+    emit(event);
+    recordProtocolDecision(event);
+  }
+  if (coordinator) {
+    if (!stopIfNeeded()) {
+      totalCost = await runCoordinatorTurn({
+        agent: coordinator,
+        coordinator,
+        input: buildCoordinatorPlanInput(options.intent, coordinator),
+        phase: "plan",
+        options,
+        runId,
+        transcript,
+        totalCost,
+        providerCalls,
+        toolExecutor,
+        toolAvailability,
+        emit,
+        recordProtocolDecision
+      });
+      stopIfNeeded();
+    }
+    if (!stopIfNeeded()) {
+      const workers = activeAgents.slice(1);
+      const providerCallSlots = [];
+      const planTranscript = [...transcript];
+      const workerResults = await Promise.all(
+        workers.map(
+          (agent, index) => runCoordinatorWorkerTurn({
+            agent,
+            coordinator,
+            input: buildWorkerInput(options.intent, planTranscript, coordinator),
+            options,
+            runId,
+            turn: transcript.length + index + 1,
+            providerCallId: providerCallIdFor$1(runId, providerCalls.length + index + 1),
+            providerCallIndex: index,
+            providerCallSlots,
+            toolExecutor,
+            toolAvailability,
+            emit
+          })
+        )
+      );
+      providerCalls.push(...providerCallSlots.filter((call) => call !== void 0));
+      for (const result of workerResults) {
+        totalCost = addCost(totalCost, result.turnCost);
+        transcript.push({
+          agentId: result.agent.id,
+          role: result.agent.role,
+          input: result.input,
+          output: result.response.text,
+          ...result.decision !== void 0 ? { decision: result.decision } : {},
+          ...result.toolCalls.length > 0 ? { toolCalls: result.toolCalls } : {}
+        });
+        const event = {
+          type: "agent-turn",
+          runId,
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          agentId: result.agent.id,
+          role: result.agent.role,
+          input: result.input,
+          output: result.response.text,
+          ...result.decision !== void 0 ? { decision: result.decision } : {},
+          cost: totalCost
+        };
+        emit(event);
+        recordProtocolDecision(event, {
+          turn: transcript.length,
+          phase: "worker",
+          transcriptEntryCount: transcript.length
+        });
+      }
+      stopIfNeeded();
+    }
+    if (!stopIfNeeded()) {
+      totalCost = await runCoordinatorTurn({
+        agent: coordinator,
+        coordinator,
+        input: buildFinalSynthesisInput(options.intent, transcript, coordinator),
+        phase: "final-synthesis",
+        options,
+        runId,
+        transcript,
+        totalCost,
+        providerCalls,
+        toolExecutor,
+        toolAvailability,
+        emit,
+        recordProtocolDecision
+      });
+      stopIfNeeded();
+    }
+  }
+  const output = transcript.at(-1)?.output ?? "";
+  throwIfAborted(options.signal, options.model.id);
+  const final = {
+    type: "final",
+    runId,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    output,
+    cost: totalCost,
+    transcript: createTranscriptLink(transcript),
+    ...termination !== void 0 ? { termination } : {}
+  };
+  emit(final);
+  recordProtocolDecision(final, {
+    transcriptEntryCount: transcript.length
+  });
+  const finalEvent = events.at(-1);
+  return {
+    output,
+    eventLog: createRunEventLog(runId, "coordinator", events),
+    trace: {
+      schemaVersion: "1.0",
+      runId,
+      protocol: "coordinator",
+      tier: options.tier,
+      modelProviderId: options.model.id,
+      agentsUsed: activeAgents,
+      inputs: createReplayTraceRunInputs({
+        intent: options.intent,
+        protocol: options.protocol,
+        tier: options.tier,
+        modelProviderId: options.model.id,
+        agents: activeAgents,
+        temperature: options.temperature
+      }),
+      budget: createReplayTraceBudget({
+        tier: options.tier,
+        ...options.budget ? { caps: options.budget } : {},
+        ...options.terminate ? { termination: options.terminate } : {}
+      }),
+      budgetStateChanges: createReplayTraceBudgetStateChanges(events),
+      seed: createReplayTraceSeed(options.seed),
+      protocolDecisions,
+      providerCalls,
+      finalOutput: createReplayTraceFinalOutput(output, finalEvent ?? {
+        type: "final",
+        at: "",
+        cost: totalCost,
+        transcript: createTranscriptLink(transcript)
+      }),
+      events,
+      transcript
+    },
+    transcript,
+    usage: createRunUsage(totalCost),
+    metadata: createRunMetadata({
+      runId,
+      protocol: "coordinator",
+      tier: options.tier,
+      modelProviderId: options.model.id,
+      agentsUsed: activeAgents,
+      events
+    }),
+    accounting: createRunAccounting({
+      tier: options.tier,
+      ...options.budget ? { budget: options.budget } : {},
+      ...options.terminate ? { termination: options.terminate } : {},
+      cost: totalCost,
+      events
+    }),
+    cost: totalCost
+  };
+  function stopIfNeeded() {
+    throwIfAborted(options.signal, options.model.id);
+    if (stopped || !options.terminate) {
+      return stopped;
+    }
+    const stopRecord2 = evaluateTerminationStop(options.terminate, {
+      protocol: "coordinator",
+      tier: options.tier,
+      cost: totalCost,
+      transcript,
+      iteration: transcript.length,
+      elapsedMs: elapsedMs$2(startedAtMs)
+    });
+    if (!stopRecord2) {
+      return false;
+    }
+    stopped = true;
+    termination = stopRecord2;
+    if (stopRecord2.reason === "budget") {
+      emitBudgetStop(stopRecord2);
+    }
+    return true;
+  }
+  function emitBudgetStop(record) {
+    const event = {
+      type: "budget-stop",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: record.budgetReason ?? "cost",
+      cost: totalCost,
+      iteration: transcript.length,
+      elapsedMs: elapsedMs$2(startedAtMs),
+      detail: record.detail ?? {}
+    };
+    emit(event);
+    recordProtocolDecision(event, {
+      transcriptEntryCount: transcript.length
+    });
+  }
+}
+async function runCoordinatorTurn(turn) {
+  throwIfAborted(turn.options.signal, turn.options.model.id);
+  const request = {
+    temperature: turn.options.temperature,
+    ...turn.options.signal !== void 0 ? { signal: turn.options.signal } : {},
+    metadata: {
+      runId: turn.runId,
+      protocol: "coordinator",
+      agentId: turn.agent.id,
+      role: turn.agent.role,
+      coordinatorAgentId: turn.coordinator.id,
+      tier: turn.options.tier,
+      phase: turn.phase,
+      ...turn.toolAvailability
+    },
+    messages: [
+      {
+        role: "system",
+        content: buildSystemPrompt$2(turn.agent, turn.coordinator)
+      },
+      {
+        role: "user",
+        content: turn.input
+      }
+    ]
+  };
+  const response = await generateModelTurn({
+    model: turn.options.model,
+    request,
+    runId: turn.runId,
+    agent: turn.agent,
+    input: turn.input,
+    emit: turn.emit,
+    callId: nextProviderCallId(turn.runId, turn.providerCalls),
+    onProviderCall(call) {
+      turn.providerCalls.push(call);
+    }
+  });
+  const decision = parseAgentDecision(response.text);
+  const totalCost = addCost(turn.totalCost, responseCost$2(response));
+  const toolCalls = await executeModelResponseToolRequests({
+    response,
+    executor: turn.toolExecutor,
+    agentId: turn.agent.id,
+    role: turn.agent.role,
+    turn: turn.transcript.length + 1,
+    metadata: {
+      phase: turn.phase
+    }
+  });
+  throwIfAborted(turn.options.signal, turn.options.model.id);
+  turn.transcript.push({
+    agentId: turn.agent.id,
+    role: turn.agent.role,
+    input: turn.input,
+    output: response.text,
+    ...decision !== void 0 ? { decision } : {},
+    ...toolCalls.length > 0 ? { toolCalls } : {}
+  });
+  const event = {
+    type: "agent-turn",
+    runId: turn.runId,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    agentId: turn.agent.id,
+    role: turn.agent.role,
+    input: turn.input,
+    output: response.text,
+    ...decision !== void 0 ? { decision } : {},
+    cost: totalCost
+  };
+  turn.emit(event);
+  turn.recordProtocolDecision(event, {
+    turn: turn.transcript.length,
+    phase: turn.phase,
+    transcriptEntryCount: turn.transcript.length
+  });
+  return totalCost;
+}
+async function runCoordinatorWorkerTurn(turn) {
+  throwIfAborted(turn.options.signal, turn.options.model.id);
+  const request = {
+    temperature: turn.options.temperature,
+    ...turn.options.signal !== void 0 ? { signal: turn.options.signal } : {},
+    metadata: {
+      runId: turn.runId,
+      protocol: "coordinator",
+      agentId: turn.agent.id,
+      role: turn.agent.role,
+      coordinatorAgentId: turn.coordinator.id,
+      tier: turn.options.tier,
+      phase: "worker",
+      ...turn.toolAvailability
+    },
+    messages: [
+      {
+        role: "system",
+        content: buildSystemPrompt$2(turn.agent, turn.coordinator)
+      },
+      {
+        role: "user",
+        content: turn.input
+      }
+    ]
+  };
+  const response = await generateModelTurn({
+    model: turn.options.model,
+    request,
+    runId: turn.runId,
+    agent: turn.agent,
+    input: turn.input,
+    emit: turn.emit,
+    callId: turn.providerCallId,
+    onProviderCall(call) {
+      turn.providerCallSlots[turn.providerCallIndex] = call;
+    }
+  });
+  const decision = parseAgentDecision(response.text);
+  const toolCalls = await executeModelResponseToolRequests({
+    response,
+    executor: turn.toolExecutor,
+    agentId: turn.agent.id,
+    role: turn.agent.role,
+    turn: turn.turn,
+    metadata: {
+      phase: "worker"
+    }
+  });
+  throwIfAborted(turn.options.signal, turn.options.model.id);
+  return {
+    agent: turn.agent,
+    input: turn.input,
+    response,
+    decision,
+    toolCalls,
+    turnCost: responseCost$2(response)
+  };
+}
+function buildSystemPrompt$2(agent, coordinator) {
+  const instruction = agent.instructions ? `
+Instructions: ${agent.instructions}` : "";
+  const coordinatorText = coordinator && agent.id === coordinator.id ? "You are the coordinator: assign work, integrate worker contributions, and produce the final answer." : `You are a worker managed by coordinator ${coordinator?.id ?? "unknown"}.`;
+  return `You are ${agent.id}, acting as ${agent.role} in a Coordinator multi-agent protocol. ${coordinatorText}${instruction}`;
+}
+function buildCoordinatorPlanInput(intent, coordinator) {
+  return `Mission: ${intent}
+Coordinator ${coordinator.id}: assign the work, name the plan, and provide the first contribution.`;
+}
+function buildWorkerInput(intent, transcript, coordinator) {
+  const prior = transcript.map((entry) => `${entry.role} (${entry.agentId}): ${entry.output}`).join("\n\n");
+  return `Mission: ${intent}
+
+Coordinator: ${coordinator.id}
+Prior contributions:
+${prior}
+
+Follow the coordinator-managed plan and provide your assigned contribution.`;
+}
+function buildFinalSynthesisInput(intent, transcript, coordinator) {
+  const prior = transcript.map((entry) => `${entry.role} (${entry.agentId}): ${entry.output}`).join("\n\n");
+  return `Mission: ${intent}
+
+Coordinator: ${coordinator.id}
+Prior contributions:
+${prior}
+
+Synthesize the final answer as the coordinator.`;
+}
+function responseCost$2(response) {
+  return {
+    usd: response.costUsd ?? 0,
+    inputTokens: response.usage?.inputTokens ?? 0,
+    outputTokens: response.usage?.outputTokens ?? 0,
+    totalTokens: response.usage?.totalTokens ?? 0
+  };
+}
+function createRunId$2() {
+  const random = globalThis.crypto?.randomUUID?.();
+  return random ?? `run-${Date.now().toString(36)}`;
+}
+function nowMs$2() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function elapsedMs$2(startedAtMs) {
+  return Math.max(0, nowMs$2() - startedAtMs);
+}
+function providerCallIdFor$1(runId, oneBasedIndex) {
+  return `${runId}:provider-call:${oneBasedIndex}`;
+}
+async function runSequential(options) {
+  const runId = createRunId$1();
+  const events = [];
+  const transcript = [];
+  const protocolDecisions = [];
+  const providerCalls = [];
+  let totalCost = emptyCost();
+  const maxTurns = options.protocol.maxTurns ?? options.agents.length;
+  const activeAgents = options.agents.slice(0, maxTurns);
+  const startedAtMs = nowMs$1();
+  let stopped = false;
+  let termination;
+  const emit = (event) => {
+    events.push(event);
+    options.emit?.(event);
+  };
+  const recordProtocolDecision = (event, decisionOptions) => {
+    protocolDecisions.push(
+      createReplayTraceProtocolDecision("sequential", event, events.length - 1, decisionOptions)
+    );
+  };
+  const toolExecutor = createRuntimeToolExecutor({
+    runId,
+    protocol: "sequential",
+    tier: options.tier,
+    tools: options.tools,
+    emit(event) {
+      emit(event);
+      recordProtocolDecision(event);
+    },
+    getTrace: () => ({ events, transcript }),
+    ...options.signal !== void 0 ? { abortSignal: options.signal } : {}
+  });
+  const toolAvailability = runtimeToolAvailability(toolExecutor.tools);
+  throwIfAborted(options.signal, options.model.id);
+  for (const agent of activeAgents) {
+    const event = {
+      type: "role-assignment",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId: agent.id,
+      role: agent.role
+    };
+    emit(event);
+    recordProtocolDecision(event);
+  }
+  for (const [index, agent] of activeAgents.entries()) {
+    if (stopIfNeeded()) {
+      break;
+    }
+    const turn = index + 1;
+    const input = buildSequentialInput(options.intent, transcript);
+    const request = {
+      temperature: options.temperature,
+      ...options.signal !== void 0 ? { signal: options.signal } : {},
+      metadata: {
+        runId,
+        protocol: "sequential",
+        agentId: agent.id,
+        role: agent.role,
+        tier: options.tier,
+        turn,
+        ...toolAvailability
+      },
+      messages: [
+        {
+          role: "system",
+          content: buildSystemPrompt$1(agent)
+        },
+        {
+          role: "user",
+          content: input
+        }
+      ]
+    };
+    const response = await generateModelTurn({
+      model: options.model,
+      request,
+      runId,
+      agent,
+      input,
+      emit,
+      callId: nextProviderCallId(runId, providerCalls),
+      onProviderCall(call) {
+        providerCalls.push(call);
+      }
+    });
+    const turnCost = responseCost$1(response);
+    totalCost = addCost(totalCost, turnCost);
+    const decision = parseAgentDecision(response.text);
+    const toolCalls = await executeModelResponseToolRequests({
+      response,
+      executor: toolExecutor,
+      agentId: agent.id,
+      role: agent.role,
+      turn
+    });
+    throwIfAborted(options.signal, options.model.id);
+    transcript.push({
+      agentId: agent.id,
+      role: agent.role,
+      input,
+      output: response.text,
+      ...decision !== void 0 ? { decision } : {},
+      ...toolCalls.length > 0 ? { toolCalls } : {}
+    });
+    const event = {
+      type: "agent-turn",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId: agent.id,
+      role: agent.role,
+      input,
+      output: response.text,
+      ...decision !== void 0 ? { decision } : {},
+      cost: totalCost
+    };
+    emit(event);
+    recordProtocolDecision(event, {
+      turn,
+      transcriptEntryCount: transcript.length
+    });
+    if (stopIfNeeded()) {
+      break;
+    }
+  }
+  const output = [...transcript].reverse().find((entry) => isParticipatingDecision(entry.decision))?.output ?? "";
+  throwIfAborted(options.signal, options.model.id);
+  const final = {
+    type: "final",
+    runId,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    output,
+    cost: totalCost,
+    transcript: createTranscriptLink(transcript),
+    ...termination !== void 0 ? { termination } : {}
+  };
+  emit(final);
+  recordProtocolDecision(final, {
+    transcriptEntryCount: transcript.length
+  });
+  const finalEvent = events.at(-1);
+  return {
+    output,
+    eventLog: createRunEventLog(runId, "sequential", events),
+    trace: {
+      schemaVersion: "1.0",
+      runId,
+      protocol: "sequential",
+      tier: options.tier,
+      modelProviderId: options.model.id,
+      agentsUsed: activeAgents,
+      inputs: createReplayTraceRunInputs({
+        intent: options.intent,
+        protocol: options.protocol,
+        tier: options.tier,
+        modelProviderId: options.model.id,
+        agents: activeAgents,
+        temperature: options.temperature
+      }),
+      budget: createReplayTraceBudget({
+        tier: options.tier,
+        ...options.budget ? { caps: options.budget } : {},
+        ...options.terminate ? { termination: options.terminate } : {}
+      }),
+      budgetStateChanges: createReplayTraceBudgetStateChanges(events),
+      seed: createReplayTraceSeed(options.seed),
+      protocolDecisions,
+      providerCalls,
+      finalOutput: createReplayTraceFinalOutput(output, finalEvent ?? events[0] ?? {
+        type: "final",
+        at: "",
+        cost: totalCost,
+        transcript: createTranscriptLink(transcript)
+      }),
+      events,
+      transcript
+    },
+    transcript,
+    usage: createRunUsage(totalCost),
+    metadata: createRunMetadata({
+      runId,
+      protocol: "sequential",
+      tier: options.tier,
+      modelProviderId: options.model.id,
+      agentsUsed: activeAgents,
+      events
+    }),
+    accounting: createRunAccounting({
+      tier: options.tier,
+      ...options.budget ? { budget: options.budget } : {},
+      ...options.terminate ? { termination: options.terminate } : {},
+      cost: totalCost,
+      events
+    }),
+    cost: totalCost
+  };
+  function stopIfNeeded() {
+    throwIfAborted(options.signal, options.model.id);
+    if (stopped || !options.terminate) {
+      return stopped;
+    }
+    const stopRecord2 = evaluateTerminationStop(options.terminate, {
+      protocol: "sequential",
+      tier: options.tier,
+      cost: totalCost,
+      transcript,
+      iteration: transcript.length,
+      elapsedMs: elapsedMs$1(startedAtMs)
+    });
+    if (!stopRecord2) {
+      return false;
+    }
+    stopped = true;
+    termination = stopRecord2;
+    if (stopRecord2.reason === "budget") {
+      emitBudgetStop(stopRecord2);
+    }
+    return true;
+  }
+  function emitBudgetStop(record) {
+    const event = {
+      type: "budget-stop",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: record.budgetReason ?? "cost",
+      cost: totalCost,
+      iteration: transcript.length,
+      elapsedMs: elapsedMs$1(startedAtMs),
+      detail: record.detail ?? {}
+    };
+    emit(event);
+    recordProtocolDecision(event, {
+      transcriptEntryCount: transcript.length
+    });
+  }
+}
+function buildSystemPrompt$1(agent) {
+  const instruction = agent.instructions ? `
+Instructions: ${agent.instructions}` : "";
+  return `You are ${agent.id}, acting as ${agent.role} in a Sequential multi-agent protocol.${instruction}`;
+}
+function buildSequentialInput(intent, transcript) {
+  if (transcript.length === 0) {
+    return `Mission: ${intent}
+Provide your contribution.`;
+  }
+  const prior = transcript.map((entry) => `${entry.role} (${entry.agentId}): ${entry.output}`).join("\n\n");
+  return `Mission: ${intent}
+
+Prior contributions:
+${prior}
+
+Continue the sequence with a useful next contribution.`;
+}
+function responseCost$1(response) {
+  return {
+    usd: response.costUsd ?? 0,
+    inputTokens: response.usage?.inputTokens ?? 0,
+    outputTokens: response.usage?.outputTokens ?? 0,
+    totalTokens: response.usage?.totalTokens ?? 0
+  };
+}
+function createRunId$1() {
+  const random = globalThis.crypto?.randomUUID?.();
+  return random ?? `run-${Date.now().toString(36)}`;
+}
+function nowMs$1() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function elapsedMs$1(startedAtMs) {
+  return Math.max(0, nowMs$1() - startedAtMs);
+}
+async function runShared(options) {
+  const runId = createRunId();
+  const events = [];
+  const transcript = [];
+  const protocolDecisions = [];
+  const providerCalls = [];
+  let totalCost = emptyCost();
+  const sharedState = options.protocol.organizationalMemory ?? "";
+  const maxTurns = options.protocol.maxTurns ?? options.agents.length;
+  const activeAgents = options.agents.slice(0, maxTurns);
+  const startedAtMs = nowMs();
+  let stopped = false;
+  let termination;
+  const emit = (event) => {
+    events.push(event);
+    options.emit?.(event);
+  };
+  const recordProtocolDecision = (event, decisionOptions) => {
+    protocolDecisions.push(createReplayTraceProtocolDecision("shared", event, events.length - 1, decisionOptions));
+  };
+  const toolExecutor = createRuntimeToolExecutor({
+    runId,
+    protocol: "shared",
+    tier: options.tier,
+    tools: options.tools,
+    emit(event) {
+      emit(event);
+      recordProtocolDecision(event);
+    },
+    getTrace: () => ({ events, transcript }),
+    ...options.signal !== void 0 ? { abortSignal: options.signal } : {}
+  });
+  const toolAvailability = runtimeToolAvailability(toolExecutor.tools);
+  throwIfAborted(options.signal, options.model.id);
+  for (const agent of activeAgents) {
+    const event = {
+      type: "role-assignment",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId: agent.id,
+      role: agent.role
+    };
+    emit(event);
+    recordProtocolDecision(event);
+  }
+  if (!stopIfNeeded()) {
+    const providerCallSlots = [];
+    const turnResults = await Promise.all(
+      activeAgents.map(async (agent, index) => {
+        const turn = index + 1;
+        const input = buildSharedInput(options.intent, sharedState, turn);
+        const request = {
+          temperature: options.temperature,
+          ...options.signal !== void 0 ? { signal: options.signal } : {},
+          metadata: {
+            runId,
+            protocol: "shared",
+            agentId: agent.id,
+            role: agent.role,
+            tier: options.tier,
+            turn,
+            ...toolAvailability
+          },
+          messages: [
+            {
+              role: "system",
+              content: buildSystemPrompt(agent)
+            },
+            {
+              role: "user",
+              content: input
+            }
+          ]
+        };
+        const response = await generateModelTurn({
+          model: options.model,
+          request,
+          runId,
+          agent,
+          input,
+          emit,
+          callId: providerCallIdFor(runId, providerCalls.length + index + 1),
+          onProviderCall(call) {
+            providerCallSlots[index] = call;
+          }
+        });
+        const decision = parseAgentDecision(response.text);
+        const toolCalls = await executeModelResponseToolRequests({
+          response,
+          executor: toolExecutor,
+          agentId: agent.id,
+          role: agent.role,
+          turn
+        });
+        throwIfAborted(options.signal, options.model.id);
+        return {
+          agent,
+          turn,
+          input,
+          response,
+          decision,
+          toolCalls,
+          turnCost: responseCost(response)
+        };
+      })
+    );
+    providerCalls.push(...providerCallSlots.filter((call) => call !== void 0));
+    for (const result of turnResults) {
+      totalCost = addCost(totalCost, result.turnCost);
+      transcript.push({
+        agentId: result.agent.id,
+        role: result.agent.role,
+        input: result.input,
+        output: result.response.text,
+        ...result.decision !== void 0 ? { decision: result.decision } : {},
+        ...result.toolCalls.length > 0 ? { toolCalls: result.toolCalls } : {}
+      });
+      const event = {
+        type: "agent-turn",
+        runId,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        agentId: result.agent.id,
+        role: result.agent.role,
+        input: result.input,
+        output: result.response.text,
+        ...result.decision !== void 0 ? { decision: result.decision } : {},
+        cost: totalCost
+      };
+      emit(event);
+      recordProtocolDecision(event, {
+        turn: result.turn,
+        transcriptEntryCount: transcript.length
+      });
+    }
+    stopIfNeeded();
+  }
+  const output = synthesizeSharedOutput(transcript);
+  throwIfAborted(options.signal, options.model.id);
+  const final = {
+    type: "final",
+    runId,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    output,
+    cost: totalCost,
+    transcript: createTranscriptLink(transcript),
+    ...termination !== void 0 ? { termination } : {}
+  };
+  emit(final);
+  recordProtocolDecision(final, {
+    transcriptEntryCount: transcript.length
+  });
+  const finalEvent = events.at(-1);
+  return {
+    output,
+    eventLog: createRunEventLog(runId, "shared", events),
+    trace: {
+      schemaVersion: "1.0",
+      runId,
+      protocol: "shared",
+      tier: options.tier,
+      modelProviderId: options.model.id,
+      agentsUsed: activeAgents,
+      inputs: createReplayTraceRunInputs({
+        intent: options.intent,
+        protocol: options.protocol,
+        tier: options.tier,
+        modelProviderId: options.model.id,
+        agents: activeAgents,
+        temperature: options.temperature
+      }),
+      budget: createReplayTraceBudget({
+        tier: options.tier,
+        ...options.budget ? { caps: options.budget } : {},
+        ...options.terminate ? { termination: options.terminate } : {}
+      }),
+      budgetStateChanges: createReplayTraceBudgetStateChanges(events),
+      seed: createReplayTraceSeed(options.seed),
+      protocolDecisions,
+      providerCalls,
+      finalOutput: createReplayTraceFinalOutput(output, finalEvent ?? {
+        type: "final",
+        at: "",
+        cost: totalCost,
+        transcript: createTranscriptLink(transcript)
+      }),
+      events,
+      transcript
+    },
+    transcript,
+    usage: createRunUsage(totalCost),
+    metadata: createRunMetadata({
+      runId,
+      protocol: "shared",
+      tier: options.tier,
+      modelProviderId: options.model.id,
+      agentsUsed: activeAgents,
+      events
+    }),
+    accounting: createRunAccounting({
+      tier: options.tier,
+      ...options.budget ? { budget: options.budget } : {},
+      ...options.terminate ? { termination: options.terminate } : {},
+      cost: totalCost,
+      events
+    }),
+    cost: totalCost
+  };
+  function stopIfNeeded() {
+    throwIfAborted(options.signal, options.model.id);
+    if (stopped || !options.terminate) {
+      return stopped;
+    }
+    const stopRecord2 = evaluateTerminationStop(options.terminate, {
+      protocol: "shared",
+      tier: options.tier,
+      cost: totalCost,
+      transcript,
+      iteration: transcript.length,
+      elapsedMs: elapsedMs(startedAtMs)
+    });
+    if (!stopRecord2) {
+      return false;
+    }
+    stopped = true;
+    termination = stopRecord2;
+    if (stopRecord2.reason === "budget") {
+      emitBudgetStop(stopRecord2);
+    }
+    return true;
+  }
+  function emitBudgetStop(record) {
+    const event = {
+      type: "budget-stop",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: record.budgetReason ?? "cost",
+      cost: totalCost,
+      iteration: transcript.length,
+      elapsedMs: elapsedMs(startedAtMs),
+      detail: record.detail ?? {}
+    };
+    emit(event);
+    recordProtocolDecision(event, {
+      transcriptEntryCount: transcript.length
+    });
+  }
+}
+function buildSystemPrompt(agent) {
+  const instruction = agent.instructions ? `
+Instructions: ${agent.instructions}` : "";
+  return `You are ${agent.id}, acting as ${agent.role} in a Shared multi-agent protocol. Read the shared state, update it with your best contribution, and preserve useful prior work.${instruction}`;
+}
+function buildSharedInput(intent, sharedState, turn) {
+  const state = sharedState ? sharedState : "(empty)";
+  return `Mission: ${intent}
+Shared turn ${turn}: read the shared state and return an improved shared-state update.
+
+Shared state:
+${state}`;
+}
+function synthesizeSharedOutput(transcript) {
+  return transcript.map((entry) => `${entry.role}:${entry.agentId} => ${entry.output}`).join("\n");
+}
+function responseCost(response) {
+  return {
+    usd: response.costUsd ?? 0,
+    inputTokens: response.usage?.inputTokens ?? 0,
+    outputTokens: response.usage?.outputTokens ?? 0,
+    totalTokens: response.usage?.totalTokens ?? 0
+  };
+}
+function createRunId() {
+  const random = globalThis.crypto?.randomUUID?.();
+  return random ?? `run-${Date.now().toString(36)}`;
+}
+function nowMs() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function elapsedMs(startedAtMs) {
+  return Math.max(0, nowMs() - startedAtMs);
+}
+function providerCallIdFor(runId, oneBasedIndex) {
+  return `${runId}:provider-call:${oneBasedIndex}`;
+}
+const defaultHighLevelProtocol = "sequential";
+const defaultHighLevelTier = "balanced";
+function createEngine(options) {
+  validateEngineOptions(options);
+  const protocol = normalizeProtocol(options.protocol);
+  const tools = options.tools ?? [];
+  const temperature = options.temperature ?? tierTemperature(options.tier);
+  const agents = orderAgentsForTemperature(options.agents ?? defaultAgents(), temperature, options.seed);
+  const terminate = options.terminate ?? (options.budget ? conditionFromBudget(options.budget) : void 0);
+  return {
+    run(intent) {
+      validateMissionIntent(intent);
+      return runNonStreamingProtocol({
+        intent,
+        protocol,
+        tier: options.tier,
+        model: options.model,
+        agents,
+        tools,
+        temperature,
+        ...options.budget ? { budget: options.budget } : {},
+        ...options.seed !== void 0 ? { seed: options.seed } : {},
+        ...options.signal !== void 0 ? { signal: options.signal } : {},
+        ...terminate ? { terminate } : {},
+        ...options.evaluate ? { evaluate: options.evaluate } : {}
+      });
+    },
+    stream(intent) {
+      validateMissionIntent(intent);
+      const pendingEvents = [];
+      const pendingResolvers = [];
+      const emittedEvents = [];
+      const subscribers = /* @__PURE__ */ new Set();
+      const abortController = new AbortController();
+      const timeoutLifecycle = createTimeoutAbortLifecycle({
+        abortController,
+        timeoutMs: runtimeTimeoutMs({ budget: options.budget, terminate }),
+        providerId: options.model.id
+      });
+      const abortRace = createAbortRace(abortController.signal, options.model.id);
+      let complete = false;
+      let lastRunId = "";
+      let pendingFinalEvent;
+      let status = "running";
+      let resolveResult;
+      let rejectResult;
+      let removeCallerAbortListener = () => {
+      };
+      const result = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+      });
+      removeCallerAbortListener = wireCallerAbortSignal(options.signal, abortController, cancelRun);
+      void execute();
+      return {
+        get status() {
+          return status;
+        },
+        result,
+        cancel() {
+          cancelRun();
+        },
+        subscribe(subscriber) {
+          subscribers.add(subscriber);
+          for (const event of emittedEvents) {
+            subscriber(event);
+          }
+          return {
+            unsubscribe() {
+              subscribers.delete(subscriber);
+            }
+          };
+        },
+        [Symbol.asyncIterator]() {
+          return {
+            next() {
+              const event = pendingEvents.shift();
+              if (event) {
+                return Promise.resolve({ done: false, value: event });
+              }
+              if (complete) {
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              return new Promise((resolve) => {
+                pendingResolvers.push(resolve);
+              });
+            }
+          };
+        }
+      };
+      async function execute() {
+        if (status !== "running") {
+          return;
+        }
+        try {
+          const baseResult = await abortRace.run(runProtocol({
+            intent,
+            protocol,
+            tier: options.tier,
+            model: options.model,
+            agents,
+            tools,
+            temperature,
+            ...options.budget ? { budget: options.budget } : {},
+            ...options.seed !== void 0 ? { seed: options.seed } : {},
+            signal: abortController.signal,
+            ...terminate ? { terminate } : {},
+            emit(event) {
+              if (status !== "running") {
+                return;
+              }
+              lastRunId = event.runId;
+              if (event.type === "final") {
+                pendingFinalEvent = event;
+                return;
+              }
+              publish(event);
+            }
+          }));
+          if (status !== "running") {
+            return;
+          }
+          const finalizedResult = await abortRace.run(applyRunEvaluation(baseResult, options.evaluate));
+          if (status !== "running") {
+            return;
+          }
+          const finalEvent = finalizedResult.trace.events.at(-1);
+          if (finalEvent?.type === "final") {
+            publish(finalEvent);
+          } else if (pendingFinalEvent) {
+            publish(pendingFinalEvent);
+          }
+          status = "completed";
+          closeStream();
+          resolveResult(finalizedResult);
+        } catch (error) {
+          if (isStreamHandleStatus(status, "cancelled")) {
+            return;
+          }
+          const runtimeError = timeoutLifecycle.translateError(error);
+          status = isCancellationError(runtimeError) ? "cancelled" : "failed";
+          publish(createStreamErrorEvent(runtimeError, lastRunId));
+          closeStream();
+          rejectResult(runtimeError);
+        }
+      }
+      function cancelRun(cause) {
+        if (status !== "running") {
+          return;
+        }
+        const error = createStreamCancellationError(options.model.id, cause);
+        status = "cancelled";
+        abortController.abort(error);
+        publish(createStreamErrorEvent(error, lastRunId));
+        closeStream();
+        rejectResult(error);
+      }
+      function closeStream() {
+        if (complete) {
+          return;
+        }
+        complete = true;
+        removeCallerAbortListener();
+        timeoutLifecycle.cleanup();
+        abortRace.cleanup();
+        subscribers.clear();
+        for (const resolver of pendingResolvers.splice(0)) {
+          resolver({ done: true, value: void 0 });
+        }
+      }
+      function publish(event) {
+        if (complete) {
+          return;
+        }
+        const canonicalEvent = canonicalizeSerializable(event);
+        emittedEvents.push(canonicalEvent);
+        for (const subscriber of subscribers) {
+          try {
+            subscriber(canonicalEvent);
+          } catch {
+          }
+        }
+        const resolver = pendingResolvers.shift();
+        if (resolver) {
+          resolver({ done: false, value: canonicalEvent });
+          return;
+        }
+        pendingEvents.push(canonicalEvent);
+      }
+    }
+  };
+}
+function isStreamHandleStatus(status, expected) {
+  return status === expected;
+}
+function conditionFromBudget(budget$1) {
+  return budget({
+    ...budget$1.maxUsd !== void 0 ? { maxUsd: budget$1.maxUsd } : {},
+    ...budget$1.maxTokens !== void 0 ? { maxTokens: budget$1.maxTokens } : {},
+    ...budget$1.maxIterations !== void 0 ? { maxIterations: budget$1.maxIterations } : {},
+    ...budget$1.timeoutMs !== void 0 ? { timeoutMs: budget$1.timeoutMs } : {}
+  });
+}
+function createNonStreamingAbortLifecycle(options) {
+  if (options.timeoutMs === void 0) {
+    return {
+      signal: options.callerSignal,
+      async run(operation) {
+        return await operation;
+      },
+      translateError(error) {
+        return error;
+      },
+      cleanup() {
+      }
+    };
+  }
+  const abortController = new AbortController();
+  const timeoutLifecycle = createTimeoutAbortLifecycle({
+    abortController,
+    timeoutMs: options.timeoutMs,
+    providerId: options.providerId
+  });
+  const abortRace = createAbortRace(abortController.signal, options.providerId);
+  const removeCallerAbortListener = wireCallerAbortSignal(options.callerSignal, abortController, () => {
+    abortController.abort(readAbortSignalReason(options.callerSignal));
+  });
+  return {
+    signal: abortController.signal,
+    async run(operation) {
+      return await abortRace.run(operation);
+    },
+    translateError(error) {
+      return timeoutLifecycle.translateError(error);
+    },
+    cleanup() {
+      timeoutLifecycle.cleanup();
+      abortRace.cleanup();
+      removeCallerAbortListener();
+    }
+  };
+}
+function createTimeoutAbortLifecycle(options) {
+  if (options.timeoutMs === void 0) {
+    return {
+      translateError(error) {
+        return error;
+      },
+      cleanup() {
+      }
+    };
+  }
+  const timeoutError = createTimeoutError(options.providerId, options.timeoutMs);
+  const timeoutId = setTimeout(() => {
+    options.abortController.abort(timeoutError);
+  }, options.timeoutMs);
+  return {
+    translateError(error) {
+      return options.abortController.signal.reason === timeoutError ? timeoutError : error;
+    },
+    cleanup() {
+      clearTimeout(timeoutId);
+    }
+  };
+}
+function createAbortRace(signal, providerId) {
+  let cleanupAbortListener = () => {
+  };
+  return {
+    signal,
+    async run(operation) {
+      if (signal.aborted) {
+        throw createAbortErrorFromSignal(signal, providerId);
+      }
+      const abortPromise = new Promise((_, reject) => {
+        const abortHandler = () => {
+          cleanupAbortListener();
+          reject(createAbortErrorFromSignal(signal, providerId));
+        };
+        cleanupAbortListener = () => {
+          signal.removeEventListener("abort", abortHandler);
+        };
+        signal.addEventListener("abort", abortHandler, { once: true });
+      });
+      try {
+        return await Promise.race([operation, abortPromise]);
+      } finally {
+        cleanupAbortListener();
+        cleanupAbortListener = () => {
+        };
+      }
+    },
+    translateError(error) {
+      return error;
+    },
+    cleanup() {
+      cleanupAbortListener();
+      cleanupAbortListener = () => {
+      };
+    }
+  };
+}
+function runtimeTimeoutMs(options) {
+  const budgetTimeoutMs = options.budget?.timeoutMs;
+  const terminationTimeoutMs = timeoutMsFromTermination(options.terminate);
+  if (budgetTimeoutMs === void 0) {
+    return terminationTimeoutMs;
+  }
+  if (terminationTimeoutMs === void 0) {
+    return budgetTimeoutMs;
+  }
+  return Math.min(budgetTimeoutMs, terminationTimeoutMs);
+}
+function timeoutMsFromTermination(condition) {
+  if (!condition) {
+    return void 0;
+  }
+  switch (condition.kind) {
+    case "budget":
+      return condition.timeoutMs;
+    case "firstOf":
+      return condition.conditions.reduce((current, child) => {
+        const childTimeoutMs = timeoutMsFromTermination(child);
+        if (childTimeoutMs === void 0) {
+          return current;
+        }
+        return current === void 0 ? childTimeoutMs : Math.min(current, childTimeoutMs);
+      }, void 0);
+    case "convergence":
+    case "judge":
+      return void 0;
+  }
+}
+function readAbortSignalReason(signal) {
+  return signal?.aborted ? signal.reason : void 0;
+}
+function createStreamErrorEvent(error, runId) {
+  if (DogpileError.isInstance(error)) {
+    return {
+      type: "error",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      name: error.name,
+      message: error.message,
+      detail: dogpileErrorStreamDetail(error)
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      type: "error",
+      runId,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      name: error.name,
+      message: error.message
+    };
+  }
+  return {
+    type: "error",
+    runId,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    name: "Error",
+    message: String(error)
+  };
+}
+function dogpileErrorStreamDetail(error) {
+  const detail = {
+    code: error.code
+  };
+  if (error.providerId !== void 0) {
+    detail.providerId = error.providerId;
+  }
+  if (error.retryable !== void 0) {
+    detail.retryable = error.retryable;
+  }
+  if (error.detail !== void 0) {
+    for (const [key, value] of Object.entries(error.detail)) {
+      detail[key] = value;
+    }
+  }
+  return detail;
+}
+async function runNonStreamingProtocol(options) {
+  const abortLifecycle = createNonStreamingAbortLifecycle({
+    callerSignal: options.signal,
+    timeoutMs: runtimeTimeoutMs(options),
+    providerId: options.model.id
+  });
+  try {
+    const emittedEvents = [];
+    const result = await abortLifecycle.run(runProtocol({
+      ...options,
+      ...abortLifecycle.signal !== void 0 ? { signal: abortLifecycle.signal } : {},
+      emit(event) {
+        emittedEvents.push(event);
+      }
+    }));
+    const events = emittedEvents.length > 0 ? emittedEvents : result.trace.events;
+    const trace = {
+      ...result.trace,
+      events,
+      budgetStateChanges: createReplayTraceBudgetStateChanges(events),
+      finalOutput: createReplayTraceFinalOutput(result.output, events.at(-1) ?? result.trace.events.at(-1))
+    };
+    const runResult = {
+      ...result,
+      accounting: createRunAccounting({
+        tier: trace.tier,
+        ...trace.budget.caps ? { budget: trace.budget.caps } : {},
+        ...trace.budget.termination ? { termination: trace.budget.termination } : {},
+        cost: result.cost,
+        events
+      }),
+      eventLog: createRunEventLog(trace.runId, trace.protocol, events),
+      trace
+    };
+    return canonicalizeRunResult(await abortLifecycle.run(applyRunEvaluation(runResult, options.evaluate)));
+  } catch (error) {
+    throw abortLifecycle.translateError(error);
+  } finally {
+    abortLifecycle.cleanup();
+  }
+}
+async function applyRunEvaluation(result, evaluate) {
+  if (!evaluate) {
+    return canonicalizeRunResult(result);
+  }
+  const evaluation = await evaluate(result);
+  const events = result.trace.events.map((event, index) => {
+    if (index !== result.trace.events.length - 1 || event.type !== "final") {
+      return event;
+    }
+    return finalEventWithEvaluation(event, evaluation);
+  });
+  const trace = {
+    ...result.trace,
+    events
+  };
+  return canonicalizeRunResult({
+    ...result,
+    quality: evaluation.quality,
+    evaluation,
+    trace,
+    eventLog: createRunEventLog(trace.runId, trace.protocol, events)
+  });
+}
+function finalEventWithEvaluation(event, evaluation) {
+  return {
+    ...event,
+    quality: evaluation.quality,
+    evaluation
+  };
+}
+function runProtocol(options) {
+  switch (options.protocol.kind) {
+    case "sequential":
+      return runSequential({
+        intent: options.intent,
+        protocol: options.protocol,
+        tier: options.tier,
+        model: options.model,
+        agents: options.agents,
+        tools: options.tools,
+        temperature: options.temperature,
+        ...options.budget ? { budget: options.budget } : {},
+        ...options.seed !== void 0 ? { seed: options.seed } : {},
+        ...options.signal !== void 0 ? { signal: options.signal } : {},
+        ...options.terminate ? { terminate: options.terminate } : {},
+        ...options.emit ? { emit: options.emit } : {}
+      });
+    case "broadcast":
+      return runBroadcast({
+        intent: options.intent,
+        protocol: options.protocol,
+        tier: options.tier,
+        model: options.model,
+        agents: options.agents,
+        tools: options.tools,
+        temperature: options.temperature,
+        ...options.budget ? { budget: options.budget } : {},
+        ...options.seed !== void 0 ? { seed: options.seed } : {},
+        ...options.signal !== void 0 ? { signal: options.signal } : {},
+        ...options.terminate ? { terminate: options.terminate } : {},
+        ...options.emit ? { emit: options.emit } : {}
+      });
+    case "coordinator":
+      return runCoordinator({
+        intent: options.intent,
+        protocol: options.protocol,
+        tier: options.tier,
+        model: options.model,
+        agents: options.agents,
+        tools: options.tools,
+        temperature: options.temperature,
+        ...options.budget ? { budget: options.budget } : {},
+        ...options.seed !== void 0 ? { seed: options.seed } : {},
+        ...options.signal !== void 0 ? { signal: options.signal } : {},
+        ...options.terminate ? { terminate: options.terminate } : {},
+        ...options.emit ? { emit: options.emit } : {}
+      });
+    case "shared":
+      return runShared({
+        intent: options.intent,
+        protocol: options.protocol,
+        tier: options.tier,
+        model: options.model,
+        agents: options.agents,
+        tools: options.tools,
+        temperature: options.temperature,
+        ...options.budget ? { budget: options.budget } : {},
+        ...options.seed !== void 0 ? { seed: options.seed } : {},
+        ...options.signal !== void 0 ? { signal: options.signal } : {},
+        ...options.terminate ? { terminate: options.terminate } : {},
+        ...options.emit ? { emit: options.emit } : {}
+      });
+  }
+}
+function run(options) {
+  validateDogpileOptions(options);
+  const { intent, ...engineOptions } = withHighLevelDefaults(options);
+  return createEngine(engineOptions).run(intent);
+}
+function stream(options) {
+  validateDogpileOptions(options);
+  const { intent, ...engineOptions } = withHighLevelDefaults(options);
+  return createEngine(engineOptions).stream(intent);
+}
+function replay(trace) {
+  const cost = trace.finalOutput.cost;
+  const lastEvent = trace.events.at(-1);
+  const baseResult = {
+    output: trace.finalOutput.output,
+    eventLog: createRunEventLog(trace.runId, trace.protocol, trace.events),
+    trace,
+    transcript: trace.transcript,
+    usage: createRunUsage(cost),
+    metadata: createRunMetadata({
+      runId: trace.runId,
+      protocol: trace.protocol,
+      tier: trace.tier,
+      modelProviderId: trace.modelProviderId,
+      agentsUsed: trace.agentsUsed,
+      events: trace.events
+    }),
+    accounting: createRunAccounting({
+      tier: trace.tier,
+      ...trace.budget.caps ? { budget: trace.budget.caps } : {},
+      ...trace.budget.termination ? { termination: trace.budget.termination } : {},
+      cost,
+      events: trace.events
+    }),
+    cost
+  };
+  if (lastEvent?.type !== "final") {
+    return baseResult;
+  }
+  return {
+    ...baseResult,
+    ...lastEvent.quality !== void 0 ? { quality: lastEvent.quality } : {},
+    ...lastEvent.evaluation !== void 0 ? { evaluation: lastEvent.evaluation } : {}
+  };
+}
+function replayStream(trace) {
+  const result = Promise.resolve(replay(trace));
+  return {
+    get status() {
+      return "completed";
+    },
+    result,
+    cancel() {
+    },
+    subscribe(subscriber) {
+      for (const event of trace.events) {
+        subscriber(event);
+      }
+      return {
+        unsubscribe() {
+        }
+      };
+    },
+    [Symbol.asyncIterator]() {
+      let index = 0;
+      return {
+        next() {
+          const event = trace.events[index];
+          if (event) {
+            index += 1;
+            return Promise.resolve({ done: false, value: event });
+          }
+          return Promise.resolve({ done: true, value: void 0 });
+        }
+      };
+    }
+  };
+}
+function wireCallerAbortSignal(callerSignal, abortController, cancelRun) {
+  if (!callerSignal) {
+    return () => {
+    };
+  }
+  const cancelFromCaller = () => {
+    cancelRun(readAbortSignalReason(callerSignal));
+  };
+  if (callerSignal.aborted) {
+    cancelFromCaller();
+    return () => {
+    };
+  }
+  callerSignal.addEventListener("abort", cancelFromCaller, { once: true });
+  const remove = () => {
+    callerSignal.removeEventListener("abort", cancelFromCaller);
+  };
+  abortController.signal.addEventListener("abort", remove, { once: true });
+  return remove;
+}
+function createStreamCancellationError(providerId, cause) {
+  return new DogpileError({
+    code: "aborted",
+    message: "The operation was aborted.",
+    retryable: false,
+    providerId,
+    ...cause !== void 0 ? { cause } : {},
+    detail: {
+      status: "cancelled"
+    }
+  });
+}
+function isCancellationError(error) {
+  if (DogpileError.isInstance(error)) {
+    return error.code === "aborted";
+  }
+  return error instanceof Error && error.name === "AbortError";
+}
+function withHighLevelDefaults(options) {
+  return {
+    ...options,
+    protocol: options.protocol ?? defaultHighLevelProtocol,
+    tier: options.tier ?? defaultHighLevelTier
+  };
+}
+function pile(options) {
+  return run(options);
+}
+const Dogpile = {
+  pile,
+  replay,
+  replayStream,
+  stream,
+  createEngine
+};
+const defaultBaseURL = "https://api.openai.com/v1";
+const defaultPath = "/chat/completions";
+function createOpenAICompatibleProvider(options) {
+  validateOptions(options);
+  const providerId = options.id ?? `openai-compatible:${options.model}`;
+  const fetchImplementation = options.fetch ?? globalThis.fetch?.bind(globalThis);
+  if (!fetchImplementation) {
+    throw new DogpileError({
+      code: "invalid-configuration",
+      message: "createOpenAICompatibleProvider() requires a fetch implementation in this runtime.",
+      retryable: false,
+      providerId,
+      detail: {
+        kind: "configuration-validation",
+        path: "fetch",
+        expected: "a fetch-compatible function"
+      }
+    });
+  }
+  return {
+    id: providerId,
+    async generate(request) {
+      const response = await fetchImplementation(createURL(options), {
+        method: "POST",
+        headers: createHeaders(options),
+        body: JSON.stringify(createBody(options, request)),
+        ...request.signal !== void 0 ? { signal: request.signal } : {}
+      });
+      const payload = await readJson(response, providerId);
+      if (!response.ok) {
+        throw createProviderError(response, payload, providerId);
+      }
+      const completion = asChatCompletionResponse(payload, providerId);
+      const text = readAssistantText(completion, providerId);
+      const usage = normalizeUsage(completion.usage);
+      const finishReason = normalizeFinishReason(completion.choices?.[0]?.finish_reason);
+      const costUsd = options.costEstimator?.({
+        providerId,
+        request,
+        response: completion,
+        ...usage ? { usage } : {}
+      });
+      return {
+        text,
+        ...finishReason !== void 0 ? { finishReason } : {},
+        ...usage ? { usage } : {},
+        ...costUsd !== void 0 ? { costUsd } : {},
+        metadata: {
+          openAICompatible: responseMetadata(completion)
+        }
+      };
+    }
+  };
+}
+function validateOptions(options) {
+  if (!isRecord(options)) {
+    throwInvalid("options", "an options object");
+  }
+  if (!isNonEmptyString(options.model)) {
+    throwInvalid("model", "a non-empty model id");
+  }
+  if (options.apiKey !== void 0 && !isNonEmptyString(options.apiKey)) {
+    throwInvalid("apiKey", "a non-empty API key when provided");
+  }
+  if (options.id !== void 0 && !isNonEmptyString(options.id)) {
+    throwInvalid("id", "a non-empty provider id when provided");
+  }
+  if (options.path !== void 0 && !isNonEmptyString(options.path)) {
+    throwInvalid("path", "a non-empty request path when provided");
+  }
+  if (options.fetch !== void 0 && typeof options.fetch !== "function") {
+    throwInvalid("fetch", "a fetch-compatible function when provided");
+  }
+  if (options.maxOutputTokens !== void 0 && (!Number.isInteger(options.maxOutputTokens) || options.maxOutputTokens <= 0)) {
+    throwInvalid("maxOutputTokens", "a positive integer when provided");
+  }
+  if (options.costEstimator !== void 0 && typeof options.costEstimator !== "function") {
+    throwInvalid("costEstimator", "a function when provided");
+  }
+}
+function throwInvalid(path, expected) {
+  throw new DogpileError({
+    code: "invalid-configuration",
+    message: `Invalid OpenAI-compatible provider option at ${path}.`,
+    retryable: false,
+    detail: {
+      kind: "configuration-validation",
+      path,
+      expected
+    }
+  });
+}
+function createURL(options) {
+  const baseURL = new URL(String(options.baseURL ?? defaultBaseURL));
+  const path = options.path ?? defaultPath;
+  return new URL(path.startsWith("/") ? path.slice(1) : path, ensureTrailingSlash(baseURL));
+}
+function ensureTrailingSlash(url) {
+  const next = new URL(url);
+  if (!next.pathname.endsWith("/")) {
+    next.pathname = `${next.pathname}/`;
+  }
+  return next;
+}
+function createHeaders(options) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(options.headers ?? {})) {
+    if (value !== void 0) {
+      headers.set(key, value);
+    }
+  }
+  headers.set("content-type", "application/json");
+  if (options.apiKey !== void 0 && !headers.has("authorization")) {
+    headers.set("authorization", `Bearer ${options.apiKey}`);
+  }
+  return headers;
+}
+function createBody(options, request) {
+  return {
+    ...options.extraBody ?? {},
+    model: options.model,
+    messages: request.messages.map(toChatMessage),
+    temperature: request.temperature,
+    ...options.maxOutputTokens !== void 0 ? { max_tokens: options.maxOutputTokens } : {}
+  };
+}
+function toChatMessage(message) {
+  return {
+    role: message.role,
+    content: message.content
+  };
+}
+async function readJson(response, providerId) {
+  try {
+    return await response.json();
+  } catch (error) {
+    throw new DogpileError({
+      code: "provider-invalid-response",
+      message: "OpenAI-compatible provider returned a non-JSON response.",
+      cause: error,
+      retryable: response.status >= 500,
+      providerId,
+      detail: {
+        statusCode: response.status,
+        statusText: response.statusText
+      }
+    });
+  }
+}
+function asChatCompletionResponse(payload, providerId) {
+  if (!isRecord(payload)) {
+    throw new DogpileError({
+      code: "provider-invalid-response",
+      message: "OpenAI-compatible provider response must be a JSON object.",
+      retryable: true,
+      providerId
+    });
+  }
+  return payload;
+}
+function readAssistantText(response, providerId) {
+  const content = response.choices?.[0]?.message?.content;
+  const text = normalizeContent(content);
+  if (!text) {
+    throw new DogpileError({
+      code: "provider-invalid-response",
+      message: "OpenAI-compatible provider response did not include assistant text.",
+      retryable: true,
+      providerId
+    });
+  }
+  return text;
+}
+function normalizeContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((part) => {
+    if (!isRecord(part)) {
+      return "";
+    }
+    const text = part.text;
+    return typeof text === "string" ? text : "";
+  }).filter(Boolean).join("");
+}
+function normalizeUsage(usage) {
+  if (!usage) {
+    return void 0;
+  }
+  const inputTokens = readTokenCount(usage.prompt_tokens ?? usage.input_tokens);
+  const outputTokens = readTokenCount(usage.completion_tokens ?? usage.output_tokens);
+  const totalTokens = readTokenCount(usage.total_tokens) ?? sumIfPresent(inputTokens, outputTokens);
+  if (inputTokens === void 0 || outputTokens === void 0 || totalTokens === void 0) {
+    return void 0;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens
+  };
+}
+function readTokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function sumIfPresent(left, right) {
+  return left === void 0 || right === void 0 ? void 0 : left + right;
+}
+function normalizeFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+    case "content-filter":
+      return "content-filter";
+    case "tool_calls":
+    case "tool-calls":
+      return "tool-calls";
+    case void 0:
+    case null:
+      return void 0;
+    default:
+      return "other";
+  }
+}
+function responseMetadata(response) {
+  return removeUndefined({
+    id: response.id,
+    object: response.object,
+    created: response.created,
+    model: response.model,
+    usage: isJsonValue(response.usage) ? response.usage : void 0
+  });
+}
+function createProviderError(response, payload, providerId) {
+  return new DogpileError({
+    code: codeForStatus(response.status),
+    message: errorMessage(response, payload),
+    retryable: response.status === 408 || response.status === 429 || response.status >= 500,
+    providerId,
+    detail: removeUndefined({
+      statusCode: response.status,
+      statusText: response.statusText,
+      response: isJsonValue(payload) ? payload : void 0
+    })
+  });
+}
+function codeForStatus(status) {
+  if (status === 401 || status === 403) {
+    return "provider-authentication";
+  }
+  if (status === 404) {
+    return "provider-not-found";
+  }
+  if (status === 408 || status === 504) {
+    return "provider-timeout";
+  }
+  if (status === 429) {
+    return "provider-rate-limited";
+  }
+  if (status >= 500) {
+    return "provider-unavailable";
+  }
+  if (status >= 400) {
+    return "provider-invalid-request";
+  }
+  return "provider-error";
+}
+function errorMessage(response, payload) {
+  const providerMessage = isRecord(payload) && isRecord(payload.error) && typeof payload.error.message === "string" ? payload.error.message : void 0;
+  return providerMessage ?? `OpenAI-compatible provider request failed with HTTP ${response.status}.`;
+}
+function removeUndefined(values) {
+  return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== void 0));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return typeof value !== "number" || Number.isFinite(value);
+  }
+  if (Array.isArray(value)) {
+    return value.every(isJsonValue);
+  }
+  if (isRecord(value)) {
+    return Object.values(value).every(isJsonValue);
+  }
+  return false;
+}
+export {
+  Dogpile,
+  DogpileError,
+  budget,
+  builtInDogpileToolIdentity,
+  builtInDogpileToolInputSchema,
+  builtInDogpileToolPermissions,
+  combineTerminationDecisions,
+  convergence,
+  createCodeExecToolAdapter,
+  createEngine,
+  createOpenAICompatibleProvider,
+  createRuntimeToolExecutor,
+  createWebSearchToolAdapter,
+  evaluateBudget,
+  evaluateConvergence,
+  evaluateFirstOf,
+  evaluateJudge,
+  evaluateTermination,
+  evaluateTerminationStop,
+  firstOf,
+  judge,
+  normalizeBuiltInDogpileTool,
+  normalizeBuiltInDogpileTools,
+  normalizeRuntimeToolAdapterError,
+  replay,
+  replayStream,
+  run,
+  runtimeToolAvailability,
+  runtimeToolManifest,
+  stream,
+  validateBuiltInDogpileToolInput
+};
+//# sourceMappingURL=index.js.map