@botbotgo/agent-harness 0.0.347 → 0.0.348

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.347";
+export declare const AGENT_HARNESS_VERSION = "0.0.348";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.347";
+export const AGENT_HARNESS_VERSION = "0.0.348";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/resource/backend/workspace-scoped-backend.d.ts

@@ -1,15 +1,20 @@
 import { CompositeBackend } from "deepagents";
 import type { RuntimeAdapterOptions, WorkspaceBundle } from "../../contracts/types.js";
-export declare function normalizeWorkspaceScopedPath(rootDir: string, inputPath: string): string;
+export declare function normalizeWorkspaceScopedPath(rootDir: string, inputPath: string, options?: {
+    allowVirtualAbsolutePath?: boolean;
+}): string;
 export declare class WorkspaceScopedBackend {
     private readonly backend;
+    private readonly options;
     readonly id?: string;
     readonly cwd: string;
     readonly rootDir: string;
     readonly root: string;
     readonly virtualMode?: boolean;
     readonly execute?: (command: string) => Promise<unknown>;
-    constructor(backend: Record<string, unknown>, rootDir: string);
+    constructor(backend: Record<string, unknown>, rootDir: string, options?: {
+        allowVirtualAbsolutePath?: boolean;
+    });
     ls(filePath: string): unknown;
     read(filePath: string, offset?: number, limit?: number): unknown;
     readRaw(filePath: string): unknown;
@@ -25,7 +30,9 @@ declare class CompatibleCompositeBackend {
     readonly id?: string;
     readonly execute?: (command: string) => ReturnType<CompositeBackend["execute"]>;
     private readonly composite;
+    private readonly routePrefixes;
     constructor(defaultBackend: unknown, routes: Record<string, unknown>);
+    private normalizeCompositePath;
     ls(filePath: string): ReturnType<CompositeBackend["ls"]>;
     read(filePath: string, offset?: number, limit?: number): ReturnType<CompositeBackend["read"]>;
     readRaw(filePath: string): ReturnType<CompositeBackend["readRaw"]>;

package/dist/resource/backend/workspace-scoped-backend.js

@@ -30,7 +30,7 @@ function normalizeVirtualExecuteCommand(command, rootDir) {
         return `${prefix}${quote}${translatedPath}${quote}`;
     });
 }
-export function normalizeWorkspaceScopedPath(rootDir, inputPath) {
+export function normalizeWorkspaceScopedPath(rootDir, inputPath, options = {}) {
     if (typeof inputPath !== "string" || inputPath.length === 0 || !path.isAbsolute(inputPath)) {
         return inputPath;
     }
@@ -53,21 +53,26 @@ export function normalizeWorkspaceScopedPath(rootDir, inputPath) {
     if (normalizedInputPath === normalizedRootDir || normalizedInputPath.startsWith(`${normalizedRootDir}${path.sep}`)) {
         return path.relative(normalizedRootDir, normalizedInputPath) || ".";
     }
+    if (options.allowVirtualAbsolutePath === true) {
+        return inputPath.replace(/\/+/g, "/");
+    }
     throw new Error(`Path '${inputPath}' is outside the workspace root '${normalizedRootDir}'. Use a workspace-relative path instead.`);
 }
-function normalizeWorkspaceScopedNullablePath(rootDir, inputPath) {
-    return typeof inputPath === "string" ? normalizeWorkspaceScopedPath(rootDir, inputPath) : inputPath;
+function normalizeWorkspaceScopedNullablePath(rootDir, inputPath, options = {}) {
+    return typeof inputPath === "string" ? normalizeWorkspaceScopedPath(rootDir, inputPath, options) : inputPath;
 }
 export class WorkspaceScopedBackend {
     backend;
+    options;
     id;
     cwd;
     rootDir;
     root;
     virtualMode;
     execute;
-    constructor(backend, rootDir) {
+    constructor(backend, rootDir, options = {}) {
         this.backend = backend;
+        this.options = options;
         this.rootDir = path.resolve(rootDir);
         this.root = this.rootDir;
         this.cwd = this.rootDir;
@@ -78,34 +83,36 @@ export class WorkspaceScopedBackend {
             : undefined;
     }
     ls(filePath) {
-        return this.backend.ls(normalizeWorkspaceScopedPath(this.rootDir, filePath));
+        return this.backend.ls(normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options));
     }
     read(filePath, offset, limit) {
-        return this.backend.read(normalizeWorkspaceScopedPath(this.rootDir, filePath), offset, limit);
+        return this.backend.read(normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options), offset, limit);
     }
     readRaw(filePath) {
-        return this.backend.readRaw(normalizeWorkspaceScopedPath(this.rootDir, filePath));
+        return this.backend.readRaw(normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options));
     }
     grep(pattern, filePath, glob) {
-        return this.backend.grep(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath), glob);
+        return this.backend.grep(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath, this.options), glob);
     }
     grepRaw(pattern, filePath, glob) {
-        return this.backend.grepRaw(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath), glob);
+        return this.backend.grepRaw(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath, this.options), glob);
     }
     glob(pattern, filePath) {
-        return this.backend.glob(pattern, typeof filePath === "string" ? normalizeWorkspaceScopedPath(this.rootDir, filePath) : filePath);
+        return this.backend.glob(pattern, typeof filePath === "string" ? normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options) : filePath);
     }
     write(filePath, content) {
-        return this.backend.write(normalizeWorkspaceScopedPath(this.rootDir, filePath), content);
+        return this.backend.write(normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options), content);
     }
     edit(filePath, oldString, newString, replaceAll) {
-        return this.backend.edit(normalizeWorkspaceScopedPath(this.rootDir, filePath), oldString, newString, replaceAll);
+        return this.backend.edit(normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options), oldString, newString, replaceAll);
     }
     uploadFiles(files) {
         return this.backend.uploadFiles(files);
     }
     downloadFiles(paths) {
-        const normalizedPaths = Array.isArray(paths) ? paths.map((currentPath) => normalizeWorkspaceScopedPath(this.rootDir, currentPath)) : paths;
+        const normalizedPaths = Array.isArray(paths)
+            ? paths.map((currentPath) => normalizeWorkspaceScopedPath(this.rootDir, currentPath, this.options))
+            : paths;
         return this.backend.downloadFiles(normalizedPaths);
     }
 }
@@ -113,8 +120,10 @@ class CompatibleCompositeBackend {
     id;
     execute;
     composite;
+    routePrefixes;
     constructor(defaultBackend, routes) {
         this.composite = new CompositeBackend(defaultBackend, routes);
+        this.routePrefixes = Object.keys(routes).filter((route) => route.startsWith("/"));
         const sandboxLike = defaultBackend;
         if (typeof sandboxLike.id === "string" && typeof sandboxLike.execute === "function") {
             this.id = sandboxLike.id;
@@ -125,32 +134,43 @@ class CompatibleCompositeBackend {
                     : (command) => this.composite.execute(command);
         }
     }
+    normalizeCompositePath(filePath) {
+        if (!path.isAbsolute(filePath)) {
+            return filePath;
+        }
+        const normalized = filePath.replace(/\/+/g, "/");
+        if (this.routePrefixes.some((route) => normalized === route || normalized.startsWith(route))) {
+            return normalized;
+        }
+        return path.join(...normalized.split("/").filter(Boolean));
+    }
     ls(filePath) {
-        return this.composite.ls(filePath);
+        return this.composite.ls(this.normalizeCompositePath(filePath));
     }
     read(filePath, offset, limit) {
-        return this.composite.read(filePath, offset, limit);
+        return this.composite.read(this.normalizeCompositePath(filePath), offset, limit);
     }
     readRaw(filePath) {
-        return this.composite.readRaw(filePath);
+        return this.composite.readRaw(this.normalizeCompositePath(filePath));
     }
     grep(pattern, filePath, glob) {
-        return this.composite.grep(pattern, filePath ?? undefined, glob ?? undefined);
+        return this.composite.grep(pattern, filePath ? this.normalizeCompositePath(filePath) : undefined, glob ?? undefined);
     }
     glob(pattern, filePath) {
-        return this.composite.glob(pattern, filePath);
+        return this.composite.glob(pattern, filePath ? this.normalizeCompositePath(filePath) : filePath);
     }
     write(filePath, content) {
-        return this.composite.write(filePath, content);
+        return this.composite.write(this.normalizeCompositePath(filePath), content);
     }
     edit(filePath, oldString, newString, replaceAll) {
-        return this.composite.edit(filePath, oldString, newString, replaceAll);
+        return this.composite.edit(this.normalizeCompositePath(filePath), oldString, newString, replaceAll);
     }
     uploadFiles(files) {
         return this.composite.uploadFiles(files);
     }
     downloadFiles(paths) {
-        return this.composite.downloadFiles(paths);
+        const normalizedPaths = Array.isArray(paths) ? paths.map((currentPath) => this.normalizeCompositePath(currentPath)) : paths;
+        return this.composite.downloadFiles(normalizedPaths);
     }
 }
 function omitKind(config) {
@@ -289,7 +309,7 @@ export function createInlineBackendResolver(workspace) {
                         const routeKind = typeof routeConfig?.kind === "string" ? routeConfig.kind : "StoreBackend";
                         return [route, createInlineBackendInstance(workspace.workspaceRoot, routeKind, routeConfig, runtimeLike)];
                     }));
-                    return new WorkspaceScopedBackend(new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes), workspace.workspaceRoot);
+                    return new WorkspaceScopedBackend(new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes), workspace.workspaceRoot, { allowVirtualAbsolutePath: true });
                 }
                 default:
                     return unsupportedInlineBackend(kind);

package/dist/runtime/adapter/flow/stream-runtime.js

@@ -705,7 +705,8 @@ export async function* streamRuntimeExecution(options) {
                 hasToolResultEvidence: invokeExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
             })
             : null;
-        const effectiveInvokeFallbackRecoveryInstruction = invokeFallbackMissingPlanRecoveryInstruction ?? invokeFallbackRecoveryInstruction;
+        const effectiveInvokeFallbackRecoveryInstruction = invokeFallbackMissingPlanRecoveryInstruction
+            ?? invokeFallbackRecoveryInstruction;
         if (effectiveInvokeFallbackRecoveryInstruction) {
             const recovered = await options.invoke(options.applyToolRecoveryInstruction(options.binding, effectiveInvokeFallbackRecoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
             const recoveredToolResults = Array.isArray(recovered.metadata?.executedToolResults)

package/dist/runtime/adapter/model/model-providers.js

@@ -13,8 +13,16 @@ const NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION = [
     "If you need a tool, respond with only one JSON object.",
     'Use this exact shape: {"name":"tool_name","arguments":{"key":"value"}}',
     "Do not add markdown, prose, or code fences unless the output is wrapped inside <tool_call>...</tool_call>.",
+    "When the latest user message explicitly requests a tool call or provides a tool-call JSON object, call that tool instead of answering locally.",
+    "If the conversation already contains TOOL_RESULT for the requested work, answer from that result instead of repeating the same tool call.",
     "If no tool is needed, answer normally.",
 ].join("\n");
+const PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER = [
+    "Final tool-call rule:",
+    "If the correct next step is a tool call, return exactly one JSON object and no prose.",
+    "If a TOOL_RESULT is already present for the requested work, do not repeat that tool call; answer normally.",
+    'Shape: {"name":"tool_name","arguments":{}}',
+].join("\n");
 function readModelText(value) {
     if (typeof value === "string") {
         return value.trim();
@@ -175,6 +183,23 @@ function readToolMessageMetadata(value) {
                 : undefined;
     return { name, toolCallId };
 }
+function hasPriorToolResultForToolName(input, toolName) {
+    if (!toolName) {
+        return false;
+    }
+    if (Array.isArray(input)) {
+        return input.some((message) => {
+            if (mapMessageRole(message) !== "TOOL") {
+                return false;
+            }
+            return readToolMessageMetadata(message).name === toolName;
+        });
+    }
+    if (typeof input === "object" && input !== null && Array.isArray(input.messages)) {
+        return hasPriorToolResultForToolName(input.messages, toolName);
+    }
+    return false;
+}
 function normalizeReadFileToolContent(name, content) {
     if (name !== "read_file") {
         return content;
@@ -274,22 +299,75 @@ function extractToolCallPayload(text) {
     if (direct) {
         return direct;
     }
-    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1]?.trim();
+    const fenced = extractFencePayload(trimmed);
     if (fenced) {
         const parsed = tryParseJson(fenced);
         if (parsed) {
             return parsed;
         }
     }
-    const xml = trimmed.match(/<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/i)?.[1]?.trim();
+    const xml = extractTaggedContent(trimmed, "tool_call");
     if (xml) {
         const parsed = tryParseJson(xml);
         if (parsed) {
             return parsed;
         }
     }
+    const toolCallsXml = extractTaggedContent(trimmed, "tool_calls");
+    if (toolCallsXml) {
+        const parsed = tryParseJson(toolCallsXml);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    const codeBlock = extractToolCodePayload(trimmed);
+    if (codeBlock) {
+        return codeBlock;
+    }
     return null;
 }
+function extractFencePayload(text) {
+    const start = text.indexOf("```");
+    if (start < 0) {
+        return null;
+    }
+    const contentStart = text.indexOf("\n", start + 3);
+    const bodyStart = contentStart >= 0 ? contentStart + 1 : start + 3;
+    const end = text.indexOf("```", bodyStart);
+    if (end < 0) {
+        return null;
+    }
+    return text.slice(bodyStart, end).trim();
+}
+function extractTaggedContent(text, tagName) {
+    const lowerText = text.toLowerCase();
+    const openTag = `<${tagName}>`;
+    const closeTag = `</${tagName}>`;
+    const start = lowerText.indexOf(openTag);
+    if (start < 0) {
+        return null;
+    }
+    const bodyStart = start + openTag.length;
+    const end = lowerText.indexOf(closeTag, bodyStart);
+    if (end < 0) {
+        return null;
+    }
+    return text.slice(bodyStart, end).trim();
+}
+function extractToolCodePayload(text) {
+    const name = extractTaggedContent(text, "tool_code");
+    if (!name) {
+        return null;
+    }
+    const rawArgs = extractTaggedContent(text, "tool_args");
+    const parsedArgs = rawArgs ? tryParseJson(rawArgs.trim()) : null;
+    const args = typeof parsedArgs === "object" && parsedArgs !== null && !Array.isArray(parsedArgs)
+        ? parsedArgs
+        : Array.isArray(parsedArgs)
+            ? { args: parsedArgs }
+            : {};
+    return { name, arguments: args };
+}
 function normalizeParsedToolCall(payload) {
     if (typeof payload !== "object" || payload === null) {
         return null;
@@ -305,7 +383,9 @@ function normalizeParsedToolCall(payload) {
         return null;
     }
     const argsCandidate = typed.arguments ?? typed.args ?? typed.parameters ?? typed.input ?? functionPayload?.arguments ?? {};
-    const args = salvageToolArgs(argsCandidate) ?? {};
+    const args = Array.isArray(argsCandidate)
+        ? { args: argsCandidate }
+        : salvageToolArgs(argsCandidate) ?? {};
     return { name, args };
 }
 function formatBoundToolInstruction(tool) {
@@ -325,16 +405,16 @@ function formatBoundToolInstruction(tool) {
         `Arguments JSON schema: ${JSON.stringify(schema)}`,
     ].filter(Boolean).join("\n");
 }
-function withNodeLlamaCppToolPrompt(input, tools) {
+function withPromptedJsonToolPrompt(input, tools) {
     const toolInstructions = tools.map((tool) => formatBoundToolInstruction(tool)).filter((value) => Boolean(value));
     if (toolInstructions.length === 0) {
         return stringifyNodeLlamaCppInput(input);
     }
     const systemContent = `${NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION}\n\n${toolInstructions.join("\n\n")}`;
     const prompt = stringifyNodeLlamaCppInput(input);
-    return [systemContent, prompt].filter(Boolean).join("\n\n");
+    return [systemContent, prompt, PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER].filter(Boolean).join("\n\n");
 }
-function createNodeLlamaCppToolBindableModel(model, boundTools = []) {
+function createPromptedJsonToolBindableModel(model, boundTools = []) {
     return new Proxy(model, {
         has(target, prop) {
             if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "withConfig") {
@@ -344,11 +424,11 @@ function createNodeLlamaCppToolBindableModel(model, boundTools = []) {
         },
         get(target, prop, receiver) {
             if (prop === "bindTools") {
-                return (tools) => createNodeLlamaCppToolBindableModel(target, tools);
+                return (tools) => createPromptedJsonToolBindableModel(target, tools);
             }
             if (prop === "invoke") {
                 return async (input, config) => {
-                    const rawResult = await target.invoke(boundTools.length > 0 ? withNodeLlamaCppToolPrompt(input, boundTools) : input, config);
+                    const rawResult = await target.invoke(boundTools.length > 0 ? withPromptedJsonToolPrompt(input, boundTools) : input, config);
                     if (boundTools.length === 0) {
                         return rawResult;
                     }
@@ -357,6 +437,9 @@ function createNodeLlamaCppToolBindableModel(model, boundTools = []) {
                     if (!parsedToolCall) {
                         return rawResult;
                     }
+                    if (hasPriorToolResultForToolName(input, parsedToolCall.name)) {
+                        return rawResult;
+                    }
                     return new AIMessage({
                         content: "",
                         tool_calls: [{
@@ -377,7 +460,7 @@ function createNodeLlamaCppToolBindableModel(model, boundTools = []) {
                 };
             }
             if (prop === "withConfig" && typeof target.withConfig === "function") {
-                return (config) => createNodeLlamaCppToolBindableModel(target.withConfig(config), boundTools);
+                return (config) => createPromptedJsonToolBindableModel(target.withConfig(config), boundTools);
             }
             const member = Reflect.get(target, prop, receiver);
             return typeof member === "function" ? member.bind(target) : member;
@@ -409,7 +492,7 @@ async function createNodeLlamaCppModel(model) {
     }
     try {
         const { ChatLlamaCpp } = await import("@langchain/community/chat_models/llama_cpp");
-        return createNodeLlamaCppToolBindableModel(await ChatLlamaCpp.initialize({
+        return createPromptedJsonToolBindableModel(await ChatLlamaCpp.initialize({
             ...model.init,
             modelPath,
         }));
@@ -423,10 +506,23 @@ export async function createResolvedModel(model, modelResolver) {
         return modelResolver(model.id);
     }
     if (model.provider === "ollama") {
-        return createProviderToolMessageCompatModel(new ChatOllama({ model: model.model, ...model.init }));
+        const { toolCallingMode, ...init } = model.init ?? {};
+        const resolved = new ChatOllama({ model: model.model, ...init });
+        if (toolCallingMode === "prompted-json") {
+            return createPromptedJsonToolBindableModel(resolved);
+        }
+        return createProviderToolMessageCompatModel(resolved);
     }
     if (model.provider === "openai-compatible") {
-        return createProviderToolMessageCompatModel(new ChatOpenAI({ model: model.model, ...normalizeOpenAICompatibleInit(model.init) }));
+        const { toolCallingMode, ...init } = model.init ?? {};
+        const resolved = new ChatOpenAI({
+            model: model.model,
+            ...normalizeOpenAICompatibleInit(init),
+        });
+        if (toolCallingMode === "prompted-json") {
+            return createPromptedJsonToolBindableModel(resolved);
+        }
+        return createProviderToolMessageCompatModel(resolved);
     }
     if (model.provider === "openai") {
         return createProviderToolMessageCompatModel(new ChatOpenAI({ model: model.model, ...model.init }));

package/dist/workspace/framework-contract-validation.js

@@ -140,8 +140,12 @@ function validateAgentContract(agent, referencedSubagentIds, tools, issues) {
         if (hasTools) {
             addIssue(issues, "agent.orchestrator.mixed_tool_surface", `Delegating agent ${agent.id} defines both subagents and direct tools. Keep routing agents focused on delegation, and move execution tools to specialist agents.`);
         }
-        if (builtinTools?.modelExposed !== false) {
-            addIssue(issues, "agent.orchestrator.model_exposed_builtins", `Delegating agent ${agent.id} should set config.builtinTools.modelExposed: false so raw built-in tools do not compete with specialist routing.`);
+        const modelExposedBuiltins = builtinTools?.modelExposed;
+        const exposesOnlyTask = Array.isArray(modelExposedBuiltins)
+            && modelExposedBuiltins.length === 1
+            && modelExposedBuiltins[0] === "task";
+        if (modelExposedBuiltins !== false && !exposesOnlyTask) {
+            addIssue(issues, "agent.orchestrator.model_exposed_builtins", `Delegating agent ${agent.id} should expose only the task builtin or set config.builtinTools.modelExposed: false so raw built-in tools do not compete with specialist routing.`);
         }
         if (!systemPrompt?.trim()) {
             addIssue(issues, "agent.orchestrator.missing_prompt", `Delegating agent ${agent.id} should define a systemPrompt that explains decomposition, delegation, synthesis, and stop conditions.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.347",
+  "version": "0.0.348",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",