@botbotgo/agent-harness 0.0.354 → 0.0.355

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.354";
-export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";
+export declare const AGENT_HARNESS_VERSION = "0.0.355";
+export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-25";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.354";
-export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";
+export const AGENT_HARNESS_VERSION = "0.0.355";
+export const AGENT_HARNESS_RELEASE_DATE = "2026-04-25";

package/dist/resources/prompts/runtime/autonomous-investigation-recovery.md

@@ -1 +1,10 @@
-Do not stop at a plan or ask the user to choose the next obvious diagnostic step when the request is for deep investigation, root-cause analysis, or step-by-step execution. Do not ask for more background, scope, logs, or environment details until you have first exhausted the context and tools already available in this runtime. Start from the current workspace, shell, and attached runtime/tool context by default, then continue the investigation yourself with the next concrete tool call. If the user explicitly asked for a plan, or if the task is clearly non-trivial and multi-step, call write_todos first with concrete investigation/execution steps before any other tool call or final answer. If the todo board already exists, do not restart planning and do not repeat the same clarification request; your next response must continue execution with a concrete diagnostic tool call. When prior tool results or triage evidence already exist, your next response must contain tool calls only and must advance the investigation from that evidence. Then keep executing the next diagnostic steps until you can explain the likely causes, impact, and recommended next actions. Ask a blocking clarification question only after the available evidence is genuinely insufficient to continue.
+Do not stop at a plan or ask the user to choose the next obvious diagnostic step when the request is for deep investigation, root-cause analysis, or step-by-step execution. Do not ask for more background, scope, logs, or environment details until you have first exhausted the context and tools already available in this runtime.
+
+If no concrete execution has happened yet, start from the current workspace, shell, and attached runtime/tool context by default, then continue the investigation yourself with the next concrete tool call. If the user explicitly asked for a plan, or if the task is clearly non-trivial and multi-step, call write_todos first with concrete investigation/execution steps before any other tool call or final answer.
+
+If a todo board already exists, do not restart planning and do not repeat the same clarification request. Use the current todo board and prior tool results to choose one of these terminally useful actions:
+- If more evidence is genuinely needed and an available tool can get it, make the next concrete tool call.
+- If the existing evidence is enough to answer, update the todo board to completed or blocked as appropriate, then provide the final answer grounded in the tool results.
+- If the available tools cannot resolve the remaining work, update the todo board to blocked or failed and provide a blocker report with the evidence.
+
+Never print a tool-call JSON object, function call, or tool name as prose when you intend to use a tool. Actually call the tool. Ask a blocking clarification question only after the available evidence is genuinely insufficient to continue.

package/dist/runtime/adapter/compat/deepagent-compat.d.ts

@@ -11,3 +11,9 @@ export declare function resolveDeepAgentSkillSourcePaths(options: {
     ownerId: string;
     skillPaths?: string[];
 }): string[] | undefined;
+export declare function resolveDeepAgentSkillSourceRootPaths(options: {
+    workspaceRoot?: string;
+    runtimeRoot?: string;
+    ownerId: string;
+    skillPaths?: string[];
+}): string[] | undefined;

package/dist/runtime/adapter/compat/deepagent-compat.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { existsSync } from "node:fs";
 export function relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) {
     if (!workspaceRoot || !skillPaths) {
         return skillPaths;
@@ -24,3 +25,18 @@ export function resolveDeepAgentSkillSourcePaths(options) {
     }
     return relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) ?? skillPaths;
 }
+export function resolveDeepAgentSkillSourceRootPaths(options) {
+    const { workspaceRoot, skillPaths } = options;
+    if (!skillPaths) {
+        return skillPaths;
+    }
+    const sourceRoots = Array.from(new Set(skillPaths.map((skillPath) => {
+        const absolutePath = path.isAbsolute(skillPath) || !workspaceRoot
+            ? skillPath
+            : path.resolve(workspaceRoot, skillPath);
+        return existsSync(path.join(absolutePath, "SKILL.md"))
+            ? path.dirname(absolutePath)
+            : absolutePath;
+    })));
+    return relativizeDeepAgentSkillSourcePaths(workspaceRoot, sourceRoots) ?? sourceRoots;
+}

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

@@ -4,9 +4,10 @@ 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";
+import { appendToolRecoveryInstruction, extractVisibleOutput, tryParseJson } from "../../parsing/output-parsing.js";
 import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
 import { isEmptyFinalAiMessageError } from "../resilience.js";
+import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION } from "../../prompts/runtime-prompts.js";
 function readBindingExecutionParams(binding) {
     const params = binding.execution?.params ?? binding.deepAgentParams ?? binding.langchainAgentParams;
     return {
@@ -36,6 +37,29 @@ function isDelegationOnlyBinding(binding) {
 function hasTaskDelegationEvidence(executedToolResults) {
     return executedToolResults.some((item) => item.toolName === "task");
 }
+function hasIncompleteTodos(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.some((todo) => {
+        if (typeof todo !== "object" || todo === null) {
+            return false;
+        }
+        const status = typeof todo.status === "string"
+            ? todo.status.trim().toLowerCase()
+            : "";
+        return status === "pending" || status === "in_progress";
+    });
+}
+function hasIncompleteUpstreamPlan(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const typed = value;
+    return hasIncompleteTodos(typed.todos)
+        || hasIncompleteTodos(typed.stateSnapshot?.todos)
+        || hasIncompleteTodos(typed.metadata?.stateSnapshot?.todos);
+}
 function hasNativeTaskDelegationIntent(value) {
     if (typeof value !== "object" || value === null) {
         return false;
@@ -285,11 +309,25 @@ export async function executeRequestInvocation(options) {
             toolRuntimeContext: invokeOptions.toolRuntimeContext,
         });
     }
-    const result = localOrUpstreamInvocation.result;
+    let result = localOrUpstreamInvocation.result;
     const executedToolResults = [...localOrUpstreamInvocation.executedToolResults];
     if (!result) {
         throw new Error("Agent invocation returned no result");
     }
+    if (options.resumePayload === undefined
+        && options.binding.harnessRuntime.executionContract?.requiresPlan === true
+        && hasIncompleteUpstreamPlan(result)
+        && !extractVisibleOutput(result).trim()) {
+        const messages = Array.isArray(result.messages)
+            ? result.messages
+            : undefined;
+        const recoveryBase = messages ? { messages } : request;
+        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION);
+        const recoveredInvocation = await invokeOnce(recoveredRequest);
+        localOrUpstreamInvocation = recoveredInvocation;
+        result = recoveredInvocation.result;
+        executedToolResults.splice(0, executedToolResults.length, ...recoveredInvocation.executedToolResults);
+    }
     try {
         return finalizeRequestResult({
             bindingAgentId: options.binding.agent.id,

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

@@ -57,6 +57,17 @@ function looksLikeToolBlocker(value) {
         || /invalid tool call/iu.test(normalized)
         || /tool call.*schema/iu.test(normalized);
 }
+function isSubstantiveFinalOutput(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (normalized.length < 80) {
+        return false;
+    }
+    return !looksLikeLeakedToolCallText(normalized)
+        && !looksLikeToolBlocker(normalized)
+        && !looksLikeClarificationQuestion(normalized)
+        && !looksLikeNonEvidenceApology(normalized)
+        && !isLowSignalStructuredCompletion(normalized);
+}
 function normalizeToolOutputText(output) {
     const directText = typeof output === "string"
         ? sanitizeVisibleText(output).trim()
@@ -343,18 +354,30 @@ export function finalizeRequestResult(params) {
         && !hasFinalMessageToolCalls(result)) {
         throw new Error("empty_final_output");
     }
+    const stateSnapshot = buildStateSnapshot(result);
+    const hasIncompleteRequiredPlan = binding?.harnessRuntime?.executionContract?.requiresPlan === true
+        && hasIncompleteStateSnapshotPlan(stateSnapshot);
     const serializedResult = JSON.stringify(result, null, 2);
-    const output = resolveDeterministicFinalOutput({
+    let output = resolveDeterministicFinalOutput({
         visibleOutput,
         toolFallback,
         executedToolResults: allExecutedToolResults,
     })
         || (containsLikelySkillDocument(result) ? "" : serializedResult);
+    const preliminaryTerminalStatus = readTerminalExecutionStatus(output);
+    const hasMissingRequiredFinalAnswer = binding?.harnessRuntime?.executionContract?.requiresPlan === true
+        && !visibleOutput
+        && !preliminaryTerminalStatus
+        && allExecutedToolResults.some((toolResult) => toolResult.isError !== true && toolResult.toolName !== "write_todos" && toolResult.toolName !== "read_todos");
+    if (hasIncompleteRequiredPlan && !visibleOutput) {
+        output = "runtime_error=Agent ended while required plan still had unfinished work.";
+    }
+    else if (hasMissingRequiredFinalAnswer) {
+        output = "runtime_error=Agent ended after tool execution without producing a final answer.";
+    }
     const finalMessageText = sanitizeVisibleText(output);
     const terminalStatus = structuredTerminalStatus ?? readTerminalExecutionStatus(finalMessageText);
-    const stateSnapshot = buildStateSnapshot(result);
-    const hasIncompleteRequiredPlan = binding?.harnessRuntime?.executionContract?.requiresPlan === true
-        && hasIncompleteStateSnapshotPlan(stateSnapshot);
+    const hasSubstantiveFinalOutput = Boolean(visibleOutput) && isSubstantiveFinalOutput(finalMessageText);
     const hasTerminalToolBlocker = looksLikeToolBlocker(finalMessageText);
     const memoryCandidates = allExecutedToolResults.flatMap((toolResult) => toolResult.memoryCandidates ?? []);
     return {
@@ -363,7 +386,7 @@ export function finalizeRequestResult(params) {
         agentId: bindingAgentId,
         state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0
             ? "waiting_for_approval"
-            : hasIncompleteRequiredPlan
+            : (hasIncompleteRequiredPlan && !hasSubstantiveFinalOutput) || hasMissingRequiredFinalAnswer
                 ? "failed"
                 : hasTerminalToolBlocker
                     ? "failed"

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

@@ -2,7 +2,7 @@ import type { CompiledAgentBinding, MessageContent, RequestResult, RuntimeAdapte
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn } from "./agent-runtime-assembly.js";
 import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
-export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
+export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourceRootPaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";

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

@@ -1,10 +1,10 @@
 import path from "node:path";
 import { createAsyncSubAgentMiddleware, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
-import { tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
 import { extractMessageText } from "../utils/message-content.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildDeepAgentSystemPromptWithCapabilityHierarchy, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
-import { resolveDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
+import { resolveDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourceRootPaths, } from "./adapter/compat/deepagent-compat.js";
 import { EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION } from "./prompts/runtime-prompts.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
@@ -18,7 +18,7 @@ import { resolveAdapterTools } from "./adapter/tool-resolution.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
 import { isRetryableProviderError } from "./adapter/resilience.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "./adapter/upstream-configurable-keys.js";
-export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
+export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourceRootPaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
@@ -509,13 +509,17 @@ export class AgentRuntimeAdapter {
             ? resolveRunnableCheckpointer(this.options, binding)
             : undefined;
         const resolvedStore = shouldAttachDeepAgentStore(binding) ? this.options.storeResolver?.(binding) : undefined;
-        const resolvedBackend = shouldAttachDeepAgentBackend(binding) ? this.options.backendResolver?.(binding) : undefined;
         const resolvedSkills = resolveDeepAgentSkillSourcePaths({
             workspaceRoot: binding.harnessRuntime.workspaceRoot,
             runtimeRoot: binding.harnessRuntime.runtimeRoot,
             ownerId: binding.agent.id,
             skillPaths: getBindingSkills(binding),
         }) ?? [];
+        const resolvedBackend = shouldAttachDeepAgentBackend(binding)
+            ? (this.options.backendResolver?.(binding) ?? (resolvedSkills.length > 0 ? this.resolveFilesystemBackend(binding, {
+                sessionId: options.sessionId ?? options.legacySessionId,
+            }) : undefined))
+            : undefined;
         if (shouldUseConfigurableDeepAgentAssembly(binding)) {
             return this.createConfigurableDeepAgentRunnable(binding, {
                 resolvedModel,
@@ -539,7 +543,15 @@ export class AgentRuntimeAdapter {
         const subagents = inlineSubagents;
         const middleware = [
             ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
-            ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({ backend, sources: input.resolvedSkills })] : []),
+            ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({
+                    backend,
+                    sources: resolveDeepAgentSkillSourceRootPaths({
+                        workspaceRoot: binding.harnessRuntime.workspaceRoot,
+                        runtimeRoot: binding.harnessRuntime.runtimeRoot,
+                        ownerId: binding.agent.id,
+                        skillPaths: input.resolvedSkills,
+                    }) ?? input.resolvedSkills,
+                })] : []),
             ...(builtinTools.filesystem === false ? [] : [createFilesystemMiddleware({ backend })]),
             ...(subagents.length > 0
                 ? [createSubAgentMiddleware({
@@ -645,9 +657,9 @@ export class AgentRuntimeAdapter {
                 sessionId,
                 requestId,
                 agentId: binding.agent.id,
-                state: "completed",
-                output,
-                finalMessageText: output,
+                state: compactDelegation.delegatedResult?.state ?? "completed",
+                output: sanitizeVisibleText(output),
+                finalMessageText: sanitizeVisibleText(output),
                 metadata: {
                     executedToolResults: [
                         {
@@ -750,7 +762,7 @@ export class AgentRuntimeAdapter {
         if (typeof model.invoke !== "function") {
             return null;
         }
-        const raw = await this.withTimeout(() => model.invoke(prompt, resolveLangChainInvocationConfig(binding, {
+        const raw = await this.invokeWithProviderRetry(binding, () => this.withTimeout(() => model.invoke(prompt, resolveLangChainInvocationConfig(binding, {
             sessionId,
             requestId,
             context: options.context,
@@ -759,7 +771,7 @@ export class AgentRuntimeAdapter {
                 sessionId,
                 requestId,
             }),
-        })), resolveBindingTimeout(binding), "delegation router invoke", "invoke");
+        })), resolveBindingTimeout(binding), "delegation router invoke", "invoke"));
         const parsed = parseFirstJsonObject(readModelText(raw));
         if (typeof parsed !== "object" || parsed === null) {
             return null;

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

@@ -8,6 +8,7 @@ export declare function materializeModelExposedBuiltinMiddlewareTools(input: {
     explicitToolNames?: string[];
     modelExposed?: boolean | string[];
 }): unknown[];
+export declare function buildRuntimeTemporalContext(now?: Date): string;
 export declare function buildDeepAgentSystemPromptWithCapabilityHierarchy(input: {
     systemPrompt?: unknown;
     subagents: Array<Pick<UpstreamSubagentConfig, "name" | "description"> | Pick<CompiledAsyncSubAgent, "name" | "description">>;

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

@@ -53,6 +53,21 @@ function buildSkillCatalog(skillPaths) {
         };
     });
 }
+export function buildRuntimeTemporalContext(now = new Date()) {
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "system local time";
+    return [
+        "Runtime temporal context:",
+        `- Current date/time: ${now.toISOString()}`,
+        `- Local time zone: ${timeZone}`,
+        "Use the runtime date/time above as authoritative for interpreting current, latest, recent, today, tomorrow, yesterday, and tool-returned dates.",
+        "Do not reject tool evidence as future-dated solely because it is newer than the model's training data.",
+    ].join("\n");
+}
+function appendRuntimeTemporalContext(systemPrompt) {
+    return [typeof systemPrompt === "string" ? systemPrompt : undefined, buildRuntimeTemporalContext()]
+        .filter((part) => typeof part === "string" && part.length > 0)
+        .join("\n\n");
+}
 export function buildDeepAgentSystemPromptWithCapabilityHierarchy(input) {
     const basePrompt = typeof input.systemPrompt === "string" ? input.systemPrompt : undefined;
     const skills = buildSkillCatalog(input.skills ?? []);
@@ -122,7 +137,7 @@ export function buildDeepAgentSystemPromptWithCapabilityHierarchy(input) {
             : []),
         "",
     ].join("\n");
-    return [basePrompt, catalogPrompt].filter((part) => typeof part === "string" && part.length > 0).join("\n\n");
+    return appendRuntimeTemporalContext([basePrompt, catalogPrompt].filter((part) => typeof part === "string" && part.length > 0).join("\n\n"));
 }
 export const buildDeepAgentSystemPromptWithSubagentCatalog = buildDeepAgentSystemPromptWithCapabilityHierarchy;
 export function resolveRunnableCheckpointer(options, binding) {
@@ -175,7 +190,7 @@ export function buildLangChainCreateParams(input) {
         ...(legacyPassthrough ?? {}),
         ...(langchainPassthrough ?? {}),
         ...(input.passthroughOverride ?? {}),
-        systemPrompt: input.systemPromptOverride ?? executionParams.systemPrompt,
+        systemPrompt: appendRuntimeTemporalContext(input.systemPromptOverride ?? executionParams.systemPrompt),
         model: input.resolvedModel,
         tools: input.resolvedTools,
         middleware: input.resolvedMiddleware,

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

@@ -1092,8 +1092,9 @@ export async function* streamHarnessRun(options) {
             visibleOutput: assistantOutput,
             executedToolResults,
         });
-        if (!assistantOutput && sawSuccessfulToolResult && deterministicToolEvidenceOutput) {
-            const terminalStructuredStatus = readTerminalExecutionStatus(deterministicToolEvidenceOutput);
+        const terminalStructuredStatus = readTerminalExecutionStatus(deterministicToolEvidenceOutput);
+        const canUseDeterministicToolEvidenceOutput = !currentPlanState || !planStateHasActiveItems(currentPlanState) || Boolean(terminalStructuredStatus);
+        if (!assistantOutput && sawSuccessfulToolResult && deterministicToolEvidenceOutput && canUseDeterministicToolEvidenceOutput) {
             if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
                 const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, mapTerminalStatusToPlanItemStatus(terminalStructuredStatus), new Date().toISOString());
                 const signature = buildPlanStateSignature(reconciledPlanState);

package/dist/runtime/parsing/output-content.js

@@ -59,6 +59,9 @@ function consumeLeadingFunctionLikeToolCall(value) {
 function stripVisibleFunctionLikeToolCallText(value) {
     let remaining = value.trim();
     let removedLeadingCall = false;
+    if (salvageJsonToolCalls(remaining).length > 0) {
+        return "";
+    }
     while (remaining.length > 0) {
         const consumed = consumeLeadingFunctionLikeToolCall(remaining);
         if (!consumed) {
@@ -84,6 +87,7 @@ function stripVisibleFunctionLikeToolCallText(value) {
 }
 export function sanitizeVisibleText(value) {
     return stripVisibleFunctionLikeToolCallText(value
+        .replace(/<agent_memory>[\s\S]*?<\/agent_memory>/giu, "")
         .replace(/[A-Za-z0-9_]*Middleware\.after_model/g, "")
         .replace(/todoListMiddleware\.after_model/g, "")
         .replace(/__end__+/g, "")

package/dist/runtime/parsing/output-tool-args.js

@@ -205,6 +205,43 @@ function closeJsonContainerSuffix(value) {
     }
     return `${trimmed}${stack.reverse().join("")}`;
 }
+function normalizePythonLikeJson(value) {
+    const trimmed = value.trim();
+    if (!trimmed.includes("'")) {
+        return null;
+    }
+    let output = "";
+    let inSingle = false;
+    let inDouble = false;
+    let escaping = false;
+    for (const char of trimmed) {
+        if (escaping) {
+            output += char;
+            escaping = false;
+            continue;
+        }
+        if (char === "\\") {
+            output += char;
+            escaping = true;
+            continue;
+        }
+        if (char === "\"" && !inSingle) {
+            inDouble = !inDouble;
+            output += char;
+            continue;
+        }
+        if (char === "'" && !inDouble) {
+            inSingle = !inSingle;
+            output += "\"";
+            continue;
+        }
+        output += char;
+    }
+    if (inSingle || inDouble) {
+        return null;
+    }
+    return output;
+}
 export function salvageToolArgs(value) {
     if (typeof value === "object" && value && !Array.isArray(value)) {
         return value;
@@ -255,6 +292,13 @@ export function salvageJsonToolCalls(value) {
             if (direct) {
                 return direct;
             }
+            const pythonLike = normalizePythonLikeJson(trimmed);
+            if (pythonLike) {
+                const parsed = tryParseJson(pythonLike);
+                if (parsed) {
+                    return parsed;
+                }
+            }
             const closed = closeJsonContainerSuffix(trimmed);
             if (closed) {
                 const parsed = tryParseJson(closed);

package/package.json

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