@botbotgo/agent-harness 0.0.338 → 0.0.341

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

@@ -1,102 +1,118 @@
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, StateBackend, } from "deepagents";
-import { createAgent, humanInTheLoopMiddleware } from "langchain";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { createMemoryMiddleware, createFilesystemMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, StateBackend, } from "deepagents";
+import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
 import { createBuiltinMiddlewareTools } from "./tool/builtin-middleware-tools.js";
 import { compileInterruptOn } from "./tool/interrupt-policy.js";
 import { extractToolFallbackContext, extractVisibleOutput } from "../parsing/output-parsing.js";
 import { isRecord } from "../../utils/object.js";
 import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { UPSTREAM_SESSION_CONFIG_KEY } from "./upstream-configurable-keys.js";
-import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingDeepAgentSubagents, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.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 { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION } from "../prompts/runtime-prompts.js";
-import { createStreamEventProjectionState, projectRuntimeStreamEvent } from "./stream-event-projection.js";
-import { resolveDeterministicFinalOutput } from "./invocation-result.js";
-const EMPTY_TOOL_NAME_MAPPING = {
-    originalToModelFacing: new Map(),
-    modelFacingToOriginal: new Map(),
-};
-function readPlanStateSummaryCounts(summary) {
-    if (typeof summary !== "object" || summary === null) {
-        return null;
+import { createContextHygieneMiddleware } from "./middleware/context-hygiene.js";
+const INVALID_TOOL_MESSAGE_BLOCK_TYPES = new Set(["tool_use", "thinking", "redacted_thinking"]);
+function extractDeepAgentTaskContent(result) {
+    if (typeof result !== "object" || result === null) {
+        return undefined;
     }
-    const typed = summary;
-    const hasAny = typeof typed.pending === "number"
-        || typeof typed.inProgress === "number";
-    if (!hasAny) {
-        return null;
+    const messages = result.messages;
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return undefined;
     }
-    return {
-        pending: typeof typed.pending === "number" ? typed.pending : 0,
-        inProgress: typeof typed.inProgress === "number" ? typed.inProgress : 0,
-    };
-}
-function hasIncompletePlanTodos(value) {
-    if (!Array.isArray(value)) {
-        return null;
+    const lastMessage = messages[messages.length - 1];
+    if (typeof lastMessage !== "object" || lastMessage === null) {
+        return undefined;
     }
-    return value.some((item) => {
-        if (typeof item !== "object" || item === null) {
-            return false;
-        }
-        const status = item.status;
-        return status === "pending" || status === "in_progress";
-    });
+    if ("content" in lastMessage) {
+        return lastMessage.content;
+    }
+    if ("kwargs" in lastMessage) {
+        return (lastMessage.kwargs)?.content;
+    }
+    return undefined;
 }
-function hasIncompletePlanStateInValue(value) {
-    if (Array.isArray(value)) {
-        return value.some((item) => hasIncompletePlanStateInValue(item));
+export function extractSubagentRequestText(state) {
+    if (!isRecord(state)) {
+        return "";
     }
-    if (typeof value !== "object" || value === null) {
-        return false;
+    const messages = Array.isArray(state.messages) ? state.messages : [];
+    const lastMessage = messages.length > 0 ? messages[messages.length - 1] : undefined;
+    if (!isRecord(lastMessage)) {
+        return "";
     }
-    const typed = value;
-    const summaryCounts = readPlanStateSummaryCounts(typed.summary);
-    if (summaryCounts) {
-        return summaryCounts.pending > 0 || summaryCounts.inProgress > 0;
+    const content = lastMessage.content;
+    if (typeof content === "string") {
+        return content;
     }
-    const todoCompleteness = hasIncompletePlanTodos(typed.todos);
-    if (todoCompleteness !== null) {
-        return todoCompleteness;
+    if (Array.isArray(content)) {
+        return content
+            .map((block) => {
+            if (typeof block === "string") {
+                return block;
+            }
+            if (isRecord(block) && typeof block.text === "string") {
+                return block.text;
+            }
+            return "";
+        })
+            .filter((part) => part.length > 0)
+            .join("\n");
     }
-    const nestedCandidates = [
-        typed.summary,
-        typed.output,
-        typed.content,
-        typed.update,
-        typed.data,
-        typed.messages,
-    ];
-    return nestedCandidates.some((candidate) => hasIncompletePlanStateInValue(candidate));
+    return "";
 }
-function hasUnresolvedDelegatedExecution(state) {
-    return state.hasIncompletePlanState || state.openTaskDelegations > 0;
+export function wrapRequestResultAsSubagentResponse(result) {
+    return {
+        messages: [new AIMessage({ content: result.output || "Task completed" })],
+        ...(result.structuredResponse !== undefined ? { structuredResponse: result.structuredResponse } : {}),
+    };
 }
-function formatDelegatedExecutionBlocker(state) {
-    const summary = state.emittedOutput.trim();
-    if (summary) {
-        return summary;
-    }
-    if (state.emittedToolError) {
-        return "Delegated investigation encountered a tool failure before the plan completed.";
-    }
-    if (state.openTaskDelegations > 0) {
-        return "Delegated investigation did not finish before control returned to the parent agent.";
-    }
-    return "Delegated investigation ended before the plan was completed.";
+function shouldUseControlledBuiltinSubagent(subagent) {
+    return subagent.builtinTools?.filesystem === false || subagent.builtinTools?.todos === false;
+}
+function createFallbackDeepAgentBackend() {
+    return new StateBackend({});
 }
-function requiresDelegatedExecutionRecovery(state) {
-    return hasUnresolvedDelegatedExecution(state);
+async function buildControlledBuiltinSubagent(input) {
+    const resolvedModel = input.subagent.model ? await input.resolveModel(input.subagent.model) : undefined;
+    const resolvedTools = input.subagent.tools ? input.resolveTools(input.subagent.tools, input.binding) : undefined;
+    const resolvedSkillPaths = (await materializeDeepAgentSkillSourcePaths({
+        workspaceRoot: input.binding?.harnessRuntime.workspaceRoot,
+        runtimeRoot: input.binding?.harnessRuntime.runtimeRoot,
+        ownerId: `${input.binding?.agent.id ?? "agent"}-${input.subagent.name}`,
+        skillPaths: input.subagent.skills,
+    })) ?? [];
+    const resolvedCustomMiddleware = await resolveDeclaredMiddleware(input.subagent.middleware, input.createDeclaredMiddlewareResolverOptions(input.binding));
+    const interruptOn = compileInterruptOn(input.subagent.tools ?? [], input.subagent.interruptOn);
+    const backend = input.resolveBackend?.(input.binding) ?? createFallbackDeepAgentBackend();
+    const builtinTools = input.subagent.builtinTools ?? {};
+    const middleware = [
+        ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
+        ...(resolvedSkillPaths.length > 0 ? [createSkillsMiddleware({ backend: backend, sources: resolvedSkillPaths })] : []),
+        ...(builtinTools.filesystem === false ? [] : [createFilesystemMiddleware({ backend: backend })]),
+        createSummarizationMiddleware({
+            model: resolvedModel,
+            backend: backend,
+        }),
+        createPatchToolCallsMiddleware(),
+        ...resolvedCustomMiddleware,
+        ...(interruptOn ? [humanInTheLoopMiddleware({ interruptOn })] : []),
+    ];
+    const runnable = createAgent({
+        model: resolvedModel,
+        systemPrompt: input.subagent.systemPrompt,
+        tools: resolvedTools,
+        middleware: middleware,
+        name: input.subagent.name,
+        ...(input.subagent.responseFormat !== undefined ? { responseFormat: input.subagent.responseFormat } : {}),
+    });
+    return {
+        name: input.subagent.name,
+        description: input.subagent.description,
+        systemPrompt: input.subagent.systemPrompt,
+        runnable,
+    };
 }
-const DELEGATED_FAILURE_PLAN_RECONCILIATION_INSTRUCTION = [
-    "Your previous attempt ended with a tool failure while the todo board still had unfinished work.",
-    "Do not continue broad investigation from here.",
-    "If the failed command had malformed arguments you can correct locally, retry that same command once.",
-    "Otherwise, if a todo board already exists, call write_todos again and keep only the tasks that were actually completed in this session.",
-    "Remove the unfinished tasks that cannot proceed until the blocker is resolved.",
-    "Then return a concise blocker report.",
-].join(" ");
 export function buildBuiltinTaskSubagentMiddleware(input) {
     const { selectedSubagent, builtinBackend, summarizationModel } = input;
     const defaultSubagentMiddleware = [
@@ -190,6 +206,16 @@ export function resolveBuiltinMiddlewareBackend(input) {
 }
 export async function resolveSubagents(input) {
     return Promise.all(input.subagents.map(async (subagent) => {
+        if (shouldUseControlledBuiltinSubagent(subagent)) {
+            return buildControlledBuiltinSubagent({
+                subagent,
+                binding: input.binding,
+                resolveModel: input.resolveModel,
+                resolveTools: input.resolveTools,
+                createDeclaredMiddlewareResolverOptions: input.createDeclaredMiddlewareResolverOptions,
+                resolveBackend: input.resolveBackend,
+            });
+        }
         // Only pass DeepAgents-supported subagent fields through to upstream middleware.
         // Harness-only extensions stay internal instead of becoming a second subagent dialect.
         return {
@@ -256,118 +282,67 @@ export async function invokeBuiltinTaskTool(input) {
         configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: `${input.binding.agent.id}:builtin-task` },
         ...(input.options?.context ? { context: input.options.context } : {}),
     };
-    const buildMessages = (recoveryInstruction) => ({
-        messages: [
-            ...(recoveryInstruction ? [new SystemMessage({ content: recoveryInstruction })] : []),
-            new HumanMessage({ content: description }),
-        ],
-    });
-    if (typeof runnable.streamEvents === "function") {
-        const runWithStreamInspection = async (recoveryInstruction) => {
-            const projectionState = createStreamEventProjectionState();
-            const executedToolResults = [];
-            const events = await runnable.streamEvents(buildMessages(recoveryInstruction), invokeConfig);
-            for await (const event of events) {
-                const projectedChunks = projectRuntimeStreamEvent({
-                    event,
-                    allowVisibleStreamDeltas: false,
-                    includeStateStreamOutput: false,
-                    rootAgentId: input.binding.agent.id,
-                    countConfiguredToolsForAgentId: (agentId) => agentId === selectedSubagent.name ? resolvedSubagentTools.length : 0,
-                    toolNameMapping: EMPTY_TOOL_NAME_MAPPING,
-                    primaryTools: [],
-                    state: projectionState,
-                });
-                for (const chunk of projectedChunks) {
-                    if (chunk.kind !== "tool-result") {
-                        continue;
-                    }
-                    executedToolResults.push({
-                        toolName: chunk.toolName,
-                        output: chunk.output,
-                        isError: chunk.isError,
-                    });
-                }
-            }
-            return { projectionState, executedToolResults };
-        };
-        let { projectionState, executedToolResults } = await runWithStreamInspection();
-        if (requiresDelegatedExecutionRecovery(projectionState)) {
-            const initialProjectionState = projectionState;
-            const initialExecutedToolResults = executedToolResults;
-            const initialDeterministicOutput = resolveDeterministicFinalOutput({
-                visibleOutput: initialProjectionState.emittedOutput.trim(),
-                executedToolResults: initialExecutedToolResults,
-            });
-            const recoveryInstruction = projectionState.hasIncompletePlanState && projectionState.emittedToolError
-                ? `${AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION}\n\n${DELEGATED_FAILURE_PLAN_RECONCILIATION_INSTRUCTION}`
-                : AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION;
-            const recovered = await runWithStreamInspection(recoveryInstruction);
-            const recoveredDeterministicOutput = resolveDeterministicFinalOutput({
-                visibleOutput: recovered.projectionState.emittedOutput.trim(),
-                executedToolResults: recovered.executedToolResults,
-            });
-            const recoveredHasSubstantiveExecution = recoveredDeterministicOutput.length > 0;
-            if (recoveredHasSubstantiveExecution) {
-                projectionState = recovered.projectionState;
-                executedToolResults = recovered.executedToolResults;
-            }
-            else {
-                projectionState = initialProjectionState;
-                executedToolResults = initialExecutedToolResults;
-                if (initialDeterministicOutput) {
-                    projectionState = {
-                        ...projectionState,
-                        emittedOutput: initialDeterministicOutput,
-                    };
-                }
-            }
-        }
-        if (requiresDelegatedExecutionRecovery(projectionState)) {
-            throw new Error(formatDelegatedExecutionBlocker(projectionState));
-        }
-        if (projectionState.emittedToolError) {
-            const blockerMessage = resolveDeterministicFinalOutput({
-                visibleOutput: projectionState.emittedOutput.trim(),
-                executedToolResults,
-            }) || formatDelegatedExecutionBlocker(projectionState);
-            if (hasUnresolvedDelegatedExecution(projectionState) || !projectionState.emittedSuccessfulToolResult) {
-                throw new Error(blockerMessage);
-            }
-        }
-        const deterministicOutput = resolveDeterministicFinalOutput({
-            visibleOutput: projectionState.emittedOutput.trim(),
-            executedToolResults,
+    const result = await runnable.invoke({
+        messages: [new HumanMessage({ content: description })],
+    }, invokeConfig);
+    const structuredResponse = typeof result === "object" && result !== null && "structuredResponse" in result
+        ? result.structuredResponse
+        : undefined;
+    if (structuredResponse !== undefined) {
+        return JSON.stringify(structuredResponse);
+    }
+    const taskContent = extractDeepAgentTaskContent(result);
+    if (Array.isArray(taskContent)) {
+        const filtered = taskContent.filter((block) => {
+            const blockType = typeof block === "object" && block !== null && "type" in block
+                ? block.type
+                : undefined;
+            return !(typeof blockType === "string" && INVALID_TOOL_MESSAGE_BLOCK_TYPES.has(blockType));
         });
-        if (deterministicOutput) {
-            return deterministicOutput;
-        }
-        if (projectionState.emittedToolResult) {
-            throw new Error("Delegated investigation performed tool work but did not return surfaced findings.");
+        if (filtered.length > 0) {
+            return filtered;
         }
     }
-    let result = await runnable.invoke(buildMessages(), invokeConfig);
-    if (hasIncompletePlanStateInValue(result)) {
-        result = await runnable.invoke(buildMessages(AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION), invokeConfig);
-    }
-    if (hasIncompletePlanStateInValue(result)) {
-        throw new Error(extractVisibleOutput(result) || extractToolFallbackContext(result) || "Delegated investigation ended before the plan was completed.");
+    else if (taskContent !== undefined && taskContent !== null && taskContent !== "") {
+        return taskContent;
     }
     const visibleOutput = extractVisibleOutput(result);
+    if (visibleOutput) {
+        return visibleOutput;
+    }
     const fallbackOutput = extractToolFallbackContext(result);
-    const structuredResponse = typeof result === "object" && result !== null && "structuredResponse" in result
-        ? result.structuredResponse
-        : undefined;
-    return visibleOutput || fallbackOutput || (structuredResponse !== undefined ? JSON.stringify(structuredResponse) : "") || JSON.stringify(result);
+    return fallbackOutput || "Task completed";
 }
 export async function resolveBuiltinMiddlewareTools(input) {
     const backend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
-    return createBuiltinMiddlewareTools(backend, {
+    const tools = (await createBuiltinMiddlewareTools(backend, {
         includeTaskTool: false,
         workspaceRoot: input.binding.harnessRuntime.workspaceRoot,
         toolRuntimeContext: input.options?.toolRuntimeContext,
         invokeTaskTool: undefined,
-    });
+    }));
+    const builtinTools = getBindingBuiltinToolsConfig(input.binding) ?? {};
+    if (builtinTools.todos === false) {
+        tools.delete("write_todos");
+        tools.delete("read_todos");
+    }
+    if (builtinTools.filesystem === false) {
+        for (const name of [
+            "ls",
+            "list_files",
+            "read_file",
+            "write_file",
+            "edit_file",
+            "glob",
+            "grep",
+            "search_files",
+            "execute",
+            "run_command",
+        ]) {
+            tools.delete(name);
+        }
+    }
+    return tools;
 }
 export async function materializeAutomaticSummarizationMiddleware(input) {
     const primaryModel = getBindingPrimaryModel(input.binding);
@@ -423,6 +398,7 @@ export async function resolveMiddleware(input) {
         ? await input.resolveLangChainRuntimeExtensionMiddleware(input.binding)
         : [];
     const middleware = [
+        createContextHygieneMiddleware(),
         ...declarativeUpstreamMiddleware,
         ...runtimeExtensionMiddleware,
         ...(input.runtimeAdapterOptions.middlewareResolver ? input.runtimeAdapterOptions.middlewareResolver(input.binding) : []),

package/dist/runtime/adapter/model/invocation-request.js

@@ -2,7 +2,7 @@ import { getBindingSkills } from "../../support/compiled-binding.js";
 import { extractMessageText, normalizeMessageContent } from "../../../utils/message-content.js";
 import { readSkillMetadata } from "../../skills/skill-metadata.js";
 import { summarizeAssistantText } from "../direct-builtin-utility.js";
-import { renderDurableMemoryContextPrompt, renderSlashCommandSkillInstruction } from "../../prompts/runtime-prompts.js";
+import { renderDurableMemoryContextPrompt, renderSlashCommandSkillInstruction, } from "../../prompts/runtime-prompts.js";
 import { hasExplicitResourceReference, } from "../../harness/system/runtime-memory-policy.js";
 const MAX_HISTORY_ASSISTANT_CHARS = 1600;
 const MAX_HISTORY_ASSISTANT_LINES = 40;
@@ -125,6 +125,42 @@ function buildContextualFollowUpInstruction(inputText, hasDurableMemory) {
     }
     return "Answer the user's current follow-up directly from the recalled context when it remains relevant. If recalled memory conflicts with the current system prompt, runtime policy, recovery instruction, available tool evidence, or the user's current request, ignore the recalled memory for this turn. If the current user turn corrects, revokes, deletes, or replaces recalled memory, treat the user's latest statement as newer than the recalled memory for this turn. Do not frame the reply as a fresh URL or page summary unless the current user turn explicitly includes a new resource to inspect.";
 }
+function isIncidentFollowUpTurn(inputText) {
+    const normalized = inputText.trim().toLowerCase();
+    if (!normalized || hasExplicitResourceReference(normalized)) {
+        return false;
+    }
+    return /(the rca|deep research.*rca|root cause|go deeper|those issues|these issues|that issue|current incident|kubernetes issues)/i.test(normalized);
+}
+function findLastAssistantText(history) {
+    for (let index = history.length - 1; index >= 0; index -= 1) {
+        const message = history[index];
+        if (message?.role !== "assistant") {
+            continue;
+        }
+        const text = extractMessageText(message.content).trim();
+        if (text) {
+            return compactHistoryText(text);
+        }
+    }
+    return undefined;
+}
+function buildIncidentFollowUpInstruction(history, inputText) {
+    if (!isIncidentFollowUpTurn(inputText)) {
+        return undefined;
+    }
+    const priorAssistantText = findLastAssistantText(history);
+    if (!priorAssistantText) {
+        return undefined;
+    }
+    return [
+        "Treat the user's current turn as a follow-up on the current incident, not as a generic background-knowledge request.",
+        "Use the immediately prior assistant findings below as the default incident context unless the user explicitly overrides it.",
+        "",
+        "Prior assistant findings:",
+        priorAssistantText,
+    ].join("\n");
+}
 export function buildSlashCommandSkillInstruction(binding, input) {
     const inputText = extractMessageText(input).trim();
     const match = inputText.match(/^\/([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+([\s\S]*))?$/i);
@@ -162,6 +198,7 @@ export function buildInvocationRequest(binding, history, input, options = {}) {
         suppressHistoryTurns: Boolean(memoryInstruction) && !hasExplicitResourceReference(inputText),
     });
     const contextualFollowUpInstruction = buildContextualFollowUpInstruction(inputText, Boolean(memoryInstruction));
+    const incidentFollowUpInstruction = buildIncidentFollowUpInstruction(history, inputText);
     const conversationLanguage = resolveConversationLanguage(history, inputText);
     const languageInstruction = !inferMessageLanguage(inputText) && conversationLanguage
         ? {
@@ -175,6 +212,7 @@ export function buildInvocationRequest(binding, history, input, options = {}) {
         messages: [
             ...(memoryInstruction ? [{ role: "system", content: memoryInstruction }] : []),
             ...(contextualFollowUpInstruction ? [{ role: "system", content: contextualFollowUpInstruction }] : []),
+            ...(incidentFollowUpInstruction ? [{ role: "system", content: incidentFollowUpInstruction }] : []),
             ...(languageInstruction ? [{ role: "system", content: languageInstruction }] : []),
             ...(userInvocableInstruction ? [{ role: "system", content: userInvocableInstruction }] : []),
             ...messages,

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

@@ -6,8 +6,29 @@ export function truncateLines(lines, maxChars = 12_000) {
     }
     return `${joined.slice(0, maxChars - 18)}\n...[truncated]`;
 }
+function findTodosArray(value, depth = 0) {
+    if (depth > 3 || !isRecord(value)) {
+        return [];
+    }
+    if (Array.isArray(value.todos)) {
+        return value.todos;
+    }
+    const nestedFromUpdate = findTodosArray(value.update, depth + 1);
+    if (nestedFromUpdate.length > 0) {
+        return nestedFromUpdate;
+    }
+    const nestedFromOutput = findTodosArray(value.output, depth + 1);
+    if (nestedFromOutput.length > 0) {
+        return nestedFromOutput;
+    }
+    const nestedFromData = findTodosArray(value.data, depth + 1);
+    if (nestedFromData.length > 0) {
+        return nestedFromData;
+    }
+    return [];
+}
 export function summarizeBuiltinWriteTodosArgs(args) {
-    const todos = Array.isArray(args.todos) ? args.todos : [];
+    const todos = findTodosArray(args);
     const items = todos.flatMap((todo) => {
         if (!isRecord(todo)) {
             return [];
@@ -16,11 +37,20 @@ export function summarizeBuiltinWriteTodosArgs(args) {
             ? todo.content.trim()
             : typeof todo.description === "string" && todo.description.trim().length > 0
                 ? todo.description.trim()
-                : "";
+                : typeof todo.title === "string" && todo.title.trim().length > 0
+                    ? todo.title.trim()
+                    : typeof todo.name === "string" && todo.name.trim().length > 0
+                        ? todo.name.trim()
+                        : typeof todo.text === "string" && todo.text.trim().length > 0
+                            ? todo.text.trim()
+                            : "";
         const status = typeof todo.status === "string" && todo.status.trim().length > 0 ? todo.status.trim() : "pending";
         const metadata = isRecord(todo.metadata) ? todo.metadata : undefined;
         return content ? [{
-                ...(typeof todo.id === "string" && todo.id.trim().length > 0 ? { id: todo.id.trim() } : {}),
+                ...((typeof todo.id === "string" && todo.id.trim().length > 0)
+                    || typeof todo.id === "number"
+                    ? { id: String(todo.id).trim() }
+                    : {}),
                 content,
                 status,
                 ...(typeof todo.ownerAgentId === "string" && todo.ownerAgentId.trim().length > 0 ? { ownerAgentId: todo.ownerAgentId.trim() } : {}),

package/dist/runtime/adapter/stream-event-projection.js

@@ -237,17 +237,18 @@ function isInternalRuntimeSpillPathErrorValue(value) {
 }
 function recordDelegatedFindings(state, value, source = "tool") {
     if (state.taskDelegationFindingsStack.length === 0) {
-        return;
+        return false;
     }
     const normalized = normalizeDelegatedFindingsText(value);
     if (!normalized) {
-        return;
+        return false;
     }
     const current = state.taskDelegationFindingsStack[state.taskDelegationFindingsStack.length - 1] ?? "";
     if (source === "terminal" && current) {
-        return;
+        return true;
     }
     state.taskDelegationFindingsStack[state.taskDelegationFindingsStack.length - 1] = normalized;
+    return true;
 }
 function updateDelegationState(state, event, countConfiguredToolsForAgentId) {
     if (typeof event !== "object" || event === null) {
@@ -392,8 +393,8 @@ export function projectRuntimeStreamEvent(params) {
     if (!allowVisibleContent) {
         const delegatedTerminalOutput = extractTerminalStreamOutput(event);
         if (delegatedTerminalOutput) {
-            state.emittedDelegatedTerminalOutput = true;
-            recordDelegatedFindings(state, delegatedTerminalOutput, "terminal");
+            state.emittedDelegatedTerminalOutput =
+                state.emittedDelegatedTerminalOutput || recordDelegatedFindings(state, delegatedTerminalOutput, "terminal");
         }
     }
     if (output && !shouldSuppressVisibleToolCallText(output)) {

package/dist/runtime/adapter/tool/builtin-middleware-tools.d.ts

@@ -243,6 +243,13 @@ export declare const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS: readonly [{
     readonly name: "task";
     readonly description: "Delegate a bounded task to a subagent.";
 }];
+export declare function filterBuiltinMiddlewareToolDescriptors(options?: {
+    filesystem?: boolean;
+    todos?: boolean;
+}): Array<{
+    name: string;
+    description: string;
+}>;
 export declare function createBuiltinMiddlewareTools(backend: BuiltinMiddlewareBackend, options: {
     includeTaskTool: boolean;
     invokeTaskTool?: (input: unknown) => Promise<unknown>;

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -4,28 +4,10 @@ import { isSandboxBackend } from "deepagents";
 import { isRecord } from "../../../utils/object.js";
 import { formatBuiltinTodoSnapshot, isLowSignalTodoContent, summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
 import { maybePersistLargeToolOutput, resolveToolRuntimeContext } from "./tool-output-artifacts.js";
-const taskToolSchema = z.preprocess((value) => {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return value;
-    }
-    return normalizeTaskToolInput(value);
-}, z.object({
+const taskToolSchema = z.object({
     description: z.string(),
     subagent_type: z.string(),
-}).passthrough());
-function normalizeTaskToolInput(typed) {
-    const description = typeof typed.description === "string" && typed.description.trim().length > 0
-        ? typed.description
-        : undefined;
-    const subagentType = typeof typed.subagent_type === "string" && typed.subagent_type.trim().length > 0
-        ? typed.subagent_type
-        : undefined;
-    return {
-        ...typed,
-        ...(description !== undefined ? { description } : {}),
-        ...(subagentType !== undefined ? { subagent_type: subagentType } : {}),
-    };
-}
+}).passthrough();
 export const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS = [
     { name: "write_todos", description: "Create and update the runtime todo board for multi-step work." },
     { name: "read_todos", description: "Read the current runtime todo board." },
@@ -46,6 +28,30 @@ export const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS = [
     { name: "schedule_task", description: "Create, inspect, update, list, and delete system-level scheduled tasks." },
     { name: "task", description: "Delegate a bounded task to a subagent." },
 ];
+export function filterBuiltinMiddlewareToolDescriptors(options) {
+    return BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS.filter((descriptor) => {
+        if (options?.todos === false
+            && (descriptor.name === "write_todos" || descriptor.name === "read_todos")) {
+            return false;
+        }
+        if (options?.filesystem === false
+            && [
+                "ls",
+                "list_files",
+                "read_file",
+                "write_file",
+                "edit_file",
+                "glob",
+                "grep",
+                "search_files",
+                "execute",
+                "run_command",
+            ].includes(descriptor.name)) {
+            return false;
+        }
+        return true;
+    }).map((descriptor) => ({ ...descriptor }));
+}
 function toDisplayContent(content) {
     if (typeof content === "string") {
         return content;
@@ -214,9 +220,12 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         description: "Create and update the runtime todo board for multi-step work.",
         schema: z.object({
             todos: z.array(z.object({
-                id: z.string().optional(),
+                id: z.union([z.string(), z.number()]).optional(),
                 content: z.string().optional(),
                 description: z.string().optional(),
+                title: z.string().optional(),
+                name: z.string().optional(),
+                text: z.string().optional(),
                 status: z.enum(["pending", "in_progress", "completed", "failed", "cancelled"]).optional(),
                 ownerAgentId: z.string().optional(),
                 startedAt: z.string().optional(),
@@ -615,9 +624,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             name: "task",
             description: "Delegate a bounded task to a subagent.",
             schema: taskToolSchema,
-            invoke: async (input, config) => options.invokeTaskTool(typeof input === "object" && input !== null && !Array.isArray(input)
-                ? normalizeTaskToolInput(input)
-                : {}),
+            invoke: async (input) => options.invokeTaskTool(input),
         });
     }
     return tools;