@better-agent/core 0.1.0-beta.1

package/dist/run/pending-tools.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-tools.mjs","names":[],"sources":["../../src/run/pending-tools.ts"],"sourcesContent":["import { BetterAgentError } from \"@better-agent/shared/errors\";\nimport type { SubmitToolApprovalParams, SubmitToolResultParams } from \"./types\";\n\nexport interface PendingToolRuntime {\n    awaitClientToolResult(params: {\n        runId: string;\n        toolCallId: string;\n        toolName: string;\n        timeoutMs?: number;\n        signal?: AbortSignal;\n    }): Promise<unknown>;\n    awaitToolApproval(params: {\n        runId: string;\n        toolCallId: string;\n        toolName: string;\n        timeoutMs?: number;\n        signal?: AbortSignal;\n    }): Promise<{\n        decision: \"approved\" | \"denied\";\n        note?: string;\n        actorId?: string;\n    }>;\n    submitToolResult(params: SubmitToolResultParams): Promise<boolean>;\n    submitToolApproval(params: SubmitToolApprovalParams): Promise<boolean>;\n    clearRun(runId: string, reason: string): void;\n}\n\nexport const createPendingToolRuntime = (): PendingToolRuntime => {\n    type PendingEntry<TValue> = {\n        resolve: (value: TValue) => void;\n        reject: (error: BetterAgentError) => void;\n    };\n    const pendingClientToolCalls = new Map<string, Map<string, PendingEntry<unknown>>>();\n    const pendingApprovals = new Map<\n        string,\n        Map<\n            string,\n            PendingEntry<{\n                decision: \"approved\" | \"denied\";\n                note?: string;\n                actorId?: string;\n            }>\n        >\n    >();\n\n    const removePendingEntry = <TValue>(\n        entries: Map<string, Map<string, PendingEntry<TValue>>>,\n        runId: string,\n        toolCallId: string,\n    ) => {\n        const runPending = entries.get(runId);\n        if (!runPending) {\n            return;\n        }\n\n        runPending.delete(toolCallId);\n        if (runPending.size === 0) {\n            entries.delete(runId);\n        }\n    };\n\n    return {\n        awaitClientToolResult(params) {\n            return new Promise((resolve, reject) => {\n                const timeoutMs = params.timeoutMs ?? 30_000;\n                const runPending = pendingClientToolCalls.get(params.runId) ?? new Map();\n                pendingClientToolCalls.set(params.runId, runPending);\n\n                if (runPending.has(params.toolCallId)) {\n                    reject(\n                        BetterAgentError.fromCode(\n                            \"VALIDATION_FAILED\",\n                            `Client tool '${params.toolName}' call '${params.toolCallId}' is already pending.`,\n                            {\n                                context: {\n                                    runId: params.runId,\n                                    toolName: params.toolName,\n                                    toolCallId: params.toolCallId,\n                                },\n                                trace: [{ at: \"core.run.pendingTools.awaitClientToolResult\" }],\n                            },\n                        ),\n                    );\n                    return;\n                }\n\n                const onAbort = () => {\n                    cleanup();\n                    reject(\n                        createAbortError(\n                            `Run '${params.runId}' was aborted while waiting for client tool result for '${params.toolName}'.`,\n                            {\n                                runId: params.runId,\n                                toolName: params.toolName,\n                                toolCallId: params.toolCallId,\n                            },\n                        ),\n                    );\n                };\n                const cleanup = () => {\n                    clearTimeout(timeout);\n                    params.signal?.removeEventListener(\"abort\", onAbort);\n                    removePendingEntry(pendingClientToolCalls, params.runId, params.toolCallId);\n                };\n                const timeout = setTimeout(() => {\n                    cleanup();\n                    reject(\n                        BetterAgentError.fromCode(\n                            \"TIMEOUT\",\n                            `Timed out waiting for client tool result for '${params.toolName}'.`,\n                            {\n                                context: {\n                                    runId: params.runId,\n                                    toolName: params.toolName,\n                                    toolCallId: params.toolCallId,\n                                },\n                                trace: [{ at: \"core.run.pendingTools.awaitClientToolResult\" }],\n                            },\n                        ),\n                    );\n                }, timeoutMs);\n\n                if (params.signal?.aborted) {\n                    onAbort();\n                    return;\n                }\n\n                params.signal?.addEventListener(\"abort\", onAbort, { once: true });\n                runPending.set(params.toolCallId, {\n                    resolve: (value: unknown) => {\n                        cleanup();\n                        resolve(value);\n                    },\n                    reject: (error: BetterAgentError) => {\n                        cleanup();\n                        reject(error);\n                    },\n                });\n            });\n        },\n\n        awaitToolApproval(params) {\n            return new Promise((resolve, reject) => {\n                const timeoutMs = params.timeoutMs ?? 30_000;\n                const runPending = pendingApprovals.get(params.runId) ?? new Map();\n                pendingApprovals.set(params.runId, runPending);\n\n                if (runPending.has(params.toolCallId)) {\n                    reject(\n                        BetterAgentError.fromCode(\n                            \"VALIDATION_FAILED\",\n                            `Tool '${params.toolName}' call '${params.toolCallId}' is already pending approval.`,\n                            {\n                                context: {\n                                    runId: params.runId,\n                                    toolName: params.toolName,\n                                    toolCallId: params.toolCallId,\n                                },\n                                trace: [{ at: \"core.run.pendingTools.awaitToolApproval\" }],\n                            },\n                        ),\n                    );\n                    return;\n                }\n                const cleanup = () => {\n                    clearTimeout(timeout);\n                    params.signal?.removeEventListener(\"abort\", onAbort);\n                    removePendingEntry(pendingApprovals, params.runId, params.toolCallId);\n                };\n\n                const onAbort = () => {\n                    cleanup();\n                    reject(\n                        createAbortError(\n                            `Run '${params.runId}' was aborted while waiting for approval of '${params.toolName}'.`,\n                            {\n                                runId: params.runId,\n                                toolName: params.toolName,\n                                toolCallId: params.toolCallId,\n                            },\n                        ),\n                    );\n                };\n\n                const timeout = setTimeout(() => {\n                    cleanup();\n                    reject(\n                        BetterAgentError.fromCode(\n                            \"TIMEOUT\",\n                            `Timed out waiting for approval of '${params.toolName}'.`,\n                            {\n                                context: {\n                                    runId: params.runId,\n                                    toolName: params.toolName,\n                                    toolCallId: params.toolCallId,\n                                },\n                                trace: [{ at: \"core.run.pendingTools.awaitToolApproval\" }],\n                            },\n                        ),\n                    );\n                }, timeoutMs);\n\n                if (params.signal?.aborted) {\n                    onAbort();\n                    return;\n                }\n\n                params.signal?.addEventListener(\"abort\", onAbort, { once: true });\n                runPending.set(params.toolCallId, {\n                    resolve: (value: {\n                        decision: \"approved\" | \"denied\";\n                        note?: string;\n                        actorId?: string;\n                    }) => {\n                        cleanup();\n                        resolve(value);\n                    },\n                    reject: (error: BetterAgentError) => {\n                        cleanup();\n                        reject(error);\n                    },\n                });\n            });\n        },\n\n        submitToolResult(params) {\n            const runPending = pendingClientToolCalls.get(params.runId);\n            if (!runPending) return Promise.resolve(false);\n\n            const pending = runPending.get(params.toolCallId);\n            if (!pending) return Promise.resolve(false);\n\n            runPending.delete(params.toolCallId);\n            if (runPending.size === 0) {\n                pendingClientToolCalls.delete(params.runId);\n            }\n\n            if (params.status === \"error\") {\n                pending.reject(\n                    BetterAgentError.fromCode(\"TOOL_EXECUTION_FAILED\", params.error, {\n                        context: {\n                            runId: params.runId,\n                            toolCallId: params.toolCallId,\n                        },\n                        trace: [{ at: \"core.run.pendingTools.submitToolResult\" }],\n                    }),\n                );\n            } else {\n                pending.resolve(params.result);\n            }\n\n            return Promise.resolve(true);\n        },\n\n        submitToolApproval(params) {\n            const runPending = pendingApprovals.get(params.runId);\n            if (!runPending) return Promise.resolve(false);\n\n            const pending = runPending.get(params.toolCallId);\n            if (!pending) return Promise.resolve(false);\n\n            runPending.delete(params.toolCallId);\n            if (runPending.size === 0) {\n                pendingApprovals.delete(params.runId);\n            }\n\n            const result: {\n                decision: \"approved\" | \"denied\";\n                note?: string;\n                actorId?: string;\n            } = {\n                decision: params.decision,\n            };\n\n            if (params.note !== undefined) {\n                result.note = params.note;\n            }\n\n            if (params.actorId !== undefined) {\n                result.actorId = params.actorId;\n            }\n\n            pending.resolve(result);\n\n            return Promise.resolve(true);\n        },\n\n        clearRun(runId: string, reason: string) {\n            const clientToolCalls = pendingClientToolCalls.get(runId);\n            if (clientToolCalls) {\n                for (const [toolCallId, pending] of clientToolCalls) {\n                    pending.reject(\n                        createAbortError(`Run '${runId}' was cleared: ${reason}`, {\n                            runId,\n                            toolCallId,\n                        }),\n                    );\n                }\n                pendingClientToolCalls.delete(runId);\n            }\n\n            const approvals = pendingApprovals.get(runId);\n            if (approvals) {\n                for (const [toolCallId, pending] of approvals) {\n                    pending.reject(\n                        createAbortError(`Run '${runId}' was cleared: ${reason}`, {\n                            runId,\n                            toolCallId,\n                        }),\n                    );\n                }\n                pendingApprovals.delete(runId);\n            }\n        },\n    };\n};\n\nconst createAbortError = (message: string, context: Record<string, unknown>) =>\n    BetterAgentError.fromCode(\"ABORTED\", message, {\n        context,\n        trace: [{ at: \"core.run.pendingTools.clearRun\" }],\n    });\n"],"mappings":"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"}

package/dist/run/registry.mjs

@@ -0,0 +1,22 @@
+import { BetterAgentError } from "@better-agent/shared/errors";
+
+//#region src/run/registry.ts
+/** Builds a read-only agent registry. */
+function createAgentRegistry(agents) {
+	const registry = /* @__PURE__ */ new Map();
+	for (const agent of agents) registry.set(agent.name, agent);
+	return registry;
+}
+function resolveAgentFromRegistry(agents, agent, traceAt) {
+	const resolved = typeof agent === "string" ? agents.get(agent) : agents.get(agent.name) ?? agent;
+	if (resolved) return resolved;
+	const agentName = typeof agent === "string" ? agent : agent.name;
+	throw BetterAgentError.fromCode("NOT_FOUND", `Agent '${agentName}' does not exist.`, {
+		context: { agentName },
+		trace: [{ at: traceAt }]
+	});
+}
+
+//#endregion
+export { createAgentRegistry, resolveAgentFromRegistry };
+//# sourceMappingURL=registry.mjs.map

package/dist/run/registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.mjs","names":[],"sources":["../../src/run/registry.ts"],"sourcesContent":["import { BetterAgentError } from \"@better-agent/shared/errors\";\nimport type { AnyAgentDefinition } from \"../agent\";\n\n/** Builds a read-only agent registry. */\nexport function createAgentRegistry(\n    agents: readonly AnyAgentDefinition[],\n): ReadonlyMap<string, AnyAgentDefinition> {\n    const registry = new Map<string, AnyAgentDefinition>();\n\n    for (const agent of agents) {\n        registry.set(agent.name, agent);\n    }\n\n    return registry;\n}\n\nexport function resolveAgentFromRegistry(\n    agents: ReadonlyMap<string, AnyAgentDefinition>,\n    agent: string | AnyAgentDefinition,\n    traceAt: string,\n): AnyAgentDefinition {\n    const resolved =\n        typeof agent === \"string\" ? agents.get(agent) : (agents.get(agent.name) ?? agent);\n    if (resolved) {\n        return resolved;\n    }\n\n    const agentName = typeof agent === \"string\" ? agent : agent.name;\n    throw BetterAgentError.fromCode(\"NOT_FOUND\", `Agent '${agentName}' does not exist.`, {\n        context: { agentName },\n        trace: [{ at: traceAt }],\n    });\n}\n"],"mappings":";;;;AAIA,SAAgB,oBACZ,QACuC;CACvC,MAAM,2BAAW,IAAI,KAAiC;AAEtD,MAAK,MAAM,SAAS,OAChB,UAAS,IAAI,MAAM,MAAM,MAAM;AAGnC,QAAO;;AAGX,SAAgB,yBACZ,QACA,OACA,SACkB;CAClB,MAAM,WACF,OAAO,UAAU,WAAW,OAAO,IAAI,MAAM,GAAI,OAAO,IAAI,MAAM,KAAK,IAAI;AAC/E,KAAI,SACA,QAAO;CAGX,MAAM,YAAY,OAAO,UAAU,WAAW,QAAQ,MAAM;AAC5D,OAAM,iBAAiB,SAAS,aAAa,UAAU,UAAU,oBAAoB;EACjF,SAAS,EAAE,WAAW;EACtB,OAAO,CAAC,EAAE,IAAI,SAAS,CAAC;EAC3B,CAAC"}

package/dist/run/runtime.d.mts

@@ -0,0 +1,19 @@
+import { AnyAgentDefinition } from "../agent/types.mjs";
+import { ConversationRuntimeStateStore, ConversationStore, StreamStore } from "../persistence/types.mjs";
+import { PluginRuntime } from "../plugins/types.mjs";
+import { BetterAgentRuntime, RunAdvancedOptions } from "./types.mjs";
+
+//#region src/run/runtime.d.ts
+/** Creates a runtime for registered agents. */
+declare function createRuntime<const TAgents extends readonly AnyAgentDefinition[]>(options: {
+  agents: TAgents;
+  pluginRuntime?: PluginRuntime | null;
+  stream?: StreamStore;
+  conversations?: ConversationStore;
+  runtimeState?: ConversationRuntimeStateStore;
+  streamLifecycle?: "request_bound" | "detached";
+  advanced?: RunAdvancedOptions;
+}): BetterAgentRuntime<TAgents>;
+//#endregion
+export { createRuntime };
+//# sourceMappingURL=runtime.d.mts.map

package/dist/run/runtime.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../../src/run/runtime.ts"],"mappings":";;;;;;;iBAiCgB,aAAA,gCAA6C,kBAAA,GAAA,CAAsB,OAAA;EAC/E,MAAA,EAAQ,OAAA;EACR,aAAA,GAAgB,aAAA;EAChB,MAAA,GAAS,WAAA;EACT,aAAA,GAAgB,iBAAA;EAChB,YAAA,GAAe,6BAAA;EACf,eAAA;EACA,QAAA,GAAW,kBAAA;AAAA,IACX,kBAAA,CAAmB,OAAA"}

package/dist/run/runtime.mjs

@@ -0,0 +1,491 @@
+import { Events } from "../events/constants.mjs";
+import { createAsyncEventQueue } from "./event-queue.mjs";
+import { createStreamPersistenceEmitter, generateId, loadConversationMessages, saveConversationMessages, toEventEmitter, validateAgentContext, validateStoredConversationItems } from "./helpers.mjs";
+import { executeRun } from "./execution.mjs";
+import { createPendingToolRuntime } from "./pending-tools.mjs";
+import { createAgentRegistry, resolveAgentFromRegistry } from "./registry.mjs";
+import { BetterAgentError } from "@better-agent/shared/errors";
+import { logger } from "@better-agent/shared/logger";
+
+//#region src/run/runtime.ts
+/** Creates a runtime for registered agents. */
+function createRuntime(options) {
+	const agents = createAgentRegistry(options.agents);
+	const pluginRuntime = options.pluginRuntime ?? null;
+	const pendingToolRuntime = createPendingToolRuntime();
+	const streamLifecycle = options.streamLifecycle ?? "request_bound";
+	const activeRuns = /* @__PURE__ */ new Map();
+	const resolveConversationReplay = (agent, runReplay) => {
+		const agentReplay = agent.conversationReplay;
+		if (!agentReplay && !runReplay) return;
+		const merged = {
+			...agentReplay ?? {},
+			...runReplay ?? {}
+		};
+		if (runReplay && Object.prototype.hasOwnProperty.call(runReplay, "prepareInput") && runReplay.prepareInput === null) merged.prepareInput = void 0;
+		return merged;
+	};
+	const warnIgnoredConversationReplay = (params) => {
+		if (!params.conversationReplay) return;
+		const replayMode = params.agent.model.caps.replayMode ?? (params.agent.model.caps.inputShape === "prompt" ? "single_turn_persistent" : "multi_turn");
+		if (replayMode === "multi_turn") return;
+		logger.warn(`conversationReplay was provided for agent '${params.agent.name}', but model replayMode is '${replayMode}', so stored history replay customization was skipped.`);
+	};
+	const buildPersistence = (persistence, defaults) => {
+		const resolved = {
+			stream: persistence?.stream ?? defaults?.stream,
+			conversations: persistence?.conversations ?? defaults?.conversations,
+			runtimeState: persistence?.runtimeState ?? defaults?.runtimeState
+		};
+		return resolved.stream || resolved.conversations || resolved.runtimeState ? resolved : void 0;
+	};
+	const createPluginEventContext = (params) => ({
+		runId: params.runId,
+		agentName: params.agentName,
+		conversationId: params.conversationId,
+		control: { abortRun: async () => {
+			params.abortController.abort();
+		} }
+	});
+	const createLiveEmitter = (params) => {
+		const userEmit = toEventEmitter(params.onEvent);
+		return async (event) => {
+			const pluginEventContext = createPluginEventContext({
+				runId: params.runId,
+				agentName: params.agentName,
+				abortController: params.abortController,
+				conversationId: params.conversationId
+			});
+			const transformed = pluginRuntime?.hasEventMiddleware === true ? await pluginRuntime.dispatchEvent(event, pluginEventContext) : event;
+			if (!transformed) return;
+			if (params.persistenceEmit) await params.persistenceEmit(transformed);
+			if (pluginRuntime?.hasOnEvent) await pluginRuntime.dispatchOnEvent(transformed, pluginEventContext);
+			if (params.queuePush) await params.queuePush(transformed);
+			await userEmit(transformed);
+		};
+	};
+	const wrapRuntimeError = (params) => BetterAgentError.wrap({
+		err: params.error,
+		message: params.message,
+		opts: {
+			code: params.isAbort ? "ABORTED" : params.error instanceof BetterAgentError ? params.error.code : "INTERNAL",
+			trace: [{ at: params.traceAt }]
+		}
+	});
+	const emitSafely = async (emit, event) => {
+		try {
+			await emit(event);
+		} catch (error) {
+			logger.error("Failed to emit runtime event.", error);
+		}
+	};
+	const closeStreamSafely = async (streamStore, runId) => {
+		if (!streamStore) return;
+		try {
+			await streamStore.close(runId);
+		} catch (error) {
+			logger.error(`Failed to close stream '${runId}'.`, error);
+		}
+	};
+	const createRuntimeExecutionContext = (params) => {
+		const runId = generateId("run");
+		const abortController = new AbortController();
+		activeRuns.set(runId, abortController);
+		const signalController = new AbortController();
+		const abortFromSignal = (signal) => {
+			if (!signalController.signal.aborted) signalController.abort(signal.reason);
+		};
+		const onInternalAbort = () => abortFromSignal(abortController.signal);
+		const onExternalAbort = () => {
+			if (params.externalSignal) abortFromSignal(params.externalSignal);
+		};
+		const signal = signalController.signal;
+		const persistenceEmit = params.streamStore ? createStreamPersistenceEmitter({
+			stream: params.streamStore,
+			streamId: runId
+		}) : void 0;
+		const emit = createLiveEmitter({
+			runId,
+			agentName: params.resolvedAgent.name,
+			abortController,
+			conversationId: params.conversationId,
+			persistenceEmit,
+			queuePush: params.queue ? async (event) => {
+				if (!params.queueSignal?.aborted) params.queue?.push(event);
+			} : void 0,
+			onEvent: params.onEvent
+		});
+		abortController.signal.addEventListener("abort", onInternalAbort, { once: true });
+		if (params.externalSignal && !params.detachFromExternalAbort) if (params.externalSignal.aborted) abortFromSignal(params.externalSignal);
+		else params.externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+		if (params.queue && params.queueSignal) {
+			const closeQueueOnAbort = () => params.queue?.close();
+			if (params.queueSignal.aborted) closeQueueOnAbort();
+			else params.queueSignal.addEventListener("abort", closeQueueOnAbort, { once: true });
+		}
+		return {
+			runId,
+			signal,
+			emit,
+			cleanupSignal() {
+				abortController.signal.removeEventListener("abort", onInternalAbort);
+				params.externalSignal?.removeEventListener("abort", onExternalAbort);
+			}
+		};
+	};
+	const completeRunSuccess = async (params) => {
+		const itemsToSave = pluginRuntime?.hasOnBeforeSave === true ? await pluginRuntime.applyBeforeSave({
+			runId: params.runId,
+			agentName: params.resolvedAgent.name,
+			items: params.result.items,
+			conversationId: params.conversationId
+		}) : params.result.items;
+		if (params.saveConversationParams) await saveConversationMessages({
+			...params.saveConversationParams,
+			result: {
+				...params.result,
+				items: itemsToSave
+			}
+		});
+		const publicResult = {
+			response: params.result.response,
+			structured: params.result.structured
+		};
+		await params.emit({
+			type: Events.RUN_FINISHED,
+			runId: params.runId,
+			agentName: params.resolvedAgent.name,
+			result: publicResult,
+			timestamp: Date.now(),
+			conversationId: params.conversationId
+		});
+		activeRuns.delete(params.runId);
+		if (params.runtimeState && params.conversationId !== void 0) await params.runtimeState.clear({
+			conversationId: params.conversationId,
+			agentName: params.resolvedAgent.name
+		});
+		await closeStreamSafely(params.streamStore, params.runId);
+		params.queue?.close();
+		pendingToolRuntime.clearRun(params.runId, "Run finished");
+		return params.success(publicResult);
+	};
+	const handleRunFailure = async (params) => {
+		const isAbort = params.signal.aborted || params.error instanceof BetterAgentError && params.error.code === "ABORTED";
+		const wrapped = wrapRuntimeError({
+			error: params.error,
+			message: "Run failed",
+			traceAt: params.traceAt,
+			isAbort
+		});
+		if (isAbort) await emitSafely(params.emit, {
+			type: Events.RUN_ABORTED,
+			runId: params.runId,
+			agentName: params.resolvedAgent.name,
+			timestamp: Date.now(),
+			conversationId: params.conversationId
+		});
+		else await emitSafely(params.emit, {
+			type: Events.RUN_ERROR,
+			runId: params.runId,
+			agentName: params.resolvedAgent.name,
+			error: wrapped,
+			timestamp: Date.now(),
+			conversationId: params.conversationId
+		});
+		activeRuns.delete(params.runId);
+		if (params.runtimeState && params.conversationId !== void 0) await params.runtimeState.clear({
+			conversationId: params.conversationId,
+			agentName: params.resolvedAgent.name
+		});
+		await closeStreamSafely(params.streamStore, params.runId);
+		params.queue?.fail(wrapped);
+		pendingToolRuntime.clearRun(params.runId, wrapped.message);
+		throw wrapped;
+	};
+	return {
+		streamLifecycle,
+		run: (async (agent, runOptions) => {
+			const resolvedAgent = resolveAgentFromRegistry(agents, agent, "core.run.createRuntime.run");
+			if (runOptions.conversationId !== void 0 && runOptions.conversationId.trim().length === 0) throw BetterAgentError.fromCode("VALIDATION_FAILED", "conversationId must be a non-empty string.", {
+				context: { conversationId: runOptions.conversationId },
+				trace: [{ at: "core.run.createRuntime.run.validateConversationId" }]
+			});
+			const execution = createRuntimeExecutionContext({
+				resolvedAgent,
+				conversationId: runOptions.conversationId,
+				onEvent: runOptions.onEvent,
+				externalSignal: runOptions.signal
+			});
+			const resolvedPersistence = buildPersistence(runOptions.persistence, {
+				stream: options.stream,
+				conversations: options.conversations,
+				runtimeState: options.runtimeState
+			});
+			try {
+				const effectiveConversationReplay = resolveConversationReplay(resolvedAgent, runOptions.conversationReplay);
+				warnIgnoredConversationReplay({
+					agent: resolvedAgent,
+					conversationReplay: effectiveConversationReplay
+				});
+				const validatedContext = await validateAgentContext(resolvedAgent, runOptions.context);
+				const resolvedConversations = runOptions.persistence?.conversations ?? options.conversations;
+				const conversationInput = await loadConversationMessages({
+					input: runOptions.input,
+					caps: resolvedAgent.model.caps,
+					agentName: resolvedAgent.name,
+					replaceHistory: runOptions.replaceHistory,
+					conversationReplay: effectiveConversationReplay,
+					conversations: resolvedConversations,
+					conversationId: runOptions.conversationId
+				});
+				await execution.emit({
+					type: Events.RUN_STARTED,
+					runId: execution.runId,
+					agentName: resolvedAgent.name,
+					runInput: {
+						input: runOptions.input,
+						context: validatedContext
+					},
+					timestamp: Date.now(),
+					conversationId: runOptions.conversationId
+				});
+				if (execution.signal.aborted) throw BetterAgentError.fromCode("ABORTED", "Run aborted before it started", {
+					context: {
+						runId: execution.runId,
+						agentName: resolvedAgent.name
+					},
+					trace: [{ at: "core.run.createRuntime.run.abortedBeforeStart" }]
+				});
+				const result = await executeRun({
+					agent: resolvedAgent,
+					options: {
+						...runOptions,
+						input: conversationInput.input,
+						initialItems: conversationInput.items,
+						replayStartIndex: conversationInput.replayStartIndex,
+						conversationReplayActive: conversationInput.conversationReplayActive,
+						conversationReplay: effectiveConversationReplay,
+						context: validatedContext,
+						runId: execution.runId,
+						signal: execution.signal,
+						emit: execution.emit,
+						generateMessageId: () => generateId("message"),
+						mode: "run",
+						advancedDefaults: options.advanced,
+						persistence: resolvedPersistence,
+						pendingToolRuntime,
+						pluginRuntime
+					}
+				});
+				return await completeRunSuccess({
+					runId: execution.runId,
+					resolvedAgent,
+					emit: execution.emit,
+					result,
+					saveConversationParams: {
+						agentName: resolvedAgent.name,
+						loaded: conversationInput.loaded,
+						conversations: resolvedConversations,
+						conversationId: runOptions.conversationId
+					},
+					runtimeState: resolvedPersistence?.runtimeState,
+					conversationId: runOptions.conversationId,
+					success: (publicResult) => publicResult
+				});
+			} catch (error) {
+				return await handleRunFailure({
+					error,
+					signal: execution.signal,
+					traceAt: "core.run.createRuntime.run",
+					emit: execution.emit,
+					runId: execution.runId,
+					resolvedAgent,
+					conversationId: runOptions.conversationId,
+					runtimeState: resolvedPersistence?.runtimeState
+				});
+			} finally {
+				execution.cleanupSignal();
+			}
+		}),
+		stream: ((agent, runOptions) => {
+			const resolvedAgent = resolveAgentFromRegistry(agents, agent, "core.run.createRuntime.stream");
+			if (runOptions.conversationId !== void 0 && runOptions.conversationId.trim().length === 0) throw BetterAgentError.fromCode("VALIDATION_FAILED", "conversationId must be a non-empty string.", {
+				context: { conversationId: runOptions.conversationId },
+				trace: [{ at: "core.run.createRuntime.stream.validateConversationId" }]
+			});
+			const queue = createAsyncEventQueue();
+			const runPersistence = runOptions.persistence;
+			const streamStore = runPersistence?.stream ?? options.stream;
+			const execution = createRuntimeExecutionContext({
+				resolvedAgent,
+				conversationId: runOptions.conversationId,
+				onEvent: runOptions.onEvent,
+				externalSignal: runOptions.signal,
+				detachFromExternalAbort: streamLifecycle === "detached",
+				queueSignal: streamLifecycle === "detached" ? runOptions.signal : void 0,
+				streamStore,
+				queue
+			});
+			const resolvedPersistence = buildPersistence(runPersistence, {
+				stream: streamStore,
+				conversations: options.conversations,
+				runtimeState: options.runtimeState
+			});
+			const result = (async () => {
+				try {
+					const effectiveConversationReplay = resolveConversationReplay(resolvedAgent, runOptions.conversationReplay);
+					warnIgnoredConversationReplay({
+						agent: resolvedAgent,
+						conversationReplay: effectiveConversationReplay
+					});
+					const validatedContext = await validateAgentContext(resolvedAgent, runOptions.context);
+					const resolvedConversations = runPersistence?.conversations ?? options.conversations;
+					const conversationInput = await loadConversationMessages({
+						input: runOptions.input,
+						caps: resolvedAgent.model.caps,
+						agentName: resolvedAgent.name,
+						replaceHistory: runOptions.replaceHistory,
+						conversationReplay: effectiveConversationReplay,
+						conversations: resolvedConversations,
+						conversationId: runOptions.conversationId
+					});
+					if (streamStore) await streamStore.open(execution.runId, { runId: execution.runId });
+					if (resolvedPersistence?.runtimeState && runOptions.conversationId !== void 0) await resolvedPersistence.runtimeState.set({
+						conversationId: runOptions.conversationId,
+						agentName: resolvedAgent.name,
+						status: "running",
+						updatedAt: Date.now(),
+						activeRunId: execution.runId,
+						activeStreamId: streamStore ? execution.runId : void 0
+					});
+					await execution.emit({
+						type: Events.RUN_STARTED,
+						runId: execution.runId,
+						agentName: resolvedAgent.name,
+						runInput: {
+							input: runOptions.input,
+							context: validatedContext
+						},
+						timestamp: Date.now(),
+						conversationId: runOptions.conversationId
+					});
+					if (execution.signal.aborted) throw BetterAgentError.fromCode("ABORTED", "Run aborted before it started", {
+						context: {
+							runId: execution.runId,
+							agentName: resolvedAgent.name
+						},
+						trace: [{ at: "core.run.createRuntime.stream.abortedBeforeStart" }]
+					});
+					const runResult = await executeRun({
+						agent: resolvedAgent,
+						options: {
+							...runOptions,
+							input: conversationInput.input,
+							initialItems: conversationInput.items,
+							replayStartIndex: conversationInput.replayStartIndex,
+							conversationReplayActive: conversationInput.conversationReplayActive,
+							conversationReplay: effectiveConversationReplay,
+							context: validatedContext,
+							runId: execution.runId,
+							signal: execution.signal,
+							emit: execution.emit,
+							generateMessageId: () => generateId("message"),
+							mode: "stream",
+							advancedDefaults: options.advanced,
+							persistence: resolvedPersistence,
+							pendingToolRuntime,
+							pluginRuntime
+						}
+					});
+					return await completeRunSuccess({
+						runId: execution.runId,
+						resolvedAgent,
+						emit: execution.emit,
+						result: runResult,
+						streamStore,
+						queue,
+						saveConversationParams: {
+							agentName: resolvedAgent.name,
+							loaded: conversationInput.loaded,
+							conversations: resolvedConversations,
+							conversationId: runOptions.conversationId
+						},
+						runtimeState: resolvedPersistence?.runtimeState,
+						conversationId: runOptions.conversationId,
+						success: (publicResult) => publicResult
+					});
+				} catch (error) {
+					return await handleRunFailure({
+						error,
+						signal: execution.signal,
+						traceAt: "core.run.createRuntime.stream",
+						emit: execution.emit,
+						runId: execution.runId,
+						resolvedAgent,
+						conversationId: runOptions.conversationId,
+						streamStore,
+						runtimeState: resolvedPersistence?.runtimeState,
+						queue
+					});
+				} finally {
+					execution.cleanupSignal();
+				}
+			})();
+			result.catch(() => {});
+			return {
+				runId: execution.runId,
+				events: queue.iterate(),
+				result
+			};
+		}),
+		loadConversation: async (agent, conversationId) => {
+			if (conversationId.trim().length === 0) throw BetterAgentError.fromCode("VALIDATION_FAILED", "conversationId must be a non-empty string.", {
+				context: { conversationId },
+				trace: [{ at: "core.run.createRuntime.loadConversation.validateConversationId" }]
+			});
+			const resolvedAgent = resolveAgentFromRegistry(agents, agent, "core.run.createRuntime.loadConversation");
+			const conversations = options.conversations;
+			if (!conversations) return null;
+			const loaded = await conversations.load({
+				conversationId,
+				agentName: resolvedAgent.name
+			});
+			if (!loaded) return null;
+			validateStoredConversationItems(loaded.items, conversationId);
+			return { items: loaded.items };
+		},
+		resumeStream: async (params) => {
+			if (params.streamId.trim().length === 0) throw BetterAgentError.fromCode("VALIDATION_FAILED", "streamId must be a non-empty string.", {
+				context: { streamId: params.streamId },
+				trace: [{ at: "core.run.createRuntime.resumeStream.validateStreamId" }]
+			});
+			if (!options.stream) return null;
+			return options.stream.resume(params.streamId, params.afterSeq);
+		},
+		resumeConversation: async (agent, params) => {
+			if (params.conversationId.trim().length === 0) throw BetterAgentError.fromCode("VALIDATION_FAILED", "conversationId must be a non-empty string.", {
+				context: { conversationId: params.conversationId },
+				trace: [{ at: "core.run.createRuntime.resumeConversation.validateConversationId" }]
+			});
+			const resolvedAgent = resolveAgentFromRegistry(agents, agent, "core.run.createRuntime.resumeConversation");
+			const state = !options.runtimeState ? null : await options.runtimeState.get({
+				conversationId: params.conversationId,
+				agentName: resolvedAgent.name
+			});
+			if (!state || state.status !== "running" || !state.activeStreamId || !options.stream) return null;
+			return options.stream.resume(state.activeStreamId, params.afterSeq);
+		},
+		abortRun: async (runId) => {
+			const controller = activeRuns.get(runId);
+			if (!controller) return false;
+			controller.abort();
+			return true;
+		},
+		submitToolResult: async (params) => pendingToolRuntime.submitToolResult(params),
+		submitToolApproval: async (params) => pendingToolRuntime.submitToolApproval(params)
+	};
+}
+
+//#endregion
+export { createRuntime };
+//# sourceMappingURL=runtime.mjs.map