@botbotgo/agent-harness 0.0.349 → 0.0.351

package/dist/package-version.d.ts

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

package/dist/resources/prompts/runtime/delegation-only-recovery.md

@@ -0,0 +1,8 @@
+A previous response ended without delegating work through the task tool.
+
+This agent has configured subagents and no direct execution skills or raw tools for local specialist work. Your next response must do exactly one of these:
+
+1. If the request fits any listed subagent description, call the task tool with the exact configured subagent_type and preserve the user's original request in the task description.
+2. If no listed subagent can responsibly handle the request, return a final refusal that says the configured subagents do not cover the request.
+
+Do not answer locally, do not merely announce that you will delegate, and do not invent or mention tools that are not listed.

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

@@ -4,6 +4,197 @@ import { finalizeRequestResult } from "../invocation-result.js";
 import { invokeRuntimeWithLocalTools } from "./invoke-runtime.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../upstream-configurable-keys.js";
+import { extractVisibleOutput, tryParseJson } from "../../parsing/output-parsing.js";
+function readBindingExecutionParams(binding) {
+    const params = binding.execution?.params ?? binding.deepAgentParams ?? binding.langchainAgentParams;
+    return {
+        tools: Array.isArray(params?.tools) ? params.tools : [],
+        subagents: Array.isArray(params?.subagents)
+            ? (params.subagents ?? [])
+            : [],
+    };
+}
+function isDelegationOnlyBinding(binding) {
+    const { tools, subagents } = readBindingExecutionParams(binding);
+    const agent = binding.agent;
+    const configuredSubagents = [
+        ...subagents,
+        ...(agent?.subagentRefs ?? []),
+        ...(agent?.subagentPathRefs ?? []),
+        ...(agent?.asyncSubagents ?? []),
+    ];
+    const configuredTools = [
+        ...tools,
+        ...(agent?.toolRefs ?? []),
+        ...(agent?.toolBindings ?? []),
+    ];
+    const skillRefs = agent?.skillPathRefs ?? [];
+    return configuredSubagents.length > 0 && configuredTools.length === 0 && skillRefs.length === 0;
+}
+function hasTaskDelegationEvidence(executedToolResults) {
+    return executedToolResults.some((item) => item.toolName === "task");
+}
+function hasNativeTaskDelegationIntent(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return value.some((item) => hasNativeTaskDelegationIntent(item));
+    }
+    const typed = value;
+    if (typed.name === "task") {
+        return true;
+    }
+    return hasNativeTaskDelegationIntent(typed.tool_calls) || hasNativeTaskDelegationIntent(typed.messages);
+}
+function readStructuredToolCall(value) {
+    const text = typeof value === "string" ? value.trim() : "";
+    const parsed = text ? (tryParseJson(text) ?? extractFirstJsonObject(text)) : value;
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return null;
+    }
+    const typed = parsed;
+    const nameCandidate = typed.name ?? typed.tool;
+    const name = typeof nameCandidate === "string" ? nameCandidate.trim() : "";
+    if (!name) {
+        return null;
+    }
+    const argsCandidate = typed.arguments ?? typed.args ?? typed.parameters ?? {};
+    const args = typeof argsCandidate === "object" && argsCandidate !== null && !Array.isArray(argsCandidate)
+        ? argsCandidate
+        : {};
+    return { name, args };
+}
+function extractFirstJsonObject(text) {
+    let start = -1;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (start < 0) {
+            if (char === "{") {
+                start = index;
+                depth = 1;
+            }
+            continue;
+        }
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = inString;
+            continue;
+        }
+        if (char === "\"") {
+            inString = !inString;
+            continue;
+        }
+        if (inString) {
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+            continue;
+        }
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                const parsed = tryParseJson(text.slice(start, index + 1));
+                if (parsed) {
+                    return parsed;
+                }
+                start = -1;
+            }
+        }
+    }
+    return null;
+}
+async function replayStructuredTaskToolCall(input) {
+    if (hasTaskDelegationEvidence(input.invocation.executedToolResults)) {
+        return input.invocation;
+    }
+    const visibleOutput = extractVisibleOutput(input.invocation.result);
+    const toolCall = readStructuredToolCall(visibleOutput);
+    if (toolCall?.name !== "task") {
+        return input.invocation;
+    }
+    const taskTool = input.builtinExecutableTools.get("task");
+    if (!taskTool) {
+        return input.invocation;
+    }
+    try {
+        const output = await taskTool.invoke(toolCall.args, input.toolRuntimeContext);
+        return {
+            result: { output },
+            executedToolResults: [
+                ...input.invocation.executedToolResults,
+                { toolName: "task", output },
+            ],
+        };
+    }
+    catch (error) {
+        const output = error instanceof Error ? error.message : String(error);
+        return {
+            result: { output },
+            executedToolResults: [
+                ...input.invocation.executedToolResults,
+                { toolName: "task", output, isError: true },
+            ],
+        };
+    }
+}
+function formatDelegationSubagentCatalog(binding) {
+    const { subagents } = readBindingExecutionParams(binding);
+    return subagents
+        .map((subagent) => {
+        if (typeof subagent !== "object" || subagent === null) {
+            return "";
+        }
+        const typed = subagent;
+        const name = typeof typed.name === "string" ? typed.name.trim() : "";
+        if (!name) {
+            return "";
+        }
+        const description = typeof typed.description === "string" ? typed.description.trim() : "";
+        return description ? `- ${name}: ${description}` : `- ${name}`;
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function buildDelegationOnlyRecoveryInstruction(binding, input) {
+    const subagentCatalog = formatDelegationSubagentCatalog(binding) || "(none)";
+    return [
+        "/no_think",
+        "Runtime correction: this agent is delegation-only.",
+        "Return exactly one JSON object and no prose.",
+        "Use this shape when a listed subagent fits:",
+        "{\"name\":\"task\",\"arguments\":{\"subagent_type\":\"<listed name>\",\"description\":\"<original request>\"}}",
+        "Use this shape only when no listed subagent fits:",
+        "{\"status\":\"refused\",\"reason\":\"No configured subagent can handle the request.\"}",
+        "Listed subagents:",
+        subagentCatalog,
+        "Original request:",
+        JSON.stringify(input),
+    ].join("\n");
+}
+function appendUserRecoveryInstruction(input, instruction) {
+    const content = [
+        "Runtime correction:",
+        instruction,
+    ].join("\n\n");
+    if (Array.isArray(input)) {
+        return [...input, { role: "user", content }];
+    }
+    if (typeof input === "object" && input && Array.isArray(input.messages)) {
+        return {
+            ...input,
+            messages: [...(input.messages), { role: "user", content }],
+        };
+    }
+    return input;
+}
 export async function executeRequestInvocation(options) {
     const history = options.history ?? [];
     const invokeOptions = options.invokeOptions ?? {};
@@ -24,9 +215,9 @@ export async function executeRequestInvocation(options) {
         },
     });
     const builtinExecutableTools = await options.resolveBuiltinMiddlewareTools(options.binding, invokeOptions);
-    const localOrUpstreamInvocation = await invokeRuntimeWithLocalTools({
+    const invokeOnce = (activeRequest) => invokeRuntimeWithLocalTools({
         binding: options.binding,
-        request,
+        request: activeRequest,
         resumePayload: options.resumePayload,
         primaryTools,
         defersToUpstreamHitlExecution,
@@ -36,6 +227,20 @@ export async function executeRequestInvocation(options) {
         callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
         toolRuntimeContext: invokeOptions.toolRuntimeContext,
     });
+    let localOrUpstreamInvocation = await invokeOnce(request);
+    if (options.resumePayload === undefined
+        && isDelegationOnlyBinding(options.binding)
+        && !hasTaskDelegationEvidence(localOrUpstreamInvocation.executedToolResults)
+        && !hasNativeTaskDelegationIntent(localOrUpstreamInvocation.result)) {
+        const delegationRecoveryInstruction = buildDelegationOnlyRecoveryInstruction(options.binding, options.input);
+        const recoveredRequest = appendUserRecoveryInstruction(request, delegationRecoveryInstruction);
+        const recoveredInvocation = await invokeOnce(recoveredRequest);
+        localOrUpstreamInvocation = await replayStructuredTaskToolCall({
+            invocation: recoveredInvocation,
+            builtinExecutableTools: builtinExecutableTools,
+            toolRuntimeContext: invokeOptions.toolRuntimeContext,
+        });
+    }
     const result = localOrUpstreamInvocation.result;
     const executedToolResults = [...localOrUpstreamInvocation.executedToolResults];
     if (!result) {

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

@@ -1,5 +1,5 @@
 import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
-import { DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION } from "../../prompts/runtime-prompts.js";
+import { DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION, DELEGATION_ONLY_RECOVERY_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { buildRawModelMessages } from "../model/message-assembly.js";
 import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "../stream-event-projection.js";
@@ -85,6 +85,7 @@ function buildExecutionRecoveryEvidence(params) {
         hasOnlyPlaceholderTaskCompletion: projectionState.emittedSuccessfulTaskResult
             && projectionState.emittedPlaceholderTaskResult
             && !projectionState.emittedDelegatedTerminalOutput,
+        hasSuccessfulTaskToolEvidence: projectionState.emittedSuccessfulTaskResult || hasSuccessfulTaskToolEvidence(executedToolResults),
     };
 }
 function hasUnresolvedExecution(evidence) {
@@ -98,6 +99,45 @@ function hasMissingDelegatedExecutionEvidence(evidence) {
 function hasMissingDelegatedFindings(evidence) {
     return evidence.hasDelegatedAgentWithConfiguredTools && evidence.hasOnlyPlaceholderTaskCompletion;
 }
+function readBindingExecutionParams(binding) {
+    const params = binding.execution?.params ?? binding.deepAgentParams ?? binding.langchainAgentParams;
+    return {
+        tools: Array.isArray(params?.tools) ? params.tools : [],
+        subagents: Array.isArray(params?.subagents)
+            ? (params.subagents ?? [])
+            : [],
+    };
+}
+function isDelegationOnlyBinding(binding) {
+    const { tools, subagents } = readBindingExecutionParams(binding);
+    const agent = binding.agent;
+    const configuredSubagents = [
+        ...subagents,
+        ...(agent?.subagentRefs ?? []),
+        ...(agent?.subagentPathRefs ?? []),
+        ...(agent?.asyncSubagents ?? []),
+    ];
+    const configuredTools = [
+        ...tools,
+        ...(agent?.toolRefs ?? []),
+        ...(agent?.toolBindings ?? []),
+    ];
+    const skillRefs = agent?.skillPathRefs ?? [];
+    return configuredSubagents.length > 0 && configuredTools.length === 0 && skillRefs.length === 0;
+}
+function hasDelegationEvidence(evidence) {
+    return (evidence.hasSuccessfulTaskToolEvidence
+        || evidence.hasOpenTaskDelegation
+        || evidence.hasFailedTaskDelegation
+        || evidence.hasDelegatedAgentWithConfiguredTools
+        || evidence.hasDelegatedExecutionToolEvidence);
+}
+function resolveDelegationOnlyRecoveryInstruction(binding, evidence) {
+    if (!isDelegationOnlyBinding(binding) || hasDelegationEvidence(evidence)) {
+        return null;
+    }
+    return DELEGATION_ONLY_RECOVERY_INSTRUCTION;
+}
 function isRuntimeFailureOutput(value) {
     return value.trim().startsWith("runtime_error=");
 }
@@ -328,7 +368,7 @@ export async function* streamRuntimeExecution(options) {
                 });
             throw error;
         }
-        if (!options.forceInvokeFallback && typeof runnable.streamEvents === "function") {
+        if (!options.forceInvokeFallback && !isDelegationOnlyBinding(options.binding) && typeof runnable.streamEvents === "function") {
             const streamEventsStart = startProfileStep({
                 id: "profile:agent:stream-events-start",
                 kind: "agent",
@@ -423,13 +463,15 @@ export async function* streamRuntimeExecution(options) {
                                 hasToolResultEvidence: terminalExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
                             })
                             : null;
+                        const terminalDelegationOnlyRecoveryInstruction = resolveDelegationOnlyRecoveryInstruction(options.binding, terminalExecutionEvidence);
                         if (!shouldDeferStreamContent()
                             && !terminalExecutionEvidence.hasIncompletePlanState
                             && !terminalExecutionEvidence.hasFailedTaskDelegation
                             && !terminalExecutionEvidence.hasOpenTaskDelegation
                             && !hasMissingDelegatedExecutionEvidence(terminalExecutionEvidence)
                             && !hasMissingDelegatedFindings(terminalExecutionEvidence)
-                            && !terminalMissingPlanRecoveryInstruction) {
+                            && !terminalMissingPlanRecoveryInstruction
+                            && !terminalDelegationOnlyRecoveryInstruction) {
                             if (deferredStreamContent.length > 0) {
                                 yield* flushDeferredStreamContent();
                             }
@@ -462,6 +504,7 @@ export async function* streamRuntimeExecution(options) {
             }
             const streamedExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState });
             const streamedDelegatedRecoveryInstruction = resolveDelegatedExecutionRecoveryInstruction(streamedExecutionEvidence);
+            const streamedDelegationOnlyRecoveryInstruction = resolveDelegationOnlyRecoveryInstruction(options.binding, streamedExecutionEvidence);
             const delegatedExecutionRecoveryInstruction = !emittedUnsafeStreamSideEffects || streamedDelegatedRecoveryInstruction
                 ? streamedDelegatedRecoveryInstruction
                 : null;
@@ -493,6 +536,7 @@ export async function* streamRuntimeExecution(options) {
                 : delegatedExecutionRecoveryInstruction
                     ?? streamedRuntimeFailureRecoveryInstruction
                     ?? missingPlanRecoveryInstruction
+                    ?? streamedDelegationOnlyRecoveryInstruction
                     ?? executionWithoutToolEvidenceInstruction;
             if (retryInstruction) {
                 let retried;
@@ -565,7 +609,10 @@ export async function* streamRuntimeExecution(options) {
                 return;
             }
         }
-        if (!options.forceInvokeFallback && options.isLangChainBinding(options.binding) && typeof runnable.stream === "function") {
+        if (!options.forceInvokeFallback
+            && options.isLangChainBinding(options.binding)
+            && !isDelegationOnlyBinding(options.binding)
+            && typeof runnable.stream === "function") {
             const streamStart = startProfileStep({
                 id: "profile:agent:stream-start",
                 kind: "agent",
@@ -705,7 +752,9 @@ export async function* streamRuntimeExecution(options) {
                 hasToolResultEvidence: invokeExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
             })
             : null;
+        const invokeFallbackDelegationOnlyRecoveryInstruction = resolveDelegationOnlyRecoveryInstruction(options.binding, invokeExecutionEvidence);
         const effectiveInvokeFallbackRecoveryInstruction = invokeFallbackMissingPlanRecoveryInstruction
+            ?? invokeFallbackDelegationOnlyRecoveryInstruction
             ?? 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);

package/dist/runtime/adapter/middleware-assembly.js

@@ -9,7 +9,7 @@ import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { UPSTREAM_SESSION_CONFIG_KEY } from "./upstream-configurable-keys.js";
 import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingBuiltinToolsConfig, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingDeepAgentSubagents, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
-import { DEFAULT_SUBAGENT_PROMPT } from "../prompts/runtime-prompts.js";
+import { DEFAULT_SUBAGENT_PROMPT, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 import { createContextHygieneMiddleware } from "./middleware/context-hygiene.js";
 const INVALID_TOOL_MESSAGE_BLOCK_TYPES = new Set(["tool_use", "thinking", "redacted_thinking"]);
 function extractDeepAgentTaskContent(result) {
@@ -32,6 +32,92 @@ function extractDeepAgentTaskContent(result) {
     }
     return undefined;
 }
+function readMessageType(message) {
+    if (typeof message !== "object" || message === null) {
+        return "";
+    }
+    if (typeof message._getType === "function") {
+        const typeName = message._getType();
+        return typeof typeName === "string" ? typeName : "";
+    }
+    const typed = message;
+    if (typeof typed.type === "string") {
+        return typed.type;
+    }
+    const kwargs = typeof typed.kwargs === "object" && typed.kwargs !== null
+        ? typed.kwargs
+        : undefined;
+    if (typeof kwargs?.type === "string") {
+        return kwargs.type;
+    }
+    const lcKwargs = typeof typed.lc_kwargs === "object" && typed.lc_kwargs !== null
+        ? typed.lc_kwargs
+        : undefined;
+    return typeof lcKwargs?.type === "string" ? lcKwargs.type : "";
+}
+function readMessageName(message) {
+    if (typeof message !== "object" || message === null) {
+        return "";
+    }
+    const typed = message;
+    if (typeof typed.name === "string") {
+        return typed.name;
+    }
+    const kwargs = typeof typed.kwargs === "object" && typed.kwargs !== null
+        ? typed.kwargs
+        : undefined;
+    if (typeof kwargs?.name === "string") {
+        return kwargs.name;
+    }
+    const lcKwargs = typeof typed.lc_kwargs === "object" && typed.lc_kwargs !== null
+        ? typed.lc_kwargs
+        : undefined;
+    return typeof lcKwargs?.name === "string" ? lcKwargs.name : "";
+}
+function readMessages(result) {
+    if (typeof result !== "object" || result === null) {
+        return [];
+    }
+    const messages = result.messages;
+    return Array.isArray(messages) ? messages : [];
+}
+function readToolNames(tools) {
+    if (!Array.isArray(tools)) {
+        return new Set();
+    }
+    return new Set(tools
+        .map((tool) => {
+        if (typeof tool !== "object" || tool === null) {
+            return "";
+        }
+        const name = tool.name;
+        return typeof name === "string" ? name : "";
+    })
+        .filter((name) => name.length > 0));
+}
+function hasSubagentExecutionToolEvidence(result, resolvedTools, configuredTools) {
+    const requiredToolNames = new Set([
+        ...readToolNames(configuredTools),
+        ...readToolNames(resolvedTools),
+    ]);
+    if (requiredToolNames.size === 0) {
+        return true;
+    }
+    for (const message of readMessages(result)) {
+        const typeName = readMessageType(message);
+        if (typeName !== "tool" && typeName !== "ToolMessage") {
+            continue;
+        }
+        const name = readMessageName(message);
+        if (name === "write_todos" || name === "read_todos") {
+            continue;
+        }
+        if (requiredToolNames.has(name)) {
+            return true;
+        }
+    }
+    return false;
+}
 export function extractSubagentRequestText(state) {
     if (!isRecord(state)) {
         return "";
@@ -257,6 +343,7 @@ export async function invokeBuiltinTaskTool(input) {
     const builtinBackend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
     const resolvedSubagents = await input.resolveSubagents(compiledSubagents, input.binding);
     const selectedSubagent = resolvedSubagents.find((subagent) => subagent.name === subagentType);
+    const selectedCompiledSubagent = compiledSubagents.find((subagent) => subagent.name === subagentType);
     if (!selectedSubagent) {
         const allowed = resolvedSubagents.map((subagent) => subagent.name);
         throw new Error(`Error: invoked agent of type ${subagentType}, the only allowed types are ${allowed.map((name) => `\`${name}\``).join(", ")}`);
@@ -282,9 +369,16 @@ export async function invokeBuiltinTaskTool(input) {
         configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: `${input.binding.agent.id}:builtin-task` },
         ...(input.options?.context ? { context: input.options.context } : {}),
     };
-    const result = await runnable.invoke({
-        messages: [new HumanMessage({ content: description })],
+    const invokeSubagent = (content) => runnable.invoke({
+        messages: [new HumanMessage({ content })],
     }, invokeConfig);
+    let result = await invokeSubagent(description);
+    if (!hasSubagentExecutionToolEvidence(result, resolvedSubagentTools, selectedCompiledSubagent?.tools)) {
+        result = await invokeSubagent([description, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"));
+        if (!hasSubagentExecutionToolEvidence(result, resolvedSubagentTools, selectedCompiledSubagent?.tools)) {
+            throw new Error(`Delegated agent ${selectedSubagent.name} completed without tool execution evidence.`);
+        }
+    }
     const structuredResponse = typeof result === "object" && result !== null && "structuredResponse" in result
         ? result.structuredResponse
         : undefined;
@@ -315,11 +409,23 @@ export async function invokeBuiltinTaskTool(input) {
 }
 export async function resolveBuiltinMiddlewareTools(input) {
     const backend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
+    const params = input.binding.execution?.params ?? input.binding.deepAgentParams ?? input.binding.langchainAgentParams;
+    const configuredSubagents = [
+        ...(Array.isArray(params?.subagents)
+            ? (params.subagents ?? [])
+            : []),
+        ...(input.binding.agent.subagentRefs ?? []),
+        ...(input.binding.agent.subagentPathRefs ?? []),
+        ...(input.binding.agent.asyncSubagents ?? []),
+    ];
+    const includeTaskTool = configuredSubagents.length > 0;
     const tools = (await createBuiltinMiddlewareTools(backend, {
-        includeTaskTool: false,
+        includeTaskTool,
         workspaceRoot: input.binding.harnessRuntime.workspaceRoot,
         toolRuntimeContext: input.options?.toolRuntimeContext,
-        invokeTaskTool: undefined,
+        invokeTaskTool: includeTaskTool
+            ? (toolInput) => input.invokeBuiltinTaskTool(input.binding, toolInput, input.options)
+            : undefined,
     }));
     const builtinTools = getBindingBuiltinToolsConfig(input.binding) ?? {};
     if (builtinTools.todos === false) {

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

@@ -299,6 +299,10 @@ function extractToolCallPayload(text) {
     if (direct) {
         return direct;
     }
+    const firstJsonObject = extractFirstJsonObjectPayload(trimmed);
+    if (firstJsonObject) {
+        return firstJsonObject;
+    }
     const fenced = extractFencePayload(trimmed);
     if (fenced) {
         const parsed = tryParseJson(fenced);
@@ -326,6 +330,52 @@ function extractToolCallPayload(text) {
     }
     return null;
 }
+function extractFirstJsonObjectPayload(text) {
+    let start = -1;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (start < 0) {
+            if (char === "{") {
+                start = index;
+                depth = 1;
+            }
+            continue;
+        }
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = inString;
+            continue;
+        }
+        if (char === "\"") {
+            inString = !inString;
+            continue;
+        }
+        if (inString) {
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+            continue;
+        }
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                const parsed = tryParseJson(text.slice(start, index + 1));
+                if (parsed) {
+                    return parsed;
+                }
+                start = -1;
+            }
+        }
+    }
+    return null;
+}
 function extractFencePayload(text) {
     const start = text.indexOf("```");
     if (start < 0) {

package/dist/runtime/adapter/resilience.js

@@ -41,6 +41,21 @@ function isEmptyFinalAiMessageError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.toLowerCase().startsWith("empty_final_ai_message:");
 }
+function isRetryableHttpStatus(status) {
+    return typeof status === "number" && Number.isInteger(status) && status >= 500 && status <= 599;
+}
+function hasRetryableHttpStatus(error, seen = new Set()) {
+    if (typeof error !== "object" || error === null || seen.has(error)) {
+        return false;
+    }
+    seen.add(error);
+    const typed = error;
+    return isRetryableHttpStatus(typed.status)
+        || isRetryableHttpStatus(typed.statusCode)
+        || isRetryableHttpStatus(typed.status_code)
+        || isRetryableHttpStatus(typed.code)
+        || hasRetryableHttpStatus(typed.cause, seen);
+}
 export function resolveProviderRetryPolicy(binding) {
     const resilience = typeof binding.harnessRuntime.resilience === "object" && binding.harnessRuntime.resilience
         ? binding.harnessRuntime.resilience
@@ -71,6 +86,9 @@ export function isRetryableProviderError(binding, error) {
     if (isEmptyFinalAiMessageError(error)) {
         return true;
     }
+    if (hasRetryableHttpStatus(error)) {
+        return true;
+    }
     const message = error instanceof Error ? error.message : String(error);
     const normalized = message.toLowerCase();
     const { retryableMessages } = resolveProviderRetryPolicy(binding);

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

@@ -58,6 +58,7 @@ export function buildDeepAgentSystemPromptWithCapabilityHierarchy(input) {
     const skills = buildSkillCatalog(input.skills ?? []);
     const tools = input.tools ?? [];
     const hasNoConfiguredCapabilities = input.subagents.length === 0 && skills.length === 0 && tools.length === 0;
+    const isDelegationOnly = input.subagents.length > 0 && skills.length === 0 && tools.length === 0;
     const catalogPrompt = [
         "Capability selection hierarchy:",
         "1. If the current request fits an available subagent, delegate with the task tool before using local skills or raw tools.",
@@ -109,6 +110,16 @@ export function buildDeepAgentSystemPromptWithCapabilityHierarchy(input) {
                 "The only valid next step is for the workspace owner to attach an appropriate subagent, skill, or tool and retry.",
             ]
             : []),
+        ...(isDelegationOnly
+            ? [
+                "",
+                "Delegation-only mode:",
+                "This agent has specialist subagents but no direct execution skills or raw tools.",
+                "For any request that fits a listed subagent, the first assistant response must be a task tool call only.",
+                "Do not write a natural-language promise such as saying you will use a subagent. Actually call the task tool.",
+                "If no listed subagent fits, return a final refusal instead of answering locally.",
+            ]
+            : []),
         "",
     ].join("\n");
     return [basePrompt, catalogPrompt].filter((part) => typeof part === "string" && part.length > 0).join("\n\n");

package/dist/runtime/prompts/runtime-prompts.d.ts

@@ -12,6 +12,7 @@ export declare const EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION: string;
 export declare const EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION: string;
 export declare const AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION: string;
 export declare const DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION: string;
+export declare const DELEGATION_ONLY_RECOVERY_INSTRUCTION: string;
 export declare const INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION: string;
 export declare const WORKSPACE_RELATIVE_PATH_INSTRUCTION: string;
 export declare function renderDurableMemoryContextPrompt(memoryContext: string): string;

package/dist/runtime/prompts/runtime-prompts.js

@@ -15,6 +15,7 @@ export const EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION = readRuntimePrompt("execu
 export const EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION = readRuntimePrompt("execution-with-tool-evidence-retry");
 export const AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION = readRuntimePrompt("autonomous-investigation-recovery");
 export const DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION = readRuntimePrompt("delegated-task-failure-recovery");
+export const DELEGATION_ONLY_RECOVERY_INSTRUCTION = readRuntimePrompt("delegation-only-recovery");
 export const INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION = readRuntimePrompt("internal-runtime-spill-path");
 export const WORKSPACE_RELATIVE_PATH_INSTRUCTION = readRuntimePrompt("workspace-relative-path");
 export function renderDurableMemoryContextPrompt(memoryContext) {

package/package.json

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