@botbotgo/agent-harness 0.0.298 → 0.0.300

package/dist/runtime/adapter/local-tool-invocation.js

@@ -3,6 +3,22 @@ import { createModelFacingToolNameLookupCandidates, resolveModelFacingToolName }
 import { canReplayToolCallsLocally } from "./tool/tool-replay.js";
 import { extractToolCallsFromResult, normalizeToolArgsForSchema, stringifyToolOutput } from "./tool/tool-arguments.js";
 import { extractMemoryCandidatesFromToolOutput } from "../harness/system/runtime-memory-candidates.js";
+const TOOL_FOLLOW_UP_INSTRUCTION = "One or more tool results are already available in this conversation. Answer the user's current request directly from the existing context and tool results. Do not ask the user to repeat inputs that are already present above.";
+function extractLatestUserInput(request) {
+    const typedRequest = request;
+    const messages = Array.isArray(typedRequest.messages) ? typedRequest.messages : [];
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const candidate = messages[index];
+        if (candidate?.role !== "user" || typeof candidate.content !== "string") {
+            continue;
+        }
+        const normalized = candidate.content.trim();
+        if (normalized.length > 0) {
+            return normalized;
+        }
+    }
+    return undefined;
+}
 export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }) {
     const executedToolResults = [];
     let activeRequest = request;
@@ -32,9 +48,15 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             throw new Error(`Tool-calling loop exceeded the maximum of ${maxToolIterations} iterations`);
         }
         const resultMessages = result.messages;
-        const nextMessages = Array.isArray(resultMessages)
-            ? [...resultMessages]
-            : [...currentMessages];
+        const nextMessages = [...currentMessages];
+        if (Array.isArray(resultMessages) && resultMessages.length > 0) {
+            nextMessages.push(...resultMessages);
+        }
+        const latestUserInput = extractLatestUserInput(activeRequest);
+        nextMessages.push({
+            role: "system",
+            content: TOOL_FOLLOW_UP_INSTRUCTION,
+        });
         for (let toolIndex = 0; toolIndex < toolCalls.length; toolIndex += 1) {
             const toolCall = toolCalls[toolIndex];
             const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
@@ -49,7 +71,9 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                 throw new Error(`Tool ${toolCall.name} is not configured for this agent.`);
             }
             const compiledTool = toolCatalog.get(toolCall.name) ?? toolCatalog.get(resolvedToolName);
-            const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema, toolCall.rawArgsInput);
+            const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema, toolCall.rawArgsInput, {
+                latestUserInput,
+            });
             const toolResult = await activeExecutable.invoke(normalizedArgs);
             const memoryCandidates = compiledTool ? extractMemoryCandidatesFromToolOutput(compiledTool, toolResult) : [];
             executedToolResults.push({

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

@@ -1,5 +1,5 @@
 import { HumanMessage } from "@langchain/core/messages";
-import { DEFAULT_SUBAGENT_PROMPT, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, StateBackend, } from "deepagents";
+import { createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware } from "langchain";
 import { createBuiltinMiddlewareTools } from "./tool/builtin-middleware-tools.js";
 import { compileInterruptOn } from "./tool/interrupt-policy.js";
@@ -9,6 +9,7 @@ import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { UPSTREAM_SESSION_CONFIG_KEY } from "./upstream-configurable-keys.js";
 import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
+import { DEFAULT_SUBAGENT_PROMPT } from "../support/runtime-prompts.js";
 export function buildBuiltinTaskSubagentMiddleware(input) {
     const { selectedSubagent, builtinBackend, summarizationModel } = input;
     const defaultSubagentMiddleware = [
@@ -180,6 +181,7 @@ export async function resolveBuiltinMiddlewareTools(input) {
     const backend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
     return createBuiltinMiddlewareTools(backend, {
         includeTaskTool: isDeepAgentBinding(input.binding),
+        workspaceRoot: input.binding.harnessRuntime.workspaceRoot,
         invokeTaskTool: isDeepAgentBinding(input.binding)
             ? async (toolInput) => input.invokeBuiltinTaskTool(input.binding, toolInput, input.options)
             : undefined,

package/dist/runtime/adapter/model/invocation-request.d.ts

@@ -1,5 +1,8 @@
 import type { CompiledAgentBinding, MessageContent, TranscriptMessage } from "../../../contracts/types.js";
-export declare function buildAgentMessages(history: TranscriptMessage[], input: MessageContent): Array<{
+export declare function buildAgentMessages(history: TranscriptMessage[], input: MessageContent, options?: {
+    suppressExplicitResourceTurns?: boolean;
+    suppressAssistantTurns?: boolean;
+}): Array<{
     role: string;
     content: MessageContent;
 }>;

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

@@ -1,12 +1,127 @@
 import { getBindingSkills } from "../../support/compiled-binding.js";
 import { extractMessageText, normalizeMessageContent } from "../../../utils/message-content.js";
 import { readSkillMetadata } from "../../support/skill-metadata.js";
-export function buildAgentMessages(history, input) {
+import { summarizeAssistantText } from "../direct-builtin-utility.js";
+import { renderDurableMemoryContextPrompt, renderSlashCommandSkillInstruction } from "../../support/runtime-prompts.js";
+import { hasExplicitResourceReference, } from "../../harness/system/runtime-memory-policy.js";
+const MAX_HISTORY_ASSISTANT_CHARS = 1600;
+const MAX_HISTORY_ASSISTANT_LINES = 40;
+function compactHistoryText(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return normalized;
+    }
+    const summarized = summarizeAssistantText(normalized);
+    if (summarized !== normalized) {
+        return summarized;
+    }
+    const lines = normalized.split(/\r?\n/);
+    if (normalized.length <= MAX_HISTORY_ASSISTANT_CHARS && lines.length <= MAX_HISTORY_ASSISTANT_LINES) {
+        return normalized;
+    }
+    const head = normalized.slice(0, 1200).trimEnd();
+    const tail = normalized.slice(-240).trimStart();
+    const omittedChars = Math.max(normalized.length - head.length - tail.length, 0);
+    return `${head}\n... [${omittedChars} characters omitted from prior assistant output] ...\n${tail}`;
+}
+function compactHistoryContent(role, content) {
+    const normalized = normalizeMessageContent(content);
+    if (role !== "assistant" || typeof normalized !== "string") {
+        return normalized;
+    }
+    return compactHistoryText(normalized);
+}
+function renderHistoryTurn(turn) {
+    const dropsAssistant = turn.some((item) => {
+        if (item.role !== "assistant" || typeof item.content !== "string") {
+            return false;
+        }
+        const compacted = compactHistoryContent(item.role, item.content);
+        return typeof compacted === "string" && compacted !== normalizeMessageContent(item.content);
+    });
+    if (dropsAssistant) {
+        return [];
+    }
+    return turn.flatMap((item) => {
+        const content = compactHistoryContent(item.role, item.content);
+        if (item.role === "assistant" && typeof item.content === "string" && typeof content === "string" && content !== normalizeMessageContent(item.content)) {
+            return [];
+        }
+        return [{ role: item.role, content }];
+    });
+}
+function dropAssistantMessages(turn) {
+    return turn.filter((item) => item.role !== "assistant");
+}
+function inferMessageLanguage(text) {
+    const normalized = text
+        .replace(/https?:\/\/\S+/giu, " ")
+        .trim();
+    if (!normalized) {
+        return undefined;
+    }
+    if (/[\p{Script=Han}]/u.test(normalized)) {
+        return "zh";
+    }
+    if (/[A-Za-z]/u.test(normalized)) {
+        return "en";
+    }
+    return undefined;
+}
+function selectRelevantHistoryTurns(groupedHistory, inputText, options = {}) {
+    if (groupedHistory.length === 0) {
+        return [];
+    }
+    if (hasExplicitResourceReference(inputText)) {
+        return [];
+    }
+    return groupedHistory
+        .slice(-4)
+        .filter((turn) => !options.suppressExplicitResourceTurns || !turn.some((item) => item.role === "user" && hasExplicitResourceReference(extractMessageText(item.content))))
+        .map((turn) => options.suppressAssistantTurns ? dropAssistantMessages(turn) : turn)
+        .filter((turn) => turn.length > 0)
+        .slice(-4);
+}
+export function buildAgentMessages(history, input, options = {}) {
+    const inputText = extractMessageText(input).trim();
+    const groupedHistory = history.reduce((groups, item) => {
+        const current = groups.at(-1);
+        if (current && current[0]?.requestId === item.requestId) {
+            current.push(item);
+            return groups;
+        }
+        groups.push([item]);
+        return groups;
+    }, []);
+    const selectedTurns = selectRelevantHistoryTurns(groupedHistory, inputText, options);
     return [
-        ...history.map((item) => ({ role: item.role, content: normalizeMessageContent(item.content) })),
+        ...selectedTurns.flatMap((turn) => renderHistoryTurn(turn)),
         { role: "user", content: normalizeMessageContent(input) },
     ];
 }
+function resolveConversationLanguage(history, inputText) {
+    const direct = inferMessageLanguage(inputText);
+    if (direct) {
+        return direct;
+    }
+    for (let index = history.length - 1; index >= 0; index -= 1) {
+        const message = history[index];
+        if (message?.role !== "user") {
+            continue;
+        }
+        const detected = inferMessageLanguage(extractMessageText(message.content));
+        if (detected) {
+            return detected;
+        }
+    }
+    return undefined;
+}
+function buildContextualFollowUpInstruction(inputText, hasDurableMemory) {
+    if (!hasDurableMemory || hasExplicitResourceReference(inputText)) {
+        return undefined;
+    }
+    return "Answer the user's current follow-up directly from the recalled context. 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.";
+}
 export function buildSlashCommandSkillInstruction(binding, input) {
     const inputText = extractMessageText(input).trim();
     const match = inputText.match(/^\/([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+([\s\S]*))?$/i);
@@ -25,31 +140,38 @@ export function buildSlashCommandSkillInstruction(binding, input) {
     const dryRunHint = /\s--dry-run(?:\s|$)/.test(` ${argumentText} `)
         ? "This invocation includes `--dry-run`. Perform the real fetch or inspection steps needed for dry-run output. Do not return hypothetical or mock results."
         : undefined;
-    return [
-        `This user message is an explicit command-style invocation of the ${skillQualifier} \`${metadata.name}\`.`,
-        `Read the skill file for \`${metadata.name}\` before taking action, then follow its documented phases and constraints exactly.`,
-        `You must use the \`${metadata.name}\` skill for this request and follow its documented workflow.`,
-        `Treat everything after \`/${metadata.name}\` as the skill argument string: ${argumentText ? JSON.stringify(argumentText) : '""'}.`,
-        "Do not answer with a generic explanation of what the skill would do. Execute the skill workflow using the available tools unless the skill instructions explicitly require confirmation before acting.",
+    return renderSlashCommandSkillInstruction({
+        skillQualifier,
+        skillName: metadata.name,
+        argumentText,
         dryRunHint,
-    ].filter((line) => typeof line === "string" && line.length > 0).join("\n");
+    });
 }
 export function buildInvocationRequest(binding, history, input, options = {}) {
+    const inputText = extractMessageText(input).trim();
     const userInvocableInstruction = buildSlashCommandSkillInstruction(binding, input);
-    const messages = buildAgentMessages(history, input);
     const memoryInstruction = typeof options.memoryContext === "string" && options.memoryContext.trim().length > 0
-        ? [
-            "Relevant durable memory was retrieved for this run.",
-            "Use it when it is still applicable, but prefer fresher direct evidence if there is any conflict.",
-            "",
-            options.memoryContext.trim(),
-        ].join("\n")
+        ? renderDurableMemoryContextPrompt(options.memoryContext)
+        : undefined;
+    const messages = buildAgentMessages(history, input, {
+        suppressExplicitResourceTurns: Boolean(memoryInstruction) && !hasExplicitResourceReference(inputText),
+        suppressAssistantTurns: Boolean(memoryInstruction) && !hasExplicitResourceReference(inputText),
+    });
+    const contextualFollowUpInstruction = buildContextualFollowUpInstruction(inputText, Boolean(memoryInstruction));
+    const conversationLanguage = resolveConversationLanguage(history, inputText);
+    const languageInstruction = !inferMessageLanguage(inputText) && conversationLanguage
+        ? {
+            zh: "Reply in Chinese for this turn.",
+            en: "Reply in English for this turn.",
+        }[conversationLanguage]
         : undefined;
     return {
         ...(options.state ?? {}),
         ...(options.files ? { files: options.files } : {}),
         messages: [
             ...(memoryInstruction ? [{ role: "system", content: memoryInstruction }] : []),
+            ...(contextualFollowUpInstruction ? [{ role: "system", content: contextualFollowUpInstruction }] : []),
+            ...(languageInstruction ? [{ role: "system", content: languageInstruction }] : []),
             ...(userInvocableInstruction ? [{ role: "system", content: userInvocableInstruction }] : []),
             ...messages,
         ],

package/dist/runtime/adapter/model/message-assembly.js

@@ -1,4 +1,5 @@
 import { buildAgentMessages, buildSlashCommandSkillInstruction } from "./invocation-request.js";
+import { renderDurableMemoryContextPrompt } from "../../support/runtime-prompts.js";
 export function buildStateSnapshot(result) {
     const snapshot = { ...result };
     delete snapshot.messages;
@@ -15,12 +16,7 @@ export function buildRawModelMessages(binding, systemPrompt, history, input, mem
     if (memoryContext?.trim()) {
         messages.push({
             role: "system",
-            content: [
-                "Relevant durable memory was retrieved for this run.",
-                "Use it when it still applies, but prefer fresher direct evidence if there is any conflict.",
-                "",
-                memoryContext.trim(),
-            ].join("\n"),
+            content: renderDurableMemoryContextPrompt(memoryContext),
         });
     }
     const userInvocableInstruction = buildSlashCommandSkillInstruction(binding, input);

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

@@ -1,5 +1,6 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatGoogle } from "@langchain/google";
+import { ToolMessage } from "@langchain/core/messages";
 import { ChatOllama } from "@langchain/ollama";
 import { ChatOpenAI } from "@langchain/openai";
 import { AIMessage } from "langchain";
@@ -151,6 +152,103 @@ function formatStructuredMessage(value) {
     }
     return content ? `${role}:\n${content}` : "";
 }
+function readToolMessageMetadata(value) {
+    if (typeof value !== "object" || value === null) {
+        return {};
+    }
+    const typed = value;
+    const kwargs = typeof typed.kwargs === "object" && typed.kwargs !== null ? typed.kwargs : undefined;
+    const lcKwargs = typeof typed.lc_kwargs === "object" && typed.lc_kwargs !== null ? typed.lc_kwargs : undefined;
+    const name = typeof typed.name === "string"
+        ? typed.name
+        : typeof kwargs?.name === "string"
+            ? kwargs.name
+            : typeof lcKwargs?.name === "string"
+                ? lcKwargs.name
+                : undefined;
+    const toolCallId = typeof typed.tool_call_id === "string"
+        ? typed.tool_call_id
+        : typeof kwargs?.tool_call_id === "string"
+            ? kwargs.tool_call_id
+            : typeof lcKwargs?.tool_call_id === "string"
+                ? lcKwargs.tool_call_id
+                : undefined;
+    return { name, toolCallId };
+}
+function normalizeReadFileToolContent(name, content) {
+    if (name !== "read_file") {
+        return content;
+    }
+    const lines = content.split("\n");
+    const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+    if (nonEmptyLines.length === 0 || !nonEmptyLines.every((line) => /^\d+\t/.test(line))) {
+        return content;
+    }
+    return lines.map((line) => line.replace(/^\d+\t/, "")).join("\n");
+}
+function normalizeProviderFacingToolMessage(message) {
+    if (mapMessageRole(message) !== "TOOL") {
+        return message;
+    }
+    if (typeof message !== "object" || message === null) {
+        return message;
+    }
+    const { name, toolCallId } = readToolMessageMetadata(message);
+    const normalizedContent = normalizeReadFileToolContent(name, readPromptContent(message));
+    const messageType = readMessageType(message);
+    if (messageType === "tool" && toolCallId) {
+        return new ToolMessage({
+            ...(name ? { name } : {}),
+            tool_call_id: toolCallId,
+            content: normalizedContent,
+        });
+    }
+    return {
+        ...message,
+        content: normalizedContent,
+    };
+}
+function normalizeProviderFacingInput(input) {
+    if (Array.isArray(input)) {
+        return input.map((message) => normalizeProviderFacingToolMessage(message));
+    }
+    if (typeof input === "object" && input !== null && Array.isArray(input.messages)) {
+        return {
+            ...input,
+            messages: normalizeProviderFacingInput(input.messages),
+        };
+    }
+    return input;
+}
+function createProviderToolMessageCompatModel(model) {
+    return new Proxy(model, {
+        has(target, prop) {
+            if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "withConfig") {
+                return true;
+            }
+            return prop in target;
+        },
+        get(target, prop, receiver) {
+            if (prop === "bindTools") {
+                return (tools) => {
+                    const bound = target.bindTools.call(target, tools);
+                    return createProviderToolMessageCompatModel(bound);
+                };
+            }
+            if (prop === "invoke") {
+                return (input, config) => target.invoke.call(target, normalizeProviderFacingInput(input), config);
+            }
+            if (prop === "stream") {
+                return (input, config) => target.stream.call(target, normalizeProviderFacingInput(input), config);
+            }
+            if (prop === "withConfig" && typeof target.withConfig === "function") {
+                return (config) => createProviderToolMessageCompatModel(target.withConfig.call(target, config));
+            }
+            const member = Reflect.get(target, prop, receiver);
+            return typeof member === "function" ? member.bind(target) : member;
+        },
+    });
+}
 function stringifyNodeLlamaCppInput(input) {
     if (typeof input === "string") {
         return input;
@@ -325,19 +423,19 @@ export async function createResolvedModel(model, modelResolver) {
         return modelResolver(model.id);
     }
     if (model.provider === "ollama") {
-        return new ChatOllama({ model: model.model, ...model.init });
+        return createProviderToolMessageCompatModel(new ChatOllama({ model: model.model, ...model.init }));
     }
     if (model.provider === "openai-compatible") {
-        return new ChatOpenAI({ model: model.model, ...normalizeOpenAICompatibleInit(model.init) });
+        return createProviderToolMessageCompatModel(new ChatOpenAI({ model: model.model, ...normalizeOpenAICompatibleInit(model.init) }));
     }
     if (model.provider === "openai") {
-        return new ChatOpenAI({ model: model.model, ...model.init });
+        return createProviderToolMessageCompatModel(new ChatOpenAI({ model: model.model, ...model.init }));
     }
     if (model.provider === "anthropic") {
-        return new ChatAnthropic({ model: model.model, ...model.init });
+        return createProviderToolMessageCompatModel(new ChatAnthropic({ model: model.model, ...model.init }));
     }
     if (model.provider === "google" || model.provider === "google-genai" || model.provider === "gemini") {
-        return new ChatGoogle({ model: model.model, ...model.init });
+        return createProviderToolMessageCompatModel(new ChatGoogle({ model: model.model, ...model.init }));
     }
     if (model.provider === "node-llama-cpp" || model.provider === "llama-cpp") {
         return createNodeLlamaCppModel(model);

package/dist/runtime/adapter/resilience.js

@@ -1,4 +1,4 @@
-import { getBindingModelInit } from "../support/compiled-binding.js";
+import { getBindingModelInit, getBindingPrimaryModel } from "../support/compiled-binding.js";
 export function resolveTimeoutMs(value) {
     return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
 }
@@ -20,12 +20,23 @@ export function resolveStreamIdleTimeout(binding) {
     if (configuredIdleTimeout) {
         return configuredIdleTimeout;
     }
+    const primaryModel = getBindingPrimaryModel(binding);
+    if (primaryModel?.provider === "ollama") {
+        return 180_000;
+    }
     const invokeTimeout = resolveBindingTimeout(binding);
     if (invokeTimeout) {
         return Math.min(invokeTimeout, 60_000);
     }
     return 60_000;
 }
+const BUILTIN_RETRYABLE_PROVIDER_MESSAGES = [
+    "unexpected eof",
+];
+function isEmptyFinalAiMessageError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.toLowerCase().startsWith("empty_final_ai_message:");
+}
 export function resolveProviderRetryPolicy(binding) {
     const resilience = typeof binding.harnessRuntime.resilience === "object" && binding.harnessRuntime.resilience
         ? binding.harnessRuntime.resilience
@@ -53,8 +64,12 @@ export function resolveProviderRetryPolicy(binding) {
     };
 }
 export function isRetryableProviderError(binding, error) {
+    if (isEmptyFinalAiMessageError(error)) {
+        return true;
+    }
     const message = error instanceof Error ? error.message : String(error);
     const normalized = message.toLowerCase();
     const { retryableMessages } = resolveProviderRetryPolicy(binding);
-    return retryableMessages.some((candidate) => normalized.includes(candidate.toLowerCase()));
+    return [...BUILTIN_RETRYABLE_PROVIDER_MESSAGES, ...retryableMessages]
+        .some((candidate) => normalized.includes(candidate.toLowerCase()));
 }

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

@@ -1,12 +1,16 @@
+import type { RequestPlanItem, RequestPlanState, RequestPlanSummary } from "../../contracts/types.js";
 export type BuiltinTodoSnapshot = {
-    total: number;
-    pending: number;
-    completed: number;
-    items: Array<{
-        content: string;
-        status: string;
-    }>;
+    items: RequestPlanItem[];
+    summary: RequestPlanSummary;
 };
 export declare function truncateLines(lines: string[], maxChars?: number): string;
 export declare function summarizeBuiltinWriteTodosArgs(args: Record<string, unknown>): BuiltinTodoSnapshot;
+export declare function isLowSignalTodoContent(content: string): boolean;
 export declare function formatBuiltinTodoSnapshot(snapshot: BuiltinTodoSnapshot): string;
+export declare function buildRequestPlanState(input: {
+    sessionId: string;
+    requestId: string;
+    updatedAt: string;
+    version?: number;
+    snapshot: BuiltinTodoSnapshot;
+}): RequestPlanState;

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

@@ -18,22 +18,56 @@ export function summarizeBuiltinWriteTodosArgs(args) {
                 ? todo.description.trim()
                 : "";
         const status = typeof todo.status === "string" && todo.status.trim().length > 0 ? todo.status.trim() : "pending";
-        return content ? [{ content, status }] : [];
+        const metadata = isRecord(todo.metadata) ? todo.metadata : undefined;
+        return content ? [{
+                ...(typeof todo.id === "string" && todo.id.trim().length > 0 ? { id: todo.id.trim() } : {}),
+                content,
+                status,
+                ...(typeof todo.ownerAgentId === "string" && todo.ownerAgentId.trim().length > 0 ? { ownerAgentId: todo.ownerAgentId.trim() } : {}),
+                ...(typeof todo.startedAt === "string" && todo.startedAt.trim().length > 0 ? { startedAt: todo.startedAt.trim() } : {}),
+                ...(typeof todo.endedAt === "string" && todo.endedAt.trim().length > 0 ? { endedAt: todo.endedAt.trim() } : {}),
+                ...(todo.result !== undefined ? { result: todo.result } : {}),
+                ...(metadata ? { metadata } : {}),
+            }] : [];
     });
-    return {
+    const summary = {
         total: items.length,
-        pending: items.filter((item) => item.status !== "completed").length,
+        pending: items.filter((item) => item.status === "pending").length,
+        inProgress: items.filter((item) => item.status === "in_progress").length,
         completed: items.filter((item) => item.status === "completed").length,
+        failed: items.filter((item) => item.status === "failed").length,
+        cancelled: items.filter((item) => item.status === "cancelled").length,
+        blocked: items.filter((item) => item.status === "blocked").length,
+    };
+    return {
         items,
+        summary,
     };
 }
+export function isLowSignalTodoContent(content) {
+    const normalized = content.trim().toLowerCase();
+    if (!normalized) {
+        return true;
+    }
+    return /^\d+$/.test(normalized) || /^step\s*\d+$/.test(normalized) || /^todo\s*\d+$/.test(normalized);
+}
 export function formatBuiltinTodoSnapshot(snapshot) {
-    if (snapshot.total === 0) {
+    if (snapshot.summary.total === 0) {
         return "No todos tracked.";
     }
     const lines = [
-        `Tracked ${snapshot.total} todo item(s): ${snapshot.pending} pending, ${snapshot.completed} completed.`,
+        `Tracked ${snapshot.summary.total} todo item(s): ${snapshot.summary.pending + snapshot.summary.inProgress + snapshot.summary.blocked} pending, ${snapshot.summary.completed} completed.`,
         ...snapshot.items.map((item, index) => `${index + 1}. [${item.status}] ${item.content}`),
     ];
     return truncateLines(lines);
 }
+export function buildRequestPlanState(input) {
+    return {
+        sessionId: input.sessionId,
+        requestId: input.requestId,
+        version: input.version ?? 1,
+        updatedAt: input.updatedAt,
+        items: input.snapshot.items,
+        summary: input.snapshot.summary,
+    };
+}

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

@@ -1,3 +1,4 @@
+import type { RuntimeScheduleManageInput, RuntimeScheduleManageResult } from "../../../contracts/types.js";
 export type BuiltinMiddlewareBackend = {
     lsInfo?: (path: string) => Promise<Array<{
         path: string;
@@ -179,13 +180,74 @@ export type BuiltinMiddlewareBackend = {
         id?: string;
         error?: string;
     };
+    manageSchedule?: (input: RuntimeScheduleManageInput) => Promise<RuntimeScheduleManageResult> | RuntimeScheduleManageResult;
 };
 export type BuiltinExecutableTool = {
     name: string;
+    description?: string;
     schema: unknown;
-    invoke: (input: unknown) => Promise<unknown>;
+    invoke: (input: unknown, config?: Record<string, unknown>) => Promise<unknown>;
 };
+export declare const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS: readonly [{
+    readonly name: "write_todos";
+    readonly description: "Create and update the runtime todo board for multi-step work.";
+}, {
+    readonly name: "read_todos";
+    readonly description: "Read the current runtime todo board.";
+}, {
+    readonly name: "ls";
+    readonly description: "List files in a directory.";
+}, {
+    readonly name: "list_files";
+    readonly description: "List files in a directory.";
+}, {
+    readonly name: "read_file";
+    readonly description: "Read a file from the workspace filesystem.";
+}, {
+    readonly name: "write_file";
+    readonly description: "Write a file in the workspace filesystem.";
+}, {
+    readonly name: "edit_file";
+    readonly description: "Replace exact text inside a workspace file.";
+}, {
+    readonly name: "glob";
+    readonly description: "Find files matching a glob pattern.";
+}, {
+    readonly name: "grep";
+    readonly description: "Search for text across workspace files.";
+}, {
+    readonly name: "search_files";
+    readonly description: "Search for text across workspace files.";
+}, {
+    readonly name: "execute";
+    readonly description: "Run a shell command in the workspace sandbox.";
+}, {
+    readonly name: "run_command";
+    readonly description: "Run a shell command in the workspace sandbox.";
+}, {
+    readonly name: "fetch_url";
+    readonly description: "Fetch a URL and return the response body.";
+}, {
+    readonly name: "http_request";
+    readonly description: "Send a structured HTTP request.";
+}, {
+    readonly name: "send_message";
+    readonly description: "Send a message through the configured backend.";
+}, {
+    readonly name: "request_approval";
+    readonly description: "Request an approval decision from the runtime.";
+}, {
+    readonly name: "schedule_task";
+    readonly description: "Create, inspect, update, list, and delete system-level scheduled tasks.";
+}, {
+    readonly name: "task";
+    readonly description: "Delegate a bounded task to a subagent.";
+}, {
+    readonly name: "delegate_task";
+    readonly description: "Delegate a bounded task to a subagent.";
+}];
 export declare function createBuiltinMiddlewareTools(backend: BuiltinMiddlewareBackend, options: {
     includeTaskTool: boolean;
     invokeTaskTool?: (input: unknown) => Promise<unknown>;
+    workspaceRoot?: string;
 }): Promise<Map<string, BuiltinExecutableTool>>;