salmon-loop 0.2.13 → 0.2.16

package/dist/core/tools/session.js

@@ -6,6 +6,7 @@ import { recordAuditEvent } from '../observability/audit-trail.js';
 import { getLogger } from '../observability/logger.js';
 import { CanonicalResponsesEventEmitter, } from '../streaming/canonical/canonical-responses-event-emitter.js';
 import { mapLlmStreamChunkToCanonicalStreamParts } from '../streaming/canonical/parts-from-llm-stream-chunk.js';
+import { ArtifactStore } from '../sub-agent/artifacts/store.js';
 import { Phase } from '../types/runtime.js';
 import { isSafeRelativePath, normalizePath } from '../utils/path.js';
 import { buildHeadlessToolInputPayload } from './headless-payload.js';
@@ -13,7 +14,9 @@ import { toolToOpenAI } from './mapper.js';
 import { InMemoryLockManager } from './parallel/lock-manager.js';
 import { PlanPersistence } from './parallel/persistence.js';
 import { ParallelScheduler } from './parallel/scheduler.js';
+import { isRecoverableToolInputErrorCode } from './recoverable-tool-errors.js';
 import { ToolCallAccumulator } from './streaming/ToolCallAccumulator.js';
+import { resolveVisibleToolSpecs } from './tool-visibility.js';
 function safeParseJson(argsText) {
     if (typeof argsText !== 'string') {
         return { ok: true, value: argsText };
@@ -80,7 +83,156 @@ function safeStringifyForAudit(value) {
         return '[Unserializable]';
     }
 }
+function buildToolCorrectionHint(result) {
+    const errorCode = result.error?.code;
+    const tool = result.toolName;
+    if (!isRecoverableToolInputErrorCode(errorCode) || !tool)
+        return undefined;
+    return {
+        kind: 'adjust_arguments',
+        tool,
+        hint: result.error?.message ||
+            `Adjust the arguments for ${tool} and retry with a valid JSON object.`,
+        retryable: true,
+    };
+}
+function normalizeRecoverableToolResult(result) {
+    if (!result.error)
+        return result;
+    const retryHint = buildToolCorrectionHint(result);
+    if (!retryHint)
+        return result;
+    const nextMeta = {
+        ...(result.meta ?? {}),
+        retryHint,
+    };
+    const nextError = {
+        ...result.error,
+        retryable: retryHint.retryable || result.error.retryable,
+    };
+    return {
+        ...result,
+        meta: nextMeta,
+        error: nextError,
+    };
+}
+function isArtifactHandleRecord(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (typeof candidate.handle === 'string' &&
+        typeof candidate.mimeType === 'string' &&
+        typeof candidate.sha256 === 'string' &&
+        typeof candidate.size === 'number');
+}
+function extractArtifactHandlesFromToolOutput(output) {
+    if (!isObjectRecord(output)) {
+        return {};
+    }
+    const patchArtifact = isArtifactHandleRecord(output.patchArtifact)
+        ? output.patchArtifact
+        : undefined;
+    const auditArtifact = isArtifactHandleRecord(output.auditArtifact)
+        ? output.auditArtifact
+        : undefined;
+    return {
+        patchArtifact,
+        auditArtifact,
+    };
+}
+function extractRecentReadResult(params) {
+    if (params.toolName !== 'fs.read' && params.toolName !== 'code.read') {
+        return undefined;
+    }
+    if (!isObjectRecord(params.output) || typeof params.output.content !== 'string') {
+        return undefined;
+    }
+    const args = safeParseJson(params.rawArgs);
+    const argsValue = args.ok ? args.value : params.rawArgs;
+    if (!isObjectRecord(argsValue))
+        return undefined;
+    const file = argsValue.file ?? argsValue.file_path ?? argsValue.filePath ?? argsValue.path;
+    if (typeof file !== 'string' || !file.trim())
+        return undefined;
+    return {
+        path: file,
+        content: params.output.content,
+    };
+}
+async function persistRecentReadArtifact(params) {
+    const readResult = extractRecentReadResult(params);
+    if (!readResult)
+        return undefined;
+    const ext = path.extname(readResult.path).replace(/^\./, '') || 'txt';
+    const artifact = await ArtifactStore.saveText({
+        content: readResult.content,
+        mimeType: 'text/plain',
+        fileExt: ext,
+    });
+    return {
+        path: readResult.path,
+        artifact,
+    };
+}
+const TOOL_RESULT_PREVIEW_MIN_CHARS = 1200;
+function sanitizeToolResultPreviewLabel(label) {
+    const oneLine = label.replace(/\s+/g, ' ').trim();
+    if (!oneLine)
+        return 'Tool result preview';
+    if (oneLine.length <= 120)
+        return oneLine;
+    return `${oneLine.slice(0, 119).trimEnd()}…`;
+}
+function serializeToolResultOutputForArtifact(output) {
+    if (typeof output === 'string') {
+        const text = output.trim();
+        if (!text)
+            return undefined;
+        return {
+            content: output,
+            mimeType: 'text/plain',
+            fileExt: 'txt',
+        };
+    }
+    if (output === undefined)
+        return undefined;
+    try {
+        const json = JSON.stringify(output, null, 2);
+        if (!json || !json.trim())
+            return undefined;
+        return {
+            content: json,
+            mimeType: 'application/json',
+            fileExt: 'json',
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function persistToolResultPreviewArtifact(params) {
+    if (params.toolName === 'fs.read' || params.toolName === 'code.read') {
+        return undefined;
+    }
+    const serialized = serializeToolResultOutputForArtifact(params.output);
+    if (!serialized)
+        return undefined;
+    if (serialized.content.length < TOOL_RESULT_PREVIEW_MIN_CHARS)
+        return undefined;
+    const artifact = await ArtifactStore.saveText({
+        content: serialized.content,
+        mimeType: serialized.mimeType,
+        fileExt: serialized.fileExt,
+    });
+    const detail = params.outputSummary ?? params.summary ?? `${params.toolName} output`;
+    return {
+        label: sanitizeToolResultPreviewLabel(`Tool result preview: ${detail}`),
+        artifact,
+    };
+}
 function defaultMaxToolCallsTotalForPhase(phase) {
+    if (phase === Phase.AUTOPILOT)
+        return 32;
     if (phase === Phase.EXPLORE)
         return 18;
     if (phase === Phase.PLAN)
@@ -90,6 +242,8 @@ function defaultMaxToolCallsTotalForPhase(phase) {
     return 10;
 }
 function defaultMaxToolCallsPerRoundForPhase(phase) {
+    if (phase === Phase.AUTOPILOT)
+        return 8;
     if (phase === Phase.EXPLORE)
         return 6;
     if (phase === Phase.PLAN)
@@ -98,7 +252,25 @@ function defaultMaxToolCallsPerRoundForPhase(phase) {
         return 4;
     return 4;
 }
-function getToolCallBudget(session) {
+function defaultMaxAgentToolCallsTotalForPhase(phase) {
+    if (phase === Phase.AUTOPILOT)
+        return 4;
+    if (phase === Phase.PLAN)
+        return 2;
+    if (phase === Phase.CONTEXT)
+        return 1;
+    return 1;
+}
+function defaultMaxAgentToolCallsPerRoundForPhase(phase) {
+    if (phase === Phase.AUTOPILOT)
+        return 2;
+    if (phase === Phase.PLAN)
+        return 1;
+    if (phase === Phase.CONTEXT)
+        return 1;
+    return 1;
+}
+function getRegularToolCallBudget(session) {
     const maxTotal = session.maxToolCallsTotal ?? defaultMaxToolCallsTotalForPhase(session.phase);
     const maxPerRound = session.maxToolCallsPerRound ?? defaultMaxToolCallsPerRoundForPhase(session.phase);
     return {
@@ -106,39 +278,62 @@ function getToolCallBudget(session) {
         maxPerRound: Math.max(0, Math.floor(maxPerRound)),
     };
 }
+function getAgentToolCallBudget(session) {
+    const maxTotal = session.maxAgentToolCallsTotal ?? defaultMaxAgentToolCallsTotalForPhase(session.phase);
+    const maxPerRound = session.maxAgentToolCallsPerRound ?? defaultMaxAgentToolCallsPerRoundForPhase(session.phase);
+    return {
+        maxTotal: Math.max(0, Math.floor(maxTotal)),
+        maxPerRound: Math.max(0, Math.floor(maxPerRound)),
+    };
+}
+function createToolCallBudgetBucketsState(session) {
+    return {
+        regular: { used: 0, ...getRegularToolCallBudget(session) },
+        agent: { used: 0, ...getAgentToolCallBudget(session) },
+    };
+}
 function resetToolCallBudgetState(session) {
-    const budget = getToolCallBudget(session);
-    const state = { used: 0, ...budget };
+    const state = createToolCallBudgetBucketsState(session);
     session.__toolCallBudgetState = state;
     return state;
 }
 function getToolCallBudgetState(session) {
-    const budget = getToolCallBudget(session);
     const anySession = session;
     const existing = anySession.__toolCallBudgetState;
     if (!existing) {
-        const created = { used: 0, ...budget };
+        const created = createToolCallBudgetBucketsState(session);
         anySession.__toolCallBudgetState = created;
         return created;
     }
     // Ensure runtime overrides are respected.
-    existing.maxTotal = budget.maxTotal;
-    existing.maxPerRound = budget.maxPerRound;
+    const regular = getRegularToolCallBudget(session);
+    existing.regular.maxTotal = regular.maxTotal;
+    existing.regular.maxPerRound = regular.maxPerRound;
+    const agent = getAgentToolCallBudget(session);
+    existing.agent.maxTotal = agent.maxTotal;
+    existing.agent.maxPerRound = agent.maxPerRound;
     return existing;
 }
 function initToolCallRoundBudget(params) {
     const budgetState = getToolCallBudgetState(params.session);
-    const roundCap = Math.min(budgetState.maxPerRound, Math.max(0, budgetState.maxTotal - budgetState.used));
-    budgetState.used += params.preparedCount;
-    if (params.preparedCount > roundCap) {
+    const roundCaps = {
+        regular: Math.min(budgetState.regular.maxPerRound, Math.max(0, budgetState.regular.maxTotal - budgetState.regular.used)),
+        agent: Math.min(budgetState.agent.maxPerRound, Math.max(0, budgetState.agent.maxTotal - budgetState.agent.used)),
+    };
+    budgetState.regular.used += params.preparedCounts.regular;
+    budgetState.agent.used += params.preparedCounts.agent;
+    for (const bucket of ['regular', 'agent']) {
+        const denied = params.preparedCounts[bucket] - roundCaps[bucket];
+        if (denied <= 0)
+            continue;
         params.session.emit?.({
             type: 'log',
             level: 'warn',
-            message: `Tool call budget exceeded; denying ${params.preparedCount - roundCap} tool calls (phase=${params.phase}, round=${params.round})`,
+            message: `Tool call budget exceeded; denying ${denied} ${bucket} tool calls (phase=${params.phase}, round=${params.round})`,
             timestamp: new Date(),
         });
     }
-    return { roundCap, budgetState };
+    return { roundCaps, budgetState };
 }
 function isFunctionCallStreamPart(part) {
     switch (part.type) {
@@ -192,6 +387,7 @@ async function consumeAssistantStreamTurn(params) {
         toolChoice: params.openAITools.length > 0 ? 'auto' : undefined,
     });
     let content = '';
+    let reasoningContent = '';
     let finishReason;
     let finishUsage;
     for await (const chunk of stream) {
@@ -233,6 +429,9 @@ async function consumeAssistantStreamTurn(params) {
             }
             content += chunk.contentDelta;
         }
+        if (typeof chunk?.reasoningDelta === 'string' && chunk.reasoningDelta) {
+            reasoningContent += chunk.reasoningDelta;
+        }
         params.toolCalls.append(chunk);
         if (chunk?.done) {
             finishReason = chunk.finishReason;
@@ -244,11 +443,21 @@ async function consumeAssistantStreamTurn(params) {
             break;
         }
     }
-    return { content, finishReason, finishUsage };
+    return {
+        content,
+        reasoningContent: reasoningContent.length > 0 ? reasoningContent : undefined,
+        finishReason,
+        finishUsage,
+    };
 }
 async function applyEmptyStreamFallback(params) {
     if (params.content.trim() !== '' || params.collectedToolCalls.length > 0) {
-        return { usedFallback: false, content: params.content, toolCalls: params.collectedToolCalls };
+        return {
+            usedFallback: false,
+            content: params.content,
+            reasoningContent: params.reasoningContent,
+            toolCalls: params.collectedToolCalls,
+        };
     }
     recordAuditEvent('llm.stream.empty_fallback', { phase: params.phase, round: params.round }, { source: 'llm', severity: 'low', scope: 'session', phase: params.phase });
     const fallback = await params.session.llm.chat(params.messages, {
@@ -259,6 +468,7 @@ async function applyEmptyStreamFallback(params) {
         toolChoice: params.openAITools.length > 0 ? 'auto' : undefined,
     });
     const finalContent = fallback.content || '';
+    const finalReasoningContent = fallback.reasoning_content;
     const finalCalls = Array.isArray(fallback.tool_calls) ? fallback.tool_calls : [];
     if (params.session.llmOutput && finalContent) {
         emitLlmOutput({
@@ -269,7 +479,12 @@ async function applyEmptyStreamFallback(params) {
             content: finalContent,
         });
     }
-    return { usedFallback: true, content: finalContent, toolCalls: finalCalls };
+    return {
+        usedFallback: true,
+        content: finalContent,
+        reasoningContent: finalReasoningContent,
+        toolCalls: finalCalls,
+    };
 }
 function emitSynthesizedFunctionCallClosures(params) {
     if (!params.canonicalEmitter)
@@ -335,22 +550,59 @@ function emitSynthesizedFunctionCallClosures(params) {
         });
     }
 }
-function resolveToolCallingForSession(session, phase) {
-    const allowedSpecs = session.toolstack.registry.listAll().filter((spec) => {
-        return session.toolstack.policy.decide(phase, spec, {
-            worktreeRoot: session.runtime.worktreeRoot,
-        }).allowed;
+const PLAN_RUNTIME_UNAVAILABLE_MARKER = 'No plan.* tools are available in this session.';
+const PLAN_RUNTIME_SESSION_ID_PATTERN = /- sessionId:\s*([^\s]+)/;
+const PLAN_RUNTIME_PATH_HINT_PATTERN = /- planPathHint:\s*([^\s]+)/;
+function inferToolVisibilityRuntimeFromMessages(messages) {
+    const systemMessage = messages.find((msg) => msg.role === 'system');
+    if (!systemMessage || typeof systemMessage.content !== 'string')
+        return undefined;
+    const content = systemMessage.content;
+    if (content.includes(PLAN_RUNTIME_UNAVAILABLE_MARKER)) {
+        return undefined;
+    }
+    const sessionIdMatch = content.match(PLAN_RUNTIME_SESSION_ID_PATTERN);
+    const planPathHintMatch = content.match(PLAN_RUNTIME_PATH_HINT_PATTERN);
+    if (!sessionIdMatch || !planPathHintMatch)
+        return undefined;
+    return {
+        plan: {
+            sessionId: sessionIdMatch[1],
+            planPathHint: planPathHintMatch[1],
+        },
+    };
+}
+function resolveToolVisibilityRuntime(session, messages) {
+    if (session.toolVisibility)
+        return session.toolVisibility;
+    if (!messages || messages.length === 0)
+        return undefined;
+    return inferToolVisibilityRuntimeFromMessages(messages);
+}
+function resolveToolCallingForSession(params) {
+    const visibilityRuntime = resolveToolVisibilityRuntime(params.session, params.messages);
+    const visibleSpecs = resolveVisibleToolSpecs({
+        phase: params.phase,
+        toolstack: params.session.toolstack,
+        worktreeRoot: params.session.runtime.worktreeRoot,
+        flowMode: params.session.runtime.flowMode,
+        runtime: visibilityRuntime,
     });
-    const openAITools = allowedSpecs.map(toolToOpenAI);
-    return { allowedSpecs, openAITools };
+    const openAITools = visibleSpecs.map(toolToOpenAI);
+    return { allowedSpecs: visibleSpecs, openAITools };
 }
-function emitToolCallingEnabledLogIfNeeded(session, openAITools) {
+function emitToolCallingEnabledLogIfNeeded(session, openAITools, allowedSpecs) {
     if (openAITools.length === 0)
         return;
+    const toolNames = allowedSpecs.map((spec) => spec.name).sort();
+    const maxNames = 24;
+    const visible = toolNames.slice(0, maxNames);
+    const overflow = toolNames.length - visible.length;
+    const suffix = overflow > 0 ? ` (+${overflow} more)` : '';
     session.emit?.({
         type: 'log',
         level: 'debug',
-        message: `Tool calling enabled (${openAITools.length} tools available)`,
+        message: `Tool calling enabled (${openAITools.length} tools available): ${visible.join(', ')}${suffix}`,
         timestamp: new Date(),
     });
 }
@@ -400,9 +652,13 @@ export async function chatWithTools(initialMessages, chatOptions, session) {
     const maxRounds = session.maxRounds ?? 6;
     const phase = session.phase;
     resetToolCallBudgetState(session);
-    const { allowedSpecs, openAITools } = resolveToolCallingForSession(session, phase);
-    emitToolCallingEnabledLogIfNeeded(session, openAITools);
     const messages = [...initialMessages];
+    const { allowedSpecs, openAITools } = resolveToolCallingForSession({
+        session,
+        phase,
+        messages,
+    });
+    emitToolCallingEnabledLogIfNeeded(session, openAITools, allowedSpecs);
     for (let round = 0; round < maxRounds; round++) {
         // Check for abort before starting a new round
         if (chatOptions.signal?.aborted) {
@@ -443,6 +699,7 @@ export async function chatWithTools(initialMessages, chatOptions, session) {
         messages.push({
             role: 'assistant',
             content: assistant.content || '',
+            reasoning_content: assistant.reasoning_content,
             tool_calls: assistant.tool_calls,
         });
         const toolCalls = assistant.tool_calls || [];
@@ -486,6 +743,52 @@ export async function chatWithTools(initialMessages, chatOptions, session) {
 function isObjectRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function isPlainObject(value) {
+    if (!isObjectRecord(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function describeValueType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+function formatPlanUpdatePatchTypeError(actualType) {
+    return (`Invalid field: patch (received ${actualType}). ` +
+        'Expected object with optional keys: status, checkbox, appendSubtasks, note. ' +
+        'Do not JSON-stringify patch.');
+}
+function coercePlanUpdatePatch(args) {
+    if (!Object.prototype.hasOwnProperty.call(args, 'patch'))
+        return { args };
+    const patch = args.patch;
+    if (isPlainObject(patch))
+        return { args };
+    if (typeof patch === 'string') {
+        const trimmed = patch.trim();
+        const looksLikeObjectLiteral = trimmed.startsWith('{') && trimmed.endsWith('}');
+        if (!looksLikeObjectLiteral) {
+            return { args, error: formatPlanUpdatePatchTypeError('string') };
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (!isPlainObject(parsed)) {
+                return { args, error: formatPlanUpdatePatchTypeError(describeValueType(parsed)) };
+            }
+            return {
+                args: { ...args, patch: parsed },
+                coercedPatchSource: 'stringified',
+            };
+        }
+        catch {
+            return { args, error: formatPlanUpdatePatchTypeError('string') };
+        }
+    }
+    return { args, error: formatPlanUpdatePatchTypeError(describeValueType(patch)) };
+}
 function unwrapRetryError(err) {
     if (!err || typeof err !== 'object')
         return err;
@@ -680,18 +983,29 @@ function applyStrictToolOutputSchemaValidation(params) {
 }
 async function executeToolCalls(session, phase, round, calls, messages, signal) {
     const prepared = prepareToolCallRequests(calls);
-    const { roundCap } = initToolCallRoundBudget({
+    const bucketByCallId = new Map();
+    const preparedCounts = { regular: 0, agent: 0 };
+    for (const item of prepared) {
+        const spec = typeof item.toolName === 'string'
+            ? session.toolstack.registry.listAll().find((s) => s.name === item.toolName)
+            : undefined;
+        const bucket = spec?.intent === 'AGENT' ? 'agent' : 'regular';
+        bucketByCallId.set(item.callId, bucket);
+        preparedCounts[bucket]++;
+    }
+    const { roundCaps } = initToolCallRoundBudget({
         session,
         phase,
         round,
-        preparedCount: prepared.length,
+        preparedCounts,
     });
     const toolResults = new Map();
     const nodes = [];
     const toolArgsPreviewByCallId = new Map();
     const rawArgsPreviewByCallId = new Map();
     const rawArgsTypeByCallId = new Map();
-    let allowedUsed = 0;
+    const patchCoercionByCallId = new Map();
+    const allowedUsed = { regular: 0, agent: 0 };
     for (const item of prepared) {
         const { callId, toolName, rawArgs } = item;
         const normalizedToolName = typeof toolName === 'string' ? toolName : 'unknown';
@@ -725,6 +1039,17 @@ async function executeToolCalls(session, phase, round, calls, messages, signal)
                 argsValue = { ...argsValue, file: inferred[0] };
             }
         }
+        let planUpdatePatchError;
+        if (parsedArgsOk && normalizedToolName === 'plan.update' && isObjectRecord(argsValue)) {
+            const patchGuard = coercePlanUpdatePatch(argsValue);
+            argsValue = patchGuard.args;
+            if (patchGuard.coercedPatchSource) {
+                patchCoercionByCallId.set(callId, patchGuard.coercedPatchSource);
+            }
+            if (patchGuard.error) {
+                planUpdatePatchError = patchGuard.error;
+            }
+        }
         if (parsedArgsOk) {
             toolArgsPreviewByCallId.set(callId, safeStringifyForAudit(argsValue));
         }
@@ -754,7 +1079,8 @@ async function executeToolCalls(session, phase, round, calls, messages, signal)
         });
         // Hard budget: deny tool execution once the session exceeds the configured budget.
         // We still return a tool result for protocol completeness and observability.
-        if (allowedUsed >= roundCap) {
+        const budgetBucket = bucketByCallId.get(callId) ?? 'regular';
+        if (allowedUsed[budgetBucket] >= roundCaps[budgetBucket]) {
             toolResults.set(callId, {
                 id: callId,
                 toolName: typeof toolName === 'string' ? toolName : 'unknown',
@@ -762,7 +1088,9 @@ async function executeToolCalls(session, phase, round, calls, messages, signal)
                 status: 'error',
                 error: {
                     code: 'TOOL_CALL_BUDGET_EXCEEDED',
-                    message: 'Tool call denied: tool calling budget exceeded for this session. Continue without additional tool calls.',
+                    message: budgetBucket === 'agent'
+                        ? 'Agent delegation denied: delegation budget exceeded for this session. Continue without additional agent dispatches or complete the task directly.'
+                        : 'Tool call denied: tool calling budget exceeded for this session. Continue without additional tool calls.',
                     retryable: false,
                     failurePhase: phase,
                 },
@@ -770,7 +1098,7 @@ async function executeToolCalls(session, phase, round, calls, messages, signal)
             });
             continue;
         }
-        allowedUsed++;
+        allowedUsed[budgetBucket]++;
         if (!toolName || typeof toolName !== 'string') {
             getLogger().warn('Received malformed tool call (missing function.name)');
             session.toolCallingAudit?.event({
@@ -835,7 +1163,7 @@ async function executeToolCalls(session, phase, round, calls, messages, signal)
             });
             continue;
         }
-        session.toolCallingAudit?.event({
+        const parsedAuditEntry = {
             timestamp: new Date().toISOString(),
             phase,
             round,
@@ -846,7 +1174,28 @@ async function executeToolCalls(session, phase, round, calls, messages, signal)
             rawArgsPreview: typeof rawArgs === 'string' ? redactJsonString(rawArgs) : undefined,
             parsedArgsOk: true,
             parsedArgsPreview: safeStringifyForAudit(argsValue),
-        });
+        };
+        const patchCoercionSource = patchCoercionByCallId.get(callId);
+        if (patchCoercionSource) {
+            parsedAuditEntry.coercedPatchSource = patchCoercionSource;
+        }
+        session.toolCallingAudit?.event(parsedAuditEntry);
+        if (planUpdatePatchError) {
+            toolResults.set(callId, normalizeRecoverableToolResult({
+                id: callId,
+                toolName,
+                source: 'builtin',
+                status: 'error',
+                error: {
+                    code: 'INVALID_INPUT',
+                    message: planUpdatePatchError,
+                    retryable: true,
+                    failurePhase: phase,
+                },
+                durationMs: 0,
+            }));
+            continue;
+        }
         nodes.push({ id: callId, toolName, args: argsValue, deps: [] });
     }
     if (nodes.length > 0) {
@@ -885,7 +1234,11 @@ async function executeToolCalls(session, phase, round, calls, messages, signal)
     }
     for (const item of prepared) {
         const { callId, toolName, rawArgs } = item;
-        const result = toolResults.get(callId);
+        const rawResult = toolResults.get(callId);
+        const result = rawResult ? normalizeRecoverableToolResult(rawResult) : undefined;
+        if (result && result !== rawResult) {
+            toolResults.set(callId, result);
+        }
         if (!result)
             continue;
         // Strict output schema validation
@@ -924,7 +1277,7 @@ async function executeToolCalls(session, phase, round, calls, messages, signal)
         if (result.status !== 'ok') {
             const errorCode = result.error?.code;
             const attachArgsPreview = errorCode === 'INVALID_INPUT';
-            session.toolCallingAudit?.event({
+            const errorAuditEntry = {
                 timestamp: new Date().toISOString(),
                 phase,
                 round,
@@ -939,6 +1292,45 @@ async function executeToolCalls(session, phase, round, calls, messages, signal)
                     : undefined,
                 rawArgsPreview: attachArgsPreview ? rawArgsPreviewByCallId.get(callId) : undefined,
                 parsedArgsPreview: attachArgsPreview ? toolArgsPreviewByCallId.get(callId) : undefined,
+            };
+            const patchCoercionSource = patchCoercionByCallId.get(callId);
+            if (patchCoercionSource) {
+                errorAuditEntry.coercedPatchSource = patchCoercionSource;
+            }
+            session.toolCallingAudit?.event(errorAuditEntry);
+        }
+        else {
+            const toolResultOutputOk = isObjectRecord(result.output) && typeof result.output.ok === 'boolean'
+                ? result.output.ok
+                : undefined;
+            const artifacts = extractArtifactHandlesFromToolOutput(result.output);
+            const recentReadArtifact = await persistRecentReadArtifact({
+                toolName: typeof toolName === 'string' ? toolName : 'unknown',
+                rawArgs,
+                output: result.output,
+            });
+            const toolResultPreviewArtifact = await persistToolResultPreviewArtifact({
+                toolName: typeof toolName === 'string' ? toolName : 'unknown',
+                output: result.output,
+                summary: result.summary,
+                outputSummary: result.outputSummary,
+            });
+            session.toolCallingAudit?.event({
+                timestamp: new Date().toISOString(),
+                phase,
+                round,
+                callId,
+                toolName: typeof toolName === 'string' ? toolName : 'unknown',
+                rawArgsType: rawArgsTypeByCallId.get(callId) ?? typeof rawArgs,
+                parsedArgsOk: true,
+                toolResultOutputOk,
+                toolResultStatus: result.status,
+                toolResultPatchArtifact: artifacts.patchArtifact,
+                toolResultAuditArtifact: artifacts.auditArtifact,
+                toolResultReadArtifact: recentReadArtifact?.artifact,
+                toolResultReadArtifactPath: recentReadArtifact?.path,
+                toolResultPreviewArtifact: toolResultPreviewArtifact?.artifact,
+                toolResultPreviewLabel: toolResultPreviewArtifact?.label,
             });
         }
         messages.push({
@@ -965,9 +1357,13 @@ export async function chatWithToolsStreaming(initialMessages, chatOptions, sessi
     const maxRounds = session.maxRounds ?? 6;
     const phase = session.phase;
     resetToolCallBudgetState(session);
-    const { allowedSpecs, openAITools } = resolveToolCallingForSession(session, phase);
-    emitToolCallingEnabledLogIfNeeded(session, openAITools);
     const messages = [...initialMessages];
+    const { allowedSpecs, openAITools } = resolveToolCallingForSession({
+        session,
+        phase,
+        messages,
+    });
+    emitToolCallingEnabledLogIfNeeded(session, openAITools, allowedSpecs);
     const canonicalEmitters = createCanonicalEmitterRegistry(session);
     try {
         for (let round = 0; round < maxRounds; round++) {
@@ -980,6 +1376,7 @@ export async function chatWithToolsStreaming(initialMessages, chatOptions, sessi
             let finishReason;
             try {
                 let streamContent = '';
+                let streamReasoningContent;
                 let finishUsage;
                 try {
                     const consumed = await consumeAssistantStreamTurn({
@@ -996,6 +1393,7 @@ export async function chatWithToolsStreaming(initialMessages, chatOptions, sessi
                         toolCalls,
                     });
                     streamContent = consumed.content;
+                    streamReasoningContent = consumed.reasoningContent;
                     finishReason = consumed.finishReason;
                     finishUsage = consumed.finishUsage;
                 }
@@ -1036,12 +1434,14 @@ export async function chatWithToolsStreaming(initialMessages, chatOptions, sessi
                     phase,
                     round,
                     content: streamContent,
+                    reasoningContent: streamReasoningContent,
                     collectedToolCalls: drainedToolCalls,
                 });
                 usedFallback = fallback.usedFallback;
                 const assistant = {
                     role: 'assistant',
                     content: fallback.content,
+                    reasoning_content: fallback.reasoningContent,
                     tool_calls: fallback.toolCalls.length > 0 ? fallback.toolCalls : undefined,
                 };
                 if (session.emit && session.llmOutput) {
@@ -1056,16 +1456,6 @@ export async function chatWithToolsStreaming(initialMessages, chatOptions, sessi
                         emittedModelToolCallIds,
                     });
                 }
-                if (session.llmOutput) {
-                    emitLlmStreamEnd({
-                        emit: session.emit,
-                        policy: session.llmOutput.policy,
-                        kind: session.llmOutput.kind,
-                        step: session.llmOutput.step,
-                        streamId,
-                        finishReason,
-                    });
-                }
                 recordAuditEvent('llm.round', {
                     status: 'ok',
                     streamed: true,
@@ -1081,9 +1471,29 @@ export async function chatWithToolsStreaming(initialMessages, chatOptions, sessi
                 messages.push(assistant);
                 const calls = assistant.tool_calls || [];
                 if (!Array.isArray(calls) || calls.length === 0) {
+                    if (session.llmOutput) {
+                        emitLlmStreamEnd({
+                            emit: session.emit,
+                            policy: session.llmOutput.policy,
+                            kind: session.llmOutput.kind,
+                            step: session.llmOutput.step,
+                            streamId,
+                            finishReason,
+                        });
+                    }
                     return assistant;
                 }
                 await executeToolCalls(session, phase, round, calls, messages, chatOptions.signal);
+                if (session.llmOutput) {
+                    emitLlmStreamEnd({
+                        emit: session.emit,
+                        policy: session.llmOutput.policy,
+                        kind: session.llmOutput.kind,
+                        step: session.llmOutput.step,
+                        streamId,
+                        finishReason,
+                    });
+                }
             }
             finally {
                 canonicalEmitters.release(streamId);