@botbotgo/agent-harness 0.0.108 → 0.0.110

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.107";
+export declare const AGENT_HARNESS_VERSION = "0.0.109";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.107";
+export const AGENT_HARNESS_VERSION = "0.0.109";

package/dist/runtime/adapter/execution-context.d.ts

@@ -1,6 +1,13 @@
 import type { CompiledAgentBinding, CompiledTool } from "../../contracts/types.js";
 import type { ToolNameMapping } from "./tool/tool-name-mapping.js";
 import { getBindingPrimaryModel } from "../support/compiled-binding.js";
+export declare function buildBindingToolCatalog(input: {
+    binding: CompiledAgentBinding;
+    getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;
+}): {
+    primaryTools: CompiledTool[];
+    toolNameMapping: ToolNameMapping;
+};
 export declare function buildBindingToolExecutionContext(input: {
     binding: CompiledAgentBinding;
     resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];

package/dist/runtime/adapter/execution-context.js

@@ -1,9 +1,16 @@
 import { buildExecutableToolMap } from "./tool-resolution.js";
 import { getBindingLangChainParams, getBindingPrimaryModel, getBindingPrimaryTools, isLangChainBinding } from "../support/compiled-binding.js";
-export function buildBindingToolExecutionContext(input) {
+export function buildBindingToolCatalog(input) {
     const primaryTools = getBindingPrimaryTools(input.binding);
-    const resolvedTools = input.resolveTools(primaryTools, input.binding);
     const toolNameMapping = input.getToolNameMapping(input.binding);
+    return {
+        primaryTools,
+        toolNameMapping,
+    };
+}
+export function buildBindingToolExecutionContext(input) {
+    const { primaryTools, toolNameMapping } = buildBindingToolCatalog(input);
+    const resolvedTools = input.resolveTools(primaryTools, input.binding);
     const executableTools = buildExecutableToolMap({
         primaryTools,
         resolvedTools,

package/dist/runtime/adapter/middleware-assembly.js

@@ -4,7 +4,7 @@ import { createAgent, humanInTheLoopMiddleware } from "langchain";
 import { createBuiltinMiddlewareTools } from "./tool/builtin-middleware-tools.js";
 import { compileInterruptOn } from "./tool/interrupt-policy.js";
 import { extractToolFallbackContext, extractVisibleOutput } from "../parsing/output-parsing.js";
-import { hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, isRecord } from "./runtime-adapter-support.js";
+import { hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isRecord } from "./runtime-adapter-support.js";
 import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryModel, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
@@ -76,7 +76,7 @@ export async function invokeBuiltinTaskTool(input) {
     if (!params) {
         throw new Error(`Agent ${input.binding.agent.id} has no deepagent params`);
     }
-    const typedInput = isObject(input.toolInput) ? input.toolInput : {};
+    const typedInput = isRecord(input.toolInput) ? input.toolInput : {};
     const description = typeof typedInput.description === "string" ? typedInput.description : "";
     const subagentType = typeof typedInput.subagent_type === "string" ? typedInput.subagent_type : "";
     const builtinBackend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);

package/dist/runtime/adapter/runnable-config.d.ts

@@ -5,9 +5,53 @@ export type ResolvedRunnableDependencies = {
     resolvedCheckpointer: unknown;
     resolvedStore: unknown;
 };
+type LangChainRunnableConfigParams = {
+    langchainParams: {
+        passthrough?: Record<string, unknown>;
+        systemPrompt?: string;
+        stateSchema?: unknown;
+        responseFormat?: unknown;
+        contextSchema?: unknown;
+        includeAgentName?: unknown;
+        version?: unknown;
+        name?: unknown;
+        description?: unknown;
+    };
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    passthroughOverride?: Record<string, unknown>;
+    systemPromptOverride?: string;
+};
+type DeepAgentRunnableConfigParams = {
+    compatibleParams: {
+        passthrough?: Record<string, unknown>;
+        systemPrompt?: string;
+        responseFormat?: unknown;
+        contextSchema?: unknown;
+        name?: unknown;
+        memory?: unknown;
+        generalPurposeAgent?: unknown;
+        taskDescription?: unknown;
+    };
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedSubagents: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    resolvedBackend: unknown;
+    resolvedInterruptOn: unknown;
+    resolvedSkills: string[];
+};
 export declare function buildResolvedRunnableConfig(params: {
     passthrough?: Record<string, unknown>;
     staticConfig?: Record<string, unknown>;
     resolved: ResolvedRunnableDependencies;
     extraConfig?: Record<string, unknown>;
 }): Record<string, unknown>;
+export declare function buildLangChainRunnableConfig(params: LangChainRunnableConfigParams): Record<string, unknown>;
+export declare function buildDeepAgentRunnableConfig(params: DeepAgentRunnableConfigParams): Record<string, unknown>;
+export {};

package/dist/runtime/adapter/runnable-config.js

@@ -11,3 +11,54 @@ export function buildResolvedRunnableConfig(params) {
         ...(extraConfig ?? {}),
     };
 }
+export function buildLangChainRunnableConfig(params) {
+    const { langchainParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedCheckpointer, resolvedStore, passthroughOverride, systemPromptOverride, } = params;
+    return buildResolvedRunnableConfig({
+        passthrough: passthroughOverride ?? langchainParams.passthrough ?? {},
+        staticConfig: {
+            systemPrompt: systemPromptOverride ?? langchainParams.systemPrompt,
+            stateSchema: langchainParams.stateSchema,
+            responseFormat: langchainParams.responseFormat,
+            contextSchema: langchainParams.contextSchema,
+            includeAgentName: langchainParams.includeAgentName,
+            version: langchainParams.version,
+            name: langchainParams.name,
+            description: langchainParams.description,
+        },
+        resolved: {
+            resolvedModel,
+            resolvedTools,
+            resolvedMiddleware,
+            resolvedCheckpointer,
+            resolvedStore,
+        },
+    });
+}
+export function buildDeepAgentRunnableConfig(params) {
+    const { compatibleParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedSubagents, resolvedCheckpointer, resolvedStore, resolvedBackend, resolvedInterruptOn, resolvedSkills, } = params;
+    return buildResolvedRunnableConfig({
+        passthrough: compatibleParams.passthrough ?? {},
+        staticConfig: {
+            systemPrompt: compatibleParams.systemPrompt,
+            responseFormat: compatibleParams.responseFormat,
+            contextSchema: compatibleParams.contextSchema,
+            name: compatibleParams.name,
+            memory: compatibleParams.memory,
+            skills: resolvedSkills,
+            generalPurposeAgent: compatibleParams.generalPurposeAgent,
+            taskDescription: compatibleParams.taskDescription,
+        },
+        resolved: {
+            resolvedModel,
+            resolvedTools,
+            resolvedMiddleware,
+            resolvedCheckpointer,
+            resolvedStore,
+        },
+        extraConfig: {
+            subagents: resolvedSubagents,
+            backend: resolvedBackend,
+            interruptOn: resolvedInterruptOn,
+        },
+    });
+}

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

@@ -1,6 +1,5 @@
 import type { CompiledAgentBinding } from "../../contracts/types.js";
 export declare function countConfiguredTools(binding: CompiledAgentBinding): number;
-export declare function asObject(value: unknown): Record<string, unknown> | undefined;
 export declare function sleep(ms: number): Promise<void>;
 export declare function hasConfiguredSubagentSupport(binding: CompiledAgentBinding): boolean;
 export declare function hasConfiguredMiddlewareKind(binding: CompiledAgentBinding, kind: string): boolean;

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

@@ -2,9 +2,6 @@ import { getBindingExecutionView } from "../support/compiled-binding.js";
 export function countConfiguredTools(binding) {
     return getBindingExecutionView(binding).primaryTools.length;
 }
-export function asObject(value) {
-    return typeof value === "object" && value ? value : undefined;
-}
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -34,7 +31,7 @@ export function truncateLines(lines, maxChars = 12_000) {
 export function summarizeBuiltinWriteTodosArgs(args) {
     const todos = Array.isArray(args.todos) ? args.todos : [];
     const items = todos.flatMap((todo) => {
-        if (!isObject(todo)) {
+        if (!isRecord(todo)) {
             return [];
         }
         const content = typeof todo.content === "string" && todo.content.trim().length > 0

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -30,6 +30,7 @@ export declare class AgentRuntimeAdapter {
     private resolveFilesystemBackend;
     private resolveBuiltinMiddlewareBackend;
     private createDeclaredMiddlewareResolverOptions;
+    private createAssemblyResolvers;
     private invokeBuiltinTaskTool;
     private resolveBuiltinMiddlewareTools;
     private resolveAutomaticSummarizationMiddleware;

package/dist/runtime/agent-runtime-adapter.js

@@ -8,8 +8,7 @@ import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { finalizeInvocationResult } from "./adapter/invocation-result.js";
 import { invokeRuntimeWithLocalTools } from "./adapter/invoke-runtime.js";
 import { streamRuntimeExecution } from "./adapter/stream-runtime.js";
-import { buildDeepAgentRunnableConfig } from "./adapter/deepagent-runnable-config.js";
-import { buildLangChainRunnableConfig } from "./adapter/langchain-runnable-config.js";
+import { buildDeepAgentRunnableConfig, buildLangChainRunnableConfig } from "./adapter/runnable-config.js";
 import { applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
 import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, resolveAutomaticSummarizationMiddleware as resolveAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainAutomaticMiddleware as resolveLangChainAutomaticMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
 import { computeRemainingTimeoutMs, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
@@ -18,7 +17,7 @@ import { buildInvocationRequest, } from "./adapter/model/invocation-request.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
 import { countConfiguredTools, } from "./adapter/runtime-adapter-support.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
-import { buildBindingToolExecutionContext, resolveLangChainStreamContext } from "./adapter/execution-context.js";
+import { buildBindingToolCatalog, buildBindingToolExecutionContext, resolveLangChainStreamContext, } from "./adapter/execution-context.js";
 export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
@@ -150,57 +149,76 @@ export class AgentRuntimeAdapter {
             binding,
         };
     }
+    createAssemblyResolvers(binding, options = {}) {
+        return {
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
+            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions = {}) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
+            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
+            invokeBuiltinTaskTool: (currentBinding, toolInput, currentOptions = {}) => this.invokeBuiltinTaskTool(currentBinding, toolInput, currentOptions),
+            binding,
+            options,
+        };
+    }
     async invokeBuiltinTaskTool(binding, input, options = {}) {
+        const assembly = this.createAssemblyResolvers(binding, options);
         return invokeBuiltinTaskToolHelper({
             binding,
             toolInput: input,
             options,
-            resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
-            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
-            resolveModel: (model) => this.resolveModel(model),
-            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            resolveBuiltinMiddlewareBackend: assembly.resolveBuiltinMiddlewareBackend,
+            resolveSubagents: assembly.resolveSubagents,
+            resolveModel: assembly.resolveModel,
+            resolveTools: assembly.resolveTools,
         });
     }
     async resolveBuiltinMiddlewareTools(binding, options = {}) {
+        const assembly = this.createAssemblyResolvers(binding, options);
         return resolveBuiltinMiddlewareToolsHelper({
             binding,
             options,
-            resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
-            invokeBuiltinTaskTool: (currentBinding, toolInput, currentOptions) => this.invokeBuiltinTaskTool(currentBinding, toolInput, currentOptions),
+            resolveBuiltinMiddlewareBackend: assembly.resolveBuiltinMiddlewareBackend,
+            invokeBuiltinTaskTool: assembly.invokeBuiltinTaskTool,
         });
     }
     async resolveAutomaticSummarizationMiddleware(binding) {
+        const assembly = this.createAssemblyResolvers(binding);
         return resolveAutomaticSummarizationMiddlewareHelper({
             binding,
-            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
         });
     }
     async resolveLangChainAutomaticMiddleware(binding) {
+        const assembly = this.createAssemblyResolvers(binding);
         return resolveLangChainAutomaticMiddlewareHelper({
             binding,
             resolveAutomaticSummarizationMiddleware: (currentBinding) => this.resolveAutomaticSummarizationMiddleware(currentBinding),
-            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
-            resolveModel: (model) => this.resolveModel(model),
-            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
-            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
+            resolveFilesystemBackend: assembly.resolveFilesystemBackend,
+            resolveModel: assembly.resolveModel,
+            resolveTools: assembly.resolveTools,
+            resolveSubagents: assembly.resolveSubagents,
         });
     }
     async resolveMiddleware(binding, interruptOn) {
+        const assembly = this.createAssemblyResolvers(binding);
         return resolveMiddlewareHelper({
             binding,
             interruptOn,
             runtimeAdapterOptions: this.options,
-            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
             resolveLangChainAutomaticMiddleware: (currentBinding) => this.resolveLangChainAutomaticMiddleware(currentBinding),
         });
     }
     async resolveSubagents(subagents, binding) {
+        const assembly = this.createAssemblyResolvers(binding);
         return resolveSubagentsHelper({
             subagents,
             binding,
-            resolveModel: (model) => this.resolveModel(model),
-            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
-            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            resolveModel: assembly.resolveModel,
+            resolveTools: assembly.resolveTools,
+            createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
         });
     }
     async createLangChainRunnable(binding, options = {}) {
@@ -324,9 +342,8 @@ export class AgentRuntimeAdapter {
         const invokeTimeoutMs = resolveBindingTimeout(binding);
         const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
         const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
-        const { primaryTools, toolNameMapping } = buildBindingToolExecutionContext({
+        const { primaryTools, toolNameMapping } = buildBindingToolCatalog({
             binding,
-            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
             getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
         });
         const { forceInvokeFallback, canUseDirectModelStream, langChainStreamModel, } = await resolveLangChainStreamContext({

package/dist/runtime/harness/events/listener-runtime.d.ts

@@ -0,0 +1,18 @@
+import type { HarnessStreamItem, RunListeners, RunResult } from "../../../contracts/types.js";
+export declare function createListenerDispatchRuntime(input: {
+    notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
+    getThread: (threadId: string) => Promise<{
+        currentState: RunResult["state"];
+        latestRunId: string;
+        entryAgentId: string;
+        runs: Array<{
+            agentId: string;
+        }>;
+        pendingDecision?: {
+            approvalId?: string;
+            pendingActionId?: string;
+        };
+    } | null>;
+}): {
+    dispatchRunListeners: (stream: AsyncGenerator<HarnessStreamItem>, listeners: RunListeners) => Promise<RunResult>;
+};

package/dist/runtime/harness/events/listener-runtime.js

@@ -0,0 +1,9 @@
+import { dispatchRunListeners as dispatchStreamingRunListeners } from "./streaming.js";
+export function createListenerDispatchRuntime(input) {
+    return {
+        dispatchRunListeners: (stream, listeners) => dispatchStreamingRunListeners(stream, listeners, {
+            notifyListener: (listener, value) => input.notifyListener(listener, value),
+            getThread: (threadId) => input.getThread(threadId),
+        }),
+    };
+}

package/dist/runtime/harness/events/runtime-event-operations.d.ts

@@ -0,0 +1,17 @@
+import type { HarnessEvent, MessageContent, RunResult } from "../../../contracts/types.js";
+import { emitRunCreatedEvent } from "./events.js";
+type EventRuntime = Parameters<typeof emitRunCreatedEvent>[0];
+export declare function createRuntimeEventOperations(runtime: EventRuntime): {
+    emitRunCreated: (threadId: string, runId: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;
+    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+        previousState: string | null;
+        checkpointRef?: string | null;
+        error?: string;
+    }) => Promise<HarnessEvent>;
+    requestApprovalAndEmit: (threadId: string, runId: string, input: MessageContent, interruptContent: string | undefined, checkpointRef: string, sequence: number) => Promise<{
+        approval: import("../../../contracts/runtime.js").InternalApprovalRecord;
+        event: HarnessEvent;
+    }>;
+    emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown, sequence?: number) => Promise<void>;
+};
+export {};

package/dist/runtime/harness/events/runtime-event-operations.js

@@ -0,0 +1,9 @@
+import { emitRunCreatedEvent, emitSyntheticFallbackEvent, requestApprovalAndEmitEvent, setRunStateAndEmitEvent } from "./events.js";
+export function createRuntimeEventOperations(runtime) {
+    return {
+        emitRunCreated: (threadId, runId, payload) => emitRunCreatedEvent(runtime, threadId, runId, payload),
+        setRunStateAndEmit: (threadId, runId, sequence, state, options) => setRunStateAndEmitEvent(runtime, threadId, runId, sequence, state, options),
+        requestApprovalAndEmit: (threadId, runId, input, interruptContent, checkpointRef, sequence) => requestApprovalAndEmitEvent(runtime, threadId, runId, input, interruptContent, checkpointRef, sequence),
+        emitSyntheticFallback: (threadId, runId, selectedAgentId, error, sequence) => emitSyntheticFallbackEvent(runtime, threadId, runId, selectedAgentId, error, sequence),
+    };
+}

package/dist/runtime/harness/run/recovery.d.ts

@@ -3,7 +3,7 @@ import type { RuntimePersistence } from "../../../persistence/types.js";
 import type { AgentRuntimeAdapter } from "../../agent-runtime-adapter.js";
 import type { ConcurrencyConfig, RecoveryConfig } from "../../../workspace/support/workspace-ref-utils.js";
 type RecoveryBinding = WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never;
-type StartupRecoveryContext = {
+export type StartupRecoveryContext = {
     persistence: RuntimePersistence;
     workspace: WorkspaceBundle;
     runtimeAdapter: AgentRuntimeAdapter;

package/dist/runtime/harness/run/recovery.js

@@ -1,28 +1,37 @@
 import { normalizeRunPriority } from "./helpers.js";
-export async function recoverQueuedStartupRun(context, thread) {
-    if (thread.status !== "queued") {
-        return false;
+async function failRecovery(context, thread, previousState, error, options = {}) {
+    await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
+        previousState,
+        error,
+    });
+    if (options.releaseRunClaim) {
+        await context.persistence.releaseRunClaim(thread.latestRunId);
     }
+    return true;
+}
+async function resolveRecoveryBinding(context, thread) {
     const runMeta = await context.persistence.getRunMeta(thread.threadId, thread.latestRunId);
     const binding = context.getBinding(runMeta.agentId);
     if (!binding) {
-        return true;
-    }
-    const request = await context.persistence.getRunRequest(thread.threadId, thread.latestRunId);
-    if (!request) {
-        await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
-            previousState: "queued",
-            error: "missing persisted run request for queued run recovery",
-        });
-        return true;
+        return null;
     }
+    return {
+        binding,
+        agentId: runMeta.agentId,
+    };
+}
+async function executeRecoveredRun(context, input) {
+    const { thread, binding, agentId, request, previousState, emitResumeEvent } = input;
     const releaseRunSlot = await context.acquireRunSlot(thread.threadId, thread.latestRunId, "running", normalizeRunPriority(request.priority));
     try {
-        await context.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, runMeta.agentId, {
+        if (emitResumeEvent) {
+            await context.emit(thread.threadId, thread.latestRunId, emitResumeEvent.sequence, emitResumeEvent.eventType, emitResumeEvent.payload);
+        }
+        await context.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, agentId, {
             context: request.invocation?.context,
             state: request.invocation?.inputs,
             files: request.invocation?.attachments,
-            previousState: "queued",
+            previousState,
             stateSequence: 103,
             approvalSequence: 104,
         });
@@ -32,6 +41,26 @@ export async function recoverQueuedStartupRun(context, thread) {
     }
     return true;
 }
+export async function recoverQueuedStartupRun(context, thread) {
+    if (thread.status !== "queued") {
+        return false;
+    }
+    const resolved = await resolveRecoveryBinding(context, thread);
+    if (!resolved) {
+        return true;
+    }
+    const request = await context.persistence.getRunRequest(thread.threadId, thread.latestRunId);
+    if (!request) {
+        return failRecovery(context, thread, "queued", "missing persisted run request for queued run recovery");
+    }
+    return executeRecoveredRun(context, {
+        thread,
+        binding: resolved.binding,
+        agentId: resolved.agentId,
+        request,
+        previousState: "queued",
+    });
+}
 export async function recoverRunningStartupRun(context, thread) {
     if (thread.status !== "running") {
         return false;
@@ -40,47 +69,36 @@ export async function recoverRunningStartupRun(context, thread) {
     if (!isStale) {
         return true;
     }
-    const runMeta = await context.persistence.getRunMeta(thread.threadId, thread.latestRunId);
-    const binding = context.getBinding(runMeta.agentId);
-    if (!binding) {
+    const resolved = await resolveRecoveryBinding(context, thread);
+    if (!resolved) {
         return true;
     }
-    if (!context.supportsRunningReplay(binding)) {
-        await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
-            previousState: "running",
-            error: "stale running run cannot be replayed safely",
+    if (!context.supportsRunningReplay(resolved.binding)) {
+        return failRecovery(context, thread, "running", "stale running run cannot be replayed safely", {
+            releaseRunClaim: true,
         });
-        await context.persistence.releaseRunClaim(thread.latestRunId);
-        return true;
     }
     const request = await context.persistence.getRunRequest(thread.threadId, thread.latestRunId);
     if (!request) {
-        await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
-            previousState: "running",
-            error: "missing persisted run request for stale running run recovery",
+        return failRecovery(context, thread, "running", "missing persisted run request for stale running run recovery", {
+            releaseRunClaim: true,
         });
-        await context.persistence.releaseRunClaim(thread.latestRunId);
-        return true;
     }
-    const releaseRunSlot = await context.acquireRunSlot(thread.threadId, thread.latestRunId, "running", normalizeRunPriority(request.priority));
-    try {
-        await context.emit(thread.threadId, thread.latestRunId, 100, "run.resumed", {
-            resumeKind: "startup-running-recovery",
-            state: "running",
-        });
-        await context.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, runMeta.agentId, {
-            context: request.invocation?.context,
-            state: request.invocation?.inputs,
-            files: request.invocation?.attachments,
-            previousState: "running",
-            stateSequence: 103,
-            approvalSequence: 104,
-        });
-    }
-    finally {
-        await releaseRunSlot();
-    }
-    return true;
+    return executeRecoveredRun(context, {
+        thread,
+        binding: resolved.binding,
+        agentId: resolved.agentId,
+        request,
+        previousState: "running",
+        emitResumeEvent: {
+            sequence: 100,
+            eventType: "run.resumed",
+            payload: {
+                resumeKind: "startup-running-recovery",
+                state: "running",
+            },
+        },
+    });
 }
 export async function recoverResumingStartupRun(context, thread) {
     if (thread.status !== "resuming" || !context.recoveryConfig.resumeResumingRunsOnStartup) {

package/dist/runtime/harness/run/routing.d.ts

@@ -1,4 +1,5 @@
 import { type MessageContent, type ThreadSummary, type WorkspaceBundle } from "../../../contracts/types.js";
+import type { RoutingRule } from "../../../workspace/support/workspace-ref-utils.js";
 export declare function getDefaultHostAgentId(workspace: WorkspaceBundle, preferredHostAgentId?: string): string;
 export declare function resolveSelectedAgentId(options: {
     workspace: WorkspaceBundle;
@@ -8,3 +9,10 @@ export declare function resolveSelectedAgentId(options: {
     preferredHostAgentId?: string;
     getThreadSummary: (threadId: string) => Promise<ThreadSummary | null>;
 }): Promise<string>;
+export declare function routeAgentId(options: {
+    workspace: WorkspaceBundle;
+    input: MessageContent;
+    routingRules: RoutingRule[];
+    routingDefaultAgentId?: string;
+    threadId?: string;
+}): string;

package/dist/runtime/harness/run/routing.js

@@ -1,4 +1,7 @@
 import { AUTO_AGENT_ID } from "../../../contracts/types.js";
+import { extractMessageText } from "../../../utils/message-content.js";
+import { matchRoutingRule } from "../../../workspace/support/workspace-ref-utils.js";
+import { getWorkspaceBinding } from "../bindings.js";
 import { inferRoutingBindings } from "../../support/harness-support.js";
 export function getDefaultHostAgentId(workspace, preferredHostAgentId) {
     const preferredBinding = preferredHostAgentId ? workspace.bindings.get(preferredHostAgentId) : undefined;
@@ -21,3 +24,21 @@ export async function resolveSelectedAgentId(options) {
     }
     return requestedAgentId;
 }
+export function routeAgentId(options) {
+    const { workspace, input, routingRules, routingDefaultAgentId, threadId } = options;
+    const rawInput = extractMessageText(input);
+    const configuredRule = routingRules.find((rule) => matchRoutingRule(rawInput, rule, { threadId }));
+    if (configuredRule) {
+        const configuredBinding = getWorkspaceBinding(workspace, configuredRule.agentId);
+        if (configuredBinding) {
+            return configuredBinding.agent.id;
+        }
+    }
+    const defaultBinding = routingDefaultAgentId
+        ? getWorkspaceBinding(workspace, routingDefaultAgentId)
+        : undefined;
+    if (defaultBinding) {
+        return defaultBinding.agent.id;
+    }
+    return getDefaultHostAgentId(workspace, routingDefaultAgentId);
+}