@dogpile/sdk 0.3.0 → 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;
@@ -1402,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",
@@ -1488,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;
 }
@@ -1501,130 +1531,168 @@ 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
+			};
+		}
+	});
+}
+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: 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)
+				};
+			}
 		}
 	};
 }
-/**
-* 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 } : {}
-		};
+function normalizeBuiltInDogpileTool(definition) {
+	switch (definition.name) {
+		case "webSearch": {
+			const identity = mergeIdentity(webSearchIdentity, definition.identity);
+			const permissions = definition.permissions ?? webSearchPermissions;
+			return {
+				identity,
+				inputSchema: definition.inputSchema ?? webSearchInputSchema,
+				permissions,
+				validateInput: (input) => validateBuiltInDogpileToolInput("webSearch", input),
+				execute: (input, context) => executeBuiltInTool(identity, definition.execute, input, context, "webSearch")
+			};
+		}
+		case "codeExec": {
+			const identity = mergeIdentity(codeExecIdentity, definition.identity);
+			const permissions = definition.permissions ?? codeExecPermissions;
+			return {
+				identity,
+				inputSchema: definition.inputSchema ?? codeExecInputSchema,
+				permissions,
+				validateInput: (input) => validateBuiltInDogpileToolInput("codeExec", input),
+				execute: (input, context) => executeBuiltInTool(identity, definition.execute, input, context, "codeExec")
+			};
+		}
+	}
+}
+function normalizeBuiltInDogpileTools(tools) {
+	const normalized = [];
+	if (tools.webSearch) normalized.push(normalizeBuiltInDogpileTool(asWebSearchDefinition(tools.webSearch)));
+	if (tools.codeExec) normalized.push(normalizeBuiltInDogpileTool(asCodeExecDefinition(tools.codeExec)));
+	return normalized;
+}
+async function executeBuiltInTool(identity, execute, input, context, name) {
+	const validation = validateBuiltInDogpileToolInput(name, input);
+	if (validation.type === "invalid") return {
+		type: "error",
+		toolCallId: context.toolCallId,
+		tool: identity,
+		error: {
+			code: "invalid-input",
+			message: `Invalid ${name} tool input.`,
+			retryable: false,
+			detail: { issues: serializeValidationIssues(validation.issues) }
+		}
+	};
+	try {
+		return await execute(input, context);
+	} catch (error) {
 		return {
-			identity: runtimeToolIdentityManifest(tool.identity),
-			inputSchema,
-			permissions: Array.from(tool.permissions ?? []).map(runtimeToolPermissionManifest)
+			type: "error",
+			toolCallId: context.toolCallId,
+			tool: identity,
+			error: normalizeRuntimeToolAdapterError(error)
 		};
-	});
+	}
 }
-/**
-* 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 } : {};
+function asWebSearchDefinition(tool) {
+	return typeof tool === "function" ? {
+		name: "webSearch",
+		execute: tool
+	} : tool;
 }
-/**
-* 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 asCodeExecDefinition(tool) {
+	return typeof tool === "function" ? {
+		name: "codeExec",
+		execute: tool
+	} : tool;
 }
-function runtimeToolIdentityManifest(identity) {
+function mergeIdentity(defaultIdentity, options) {
+	if (!options) return defaultIdentity;
 	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 } : {}
+		...defaultIdentity,
+		...options.namespace !== void 0 ? { namespace: options.namespace } : {},
+		...options.version !== void 0 ? { version: options.version } : {},
+		...options.description !== void 0 ? { description: options.description } : {}
 	};
 }
 function validateCodeExecAdapterInput(input, options) {
@@ -1633,296 +1701,19 @@ function validateCodeExecAdapterInput(input, options) {
 	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)
-				};
-			}
-		}
-	};
-}
-function normalizeBuiltInDogpileTool(definition) {
-	switch (definition.name) {
-		case "webSearch": {
-			const identity = mergeIdentity(webSearchIdentity, definition.identity);
-			const permissions = definition.permissions ?? webSearchPermissions;
-			return {
-				identity,
-				inputSchema: definition.inputSchema ?? webSearchInputSchema,
-				permissions,
-				validateInput: (input) => validateBuiltInDogpileToolInput("webSearch", input),
-				execute: (input, context) => executeBuiltInTool(identity, definition.execute, input, context, "webSearch")
-			};
-		}
-		case "codeExec": {
-			const identity = mergeIdentity(codeExecIdentity, definition.identity);
-			const permissions = definition.permissions ?? codeExecPermissions;
-			return {
-				identity,
-				inputSchema: definition.inputSchema ?? codeExecInputSchema,
-				permissions,
-				validateInput: (input) => validateBuiltInDogpileToolInput("codeExec", input),
-				execute: (input, context) => executeBuiltInTool(identity, definition.execute, input, context, "codeExec")
-			};
-		}
-	}
-}
-/**
-* Normalize configured built-in Dogpile tool executors into runtime tools.
-*/
-function normalizeBuiltInDogpileTools(tools) {
-	const normalized = [];
-	if (tools.webSearch) normalized.push(normalizeBuiltInDogpileTool(asWebSearchDefinition(tools.webSearch)));
-	if (tools.codeExec) normalized.push(normalizeBuiltInDogpileTool(asCodeExecDefinition(tools.codeExec)));
-	return normalized;
-}
-async function executeBuiltInTool(identity, execute, input, context, name) {
-	const validation = validateBuiltInDogpileToolInput(name, input);
-	if (validation.type === "invalid") return {
-		type: "error",
-		toolCallId: context.toolCallId,
-		tool: identity,
-		error: {
-			code: "invalid-input",
-			message: `Invalid ${name} tool input.`,
-			retryable: false,
-			detail: { issues: validation.issues }
-		}
-	};
-	try {
-		return await execute(input, context);
-	} catch (error) {
-		return {
-			type: "error",
-			toolCallId: context.toolCallId,
-			tool: identity,
-			error: normalizeRuntimeToolAdapterError(error)
-		};
-	}
-}
-function asWebSearchDefinition(tool) {
-	return typeof tool === "function" ? {
-		name: "webSearch",
-		execute: tool
-	} : tool;
-}
-function asCodeExecDefinition(tool) {
-	return typeof tool === "function" ? {
-		name: "codeExec",
-		execute: tool
-	} : tool;
-}
-function mergeIdentity(defaultIdentity, options) {
-	if (!options) return defaultIdentity;
-	return {
-		...defaultIdentity,
-		...options.namespace !== void 0 ? { namespace: options.namespace } : {},
-		...options.version !== void 0 ? { version: options.version } : {},
-		...options.description !== void 0 ? { description: options.description } : {}
+		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) {
@@ -2041,105 +1832,324 @@ function jsonString(value, fieldName) {
 		message: `Web search result ${fieldName} must be a non-empty string.`,
 		retryable: false
 	};
-	return value;
+	return value;
+}
+function optionalJsonString(value, fieldName) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw {
+		code: "backend-error",
+		message: `Web search result ${fieldName} must be a string when present.`,
+		retryable: false
+	};
+	return value;
+}
+function optionalJsonObject(value, fieldName) {
+	if (value === void 0) return void 0;
+	if (!isJsonObject(value)) throw {
+		code: "backend-error",
+		message: `Web search result ${fieldName} must be a JSON object when present.`,
+		retryable: false
+	};
+	return value;
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateWebSearchInput(input) {
+	const issues = [];
+	if (typeof input.query !== "string") issues.push({
+		code: input.query === void 0 ? "missing-field" : "invalid-type",
+		path: "query",
+		message: "webSearch.query must be a string."
+	});
+	else if (input.query.trim().length === 0) issues.push({
+		code: "invalid-value",
+		path: "query",
+		message: "webSearch.query must not be empty."
+	});
+	if (input.maxResults !== void 0) {
+		if (typeof input.maxResults !== "number" || !Number.isFinite(input.maxResults)) issues.push({
+			code: "invalid-type",
+			path: "maxResults",
+			message: "webSearch.maxResults must be a finite number."
+		});
+		else if (input.maxResults < 1) issues.push({
+			code: "out-of-range",
+			path: "maxResults",
+			message: "webSearch.maxResults must be greater than or equal to 1.",
+			detail: { minimum: 1 }
+		});
+	}
+	return issues;
+}
+function validateCodeExecInput(input) {
+	const issues = [];
+	if (typeof input.language !== "string") issues.push({
+		code: input.language === void 0 ? "missing-field" : "invalid-type",
+		path: "language",
+		message: "codeExec.language must be a string."
+	});
+	else if (!isCodeExecLanguage(input.language)) issues.push({
+		code: "invalid-value",
+		path: "language",
+		message: "codeExec.language must be one of javascript, typescript, python, bash, or shell.",
+		detail: { allowed: [
+			"javascript",
+			"typescript",
+			"python",
+			"bash",
+			"shell"
+		] }
+	});
+	if (typeof input.code !== "string") issues.push({
+		code: input.code === void 0 ? "missing-field" : "invalid-type",
+		path: "code",
+		message: "codeExec.code must be a string."
+	});
+	if (input.timeoutMs !== void 0) {
+		if (typeof input.timeoutMs !== "number" || !Number.isFinite(input.timeoutMs)) issues.push({
+			code: "invalid-type",
+			path: "timeoutMs",
+			message: "codeExec.timeoutMs must be a finite number."
+		});
+		else if (input.timeoutMs < 1) issues.push({
+			code: "out-of-range",
+			path: "timeoutMs",
+			message: "codeExec.timeoutMs must be greater than or equal to 1.",
+			detail: { minimum: 1 }
+		});
+	}
+	return issues;
+}
+function isCodeExecLanguage(value) {
+	return value === "javascript" || value === "typescript" || value === "python" || value === "bash" || value === "shell";
+}
+function 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 optionalJsonString(value, fieldName) {
-	if (value === void 0) return;
-	if (typeof value !== "string") throw {
-		code: "backend-error",
-		message: `Web search result ${fieldName} must be a string when present.`,
-		retryable: false
+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) } : {}
 	};
-	return value;
 }
-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
+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
+		}
 	};
-	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 }
-		});
+	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)
+		};
 	}
-	return issues;
-}
-function isCodeExecLanguage(value) {
-	return value === "javascript" || value === "typescript" || value === "python" || value === "bash" || value === "shell";
 }
-function isRuntimeToolAdapterError(error) {
-	if (typeof error !== "object" || error === null || !("code" in error) || !("message" in error)) return false;
-	const candidate = error;
-	return isRuntimeToolAdapterErrorCode(candidate.code) && typeof candidate.message === "string";
+function mergeToolMetadata(base, request) {
+	return {
+		...base ?? {},
+		...request ?? {}
+	};
 }
-function isRuntimeToolAdapterErrorCode(value) {
-	return value === "invalid-input" || value === "permission-denied" || value === "timeout" || value === "aborted" || value === "unavailable" || value === "backend-error" || value === "unknown";
+function defaultToolCallId(runId, callIndex) {
+	return `${runId}:tool-${callIndex + 1}`;
 }
 //#endregion
 //#region src/runtime/wrap-up.ts
@@ -2289,7 +2299,7 @@ function minCap(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 = [];
@@ -2298,7 +2308,7 @@ 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({
@@ -2375,7 +2385,7 @@ async function runBroadcast(options) {
 					events,
 					transcript,
 					iteration: transcript.length,
-					elapsedMs: elapsedMs$3(startedAtMs)
+					elapsedMs: elapsedMs(startedAtMs)
 				})
 			};
 			const response = await generateModelTurn({
@@ -2385,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;
 				}
@@ -2550,7 +2560,7 @@ async function runBroadcast(options) {
 			events,
 			transcript,
 			iteration: transcript.length,
-			elapsedMs: elapsedMs$3(startedAtMs)
+			elapsedMs: elapsedMs(startedAtMs)
 		}));
 		if (!stopRecord) return false;
 		stopped = true;
@@ -2566,7 +2576,7 @@ 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);
@@ -2596,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 = [];
@@ -2620,7 +2618,7 @@ 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({
@@ -2699,7 +2697,7 @@ 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,
@@ -2847,7 +2845,7 @@ async function runCoordinator(options) {
 			events,
 			transcript,
 			iteration: transcript.length,
-			elapsedMs: elapsedMs$2(startedAtMs)
+			elapsedMs: elapsedMs(startedAtMs)
 		}));
 		if (!stopRecord) return false;
 		stopped = true;
@@ -2863,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);
@@ -2898,7 +2896,7 @@ async function runCoordinatorTurn(turn) {
 			events: turn.events,
 			transcript: turn.transcript,
 			iteration: turn.transcript.length,
-			elapsedMs: elapsedMs$2(turn.startedAtMs)
+			elapsedMs: elapsedMs(turn.startedAtMs)
 		})
 	};
 	const response = await generateModelTurn({
@@ -2979,7 +2977,7 @@ async function runCoordinatorWorkerTurn(turn) {
 			events: turn.events,
 			transcript: turn.transcript,
 			iteration: turn.turn - 1,
-			elapsedMs: elapsedMs$2(turn.startedAtMs)
+			elapsedMs: elapsedMs(turn.startedAtMs)
 		})
 	};
 	const response = await generateModelTurn({
@@ -3037,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 = [];
@@ -3060,7 +3046,7 @@ 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({
@@ -3135,7 +3121,7 @@ async function runSequential(options) {
 				events,
 				transcript,
 				iteration: transcript.length,
-				elapsedMs: elapsedMs$1(startedAtMs)
+				elapsedMs: elapsedMs(startedAtMs)
 			})
 		};
 		const response = await generateModelTurn({
@@ -3270,7 +3256,7 @@ async function runSequential(options) {
 			events,
 			transcript,
 			iteration: transcript.length,
-			elapsedMs: elapsedMs$1(startedAtMs)
+			elapsedMs: elapsedMs(startedAtMs)
 		}));
 		if (!stopRecord) return false;
 		stopped = true;
@@ -3286,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);
@@ -3309,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) {
@@ -3594,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";
@@ -4515,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