@botbotgo/agent-harness 0.0.108 → 0.0.109

package/dist/runtime/harness.js

@@ -1,34 +1,35 @@
-import { AUTO_AGENT_ID } from "../contracts/types.js";
 import { SqlitePersistence } from "../persistence/sqlite-store.js";
 import { createPersistentId } from "../utils/id.js";
 import { AgentRuntimeAdapter } from "./agent-runtime-adapter.js";
-import { createResourceBackendResolver, createResourceToolResolver } from "../resource/resource.js";
 import { EventBus } from "./harness/events/event-bus.js";
 import { createBackgroundEventRuntime } from "./harness/background-runtime.js";
 import { PolicyEngine } from "./harness/system/policy-engine.js";
-import { getConcurrencyConfig, getRecoveryConfig, getRoutingDefaultAgentId, getRoutingRules, matchRoutingRule, } from "../workspace/support/workspace-ref-utils.js";
+import { getConcurrencyConfig, getRecoveryConfig, getRoutingDefaultAgentId, getRoutingRules, } from "../workspace/support/workspace-ref-utils.js";
 import { createHarnessEvent, inferRoutingBindings, renderRuntimeFailure, } from "./support/harness-support.js";
 import { ThreadMemorySync } from "./harness/system/thread-memory-sync.js";
 import { FileBackedStore } from "./harness/system/store.js";
 import { HealthMonitor, readHealthMonitorConfig, } from "./harness/system/health-monitor.js";
-import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
-import { buildPersistedRunRequest, normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, } from "./harness/run/helpers.js";
-import { emitHarnessEvent, emitRunCreatedEvent, emitSyntheticFallbackEvent, requestApprovalAndEmitEvent, setRunStateAndEmitEvent, } from "./harness/events/events.js";
-import { appendAssistantMessage as appendLifecycleAssistantMessage, finalizeCancelledRun as finalizeLifecycleCancelledRun, finalizeContinuedRun as finalizeLifecycleContinuedRun, } from "./harness/run/run-lifecycle.js";
-import { dispatchRunListeners as dispatchStreamingRunListeners, } from "./harness/events/streaming.js";
-import { buildResumePayload as buildHarnessResumePayload, resolveApprovalRecord as resolveHarnessApprovalRecord, } from "./harness/run/resume.js";
-import { cancelRunOperation, resumeRun } from "./harness/run/run-operations.js";
+import { normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, } from "./harness/run/helpers.js";
+import { emitHarnessEvent, } from "./harness/events/events.js";
+import { createRuntimeEventOperations } from "./harness/events/runtime-event-operations.js";
+import { finalizeCancelledRun as finalizeLifecycleCancelledRun, finalizeContinuedRun as finalizeLifecycleContinuedRun, } from "./harness/run/run-lifecycle.js";
+import { createListenerDispatchRuntime } from "./harness/events/listener-runtime.js";
+import { cancelRunOperation, executeQueuedRunOperation, resumeRun } from "./harness/run/run-operations.js";
+import { createResumeRunRuntime } from "./harness/run/resume-runtime.js";
 import { acquireRunSlot as acquireHarnessRunSlot } from "./harness/run/run-slot-acquisition.js";
 import { dropPendingRunSlot, enqueuePendingRunSlot } from "./harness/run/run-queue.js";
-import { getDefaultHostAgentId, resolveSelectedAgentId } from "./harness/run/routing.js";
-import { resolveCheckpointer, resolveEmbeddingModel, resolveStore, resolveStoreFromConfig, resolveVectorStore, } from "./harness/run/resources.js";
+import { getDefaultHostAgentId, resolveSelectedAgentId, routeAgentId } from "./harness/run/routing.js";
+import { resolveStoreFromConfig, } from "./harness/run/resources.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
-import { getBindingAdapterKind, getBindingStoreConfig } from "./support/compiled-binding.js";
-import { getRequiredWorkspaceBinding, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
+import { getBindingAdapterKind } from "./support/compiled-binding.js";
+import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
 import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
-import { initializeHarnessRuntime, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
+import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
+import { initializeHarnessRuntime, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
+import { createStreamRunRuntime } from "./harness/run/stream-runtime.js";
+import { defaultRequestedAgentId, prepareRunStart } from "./harness/run/start-run.js";
 import { deleteThreadRecord, getPublicApproval, getThreadRecord, listPublicApprovals, } from "./harness/run/thread-records.js";
 export class AgentHarnessRuntime {
     workspace;
@@ -67,7 +68,10 @@ export class AgentHarnessRuntime {
     pendingRunInsertionOrder = 0;
     pendingRunSlots = [];
     runtimeEventSequence = 0;
+    initialized = false;
+    closed = false;
     backgroundEventRuntime;
+    runtimeEventOperations;
     defaultRunRoot() {
         return this.defaultRunRootValue;
     }
@@ -99,21 +103,16 @@ export class AgentHarnessRuntime {
             ? this.defaultHostBinding.harnessRuntime.runtimeMemory.store
             : undefined;
         this.runtimeMemoryStore = resolveStoreFromConfig(this.stores, runtimeMemoryStoreConfig, runRoot) ?? this.defaultStore;
-        this.resolvedRuntimeAdapterOptions = {
-            ...runtimeAdapterOptions,
-            toolResolver: runtimeAdapterOptions.toolResolver ??
-                createResourceToolResolver(workspace, {
-                    getStore: (binding) => resolveStore(this.stores, this.defaultStore, this.defaultRunRoot(), (currentBinding) => currentBinding ? getBindingStoreConfig(currentBinding) : undefined, binding),
-                    getEmbeddingModel: (embeddingModelRef) => resolveEmbeddingModel(this.workspace, this.embeddingModels, embeddingModelRef, this.runtimeAdapterOptions),
-                    getVectorStore: (vectorStoreRef) => resolveVectorStore(this.workspace, this.vectorStores, vectorStoreRef, this.runtimeAdapterOptions),
-                }),
-            checkpointerResolver: runtimeAdapterOptions.checkpointerResolver ??
-                ((binding) => resolveCheckpointer(this.checkpointers, binding)),
-            storeResolver: runtimeAdapterOptions.storeResolver ??
-                ((binding) => resolveStore(this.stores, this.defaultStore, this.defaultRunRoot(), (currentBinding) => currentBinding ? getBindingStoreConfig(currentBinding) : undefined, binding)),
-            backendResolver: runtimeAdapterOptions.backendResolver ??
-                ((binding) => createResourceBackendResolver(workspace)(binding)),
-        };
+        this.resolvedRuntimeAdapterOptions = resolveRuntimeAdapterOptions({
+            workspace,
+            runtimeAdapterOptions,
+            checkpointers: this.checkpointers,
+            stores: this.stores,
+            defaultStore: this.defaultStore,
+            embeddingModels: this.embeddingModels,
+            vectorStores: this.vectorStores,
+            getDefaultRunRoot: () => this.defaultRunRoot(),
+        });
         this.runtimeAdapter = new AgentRuntimeAdapter(this.resolvedRuntimeAdapterOptions);
         this.backgroundEventRuntime = createBackgroundEventRuntime({
             persistence: this.persistence,
@@ -121,6 +120,7 @@ export class AgentHarnessRuntime {
             trackBackgroundTask: (task) => this.trackBackgroundTask(task),
             backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
         });
+        this.runtimeEventOperations = createRuntimeEventOperations(this.backgroundEventRuntime);
         this.routingRules = getRoutingRules(workspace.refs);
         this.routingDefaultAgentId = getRoutingDefaultAgentId(workspace.refs);
         if (isThreadMemorySyncEnabled(workspace)) {
@@ -156,10 +156,18 @@ export class AgentHarnessRuntime {
         this.healthMonitor?.recordLlmFailure(Date.now() - startedAt);
     }
     async initialize() {
+        if (this.closed) {
+            throw new Error("AgentHarnessRuntime has been closed and cannot be reinitialized");
+        }
+        if (this.initialized) {
+            return;
+        }
         await initializeHarnessRuntime({
             persistence: this.persistence,
             healthMonitor: this.healthMonitor,
         });
+        await this.recoverStartupRuns();
+        this.initialized = true;
     }
     subscribe(listener) {
         return this.eventBus.subscribe(listener);
@@ -236,45 +244,21 @@ export class AgentHarnessRuntime {
         }, threadId);
     }
     async createToolMcpServer(options) {
-        const tools = resolveWorkspaceAgentTools({
-            workspace: this.workspace,
-            agentId: options.agentId,
-            toolResolver: this.resolvedRuntimeAdapterOptions.toolResolver,
-        }).map(({ compiledTool, resolvedTool }) => ({
-            compiledTool,
-            resolvedTool,
-            sourceTool: this.workspace.tools.get(compiledTool.id),
-        }));
+        const tools = this.resolveToolMcpServerTools(options.agentId);
         return createToolMcpServerFromTools(tools, options);
     }
     async serveToolsOverStdio(options) {
-        const tools = resolveWorkspaceAgentTools({
-            workspace: this.workspace,
-            agentId: options.agentId,
-            toolResolver: this.resolvedRuntimeAdapterOptions.toolResolver,
-        }).map(({ compiledTool, resolvedTool }) => ({
-            compiledTool,
-            resolvedTool,
-            sourceTool: this.workspace.tools.get(compiledTool.id),
-        }));
+        const tools = this.resolveToolMcpServerTools(options.agentId);
         return serveToolsOverStdioFromHarness(tools, options);
     }
     async routeAgent(input, options = {}) {
-        const rawInput = extractMessageText(input);
-        const configuredRule = this.routingRules.find((rule) => matchRoutingRule(rawInput, rule, options));
-        if (configuredRule) {
-            const configuredBinding = getWorkspaceBinding(this.workspace, configuredRule.agentId);
-            if (configuredBinding) {
-                return configuredBinding.agent.id;
-            }
-        }
-        const defaultBinding = this.routingDefaultAgentId
-            ? getWorkspaceBinding(this.workspace, this.routingDefaultAgentId)
-            : undefined;
-        if (defaultBinding) {
-            return defaultBinding.agent.id;
-        }
-        return this.getDefaultHostAgentId();
+        return routeAgentId({
+            workspace: this.workspace,
+            input,
+            routingRules: this.routingRules,
+            routingDefaultAgentId: this.routingDefaultAgentId,
+            threadId: options.threadId,
+        });
     }
     async emit(threadId, runId, sequence, eventType, payload, source = "runtime") {
         return emitHarnessEvent({
@@ -290,55 +274,16 @@ export class AgentHarnessRuntime {
             this.backgroundTasks.delete(task);
         });
     }
-    async ensureThreadStarted(selectedAgentId, binding, input, runRequest, existingThreadId) {
-        const threadId = existingThreadId ?? createPersistentId();
-        const runId = createPersistentId();
-        const createdAt = new Date().toISOString();
-        const isNewThread = !existingThreadId;
-        const userMessage = {
-            role: "user",
-            content: normalizeMessageContent(input),
-            runId,
-            createdAt,
-        };
-        if (typeof this.persistence.bootstrapRun === "function") {
-            await this.persistence.bootstrapRun({
-                threadId,
-                agentId: binding.agent.id,
-                runId,
-                status: "running",
-                createdAt,
-                executionMode: getBindingAdapterKind(binding),
-                adapterKind: getBindingAdapterKind(binding),
-                userMessage,
-                runRequest,
-                createThread: isNewThread,
-            });
-        }
-        else {
-            if (isNewThread) {
-                await this.persistence.createThread({
-                    threadId,
-                    agentId: selectedAgentId,
-                    runId,
-                    status: "running",
-                    createdAt,
-                });
-            }
-            await Promise.all([
-                this.persistence.appendThreadMessage(threadId, userMessage),
-                this.persistence.createRun({
-                    threadId,
-                    runId,
-                    agentId: binding.agent.id,
-                    executionMode: getBindingAdapterKind(binding),
-                    adapterKind: getBindingAdapterKind(binding),
-                    createdAt,
-                }),
-                this.persistence.saveRunRequest(threadId, runId, runRequest),
-            ]);
-        }
-        return { threadId, runId, createdAt, isNewThread };
+    resolveToolMcpServerTools(agentId) {
+        return resolveWorkspaceAgentTools({
+            workspace: this.workspace,
+            agentId,
+            toolResolver: this.resolvedRuntimeAdapterOptions.toolResolver,
+        }).map(({ compiledTool, resolvedTool }) => ({
+            compiledTool,
+            resolvedTool,
+            sourceTool: this.workspace.tools.get(compiledTool.id),
+        }));
     }
     async loadPriorHistory(threadId, runId) {
         const history = await this.persistence.listThreadMessages(threadId);
@@ -384,71 +329,33 @@ export class AgentHarnessRuntime {
         return enqueuePendingRunSlot(this.pendingRunSlots, entry, this.pendingRunInsertionOrder++);
     }
     async executeQueuedRun(binding, input, threadId, runId, agentId, options = {}) {
-        const previousState = options.previousState ?? "running";
-        const currentRun = await this.persistence.getRun(runId);
-        if (currentRun?.state === "cancelled") {
-            return {
-                threadId,
-                runId,
-                agentId,
-                state: "cancelled",
-                output: "cancelled",
-            };
-        }
-        const cancellation = await this.getRunCancellation(runId);
-        if (cancellation.requested) {
-            return this.finalizeCancelledRun(threadId, runId, previousState, cancellation.reason);
-        }
-        if (previousState === "queued") {
-            await this.emit(threadId, runId, 101, "run.dequeued", {
-                queuePosition: 0,
-                activeRunCount: this.activeRunSlots,
-                maxConcurrentRuns: this.concurrencyConfig.maxConcurrentRuns,
-                recoveredOnStartup: true,
-            });
-            await this.setRunStateAndEmit(threadId, runId, 102, "running", {
-                previousState: "queued",
-            });
-        }
-        try {
-            const actual = await this.invokeWithHistory(binding, input, threadId, runId, undefined, options.priorHistory, {
-                context: options.context,
-                state: options.state,
-                files: options.files,
-            });
-            const cancelledAfterInvoke = await this.getRunCancellation(runId);
-            if (cancelledAfterInvoke.requested) {
-                return this.finalizeCancelledRun(threadId, runId, previousState === "queued" ? "running" : previousState, cancelledAfterInvoke.reason);
-            }
-            const finalized = await this.finalizeContinuedRun(binding, threadId, runId, input, actual, {
-                previousState: previousState === "queued" ? "running" : previousState,
-                stateSequence: options.stateSequence ?? 103,
-                approvalSequence: options.approvalSequence ?? 104,
-            });
-            return {
-                ...finalized,
-                agentId,
-            };
-        }
-        catch (error) {
-            await emitSyntheticFallbackEvent({
-                ...this.backgroundEventRuntime,
-            }, threadId, runId, agentId, error, 103);
-            await this.setRunStateAndEmit(threadId, runId, 104, "failed", {
-                previousState: previousState === "queued" ? "running" : previousState,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                threadId,
-                runId,
-                agentId,
-                state: "failed",
-                output: renderRuntimeFailure(error),
-            };
-        }
-        finally {
-            await this.persistence.clearRunRequest(threadId, runId);
-        }
+        return executeQueuedRunOperation({
+            persistence: this.persistence,
+            getRunCancellation: (currentRunId) => this.getRunCancellation(currentRunId),
+            finalizeCancelledRun: (currentThreadId, currentRunId, previousRunState, reason) => this.finalizeCancelledRun(currentThreadId, currentRunId, previousRunState, reason),
+            emit: (currentThreadId, currentRunId, sequence, eventType, payload) => {
+                if (eventType === "run.dequeued") {
+                    return this.emit(currentThreadId, currentRunId, sequence, eventType, {
+                        ...payload,
+                        activeRunCount: this.activeRunSlots,
+                        maxConcurrentRuns: this.concurrencyConfig.maxConcurrentRuns,
+                    });
+                }
+                return this.emit(currentThreadId, currentRunId, sequence, eventType, payload);
+            },
+            setRunStateAndEmit: (currentThreadId, currentRunId, sequence, state, stateOptions) => this.setRunStateAndEmit(currentThreadId, currentRunId, sequence, state, stateOptions),
+            invokeWithHistory: (activeBinding, activeInput, currentThreadId, currentRunId, resumePayload, priorHistory, invokeOptions) => this.invokeWithHistory(activeBinding, activeInput, currentThreadId, currentRunId, resumePayload, priorHistory, invokeOptions),
+            finalizeContinuedRun: (activeBinding, currentThreadId, currentRunId, currentInput, actual, finalizeOptions) => this.finalizeContinuedRun(activeBinding, currentThreadId, currentRunId, currentInput, actual, finalizeOptions),
+            emitSyntheticFallback: (currentThreadId, currentRunId, currentAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(currentThreadId, currentRunId, currentAgentId, error, 103),
+            renderRuntimeFailure,
+        }, {
+            binding,
+            message: input,
+            threadId,
+            runId,
+            agentId,
+            options,
+        });
     }
     async finalizeContinuedRun(binding, threadId, runId, input, actual, options) {
         return finalizeLifecycleContinuedRun({
@@ -459,14 +366,10 @@ export class AgentHarnessRuntime {
         }, binding, threadId, runId, input, actual, options);
     }
     async setRunStateAndEmit(threadId, runId, sequence, state, options) {
-        return setRunStateAndEmitEvent({
-            ...this.backgroundEventRuntime,
-        }, threadId, runId, sequence, state, options);
+        return this.runtimeEventOperations.setRunStateAndEmit(threadId, runId, sequence, state, options);
     }
     async requestApprovalAndEmit(threadId, runId, input, interruptContent, checkpointRef, sequence) {
-        return requestApprovalAndEmitEvent({
-            ...this.backgroundEventRuntime,
-        }, threadId, runId, input, interruptContent, checkpointRef, sequence);
+        return this.runtimeEventOperations.requestApprovalAndEmit(threadId, runId, input, interruptContent, checkpointRef, sequence);
     }
     isDecisionRun(options) {
         return "decision" in options;
@@ -477,29 +380,6 @@ export class AgentHarnessRuntime {
         }
         await listener(value);
     }
-    async prepareRunStart(options, invocation, runCreatedPayload) {
-        const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
-        const binding = getRequiredWorkspaceBinding(this.workspace, selectedAgentId);
-        const policyDecision = this.policyEngine.evaluate(binding);
-        if (!policyDecision.allowed) {
-            throw new Error(`Policy evaluation blocked agent ${selectedAgentId}: ${policyDecision.reasons.join(", ")}`);
-        }
-        const priority = normalizeRunPriority(options.priority);
-        const runRequest = buildPersistedRunRequest(options.input, invocation, priority);
-        const { threadId, runId, isNewThread } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, runRequest, options.threadId);
-        return {
-            binding,
-            selectedAgentId,
-            priority,
-            threadId,
-            runId,
-            isNewThread,
-            runCreatedEventPromise: emitRunCreatedEvent({
-                ...this.backgroundEventRuntime,
-            }, threadId, runId, runCreatedPayload(binding, selectedAgentId)),
-            releaseRunSlotPromise: this.acquireRunSlot(threadId, runId, "running", priority),
-        };
-    }
     async acquireRunSlot(threadId, runId, activeState = "running", priority = 0) {
         return acquireHarnessRunSlot({
             persistence: this.persistence,
@@ -523,12 +403,6 @@ export class AgentHarnessRuntime {
     dropPendingRunSlot(runId) {
         return dropPendingRunSlot(this.pendingRunSlots, runId);
     }
-    async dispatchRunListeners(stream, listeners) {
-        return dispatchStreamingRunListeners(stream, listeners, {
-            notifyListener: (listener, value) => this.notifyListener(listener, value),
-            getThread: (threadId) => this.getThread(threadId),
-        });
-    }
     async run(options) {
         if (this.isDecisionRun(options)) {
             const resumeOptions = {
@@ -542,15 +416,29 @@ export class AgentHarnessRuntime {
         }
         const resolvedListeners = resolveRunListeners(options);
         if (resolvedListeners) {
-            return this.dispatchRunListeners(this.streamEvents(options), resolvedListeners);
+            return createListenerDispatchRuntime({
+                notifyListener: (listener, value) => this.notifyListener(listener, value),
+                getThread: (threadId) => this.getThread(threadId),
+            }).dispatchRunListeners(this.streamEvents(options), resolvedListeners);
         }
         const invocation = normalizeInvocationEnvelope(options);
-        const { binding, selectedAgentId, threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await this.prepareRunStart(options, invocation, (activeBinding, activeSelectedAgentId) => ({
-            agentId: activeBinding.agent.id,
-            requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
-            selectedAgentId: activeSelectedAgentId,
-            executionMode: getBindingAdapterKind(activeBinding),
-        }));
+        const { binding, selectedAgentId, threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart({
+            workspace: this.workspace,
+            policyEngine: this.policyEngine,
+            persistence: this.persistence,
+            resolveSelectedAgentId: (input, requestedAgentId, threadId) => this.resolveSelectedAgentId(input, requestedAgentId, threadId),
+            emitRunCreated: (threadId, runId, payload) => this.runtimeEventOperations.emitRunCreated(threadId, runId, payload),
+            acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
+        }, {
+            options,
+            invocation,
+            runCreatedPayload: (activeBinding, activeSelectedAgentId) => ({
+                agentId: activeBinding.agent.id,
+                requestedAgentId: defaultRequestedAgentId(options.agentId),
+                selectedAgentId: activeSelectedAgentId,
+                executionMode: getBindingAdapterKind(activeBinding),
+            }),
+        });
         await runCreatedEventPromise;
         const releaseRunSlot = await releaseRunSlotPromise;
         try {
@@ -585,13 +473,34 @@ export class AgentHarnessRuntime {
             }
             return;
         }
-        const { threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await this.prepareRunStart(options, invocation, (_binding, activeSelectedAgentId) => ({
-            agentId: activeSelectedAgentId,
-            requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
-            selectedAgentId: activeSelectedAgentId,
-            input: options.input,
-            state: "running",
-        }));
+        const { threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart({
+            workspace: this.workspace,
+            policyEngine: this.policyEngine,
+            persistence: this.persistence,
+            resolveSelectedAgentId: (input, requestedAgentId, threadId) => this.resolveSelectedAgentId(input, requestedAgentId, threadId),
+            emitRunCreated: (threadId, runId, payload) => this.runtimeEventOperations.emitRunCreated(threadId, runId, payload),
+            acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
+        }, {
+            options,
+            invocation,
+            runCreatedPayload: (_binding, activeSelectedAgentId) => ({
+                agentId: activeSelectedAgentId,
+                requestedAgentId: defaultRequestedAgentId(options.agentId),
+                selectedAgentId: activeSelectedAgentId,
+                input: options.input,
+                state: "running",
+            }),
+        });
+        const streamRuntime = createStreamRunRuntime({
+            persistence: this.persistence,
+            runtimeAdapter: this.runtimeAdapter,
+            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
+            setRunStateAndEmit: (threadId, runId, sequence, state, stateOptions) => this.setRunStateAndEmit(threadId, runId, sequence, state, stateOptions),
+            requestApprovalAndEmit: (threadId, runId, input, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(threadId, runId, input, interruptContent, checkpointRef, sequence),
+            loadPriorHistory: (threadId, runId) => this.loadPriorHistory(threadId, runId),
+            invokeWithHistory: (binding, input, threadId, runId) => this.invokeWithHistory(binding, input, threadId, runId),
+            emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
+        });
         yield* streamHarnessRun({
             binding,
             input: options.input,
@@ -602,42 +511,25 @@ export class AgentHarnessRuntime {
             isNewThread,
             runCreatedEventPromise,
             releaseRunSlotPromise,
-            loadPriorHistory: (currentThreadId, currentRunId) => this.loadPriorHistory(currentThreadId, currentRunId),
-            stream: (activeBinding, input, currentThreadId, priorHistory, streamOptions) => this.runtimeAdapter.stream(activeBinding, input, currentThreadId, priorHistory, streamOptions),
-            invokeWithHistory: (activeBinding, input, currentThreadId, currentRunId) => this.invokeWithHistory(activeBinding, input, currentThreadId, currentRunId),
-            emit: (currentThreadId, currentRunId, sequence, eventType, payload) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload),
-            setRunStateAndEmit: (currentThreadId, currentRunId, sequence, state, stateOptions) => this.setRunStateAndEmit(currentThreadId, currentRunId, sequence, state, stateOptions),
-            requestApprovalAndEmit: (currentThreadId, currentRunId, input, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(currentThreadId, currentRunId, input, interruptContent, checkpointRef, sequence),
-            appendAssistantMessage: (currentThreadId, currentRunId, content) => appendLifecycleAssistantMessage(this.persistence, currentThreadId, currentRunId, content),
-            clearRunRequest: (currentThreadId, currentRunId) => this.persistence.clearRunRequest(currentThreadId, currentRunId),
-            emitSyntheticFallback: (currentThreadId, currentRunId, currentSelectedAgentId, error) => emitSyntheticFallbackEvent({
-                ...this.backgroundEventRuntime,
-            }, currentThreadId, currentRunId, currentSelectedAgentId, error),
+            ...streamRuntime,
         });
     }
     async resume(options) {
-        return resumeRun({
-            getApprovalById: (approvalId) => this.persistence.getApproval(approvalId),
+        return resumeRun(createResumeRunRuntime({
+            persistence: this.persistence,
+            workspace: this.workspace,
+            runtimeAdapter: this.runtimeAdapter,
             getSession: (threadId) => this.getSession(threadId),
-            resolveApprovalRecord: (resumeOptions, thread) => resolveHarnessApprovalRecord(this.persistence, resumeOptions, thread),
-            getBinding: (agentId) => getWorkspaceBinding(this.workspace, agentId),
-            buildResumePayload: (binding, approval, resumeOptions) => buildHarnessResumePayload(binding, approval, resumeOptions),
             getRunCancellation: (runId) => this.getRunCancellation(runId),
             finalizeCancelledRun: (threadId, runId, previousState, reason) => this.finalizeCancelledRun(threadId, runId, previousState, reason),
-            setRunState: (threadId, runId, state, checkpointRef) => this.persistence.setRunState(threadId, runId, state, checkpointRef),
             acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
             resolvePersistedRunPriority: (threadId, runId) => this.resolvePersistedRunPriority(threadId, runId),
-            saveRecoveryIntent: (threadId, runId, payload) => this.persistence.saveRecoveryIntent(threadId, runId, payload),
             emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
-            resolveApproval: (threadId, runId, approvalId, resolution) => this.persistence.resolveApproval(threadId, runId, approvalId, resolution),
-            listThreadMessages: (threadId) => this.persistence.listThreadMessages(threadId),
             loadRunInput: (threadId, runId) => this.loadRunInput(threadId, runId),
-            invoke: (binding, input, threadId, runId, resumePayload, priorHistory) => this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, priorHistory),
             recordLlmSuccess: (startedAt) => this.recordLlmSuccess(startedAt),
             recordLlmFailure: (startedAt) => this.recordLlmFailure(startedAt),
-            clearRecoveryIntent: (threadId, runId) => this.persistence.clearRecoveryIntent(threadId, runId),
             finalizeContinuedRun: (binding, threadId, runId, input, actual, operationOptions) => this.finalizeContinuedRun(binding, threadId, runId, input, actual, operationOptions),
-        }, options);
+        }), options);
     }
     async restartConversation(options) {
         const thread = await this.getSession(options.threadId);
@@ -665,10 +557,15 @@ export class AgentHarnessRuntime {
         };
     }
     async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
         await this.healthMonitor?.stop();
         this.unregisterThreadMemorySync();
         await Promise.allSettled(Array.from(this.backgroundTasks));
         await this.threadMemorySync?.close();
+        this.initialized = false;
     }
     async stop() {
         await this.close();
@@ -683,10 +580,38 @@ export class AgentHarnessRuntime {
         }, options);
     }
     async recoverStartupRuns() {
-        return;
+        await recoverHarnessStartupRuns({
+            recoveryConfig: this.recoveryConfig,
+            persistence: this.persistence,
+            createStartupRecoveryContext: () => ({
+                persistence: this.persistence,
+                workspace: this.workspace,
+                runtimeAdapter: this.runtimeAdapter,
+                recoveryConfig: this.recoveryConfig,
+                concurrencyConfig: this.concurrencyConfig,
+                getBinding: (agentId) => getWorkspaceBinding(this.workspace, agentId),
+                acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
+                executeQueuedRun: (binding, input, threadId, runId, agentId, options) => this.executeQueuedRun(binding, input, threadId, runId, agentId, options),
+                setRunStateAndEmit: (threadId, runId, sequence, state, options) => this.setRunStateAndEmit(threadId, runId, sequence, state, options),
+                emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
+                loadRunInput: (threadId, runId) => this.loadRunInput(threadId, runId),
+                finalizeContinuedRun: (binding, threadId, runId, input, actual, options) => this.finalizeContinuedRun(binding, threadId, runId, input, actual, options),
+                supportsRunningReplay: (binding) => bindingSupportsRunningReplay(binding),
+                isStaleRunningRun: (thread, nowMs) => this.isStaleRunningRun(thread, nowMs),
+                recordLlmSuccess: (startedAt) => this.recordLlmSuccess(startedAt),
+                recordLlmFailure: (startedAt) => this.recordLlmFailure(startedAt),
+            }),
+            reclaimExpiredClaimedRuns: (nowIso) => this.reclaimExpiredClaimedRuns(nowIso),
+        });
     }
-    async reclaimExpiredClaimedRuns(_nowIso = new Date().toISOString()) {
-        return;
+    async reclaimExpiredClaimedRuns(nowIso = new Date().toISOString()) {
+        await reclaimHarnessExpiredClaimedRuns({
+            persistence: this.persistence,
+            setRunStateAndEmit: (threadId, runId, sequence, state, options) => this.setRunStateAndEmit(threadId, runId, sequence, state, options),
+            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
+            concurrencyConfig: this.concurrencyConfig,
+            getActiveRunSlots: () => this.activeRunSlots,
+        }, nowIso);
     }
     async isStaleRunningRun(thread, nowMs = Date.now()) {
         return isHarnessStaleRunningRun({

package/dist/runtime/support/runtime-adapter-options.d.ts

@@ -0,0 +1,17 @@
+import type { CompiledAgentBinding, RuntimeAdapterOptions, WorkspaceBundle } from "../../contracts/types.js";
+import type { StoreLike } from "../harness/system/store.js";
+export declare function createBindingStoreResolver(input: {
+    stores: Map<string, StoreLike>;
+    defaultStore: StoreLike;
+    getDefaultRunRoot: () => string;
+}): (binding?: CompiledAgentBinding) => StoreLike;
+export declare function resolveRuntimeAdapterOptions(input: {
+    workspace: WorkspaceBundle;
+    runtimeAdapterOptions: RuntimeAdapterOptions;
+    checkpointers: Map<string, unknown>;
+    stores: Map<string, StoreLike>;
+    defaultStore: StoreLike;
+    embeddingModels: Map<string, unknown>;
+    vectorStores: Map<string, unknown>;
+    getDefaultRunRoot: () => string;
+}): RuntimeAdapterOptions;

package/dist/runtime/support/runtime-adapter-options.js

@@ -0,0 +1,29 @@
+import { createResourceBackendResolver, createResourceToolResolver } from "../../resource/resource.js";
+import { resolveCheckpointer, resolveEmbeddingModel, resolveStore, resolveVectorStore, } from "../harness/run/resources.js";
+import { getBindingStoreConfig } from "./compiled-binding.js";
+export function createBindingStoreResolver(input) {
+    return (binding) => resolveStore(input.stores, input.defaultStore, input.getDefaultRunRoot(), (currentBinding) => currentBinding ? getBindingStoreConfig(currentBinding) : undefined, binding);
+}
+export function resolveRuntimeAdapterOptions(input) {
+    const { workspace, runtimeAdapterOptions, checkpointers, stores, defaultStore, embeddingModels, vectorStores, getDefaultRunRoot, } = input;
+    const storeResolver = runtimeAdapterOptions.storeResolver ??
+        createBindingStoreResolver({
+            stores,
+            defaultStore,
+            getDefaultRunRoot,
+        });
+    return {
+        ...runtimeAdapterOptions,
+        toolResolver: runtimeAdapterOptions.toolResolver ??
+            createResourceToolResolver(workspace, {
+                getStore: (binding) => binding ? storeResolver(binding) : defaultStore,
+                getEmbeddingModel: (embeddingModelRef) => resolveEmbeddingModel(workspace, embeddingModels, embeddingModelRef, runtimeAdapterOptions),
+                getVectorStore: (vectorStoreRef) => resolveVectorStore(workspace, vectorStores, vectorStoreRef, runtimeAdapterOptions),
+            }),
+        checkpointerResolver: runtimeAdapterOptions.checkpointerResolver ??
+            ((binding) => resolveCheckpointer(checkpointers, binding)),
+        storeResolver,
+        backendResolver: runtimeAdapterOptions.backendResolver ??
+            ((binding) => createResourceBackendResolver(workspace)(binding)),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.108",
+  "version": "0.0.109",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",