@botbotgo/agent-harness 0.0.37 → 0.0.39

package/dist/mcp.js

@@ -7,14 +7,13 @@ import { loadToolModuleDefinition } from "./tool-modules.js";
 function asResolvedTool(value) {
     return typeof value === "object" && value !== null ? value : null;
 }
-async function buildRawShapeForTool(harness, toolId, resolvedTool) {
-    const tool = harness.getWorkspace().tools.get(toolId);
-    if (!tool) {
+async function buildRawShapeForTool(sourceTool, resolvedTool) {
+    if (!sourceTool) {
         return undefined;
     }
-    if (tool.type === "function") {
-        const imported = await import(pathToFileURL(tool.sourcePath).href);
-        const definition = loadToolModuleDefinition(imported, tool.implementationName ?? tool.id);
+    if (sourceTool.type === "function") {
+        const imported = await import(pathToFileURL(sourceTool.sourcePath).href);
+        const definition = loadToolModuleDefinition(imported, sourceTool.implementationName ?? sourceTool.id);
         return typeof definition.schema.shape === "object" && definition.schema.shape !== null
             ? definition.schema.shape
             : undefined;
@@ -84,17 +83,17 @@ function jsonSchemaToZod(schema) {
             return z.any();
     }
 }
-export async function createToolMcpServerFromHarness(harness, options) {
+export async function createToolMcpServerFromTools(tools, options) {
     const server = new McpServer({
         name: options.serverInfo?.name ?? `agent-harness-${options.agentId}`,
         version: options.serverInfo?.version ?? AGENT_HARNESS_VERSION,
     });
     const allowedNames = options.includeToolNames ? new Set(options.includeToolNames) : null;
-    for (const { compiledTool, resolvedTool } of harness.resolveAgentTools(options.agentId)) {
+    for (const { compiledTool, resolvedTool, sourceTool } of tools) {
         if (allowedNames && !allowedNames.has(compiledTool.name)) {
             continue;
         }
-        const rawShape = await buildRawShapeForTool(harness, compiledTool.id, resolvedTool);
+        const rawShape = await buildRawShapeForTool(sourceTool, resolvedTool);
         server.tool(compiledTool.name, compiledTool.description, rawShape ?? {}, async (input) => ({
             content: [
                 {
@@ -106,8 +105,8 @@ export async function createToolMcpServerFromHarness(harness, options) {
     }
     return server;
 }
-export async function serveToolsOverStdioFromHarness(harness, options) {
-    const server = await createToolMcpServerFromHarness(harness, options);
+export async function serveToolsOverStdioFromHarness(tools, options) {
+    const server = await createToolMcpServerFromTools(tools, options);
     await server.connect(new StdioServerTransport());
     return server;
 }

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.36";
+export declare const AGENT_HARNESS_VERSION = "0.0.38";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.36";
+export const AGENT_HARNESS_VERSION = "0.0.38";

package/dist/resource/resource-impl.d.ts

@@ -1,6 +1,6 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { RuntimeAdapterOptions, WorkspaceBundle } from "../contracts/types.js";
-export declare function resolveLocalBuiltinsEntry(currentResourceDir: string, resolveInstalledEntry?: () => string | null): string;
+export declare function resolveLocalResourceProviderEntry(currentResourceDir: string, resolveInstalledEntry?: () => string | null): string;
 export type ResourceToolInfo = {
     toolPath: string;
     backendOperation: string;
@@ -46,3 +46,4 @@ export declare const listBuiltinTools: typeof listResourceTools;
 export declare const listBuiltinToolsForSource: typeof listResourceToolsForSource;
 export declare const createBuiltinBackendResolver: typeof createResourceBackendResolver;
 export declare const createBuiltinToolResolver: typeof createResourceToolResolver;
+export declare const resolveLocalBuiltinsEntry: typeof resolveLocalResourceProviderEntry;

package/dist/resource/resource-impl.js

@@ -16,7 +16,13 @@ import { resolveIsolatedResourceModulePath } from "./isolation.js";
 import { ensureExternalResourceSource, ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator } from "./sources.js";
 const resourceDir = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
-function installedBuiltinsEntry() {
+function installedResourceProviderEntry() {
+    try {
+        return require.resolve("@botbotgo/agent-harness-resource");
+    }
+    catch {
+        // Fall through to the legacy package name for backward compatibility only.
+    }
     try {
         return require.resolve("@botbotgo/agent-harness-builtin");
     }
@@ -24,12 +30,10 @@ function installedBuiltinsEntry() {
         return null;
     }
 }
-export function resolveLocalBuiltinsEntry(currentResourceDir, resolveInstalledEntry = installedBuiltinsEntry) {
+export function resolveLocalResourceProviderEntry(currentResourceDir, resolveInstalledEntry = installedResourceProviderEntry) {
     const candidates = [
-        path.resolve(currentResourceDir, "../../../builtins/dist/src/index.js"),
-        path.resolve(currentResourceDir, "../../../agent-harness/packages/builtins/dist/src/index.js"),
-        path.resolve(currentResourceDir, "../../../builtins/src/index.ts"),
-        path.resolve(currentResourceDir, "../../../agent-harness/packages/builtins/src/index.ts"),
+        path.resolve(currentResourceDir, "../../../resource-package/dist/src/index.js"),
+        path.resolve(currentResourceDir, "../../../resource-package/src/index.ts"),
         resolveInstalledEntry(),
     ].filter((candidate) => typeof candidate === "string" && candidate.length > 0);
     for (const candidate of candidates) {
@@ -37,9 +41,9 @@ export function resolveLocalBuiltinsEntry(currentResourceDir, resolveInstalledEn
             return candidate;
         }
     }
-    return candidates.at(-1) ?? path.resolve(currentResourceDir, "../../../agent-harness/packages/builtins/dist/src/index.js");
+    return candidates.at(-1) ?? path.resolve(currentResourceDir, "../../../resource-package/dist/src/index.js");
 }
-const builtinsEntry = resolveLocalBuiltinsEntry(resourceDir);
+const resourceProviderEntry = resolveLocalResourceProviderEntry(resourceDir);
 async function loadLocalResource(entry) {
     if (!existsSync(entry)) {
         return null;
@@ -47,7 +51,7 @@ async function loadLocalResource(entry) {
     const imported = await import(pathToFileURL(entry).href);
     return (imported.default ?? imported);
 }
-const localResource = await loadLocalResource(builtinsEntry);
+const localResource = await loadLocalResource(resourceProviderEntry);
 function listProviderTools(provider) {
     const rawTools = provider?.listResourceTools?.() ?? provider?.listBuiltinTools?.() ?? [];
     return rawTools.map((tool) => ({
@@ -509,7 +513,7 @@ export async function listResourceToolsForSource(source, workspaceRoot = process
 }
 export function createResourceBackendResolver(workspace) {
     const localResolver = createProviderBackendResolver(localResource, workspace);
-    const remoteResolvers = (workspace.resourceSources ?? workspace.builtinSources ?? [])
+    const remoteResolvers = (workspace.resourceSources ?? [])
         .map((source) => remoteResourceCache.get(source))
         .filter((provider) => Boolean(provider))
         .map((provider) => createProviderBackendResolver(provider, workspace))
@@ -525,7 +529,7 @@ export function createResourceToolResolver(workspace, options = {}) {
     const functionResolver = createFunctionToolResolver(workspace);
     const mcpResolver = createMcpToolResolver(workspace);
     const localResolver = createProviderToolResolver(localResource, workspace, options);
-    const remoteResolvers = (workspace.resourceSources ?? workspace.builtinSources ?? [])
+    const remoteResolvers = (workspace.resourceSources ?? [])
         .map((source) => remoteResourceCache.get(source))
         .filter((provider) => Boolean(provider))
         .map((provider) => createProviderToolResolver(provider, workspace, options))
@@ -551,3 +555,4 @@ export const listBuiltinTools = listResourceTools;
 export const listBuiltinToolsForSource = listResourceToolsForSource;
 export const createBuiltinBackendResolver = createResourceBackendResolver;
 export const createBuiltinToolResolver = createResourceToolResolver;
+export const resolveLocalBuiltinsEntry = resolveLocalResourceProviderEntry;

package/dist/resource/resource.d.ts

@@ -1 +1 @@
-export { type ResourceToolInfo, ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, ensureBuiltinSources, builtinSkillsRoot, builtinConfigRoot, listBuiltinTools, listBuiltinToolsForSource, createBuiltinBackendResolver, createBuiltinToolResolver, resolveLocalBuiltinsEntry, } from "./resource-impl.js";
+export { type ResourceToolInfo, ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, resolveLocalResourceProviderEntry, } from "./resource-impl.js";

package/dist/resource/resource.js

@@ -1 +1 @@
-export { ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, ensureBuiltinSources, builtinSkillsRoot, builtinConfigRoot, listBuiltinTools, listBuiltinToolsForSource, createBuiltinBackendResolver, createBuiltinToolResolver, resolveLocalBuiltinsEntry, } from "./resource-impl.js";
+export { ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, resolveLocalResourceProviderEntry, } from "./resource-impl.js";

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

@@ -656,6 +656,7 @@ export class AgentRuntimeAdapter {
                 const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2" }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
                 const allowVisibleStreamDeltas = Boolean(binding.langchainAgentParams);
                 let emittedOutput = "";
+                let emittedToolError = false;
                 const seenTerminalOutputs = new Set();
                 let lastStep = "";
                 for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents", streamDeadlineAt, invokeTimeoutMs)) {
@@ -695,7 +696,8 @@ export class AgentRuntimeAdapter {
                     }
                     const toolResult = extractToolResult(event);
                     if (toolResult) {
-                        yield { kind: "tool-result", toolName: toolResult.toolName, output: toolResult.output };
+                        emittedToolError = emittedToolError || toolResult.isError === true;
+                        yield { kind: "tool-result", toolName: toolResult.toolName, output: toolResult.output, isError: toolResult.isError };
                     }
                     const output = extractTerminalStreamOutput(event);
                     if (output) {
@@ -713,7 +715,7 @@ export class AgentRuntimeAdapter {
                         }
                     }
                 }
-                if (emittedOutput) {
+                if (emittedOutput || emittedToolError) {
                     return;
                 }
             }

package/dist/runtime/event-bus.d.ts

@@ -1,6 +1,7 @@
-import type { HarnessEvent } from "../contracts/types.js";
-export declare class EventBus {
-    private readonly emitter;
+import type { HarnessEvent, HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../contracts/types.js";
+export declare class EventBus implements RuntimeEventSink {
+    private readonly sink;
     publish(event: HarnessEvent): void;
-    subscribe(listener: (event: HarnessEvent) => void): () => void;
+    subscribe(listener: HarnessEventListener): () => void;
+    registerProjection(projection: HarnessEventProjection): () => void;
 }

package/dist/runtime/event-bus.js

@@ -1,15 +1,13 @@
-import { EventEmitter } from "node:events";
-import { getEventSubscribers } from "../extensions.js";
+import { createRuntimeEventSink } from "./event-sink.js";
 export class EventBus {
-    emitter = new EventEmitter();
+    sink = createRuntimeEventSink();
     publish(event) {
-        this.emitter.emit("event", event);
-        for (const subscriber of getEventSubscribers()) {
-            void Promise.resolve(subscriber.onEvent(event));
-        }
+        this.sink.publish(event);
     }
     subscribe(listener) {
-        this.emitter.on("event", listener);
-        return () => this.emitter.off("event", listener);
+        return this.sink.subscribe(listener);
+    }
+    registerProjection(projection) {
+        return this.sink.registerProjection(projection);
     }
 }

package/dist/runtime/event-sink.d.ts

@@ -0,0 +1,9 @@
+import type { HarnessEvent, HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../contracts/types.js";
+export declare class RuntimeEventSinkImpl implements RuntimeEventSink {
+    private readonly emitter;
+    private readonly projections;
+    publish(event: HarnessEvent): void;
+    subscribe(listener: HarnessEventListener): () => void;
+    registerProjection(projection: HarnessEventProjection): () => void;
+}
+export declare function createRuntimeEventSink(): RuntimeEventSinkImpl;

package/dist/runtime/event-sink.js

@@ -0,0 +1,35 @@
+import { EventEmitter } from "node:events";
+import { getEventSubscribers } from "../extensions.js";
+function dispatchListener(listener, event) {
+    void Promise.resolve(listener(event));
+}
+function dispatchProjection(projection, event) {
+    if (projection.shouldHandle && !projection.shouldHandle(event)) {
+        return;
+    }
+    void Promise.resolve(projection.handleEvent(event));
+}
+export class RuntimeEventSinkImpl {
+    emitter = new EventEmitter();
+    projections = new Set();
+    publish(event) {
+        this.emitter.emit("event", event);
+        for (const projection of this.projections) {
+            dispatchProjection(projection, event);
+        }
+        for (const subscriber of getEventSubscribers()) {
+            dispatchListener(subscriber.onEvent, event);
+        }
+    }
+    subscribe(listener) {
+        this.emitter.on("event", listener);
+        return () => this.emitter.off("event", listener);
+    }
+    registerProjection(projection) {
+        this.projections.add(projection);
+        return () => this.projections.delete(projection);
+    }
+}
+export function createRuntimeEventSink() {
+    return new RuntimeEventSinkImpl();
+}

package/dist/runtime/harness.d.ts

@@ -1,5 +1,6 @@
-import type { ApprovalRecord, CompiledTool, HarnessEvent, HarnessStreamItem, MessageContent, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
-export declare class AgentHarness {
+import type { ApprovalRecord, HarnessEvent, HarnessStreamItem, MessageContent, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
+import { type ToolMcpServerOptions } from "../mcp.js";
+export declare class AgentHarnessRuntime {
     private readonly workspace;
     private readonly runtimeAdapterOptions;
     private readonly eventBus;
@@ -12,8 +13,11 @@ export declare class AgentHarness {
     private readonly vectorStores;
     private readonly defaultStore;
     private readonly routingSystemPrompt?;
+    private readonly routingRules;
+    private readonly routingDefaultAgentId?;
+    private readonly modelRoutingEnabled;
     private readonly threadMemorySync;
-    private readonly unsubscribeThreadMemorySync;
+    private readonly unregisterThreadMemorySync;
     private readonly resolvedRuntimeAdapterOptions;
     private readonly checkpointMaintenance;
     private listHostBindings;
@@ -27,19 +31,22 @@ export declare class AgentHarness {
     constructor(workspace: WorkspaceBundle, runtimeAdapterOptions?: RuntimeAdapterOptions);
     initialize(): Promise<void>;
     subscribe(listener: (event: HarnessEvent) => void): () => void;
-    getWorkspace(): WorkspaceBundle;
-    getBinding(agentId: string): WorkspaceBundle["bindings"] extends Map<any, infer T> ? T | undefined : never;
-    listAgentTools(agentId: string): CompiledTool[];
-    resolveAgentTools(agentId: string): Array<{
-        compiledTool: CompiledTool;
-        resolvedTool: unknown;
-    }>;
-    listSessions(filter?: {
+    private getBinding;
+    private listAgentTools;
+    private resolveAgentTools;
+    listThreads(filter?: {
         agentId?: string;
     }): Promise<ThreadSummary[]>;
     private getSession;
     getThread(threadId: string): Promise<ThreadRecord | null>;
-    listPendingApprovals(): Promise<ApprovalRecord[]>;
+    listApprovals(filter?: {
+        status?: ApprovalRecord["status"];
+        threadId?: string;
+        runId?: string;
+    }): Promise<ApprovalRecord[]>;
+    getApproval(approvalId: string): Promise<ApprovalRecord | null>;
+    createToolMcpServer(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
+    serveToolsOverStdio(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
     routeAgent(input: MessageContent, options?: {
         threadId?: string;
     }): Promise<string>;
@@ -65,4 +72,6 @@ export declare class AgentHarness {
         restart: Record<string, string>;
     }>;
     close(): Promise<void>;
+    stop(): Promise<void>;
 }
+export { AgentHarnessRuntime as AgentHarness };

package/dist/runtime/harness.js

@@ -5,8 +5,8 @@ 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 { getRoutingSystemPrompt } from "../workspace/support/workspace-ref-utils.js";
-import { createHarnessEvent, createPendingApproval, heuristicRoute, inferRoutingBindings, resolveDeterministicRouteIntent, renderRuntimeFailure, requiresResearchRoute, } from "./support/harness-support.js";
+import { 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";
 import { resolveCompiledVectorStore, resolveCompiledVectorStoreRef } from "./support/vector-stores.js";
@@ -14,7 +14,8 @@ import { ThreadMemorySync } from "./thread-memory-sync.js";
 import { FileBackedStore } from "./store.js";
 import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
-export class AgentHarness {
+import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
+export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
     eventBus = new EventBus();
@@ -27,8 +28,11 @@ export class AgentHarness {
     vectorStores = new Map();
     defaultStore;
     routingSystemPrompt;
+    routingRules;
+    routingDefaultAgentId;
+    modelRoutingEnabled;
     threadMemorySync;
-    unsubscribeThreadMemorySync;
+    unregisterThreadMemorySync;
     resolvedRuntimeAdapterOptions;
     checkpointMaintenance;
     listHostBindings() {
@@ -144,10 +148,11 @@ export class AgentHarness {
         };
         this.runtimeAdapter = new AgentRuntimeAdapter(this.resolvedRuntimeAdapterOptions);
         this.routingSystemPrompt = getRoutingSystemPrompt(workspace.refs);
+        this.routingRules = getRoutingRules(workspace.refs);
+        this.routingDefaultAgentId = getRoutingDefaultAgentId(workspace.refs);
+        this.modelRoutingEnabled = isModelRoutingEnabled(workspace.refs);
         this.threadMemorySync = new ThreadMemorySync(this.persistence, this.defaultStore);
-        this.unsubscribeThreadMemorySync = this.eventBus.subscribe((event) => {
-            void this.threadMemorySync.handleEvent(event);
-        });
+        this.unregisterThreadMemorySync = this.eventBus.registerProjection(this.threadMemorySync);
         const checkpointMaintenanceConfig = readCheckpointMaintenanceConfig(workspace);
         this.checkpointMaintenance = checkpointMaintenanceConfig
             ? new CheckpointMaintenanceLoop(discoverCheckpointMaintenanceTargets(workspace), checkpointMaintenanceConfig)
@@ -160,9 +165,6 @@ export class AgentHarness {
     subscribe(listener) {
         return this.eventBus.subscribe(listener);
     }
-    getWorkspace() {
-        return this.workspace;
-    }
     getBinding(agentId) {
         return this.workspace.bindings.get(agentId);
     }
@@ -186,7 +188,7 @@ export class AgentHarness {
             resolvedTool: resolvedTools[index],
         }));
     }
-    async listSessions(filter) {
+    async listThreads(filter) {
         const threadSummaries = await this.persistence.listSessions();
         if (!filter?.agentId) {
             return threadSummaries;
@@ -231,30 +233,63 @@ export class AgentHarness {
                 : undefined,
         };
     }
-    async listPendingApprovals() {
-        return (await this.persistence.listApprovals()).filter((approval) => approval.status === "pending");
+    async listApprovals(filter) {
+        const approvals = filter?.threadId && filter?.runId
+            ? await this.persistence.getRunApprovals(filter.threadId, filter.runId)
+            : await this.persistence.listApprovals();
+        return approvals.filter((approval) => {
+            if (filter?.status && approval.status !== filter.status) {
+                return false;
+            }
+            if (filter?.threadId && approval.threadId !== filter.threadId) {
+                return false;
+            }
+            if (filter?.runId && approval.runId !== filter.runId) {
+                return false;
+            }
+            return true;
+        });
+    }
+    async getApproval(approvalId) {
+        return this.persistence.getApproval(approvalId);
+    }
+    async createToolMcpServer(options) {
+        const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
+            compiledTool,
+            resolvedTool,
+            sourceTool: this.workspace.tools.get(compiledTool.id),
+        }));
+        return createToolMcpServerFromTools(tools, options);
+    }
+    async serveToolsOverStdio(options) {
+        const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
+            compiledTool,
+            resolvedTool,
+            sourceTool: this.workspace.tools.get(compiledTool.id),
+        }));
+        return serveToolsOverStdioFromHarness(tools, options);
     }
     async routeAgent(input, options = {}) {
         const routingInput = await this.buildRoutingInput(input, options.threadId);
-        const normalized = extractMessageText(input).trim().toLowerCase();
-        const { primaryBinding, secondaryBinding, researchBinding } = inferRoutingBindings(this.workspace);
-        const deterministicIntent = resolveDeterministicRouteIntent(normalized);
-        if (requiresResearchRoute(normalized)) {
-            const explicitResearchBinding = this.workspace.bindings.get("research-lite") ?? this.workspace.bindings.get("research");
-            const hostResearchBinding = explicitResearchBinding?.harnessRuntime.hostFacing !== false ? explicitResearchBinding : researchBinding;
-            return hostResearchBinding?.agent.id ?? secondaryBinding?.agent.id ?? primaryBinding?.agent.id ?? heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
-        }
-        if (secondaryBinding?.deepAgentParams) {
-            return secondaryBinding.agent.id;
-        }
-        if (deterministicIntent === "primary") {
-            return primaryBinding?.agent.id ?? heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
+        const rawInput = extractMessageText(input);
+        const { primaryBinding, secondaryBinding } = inferRoutingBindings(this.workspace);
+        const configuredRule = this.routingRules.find((rule) => matchRoutingRule(rawInput, rule, options));
+        if (configuredRule) {
+            const configuredBinding = this.workspace.bindings.get(configuredRule.agentId);
+            if (configuredBinding && configuredBinding.harnessRuntime.hostFacing !== false) {
+                return configuredBinding.agent.id;
+            }
         }
-        if (deterministicIntent === "secondary") {
-            return secondaryBinding?.agent.id ?? primaryBinding?.agent.id ?? heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
+        if (!this.modelRoutingEnabled) {
+            const defaultBinding = this.routingDefaultAgentId
+                ? this.workspace.bindings.get(this.routingDefaultAgentId)
+                : primaryBinding;
+            if (defaultBinding && defaultBinding.harnessRuntime.hostFacing !== false) {
+                return defaultBinding.agent.id;
+            }
         }
         if (!primaryBinding || !secondaryBinding) {
-            return heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
+            return heuristicRoute(rawInput, primaryBinding, secondaryBinding);
         }
         try {
             return await this.runtimeAdapter.route(routingInput, primaryBinding, secondaryBinding, {
@@ -262,7 +297,7 @@ export class AgentHarness {
             });
         }
         catch {
-            return heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
+            return heuristicRoute(rawInput, primaryBinding, secondaryBinding);
         }
     }
     async emit(threadId, runId, sequence, eventType, payload, source = "runtime") {
@@ -429,6 +464,7 @@ export class AgentHarness {
                 await this.notifyListener(listeners.onToolResult, {
                     toolName: item.toolName,
                     output: item.output,
+                    isError: item.isError,
                 });
             }
         }
@@ -543,6 +579,7 @@ export class AgentHarness {
         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)) {
                 if (chunk) {
                     const normalizedChunk = typeof chunk === "string"
@@ -591,6 +628,9 @@ export class AgentHarness {
                         continue;
                     }
                     if (normalizedChunk.kind === "tool-result") {
+                        if (normalizedChunk.isError) {
+                            toolErrors.push(renderToolFailure(normalizedChunk.toolName, normalizedChunk.output));
+                        }
                         yield {
                             type: "tool-result",
                             threadId,
@@ -598,6 +638,7 @@ export class AgentHarness {
                             agentId: selectedAgentId,
                             toolName: normalizedChunk.toolName,
                             output: normalizedChunk.output,
+                            isError: normalizedChunk.isError,
                         };
                         continue;
                     }
@@ -606,6 +647,11 @@ export class AgentHarness {
                     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) {
@@ -750,7 +796,11 @@ export class AgentHarness {
     }
     async close() {
         await this.checkpointMaintenance?.stop();
-        this.unsubscribeThreadMemorySync();
+        this.unregisterThreadMemorySync();
         await this.threadMemorySync.close();
     }
+    async stop() {
+        await this.close();
+    }
 }
+export { AgentHarnessRuntime as AgentHarness };

package/dist/runtime/index.d.ts

@@ -1,12 +1,14 @@
 export { AgentRuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX } from "./agent-runtime-adapter.js";
 export { EventBus } from "./event-bus.js";
+export { createRuntimeEventSink, RuntimeEventSinkImpl } from "./event-sink.js";
 export { FileCheckpointSaver } from "./file-checkpoint-saver.js";
 export { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, maintainSqliteCheckpoints, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 export { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
-export { AgentHarness } from "./harness.js";
+export { AgentHarnessRuntime, AgentHarness } from "./harness.js";
 export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./inventory.js";
 export * from "./parsing/index.js";
 export { PolicyEngine } from "./policy-engine.js";
 export { createInMemoryStore, FileBackedStore } from "./store.js";
 export * from "./support/index.js";
 export { ThreadMemorySync } from "./thread-memory-sync.js";
+export type { HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../contracts/types.js";

package/dist/runtime/index.js

@@ -1,9 +1,10 @@
 export { AgentRuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX } from "./agent-runtime-adapter.js";
 export { EventBus } from "./event-bus.js";
+export { createRuntimeEventSink, RuntimeEventSinkImpl } from "./event-sink.js";
 export { FileCheckpointSaver } from "./file-checkpoint-saver.js";
 export { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, maintainSqliteCheckpoints, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 export { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
-export { AgentHarness } from "./harness.js";
+export { AgentHarnessRuntime, AgentHarness } from "./harness.js";
 export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./inventory.js";
 export * from "./parsing/index.js";
 export { PolicyEngine } from "./policy-engine.js";

package/dist/runtime/parsing/stream-event-parsing.d.ts

@@ -14,6 +14,7 @@ export type RuntimeStreamChunk = {
     kind: "tool-result";
     toolName: string;
     output: unknown;
+    isError?: boolean;
 };
 export declare function extractTerminalStreamOutput(event: unknown): string;
 export declare function extractReasoningStreamOutput(event: unknown): string;
@@ -23,6 +24,7 @@ export declare function extractAgentStep(event: unknown): string | null;
 export declare function extractToolResult(event: unknown): {
     toolName: string;
     output: unknown;
+    isError?: boolean;
 } | null;
 export declare function extractInterruptPayload(event: unknown): string | null;
 export declare function normalizeTerminalOutputKey(value: string): string;