@dogpile/sdk 0.4.0 → 0.5.0

package/dist/browser/index.js

@@ -262,8 +262,8 @@ function createRunMetadata(options) {
 		tier: options.tier,
 		modelProviderId: options.modelProviderId,
 		agentsUsed: options.agentsUsed,
-		startedAt: firstEvent?.at ?? "",
-		completedAt: lastEvent?.at ?? ""
+		startedAt: eventTimestamp$1(firstEvent) ?? "",
+		completedAt: eventTimestamp$1(lastEvent) ?? ""
 	};
 }
 function createReplayTraceRunInputs(options) {
@@ -342,7 +342,7 @@ function createReplayTraceProtocolDecision(protocol, event, eventIndex, options
 		eventType: event.type,
 		protocol,
 		decision: options.decision ?? defaultProtocolDecision(event),
-		at: event.at,
+		at: eventTimestamp$1(event),
 		...options.turn !== void 0 ? { turn: options.turn } : {},
 		...options.phase !== void 0 ? { phase: options.phase } : {},
 		...options.round !== void 0 ? { round: options.round } : {},
@@ -475,7 +475,7 @@ function createReplayTraceFinalOutput(output, event) {
 		kind: "replay-trace-final-output",
 		output,
 		cost: emptyCost(),
-		completedAt: event.at,
+		completedAt: eventTimestamp$1(event),
 		transcript: {
 			kind: "trace-transcript",
 			entryCount: 0,
@@ -483,6 +483,11 @@ function createReplayTraceFinalOutput(output, event) {
 		}
 	};
 }
+function eventTimestamp$1(event) {
+	if (event === void 0) return void 0;
+	if ("at" in event) return event.at;
+	return event.type === "model-response" ? event.completedAt : event.startedAt;
+}
 function nextProviderCallId(runId, providerCalls) {
 	return `${runId}:provider-call:${providerCalls.length + 1}`;
 }
@@ -509,6 +514,7 @@ function canonicalizeRunResult(result) {
 		cost: canonicalizeSerializable(result.cost),
 		...result.evaluation !== void 0 ? { evaluation: canonicalizeSerializable(result.evaluation) } : {},
 		eventLog,
+		health: canonicalizeSerializable(result.health),
 		metadata: canonicalizeSerializable(result.metadata),
 		output: result.output,
 		...result.quality !== void 0 ? { quality: canonicalizeSerializable(result.quality) } : {},
@@ -747,6 +753,77 @@ function canonicalizeSerializable(value) {
 	return output;
 }
 //#endregion
+//#region src/runtime/health.ts
+/**
+* Default health thresholds used for `result.health` auto-computation.
+*
+* Both threshold-gated anomalies (runaway-turns, budget-near-miss) are suppressed
+* by default. Only threshold-free anomalies (empty-contribution) can fire on the
+* auto-compute path.
+*/
+var DEFAULT_HEALTH_THRESHOLDS = Object.freeze({});
+/**
+* Compute a health summary from a completed run trace.
+*
+* Pure function - no side effects, no I/O, no storage access. Deterministic:
+* given the same trace and thresholds, always produces the same result.
+*
+* @param trace - Completed run trace (from RunResult.trace or a stored trace).
+* @param thresholds - Optional threshold overrides. Defaults to DEFAULT_HEALTH_THRESHOLDS.
+*/
+function computeHealth(trace, thresholds = DEFAULT_HEALTH_THRESHOLDS) {
+	assertFiniteNonNegativeThreshold(thresholds.runawayTurns, "runawayTurns");
+	assertBudgetNearMissThreshold(thresholds.budgetNearMissPct);
+	const turnEvents = trace.events.filter((event) => event.type === "agent-turn");
+	const agentIds = new Set(turnEvents.map((event) => event.agentId));
+	const totalTurns = turnEvents.length;
+	const agentCount = agentIds.size;
+	const maxUsd = trace.budget.caps?.maxUsd;
+	const finalCost = trace.finalOutput.cost.usd;
+	const budgetUtilizationPct = maxUsd !== void 0 ? maxUsd === 0 ? finalCost === 0 ? 0 : 100 : finalCost / maxUsd * 100 : null;
+	const anomalies = [];
+	if (thresholds.runawayTurns !== void 0) for (const agentId of agentIds) {
+		const count = turnEvents.filter((event) => event.agentId === agentId).length;
+		if (count > thresholds.runawayTurns) anomalies.push({
+			code: "runaway-turns",
+			severity: "error",
+			value: count,
+			threshold: thresholds.runawayTurns,
+			agentId
+		});
+	}
+	if (thresholds.budgetNearMissPct !== void 0 && budgetUtilizationPct !== null) {
+		if (budgetUtilizationPct >= thresholds.budgetNearMissPct) anomalies.push({
+			code: "budget-near-miss",
+			severity: "warning",
+			value: budgetUtilizationPct,
+			threshold: thresholds.budgetNearMissPct
+		});
+	}
+	for (const event of turnEvents) if (event.output.trim() === "") anomalies.push({
+		code: "empty-contribution",
+		severity: "error",
+		value: 0,
+		threshold: 0,
+		agentId: event.agentId
+	});
+	return {
+		anomalies,
+		stats: {
+			totalTurns,
+			agentCount,
+			budgetUtilizationPct
+		}
+	};
+}
+function assertFiniteNonNegativeThreshold(value, name) {
+	if (value !== void 0 && (!Number.isFinite(value) || value < 0)) throw new RangeError(`${name} must be a finite non-negative number`);
+}
+function assertBudgetNearMissThreshold(value) {
+	assertFiniteNonNegativeThreshold(value, "budgetNearMissPct");
+	if (value !== void 0 && value > 100) throw new RangeError("budgetNearMissPct must be between 0 and 100");
+}
+//#endregion
 //#region src/runtime/cancellation.ts
 /**
 * Classify an abort signal's reason into the BUDGET-01 / BUDGET-02
@@ -1034,12 +1111,25 @@ function truncate(value) {
 //#region src/runtime/model.ts
 async function generateModelTurn(options) {
 	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const modelId = options.model.modelId ?? options.model.id;
+	const traceRequest = requestForTrace(options.request);
 	let response;
 	throwIfAborted(options.request.signal, options.model.id);
+	options.emit({
+		type: "model-request",
+		runId: options.runId,
+		callId: options.callId,
+		providerId: options.model.id,
+		modelId,
+		startedAt,
+		agentId: options.agent.id,
+		role: options.agent.role,
+		request: traceRequest
+	});
 	if (!options.model.stream) {
 		response = await options.model.generate(options.request);
 		throwIfAborted(options.request.signal, options.model.id);
-		recordProviderCall(response, startedAt, options);
+		recordProviderCall(response, startedAt, modelId, traceRequest, options);
 		return response;
 	}
 	let text = "";
@@ -1079,27 +1169,41 @@ async function generateModelTurn(options) {
 		...metadata !== void 0 ? { metadata } : {}
 	};
 	throwIfAborted(options.request.signal, options.model.id);
-	recordProviderCall(response, startedAt, options);
+	recordProviderCall(response, startedAt, modelId, traceRequest, options);
 	return response;
 }
-function recordProviderCall(response, startedAt, options) {
+function recordProviderCall(response, startedAt, modelId, request, options) {
+	const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+	options.emit({
+		type: "model-response",
+		runId: options.runId,
+		callId: options.callId,
+		providerId: options.model.id,
+		modelId,
+		startedAt,
+		completedAt,
+		agentId: options.agent.id,
+		role: options.agent.role,
+		response
+	});
 	options.onProviderCall?.({
 		kind: "replay-trace-provider-call",
 		callId: options.callId,
 		providerId: options.model.id,
+		modelId,
 		startedAt,
-		completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		completedAt,
 		agentId: options.agent.id,
 		role: options.agent.role,
-		request: requestForTrace(options.request),
+		request,
 		response
 	});
 }
 function requestForTrace(request) {
 	return {
-		messages: request.messages,
+		messages: request.messages.map((message) => ({ ...message })),
 		temperature: request.temperature,
-		metadata: request.metadata
+		metadata: JSON.parse(JSON.stringify(request.metadata))
 	};
 }
 //#endregion
@@ -3042,44 +3146,45 @@ async function runBroadcast(options) {
 	emit(final);
 	recordProtocolDecision(final, { transcriptEntryCount: transcript.length });
 	const finalEvent = events.at(-1);
+	const 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",
+			runId,
+			at: "",
+			output,
+			cost: totalCost,
+			transcript: createTranscriptLink(transcript)
+		}),
+		events,
+		transcript
+	};
 	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",
-				runId,
-				at: "",
-				output,
-				cost: totalCost,
-				transcript: createTranscriptLink(transcript)
-			}),
-			events,
-			transcript
-		},
+		trace,
 		transcript,
 		usage: createRunUsage(totalCost),
 		metadata: createRunMetadata({
@@ -3097,7 +3202,8 @@ async function runBroadcast(options) {
 			cost: totalCost,
 			events
 		}),
-		cost: totalCost
+		cost: totalCost,
+		health: computeHealth(trace, DEFAULT_HEALTH_THRESHOLDS)
 	};
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
@@ -3645,45 +3751,46 @@ async function runCoordinator(options) {
 	emit(final);
 	recordProtocolDecision(final, { transcriptEntryCount: transcript.length });
 	const finalEvent = events.at(-1);
+	const 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",
+			runId,
+			at: "",
+			output,
+			cost: totalCost,
+			transcript: createTranscriptLink(transcript)
+		}),
+		...triggeringFailureForAbortMode !== void 0 ? { triggeringFailureForAbortMode } : {},
+		events,
+		transcript
+	};
 	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",
-				runId,
-				at: "",
-				output,
-				cost: totalCost,
-				transcript: createTranscriptLink(transcript)
-			}),
-			...triggeringFailureForAbortMode !== void 0 ? { triggeringFailureForAbortMode } : {},
-			events,
-			transcript
-		},
+		trace,
 		transcript,
 		usage: createRunUsage(totalCost),
 		metadata: createRunMetadata({
@@ -3701,7 +3808,8 @@ async function runCoordinator(options) {
 			cost: totalCost,
 			events
 		}),
-		cost: totalCost
+		cost: totalCost,
+		health: computeHealth(trace, DEFAULT_HEALTH_THRESHOLDS)
 	};
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
@@ -4063,6 +4171,7 @@ async function dispatchDelegate(input) {
 		input.dispatchedChild.controller.abort(childDeadlineReason);
 	}, childTimeoutMs) : void 0;
 	const childOptions = {
+		runId: childRunId,
 		intent: decision.intent,
 		protocol: decision.protocol,
 		tier: options.tier,
@@ -4214,11 +4323,16 @@ async function dispatchDelegate(input) {
 function renderSubRunResult(childRunId, subResult) {
 	const turns = subResult.transcript.length;
 	const costUsd = subResult.cost.usd ?? 0;
-	const startedAt = subResult.trace.events[0]?.at;
-	const endedAt = subResult.trace.events.at(-1)?.at;
+	const startedAt = eventTimestamp(subResult.trace.events[0]);
+	const endedAt = eventTimestamp(subResult.trace.events.at(-1));
 	const durationMs = startedAt && endedAt ? Math.max(0, Date.parse(endedAt) - Date.parse(startedAt)) : 0;
 	return [`[sub-run ${childRunId}]: ${subResult.output}`, `[sub-run ${childRunId} stats]: turns=${turns} costUsd=${costUsd} durationMs=${durationMs}`].join("\n");
 }
+function eventTimestamp(event) {
+	if (event === void 0) return void 0;
+	if ("at" in event) return event.at;
+	return event.type === "model-response" ? event.completedAt : event.startedAt;
+}
 /**
 * Build a JSON-serializable {@link Trace} for `sub-run-failed.partialTrace`
 * from a buffered tee of child emits. Keeps `runProtocol`'s error contract
@@ -4482,44 +4596,45 @@ async function runSequential(options) {
 	emit(final);
 	recordProtocolDecision(final, { transcriptEntryCount: transcript.length });
 	const finalEvent = events.at(-1);
+	const 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",
+			runId,
+			at: "",
+			output,
+			cost: totalCost,
+			transcript: createTranscriptLink(transcript)
+		}),
+		events,
+		transcript
+	};
 	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",
-				runId,
-				at: "",
-				output,
-				cost: totalCost,
-				transcript: createTranscriptLink(transcript)
-			}),
-			events,
-			transcript
-		},
+		trace,
 		transcript,
 		usage: createRunUsage(totalCost),
 		metadata: createRunMetadata({
@@ -4537,7 +4652,8 @@ async function runSequential(options) {
 			cost: totalCost,
 			events
 		}),
-		cost: totalCost
+		cost: totalCost,
+		health: computeHealth(trace, DEFAULT_HEALTH_THRESHOLDS)
 	};
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
@@ -4756,44 +4872,45 @@ async function runShared(options) {
 	emit(final);
 	recordProtocolDecision(final, { transcriptEntryCount: transcript.length });
 	const finalEvent = events.at(-1);
+	const 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",
+			runId,
+			at: "",
+			output,
+			cost: totalCost,
+			transcript: createTranscriptLink(transcript)
+		}),
+		events,
+		transcript
+	};
 	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",
-				runId,
-				at: "",
-				output,
-				cost: totalCost,
-				transcript: createTranscriptLink(transcript)
-			}),
-			events,
-			transcript
-		},
+		trace,
 		transcript,
 		usage: createRunUsage(totalCost),
 		metadata: createRunMetadata({
@@ -4811,7 +4928,8 @@ async function runShared(options) {
 			cost: totalCost,
 			events
 		}),
-		cost: totalCost
+		cost: totalCost,
+		health: computeHealth(trace, DEFAULT_HEALTH_THRESHOLDS)
 	};
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
@@ -4867,6 +4985,14 @@ function responseCost(response) {
 	};
 }
 //#endregion
+//#region src/runtime/tracing.ts
+var DOGPILE_SPAN_NAMES = {
+	RUN: "dogpile.run",
+	SUB_RUN: "dogpile.sub-run",
+	AGENT_TURN: "dogpile.agent-turn",
+	MODEL_CALL: "dogpile.model-call"
+};
+//#endregion
 //#region src/runtime/engine.ts
 var DEFAULT_MAX_DEPTH = 4;
 var DEFAULT_MAX_CONCURRENT_CHILDREN = 4;
@@ -4918,6 +5044,9 @@ function createEngine(options) {
 				...terminate ? { terminate } : {},
 				...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 				...options.evaluate ? { evaluate: options.evaluate } : {},
+				...options.tracer ? { tracer: options.tracer } : {},
+				...options.metricsHook ? { metricsHook: options.metricsHook } : {},
+				...options.logger ? { logger: options.logger } : {},
 				currentDepth: 0,
 				effectiveMaxDepth,
 				effectiveMaxConcurrentChildren,
@@ -5019,6 +5148,9 @@ function createEngine(options) {
 						onChildFailure,
 						...streamParentDeadlineMs !== void 0 ? { parentDeadlineMs: streamParentDeadlineMs } : {},
 						...options.defaultSubRunTimeoutMs !== void 0 ? { defaultSubRunTimeoutMs: options.defaultSubRunTimeoutMs } : {},
+						...options.tracer ? { tracer: options.tracer } : {},
+						...options.metricsHook ? { metricsHook: options.metricsHook } : {},
+						...options.logger ? { logger: options.logger } : {},
 						streamEvents: true,
 						emit(event) {
 							if (status !== "running") return;
@@ -5279,6 +5411,329 @@ function dogpileErrorStreamDetail(error) {
 	if (error.detail !== void 0) for (const [key, value] of Object.entries(error.detail)) detail[key] = value;
 	return detail;
 }
+function openRunTracing(options) {
+	if (!options.tracer) return;
+	const runSpan = options.tracer.startSpan(DOGPILE_SPAN_NAMES.RUN, {
+		...options.parentSpan ? { parent: options.parentSpan } : {},
+		attributes: {
+			"dogpile.run.protocol": options.protocolKind,
+			"dogpile.run.tier": String(options.tier),
+			"dogpile.run.intent": options.intent.slice(0, 200)
+		}
+	});
+	return {
+		tracer: options.tracer,
+		runSpan,
+		subRunSpans: /* @__PURE__ */ new Map(),
+		agentTurnSpans: /* @__PURE__ */ new Map(),
+		modelCallSpans: /* @__PURE__ */ new Map(),
+		pendingModelRequests: /* @__PURE__ */ new Map(),
+		agentTurnCounters: /* @__PURE__ */ new Map(),
+		turnAccumByAgent: /* @__PURE__ */ new Map(),
+		agentIds: /* @__PURE__ */ new Set(),
+		turnCount: 0,
+		lastCost: emptyCost()
+	};
+}
+function openRunMetrics(options) {
+	if (!options.metricsHook) return;
+	return {
+		metricsHook: options.metricsHook,
+		logger: options.logger,
+		startedAtMs: Date.now(),
+		subRunStartTimes: /* @__PURE__ */ new Map(),
+		totalCost: emptyCost(),
+		nestedCost: emptyCost(),
+		turns: 0
+	};
+}
+function routeMetricsError(err, logger) {
+	const msg = err instanceof Error ? err.message : String(err);
+	try {
+		if (logger !== void 0) logger.error("dogpile:metricsHook threw", { error: msg });
+		else console.error("dogpile:metricsHook threw", { error: msg });
+	} catch {}
+}
+function fireHook(callback, snapshot, logger) {
+	if (!callback) return;
+	try {
+		const result = callback(snapshot);
+		if (result && typeof result.catch === "function") result.catch((err) => {
+			routeMetricsError(err, logger);
+		});
+	} catch (err) {
+		routeMetricsError(err, logger);
+	}
+}
+function buildRunSnapshot(result, startedAtMs) {
+	const nestedCosts = nestedSubRunCosts(result);
+	const outcome = result.trace.events.find((event) => event.type === "budget-stop") !== void 0 ? "budget-stopped" : "completed";
+	const totalInputTokens = result.cost.inputTokens;
+	const totalOutputTokens = result.cost.outputTokens;
+	const totalCostUsd = result.cost.usd;
+	return {
+		outcome,
+		inputTokens: totalInputTokens - nestedCosts.reduce((sum, cost) => sum + cost.inputTokens, 0),
+		outputTokens: totalOutputTokens - nestedCosts.reduce((sum, cost) => sum + cost.outputTokens, 0),
+		costUsd: totalCostUsd - nestedCosts.reduce((sum, cost) => sum + cost.usd, 0),
+		totalInputTokens,
+		totalOutputTokens,
+		totalCostUsd,
+		turns: result.trace.events.filter((event) => event.type === "agent-turn").length,
+		durationMs: Date.now() - startedAtMs
+	};
+}
+function buildSubRunSnapshot(subResult, durationMs) {
+	const nestedCosts = nestedSubRunCosts(subResult);
+	const outcome = subResult.trace.events.find((event) => event.type === "budget-stop") !== void 0 ? "budget-stopped" : "completed";
+	const totalInputTokens = subResult.cost.inputTokens;
+	const totalOutputTokens = subResult.cost.outputTokens;
+	const totalCostUsd = subResult.cost.usd;
+	return {
+		outcome,
+		inputTokens: totalInputTokens - nestedCosts.reduce((sum, cost) => sum + cost.inputTokens, 0),
+		outputTokens: totalOutputTokens - nestedCosts.reduce((sum, cost) => sum + cost.outputTokens, 0),
+		costUsd: totalCostUsd - nestedCosts.reduce((sum, cost) => sum + cost.usd, 0),
+		totalInputTokens,
+		totalOutputTokens,
+		totalCostUsd,
+		turns: subResult.trace.events.filter((event) => event.type === "agent-turn").length,
+		durationMs
+	};
+}
+function nestedSubRunCosts(result) {
+	return result.trace.events.flatMap((event) => {
+		if (event.type === "sub-run-completed") return [event.subResult.cost];
+		if (event.type === "sub-run-failed") return [event.partialCost];
+		return [];
+	});
+}
+function subtractCost(total, nested) {
+	return {
+		usd: total.usd - nested.usd,
+		inputTokens: total.inputTokens - nested.inputTokens,
+		outputTokens: total.outputTokens - nested.outputTokens,
+		totalTokens: total.totalTokens - nested.totalTokens
+	};
+}
+function handleMetricsEvent(state, event) {
+	if (event.parentRunIds !== void 0) return;
+	switch (event.type) {
+		case "agent-turn":
+			state.totalCost = event.cost;
+			state.turns += 1;
+			break;
+		case "broadcast":
+		case "budget-stop":
+		case "final":
+			state.totalCost = event.cost;
+			break;
+		case "sub-run-started":
+			state.subRunStartTimes.set(event.childRunId, Date.now());
+			break;
+		case "sub-run-completed": {
+			state.totalCost = addCost(state.totalCost, event.subResult.cost);
+			state.nestedCost = addCost(state.nestedCost, event.subResult.cost);
+			const startMs = state.subRunStartTimes.get(event.childRunId);
+			const durationMs = startMs !== void 0 ? Date.now() - startMs : 0;
+			state.subRunStartTimes.delete(event.childRunId);
+			const snapshot = buildSubRunSnapshot(event.subResult, durationMs);
+			fireHook(state.metricsHook.onSubRunComplete, snapshot, state.logger);
+			break;
+		}
+		case "sub-run-failed":
+			state.totalCost = addCost(state.totalCost, event.partialCost);
+			state.nestedCost = addCost(state.nestedCost, event.partialCost);
+			state.subRunStartTimes.delete(event.childRunId);
+			break;
+		default: break;
+	}
+}
+function closeRunMetrics(state, result) {
+	if (result !== void 0) {
+		const snapshot = buildRunSnapshot(result, state.startedAtMs);
+		fireHook(state.metricsHook.onRunComplete, snapshot, state.logger);
+		return;
+	}
+	const ownCost = subtractCost(state.totalCost, state.nestedCost);
+	const snapshot = {
+		outcome: "aborted",
+		inputTokens: ownCost.inputTokens,
+		outputTokens: ownCost.outputTokens,
+		costUsd: ownCost.usd,
+		totalInputTokens: state.totalCost.inputTokens,
+		totalOutputTokens: state.totalCost.outputTokens,
+		totalCostUsd: state.totalCost.usd,
+		turns: state.turns,
+		durationMs: Date.now() - state.startedAtMs
+	};
+	fireHook(state.metricsHook.onRunComplete, snapshot, state.logger);
+}
+function handleTracingEvent(state, event) {
+	if (event.parentRunIds !== void 0) return;
+	if (state.runId === void 0) {
+		state.runId = event.runId;
+		state.runSpan.setAttribute("dogpile.run.id", event.runId);
+	}
+	switch (event.type) {
+		case "model-request": {
+			state.pendingModelRequests.set(event.callId, event);
+			state.agentIds.add(event.agentId);
+			if (!state.agentTurnSpans.has(event.agentId)) {
+				const turnNumber = (state.agentTurnCounters.get(event.agentId) ?? 0) + 1;
+				state.agentTurnCounters.set(event.agentId, turnNumber);
+				const turnParent = state.subRunSpans.get(event.runId) ?? state.runSpan;
+				const turnSpan = state.tracer.startSpan(DOGPILE_SPAN_NAMES.AGENT_TURN, {
+					parent: turnParent,
+					attributes: {
+						"dogpile.agent.id": event.agentId,
+						"dogpile.agent.role": event.role,
+						"dogpile.turn.number": turnNumber,
+						"dogpile.model.id": event.modelId
+					}
+				});
+				state.agentTurnSpans.set(event.agentId, turnSpan);
+			}
+			const callParent = state.agentTurnSpans.get(event.agentId) ?? state.subRunSpans.get(event.runId) ?? state.runSpan;
+			const callSpan = state.tracer.startSpan(DOGPILE_SPAN_NAMES.MODEL_CALL, {
+				parent: callParent,
+				attributes: {
+					"dogpile.model.id": event.modelId,
+					"dogpile.call.id": event.callId,
+					"dogpile.provider.id": event.providerId
+				}
+			});
+			state.modelCallSpans.set(event.callId, callSpan);
+			break;
+		}
+		case "model-response": {
+			const span = state.modelCallSpans.get(event.callId);
+			if (span) {
+				const inputTokens = event.response.usage?.inputTokens ?? 0;
+				const outputTokens = event.response.usage?.outputTokens ?? 0;
+				const responseCost = {
+					usd: event.response.costUsd ?? 0,
+					inputTokens,
+					outputTokens,
+					totalTokens: event.response.usage?.totalTokens ?? inputTokens + outputTokens
+				};
+				span.setAttribute("dogpile.model.input_tokens", inputTokens);
+				span.setAttribute("dogpile.model.output_tokens", outputTokens);
+				if (event.response.costUsd !== void 0) span.setAttribute("dogpile.model.cost_usd", event.response.costUsd);
+				span.setStatus("ok");
+				span.end();
+				state.modelCallSpans.delete(event.callId);
+				const accum = state.turnAccumByAgent.get(event.agentId) ?? {
+					inputTokens: 0,
+					outputTokens: 0,
+					costUsd: 0
+				};
+				accum.inputTokens += inputTokens;
+				accum.outputTokens += outputTokens;
+				accum.costUsd += responseCost.usd;
+				state.turnAccumByAgent.set(event.agentId, accum);
+				state.lastCost = addCost(state.lastCost, responseCost);
+			}
+			state.pendingModelRequests.delete(event.callId);
+			break;
+		}
+		case "agent-turn": {
+			state.agentIds.add(event.agentId);
+			state.turnCount += 1;
+			state.lastCost = event.cost;
+			const turnSpan = state.agentTurnSpans.get(event.agentId);
+			if (turnSpan) {
+				turnSpan.setAttribute("dogpile.agent.role", event.role);
+				const accum = state.turnAccumByAgent.get(event.agentId);
+				turnSpan.setAttribute("dogpile.turn.cost_usd", accum?.costUsd ?? 0);
+				turnSpan.setAttribute("dogpile.turn.input_tokens", accum?.inputTokens ?? 0);
+				turnSpan.setAttribute("dogpile.turn.output_tokens", accum?.outputTokens ?? 0);
+				turnSpan.setStatus("ok");
+				turnSpan.end();
+				state.agentTurnSpans.delete(event.agentId);
+			}
+			state.turnAccumByAgent.delete(event.agentId);
+			break;
+		}
+		case "broadcast":
+		case "budget-stop":
+		case "final":
+			state.lastCost = event.cost;
+			break;
+		case "sub-run-started": {
+			const span = state.tracer.startSpan(DOGPILE_SPAN_NAMES.SUB_RUN, {
+				parent: state.runSpan,
+				attributes: {
+					"dogpile.sub_run.child_run_id": event.childRunId,
+					"dogpile.sub_run.parent_run_id": event.parentRunId,
+					"dogpile.sub_run.depth": event.depth
+				}
+			});
+			state.subRunSpans.set(event.childRunId, span);
+			break;
+		}
+		case "sub-run-completed": {
+			const span = state.subRunSpans.get(event.childRunId);
+			if (span) {
+				span.setStatus("ok");
+				span.end();
+				state.subRunSpans.delete(event.childRunId);
+			}
+			break;
+		}
+		case "sub-run-failed": {
+			const span = state.subRunSpans.get(event.childRunId);
+			if (span) {
+				span.setStatus("error", event.error.message);
+				span.end();
+				state.subRunSpans.delete(event.childRunId);
+			}
+			break;
+		}
+		default: break;
+	}
+}
+function closeRunTracing(state, result, error) {
+	if (error !== void 0) {
+		if (state.runId !== void 0) state.runSpan.setAttribute("dogpile.run.id", state.runId);
+		state.runSpan.setAttribute("dogpile.run.agent_count", state.agentIds.size);
+		state.runSpan.setAttribute("dogpile.run.turn_count", state.turnCount);
+		state.runSpan.setAttribute("dogpile.run.cost_usd", state.lastCost.usd);
+		state.runSpan.setAttribute("dogpile.run.input_tokens", state.lastCost.inputTokens);
+		state.runSpan.setAttribute("dogpile.run.output_tokens", state.lastCost.outputTokens);
+		state.runSpan.setAttribute("dogpile.run.outcome", "aborted");
+		state.runSpan.setStatus("error", error instanceof Error ? error.message : String(error));
+		closeOpenTracingSpans(state);
+		state.runSpan.end();
+		return;
+	}
+	if (result === void 0) {
+		closeOpenTracingSpans(state);
+		state.runSpan.end();
+		return;
+	}
+	const terminationReason = result.trace.events.find((event) => event.type === "budget-stop")?.reason;
+	const outcome = terminationReason !== void 0 ? "budget-stopped" : "completed";
+	state.runSpan.setAttribute("dogpile.run.id", result.trace.runId);
+	state.runSpan.setAttribute("dogpile.run.agent_count", result.trace.agentsUsed.length);
+	state.runSpan.setAttribute("dogpile.run.turn_count", result.trace.events.filter((event) => event.type === "agent-turn").length);
+	state.runSpan.setAttribute("dogpile.run.cost_usd", result.cost.usd);
+	state.runSpan.setAttribute("dogpile.run.input_tokens", result.cost.inputTokens);
+	state.runSpan.setAttribute("dogpile.run.output_tokens", result.cost.outputTokens);
+	state.runSpan.setAttribute("dogpile.run.outcome", outcome);
+	if (terminationReason !== void 0) state.runSpan.setAttribute("dogpile.run.termination_reason", terminationReason);
+	state.runSpan.setStatus("ok");
+	closeOpenTracingSpans(state);
+	state.runSpan.end();
+}
+function closeOpenTracingSpans(state) {
+	for (const span of state.modelCallSpans.values()) span.end();
+	state.modelCallSpans.clear();
+	for (const span of state.agentTurnSpans.values()) span.end();
+	state.agentTurnSpans.clear();
+	for (const span of state.subRunSpans.values()) span.end();
+	state.subRunSpans.clear();
+}
 async function runNonStreamingProtocol(options) {
 	const failureInstancesByChildRunId = /* @__PURE__ */ new Map();
 	const abortLifecycle = createNonStreamingAbortLifecycle({
@@ -5314,7 +5769,8 @@ async function runNonStreamingProtocol(options) {
 				events
 			}),
 			eventLog: createRunEventLog(trace.runId, trace.protocol, events),
-			trace
+			trace,
+			health: computeHealth(trace, DEFAULT_HEALTH_THRESHOLDS)
 		};
 		const terminalThrow = resolveRuntimeTerminalThrow(runResult.trace, failureInstancesByChildRunId);
 		if (terminalThrow) throw terminalThrow;
@@ -5352,7 +5808,39 @@ function finalEventWithEvaluation(event, evaluation) {
 		evaluation
 	};
 }
-function runProtocol(options) {
+async function runProtocol(options) {
+	const tracing = openRunTracing({
+		...options.tracer ? { tracer: options.tracer } : {},
+		...options.parentSpan ? { parentSpan: options.parentSpan } : {},
+		intent: options.intent,
+		protocolKind: options.protocol.kind,
+		tier: options.tier
+	});
+	const metrics = openRunMetrics({
+		...options.metricsHook ? { metricsHook: options.metricsHook } : {},
+		...options.logger ? { logger: options.logger } : {}
+	});
+	const emitForProtocol = tracing || metrics || options.emit ? (event) => {
+		if (tracing) handleTracingEvent(tracing, event);
+		if (metrics) handleMetricsEvent(metrics, event);
+		options.emit?.(event);
+	} : void 0;
+	const protocolOptions = tracing ? {
+		...options,
+		subRunSpansByChildId: tracing.subRunSpans
+	} : options;
+	try {
+		const result = await runProtocolInner(protocolOptions, emitForProtocol);
+		if (tracing) closeRunTracing(tracing, result);
+		if (metrics && (options.currentDepth === 0 || options.currentDepth === void 0)) closeRunMetrics(metrics, result);
+		return result;
+	} catch (error) {
+		if (tracing) closeRunTracing(tracing, void 0, error);
+		if (metrics && (options.currentDepth === 0 || options.currentDepth === void 0)) closeRunMetrics(metrics, void 0);
+		throw error;
+	}
+}
+function runProtocolInner(options, emitForProtocol) {
 	switch (options.protocol.kind) {
 		case "sequential": return runSequential({
 			intent: options.intent,
@@ -5367,7 +5855,7 @@ function runProtocol(options) {
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
 			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
-			...options.emit ? { emit: options.emit } : {}
+			...emitForProtocol ? { emit: emitForProtocol } : {}
 		});
 		case "broadcast": return runBroadcast({
 			intent: options.intent,
@@ -5382,7 +5870,7 @@ function runProtocol(options) {
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
 			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
-			...options.emit ? { emit: options.emit } : {}
+			...emitForProtocol ? { emit: emitForProtocol } : {}
 		});
 		case "coordinator": return runCoordinator({
 			intent: options.intent,
@@ -5397,7 +5885,7 @@ function runProtocol(options) {
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
 			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
-			...options.emit ? { emit: options.emit } : {},
+			...emitForProtocol ? { emit: emitForProtocol } : {},
 			...options.streamEvents !== void 0 ? { streamEvents: options.streamEvents } : {},
 			currentDepth: options.currentDepth ?? 0,
 			effectiveMaxDepth: options.effectiveMaxDepth ?? Infinity,
@@ -5407,10 +5895,17 @@ function runProtocol(options) {
 			...options.defaultSubRunTimeoutMs !== void 0 ? { defaultSubRunTimeoutMs: options.defaultSubRunTimeoutMs } : {},
 			...options.registerAbortDrain !== void 0 ? { registerAbortDrain: options.registerAbortDrain } : {},
 			...options.failureInstancesByChildRunId !== void 0 ? { failureInstancesByChildRunId: options.failureInstancesByChildRunId } : {},
-			runProtocol: (childInput) => runProtocol({
-				...childInput,
-				protocol: normalizeProtocol(childInput.protocol)
-			})
+			runProtocol: (childInput) => {
+				const { runId: childRunId, ...childProtocolInput } = childInput;
+				const childParent = options.subRunSpansByChildId?.get(childRunId) ?? options.parentSpan;
+				return runProtocol({
+					...childProtocolInput,
+					protocol: normalizeProtocol(childProtocolInput.protocol),
+					...options.tracer ? { tracer: options.tracer } : {},
+					...childParent ? { parentSpan: childParent } : {},
+					...options.logger ? { logger: options.logger } : {}
+				});
+			}
 		});
 		case "shared": return runShared({
 			intent: options.intent,
@@ -5425,7 +5920,7 @@ function runProtocol(options) {
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
 			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
-			...options.emit ? { emit: options.emit } : {}
+			...emitForProtocol ? { emit: emitForProtocol } : {}
 		});
 	}
 }
@@ -5473,6 +5968,12 @@ function stream(options) {
 * the ergonomic {@link RunResult} wrapper from the JSON-serializable
 * {@link Trace} returned by a previous `run()`, `stream()`, or
 * `Dogpile.pile()` call.
+*
+* Tracing and metrics: replay is intentionally tracing-free and metrics-free.
+* Even when an engine instance has been configured with a `tracer` or
+* `metricsHook` on its `EngineOptions`, calling this function emits no spans
+* or callbacks — replaying historical events with current timestamps would
+* confuse observability backends. See `docs/developer-usage.md`.
 */
 function replay(trace) {
 	const cost = trace.finalOutput.cost;
@@ -5482,7 +5983,7 @@ function replay(trace) {
 	if (replayThrow) throw replayThrow;
 	const baseResult = {
 		output: trace.finalOutput.output,
-		eventLog: createRunEventLog(trace.runId, trace.protocol, trace.events),
+		eventLog: createRunEventLog(trace.runId, trace.protocol, synthesizeProviderEvents(trace, trace.providerCalls)),
 		trace,
 		transcript: trace.transcript,
 		usage: createRunUsage(cost),
@@ -5495,7 +5996,8 @@ function replay(trace) {
 			events: trace.events
 		}),
 		accounting,
-		cost
+		cost,
+		health: computeHealth(trace, DEFAULT_HEALTH_THRESHOLDS)
 	};
 	if (lastEvent?.type !== "final") return baseResult;
 	return {
@@ -5504,6 +6006,46 @@ function replay(trace) {
 		...lastEvent.evaluation !== void 0 ? { evaluation: lastEvent.evaluation } : {}
 	};
 }
+function synthesizeProviderEvents(trace, providerCalls) {
+	if (trace.events.some((event) => event.type === "model-request" || event.type === "model-response")) return trace.events;
+	const baseEvents = trace.events.filter((event) => event.type !== "model-request" && event.type !== "model-response");
+	const result = [];
+	let turnCount = 0;
+	for (const event of baseEvents) {
+		if (event.type === "agent-turn") {
+			const call = providerCalls[turnCount];
+			if (call !== void 0) {
+				const modelId = typeof call.modelId === "string" && call.modelId.length > 0 ? call.modelId : call.providerId;
+				result.push({
+					type: "model-request",
+					runId: trace.runId,
+					callId: call.callId,
+					providerId: call.providerId,
+					modelId,
+					startedAt: call.startedAt,
+					agentId: call.agentId,
+					role: call.role,
+					request: call.request
+				});
+				result.push({
+					type: "model-response",
+					runId: trace.runId,
+					callId: call.callId,
+					providerId: call.providerId,
+					modelId,
+					startedAt: call.startedAt,
+					completedAt: call.completedAt,
+					agentId: call.agentId,
+					role: call.role,
+					response: call.response
+				});
+			}
+			turnCount += 1;
+		}
+		result.push(event);
+	}
+	return result;
+}
 function resolveRuntimeTerminalThrow(trace, failureInstancesByChildRunId) {
 	if (trace.triggeringFailureForAbortMode !== void 0) return failureInstancesByChildRunId.get(trace.triggeringFailureForAbortMode.childRunId) ?? null;
 	const finalEvent = trace.events.at(-1);
@@ -5566,10 +6108,17 @@ function dogpileErrorFromSerializedPayload(input) {
 * Replay a saved completed trace as a stream without invoking a model provider.
 *
 * @remarks
-* This is the streaming counterpart to {@link replay}. It yields the exact
-* saved {@link Trace.events} in order and resolves {@link StreamHandle.result}
-* to the rehydrated {@link RunResult}. Since all data comes from the trace,
-* replay remains storage-free and provider-free.
+* This is the streaming counterpart to {@link replay}. It yields the same
+* event sequence exposed by the replayed result event log, including legacy
+* provenance synthesis when a saved trace predates model request/response
+* events. Since all data comes from the trace, replay remains storage-free and
+* provider-free.
+*
+* Tracing and metrics: replayStream is intentionally tracing-free and
+* metrics-free. Even when an engine instance has been configured with a
+* `tracer` or `metricsHook` on its `EngineOptions`, calling this function
+* emits no spans or callbacks — replaying historical events with current
+* timestamps would confuse observability backends. See `docs/developer-usage.md`.
 */
 function replayStream(trace) {
 	const result = Promise.resolve(replay(trace));
@@ -5605,7 +6154,7 @@ function replayStream(trace) {
 }
 function replayStreamEvents(trace, parentRunIds = []) {
 	const events = [];
-	for (const event of trace.events) {
+	for (const event of synthesizeProviderEvents(trace, trace.providerCalls)) {
 		if (event.type === "sub-run-completed") events.push(...replayStreamEvents(event.subResult.trace, [...parentRunIds, trace.runId]));
 		events.push(wrapReplayStreamEvent(event, parentRunIds));
 	}
@@ -5714,6 +6263,7 @@ function createOpenAICompatibleProvider(options) {
 	});
 	return {
 		id: providerId,
+		modelId: options.model,
 		metadata: { locality: resolvedLocality },
 		async generate(request) {
 			let response;
@@ -6278,6 +6828,6 @@ function defaultSleep(ms, signal) {
 	});
 }
 //#endregion
-export { DEFAULT_RETRYABLE_DOGPILE_CODES, Dogpile, DogpileError, budget, builtInDogpileToolIdentity, builtInDogpileToolInputSchema, builtInDogpileToolPermissions, combineTerminationDecisions, consoleLogger, convergence, createCodeExecToolAdapter, createEngine, createOpenAICompatibleProvider, createRuntimeToolExecutor, createWebSearchToolAdapter, evaluateBudget, evaluateConvergence, evaluateFirstOf, evaluateJudge, evaluateTermination, evaluateTerminationStop, firstOf, judge, loggerFromEvents, noopLogger, normalizeBuiltInDogpileTool, normalizeBuiltInDogpileTools, normalizeRuntimeToolAdapterError, replay, replayStream, run, runtimeToolAvailability, runtimeToolManifest, stream, validateBuiltInDogpileToolInput, withRetry };
+export { DEFAULT_RETRYABLE_DOGPILE_CODES, DOGPILE_SPAN_NAMES, Dogpile, DogpileError, budget, builtInDogpileToolIdentity, builtInDogpileToolInputSchema, builtInDogpileToolPermissions, combineTerminationDecisions, consoleLogger, convergence, createCodeExecToolAdapter, createEngine, createOpenAICompatibleProvider, createRuntimeToolExecutor, createWebSearchToolAdapter, evaluateBudget, evaluateConvergence, evaluateFirstOf, evaluateJudge, evaluateTermination, evaluateTerminationStop, firstOf, judge, loggerFromEvents, noopLogger, normalizeBuiltInDogpileTool, normalizeBuiltInDogpileTools, normalizeRuntimeToolAdapterError, replay, replayStream, run, runtimeToolAvailability, runtimeToolManifest, stream, validateBuiltInDogpileToolInput, withRetry };
 
 //# sourceMappingURL=index.js.map