@botbotgo/agent-harness 0.0.38 → 0.0.40

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.38",
-  "description": "Agent Harness framework package",
+  "version": "0.0.40",
+  "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",