@botbotgo/agent-harness 0.0.351 → 0.0.353

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

@@ -10,7 +10,7 @@ import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { applyToolRecoveryInstruction as applyToolRecoveryInstructionHelper, applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
 import { extractSubagentRequestText, invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, materializeAutomaticSummarizationMiddleware as materializeAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainRuntimeExtensionMiddleware as resolveLangChainRuntimeExtensionMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, wrapRequestResultAsSubagentResponse, } from "./adapter/middleware-assembly.js";
-import { resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
+import { isEmptyFinalAiMessageError, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { renderDirectWorkspaceListing, shouldDirectlyListWorkspaceFiles } from "./adapter/direct-builtin-utility.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
@@ -585,7 +585,7 @@ export class AgentRuntimeAdapter {
             sessionId,
             requestId,
         });
-        return this.invokeWithProviderRetry(binding, async () => executeRequestInvocation({
+        const invokeRequest = () => executeRequestInvocation({
             binding,
             input,
             sessionId,
@@ -600,7 +600,17 @@ export class AgentRuntimeAdapter {
             getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
             resolveBuiltinMiddlewareTools: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareTools(currentBinding, { ...currentOptions, sessionId, requestId }),
             callRuntimeWithToolParseRecovery,
-        }));
+        });
+        try {
+            return await invokeRequest();
+        }
+        catch (error) {
+            if (!isEmptyFinalAiMessageError(error)) {
+                throw error;
+            }
+            this.invalidateBindingRuntimeCaches(binding);
+            return invokeRequest();
+        }
     }
     async *stream(binding, input, sessionId, history = [], options = {}) {
         const directListing = await this.tryHandleDirectWorkspaceListing(binding, input, {

package/dist/runtime/harness/events/event-sink.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from "node:events";
 import { getEventSubscribers } from "../../../tooling/extensions.js";
+const EVENT_PROJECTION_DRAIN_TIMEOUT_MS = 1_000;
 function dispatchListener(listener, event) {
     void Promise.resolve(listener(event));
 }
@@ -34,8 +35,24 @@ export class RuntimeEventSinkImpl {
         return () => this.projections.delete(projection);
     }
     async drain() {
-        while (this.inflightProjectionTasks.size > 0) {
-            await Promise.allSettled(Array.from(this.inflightProjectionTasks));
+        let timeoutHandle;
+        try {
+            await Promise.race([
+                (async () => {
+                    while (this.inflightProjectionTasks.size > 0) {
+                        await Promise.allSettled(Array.from(this.inflightProjectionTasks));
+                    }
+                })(),
+                new Promise((resolve) => {
+                    timeoutHandle = setTimeout(resolve, EVENT_PROJECTION_DRAIN_TIMEOUT_MS);
+                    timeoutHandle.unref?.();
+                }),
+            ]);
+        }
+        finally {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
         }
     }
 }

package/dist/runtime/harness/system/boundary-analysis.d.ts

@@ -0,0 +1,42 @@
+import type { WorkspaceBundle } from "../../../contracts/types.js";
+export type BoundaryFindingSeverity = "info" | "warning" | "error";
+export type BoundaryFinding = {
+    severity: BoundaryFindingSeverity;
+    code: string;
+    message: string;
+    agentId?: string;
+    parentAgentId?: string;
+    toolName?: string;
+    skillName?: string;
+    skillPath?: string;
+    relatedAgents?: string[];
+    sourcePath?: string;
+};
+export type BoundaryAgentSurface = {
+    id: string;
+    description: string;
+    tools: string[];
+    skills: string[];
+    subagents: string[];
+    sourcePath?: string;
+    parentAgentId?: string;
+};
+export type BoundaryAnalysisSummary = {
+    agentCount: number;
+    toolCount: number;
+    skillCount: number;
+    findingCount: number;
+    errorCount: number;
+    warningCount: number;
+    infoCount: number;
+};
+export type WorkspaceBoundaryAnalysis = {
+    workspaceRoot: string;
+    summary: BoundaryAnalysisSummary;
+    agents: BoundaryAgentSurface[];
+    findings: BoundaryFinding[];
+};
+export type BoundaryAnalysisOptions = {
+    includeInfo?: boolean;
+};
+export declare function analyzeWorkspaceBoundaries(workspace: WorkspaceBundle, options?: BoundaryAnalysisOptions): WorkspaceBoundaryAnalysis;

package/dist/runtime/harness/system/boundary-analysis.js

@@ -0,0 +1,234 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { readSkillMetadata } from "../../skills/skill-metadata.js";
+import { getBindingPrimaryTools, getBindingSkills, getBindingSubagents, } from "../../support/compiled-binding.js";
+const BUILTIN_SKILL_TOOLS = new Set(["read_todos", "write_todos"]);
+function uniqueSorted(values) {
+    return Array.from(new Set(values.filter((value) => value.trim().length > 0))).sort();
+}
+function addFinding(findings, options, finding) {
+    if (finding.severity === "info" && options.includeInfo === false) {
+        return;
+    }
+    findings.push(finding);
+}
+function discoverWorkspaceSkillPaths(workspaceRoot, referencedSkillPaths) {
+    const skillPaths = new Set(referencedSkillPaths);
+    const skillsRoot = path.join(workspaceRoot, "resources", "skills");
+    if (!existsSync(skillsRoot)) {
+        return uniqueSorted(Array.from(skillPaths));
+    }
+    for (const entry of readdirSync(skillsRoot)) {
+        const skillPath = path.join(skillsRoot, entry);
+        try {
+            if (statSync(skillPath).isDirectory() && existsSync(path.join(skillPath, "SKILL.md"))) {
+                skillPaths.add(skillPath);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return uniqueSorted(Array.from(skillPaths));
+}
+function describeTopLevelSurface(binding) {
+    return {
+        id: binding.agent.id,
+        description: binding.agent.description,
+        tools: uniqueSorted(getBindingPrimaryTools(binding).map((tool) => tool.name)),
+        skills: uniqueSorted(getBindingSkills(binding)),
+        subagents: uniqueSorted(getBindingSubagents(binding).map((subagent) => subagent.name)),
+        sourcePath: binding.agent.sourcePath,
+    };
+}
+function describeSubagentSurface(subagent, parentAgentId) {
+    return {
+        id: subagent.name,
+        description: subagent.description,
+        tools: uniqueSorted((subagent.tools ?? []).map((tool) => tool.name)),
+        skills: uniqueSorted(subagent.skills ?? []),
+        subagents: [],
+        parentAgentId,
+    };
+}
+function addOwner(index, key, agentId) {
+    const owners = index.get(key) ?? [];
+    owners.push(agentId);
+    index.set(key, owners);
+}
+function stripAgentRefPrefix(value) {
+    const prefix = "agent/";
+    return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+}
+export function analyzeWorkspaceBoundaries(workspace, options = {}) {
+    const findings = [];
+    const agentSurfaces = [];
+    const referencedSkillPaths = [];
+    const toolOwners = new Map();
+    const skillOwners = new Map();
+    const skillSurfaceOwners = new Map();
+    for (const binding of workspace.bindings.values()) {
+        const topLevel = describeTopLevelSurface(binding);
+        agentSurfaces.push(topLevel);
+        for (const skillPath of topLevel.skills) {
+            referencedSkillPaths.push(skillPath);
+        }
+        for (const subagent of getBindingSubagents(binding)) {
+            const surface = describeSubagentSurface(subagent, binding.agent.id);
+            agentSurfaces.push(surface);
+            for (const skillPath of surface.skills) {
+                referencedSkillPaths.push(skillPath);
+            }
+        }
+    }
+    for (const surface of agentSurfaces) {
+        if (surface.description.trim().length === 0) {
+            addFinding(findings, options, {
+                severity: "warning",
+                code: "agent-missing-description",
+                message: `Agent '${surface.id}' has no description, making routing boundaries ambiguous.`,
+                agentId: surface.id,
+                parentAgentId: surface.parentAgentId,
+                sourcePath: surface.sourcePath,
+            });
+        }
+        if (surface.subagents.length > 0 && (surface.tools.length > 0 || surface.skills.length > 0)) {
+            addFinding(findings, options, {
+                severity: "warning",
+                code: "mixed-routing-and-execution-surface",
+                message: `Agent '${surface.id}' declares subagents and also exposes local tools or skills.`,
+                agentId: surface.id,
+                sourcePath: surface.sourcePath,
+            });
+        }
+        if (surface.subagents.length === 0 && surface.tools.length === 0 && surface.skills.length === 0) {
+            addFinding(findings, options, {
+                severity: "info",
+                code: "empty-execution-surface",
+                message: `Agent '${surface.id}' has no tools, skills, or subagents declared.`,
+                agentId: surface.id,
+                parentAgentId: surface.parentAgentId,
+                sourcePath: surface.sourcePath,
+            });
+        }
+        for (const toolName of surface.tools) {
+            addOwner(toolOwners, toolName, surface.id);
+        }
+        for (const skillPath of surface.skills) {
+            addOwner(skillOwners, skillPath, surface.id);
+            skillSurfaceOwners.set(skillPath, [...(skillSurfaceOwners.get(skillPath) ?? []), surface]);
+        }
+    }
+    for (const agent of workspace.agents.values()) {
+        for (const subagentRef of agent.subagentRefs) {
+            const subagentId = stripAgentRefPrefix(subagentRef);
+            if (!workspace.agents.has(subagentId)) {
+                addFinding(findings, options, {
+                    severity: "error",
+                    code: "missing-subagent-reference",
+                    message: `Agent '${agent.id}' references missing subagent '${subagentRef}'.`,
+                    agentId: agent.id,
+                    sourcePath: agent.sourcePath,
+                });
+            }
+        }
+    }
+    for (const [toolName, owners] of toolOwners) {
+        const uniqueOwners = uniqueSorted(owners);
+        if (uniqueOwners.length > 1) {
+            addFinding(findings, options, {
+                severity: "info",
+                code: "shared-tool-surface",
+                message: `Tool '${toolName}' is exposed by multiple agents; review whether the shared surface is intentional.`,
+                toolName,
+                relatedAgents: uniqueOwners,
+            });
+        }
+    }
+    for (const [skillPath, owners] of skillOwners) {
+        const uniqueOwners = uniqueSorted(owners);
+        if (uniqueOwners.length > 1) {
+            const metadata = readSkillMetadata(skillPath);
+            addFinding(findings, options, {
+                severity: "info",
+                code: "shared-skill-surface",
+                message: `Skill '${metadata.name}' is exposed by multiple agents; review whether the shared surface is intentional.`,
+                skillName: metadata.name,
+                skillPath,
+                relatedAgents: uniqueOwners,
+            });
+        }
+    }
+    for (const tool of workspace.tools.values()) {
+        if (!toolOwners.has(tool.name)) {
+            addFinding(findings, options, {
+                severity: "warning",
+                code: "unreferenced-tool",
+                message: `Tool '${tool.name}' is defined but not exposed by any agent or subagent.`,
+                toolName: tool.name,
+                sourcePath: tool.sourcePath,
+            });
+        }
+    }
+    const discoveredSkillPaths = discoverWorkspaceSkillPaths(workspace.workspaceRoot, referencedSkillPaths);
+    for (const skillPath of discoveredSkillPaths) {
+        const metadata = readSkillMetadata(skillPath);
+        const owners = skillOwners.get(skillPath) ?? [];
+        if (owners.length === 0) {
+            addFinding(findings, options, {
+                severity: "warning",
+                code: "unreferenced-skill",
+                message: `Skill '${metadata.name}' is present but not exposed by any agent or subagent.`,
+                skillName: metadata.name,
+                skillPath,
+            });
+            continue;
+        }
+        if (!metadata.allowedTools || metadata.allowedTools.length === 0) {
+            addFinding(findings, options, {
+                severity: "warning",
+                code: "skill-missing-allowed-tools",
+                message: `Skill '${metadata.name}' does not declare allowed-tools.`,
+                skillName: metadata.name,
+                skillPath,
+                relatedAgents: uniqueSorted(owners),
+            });
+            continue;
+        }
+        for (const surface of skillSurfaceOwners.get(skillPath) ?? []) {
+            const owner = surface.parentAgentId ? `${surface.parentAgentId}/${surface.id}` : surface.id;
+            const availableTools = new Set([...surface.tools, ...BUILTIN_SKILL_TOOLS]);
+            for (const allowedTool of metadata.allowedTools) {
+                if (!availableTools.has(allowedTool)) {
+                    addFinding(findings, options, {
+                        severity: "error",
+                        code: "skill-allowed-tool-unavailable",
+                        message: `Skill '${metadata.name}' allows tool '${allowedTool}', but agent '${owner}' does not expose it.`,
+                        agentId: surface.id,
+                        parentAgentId: surface.parentAgentId,
+                        toolName: allowedTool,
+                        skillName: metadata.name,
+                        skillPath,
+                    });
+                }
+            }
+        }
+    }
+    const errorCount = findings.filter((finding) => finding.severity === "error").length;
+    const warningCount = findings.filter((finding) => finding.severity === "warning").length;
+    const infoCount = findings.filter((finding) => finding.severity === "info").length;
+    return {
+        workspaceRoot: workspace.workspaceRoot,
+        summary: {
+            agentCount: agentSurfaces.length,
+            toolCount: workspace.tools.size,
+            skillCount: discoveredSkillPaths.length,
+            findingCount: findings.length,
+            errorCount,
+            warningCount,
+            infoCount,
+        },
+        agents: agentSurfaces,
+        findings,
+    };
+}

package/dist/runtime/harness.d.ts

@@ -1,6 +1,7 @@
 import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, RuntimeOperatorOverview, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RequestPlanState, RequestOptions, RequestRecord, RequestResult, RequestSummary, RequestStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeArtifactWriteInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, RuntimeRequestPackage, RuntimeRequestPackageInput, RuntimeSessionPackage, RuntimeSessionPackageInput, ResumeOptions, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, SessionSummary, SessionRecord, SessionListSummary, WorkspaceBundle } from "../contracts/types.js";
 import { type RuntimeMcpServerOptions, type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./harness/system/inventory.js";
+import { type BoundaryAnalysisOptions, type WorkspaceBoundaryAnalysis } from "./harness/system/boundary-analysis.js";
 import type { RequirementAssessmentOptions } from "./harness/system/skill-requirements.js";
 import { SystemScheduleManager } from "./scheduling/system-schedule-manager.js";
 export declare class AgentHarnessRuntime {
@@ -119,6 +120,7 @@ export declare class AgentHarnessRuntime {
         workspaceRoot: string;
         agents: InventoryAgentRecord[];
     };
+    analyzeWorkspaceBoundaries(options?: BoundaryAnalysisOptions): WorkspaceBoundaryAnalysis;
     private deleteSessionCheckpoints;
     deleteSession(sessionId: string): Promise<boolean>;
     createToolMcpServer(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
@@ -133,6 +135,7 @@ export declare class AgentHarnessRuntime {
     private trackBackgroundTask;
     private scheduleBackgroundStartupTask;
     private drainBackgroundTasksForClose;
+    private closeStageWithTimeout;
     private resolveToolMcpServerTools;
     private loadPriorHistory;
     private loadRequestInput;

package/dist/runtime/harness.js

@@ -30,6 +30,7 @@ import { closeMcpClientsForWorkspace } from "../resource/mcp/tool-support.js";
 import { getBindingRuntimeExecutionMode, } from "./support/compiled-binding.js";
 import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
 import { describeWorkspaceInventory, getAgentInventoryRecord, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
+import { analyzeWorkspaceBoundaries, } from "./harness/system/boundary-analysis.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isSessionMemorySyncEnabled, } from "./harness/runtime-defaults.js";
 import { cloneRequestRecord, cloneSessionRecord, deriveRequestInputFromTranscript, mergeMemoryItems, summarizeApprovalEvidence, toPublicHarnessStreamItem, toPublicRequestResultShape, toSessionListSummary, } from "./harness/public-shapes.js";
 import { Mem0IngestionSync, Mem0SemanticRecall, readMem0RuntimeConfig, } from "./harness/system/mem0-ingestion-sync.js";
@@ -47,6 +48,7 @@ import { buildRequestInspectionRecord, buildSessionInspectionRecord, deleteSessi
 import { createKnowledgeModule } from "../knowledge/index.js";
 import { createProceduralMemoryManager, ProceduralMemoryFormationSync, readProceduralMemoryRuntimeConfig, } from "../knowledge/procedural/index.js";
 const BACKGROUND_TASK_CLOSE_DRAIN_TIMEOUT_MS = 1_000;
+const CLOSE_STAGE_TIMEOUT_MS = 1_000;
 const ACTIVE_REQUEST_STATES = [
     "queued",
     "claimed",
@@ -876,6 +878,9 @@ export class AgentHarnessRuntime {
             ...options,
         });
     }
+    analyzeWorkspaceBoundaries(options = {}) {
+        return analyzeWorkspaceBoundaries(this.workspace, options);
+    }
     async deleteSessionCheckpoints(sessionId) {
         const resolver = this.resolvedRuntimeAdapterOptions.checkpointerResolver;
         if (!resolver) {
@@ -963,6 +968,22 @@ export class AgentHarnessRuntime {
             clearTimeout(timeoutHandle);
         }
     }
+    async closeStageWithTimeout(_label, stage) {
+        if (!stage) {
+            return;
+        }
+        let timeoutHandle;
+        await Promise.race([
+            stage().then(() => undefined).catch(() => undefined),
+            new Promise((resolve) => {
+                timeoutHandle = setTimeout(resolve, CLOSE_STAGE_TIMEOUT_MS);
+                timeoutHandle.unref?.();
+            }),
+        ]);
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
     resolveToolMcpServerTools(agentId) {
         return resolveWorkspaceAgentTools({
             workspace: this.workspace,
@@ -1386,20 +1407,20 @@ export class AgentHarnessRuntime {
             return;
         }
         this.closed = true;
-        await this.healthMonitor?.stop();
-        await this.eventBus.drain();
+        await this.closeStageWithTimeout("healthMonitor.stop", () => this.healthMonitor?.stop() ?? Promise.resolve());
+        await this.closeStageWithTimeout("eventBus.drain", () => this.eventBus.drain());
         this.unregisterSessionMemorySync();
         this.unregisterRuntimeMemorySync();
         this.unregisterMem0IngestionSync();
         this.unregisterRuntimeMemoryFormationSync();
         this.unregisterProceduralMemoryFormationSync();
         await this.drainBackgroundTasksForClose();
-        await this.sessionMemorySync?.close();
-        await this.runtimeMemorySync?.close();
-        await this.mem0IngestionSync?.close();
-        await this.runtimeMemoryFormationSync?.close();
-        await this.proceduralMemoryFormationSync?.close();
-        await closeMcpClientsForWorkspace(this.workspace);
+        await this.closeStageWithTimeout("sessionMemorySync.close", () => this.sessionMemorySync?.close() ?? Promise.resolve());
+        await this.closeStageWithTimeout("runtimeMemorySync.close", () => this.runtimeMemorySync?.close() ?? Promise.resolve());
+        await this.closeStageWithTimeout("mem0IngestionSync.close", () => this.mem0IngestionSync?.close() ?? Promise.resolve());
+        await this.closeStageWithTimeout("runtimeMemoryFormationSync.close", () => this.runtimeMemoryFormationSync?.close() ?? Promise.resolve());
+        await this.closeStageWithTimeout("proceduralMemoryFormationSync.close", () => this.proceduralMemoryFormationSync?.close() ?? Promise.resolve());
+        await this.closeStageWithTimeout("closeMcpClientsForWorkspace", () => closeMcpClientsForWorkspace(this.workspace));
         this.initialized = false;
     }
     async stop() {

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

@@ -1,5 +1,5 @@
 import { AIMessage } from "langchain";
-import { salvageFunctionLikeToolCall, salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
+import { salvageFunctionLikeToolCall, salvageJsonToolCalls, salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
 function consumeLeadingFunctionLikeToolCall(value) {
     const match = /^([A-Za-z_][A-Za-z0-9_]*)\(/.exec(value);
     if (!match) {
@@ -495,8 +495,12 @@ function normalizeAgentMessage(value) {
     const functionLikeToolCall = normalizedToolCalls.length === 0 && recoveredToolCalls.length === 0 && typeof normalizedContent === "string"
         ? salvageFunctionLikeToolCall(normalizedContent)
         : null;
+    const jsonToolCalls = normalizedToolCalls.length === 0 && recoveredToolCalls.length === 0 && !functionLikeToolCall && typeof normalizedContent === "string"
+        ? salvageJsonToolCalls(normalizedContent)
+        : [];
+    const hasRecoveredContentToolCalls = Boolean(functionLikeToolCall) || jsonToolCalls.length > 0;
     return new AIMessage({
-        content: functionLikeToolCall ? "" : normalizedContent,
+        content: hasRecoveredContentToolCalls ? "" : normalizedContent,
         name: typeof typed.name === "string" ? typed.name : undefined,
         additional_kwargs: typeof typed.additional_kwargs === "object" && typed.additional_kwargs ? typed.additional_kwargs : {},
         response_metadata: typeof typed.response_metadata === "object" && typed.response_metadata ? typed.response_metadata : {},
@@ -505,6 +509,7 @@ function normalizeAgentMessage(value) {
             ...normalizedToolCalls,
             ...recoveredToolCalls,
             ...(functionLikeToolCall ? [{ name: functionLikeToolCall.name, args: functionLikeToolCall.args }] : []),
+            ...jsonToolCalls.map((toolCall) => ({ name: toolCall.name, args: toolCall.args })),
         ],
         invalid_tool_calls: normalizedInvalidToolCalls.filter((toolCall) => toolCall.type !== "tool_call"),
         usage_metadata: typeof typed.usage_metadata === "object" && typed.usage_metadata ? typed.usage_metadata : undefined,

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

@@ -1,5 +1,6 @@
 import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 import { wrapNormalizedMessage, readTextContent } from "./output-content.js";
+import { salvageJsonToolCalls } from "./output-tool-args.js";
 function collectRequestMessages(request) {
     if (typeof request !== "object" || !request || Array.isArray(request)) {
         return [];
@@ -145,12 +146,15 @@ export function resolveExecutionWithoutToolEvidenceTextInstruction(request, assi
     const hasUnfinishedExecution = resultEvidence.hasIncompletePlanState === true
         || resultEvidence.hasOpenTaskDelegation === true
         || resultEvidence.hasMissingDelegatedExecutionEvidence === true;
-    if (!normalizedText || !hasUnfinishedExecution) {
-        return null;
+    if (salvageJsonToolCalls(normalizedText).length > 0) {
+        return STRICT_TOOL_JSON_INSTRUCTION;
     }
     const hasExecutionEvidence = toolCallEvidence
         || resultEvidence.hasWriteTodosEvidence === true
         || resultEvidence.hasToolResultEvidence === true;
+    if (!normalizedText || !hasUnfinishedExecution) {
+        return null;
+    }
     return hasExecutionEvidence
         ? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION
         : EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION;

package/dist/runtime/parsing/output-tool-args.d.ts

@@ -4,5 +4,9 @@ export declare function salvageFunctionLikeToolCall(value: unknown): {
     args: Record<string, unknown>;
 } | null;
 export declare function salvageToolArgs(value: unknown): Record<string, unknown> | null;
+export declare function salvageJsonToolCalls(value: unknown): Array<{
+    name: string;
+    args: Record<string, unknown>;
+}>;
 export declare function normalizeKnownToolArgs(toolName: unknown, args: Record<string, unknown>): Record<string, unknown>;
 export declare function isLikelyToolArgsObject(value: unknown): boolean;

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

@@ -112,8 +112,8 @@ export function salvageFunctionLikeToolCall(value) {
     }
     return { name, args: normalizeKnownToolArgs(name, args) };
 }
-function extractBalancedJsonObject(value) {
-    const start = value.indexOf("{");
+function extractBalancedJsonValue(value, openChar, closeChar) {
+    const start = value.indexOf(openChar);
     if (start < 0)
         return null;
     let depth = 0;
@@ -139,11 +139,11 @@ function extractBalancedJsonObject(value) {
             inString = true;
             continue;
         }
-        if (char === "{") {
+        if (char === openChar) {
             depth += 1;
             continue;
         }
-        if (char === "}") {
+        if (char === closeChar) {
             depth -= 1;
             if (depth === 0) {
                 return value.slice(start, index + 1);
@@ -152,6 +152,59 @@ function extractBalancedJsonObject(value) {
     }
     return null;
 }
+function extractBalancedJsonObject(value) {
+    return extractBalancedJsonValue(value, "{", "}");
+}
+function extractBalancedJsonArray(value) {
+    return extractBalancedJsonValue(value, "[", "]");
+}
+function closeJsonContainerSuffix(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+        return null;
+    }
+    const stack = [];
+    let inString = false;
+    let escaping = false;
+    for (const char of trimmed) {
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaping = true;
+                continue;
+            }
+            if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+            continue;
+        }
+        if (char === "{") {
+            stack.push("}");
+            continue;
+        }
+        if (char === "[") {
+            stack.push("]");
+            continue;
+        }
+        if (char === "}" || char === "]") {
+            const expected = stack.pop();
+            if (expected !== char) {
+                return null;
+            }
+        }
+    }
+    if (inString || stack.length === 0) {
+        return null;
+    }
+    return `${trimmed}${stack.reverse().join("")}`;
+}
 export function salvageToolArgs(value) {
     if (typeof value === "object" && value && !Array.isArray(value)) {
         return value;
@@ -174,6 +227,63 @@ export function salvageToolArgs(value) {
     const parsed = tryParseJson(embedded);
     return typeof parsed === "object" && parsed && !Array.isArray(parsed) ? parsed : null;
 }
+function normalizeJsonToolCallPayload(payload) {
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        return null;
+    }
+    const typed = payload;
+    const functionPayload = typeof typed.function === "object" && typed.function !== null ? typed.function : undefined;
+    const nameCandidate = typed.name ?? typed.tool ?? functionPayload?.name;
+    const name = typeof nameCandidate === "string" ? nameCandidate.trim() : "";
+    if (!name) {
+        return null;
+    }
+    const argsCandidate = typed.arguments ?? typed.args ?? typed.parameters ?? typed.input ?? functionPayload?.arguments ?? {};
+    const args = Array.isArray(argsCandidate)
+        ? { args: argsCandidate }
+        : salvageToolArgs(argsCandidate) ?? {};
+    return { name, args: normalizeKnownToolArgs(name, args) };
+}
+export function salvageJsonToolCalls(value) {
+    const payload = typeof value === "string"
+        ? (() => {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                return null;
+            }
+            const direct = tryParseJson(trimmed);
+            if (direct) {
+                return direct;
+            }
+            const closed = closeJsonContainerSuffix(trimmed);
+            if (closed) {
+                const parsed = tryParseJson(closed);
+                if (parsed) {
+                    return parsed;
+                }
+            }
+            const embeddedArray = extractBalancedJsonArray(trimmed);
+            if (embeddedArray) {
+                const parsed = tryParseJson(embeddedArray);
+                if (parsed) {
+                    return parsed;
+                }
+            }
+            const embeddedObject = extractBalancedJsonObject(trimmed);
+            if (embeddedObject) {
+                const parsed = tryParseJson(embeddedObject);
+                if (parsed) {
+                    return parsed;
+                }
+            }
+            return null;
+        })()
+        : value;
+    const candidates = Array.isArray(payload) ? payload : [payload];
+    return candidates
+        .map((item) => normalizeJsonToolCallPayload(item))
+        .filter((item) => item !== null);
+}
 function normalizeWriteTodosArgs(args) {
     if (!Array.isArray(args.todos)) {
         return args;