@botbotgo/agent-harness 0.0.353 → 0.0.354

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.353";
+export declare const AGENT_HARNESS_VERSION = "0.0.354";
 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.353";
+export const AGENT_HARNESS_VERSION = "0.0.354";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

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

@@ -23,6 +23,7 @@ const PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER = [
     "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");
+const NO_THINK_CONTROL_TOKEN = "/no_think";
 function readModelText(value) {
     if (typeof value === "string") {
         return value.trim();
@@ -455,16 +456,21 @@ function formatBoundToolInstruction(tool) {
         `Arguments JSON schema: ${JSON.stringify(schema)}`,
     ].filter(Boolean).join("\n");
 }
-function withPromptedJsonToolPrompt(input, tools) {
+function withPromptedJsonToolPrompt(input, tools, options = {}) {
     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, PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER].filter(Boolean).join("\n\n");
+    return [
+        options.suppressThinking ? NO_THINK_CONTROL_TOKEN : "",
+        systemContent,
+        prompt,
+        PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER,
+    ].filter(Boolean).join("\n\n");
 }
-function createPromptedJsonToolBindableModel(model, boundTools = []) {
+function createPromptedJsonToolBindableModel(model, boundTools = [], options = {}) {
     return new Proxy(model, {
         has(target, prop) {
             if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "withConfig") {
@@ -474,11 +480,11 @@ function createPromptedJsonToolBindableModel(model, boundTools = []) {
         },
         get(target, prop, receiver) {
             if (prop === "bindTools") {
-                return (tools) => createPromptedJsonToolBindableModel(target, tools);
+                return (tools) => createPromptedJsonToolBindableModel(target, tools, options);
             }
             if (prop === "invoke") {
                 return async (input, config) => {
-                    const rawResult = await target.invoke(boundTools.length > 0 ? withPromptedJsonToolPrompt(input, boundTools) : input, config);
+                    const rawResult = await target.invoke(boundTools.length > 0 ? withPromptedJsonToolPrompt(input, boundTools, options) : input, config);
                     if (boundTools.length === 0) {
                         return rawResult;
                     }
@@ -510,7 +516,7 @@ function createPromptedJsonToolBindableModel(model, boundTools = []) {
                 };
             }
             if (prop === "withConfig" && typeof target.withConfig === "function") {
-                return (config) => createPromptedJsonToolBindableModel(target.withConfig(config), boundTools);
+                return (config) => createPromptedJsonToolBindableModel(target.withConfig(config), boundTools, options);
             }
             const member = Reflect.get(target, prop, receiver);
             return typeof member === "function" ? member.bind(target) : member;
@@ -559,7 +565,7 @@ export async function createResolvedModel(model, modelResolver) {
         const { toolCallingMode, ...init } = model.init ?? {};
         const resolved = new ChatOllama({ model: model.model, ...init });
         if (toolCallingMode === "prompted-json") {
-            return createPromptedJsonToolBindableModel(resolved);
+            return createPromptedJsonToolBindableModel(resolved, [], { suppressThinking: init.think === false });
         }
         return createProviderToolMessageCompatModel(resolved);
     }

package/dist/runtime/adapter/resilience.js

@@ -42,6 +42,9 @@ export function isEmptyFinalAiMessageError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.toLowerCase().startsWith("empty_final_ai_message:");
 }
+function isRuntimeOperationTimeoutError(error) {
+    return typeof error === "object" && error !== null && error.name === "RuntimeOperationTimeoutError";
+}
 function isRetryableHttpStatus(status) {
     return typeof status === "number" && Number.isInteger(status) && status >= 500 && status <= 599;
 }
@@ -84,6 +87,9 @@ export function resolveProviderRetryPolicy(binding) {
     };
 }
 export function isRetryableProviderError(binding, error) {
+    if (isRuntimeOperationTimeoutError(error)) {
+        return false;
+    }
     if (isEmptyFinalAiMessageError(error)) {
         return true;
     }

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

@@ -57,6 +57,7 @@ export declare class AgentRuntimeAdapter {
         files?: Record<string, unknown>;
         memoryContext?: string;
     }): Promise<RequestResult>;
+    private tryDelegateWithCompactRouter;
     stream(binding: CompiledAgentBinding, input: MessageContent, sessionId: string, history?: TranscriptMessage[], options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;

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

@@ -1,7 +1,8 @@
 import path from "node:path";
 import { createAsyncSubAgentMiddleware, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
-import { wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { extractMessageText } from "../utils/message-content.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildDeepAgentSystemPromptWithCapabilityHierarchy, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
 import { resolveDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 import { EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION } from "./prompts/runtime-prompts.js";
@@ -21,7 +22,7 @@ export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths,
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
-import { getBindingAdapterKind, getBindingBuiltinToolsConfig, getBindingDeepAgentSubagents, getBindingExecutionParams, getBindingExecutionKind, getBindingFilesystemConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingSkills, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingBuiltinToolsConfig, getBindingDeepAgentSubagents, getBindingExecutionParams, getBindingExecutionKind, getBindingFilesystemConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingSkills, getBindingSubagents, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 class DelegatedExecutionNoToolEvidenceError extends Error {
     constructor(agentId) {
         super(`Delegated agent ${agentId} completed without tool execution evidence.`);
@@ -39,6 +40,77 @@ function hasDelegatedExecutionToolEvidence(result) {
 function shouldUseConfigurableDeepAgentAssembly(binding) {
     return getBindingExecutionKind(binding) === "deepagent";
 }
+function readModelText(value) {
+    if (typeof value === "string") {
+        return value.trim();
+    }
+    if (typeof value !== "object" || value === null) {
+        return "";
+    }
+    const content = value.content;
+    if (typeof content === "string") {
+        return content.trim();
+    }
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === "string")
+                return part;
+            if (typeof part === "object" && part !== null && typeof part.text === "string") {
+                return part.text;
+            }
+            return "";
+        })
+            .join("")
+            .trim();
+    }
+    return "";
+}
+function parseFirstJsonObject(value) {
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaping = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+            }
+            else if (char === "\\") {
+                escaping = true;
+            }
+            else if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+            continue;
+        }
+        if (char === "{") {
+            if (depth === 0) {
+                start = index;
+            }
+            depth += 1;
+            continue;
+        }
+        if (char === "}" && depth > 0) {
+            depth -= 1;
+            if (depth === 0 && start >= 0) {
+                return tryParseJson(value.slice(start, index + 1));
+            }
+        }
+    }
+    return null;
+}
+function isDelegationOnlyDeepAgentBinding(binding) {
+    return isDeepAgentBinding(binding)
+        && getBindingSubagents(binding).length > 0
+        && getBindingPrimaryTools(binding).length === 0
+        && getBindingSkills(binding).length === 0;
+}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -557,6 +629,36 @@ export class AgentRuntimeAdapter {
                 },
             };
         }
+        const compactDelegation = await this.tryDelegateWithCompactRouter(binding, input, sessionId, requestId, {
+            ...options,
+            sessionId,
+            requestId,
+        });
+        if (compactDelegation) {
+            const output = typeof compactDelegation.toolOutput === "string"
+                ? compactDelegation.toolOutput
+                : JSON.stringify(compactDelegation.toolOutput);
+            const delegatedToolResults = Array.isArray(compactDelegation.delegatedResult?.metadata?.executedToolResults)
+                ? compactDelegation.delegatedResult.metadata.executedToolResults
+                : [];
+            return {
+                sessionId,
+                requestId,
+                agentId: binding.agent.id,
+                state: "completed",
+                output,
+                finalMessageText: output,
+                metadata: {
+                    executedToolResults: [
+                        {
+                            toolName: "task",
+                            output: compactDelegation.toolOutput,
+                        },
+                        ...delegatedToolResults,
+                    ],
+                },
+            };
+        }
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
                 const runnable = await this.create(activeBinding, { sessionId });
@@ -612,6 +714,74 @@ export class AgentRuntimeAdapter {
             return invokeRequest();
         }
     }
+    async tryDelegateWithCompactRouter(binding, input, sessionId, requestId, options = {}) {
+        if (!isDelegationOnlyDeepAgentBinding(binding)) {
+            return null;
+        }
+        if (!this.options.bindingResolver) {
+            return null;
+        }
+        const primaryModel = getBindingPrimaryModel(binding);
+        if (!primaryModel) {
+            return null;
+        }
+        const requestText = extractMessageText(input).trim();
+        if (!requestText) {
+            return null;
+        }
+        const subagents = getBindingSubagents(binding);
+        const subagentCatalog = subagents
+            .map((subagent) => `- ${subagent.name}: ${subagent.description}`)
+            .join("\n");
+        const prompt = [
+            primaryModel.init?.think === false ? "/no_think" : "",
+            "You are selecting a subagent for a delegation-only agent.",
+            "Choose exactly one listed subagent when it can responsibly handle the request.",
+            "Return only JSON with this shape:",
+            "{\"subagent_type\":\"<listed subagent name>\"}",
+            "If no listed subagent can handle the request, return only:",
+            "{\"status\":\"refused\",\"reason\":\"No configured subagent can handle the request.\"}",
+            "Available subagents:",
+            subagentCatalog,
+            "User request:",
+            requestText,
+        ].filter(Boolean).join("\n\n");
+        const model = await this.resolveModel(primaryModel);
+        if (typeof model.invoke !== "function") {
+            return null;
+        }
+        const raw = await this.withTimeout(() => model.invoke(prompt, resolveLangChainInvocationConfig(binding, {
+            sessionId,
+            requestId,
+            context: options.context,
+            toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
+                ...options,
+                sessionId,
+                requestId,
+            }),
+        })), resolveBindingTimeout(binding), "delegation router invoke", "invoke");
+        const parsed = parseFirstJsonObject(readModelText(raw));
+        if (typeof parsed !== "object" || parsed === null) {
+            return null;
+        }
+        const subagentType = typeof parsed.subagent_type === "string"
+            ? parsed.subagent_type
+            : "";
+        if (!subagents.some((subagent) => subagent.name === subagentType)) {
+            return null;
+        }
+        const selectedBinding = this.options.bindingResolver(subagentType);
+        if (!selectedBinding) {
+            return null;
+        }
+        const delegatedResult = await this.invoke(selectedBinding, requestText, sessionId, `${requestId}:${subagentType}`, undefined, [], {
+            context: options.context,
+            state: options.state,
+            files: options.files,
+            memoryContext: options.memoryContext,
+        });
+        return { toolOutput: delegatedResult.output, delegatedResult };
+    }
     async *stream(binding, input, sessionId, history = [], options = {}) {
         const directListing = await this.tryHandleDirectWorkspaceListing(binding, input, {
             ...options,
@@ -630,6 +800,25 @@ export class AgentRuntimeAdapter {
             };
             return;
         }
+        const compactDelegation = await this.tryDelegateWithCompactRouter(binding, input, sessionId, options.requestId ?? sessionId, {
+            ...options,
+            sessionId,
+            requestId: options.requestId,
+        });
+        if (compactDelegation) {
+            yield {
+                kind: "tool-result",
+                toolName: "task",
+                output: compactDelegation.toolOutput,
+            };
+            yield {
+                kind: "content",
+                content: typeof compactDelegation.toolOutput === "string"
+                    ? compactDelegation.toolOutput
+                    : JSON.stringify(compactDelegation.toolOutput),
+            };
+            return;
+        }
         const invokeTimeoutMs = resolveBindingTimeout(binding);
         const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
         const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;

package/dist/runtime/harness/run/stream-run.js

@@ -517,6 +517,15 @@ function createProfileStepCommentary(step) {
     if (step.kind === "memory") {
         return `Checking memory ${name}.`;
     }
+    if (step.kind === "agent" && step.action === "invoke") {
+        return "Running model invocation.";
+    }
+    if (step.kind === "agent" && step.action === "start") {
+        return "Starting runtime stream.";
+    }
+    if (step.kind === "agent" && step.action === "startup") {
+        return `Preparing ${name}.`;
+    }
     return null;
 }
 function isOpenAICompatibleStreamingCompatibilityError(binding, error) {

package/package.json

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