@botbotgo/agent-harness 0.0.41 → 0.0.43

package/dist/runtime/harness.js

@@ -5,7 +5,7 @@ import { AGENT_INTERRUPT_SENTINEL_PREFIX, AgentRuntimeAdapter, RuntimeOperationT
 import { createResourceBackendResolver, createResourceToolResolver } from "../resource/resource.js";
 import { EventBus } from "./event-bus.js";
 import { PolicyEngine } from "./policy-engine.js";
-import { getRecoveryConfig, getRoutingDefaultAgentId, getRoutingRules, getRoutingSystemPrompt, isModelRoutingEnabled, matchRoutingRule, } from "../workspace/support/workspace-ref-utils.js";
+import { getConcurrencyConfig, getRecoveryConfig, getRoutingDefaultAgentId, getRoutingRules, getRoutingSystemPrompt, isModelRoutingEnabled, matchRoutingRule, } from "../workspace/support/workspace-ref-utils.js";
 import { createHarnessEvent, createPendingApproval, heuristicRoute, inferRoutingBindings, renderRuntimeFailure, renderToolFailure, } from "./support/harness-support.js";
 import { createCheckpointerForConfig, createStoreForConfig } from "./support/runtime-factories.js";
 import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "./support/embedding-models.js";
@@ -15,6 +15,7 @@ import { FileBackedStore } from "./store.js";
 import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
+import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig } from "./support/compiled-binding.js";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -36,6 +37,22 @@ export class AgentHarnessRuntime {
     resolvedRuntimeAdapterOptions;
     checkpointMaintenance;
     recoveryConfig;
+    concurrencyConfig;
+    activeRunSlots = 0;
+    pendingRunSlots = [];
+    toPublicApprovalRecord(approval) {
+        const { toolCallId: _toolCallId, checkpointRef: _checkpointRef, eventRefs: _eventRefs, ...publicApproval } = approval;
+        return publicApproval;
+    }
+    normalizeInvocationEnvelope(options) {
+        const invocation = options.invocation;
+        return {
+            context: invocation?.context ?? options.context,
+            state: invocation?.inputs ?? options.state,
+            files: invocation?.attachments ?? options.files,
+            invocation,
+        };
+    }
     listHostBindings() {
         return inferRoutingBindings(this.workspace).hostBindings;
     }
@@ -76,7 +93,7 @@ export class AgentHarnessRuntime {
         return requestedAgentId;
     }
     resolveStore(binding) {
-        const storeConfig = binding?.deepAgentParams?.store ?? binding?.harnessRuntime.store;
+        const storeConfig = binding ? getBindingStoreConfig(binding) : undefined;
         const cacheKey = storeConfig ? JSON.stringify(storeConfig) : undefined;
         if (!storeConfig) {
             return this.defaultStore;
@@ -138,6 +155,10 @@ export class AgentHarnessRuntime {
                         return existing;
                     }
                     const resolvedConfig = binding.harnessRuntime.checkpointer ?? { kind: "FileCheckpointer", path: "checkpoints.json" };
+                    if (typeof resolvedConfig === "boolean") {
+                        this.checkpointers.set(key, resolvedConfig);
+                        return resolvedConfig;
+                    }
                     const saver = createCheckpointerForConfig(resolvedConfig, binding.harnessRuntime.runRoot);
                     this.checkpointers.set(key, saver);
                     return saver;
@@ -159,6 +180,7 @@ export class AgentHarnessRuntime {
             ? new CheckpointMaintenanceLoop(discoverCheckpointMaintenanceTargets(workspace), checkpointMaintenanceConfig)
             : null;
         this.recoveryConfig = getRecoveryConfig(workspace.refs);
+        this.concurrencyConfig = getConcurrencyConfig(workspace.refs);
     }
     async initialize() {
         await this.persistence.initialize();
@@ -176,7 +198,7 @@ export class AgentHarnessRuntime {
         if (!binding) {
             throw new Error(`Unknown agent ${agentId}`);
         }
-        return binding.langchainAgentParams?.tools ?? binding.deepAgentParams?.tools ?? [];
+        return getBindingPrimaryTools(binding);
     }
     resolveAgentTools(agentId) {
         const binding = this.getBinding(agentId);
@@ -251,10 +273,11 @@ export class AgentHarnessRuntime {
                 return false;
             }
             return true;
-        });
+        }).map((approval) => this.toPublicApprovalRecord(approval));
     }
     async getApproval(approvalId) {
-        return this.persistence.getApproval(approvalId);
+        const approval = await this.persistence.getApproval(approvalId);
+        return approval ? this.toPublicApprovalRecord(approval) : null;
     }
     async createToolMcpServer(options) {
         const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
@@ -332,7 +355,8 @@ export class AgentHarnessRuntime {
             threadId,
             runId,
             agentId: binding.agent.id,
-            executionMode: binding.agent.executionMode,
+            executionMode: getBindingAdapterKind(binding),
+            adapterKind: getBindingAdapterKind(binding),
             createdAt,
         });
         return { threadId, runId, createdAt };
@@ -468,8 +492,31 @@ export class AgentHarnessRuntime {
         }
         await listener(value);
     }
+    async acquireRunSlot() {
+        const maxConcurrentRuns = this.concurrencyConfig.maxConcurrentRuns;
+        if (!maxConcurrentRuns) {
+            return () => undefined;
+        }
+        if (this.activeRunSlots >= maxConcurrentRuns) {
+            await new Promise((resolve) => {
+                this.pendingRunSlots.push(resolve);
+            });
+        }
+        this.activeRunSlots += 1;
+        let released = false;
+        return () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            this.activeRunSlots = Math.max(0, this.activeRunSlots - 1);
+            const next = this.pendingRunSlots.shift();
+            next?.();
+        };
+    }
     async dispatchRunListeners(stream, listeners) {
         let latestEvent;
+        let latestResult;
         let output = "";
         for await (const item of stream) {
             if (item.type === "event") {
@@ -477,6 +524,10 @@ export class AgentHarnessRuntime {
                 await this.notifyListener(listeners.onEvent, item.event);
                 continue;
             }
+            if (item.type === "result") {
+                latestResult = item.result;
+                continue;
+            }
             if (item.type === "content") {
                 output += item.content;
                 await this.notifyListener(listeners.onChunk, item.content);
@@ -501,6 +552,13 @@ export class AgentHarnessRuntime {
         if (!latestEvent) {
             throw new Error("run did not emit any events");
         }
+        if (latestResult) {
+            return {
+                ...latestResult,
+                output: latestResult.output || output,
+                finalMessageText: latestResult.finalMessageText ?? latestResult.output ?? output,
+            };
+        }
         const thread = await this.getThread(latestEvent.threadId);
         if (!thread) {
             throw new Error(`Unknown thread ${latestEvent.threadId}`);
@@ -529,285 +587,361 @@ export class AgentHarnessRuntime {
         if (options.listeners) {
             return this.dispatchRunListeners(this.streamEvents(options), options.listeners);
         }
-        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, runId } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, options.threadId);
-        await this.emitRunCreated(threadId, runId, {
-            agentId: binding.agent.id,
-            requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
-            selectedAgentId,
-            executionMode: binding.agent.executionMode,
-        });
+        const releaseRunSlot = await this.acquireRunSlot();
         try {
-            const actual = await this.invokeWithHistory(binding, options.input, threadId, runId, undefined, {
-                context: options.context,
-                state: options.state,
-                files: options.files,
-            });
-            const finalized = await this.finalizeContinuedRun(threadId, runId, options.input, actual, {
-                previousState: null,
-                stateSequence: 3,
-                approvalSequence: 4,
+            const invocation = this.normalizeInvocationEnvelope(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, runId } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, options.threadId);
+            await this.emitRunCreated(threadId, runId, {
+                agentId: binding.agent.id,
+                requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
+                selectedAgentId,
+                executionMode: getBindingAdapterKind(binding),
             });
-            return {
-                ...finalized,
-                agentId: selectedAgentId,
-            };
+            try {
+                const actual = await this.invokeWithHistory(binding, options.input, threadId, runId, undefined, {
+                    context: invocation.context,
+                    state: invocation.state,
+                    files: invocation.files,
+                });
+                const finalized = await this.finalizeContinuedRun(threadId, runId, options.input, actual, {
+                    previousState: null,
+                    stateSequence: 3,
+                    approvalSequence: 4,
+                });
+                return {
+                    ...finalized,
+                    agentId: selectedAgentId,
+                };
+            }
+            catch (error) {
+                await this.emitSyntheticFallback(threadId, runId, selectedAgentId, error);
+                await this.setRunStateAndEmit(threadId, runId, 4, "failed", {
+                    previousState: null,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return {
+                    threadId,
+                    runId,
+                    agentId: selectedAgentId,
+                    state: "failed",
+                    output: renderRuntimeFailure(error),
+                };
+            }
         }
-        catch (error) {
-            await this.emitSyntheticFallback(threadId, runId, selectedAgentId, error);
-            await this.setRunStateAndEmit(threadId, runId, 4, "failed", {
-                previousState: null,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                threadId,
-                runId,
-                agentId: selectedAgentId,
-                state: "failed",
-                output: renderRuntimeFailure(error),
-            };
+        finally {
+            releaseRunSlot();
         }
     }
     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")) {
+        const releaseRunSlot = await this.acquireRunSlot();
+        try {
+            const invocation = this.normalizeInvocationEnvelope(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, runId } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, options.threadId);
+            yield { type: "event", event: await this.emitRunCreated(threadId, runId, {
+                    agentId: selectedAgentId,
+                    requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
+                    selectedAgentId,
+                    input: options.input,
+                    state: "running",
+                }) };
+            try {
+                const priorHistory = await this.loadPriorHistory(threadId, runId);
+                let assistantOutput = "";
+                const toolErrors = [];
+                for await (const chunk of this.runtimeAdapter.stream(binding, options.input, threadId, priorHistory, {
+                    context: invocation.context,
+                    state: invocation.state,
+                    files: invocation.files,
+                })) {
+                    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`;
+                            const waitingEvent = await this.setRunStateAndEmit(threadId, runId, 4, "waiting_for_approval", {
+                                previousState: null,
+                                checkpointRef,
+                            });
+                            const approvalRequest = await this.requestApprovalAndEmit(threadId, runId, options.input, normalizedChunk.content, checkpointRef, 5);
+                            yield {
+                                type: "event",
+                                event: waitingEvent,
+                            };
+                            yield {
+                                type: "event",
+                                event: approvalRequest.event,
+                            };
+                            yield {
+                                type: "result",
+                                result: {
+                                    threadId,
+                                    runId,
+                                    agentId: selectedAgentId,
+                                    state: "waiting_for_approval",
+                                    output: assistantOutput,
+                                    finalMessageText: assistantOutput,
+                                    interruptContent: normalizedChunk.content,
+                                    approvalId: approvalRequest.approval.approvalId,
+                                    pendingActionId: approvalRequest.approval.pendingActionId,
+                                },
+                            };
+                            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") {
+                            if (normalizedChunk.isError) {
+                                toolErrors.push(renderToolFailure(normalizedChunk.toolName, normalizedChunk.output));
+                            }
+                            yield {
+                                type: "tool-result",
+                                threadId,
+                                runId,
+                                agentId: selectedAgentId,
+                                toolName: normalizedChunk.toolName,
+                                output: normalizedChunk.output,
+                                isError: normalizedChunk.isError,
+                            };
+                            continue;
+                        }
+                        emitted = true;
+                        assistantOutput += normalizedChunk.content;
+                        yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, normalizedChunk.content);
+                    }
+                }
+                if (!assistantOutput && toolErrors.length > 0) {
+                    assistantOutput = toolErrors.join("\n\n");
+                    emitted = true;
+                    yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, assistantOutput);
+                }
+                if (!assistantOutput) {
+                    const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
+                    if (actual.output) {
+                        assistantOutput = actual.output;
+                        emitted = true;
+                        yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, actual.output);
+                    }
+                }
+                await this.appendAssistantMessage(threadId, runId, assistantOutput);
                 yield {
-                    type: "content",
-                    threadId: result.threadId,
-                    runId: result.runId,
-                    agentId: result.agentId ?? selectedAgentId,
-                    content: `${line}\n`,
+                    type: "result",
+                    result: {
+                        threadId,
+                        runId,
+                        agentId: selectedAgentId,
+                        state: "completed",
+                        output: assistantOutput,
+                        finalMessageText: assistantOutput,
+                    },
                 };
+                yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "completed", {
+                        previousState: null,
+                    }) };
+                return;
             }
-            return;
-        }
-        let emitted = false;
-        const { threadId, runId } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, options.threadId);
-        yield { type: "event", event: await this.emitRunCreated(threadId, runId, {
-                agentId: selectedAgentId,
-                requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
-                selectedAgentId,
-                input: options.input,
-                state: "running",
-            }) };
-        try {
-            const priorHistory = await this.loadPriorHistory(threadId, runId);
-            let assistantOutput = "";
-            const toolErrors = [];
-            for await (const chunk of this.runtimeAdapter.stream(binding, options.input, threadId, priorHistory, {
-                context: options.context,
-                state: options.state,
-                files: options.files,
-            })) {
-                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`;
-                        const waitingEvent = await this.setRunStateAndEmit(threadId, runId, 4, "waiting_for_approval", {
+            catch (error) {
+                if (emitted) {
+                    yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "failed", {
                             previousState: null,
-                            checkpointRef,
-                        });
-                        const approvalRequest = await this.requestApprovalAndEmit(threadId, runId, options.input, normalizedChunk.content, checkpointRef, 5);
-                        yield {
-                            type: "event",
-                            event: waitingEvent,
-                        };
-                        yield {
-                            type: "event",
-                            event: approvalRequest.event,
-                        };
-                        return;
-                    }
-                    if (normalizedChunk.kind === "reasoning") {
-                        await this.emit(threadId, runId, 3, "reasoning.delta", {
-                            content: normalizedChunk.content,
-                        });
-                        yield {
-                            type: "reasoning",
+                            error: error instanceof Error ? error.message : String(error),
+                        }) };
+                    return;
+                }
+                if (error instanceof RuntimeOperationTimeoutError && error.stage === "invoke") {
+                    yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "failed", {
+                            previousState: null,
+                            error: error.message,
+                        }) };
+                    yield {
+                        type: "content",
+                        threadId,
+                        runId,
+                        agentId: selectedAgentId,
+                        content: renderRuntimeFailure(error),
+                    };
+                    yield {
+                        type: "result",
+                        result: {
                             threadId,
                             runId,
                             agentId: selectedAgentId,
-                            content: normalizedChunk.content,
-                        };
-                        continue;
+                            state: "failed",
+                            output: renderRuntimeFailure(error),
+                            finalMessageText: renderRuntimeFailure(error),
+                        },
+                    };
+                    return;
+                }
+                try {
+                    const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
+                    await this.appendAssistantMessage(threadId, runId, actual.output);
+                    if (actual.output) {
+                        yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, actual.output);
                     }
-                    if (normalizedChunk.kind === "step") {
-                        yield {
-                            type: "step",
+                    yield {
+                        type: "result",
+                        result: {
+                            ...actual,
                             threadId,
                             runId,
                             agentId: selectedAgentId,
-                            content: normalizedChunk.content,
-                        };
-                        continue;
-                    }
-                    if (normalizedChunk.kind === "tool-result") {
-                        if (normalizedChunk.isError) {
-                            toolErrors.push(renderToolFailure(normalizedChunk.toolName, normalizedChunk.output));
-                        }
-                        yield {
-                            type: "tool-result",
+                        },
+                    };
+                    yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, actual.state, {
+                            previousState: null,
+                        }) };
+                    return;
+                }
+                catch (invokeError) {
+                    await this.emitSyntheticFallback(threadId, runId, selectedAgentId, invokeError);
+                    yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "failed", {
+                            previousState: null,
+                            error: invokeError instanceof Error ? invokeError.message : String(invokeError),
+                        }) };
+                    yield {
+                        type: "content",
+                        threadId,
+                        runId,
+                        agentId: selectedAgentId,
+                        content: renderRuntimeFailure(invokeError),
+                    };
+                    yield {
+                        type: "result",
+                        result: {
                             threadId,
                             runId,
                             agentId: selectedAgentId,
-                            toolName: normalizedChunk.toolName,
-                            output: normalizedChunk.output,
-                            isError: normalizedChunk.isError,
-                        };
-                        continue;
-                    }
-                    emitted = true;
-                    assistantOutput += normalizedChunk.content;
-                    yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, normalizedChunk.content);
-                }
-            }
-            if (!assistantOutput && toolErrors.length > 0) {
-                assistantOutput = toolErrors.join("\n\n");
-                emitted = true;
-                yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, assistantOutput);
-            }
-            if (!assistantOutput) {
-                const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
-                if (actual.output) {
-                    assistantOutput = actual.output;
-                    emitted = true;
-                    yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, actual.output);
+                            state: "failed",
+                            output: renderRuntimeFailure(invokeError),
+                            finalMessageText: renderRuntimeFailure(invokeError),
+                        },
+                    };
+                    return;
                 }
             }
-            await this.appendAssistantMessage(threadId, runId, assistantOutput);
-            yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "completed", {
-                    previousState: null,
-                }) };
-            return;
         }
-        catch (error) {
-            if (emitted) {
-                yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "failed", {
-                        previousState: null,
-                        error: error instanceof Error ? error.message : String(error),
-                    }) };
-                return;
-            }
-            if (error instanceof RuntimeOperationTimeoutError && error.stage === "invoke") {
-                yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "failed", {
-                        previousState: null,
-                        error: error.message,
-                    }) };
-                yield {
-                    type: "content",
-                    threadId,
-                    runId,
-                    agentId: selectedAgentId,
-                    content: renderRuntimeFailure(error),
-                };
-                return;
-            }
-            try {
-                const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
-                await this.appendAssistantMessage(threadId, runId, actual.output);
-                if (actual.output) {
-                    yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, actual.output);
-                }
-                yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, actual.state, {
-                        previousState: null,
-                    }) };
-                return;
-            }
-            catch (invokeError) {
-                await this.emitSyntheticFallback(threadId, runId, selectedAgentId, invokeError);
-                yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "failed", {
-                        previousState: null,
-                        error: invokeError instanceof Error ? invokeError.message : String(invokeError),
-                    }) };
-                yield {
-                    type: "content",
-                    threadId,
-                    runId,
-                    agentId: selectedAgentId,
-                    content: renderRuntimeFailure(invokeError),
-                };
-                return;
-            }
+        finally {
+            releaseRunSlot();
         }
     }
     async resume(options) {
-        const approvalById = options.approvalId ? await this.persistence.getApproval(options.approvalId) : null;
-        const thread = options.threadId
-            ? await this.getSession(options.threadId)
-            : approvalById
-                ? await this.getSession(approvalById.threadId)
-                : null;
-        if (!thread) {
-            throw new Error("resume requires either threadId or approvalId");
-        }
-        const approval = approvalById ?? await this.resolveApprovalRecord(options, thread);
-        const threadId = approval.threadId;
-        const runId = approval.runId;
-        const binding = this.workspace.bindings.get(thread.agentId);
-        if (!binding) {
-            throw new Error(`Unknown agent ${thread.agentId}`);
-        }
-        await this.persistence.setRunState(threadId, runId, "resuming", `checkpoints/${threadId}/${runId}/cp-1`);
-        await this.persistence.saveRecoveryIntent(threadId, runId, {
-            kind: "approval-decision",
-            savedAt: new Date().toISOString(),
-            checkpointRef: `checkpoints/${threadId}/${runId}/cp-1`,
-            resumePayload: options.decision === "edit" && options.editedInput
-                ? { decision: "edit", editedInput: options.editedInput }
-                : (options.decision ?? "approve"),
-            attempts: 0,
-        });
-        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 runInput = await this.loadRunInput(threadId, runId);
-        const resumeDecision = options.decision === "edit" && options.editedInput
-            ? { decision: "edit", editedInput: options.editedInput }
-            : (options.decision ?? "approve");
+        const releaseRunSlot = await this.acquireRunSlot();
         try {
-            const actual = await this.runtimeAdapter.invoke(binding, "", threadId, runId, resumeDecision, priorHistory);
-            await this.persistence.clearRecoveryIntent(threadId, runId);
-            const finalized = await this.finalizeContinuedRun(threadId, runId, runInput, actual, {
-                previousState: "resuming",
-                stateSequence: 7,
-                approvalSequence: 8,
+            const approvalById = options.approvalId ? await this.persistence.getApproval(options.approvalId) : null;
+            const thread = options.threadId
+                ? await this.getSession(options.threadId)
+                : approvalById
+                    ? await this.getSession(approvalById.threadId)
+                    : null;
+            if (!thread) {
+                throw new Error("resume requires either threadId or approvalId");
+            }
+            const approval = approvalById ?? await this.resolveApprovalRecord(options, thread);
+            const threadId = approval.threadId;
+            const runId = approval.runId;
+            const binding = this.workspace.bindings.get(thread.agentId);
+            if (!binding) {
+                throw new Error(`Unknown agent ${thread.agentId}`);
+            }
+            await this.persistence.setRunState(threadId, runId, "resuming", `checkpoints/${threadId}/${runId}/cp-1`);
+            await this.persistence.saveRecoveryIntent(threadId, runId, {
+                kind: "approval-decision",
+                savedAt: new Date().toISOString(),
+                checkpointRef: `checkpoints/${threadId}/${runId}/cp-1`,
+                resumePayload: options.decision === "edit" && options.editedInput
+                    ? { decision: "edit", editedInput: options.editedInput }
+                    : (options.decision ?? "approve"),
+                attempts: 0,
             });
-            return {
-                ...finalized,
-                approvalId: finalized.approvalId ?? approval.approvalId,
-                pendingActionId: finalized.pendingActionId ?? approval.pendingActionId,
-            };
+            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 runInput = await this.loadRunInput(threadId, runId);
+            const resumeDecision = options.decision === "edit" && options.editedInput
+                ? { decision: "edit", editedInput: options.editedInput }
+                : (options.decision ?? "approve");
+            try {
+                const actual = await this.runtimeAdapter.invoke(binding, "", threadId, runId, resumeDecision, priorHistory);
+                await this.persistence.clearRecoveryIntent(threadId, runId);
+                const finalized = await this.finalizeContinuedRun(threadId, runId, runInput, actual, {
+                    previousState: "resuming",
+                    stateSequence: 7,
+                    approvalSequence: 8,
+                });
+                return {
+                    ...finalized,
+                    approvalId: finalized.approvalId ?? approval.approvalId,
+                    pendingActionId: finalized.pendingActionId ?? approval.pendingActionId,
+                };
+            }
+            catch (error) {
+                throw error;
+            }
         }
-        catch (error) {
-            throw error;
+        finally {
+            releaseRunSlot();
         }
     }
     async restartConversation(options) {