@botbotgo/agent-harness 0.0.1

package/dist/runtime/harness.js

@@ -0,0 +1,696 @@
+import { Readable } from "node:stream";
+import { AUTO_AGENT_ID } from "../contracts/types.js";
+import { FilePersistence } from "../persistence/file-store.js";
+import { createPersistentId } from "../utils/id.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, AgentRuntimeAdapter } from "./agent-runtime-adapter.js";
+import { createBuiltinBackendResolver, createBuiltinToolResolver } from "../vendor/builtins.js";
+import { EventBus } from "./event-bus.js";
+import { PolicyEngine } from "./policy-engine.js";
+import { getRoutingSystemPrompt } from "../workspace/support/workspace-ref-utils.js";
+import { createHarnessEvent, createPendingApproval, heuristicRoute, inferRoutingBindings, resolveDeterministicRouteIntent, renderRuntimeFailure, requiresResearchRoute, } from "./support/harness-support.js";
+import { createCheckpointerForConfig, createStoreForConfig } from "./support/runtime-factories.js";
+import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "./support/embedding-models.js";
+import { resolveCompiledVectorStore, resolveCompiledVectorStoreRef } from "./support/vector-stores.js";
+import { ThreadMemorySync } from "./thread-memory-sync.js";
+import { FileBackedStore } from "./store.js";
+export class AgentHarness {
+    workspace;
+    runtimeAdapterOptions;
+    eventBus = new EventBus();
+    persistence;
+    policyEngine = new PolicyEngine();
+    runtimeAdapter;
+    checkpointers = new Map();
+    stores = new Map();
+    embeddingModels = new Map();
+    vectorStores = new Map();
+    defaultStore;
+    routingSystemPrompt;
+    threadMemorySync;
+    unsubscribeThreadMemorySync;
+    listHostBindings() {
+        return inferRoutingBindings(this.workspace).hostBindings;
+    }
+    defaultRunRoot() {
+        return (this.listHostBindings()[0]?.harnessRuntime.runRoot ??
+            `${this.workspace.workspaceRoot}/run-data`);
+    }
+    heuristicRoute(input) {
+        const { primaryBinding, secondaryBinding } = inferRoutingBindings(this.workspace);
+        return heuristicRoute(input, primaryBinding, secondaryBinding);
+    }
+    async buildRoutingInput(input, threadId) {
+        if (!threadId) {
+            return input;
+        }
+        const history = await this.persistence.listThreadMessages(threadId);
+        const priorHistory = history.filter((message) => message.content.trim());
+        if (priorHistory.length === 0) {
+            return input;
+        }
+        const recentTurns = priorHistory.slice(-6).map((message) => {
+            const role = message.role === "assistant" ? "assistant" : "user";
+            const compact = message.content.replace(/\s+/g, " ").trim();
+            return `${role}: ${compact.slice(0, 240)}`;
+        });
+        return [
+            "Recent conversation context:",
+            ...recentTurns,
+            "",
+            `Current user request: ${input}`,
+        ].join("\n");
+    }
+    async resolveSelectedAgentId(input, requestedAgentId, threadId) {
+        if (!requestedAgentId || requestedAgentId === AUTO_AGENT_ID) {
+            return this.routeAgent(input, { threadId });
+        }
+        return requestedAgentId;
+    }
+    resolveStore(binding) {
+        const storeConfig = binding?.deepAgentParams?.store ?? binding?.harnessRuntime.store;
+        const cacheKey = storeConfig ? JSON.stringify(storeConfig) : undefined;
+        if (!storeConfig) {
+            return this.defaultStore;
+        }
+        if (!cacheKey) {
+            return this.defaultStore;
+        }
+        const existing = this.stores.get(cacheKey);
+        if (existing) {
+            return existing;
+        }
+        const created = createStoreForConfig(storeConfig, binding?.harnessRuntime.runRoot ?? this.defaultRunRoot());
+        this.stores.set(cacheKey, created);
+        return created;
+    }
+    async resolveEmbeddingModel(embeddingModelRef) {
+        const compiled = resolveCompiledEmbeddingModelRef(this.workspace, embeddingModelRef);
+        const existing = this.embeddingModels.get(compiled.id);
+        if (existing) {
+            return existing;
+        }
+        const resolved = await resolveCompiledEmbeddingModel(compiled, this.runtimeAdapterOptions.embeddingModelResolver);
+        this.embeddingModels.set(compiled.id, resolved);
+        return resolved;
+    }
+    async resolveVectorStore(vectorStoreRef) {
+        const compiled = resolveCompiledVectorStoreRef(this.workspace, vectorStoreRef);
+        const existing = this.vectorStores.get(compiled.id);
+        if (existing) {
+            return existing;
+        }
+        const resolved = await resolveCompiledVectorStore(this.workspace, compiled, {
+            embeddingModelResolver: this.runtimeAdapterOptions.embeddingModelResolver,
+            vectorStoreResolver: this.runtimeAdapterOptions.vectorStoreResolver,
+        });
+        this.vectorStores.set(compiled.id, resolved);
+        return resolved;
+    }
+    constructor(workspace, runtimeAdapterOptions = {}) {
+        this.workspace = workspace;
+        this.runtimeAdapterOptions = runtimeAdapterOptions;
+        const runRoot = this.defaultRunRoot();
+        this.persistence = new FilePersistence(runRoot);
+        const defaultStoreConfig = this.listHostBindings()[0]?.harnessRuntime.store;
+        this.defaultStore = defaultStoreConfig ? createStoreForConfig(defaultStoreConfig, runRoot) : new FileBackedStore(`${runRoot}/store.json`);
+        this.runtimeAdapter = new AgentRuntimeAdapter({
+            ...runtimeAdapterOptions,
+            toolResolver: runtimeAdapterOptions.toolResolver ??
+                createBuiltinToolResolver(workspace, {
+                    getStore: (binding) => this.resolveStore(binding),
+                    getEmbeddingModel: (embeddingModelRef) => this.resolveEmbeddingModel(embeddingModelRef),
+                    getVectorStore: (vectorStoreRef) => this.resolveVectorStore(vectorStoreRef),
+                }),
+            checkpointerResolver: runtimeAdapterOptions.checkpointerResolver ??
+                ((binding) => {
+                    const key = `${binding.harnessRuntime.runRoot}:${JSON.stringify(binding.harnessRuntime.checkpointer ?? { kind: "FileCheckpointer", path: "checkpoints.json" })}`;
+                    const existing = this.checkpointers.get(key);
+                    if (existing) {
+                        return existing;
+                    }
+                    const resolvedConfig = binding.harnessRuntime.checkpointer ?? { kind: "FileCheckpointer", path: "checkpoints.json" };
+                    const saver = createCheckpointerForConfig(resolvedConfig, binding.harnessRuntime.runRoot);
+                    this.checkpointers.set(key, saver);
+                    return saver;
+                }),
+            storeResolver: runtimeAdapterOptions.storeResolver ??
+                ((binding) => this.resolveStore(binding)),
+            backendResolver: runtimeAdapterOptions.backendResolver ??
+                ((binding) => createBuiltinBackendResolver(workspace)(binding)),
+        });
+        this.routingSystemPrompt = getRoutingSystemPrompt(workspace.refs);
+        this.threadMemorySync = new ThreadMemorySync(this.persistence, this.defaultStore);
+        this.unsubscribeThreadMemorySync = this.eventBus.subscribe((event) => {
+            void this.threadMemorySync.handleEvent(event);
+        });
+    }
+    async initialize() {
+        await this.persistence.initialize();
+    }
+    subscribeEvents(listener) {
+        return this.eventBus.subscribe(listener);
+    }
+    subscribe(listener) {
+        return this.subscribeEvents(listener);
+    }
+    async listSessions(filter) {
+        const sessions = await this.persistence.listSessions();
+        if (!filter?.agentId) {
+            return sessions;
+        }
+        return sessions.filter((session) => session.agentId === filter.agentId);
+    }
+    async getSession(threadId) {
+        return this.persistence.getSession(threadId);
+    }
+    async getEvents(threadId, runId) {
+        const session = await this.getSession(threadId);
+        if (!session) {
+            throw new Error(`Unknown thread ${threadId}`);
+        }
+        return this.persistence.listRunEvents(threadId, runId ?? session.latestRunId);
+    }
+    async listPendingApprovals() {
+        return (await this.persistence.listApprovals()).filter((approval) => approval.status === "pending");
+    }
+    async getApproval(approvalId) {
+        return this.persistence.getApproval(approvalId);
+    }
+    async listDelegations() {
+        return this.persistence.listDelegations();
+    }
+    async routeAgent(input, options = {}) {
+        const routingInput = await this.buildRoutingInput(input, options.threadId);
+        const normalized = input.trim().toLowerCase();
+        const { primaryBinding, secondaryBinding, researchBinding } = inferRoutingBindings(this.workspace);
+        const deterministicIntent = resolveDeterministicRouteIntent(normalized);
+        if (requiresResearchRoute(normalized)) {
+            const explicitResearchBinding = this.workspace.bindings.get("research-lite") ?? this.workspace.bindings.get("research");
+            const hostResearchBinding = explicitResearchBinding?.harnessRuntime.hostFacing !== false ? explicitResearchBinding : researchBinding;
+            return hostResearchBinding?.agent.id ?? secondaryBinding?.agent.id ?? primaryBinding?.agent.id ?? heuristicRoute(input, primaryBinding, secondaryBinding);
+        }
+        if (secondaryBinding?.deepAgentParams) {
+            return secondaryBinding.agent.id;
+        }
+        if (deterministicIntent === "primary") {
+            return primaryBinding?.agent.id ?? heuristicRoute(input, primaryBinding, secondaryBinding);
+        }
+        if (deterministicIntent === "secondary") {
+            return secondaryBinding?.agent.id ?? primaryBinding?.agent.id ?? heuristicRoute(input, primaryBinding, secondaryBinding);
+        }
+        if (!primaryBinding || !secondaryBinding) {
+            return heuristicRoute(input, primaryBinding, secondaryBinding);
+        }
+        try {
+            return await this.runtimeAdapter.route(routingInput, primaryBinding, secondaryBinding, {
+                systemPrompt: this.routingSystemPrompt,
+            });
+        }
+        catch {
+            return heuristicRoute(input, primaryBinding, secondaryBinding);
+        }
+    }
+    async artifacts(threadId, runId) {
+        const session = await this.getSession(threadId);
+        if (!session) {
+            throw new Error(`Unknown thread ${threadId}`);
+        }
+        return this.persistence.listArtifacts(threadId, runId ?? session.latestRunId);
+    }
+    async emit(threadId, runId, sequence, eventType, payload, source = "runtime") {
+        const event = createHarnessEvent(threadId, runId, sequence, eventType, payload, source);
+        await this.persistence.appendEvent(event);
+        this.eventBus.publish(event);
+        return event;
+    }
+    async persistApproval(threadId, runId, checkpointRef, input, interruptContent) {
+        const approval = createPendingApproval(threadId, runId, checkpointRef, input, interruptContent);
+        await this.persistence.createApproval(approval);
+        const artifact = await this.persistence.createArtifact(threadId, runId, {
+            artifactId: `artifact-approval-${runId}`,
+            kind: "approval-packet",
+            path: `artifacts/approval-${runId}.json`,
+            createdAt: approval.requestedAt,
+        }, approval);
+        await this.emit(threadId, runId, 5, "artifact.created", {
+            artifactId: artifact.artifactId,
+            kind: artifact.kind,
+            path: artifact.path,
+        });
+        return approval;
+    }
+    async resolveApprovalRecord(options, session) {
+        if (options.approvalId) {
+            const approval = await this.persistence.getApproval(options.approvalId);
+            if (!approval) {
+                throw new Error(`Unknown approval ${options.approvalId}`);
+            }
+            return approval;
+        }
+        const runId = options.runId ?? session.latestRunId;
+        const approvals = await this.persistence.getRunApprovals(options.threadId ?? session.threadId, runId);
+        const approval = approvals
+            .filter((candidate) => candidate.status === "pending")
+            .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
+        if (!approval) {
+            throw new Error(`No pending approval for run ${runId}`);
+        }
+        return approval;
+    }
+    async run(options) {
+        const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
+        const binding = this.workspace.bindings.get(selectedAgentId);
+        if (!binding) {
+            throw new Error(`Unknown agent ${selectedAgentId}`);
+        }
+        const policyDecision = this.policyEngine.evaluate(binding);
+        if (!policyDecision.allowed) {
+            throw new Error(`Policy evaluation blocked agent ${selectedAgentId}: ${policyDecision.reasons.join(", ")}`);
+        }
+        const threadId = options.threadId ?? createPersistentId();
+        const runId = createPersistentId();
+        const createdAt = new Date().toISOString();
+        if (!options.threadId) {
+            await this.persistence.createThread({
+                threadId,
+                agentId: selectedAgentId,
+                runId,
+                status: "running",
+                createdAt,
+            });
+        }
+        await this.persistence.appendThreadMessage(threadId, {
+            role: "user",
+            content: options.input,
+            runId,
+            createdAt,
+        });
+        await this.persistence.createRun({
+            threadId,
+            runId,
+            agentId: binding.agent.id,
+            executionMode: binding.agent.executionMode,
+            createdAt,
+        });
+        await this.emit(threadId, runId, 1, "run.created", {
+            agentId: binding.agent.id,
+            requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
+            selectedAgentId,
+            executionMode: binding.agent.executionMode,
+        });
+        try {
+            const history = await this.persistence.listThreadMessages(threadId);
+            const priorHistory = history.filter((message) => message.runId !== runId);
+            const actual = await this.runtimeAdapter.invoke(binding, options.input, threadId, runId, undefined, priorHistory);
+            let approval;
+            if (actual.output) {
+                await this.persistence.appendThreadMessage(threadId, {
+                    role: "assistant",
+                    content: actual.output,
+                    runId,
+                    createdAt: new Date().toISOString(),
+                });
+            }
+            await this.persistence.setRunState(threadId, runId, actual.state, actual.state === "waiting_for_approval" ? `checkpoints/${threadId}/${runId}/cp-1` : null);
+            if (actual.state === "waiting_for_approval") {
+                const checkpointRef = `checkpoints/${threadId}/${runId}/cp-1`;
+                approval = await this.persistApproval(threadId, runId, checkpointRef, options.input, actual.interruptContent);
+                await this.emit(threadId, runId, 4, "approval.requested", {
+                    approvalId: approval.approvalId,
+                    pendingActionId: approval.pendingActionId,
+                    toolName: approval.toolName,
+                    toolCallId: approval.toolCallId,
+                    allowedDecisions: approval.allowedDecisions,
+                    checkpointRef,
+                });
+            }
+            await this.emit(threadId, runId, 3, "run.state.changed", {
+                previousState: null,
+                state: actual.state,
+                checkpointRef: actual.state === "waiting_for_approval" ? `checkpoints/${threadId}/${runId}/cp-1` : null,
+            });
+            return {
+                ...actual,
+                threadId,
+                runId,
+                agentId: selectedAgentId,
+                approvalId: approval?.approvalId ?? actual.approvalId,
+                pendingActionId: approval?.pendingActionId ?? actual.pendingActionId,
+            };
+        }
+        catch (error) {
+            await this.emit(threadId, runId, 3, "runtime.synthetic_fallback", {
+                reason: error instanceof Error ? error.message : String(error),
+                selectedAgentId,
+            });
+            await this.persistence.setRunState(threadId, runId, "failed");
+            await this.emit(threadId, runId, 4, "run.state.changed", {
+                previousState: null,
+                state: "failed",
+                checkpointRef: null,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return {
+                threadId,
+                runId,
+                agentId: selectedAgentId,
+                state: "failed",
+                output: renderRuntimeFailure(error),
+            };
+        }
+    }
+    async *stream(options) {
+        for await (const item of this.streamEvents(options)) {
+            if (item.type === "content") {
+                yield item.content;
+            }
+        }
+    }
+    async *streamEvents(options) {
+        const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
+        const binding = this.workspace.bindings.get(selectedAgentId);
+        if (!binding) {
+            const result = await this.run(options);
+            for (const line of result.output.split("\n")) {
+                yield {
+                    type: "content",
+                    threadId: result.threadId,
+                    runId: result.runId,
+                    agentId: result.agentId ?? selectedAgentId,
+                    content: `${line}\n`,
+                };
+            }
+            return;
+        }
+        let emitted = false;
+        const threadId = options.threadId ?? createPersistentId();
+        const runId = createPersistentId();
+        const createdAt = new Date().toISOString();
+        if (!options.threadId) {
+            await this.persistence.createThread({
+                threadId,
+                agentId: selectedAgentId,
+                runId,
+                status: "running",
+                createdAt,
+            });
+        }
+        await this.persistence.appendThreadMessage(threadId, {
+            role: "user",
+            content: options.input,
+            runId,
+            createdAt,
+        });
+        await this.persistence.createRun({
+            threadId,
+            runId,
+            agentId: selectedAgentId,
+            executionMode: binding.agent.executionMode,
+            createdAt,
+        });
+        yield { type: "event", event: await this.emit(threadId, runId, 1, "run.created", {
+                agentId: selectedAgentId,
+                requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
+                selectedAgentId,
+                input: options.input,
+                state: "running",
+            }) };
+        try {
+            const history = await this.persistence.listThreadMessages(threadId);
+            const priorHistory = history.filter((message) => message.runId !== runId);
+            let assistantOutput = "";
+            for await (const chunk of this.runtimeAdapter.stream(binding, options.input, threadId, priorHistory)) {
+                if (chunk) {
+                    const normalizedChunk = typeof chunk === "string"
+                        ? chunk.startsWith(AGENT_INTERRUPT_SENTINEL_PREFIX)
+                            ? { kind: "interrupt", content: chunk.slice(AGENT_INTERRUPT_SENTINEL_PREFIX.length) }
+                            : { kind: "content", content: chunk }
+                        : chunk;
+                    if (normalizedChunk.kind === "interrupt") {
+                        const checkpointRef = `checkpoints/${threadId}/${runId}/cp-1`;
+                        await this.persistence.setRunState(threadId, runId, "waiting_for_approval", checkpointRef);
+                        const approval = await this.persistApproval(threadId, runId, checkpointRef, options.input, normalizedChunk.content);
+                        yield {
+                            type: "event",
+                            event: await this.emit(threadId, runId, 4, "run.state.changed", {
+                                previousState: null,
+                                state: "waiting_for_approval",
+                                checkpointRef,
+                            }),
+                        };
+                        yield {
+                            type: "event",
+                            event: await this.emit(threadId, runId, 5, "approval.requested", {
+                                approvalId: approval.approvalId,
+                                pendingActionId: approval.pendingActionId,
+                                toolName: approval.toolName,
+                                toolCallId: approval.toolCallId,
+                                allowedDecisions: approval.allowedDecisions,
+                                checkpointRef,
+                            }),
+                        };
+                        return;
+                    }
+                    if (normalizedChunk.kind === "reasoning") {
+                        await this.emit(threadId, runId, 3, "reasoning.delta", {
+                            content: normalizedChunk.content,
+                        });
+                        yield {
+                            type: "reasoning",
+                            threadId,
+                            runId,
+                            agentId: selectedAgentId,
+                            content: normalizedChunk.content,
+                        };
+                        continue;
+                    }
+                    if (normalizedChunk.kind === "step") {
+                        yield {
+                            type: "step",
+                            threadId,
+                            runId,
+                            agentId: selectedAgentId,
+                            content: normalizedChunk.content,
+                        };
+                        continue;
+                    }
+                    if (normalizedChunk.kind === "tool-result") {
+                        yield {
+                            type: "tool-result",
+                            threadId,
+                            runId,
+                            agentId: selectedAgentId,
+                            toolName: normalizedChunk.toolName,
+                            output: normalizedChunk.output,
+                        };
+                        continue;
+                    }
+                    emitted = true;
+                    assistantOutput += normalizedChunk.content;
+                    await this.emit(threadId, runId, 3, "output.delta", {
+                        content: normalizedChunk.content,
+                    });
+                    yield {
+                        type: "content",
+                        threadId,
+                        runId,
+                        agentId: selectedAgentId,
+                        content: normalizedChunk.content,
+                    };
+                }
+            }
+            if (!assistantOutput) {
+                const actual = await this.runtimeAdapter.invoke(binding, options.input, threadId, runId, undefined, priorHistory);
+                if (actual.output) {
+                    assistantOutput = actual.output;
+                    emitted = true;
+                    await this.emit(threadId, runId, 3, "output.delta", {
+                        content: actual.output,
+                    });
+                    yield {
+                        type: "content",
+                        threadId,
+                        runId,
+                        agentId: selectedAgentId,
+                        content: actual.output,
+                    };
+                }
+            }
+            if (assistantOutput) {
+                await this.persistence.appendThreadMessage(threadId, {
+                    role: "assistant",
+                    content: assistantOutput,
+                    runId,
+                    createdAt: new Date().toISOString(),
+                });
+            }
+            await this.persistence.setRunState(threadId, runId, "completed");
+            yield { type: "event", event: await this.emit(threadId, runId, 4, "run.state.changed", {
+                    previousState: null,
+                    state: "completed",
+                    checkpointRef: null,
+                }) };
+            return;
+        }
+        catch (error) {
+            if (emitted) {
+                await this.persistence.setRunState(threadId, runId, "failed");
+                yield { type: "event", event: await this.emit(threadId, runId, 4, "run.state.changed", {
+                        previousState: null,
+                        state: "failed",
+                        error: error instanceof Error ? error.message : String(error),
+                    }) };
+                return;
+            }
+            try {
+                const history = await this.persistence.listThreadMessages(threadId);
+                const priorHistory = history.filter((message) => message.runId !== runId);
+                const actual = await this.runtimeAdapter.invoke(binding, options.input, threadId, runId, undefined, priorHistory);
+                if (actual.output) {
+                    await this.persistence.appendThreadMessage(threadId, {
+                        role: "assistant",
+                        content: actual.output,
+                        runId,
+                        createdAt: new Date().toISOString(),
+                    });
+                    yield {
+                        type: "content",
+                        threadId,
+                        runId,
+                        agentId: selectedAgentId,
+                        content: actual.output,
+                    };
+                }
+                await this.persistence.setRunState(threadId, runId, actual.state);
+                yield { type: "event", event: await this.emit(threadId, runId, 4, "run.state.changed", {
+                        previousState: null,
+                        state: actual.state,
+                        checkpointRef: null,
+                    }) };
+                return;
+            }
+            catch (invokeError) {
+                await this.emit(threadId, runId, 3, "runtime.synthetic_fallback", {
+                    reason: invokeError instanceof Error ? invokeError.message : String(invokeError),
+                    selectedAgentId,
+                });
+                await this.persistence.setRunState(threadId, runId, "failed");
+                yield { type: "event", event: await this.emit(threadId, runId, 4, "run.state.changed", {
+                        previousState: null,
+                        state: "failed",
+                        checkpointRef: null,
+                        error: invokeError instanceof Error ? invokeError.message : String(invokeError),
+                    }) };
+                yield {
+                    type: "content",
+                    threadId,
+                    runId,
+                    agentId: selectedAgentId,
+                    content: renderRuntimeFailure(invokeError),
+                };
+                return;
+            }
+        }
+    }
+    async streamReadable(options) {
+        return Readable.from(this.stream(options));
+    }
+    async resume(options) {
+        const approvalById = options.approvalId ? await this.persistence.getApproval(options.approvalId) : null;
+        const session = options.threadId
+            ? await this.getSession(options.threadId)
+            : approvalById
+                ? await this.getSession(approvalById.threadId)
+                : null;
+        if (!session) {
+            throw new Error("resume requires either threadId or approvalId");
+        }
+        const approval = approvalById ?? await this.resolveApprovalRecord(options, session);
+        const threadId = approval.threadId;
+        const runId = approval.runId;
+        const binding = this.workspace.bindings.get(session.agentId);
+        if (!binding) {
+            throw new Error(`Unknown agent ${session.agentId}`);
+        }
+        await this.persistence.setRunState(threadId, runId, "resuming", `checkpoints/${threadId}/${runId}/cp-1`);
+        await this.emit(threadId, runId, 5, "run.resumed", {
+            resumeKind: "cross-restart",
+            checkpointRef: `checkpoints/${threadId}/${runId}/cp-1`,
+            state: "resuming",
+            approvalId: approval.approvalId,
+            pendingActionId: approval.pendingActionId,
+        });
+        await this.persistence.resolveApproval(threadId, runId, approval.approvalId, options.decision === "reject" ? "rejected" : options.decision === "edit" ? "edited" : "approved");
+        await this.emit(threadId, runId, 6, "approval.resolved", {
+            approvalId: approval.approvalId,
+            pendingActionId: approval.pendingActionId,
+            decision: options.decision ?? "approve",
+            toolName: approval.toolName,
+        });
+        const history = await this.persistence.listThreadMessages(threadId);
+        const priorHistory = history.filter((message) => message.runId !== runId);
+        const resumeDecision = options.decision === "edit" && options.editedInput
+            ? { decision: "edit", editedInput: options.editedInput }
+            : (options.decision ?? "approve");
+        const actual = await this.runtimeAdapter.invoke(binding, "", threadId, runId, resumeDecision, priorHistory);
+        if (actual.output) {
+            await this.persistence.appendThreadMessage(threadId, {
+                role: "assistant",
+                content: actual.output,
+                runId,
+                createdAt: new Date().toISOString(),
+            });
+        }
+        await this.persistence.setRunState(threadId, runId, actual.state, actual.state === "waiting_for_approval" ? `checkpoints/${threadId}/${runId}/cp-1` : null);
+        await this.emit(threadId, runId, 7, "run.state.changed", {
+            previousState: "resuming",
+            state: actual.state,
+            checkpointRef: actual.state === "waiting_for_approval" ? `checkpoints/${threadId}/${runId}/cp-1` : null,
+        });
+        return {
+            ...actual,
+            threadId,
+            runId,
+            approvalId: approval.approvalId,
+            pendingActionId: approval.pendingActionId,
+        };
+    }
+    async submitDecision(options) {
+        return this.resume(options);
+    }
+    async approve(threadId, runId) {
+        return this.submitDecision({ threadId, runId, decision: "approve" });
+    }
+    async reject(threadId, runId) {
+        return this.submitDecision({ threadId, runId, decision: "reject" });
+    }
+    async restartConversation(options) {
+        const session = await this.getSession(options.threadId);
+        if (!session) {
+            throw new Error(`Unknown thread ${options.threadId}`);
+        }
+        const sourceRunId = session.latestRunId;
+        const targetThreadId = options.mode === "restart-new-thread" ? createPersistentId() : options.threadId;
+        const result = await this.run({
+            agentId: session.agentId,
+            input: options.input,
+            threadId: options.mode === "restart-new-thread" ? undefined : targetThreadId,
+        });
+        return {
+            ...result,
+            restart: {
+                sourceThreadId: options.threadId,
+                sourceRunId,
+                restartMode: options.mode,
+                restartedBy: "console",
+                restartedAt: new Date().toISOString(),
+                newThreadId: result.threadId,
+                newRunId: result.runId,
+            },
+        };
+    }
+    async close() {
+        this.unsubscribeThreadMemorySync();
+        await this.threadMemorySync.close();
+    }
+}