@dogpile/sdk 0.2.2 → 0.3.1

package/dist/browser/index.js

@@ -67,6 +67,39 @@ function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
+//#region src/runtime/ids.ts
+/**
+* Repo-internal id and timing helpers used across all four protocols.
+*
+* Centralized here so a change to id format or fallback semantics happens in
+* exactly one place — switching `protocol` must not change the run-id contract.
+*/
+/**
+* Generates a fresh run id using `globalThis.crypto.randomUUID`.
+*
+* Throws a `DogpileError` when no UUID source is available rather than falling
+* back to a millisecond-based id (which collides under back-to-back runs in
+* the same tick). Node 22+, Bun latest, and modern browsers all expose
+* `crypto.randomUUID`; environments without it are unsupported by Dogpile.
+*/
+function createRunId() {
+	const random = globalThis.crypto?.randomUUID?.();
+	if (typeof random === "string" && random.length > 0) return random;
+	throw new DogpileError({
+		code: "invalid-configuration",
+		message: "Dogpile requires globalThis.crypto.randomUUID to mint a run id. Run on Node 22+, Bun latest, or a modern browser ESM environment."
+	});
+}
+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}`;
+}
+//#endregion
 //#region src/runtime/defaults.ts
 function normalizeProtocol(protocol) {
 	if (typeof protocol !== "string") return protocol;
@@ -638,6 +671,10 @@ function firstOf(...conditions) {
 * own normalized inputs so one stop class cannot accidentally satisfy another.
 */
 function evaluateTermination(condition, context) {
+	if (isTerminationFloorBlocked(condition, context)) return {
+		type: "continue",
+		condition
+	};
 	switch (condition.kind) {
 		case "budget": return evaluateBudget(condition, context);
 		case "firstOf": return evaluateFirstOf(condition, context).decision;
@@ -695,6 +732,17 @@ function evaluateTerminationStop(condition, context) {
 	return stopRecord(condition, decision);
 }
 /**
+* Warn when a protocol-level termination floor cannot be satisfied because a
+* lower iteration cap will stop the run first.
+*/
+function warnOnProtocolTerminationMisconfiguration(protocol, terminate, warn = console.warn) {
+	const minTurns = protocolMinTurns(protocol);
+	if (minTurns === void 0 || !terminate) return;
+	const limitingIterationBudget = smallestIterationBudget(terminate);
+	if (limitingIterationBudget === void 0 || limitingIterationBudget >= minTurns) return;
+	warn(`[dogpile] protocol.minTurns (${minTurns}) exceeds terminate budget maxIterations (${limitingIterationBudget}); maxIterations will win.`);
+}
+/**
 * Combine independently evaluated termination decisions with SDK precedence.
 *
 * Budget caps win over judge decisions, and judge decisions win over
@@ -843,6 +891,48 @@ function stopPrecedence(reason) {
 	if (reason.startsWith("judge:")) return 1;
 	return 2;
 }
+function isTerminationFloorBlocked(condition, context) {
+	if (condition.kind !== "convergence" && condition.kind !== "judge") return false;
+	const floor = protocolTerminationFloor(context.protocolConfig);
+	if (floor === void 0 || floor <= 0) return false;
+	return protocolProgress(context) < floor;
+}
+function protocolTerminationFloor(protocol) {
+	if (!protocol) return;
+	switch (protocol.kind) {
+		case "broadcast": return protocol.minRounds;
+		case "coordinator":
+		case "sequential":
+		case "shared": return protocol.minTurns;
+	}
+}
+function protocolProgress(context) {
+	return context.protocolIteration ?? context.iteration ?? context.transcript.length;
+}
+function protocolMinTurns(protocol) {
+	switch (protocol.kind) {
+		case "broadcast": return;
+		case "coordinator":
+		case "sequential":
+		case "shared": return protocol.minTurns;
+	}
+}
+function smallestIterationBudget(condition) {
+	switch (condition.kind) {
+		case "budget": return condition.maxIterations;
+		case "convergence":
+		case "judge": return;
+		case "firstOf": {
+			let smallest;
+			for (const child of condition.conditions) {
+				const budget = smallestIterationBudget(child);
+				if (budget === void 0) continue;
+				smallest = smallest === void 0 ? budget : Math.min(smallest, budget);
+			}
+			return smallest;
+		}
+	}
+}
 function judgeStopDetail(decision, minScore) {
 	return {
 		decision: decision.type,
@@ -921,6 +1011,7 @@ function validateDogpileOptions(options) {
 	validateOptionalTemperature(options.temperature, "temperature");
 	validateOptionalBudgetCaps(options.budget, "budget");
 	validateOptionalTerminationCondition(options.terminate, "terminate");
+	validateOptionalWrapUpHint(options.wrapUpHint, "wrapUpHint");
 	validateOptionalFunction(options.evaluate, "evaluate");
 	validateOptionalSeed(options.seed, "seed");
 	validateOptionalAbortSignal(options.signal, "signal");
@@ -941,6 +1032,7 @@ function validateEngineOptions(options) {
 	validateOptionalTemperature(options.temperature, "temperature");
 	validateOptionalBudgetCaps(options.budget, "budget");
 	validateOptionalTerminationCondition(options.terminate, "terminate");
+	validateOptionalWrapUpHint(options.wrapUpHint, "wrapUpHint");
 	validateOptionalFunction(options.evaluate, "evaluate");
 	validateOptionalSeed(options.seed, "seed");
 	validateOptionalAbortSignal(options.signal, "signal");
@@ -973,10 +1065,12 @@ function validateProtocolConfig(value, path) {
 		case "sequential":
 		case "shared":
 			validateOptionalPositiveInteger(record.maxTurns, `${path}.maxTurns`);
+			validateOptionalNonNegativeInteger(record.minTurns, `${path}.minTurns`);
 			if (kind === "shared") validateOptionalString(record.organizationalMemory, `${path}.organizationalMemory`);
 			return;
 		case "broadcast":
 			validateOptionalPositiveInteger(record.maxRounds, `${path}.maxRounds`);
+			validateOptionalNonNegativeInteger(record.minRounds, `${path}.minRounds`);
 			return;
 	}
 }
@@ -1144,6 +1238,20 @@ function validateJudgeRubric(value, path) {
 function validateOptionalTemperature(value, path) {
 	validateOptionalNumberInRange(value, path, 0, 2);
 }
+function validateOptionalWrapUpHint(value, path) {
+	if (value === void 0) return;
+	const record = requireRecord(value, path);
+	validateOptionalNonNegativeInteger(record.atIteration, `${path}.atIteration`);
+	validateOptionalNumberInRange(record.atFraction, `${path}.atFraction`, 0, 1);
+	validateOptionalFunction(record.inject, `${path}.inject`);
+	if (record.atIteration === void 0 && record.atFraction === void 0) invalidConfiguration({
+		path,
+		rule: "object",
+		message: "wrapUpHint must configure atIteration or atFraction.",
+		expected: "WrapUpHintConfig with atIteration or atFraction",
+		actual: value
+	});
+}
 function validateOptionalSeed(value, path) {
 	if (value === void 0) return;
 	if (typeof value === "string") return;
@@ -1327,7 +1435,7 @@ function describeValue(value) {
 	return typeof value;
 }
 //#endregion
-//#region src/runtime/tools.ts
+//#region src/runtime/tools/built-in.ts
 var webSearchIdentity = {
 	id: "dogpile.tools.webSearch",
 	namespace: "dogpile",
@@ -1413,9 +1521,6 @@ function builtInDogpileToolIdentity(name) {
 function builtInDogpileToolInputSchema(name) {
 	return name === "webSearch" ? webSearchInputSchema : codeExecInputSchema;
 }
-/**
-* Return the default permission declarations for one built-in tool name.
-*/
 function builtInDogpileToolPermissions(name) {
 	return name === "webSearch" ? webSearchPermissions : codeExecPermissions;
 }
@@ -1426,348 +1531,91 @@ function validateBuiltInDogpileToolInput(name, input) {
 		issues
 	};
 }
-/**
-* Create the shared runtime tool executor used by every first-party protocol.
-*
-* @remarks
-* The executor owns call id generation, read-only trace context construction,
-* adapter validation, error normalization, and matched `tool-call` /
-* `tool-result` events. Protocols only supply a normalized
-* {@link RuntimeToolExecutionRequest}, which keeps tool execution independent
-* of Coordinator, Sequential, Broadcast, or Shared control flow.
-*/
-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,
+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,
-				input: request.input,
-				...request.agentId ? { agentId: request.agentId } : {},
-				...request.role ? { role: request.role } : {}
+				error: {
+					code: "unavailable",
+					message: "No fetch implementation is available for webSearch.",
+					retryable: false
+				}
+			};
+			const request = options.buildRequest ? options.buildRequest(input, context) : defaultWebSearchRequest(options, input, context);
+			const response = await fetchImplementation(request.url, {
+				...request.init,
+				...context.abortSignal ? { signal: context.abortSignal } : {}
 			});
-			const result = await executeRuntimeTool(tool, identity, request.input, context);
-			options.emit?.({
-				type: "tool-result",
-				runId: options.runId,
-				at: (/* @__PURE__ */ new Date()).toISOString(),
-				toolCallId,
+			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,
-				result,
-				...request.agentId ? { agentId: request.agentId } : {},
-				...request.role ? { role: request.role } : {}
-			});
-			return result;
+				output
+			};
 		}
-	};
-}
-/**
-* Return a JSON-serializable manifest for tools visible to a protocol run.
-*/
-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)
-		};
 	});
 }
-/**
-* Return request metadata that makes runtime tools visible to provider
-* adapters, or an empty object when no tools are available.
-*/
-function runtimeToolAvailability(tools) {
-	const manifest = runtimeToolManifest(tools);
-	return manifest.length > 0 ? { tools: manifest } : {};
-}
-/**
-* Execute normalized tool requests returned by a provider response.
-*/
-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 }
-	};
+function createCodeExecToolAdapter(options) {
+	const identity = mergeIdentity(codeExecIdentity, options.identity);
+	const permissions = options.permissions ?? codeExecPermissionsFor(options.languages ?? codeExecLanguages, options.allowNetwork ?? false);
 	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}`;
-}
-/**
-* Convert an unknown adapter failure into Dogpile's serializable error data.
-*/
-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 }
-	};
-}
-/**
-* Create Dogpile's built-in fetch-based web search adapter.
-*
-* @remarks
-* The adapter is backend-neutral: by default it sends a GET request with
-* `q` and `limit` query parameters, then accepts either `{ results: [...] }`
-* or a bare array of result objects from the response JSON. Callers can replace
-* request construction or response parsing for a specific search API while
-* keeping Dogpile's shared runtime tool contract, identity, permissions, input
-* validation, and serializable errors.
-*/
-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, context);
-			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
-			};
-		}
-	});
-}
-/**
-* Create Dogpile's built-in code execution adapter around a caller-owned sandbox.
-*
-* @remarks
-* Dogpile core stays runtime-portable and never evaluates code itself. This
-* adapter supplies the stable `codeExec` identity, schema, permissions,
-* validation, timeout defaults, abort handling, and serializable errors while
-* the host application owns the sandbox boundary.
-*/
-function createCodeExecToolAdapter(options) {
-	const identity = mergeIdentity(codeExecIdentity, options.identity);
-	const permissions = options.permissions ?? codeExecPermissionsFor(options.languages ?? codeExecLanguages, options.allowNetwork ?? false);
-	return {
-		identity,
-		inputSchema: codeExecInputSchemaFor(options.languages ?? codeExecLanguages),
-		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)
-				};
-			}
-		}
+		identity,
+		inputSchema: codeExecInputSchemaFor(options.languages ?? codeExecLanguages),
+		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: serializeValidationIssues(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) {
@@ -1796,9 +1644,6 @@ function normalizeBuiltInDogpileTool(definition) {
 		}
 	}
 }
-/**
-* Normalize configured built-in Dogpile tool executors into runtime tools.
-*/
 function normalizeBuiltInDogpileTools(tools) {
 	const normalized = [];
 	if (tools.webSearch) normalized.push(normalizeBuiltInDogpileTool(asWebSearchDefinition(tools.webSearch)));
@@ -1815,7 +1660,7 @@ async function executeBuiltInTool(identity, execute, input, context, name) {
 			code: "invalid-input",
 			message: `Invalid ${name} tool input.`,
 			retryable: false,
-			detail: { issues: validation.issues }
+			detail: { issues: serializeValidationIssues(validation.issues) }
 		}
 	};
 	try {
@@ -1850,6 +1695,27 @@ function mergeIdentity(defaultIdentity, options) {
 		...options.description !== void 0 ? { description: options.description } : {}
 	};
 }
+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 defaultWebSearchRequest(options, input, _context) {
 	const url = new URL(String(options.endpoint));
 	url.searchParams.set("q", input.query);
@@ -1969,107 +1835,471 @@ function jsonString(value, fieldName) {
 	return value;
 }
 function optionalJsonString(value, fieldName) {
-	if (value === void 0) return;
+	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;
+	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 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 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";
+}
+function serializeValidationIssues(issues) {
+	return issues.map((issue) => ({
+		code: issue.code,
+		path: issue.path,
+		message: issue.message,
+		...issue.detail !== void 0 ? { detail: issue.detail } : {}
+	}));
+}
+//#endregion
+//#region src/runtime/tools.ts
+/**
+* Create the shared runtime tool executor used by every first-party protocol.
+*
+* @remarks
+* The executor owns call id generation, read-only trace context construction,
+* adapter validation, error normalization, and matched `tool-call` /
+* `tool-result` events. Protocols only supply a normalized
+* {@link RuntimeToolExecutionRequest}, which keeps tool execution independent
+* of Coordinator, Sequential, Broadcast, or Shared control flow.
+*/
+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;
+		}
+	};
+}
+/**
+* Return a JSON-serializable manifest for tools visible to a protocol run.
+*/
+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)
+		};
+	});
+}
+/**
+* Return request metadata that makes runtime tools visible to provider
+* adapters, or an empty object when no tools are available.
+*/
+function runtimeToolAvailability(tools) {
+	const manifest = runtimeToolManifest(tools);
+	return manifest.length > 0 ? { tools: manifest } : {};
+}
+/**
+* Execute normalized tool requests returned by a provider response.
+*/
+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 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 = tool.validateInput?.(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 mergeToolMetadata(base, request) {
+	return {
+		...base ?? {},
+		...request ?? {}
+	};
+}
+function defaultToolCallId(runId, callIndex) {
+	return `${runId}:tool-${callIndex + 1}`;
+}
+//#endregion
+//#region src/runtime/wrap-up.ts
+function createWrapUpHintController(options) {
+	const hint = options.wrapUpHint;
+	const effectiveBudget = effectiveWrapUpBudget(options.budget, options.terminate);
+	let emitted = false;
+	return {
+		context(context) {
+			return wrapUpEvaluationContext({
+				...context,
+				tier: options.tier,
+				...effectiveBudget !== void 0 ? { budget: effectiveBudget } : {}
+			});
+		},
+		inject(messages, context) {
+			if (!hint || emitted) return messages;
+			const evaluationContext = wrapUpEvaluationContext({
+				...context,
+				tier: options.tier,
+				...effectiveBudget !== void 0 ? { budget: effectiveBudget } : {}
+			});
+			if (!shouldInjectWrapUpHint(hint, evaluationContext)) return messages;
+			const content = (hint.inject ?? defaultWrapUpHint)(evaluationContext);
+			emitted = true;
+			return [
+				messages[0] ?? {
+					role: "system",
+					content: ""
+				},
+				{
+					role: "system",
+					content
+				},
+				...messages.slice(1)
+			];
+		}
+	};
 }
-function optionalJsonObject(value, fieldName) {
-	if (value === void 0) return;
-	if (!isJsonObject(value)) throw {
-		code: "backend-error",
-		message: `Web search result ${fieldName} must be a JSON object when present.`,
-		retryable: false
+function wrapUpEvaluationContext(options) {
+	const iteration = options.iteration ?? options.transcript.length;
+	const elapsedMs = options.elapsedMs;
+	return {
+		runId: options.runId,
+		protocol: options.protocol,
+		tier: options.tier,
+		cost: options.cost,
+		events: options.events,
+		transcript: options.transcript,
+		...options.protocolConfig !== void 0 ? { protocolConfig: options.protocolConfig } : {},
+		...iteration !== void 0 ? { iteration } : {},
+		...options.protocolIteration !== void 0 ? { protocolIteration: options.protocolIteration } : {},
+		...elapsedMs !== void 0 ? { elapsedMs } : {},
+		...options.budget !== void 0 ? { budget: options.budget } : {},
+		...options.budget !== void 0 ? { remainingBudget: remainingBudget(options.budget, {
+			cost: options.cost,
+			iteration,
+			elapsedMs
+		}) } : {},
+		...options.metadata !== void 0 ? { metadata: options.metadata } : {}
 	};
-	return value;
 }
-function isJsonObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+function shouldInjectWrapUpHint(hint, context) {
+	const iteration = context.iteration ?? context.transcript.length;
+	if (hint.atIteration !== void 0 && iteration >= hint.atIteration) return true;
+	if (hint.atFraction === void 0 || context.budget === void 0) return false;
+	const fraction = hint.atFraction;
+	return capFractionReached(iteration, context.budget.maxIterations, fraction) || capFractionReached(context.elapsedMs, context.budget.timeoutMs, fraction);
 }
-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 capFractionReached(current, limit, fraction) {
+	if (current === void 0 || limit === void 0 || limit <= 0) return false;
+	return current / limit >= fraction;
 }
-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 }
-		});
+function remainingBudget(budget, current) {
+	return {
+		...budget.maxIterations !== void 0 && current.iteration !== void 0 ? { iterations: Math.max(0, budget.maxIterations - current.iteration) } : {},
+		...budget.timeoutMs !== void 0 && current.elapsedMs !== void 0 ? { timeoutMs: Math.max(0, budget.timeoutMs - current.elapsedMs) } : {},
+		...budget.maxUsd !== void 0 ? { usd: Math.max(0, budget.maxUsd - current.cost.usd) } : {},
+		...budget.maxTokens !== void 0 ? { tokens: Math.max(0, budget.maxTokens - current.cost.totalTokens) } : {}
+	};
+}
+function defaultWrapUpHint(context) {
+	const parts = [];
+	const remaining = context.remainingBudget;
+	if (remaining?.iterations !== void 0) {
+		const label = remaining.iterations === 1 ? "turn" : "turns";
+		parts.push(`${remaining.iterations} ${label} remaining`);
 	}
-	return issues;
+	if (remaining?.timeoutMs !== void 0) parts.push(`${formatRemainingTime(remaining.timeoutMs)} remaining`);
+	return `[wrap-up] ${parts.length === 0 ? "You are approaching a configured hard limit." : `You are approaching a hard limit with ${parts.join(" and ")}.`} If you have enough context, package your work now and return a final-ready answer.`;
+}
+function formatRemainingTime(timeoutMs) {
+	if (timeoutMs >= 1e3) return `${(timeoutMs / 1e3).toFixed(1)}s`;
+	return `${timeoutMs}ms`;
+}
+function effectiveWrapUpBudget(budget, terminate) {
+	const terminationBudget = budgetCapsFromTermination(terminate);
+	if (!budget && !terminationBudget) return;
+	const maxUsd = minCap(budget?.maxUsd, terminationBudget?.maxUsd);
+	const maxTokens = minCap(budget?.maxTokens, terminationBudget?.maxTokens);
+	const maxIterations = minCap(budget?.maxIterations, terminationBudget?.maxIterations);
+	const timeoutMs = minCap(budget?.timeoutMs, terminationBudget?.timeoutMs);
+	return {
+		...maxUsd !== void 0 ? { maxUsd } : {},
+		...maxTokens !== void 0 ? { maxTokens } : {},
+		...maxIterations !== void 0 ? { maxIterations } : {},
+		...timeoutMs !== void 0 ? { timeoutMs } : {}
+	};
 }
-function isCodeExecLanguage(value) {
-	return value === "javascript" || value === "typescript" || value === "python" || value === "bash" || value === "shell";
+function budgetCapsFromTermination(condition) {
+	if (!condition) return;
+	switch (condition.kind) {
+		case "budget": return {
+			...condition.maxUsd !== void 0 ? { maxUsd: condition.maxUsd } : {},
+			...condition.maxTokens !== void 0 ? { maxTokens: condition.maxTokens } : {},
+			...condition.maxIterations !== void 0 ? { maxIterations: condition.maxIterations } : {},
+			...condition.timeoutMs !== void 0 ? { timeoutMs: condition.timeoutMs } : {}
+		};
+		case "firstOf": {
+			let merged;
+			for (const child of condition.conditions) merged = mergeBudgetCaps(merged, budgetCapsFromTermination(child));
+			return merged;
+		}
+		case "convergence":
+		case "judge": return;
+	}
 }
-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 mergeBudgetCaps(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	const maxUsd = minCap(left.maxUsd, right.maxUsd);
+	const maxTokens = minCap(left.maxTokens, right.maxTokens);
+	const maxIterations = minCap(left.maxIterations, right.maxIterations);
+	const timeoutMs = minCap(left.timeoutMs, right.timeoutMs);
+	return {
+		...maxUsd !== void 0 ? { maxUsd } : {},
+		...maxTokens !== void 0 ? { maxTokens } : {},
+		...maxIterations !== void 0 ? { maxIterations } : {},
+		...timeoutMs !== void 0 ? { timeoutMs } : {}
+	};
 }
-function isRuntimeToolAdapterErrorCode(value) {
-	return value === "invalid-input" || value === "permission-denied" || value === "timeout" || value === "aborted" || value === "unavailable" || value === "backend-error" || value === "unknown";
+function minCap(left, right) {
+	if (left === void 0) return right;
+	if (right === void 0) return left;
+	return Math.min(left, right);
 }
 //#endregion
 //#region src/runtime/broadcast.ts
 async function runBroadcast(options) {
-	const runId = createRunId$3();
+	const runId = createRunId();
 	const events = [];
 	const transcript = [];
 	const protocolDecisions = [];
@@ -2078,9 +2308,17 @@ async function runBroadcast(options) {
 	const maxRounds = options.protocol.maxRounds ?? 2;
 	let firstRoundContributions = [];
 	let lastContributions = [];
-	const startedAtMs = nowMs$3();
+	const startedAtMs = nowMs();
 	let stopped = false;
 	let termination;
+	const wrapUpHint = createWrapUpHintController({
+		protocol: options.protocol,
+		tier: options.tier,
+		...options.budget ? { budget: options.budget } : {},
+		...options.terminate ? { terminate: options.terminate } : {},
+		...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {}
+	});
+	warnOnProtocolTerminationMisconfiguration(options.protocol, options.terminate);
 	const emit = (event) => {
 		events.push(event);
 		options.emit?.(event);
@@ -2134,13 +2372,21 @@ async function runBroadcast(options) {
 					round,
 					...toolAvailability
 				},
-				messages: [{
+				messages: wrapUpHint.inject([{
 					role: "system",
 					content: buildSystemPrompt$3(agent)
 				}, {
 					role: "user",
 					content: input
-				}]
+				}], {
+					runId,
+					protocol: "broadcast",
+					cost: totalCost,
+					events,
+					transcript,
+					iteration: transcript.length,
+					elapsedMs: elapsedMs(startedAtMs)
+				})
 			};
 			const response = await generateModelTurn({
 				model: options.model,
@@ -2149,7 +2395,7 @@ async function runBroadcast(options) {
 				agent,
 				input,
 				emit,
-				callId: providerCallIdFor$2(runId, providerCalls.length + agentIndex + 1),
+				callId: providerCallIdFor(runId, providerCalls.length + agentIndex + 1),
 				onProviderCall(call) {
 					providerCallSlots[agentIndex] = call;
 				}
@@ -2305,16 +2551,17 @@ async function runBroadcast(options) {
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
 		if (stopped || !options.terminate) return stopped;
-		const stopRecord = evaluateTerminationStop(options.terminate, {
+		const stopRecord = evaluateTerminationStop(options.terminate, wrapUpHint.context({
 			runId,
 			protocol: "broadcast",
-			tier: options.tier,
+			protocolConfig: options.protocol,
+			protocolIteration: broadcastRoundsCompleted(events),
 			cost: totalCost,
 			events,
 			transcript,
 			iteration: transcript.length,
-			elapsedMs: elapsedMs$3(startedAtMs)
-		});
+			elapsedMs: elapsedMs(startedAtMs)
+		}));
 		if (!stopRecord) return false;
 		stopped = true;
 		termination = stopRecord;
@@ -2329,13 +2576,16 @@ async function runBroadcast(options) {
 			reason: record.budgetReason ?? "cost",
 			cost: totalCost,
 			iteration: transcript.length,
-			elapsedMs: elapsedMs$3(startedAtMs),
+			elapsedMs: elapsedMs(startedAtMs),
 			detail: record.detail ?? {}
 		};
 		emit(event);
 		recordProtocolDecision(event, { transcriptEntryCount: transcript.length });
 	}
 }
+function broadcastRoundsCompleted(events) {
+	return events.filter((event) => event.type === "broadcast").length;
+}
 function buildSystemPrompt$3(agent) {
 	const instruction = agent.instructions ? `\nInstructions: ${agent.instructions}` : "";
 	return `You are ${agent.id}, acting as ${agent.role} in a Broadcast multi-agent protocol.${instruction}`;
@@ -2356,22 +2606,10 @@ function responseCost$3(response) {
 		totalTokens: response.usage?.totalTokens ?? 0
 	};
 }
-function createRunId$3() {
-	return globalThis.crypto?.randomUUID?.() ?? `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}`;
-}
 //#endregion
 //#region src/runtime/coordinator.ts
 async function runCoordinator(options) {
-	const runId = createRunId$2();
+	const runId = createRunId();
 	const events = [];
 	const transcript = [];
 	const protocolDecisions = [];
@@ -2380,9 +2618,17 @@ async function runCoordinator(options) {
 	const maxTurns = options.protocol.maxTurns ?? options.agents.length;
 	const activeAgents = options.agents.slice(0, maxTurns);
 	const coordinator = activeAgents[0];
-	const startedAtMs = nowMs$2();
+	const startedAtMs = nowMs();
 	let stopped = false;
 	let termination;
+	const wrapUpHint = createWrapUpHintController({
+		protocol: options.protocol,
+		tier: options.tier,
+		...options.budget ? { budget: options.budget } : {},
+		...options.terminate ? { terminate: options.terminate } : {},
+		...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {}
+	});
+	warnOnProtocolTerminationMisconfiguration(options.protocol, options.terminate);
 	const emit = (event) => {
 		events.push(event);
 		options.emit?.(event);
@@ -2432,6 +2678,9 @@ async function runCoordinator(options) {
 				providerCalls,
 				toolExecutor,
 				toolAvailability,
+				events,
+				startedAtMs,
+				wrapUpHint,
 				emit,
 				recordProtocolDecision
 			});
@@ -2448,11 +2697,16 @@ async function runCoordinator(options) {
 				options,
 				runId,
 				turn: transcript.length + index + 1,
-				providerCallId: providerCallIdFor$1(runId, providerCalls.length + index + 1),
+				providerCallId: providerCallIdFor(runId, providerCalls.length + index + 1),
 				providerCallIndex: index,
 				providerCallSlots,
 				toolExecutor,
 				toolAvailability,
+				totalCost,
+				events,
+				transcript: planTranscript,
+				startedAtMs,
+				wrapUpHint,
 				emit
 			})));
 			providerCalls.push(...providerCallSlots.filter((call) => call !== void 0));
@@ -2499,6 +2753,9 @@ async function runCoordinator(options) {
 				providerCalls,
 				toolExecutor,
 				toolAvailability,
+				events,
+				startedAtMs,
+				wrapUpHint,
 				emit,
 				recordProtocolDecision
 			});
@@ -2579,16 +2836,17 @@ async function runCoordinator(options) {
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
 		if (stopped || !options.terminate) return stopped;
-		const stopRecord = evaluateTerminationStop(options.terminate, {
+		const stopRecord = evaluateTerminationStop(options.terminate, wrapUpHint.context({
 			runId,
 			protocol: "coordinator",
-			tier: options.tier,
+			protocolConfig: options.protocol,
+			protocolIteration: transcript.length,
 			cost: totalCost,
 			events,
 			transcript,
 			iteration: transcript.length,
-			elapsedMs: elapsedMs$2(startedAtMs)
-		});
+			elapsedMs: elapsedMs(startedAtMs)
+		}));
 		if (!stopRecord) return false;
 		stopped = true;
 		termination = stopRecord;
@@ -2603,7 +2861,7 @@ async function runCoordinator(options) {
 			reason: record.budgetReason ?? "cost",
 			cost: totalCost,
 			iteration: transcript.length,
-			elapsedMs: elapsedMs$2(startedAtMs),
+			elapsedMs: elapsedMs(startedAtMs),
 			detail: record.detail ?? {}
 		};
 		emit(event);
@@ -2625,13 +2883,21 @@ async function runCoordinatorTurn(turn) {
 			phase: turn.phase,
 			...turn.toolAvailability
 		},
-		messages: [{
+		messages: turn.wrapUpHint.inject([{
 			role: "system",
 			content: buildSystemPrompt$2(turn.agent, turn.coordinator)
 		}, {
 			role: "user",
 			content: turn.input
-		}]
+		}], {
+			runId: turn.runId,
+			protocol: "coordinator",
+			cost: turn.totalCost,
+			events: turn.events,
+			transcript: turn.transcript,
+			iteration: turn.transcript.length,
+			elapsedMs: elapsedMs(turn.startedAtMs)
+		})
 	};
 	const response = await generateModelTurn({
 		model: turn.options.model,
@@ -2698,13 +2964,21 @@ async function runCoordinatorWorkerTurn(turn) {
 			phase: "worker",
 			...turn.toolAvailability
 		},
-		messages: [{
+		messages: turn.wrapUpHint.inject([{
 			role: "system",
 			content: buildSystemPrompt$2(turn.agent, turn.coordinator)
 		}, {
 			role: "user",
 			content: turn.input
-		}]
+		}], {
+			runId: turn.runId,
+			protocol: "coordinator",
+			cost: turn.totalCost,
+			events: turn.events,
+			transcript: turn.transcript,
+			iteration: turn.turn - 1,
+			elapsedMs: elapsedMs(turn.startedAtMs)
+		})
 	};
 	const response = await generateModelTurn({
 		model: turn.options.model,
@@ -2761,22 +3035,10 @@ function responseCost$2(response) {
 		totalTokens: response.usage?.totalTokens ?? 0
 	};
 }
-function createRunId$2() {
-	return globalThis.crypto?.randomUUID?.() ?? `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}`;
-}
 //#endregion
 //#region src/runtime/sequential.ts
 async function runSequential(options) {
-	const runId = createRunId$1();
+	const runId = createRunId();
 	const events = [];
 	const transcript = [];
 	const protocolDecisions = [];
@@ -2784,9 +3046,17 @@ async function runSequential(options) {
 	let totalCost = emptyCost();
 	const maxTurns = options.protocol.maxTurns ?? options.agents.length;
 	const activeAgents = options.agents.slice(0, maxTurns);
-	const startedAtMs = nowMs$1();
+	const startedAtMs = nowMs();
 	let stopped = false;
 	let termination;
+	const wrapUpHint = createWrapUpHintController({
+		protocol: options.protocol,
+		tier: options.tier,
+		...options.budget ? { budget: options.budget } : {},
+		...options.terminate ? { terminate: options.terminate } : {},
+		...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {}
+	});
+	warnOnProtocolTerminationMisconfiguration(options.protocol, options.terminate);
 	const emit = (event) => {
 		events.push(event);
 		options.emit?.(event);
@@ -2838,13 +3108,21 @@ async function runSequential(options) {
 				turn,
 				...toolAvailability
 			},
-			messages: [{
+			messages: wrapUpHint.inject([{
 				role: "system",
 				content: buildSystemPrompt$1(agent)
 			}, {
 				role: "user",
 				content: input
-			}]
+			}], {
+				runId,
+				protocol: "sequential",
+				cost: totalCost,
+				events,
+				transcript,
+				iteration: transcript.length,
+				elapsedMs: elapsedMs(startedAtMs)
+			})
 		};
 		const response = await generateModelTurn({
 			model: options.model,
@@ -2969,16 +3247,17 @@ async function runSequential(options) {
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
 		if (stopped || !options.terminate) return stopped;
-		const stopRecord = evaluateTerminationStop(options.terminate, {
+		const stopRecord = evaluateTerminationStop(options.terminate, wrapUpHint.context({
 			runId,
 			protocol: "sequential",
-			tier: options.tier,
+			protocolConfig: options.protocol,
+			protocolIteration: transcript.length,
 			cost: totalCost,
 			events,
 			transcript,
 			iteration: transcript.length,
-			elapsedMs: elapsedMs$1(startedAtMs)
-		});
+			elapsedMs: elapsedMs(startedAtMs)
+		}));
 		if (!stopRecord) return false;
 		stopped = true;
 		termination = stopRecord;
@@ -2993,7 +3272,7 @@ async function runSequential(options) {
 			reason: record.budgetReason ?? "cost",
 			cost: totalCost,
 			iteration: transcript.length,
-			elapsedMs: elapsedMs$1(startedAtMs),
+			elapsedMs: elapsedMs(startedAtMs),
 			detail: record.detail ?? {}
 		};
 		emit(event);
@@ -3016,15 +3295,6 @@ function responseCost$1(response) {
 		totalTokens: response.usage?.totalTokens ?? 0
 	};
 }
-function createRunId$1() {
-	return globalThis.crypto?.randomUUID?.() ?? `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);
-}
 //#endregion
 //#region src/runtime/shared.ts
 async function runShared(options) {
@@ -3040,6 +3310,14 @@ async function runShared(options) {
 	const startedAtMs = nowMs();
 	let stopped = false;
 	let termination;
+	const wrapUpHint = createWrapUpHintController({
+		protocol: options.protocol,
+		tier: options.tier,
+		...options.budget ? { budget: options.budget } : {},
+		...options.terminate ? { terminate: options.terminate } : {},
+		...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {}
+	});
+	warnOnProtocolTerminationMisconfiguration(options.protocol, options.terminate);
 	const emit = (event) => {
 		events.push(event);
 		options.emit?.(event);
@@ -3092,13 +3370,21 @@ async function runShared(options) {
 					turn,
 					...toolAvailability
 				},
-				messages: [{
+				messages: wrapUpHint.inject([{
 					role: "system",
 					content: buildSystemPrompt(agent)
 				}, {
 					role: "user",
 					content: input
-				}]
+				}], {
+					runId,
+					protocol: "shared",
+					cost: totalCost,
+					events,
+					transcript,
+					iteration: transcript.length,
+					elapsedMs: elapsedMs(startedAtMs)
+				})
 			};
 			const response = await generateModelTurn({
 				model: options.model,
@@ -3235,16 +3521,17 @@ async function runShared(options) {
 	function stopIfNeeded() {
 		throwIfAborted(options.signal, options.model.id);
 		if (stopped || !options.terminate) return stopped;
-		const stopRecord = evaluateTerminationStop(options.terminate, {
+		const stopRecord = evaluateTerminationStop(options.terminate, wrapUpHint.context({
 			runId,
 			protocol: "shared",
-			tier: options.tier,
+			protocolConfig: options.protocol,
+			protocolIteration: transcript.length,
 			cost: totalCost,
 			events,
 			transcript,
 			iteration: transcript.length,
 			elapsedMs: elapsedMs(startedAtMs)
-		});
+		}));
 		if (!stopRecord) return false;
 		stopped = true;
 		termination = stopRecord;
@@ -3284,18 +3571,6 @@ function responseCost(response) {
 		totalTokens: response.usage?.totalTokens ?? 0
 	};
 }
-function createRunId() {
-	return globalThis.crypto?.randomUUID?.() ?? `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}`;
-}
 //#endregion
 //#region src/runtime/engine.ts
 var defaultHighLevelProtocol = "sequential";
@@ -3333,6 +3608,7 @@ function createEngine(options) {
 				...options.seed !== void 0 ? { seed: options.seed } : {},
 				...options.signal !== void 0 ? { signal: options.signal } : {},
 				...terminate ? { terminate } : {},
+				...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 				...options.evaluate ? { evaluate: options.evaluate } : {}
 			});
 		},
@@ -3715,6 +3991,7 @@ function runProtocol(options) {
 			...options.seed !== void 0 ? { seed: options.seed } : {},
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
+			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 			...options.emit ? { emit: options.emit } : {}
 		});
 		case "broadcast": return runBroadcast({
@@ -3729,6 +4006,7 @@ function runProtocol(options) {
 			...options.seed !== void 0 ? { seed: options.seed } : {},
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
+			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 			...options.emit ? { emit: options.emit } : {}
 		});
 		case "coordinator": return runCoordinator({
@@ -3743,6 +4021,7 @@ function runProtocol(options) {
 			...options.seed !== void 0 ? { seed: options.seed } : {},
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
+			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 			...options.emit ? { emit: options.emit } : {}
 		});
 		case "shared": return runShared({
@@ -3757,6 +4036,7 @@ function runProtocol(options) {
 			...options.seed !== void 0 ? { seed: options.seed } : {},
 			...options.signal !== void 0 ? { signal: options.signal } : {},
 			...options.terminate ? { terminate: options.terminate } : {},
+			...options.wrapUpHint ? { wrapUpHint: options.wrapUpHint } : {},
 			...options.emit ? { emit: options.emit } : {}
 		});
 	}
@@ -4200,6 +4480,263 @@ function isJsonValue(value) {
 	return false;
 }
 //#endregion
-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 };
+//#region src/runtime/logger.ts
+/** Logger that drops every call. The default when no logger is supplied. */
+var noopLogger = {
+	debug() {},
+	info() {},
+	warn() {},
+	error() {}
+};
+/**
+* Build a console-backed logger respecting a minimum level.
+*
+* The output format is JSON-on-one-line so it can be piped straight into log
+* collectors. Use `loggerFromEvents` to bridge it to a Dogpile stream handle.
+*/
+function consoleLogger(options = {}) {
+	const minLevel = options.level ?? "info";
+	const allowed = (level) => LEVEL_ORDER[level] >= LEVEL_ORDER[minLevel];
+	const emit = (level, message, fields) => {
+		if (!allowed(level)) return;
+		const payload = {
+			level,
+			message
+		};
+		if (fields !== void 0) payload.fields = fields;
+		(level === "error" ? console.error : level === "warn" ? console.warn : console.log)(JSON.stringify(payload));
+	};
+	return {
+		debug: (message, fields) => emit("debug", message, fields),
+		info: (message, fields) => emit("info", message, fields),
+		warn: (message, fields) => emit("warn", message, fields),
+		error: (message, fields) => emit("error", message, fields)
+	};
+}
+var LEVEL_ORDER = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+/**
+* Bridge a `Logger` to a Dogpile stream handle by returning a
+* `StreamEventSubscriber`. Pass it to `handle.subscribe(...)`.
+*
+* Logger throws are caught and routed to `logger.error` so a misbehaving
+* logger can never crash an in-flight run.
+*
+* @example
+* ```ts
+* const handle = Dogpile.stream({ intent, model });
+* handle.subscribe(loggerFromEvents(consoleLogger({ level: "info" })));
+* const result = await handle.result;
+* ```
+*/
+function loggerFromEvents(logger, options = {}) {
+	const includeSet = options.include ? new Set(options.include) : void 0;
+	return (event) => {
+		const eventType = event.type;
+		if (includeSet && !includeSet.has(eventType)) return;
+		const level = options.levelFor?.(event) ?? defaultLevel(event);
+		const message = describeEvent(event);
+		const fields = summarizeEvent(event);
+		try {
+			logger[level](message, fields);
+		} catch (cause) {
+			try {
+				logger.error("dogpile logger threw while handling event", {
+					eventType,
+					error: cause instanceof Error ? cause.message : String(cause)
+				});
+			} catch {}
+		}
+	};
+}
+function defaultLevel(event) {
+	switch (event.type) {
+		case "model-output-chunk": return "debug";
+		case "budget-stop": return "warn";
+		case "error": return "error";
+		case "tool-result": return event.result?.type === "error" ? "warn" : "info";
+		default: return "info";
+	}
+}
+function describeEvent(event) {
+	return `dogpile:${event.type}`;
+}
+function summarizeEvent(event) {
+	const fields = { eventType: event.type };
+	const at = event.at;
+	if (typeof at === "string") fields.at = at;
+	const runId = event.runId;
+	if (typeof runId === "string") fields.runId = runId;
+	const agentId = event.agentId;
+	if (typeof agentId === "string") fields.agentId = agentId;
+	const role = event.role;
+	if (typeof role === "string") fields.role = role;
+	return fields;
+}
+//#endregion
+//#region src/runtime/retry.ts
+/**
+* Default DogpileError codes that `withRetry` retries when no `retryOn`
+* predicate is supplied. These map to the transient provider failures listed
+* in `docs/developer-usage.md`.
+*/
+var DEFAULT_RETRYABLE_DOGPILE_CODES = [
+	"provider-rate-limited",
+	"provider-timeout",
+	"provider-unavailable"
+];
+var DEFAULTS = {
+	maxAttempts: 3,
+	baseDelayMs: 250,
+	maxDelayMs: 4e3,
+	jitter: "full"
+};
+/**
+* Wrap a `ConfiguredModelProvider` with a retry policy. The wrapper:
+*
+* - Preserves the provider `id` so traces remain stable.
+* - Retries `generate()` calls when the policy says the error is retryable.
+* - Propagates `AbortSignal` cancellation immediately — never retries after
+*   the caller cancels.
+* - Honors a `Retry-After`-style hint exposed via `error.detail.retryAfterMs`
+*   when present and the policy did not provide its own `delayForError`.
+* - Forwards `stream()` calls through unchanged — streaming retries cannot be
+*   safely automated because partial output may have already been observed.
+*
+* @example
+* ```ts
+* const robustProvider = withRetry(rawProvider, {
+*   maxAttempts: 4,
+*   baseDelayMs: 500,
+*   onRetry: ({ attempt, delayMs, error }) => {
+*     logger.warn("provider retry", { attempt, delayMs, error });
+*   }
+* });
+* ```
+*/
+function withRetry(provider, policy = {}) {
+	const settings = {
+		maxAttempts: policy.maxAttempts ?? DEFAULTS.maxAttempts,
+		baseDelayMs: policy.baseDelayMs ?? DEFAULTS.baseDelayMs,
+		maxDelayMs: policy.maxDelayMs ?? DEFAULTS.maxDelayMs,
+		jitter: policy.jitter ?? DEFAULTS.jitter,
+		retryOn: policy.retryOn ?? defaultRetryOn,
+		random: policy.random ?? Math.random,
+		sleep: policy.sleep ?? defaultSleep
+	};
+	if (settings.maxAttempts < 1) throw new DogpileError({
+		code: "invalid-configuration",
+		message: "withRetry: maxAttempts must be >= 1.",
+		detail: { maxAttempts: settings.maxAttempts }
+	});
+	if (settings.baseDelayMs < 0 || settings.maxDelayMs < 0) throw new DogpileError({
+		code: "invalid-configuration",
+		message: "withRetry: delay fields must be non-negative.",
+		detail: {
+			baseDelayMs: settings.baseDelayMs,
+			maxDelayMs: settings.maxDelayMs
+		}
+	});
+	const wrapped = {
+		id: provider.id,
+		async generate(request) {
+			let lastError;
+			for (let attempt = 1; attempt <= settings.maxAttempts; attempt++) {
+				if (request.signal?.aborted) throw abortReason(request.signal);
+				try {
+					return await provider.generate(request);
+				} catch (error) {
+					lastError = error;
+					if (isAbortError(error) || request.signal?.aborted) throw error;
+					if (attempt >= settings.maxAttempts || !settings.retryOn(error)) throw error;
+					const delayMs = chooseDelay({
+						attempt,
+						error,
+						settings,
+						policy
+					});
+					policy.onRetry?.({
+						attempt,
+						maxAttempts: settings.maxAttempts,
+						delayMs,
+						error,
+						providerId: provider.id
+					});
+					await settings.sleep(delayMs, request.signal);
+				}
+			}
+			throw lastError ?? new DogpileError({
+				code: "unknown",
+				message: "withRetry: exhausted attempts without throwing or returning."
+			});
+		}
+	};
+	if (typeof provider.stream === "function") {
+		const upstreamStream = provider.stream.bind(provider);
+		wrapped.stream = (request) => upstreamStream(request);
+	}
+	return wrapped;
+}
+function chooseDelay(args) {
+	const override = args.policy.delayForError?.(args.error) ?? retryAfterFromError(args.error);
+	if (override !== void 0 && Number.isFinite(override) && override >= 0) return Math.min(args.settings.maxDelayMs, override);
+	const exponential = args.settings.baseDelayMs * 2 ** (args.attempt - 1);
+	const capped = Math.min(args.settings.maxDelayMs, exponential);
+	if (args.settings.jitter === "none") return capped;
+	return Math.floor(capped * args.settings.random());
+}
+function defaultRetryOn(error) {
+	if (isAbortError(error)) return false;
+	if (DogpileError.isInstance(error)) {
+		if (error.code === "aborted" || error.code === "invalid-configuration") return false;
+		return DEFAULT_RETRYABLE_DOGPILE_CODES.includes(error.code);
+	}
+	if (error instanceof TypeError) return true;
+	return false;
+}
+function isAbortError(error) {
+	if (DogpileError.isInstance(error) && error.code === "aborted") return true;
+	if (typeof error === "object" && error !== null) {
+		if (error.name === "AbortError") return true;
+	}
+	return false;
+}
+function abortReason(signal) {
+	return signal.reason ?? new DogpileError({
+		code: "aborted",
+		message: "Request aborted."
+	});
+}
+function retryAfterFromError(error) {
+	if (!DogpileError.isInstance(error)) return void 0;
+	const detail = error.detail;
+	if (!detail || typeof detail !== "object") return void 0;
+	const candidate = detail.retryAfterMs;
+	if (typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 0) return candidate;
+}
+function defaultSleep(ms, signal) {
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(abortReason(signal));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(abortReason(signal));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#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 };
 
 //# sourceMappingURL=index.js.map