@botbotgo/agent-harness 0.0.37 → 0.0.39

package/dist/runtime/parsing/stream-event-parsing.js

@@ -50,6 +50,31 @@ function summarizeStepValue(value) {
 function humanizeEventName(name) {
     return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[._-]+/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
 }
+function readToolErrorText(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value instanceof Error) {
+        return value.message;
+    }
+    if (typeof value !== "object" || !value) {
+        return "";
+    }
+    const record = value;
+    for (const candidate of [record.error, record.message, record.detail, record.details]) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate;
+        }
+    }
+    return "";
+}
+function isErrorLikeToolOutput(value) {
+    const message = readToolErrorText(value).trim();
+    if (!message) {
+        return false;
+    }
+    return /(^|\b)(error|exception|failed|failure|denied|timed out|timeout|not permitted|eperm|eacces)(\b|:)/i.test(message);
+}
 export function extractTerminalStreamOutput(event) {
     if (typeof event !== "object" || !event)
         return "";
@@ -109,6 +134,10 @@ export function extractAgentStep(event) {
         const outputSummary = formatStepValue(typed.data?.output, 80);
         return outputSummary ? `tool ${name || "tool"} done  ${outputSummary}` : `tool ${name || "tool"} done`;
     }
+    if (typed.event === "on_tool_error" || (typed.event === "on_chain_error" && typed.run_type === "tool")) {
+        const errorSummary = formatStepValue(typed.data?.error ?? typed.data?.output, 80);
+        return errorSummary ? `tool ${name || "tool"} error  ${errorSummary}` : `tool ${name || "tool"} error`;
+    }
     if (typed.event === "on_chat_model_start") {
         const inputTools = typed.data?.input?.tools;
         const tools = typed.invocation_params?.tools ?? inputTools ?? [];
@@ -148,14 +177,17 @@ export function extractToolResult(event) {
         return null;
     const typed = event;
     const isToolEnd = typed.event === "on_tool_end" || (typed.event === "on_chain_end" && typed.run_type === "tool");
+    const isToolError = typed.event === "on_tool_error" || (typed.event === "on_chain_error" && typed.run_type === "tool");
     const toolName = typeof typed.name === "string" ? typed.name : "";
-    if (!isToolEnd || !toolName) {
+    if ((!isToolEnd && !isToolError) || !toolName) {
         return null;
     }
-    const rawOutput = typed.data?.output;
+    const rawOutput = isToolError ? typed.data?.error ?? typed.data?.output : typed.data?.output;
+    const normalizedOutput = typeof rawOutput === "string" ? parseMaybeJson(rawOutput) : rawOutput;
     return {
         toolName,
-        output: typeof rawOutput === "string" ? parseMaybeJson(rawOutput) : rawOutput,
+        output: normalizedOutput,
+        isError: isToolError || isErrorLikeToolOutput(normalizedOutput),
     };
 }
 export function extractInterruptPayload(event) {

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

@@ -1,5 +1,6 @@
 import type { ApprovalRecord, HarnessEvent, WorkspaceBundle } from "../../contracts/types.js";
 export declare function renderRuntimeFailure(error: unknown): string;
+export declare function renderToolFailure(toolName: string, output: unknown): string;
 export declare function parseInterruptContent(content: string): {
     toolName?: string;
     toolId?: string;

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

@@ -3,6 +3,33 @@ export function renderRuntimeFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     return `runtime_error=${message}`.trim();
 }
+function readToolErrorMessage(output) {
+    if (typeof output === "string" && output.trim()) {
+        return output.trim();
+    }
+    if (output instanceof Error) {
+        return output.message;
+    }
+    if (typeof output !== "object" || !output) {
+        return "";
+    }
+    const record = output;
+    for (const candidate of [record.error, record.message, record.detail, record.details]) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    try {
+        return JSON.stringify(output);
+    }
+    catch {
+        return String(output);
+    }
+}
+export function renderToolFailure(toolName, output) {
+    const detail = readToolErrorMessage(output);
+    return detail ? `Tool ${toolName} failed: ${detail}` : `Tool ${toolName} failed.`;
+}
 export function parseInterruptContent(content) {
     try {
         const raw = JSON.parse(content);
@@ -106,11 +133,18 @@ export function inferRoutingBindings(workspace) {
     const directBinding = hostBindings.find((binding) => binding.agent.id === "direct");
     const langchainHost = hostBindings.find((binding) => binding.agent.executionMode === "langchain-v1" && binding.agent.id !== researchBinding?.agent.id);
     const deepagentHosts = hostBindings.filter((binding) => binding.agent.executionMode === "deepagent");
+    const defaultDeepagentHost = deepagentHosts.find((binding) => binding.agent.id === "orchestra") ??
+        deepagentHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        deepagentHosts[0];
     const deepagentWithSubagents = deepagentHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
         deepagentHosts[0];
-    const primaryBinding = directBinding ?? langchainHost ?? hostBindings[0];
-    const secondaryBinding = deepagentWithSubagents && deepagentWithSubagents.agent.id !== primaryBinding?.agent.id
-        ? deepagentWithSubagents
-        : hostBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id);
+    const primaryBinding = defaultDeepagentHost ?? directBinding ?? langchainHost ?? hostBindings[0];
+    const secondaryBinding = langchainHost && langchainHost.agent.id !== primaryBinding?.agent.id
+        ? langchainHost
+        : directBinding && directBinding.agent.id !== primaryBinding?.agent.id
+            ? directBinding
+            : deepagentWithSubagents && deepagentWithSubagents.agent.id !== primaryBinding?.agent.id
+                ? deepagentWithSubagents
+                : hostBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id);
     return { primaryBinding, secondaryBinding, researchBinding, hostBindings };
 }

package/dist/runtime/thread-memory-sync.d.ts

@@ -1,12 +1,14 @@
-import type { HarnessEvent } from "../contracts/types.js";
+import type { HarnessEvent, HarnessEventProjection } from "../contracts/types.js";
 import type { FilePersistence } from "../persistence/file-store.js";
-export declare class ThreadMemorySync {
+export declare class ThreadMemorySync implements HarnessEventProjection {
     private readonly persistence;
     private readonly store?;
     private readonly pending;
+    readonly name = "thread-memory-sync";
     constructor(persistence: FilePersistence, store?: {
         put: (namespace: string[], key: string, value: Record<string, any>) => Promise<void>;
     } | undefined);
+    shouldHandle(event: HarnessEvent): boolean;
     handleEvent(event: HarnessEvent): Promise<void>;
     private syncThread;
     close(): Promise<void>;

package/dist/runtime/thread-memory-sync.js

@@ -42,16 +42,25 @@ function renderOpenApprovalsMarkdown(approvals) {
     }
     return lines.join("\n");
 }
+const THREAD_MEMORY_EVENT_TYPES = new Set([
+    "run.state.changed",
+    "approval.resolved",
+    "approval.requested",
+]);
 export class ThreadMemorySync {
     persistence;
     store;
     pending = new Set();
+    name = "thread-memory-sync";
     constructor(persistence, store) {
         this.persistence = persistence;
         this.store = store;
     }
+    shouldHandle(event) {
+        return THREAD_MEMORY_EVENT_TYPES.has(event.eventType);
+    }
     async handleEvent(event) {
-        if (event.eventType !== "run.state.changed" && event.eventType !== "approval.resolved" && event.eventType !== "approval.requested") {
+        if (!this.shouldHandle(event)) {
             return;
         }
         const task = this.syncThread(event.threadId)

package/dist/workspace/agent-binding-compiler.js

@@ -52,9 +52,6 @@ function resolveAgentRuntimeName(agent) {
         return baseName;
     }
     const normalizedSourcePath = agent.sourcePath.split(path.sep).join("/");
-    if (normalizedSourcePath.includes("/packages/builtins/")) {
-        return `builtin.${baseName}`;
-    }
     if (normalizedSourcePath.includes("/packages/framework/")) {
         return `core.${baseName}`;
     }

package/dist/workspace/compile.js

@@ -87,7 +87,6 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
     return {
         workspaceRoot,
         resourceSources: [...toolSourceRefs],
-        builtinSources: [...toolSourceRefs],
         refs: loaded.refs,
         embeddings,
         mcpServers,

package/dist/workspace/support/discovery.js

@@ -4,11 +4,14 @@ import { defaultResourceConfigRoot, defaultResourceSkillsRoot } from "../../reso
 import { validateSkillMetadata } from "../../runtime/support/skill-metadata.js";
 import { ensureExternalResourceSource, isDirectoryPath, isExternalSourceLocator, resolveExternalResourcePath, resolveResourcePackageRoot, } from "../../resource/sources.js";
 import { parseAgentItem, readYamlItems } from "../object-loader.js";
-function resolveBuiltinPath(kind, ref) {
-    const normalized = ref.replace(/^builtin:\/\//, "").replace(/^\/+/, "");
+function isBundledResourceRef(ref) {
+    return ref.startsWith("resource://") || ref.startsWith("builtin://");
+}
+function resolveBundledResourcePath(kind, ref) {
+    const normalized = ref.replace(/^(resource|builtin):\/\//, "").replace(/^\/+/, "");
     if (kind === "skills") {
         if (!normalized.startsWith("skills")) {
-            throw new Error(`Unsupported builtin skill discovery path ${ref}`);
+            throw new Error(`Unsupported resource skill discovery path ${ref}`);
         }
         const suffix = normalized.replace(/^skills\/?/, "");
         const root = defaultResourceSkillsRoot();
@@ -28,7 +31,7 @@ function resolveBuiltinPath(kind, ref) {
         return candidate;
     }
     if (!normalized.startsWith("agents")) {
-        throw new Error(`Unsupported builtin subagent discovery path ${ref}`);
+        throw new Error(`Unsupported resource subagent discovery path ${ref}`);
     }
     const suffix = normalized.replace(/^agents\/?/, "");
     const root = path.join(defaultResourceConfigRoot(), "agents");
@@ -69,8 +72,8 @@ export async function ensureDiscoverySources(locators, workspaceRoot) {
         .map((locator) => ensureExternalResourceSource(locator, workspaceRoot)));
 }
 export function resolveDiscoveryRoot(ref, workspaceRoot, kind) {
-    if (ref.startsWith("builtin://")) {
-        return resolveBuiltinPath(kind, ref);
+    if (isBundledResourceRef(ref)) {
+        return resolveBundledResourcePath(kind, ref);
     }
     if (isExternalSourceLocator(ref)) {
         return preferPackageConvention(resolveExternalResourcePath(ref, workspaceRoot), kind);
@@ -78,8 +81,8 @@ export function resolveDiscoveryRoot(ref, workspaceRoot, kind) {
     return preferPackageConvention(path.resolve(workspaceRoot, ref), kind);
 }
 async function resolveDiscoveryRootAsync(ref, workspaceRoot, kind) {
-    if (ref.startsWith("builtin://")) {
-        return resolveBuiltinPath(kind, ref);
+    if (isBundledResourceRef(ref)) {
+        return resolveBundledResourcePath(kind, ref);
     }
     if (isExternalSourceLocator(ref)) {
         return preferPackageConvention(await ensureExternalResourceSource(ref, workspaceRoot), kind);

package/dist/workspace/support/source-collectors.js

@@ -1,6 +1,6 @@
 import { isExternalSourceLocator } from "../../resource/sources.js";
 export function collectToolSourceRefs(tools, agents, options) {
-    const refs = new Set(options.resourceSources ?? options.builtinSources ?? []);
+    const refs = new Set(options.resourceSources ?? []);
     for (const tool of tools.values()) {
         for (const ref of tool.bundleRefs) {
             if (isExternalSourceLocator(ref)) {

package/dist/workspace/support/workspace-ref-utils.d.ts

@@ -1,7 +1,26 @@
 import type { ParsedAgentObject, WorkspaceObject } from "../../contracts/types.js";
+export type RoutingRule = {
+    agentId: string;
+    equals?: string[];
+    startsWith?: string[];
+    contains?: string[];
+    regex?: string[];
+    minLength?: number;
+    maxLength?: number;
+    minLines?: number;
+    maxLines?: number;
+    hasThreadId?: boolean;
+    caseSensitive?: boolean;
+};
 export declare function getWorkspaceObject(refs: Map<string, WorkspaceObject | ParsedAgentObject>, ref: string | undefined): WorkspaceObject | undefined;
 export declare function getRuntimeDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
 export declare function getRoutingSystemPrompt(refs: Map<string, WorkspaceObject | ParsedAgentObject>): string | undefined;
+export declare function getRoutingDefaultAgentId(refs: Map<string, WorkspaceObject | ParsedAgentObject>): string | undefined;
+export declare function isModelRoutingEnabled(refs: Map<string, WorkspaceObject | ParsedAgentObject>): boolean;
+export declare function getRoutingRules(refs: Map<string, WorkspaceObject | ParsedAgentObject>): RoutingRule[];
+export declare function matchRoutingRule(input: string, rule: RoutingRule, options?: {
+    threadId?: string;
+}): boolean;
 export declare function resolvePromptValue(promptConfig: unknown): string | undefined;
 export declare function resolveRefId(ref: string): string;
 export declare function resolvePathList(refs: Map<string, WorkspaceObject | ParsedAgentObject>, workspaceRoot: string, refList: string[]): string[];

package/dist/workspace/support/workspace-ref-utils.js

@@ -1,4 +1,10 @@
 import path from "node:path";
+function getRoutingObject(refs) {
+    const runtimeDefaults = getRuntimeDefaults(refs);
+    return typeof runtimeDefaults?.routing === "object" && runtimeDefaults.routing
+        ? runtimeDefaults.routing
+        : undefined;
+}
 export function getWorkspaceObject(refs, ref) {
     if (!ref) {
         return undefined;
@@ -20,12 +26,108 @@ export function getRuntimeDefaults(refs) {
     return runtimes[0].value;
 }
 export function getRoutingSystemPrompt(refs) {
-    const runtimeDefaults = getRuntimeDefaults(refs);
-    const routing = typeof runtimeDefaults?.routing === "object" && runtimeDefaults.routing
-        ? runtimeDefaults.routing
-        : undefined;
+    const routing = getRoutingObject(refs);
     return typeof routing?.systemPrompt === "string" && routing.systemPrompt.trim() ? routing.systemPrompt : undefined;
 }
+export function getRoutingDefaultAgentId(refs) {
+    const routing = getRoutingObject(refs);
+    return typeof routing?.defaultAgentId === "string" && routing.defaultAgentId.trim()
+        ? routing.defaultAgentId.trim()
+        : undefined;
+}
+export function isModelRoutingEnabled(refs) {
+    const routing = getRoutingObject(refs);
+    return routing?.modelRouting === true;
+}
+function toStringList(value) {
+    if (typeof value === "string" && value.trim()) {
+        return [value];
+    }
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value
+        .filter((item) => typeof item === "string" && item.trim().length > 0)
+        .map((item) => item.trim());
+    return items.length > 0 ? items : undefined;
+}
+function toPositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+export function getRoutingRules(refs) {
+    const routing = getRoutingObject(refs);
+    if (!Array.isArray(routing?.rules)) {
+        return [];
+    }
+    return routing.rules.flatMap((rule, index) => {
+        if (typeof rule !== "object" || rule === null || Array.isArray(rule)) {
+            throw new Error(`Runtime routing.rules[${index}] must be an object`);
+        }
+        const typed = rule;
+        if (typeof typed.agentId !== "string" || !typed.agentId.trim()) {
+            throw new Error(`Runtime routing.rules[${index}] requires a non-empty agentId`);
+        }
+        const regex = toStringList(typed.regex);
+        if (regex) {
+            for (const pattern of regex) {
+                try {
+                    new RegExp(pattern);
+                }
+                catch (error) {
+                    const detail = error instanceof Error ? error.message : String(error);
+                    throw new Error(`Runtime routing.rules[${index}] has invalid regex ${JSON.stringify(pattern)}: ${detail}`);
+                }
+            }
+        }
+        return [{
+                agentId: typed.agentId.trim(),
+                equals: toStringList(typed.equals),
+                startsWith: toStringList(typed.startsWith),
+                contains: toStringList(typed.contains),
+                regex,
+                minLength: toPositiveNumber(typed.minLength),
+                maxLength: toPositiveNumber(typed.maxLength),
+                minLines: toPositiveNumber(typed.minLines),
+                maxLines: toPositiveNumber(typed.maxLines),
+                hasThreadId: typeof typed.hasThreadId === "boolean" ? typed.hasThreadId : undefined,
+                caseSensitive: typed.caseSensitive === true,
+            }];
+    });
+}
+export function matchRoutingRule(input, rule, options = {}) {
+    const text = input.trim();
+    const source = rule.caseSensitive ? text : text.toLowerCase();
+    const lineCount = text ? text.split(/\n+/).length : 0;
+    const normalize = (value) => (rule.caseSensitive ? value : value.toLowerCase());
+    if (rule.hasThreadId !== undefined && rule.hasThreadId !== Boolean(options.threadId)) {
+        return false;
+    }
+    if (rule.minLength !== undefined && text.length < rule.minLength) {
+        return false;
+    }
+    if (rule.maxLength !== undefined && text.length > rule.maxLength) {
+        return false;
+    }
+    if (rule.minLines !== undefined && lineCount < rule.minLines) {
+        return false;
+    }
+    if (rule.maxLines !== undefined && lineCount > rule.maxLines) {
+        return false;
+    }
+    if (rule.equals && !rule.equals.some((candidate) => source === normalize(candidate.trim()))) {
+        return false;
+    }
+    if (rule.startsWith && !rule.startsWith.some((candidate) => source.startsWith(normalize(candidate.trim())))) {
+        return false;
+    }
+    if (rule.contains && !rule.contains.some((candidate) => source.includes(normalize(candidate.trim())))) {
+        return false;
+    }
+    if (rule.regex && !rule.regex.some((pattern) => new RegExp(pattern, rule.caseSensitive ? undefined : "i").test(text))) {
+        return false;
+    }
+    return true;
+}
 export function resolvePromptValue(promptConfig) {
     if (typeof promptConfig === "string" && promptConfig.trim()) {
         return promptConfig;
@@ -33,10 +135,14 @@ export function resolvePromptValue(promptConfig) {
     return undefined;
 }
 export function resolveRefId(ref) {
-    if (ref.startsWith("builtin/")) {
+    const [namespace, ...rest] = ref.split("/");
+    if (rest.length === 0) {
         return ref;
     }
-    return ref.split("/").slice(1).join("/");
+    if (["agent", "embedding-model", "mcp", "model", "object", "prompt", "runtime", "tool", "vector-store"].includes(namespace)) {
+        return rest.join("/");
+    }
+    return ref;
 }
 export function resolvePathList(refs, workspaceRoot, refList) {
     return refList.map((ref) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.37",
-  "description": "Agent Harness framework package",
+  "version": "0.0.39",
+  "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
   "main": "./dist/index.js",
@@ -50,7 +50,7 @@
   "scripts": {
     "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json && cp -R config dist/",
     "check": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run test/public-api.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/runtime-adapter-regressions.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts",
+    "test": "vitest run test/public-api.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/runtime-adapter-regressions.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts",
     "test:real-providers": "vitest run test/real-provider-harness.test.ts",
     "release:prepare": "npm version patch --no-git-tag-version && node ./scripts/sync-example-version.mjs",
     "release:pack": "npm pack --dry-run",