salmon-loop 0.2.3

package/dist/core/tools/session.js

@@ -0,0 +1,1105 @@
+import * as crypto from 'crypto';
+import path from 'path';
+import { emitLlmOutput, emitLlmStreamDelta, emitLlmStreamEnd } from '../llm/output-policy.js';
+import { redactErrorMessage, redactJsonString, redactValue } from '../llm/redact.js';
+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 { Phase } from '../types/runtime.js';
+import { isSafeRelativePath, normalizePath } from '../utils/path.js';
+import { buildHeadlessToolInputPayload } from './headless-payload.js';
+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 { ToolCallAccumulator } from './streaming/ToolCallAccumulator.js';
+function safeParseJson(argsText) {
+    if (typeof argsText !== 'string') {
+        return { ok: true, value: argsText };
+    }
+    const trimmed = argsText.trim();
+    if (!trimmed) {
+        return { ok: true, value: {} };
+    }
+    try {
+        let value = JSON.parse(trimmed);
+        // Some models will JSON-encode the arguments object as a string (double-encoded JSON).
+        // Example raw args: "\"{\\\"pattern\\\":\\\"README\\\"}\"" -> first parse returns string.
+        if (typeof value === 'string') {
+            const nested = value.trim();
+            const looksJsonObject = (nested.startsWith('{') && nested.endsWith('}')) ||
+                (nested.startsWith('[') && nested.endsWith(']'));
+            if (looksJsonObject) {
+                try {
+                    value = JSON.parse(nested);
+                }
+                catch {
+                    // Ignore: fall back to the first parse result to preserve observability.
+                }
+            }
+        }
+        return { ok: true, value };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+function formatToolResultForModel(result) {
+    const payload = {
+        id: result.id,
+        toolName: result.toolName,
+        status: result.status,
+        output: result.output,
+        summary: result.summary,
+        error: result.error,
+        meta: result.meta,
+        durationMs: result.durationMs,
+    };
+    try {
+        return JSON.stringify(payload);
+    }
+    catch {
+        return JSON.stringify({
+            id: result.id,
+            toolName: result.toolName,
+            status: 'error',
+            error: {
+                code: 'SERIALIZE_ERROR',
+                message: 'Failed to serialize tool result',
+                retryable: false,
+            },
+        });
+    }
+}
+function safeStringifyForAudit(value) {
+    try {
+        return redactJsonString(JSON.stringify(redactValue(value)));
+    }
+    catch {
+        return '[Unserializable]';
+    }
+}
+function defaultMaxToolCallsTotalForPhase(phase) {
+    if (phase === Phase.EXPLORE)
+        return 18;
+    if (phase === Phase.PLAN)
+        return 10;
+    if (phase === Phase.PATCH)
+        return 10;
+    return 10;
+}
+function defaultMaxToolCallsPerRoundForPhase(phase) {
+    if (phase === Phase.EXPLORE)
+        return 6;
+    if (phase === Phase.PLAN)
+        return 4;
+    if (phase === Phase.PATCH)
+        return 4;
+    return 4;
+}
+function getToolCallBudget(session) {
+    const maxTotal = session.maxToolCallsTotal ?? defaultMaxToolCallsTotalForPhase(session.phase);
+    const maxPerRound = session.maxToolCallsPerRound ?? defaultMaxToolCallsPerRoundForPhase(session.phase);
+    return {
+        maxTotal: Math.max(0, Math.floor(maxTotal)),
+        maxPerRound: Math.max(0, Math.floor(maxPerRound)),
+    };
+}
+function resetToolCallBudgetState(session) {
+    const budget = getToolCallBudget(session);
+    const state = { used: 0, ...budget };
+    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 };
+        anySession.__toolCallBudgetState = created;
+        return created;
+    }
+    // Ensure runtime overrides are respected.
+    existing.maxTotal = budget.maxTotal;
+    existing.maxPerRound = budget.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) {
+        params.session.emit?.({
+            type: 'log',
+            level: 'warn',
+            message: `Tool call budget exceeded; denying ${params.preparedCount - roundCap} tool calls (phase=${params.phase}, round=${params.round})`,
+            timestamp: new Date(),
+        });
+    }
+    return { roundCap, budgetState };
+}
+function isFunctionCallStreamPart(part) {
+    switch (part.type) {
+        case 'function_call.start':
+        case 'function_call_arguments.delta':
+        case 'function_call_arguments.done':
+        case 'function_call.done':
+            return typeof part.callId === 'string';
+        default:
+            return false;
+    }
+}
+function groupNewFunctionCallPartsByCallId(params) {
+    const out = new Map();
+    for (const part of params.parts) {
+        if (!isFunctionCallStreamPart(part))
+            continue;
+        if (!part.callId)
+            continue;
+        if (params.alreadyEmittedCallIds.has(part.callId))
+            continue;
+        const bucket = out.get(part.callId);
+        if (bucket)
+            bucket.push(part);
+        else
+            out.set(part.callId, [part]);
+    }
+    return out;
+}
+function emitCanonicalResponsesEvents(params) {
+    for (const event of params.events) {
+        params.emit({
+            type: 'llm.responses.event',
+            kind: params.llmOutput.kind,
+            step: params.llmOutput.step,
+            streamId: params.streamId,
+            phase: params.phase,
+            round: params.round,
+            source: params.source,
+            event,
+            timestamp: params.timestamp,
+        });
+    }
+}
+async function consumeAssistantStreamTurn(params) {
+    const stream = params.session.llm.chatStream(params.messages, {
+        ...params.chatOptions,
+        phase: params.phase,
+        tools: params.openAITools,
+        toolSpecs: params.allowedSpecs,
+        toolChoice: params.openAITools.length > 0 ? 'auto' : undefined,
+    });
+    let content = '';
+    let finishReason;
+    let finishUsage;
+    for await (const chunk of stream) {
+        if (params.canonicalEmitter && params.session.emit && params.session.llmOutput) {
+            const parts = mapLlmStreamChunkToCanonicalStreamParts({ streamId: params.streamId, chunk });
+            const at = new Date();
+            const source = chunk.source ?? 'provider';
+            const toolPartsByCallId = groupNewFunctionCallPartsByCallId({
+                parts,
+                alreadyEmittedCallIds: params.emittedModelToolCallIds,
+            });
+            for (const [callId, callParts] of toolPartsByCallId) {
+                for (const part of callParts) {
+                    const events = params.canonicalEmitter.push(part);
+                    emitCanonicalResponsesEvents({
+                        emit: params.session.emit,
+                        llmOutput: params.session.llmOutput,
+                        streamId: params.streamId,
+                        phase: params.phase,
+                        round: params.round,
+                        source,
+                        events,
+                        timestamp: at,
+                    });
+                }
+                params.emittedModelToolCallIds.add(callId);
+            }
+        }
+        if (typeof chunk?.contentDelta === 'string' && chunk.contentDelta) {
+            if (params.session.llmOutput) {
+                emitLlmStreamDelta({
+                    emit: params.session.emit,
+                    policy: params.session.llmOutput.policy,
+                    kind: params.session.llmOutput.kind,
+                    step: params.session.llmOutput.step,
+                    streamId: params.streamId,
+                    content: chunk.contentDelta,
+                });
+            }
+            content += chunk.contentDelta;
+        }
+        params.toolCalls.append(chunk);
+        if (chunk?.done) {
+            finishReason = chunk.finishReason;
+            if (chunk.usage &&
+                typeof chunk.usage.promptTokens === 'number' &&
+                typeof chunk.usage.completionTokens === 'number') {
+                finishUsage = chunk.usage;
+            }
+            break;
+        }
+    }
+    return { content, finishReason, finishUsage };
+}
+async function applyEmptyStreamFallback(params) {
+    if (params.content.trim() !== '' || params.collectedToolCalls.length > 0) {
+        return { usedFallback: false, content: params.content, 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, {
+        ...params.chatOptions,
+        phase: params.phase,
+        tools: params.openAITools,
+        toolSpecs: params.allowedSpecs,
+        toolChoice: params.openAITools.length > 0 ? 'auto' : undefined,
+    });
+    const finalContent = fallback.content || '';
+    const finalCalls = Array.isArray(fallback.tool_calls) ? fallback.tool_calls : [];
+    if (params.session.llmOutput && finalContent) {
+        emitLlmOutput({
+            emit: params.session.emit,
+            policy: params.session.llmOutput.policy,
+            kind: params.session.llmOutput.kind,
+            step: params.session.llmOutput.step,
+            content: finalContent,
+        });
+    }
+    return { usedFallback: true, content: finalContent, toolCalls: finalCalls };
+}
+function emitSynthesizedFunctionCallClosures(params) {
+    if (!params.canonicalEmitter)
+        return;
+    if (params.collectedToolCalls.length === 0)
+        return;
+    const seenDoneIds = new Set();
+    for (const call of params.collectedToolCalls) {
+        const callId = call?.id;
+        const toolName = call?.function?.name;
+        const argsText = call?.function?.arguments;
+        if (typeof callId !== 'string' || !callId)
+            continue;
+        if (typeof toolName !== 'string' || !toolName)
+            continue;
+        if (seenDoneIds.has(callId))
+            continue;
+        seenDoneIds.add(callId);
+        if (!params.emittedModelToolCallIds.has(callId)) {
+            params.emittedModelToolCallIds.add(callId);
+            const at = new Date();
+            const startEvents = params.canonicalEmitter.push({
+                type: 'function_call.start',
+                streamId: params.streamId,
+                callId,
+                name: toolName,
+            });
+            const argEvents = params.canonicalEmitter.push({
+                type: 'function_call_arguments.done',
+                streamId: params.streamId,
+                callId,
+                name: toolName,
+                arguments: typeof argsText === 'string' ? argsText : '{}',
+            });
+            emitCanonicalResponsesEvents({
+                emit: params.emit,
+                llmOutput: params.llmOutput,
+                streamId: params.streamId,
+                phase: params.phase,
+                round: params.round,
+                source: 'synthesized',
+                events: [...startEvents, ...argEvents],
+                timestamp: at,
+            });
+        }
+        const doneAt = new Date();
+        const doneEvents = params.canonicalEmitter.push({
+            type: 'function_call.done',
+            streamId: params.streamId,
+            callId,
+            name: toolName,
+            arguments: typeof argsText === 'string' ? argsText : '{}',
+        });
+        emitCanonicalResponsesEvents({
+            emit: params.emit,
+            llmOutput: params.llmOutput,
+            streamId: params.streamId,
+            phase: params.phase,
+            round: params.round,
+            source: 'synthesized',
+            events: doneEvents,
+            timestamp: doneAt,
+        });
+    }
+}
+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 openAITools = allowedSpecs.map(toolToOpenAI);
+    return { allowedSpecs, openAITools };
+}
+function emitToolCallingEnabledLogIfNeeded(session, openAITools) {
+    if (openAITools.length === 0)
+        return;
+    session.emit?.({
+        type: 'log',
+        level: 'debug',
+        message: `Tool calling enabled (${openAITools.length} tools available)`,
+        timestamp: new Date(),
+    });
+}
+function createCanonicalEmitterRegistry(session) {
+    if (!session.emit || !session.llmOutput) {
+        return {
+            get: () => null,
+            release: () => { },
+            clear: () => { },
+        };
+    }
+    const emitters = new Map();
+    return {
+        get(streamId) {
+            if (!streamId)
+                return null;
+            const existing = emitters.get(streamId);
+            if (existing)
+                return existing;
+            const created = new CanonicalResponsesEventEmitter();
+            emitters.set(streamId, created);
+            return created;
+        },
+        release(streamId) {
+            if (!streamId)
+                return;
+            emitters.delete(streamId);
+        },
+        clear() {
+            emitters.clear();
+        },
+    };
+}
+function createStreamingStreamId(params) {
+    if (!params.session.llmOutput)
+        return '';
+    return `llm-${params.session.llmOutput.kind}-${params.phase}-${params.round}-${crypto.randomUUID()}`;
+}
+/**
+ * Runs an OpenAI-style tool calling loop:
+ * - Send messages (+ tools)
+ * - If assistant returns tool_calls, execute them via ToolRouter
+ * - Feed tool results back as role='tool' messages
+ * - Repeat until no tool_calls or maxRounds reached
+ */
+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];
+    for (let round = 0; round < maxRounds; round++) {
+        // Check for abort before starting a new round
+        if (chatOptions.signal?.aborted) {
+            throw new Error('Operation aborted');
+        }
+        const roundStartedAt = Date.now();
+        let assistant;
+        try {
+            assistant = await session.llm.chat(messages, {
+                ...chatOptions,
+                phase,
+                tools: openAITools,
+                toolSpecs: allowedSpecs,
+                toolChoice: openAITools.length > 0 ? 'auto' : undefined,
+            });
+        }
+        catch (e) {
+            recordAuditEvent('llm.round', {
+                status: 'error',
+                streamed: false,
+                phase,
+                round,
+                model: session.runtime.model,
+                durationMs: Date.now() - roundStartedAt,
+            }, { source: 'llm', severity: 'low', scope: 'session', phase });
+            throw e;
+        }
+        recordAuditEvent('llm.round', {
+            status: 'ok',
+            streamed: false,
+            phase,
+            round,
+            model: session.runtime.model,
+            durationMs: Date.now() - roundStartedAt,
+            contentChars: typeof assistant.content === 'string' ? assistant.content.length : 0,
+            toolCallCount: Array.isArray(assistant.tool_calls) ? assistant.tool_calls.length : 0,
+        }, { source: 'llm', severity: 'low', scope: 'session', phase });
+        messages.push({
+            role: 'assistant',
+            content: assistant.content || '',
+            tool_calls: assistant.tool_calls,
+        });
+        const toolCalls = assistant.tool_calls || [];
+        if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+            if (session.llmOutput) {
+                emitLlmOutput({
+                    emit: session.emit,
+                    policy: session.llmOutput.policy,
+                    kind: session.llmOutput.kind,
+                    step: session.llmOutput.step,
+                    content: assistant.content || '',
+                });
+            }
+            return assistant;
+        }
+        // Check for abort before executing tools
+        if (chatOptions.signal?.aborted) {
+            throw new Error('Operation aborted');
+        }
+        await executeToolCalls(session, phase, round, toolCalls, messages, chatOptions.signal);
+    }
+    // If we reach here, the model is stuck in tool calling. Return the last assistant content.
+    session.emit?.({
+        type: 'log',
+        level: 'warn',
+        message: `Tool calling exceeded maximum rounds (${maxRounds}); continuing without further tool execution`,
+        timestamp: new Date(),
+    });
+    const lastAssistant = [...messages].reverse().find((m) => m.role === 'assistant');
+    if (session.llmOutput && lastAssistant?.content) {
+        emitLlmOutput({
+            emit: session.emit,
+            policy: session.llmOutput.policy,
+            kind: session.llmOutput.kind,
+            step: session.llmOutput.step,
+            content: lastAssistant.content,
+        });
+    }
+    return lastAssistant || { role: 'assistant', content: '' };
+}
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function unwrapRetryError(err) {
+    if (!err || typeof err !== 'object')
+        return err;
+    const candidate = err;
+    if (candidate.lastError)
+        return candidate.lastError;
+    return err;
+}
+function extractStatusCode(err) {
+    const unwrapped = unwrapRetryError(err);
+    if (!unwrapped || typeof unwrapped !== 'object')
+        return undefined;
+    const meta = unwrapped?.meta;
+    if (meta && typeof meta === 'object' && typeof meta.statusCode === 'number') {
+        return meta.statusCode;
+    }
+    const statusCode = unwrapped?.statusCode;
+    if (typeof statusCode === 'number')
+        return statusCode;
+    const response = unwrapped?.response;
+    if (response && typeof response === 'object' && typeof response.status === 'number') {
+        return response.status;
+    }
+    return undefined;
+}
+function extractNetworkCode(err) {
+    const unwrapped = unwrapRetryError(err);
+    if (!unwrapped || typeof unwrapped !== 'object')
+        return undefined;
+    const code = unwrapped?.code;
+    if (typeof code === 'string')
+        return code;
+    const cause = unwrapped?.cause;
+    if (cause && typeof cause === 'object' && typeof cause.code === 'string') {
+        return cause.code;
+    }
+    const meta = unwrapped?.meta;
+    if (meta && typeof meta === 'object' && typeof meta.causeName === 'string') {
+        return meta.causeName;
+    }
+    return undefined;
+}
+function extractProvider(err) {
+    const unwrapped = unwrapRetryError(err);
+    if (!unwrapped || typeof unwrapped !== 'object')
+        return undefined;
+    const meta = unwrapped?.meta;
+    if (meta && typeof meta === 'object' && typeof meta.provider === 'string') {
+        return meta.provider;
+    }
+    const provider = unwrapped?.provider;
+    if (typeof provider === 'string')
+        return provider;
+    return undefined;
+}
+const ENABLE_TOOL_ARG_REPAIR = process.env.SALMONLOOP_ENABLE_TOOL_ARG_REPAIR === '1' ||
+    process.env.SALMONLOOP_ENABLE_TOOL_ARG_REPAIR === 'true';
+const SAFE_INFERRED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.json',
+    '.md',
+    '.txt',
+    '.css',
+    '.html',
+    '.vue',
+    '.py',
+    '.rs',
+    '.go',
+    '.java',
+    '.c',
+    '.cpp',
+    '.h',
+]);
+function inferHighConfidenceFiles(instruction) {
+    const candidates = [];
+    const normalized = instruction || '';
+    if (/README\b/i.test(normalized)) {
+        candidates.push('README.md');
+    }
+    const pathLike = /(?:^|\s)([a-zA-Z0-9][a-zA-Z0-9._/-]*\.[a-zA-Z0-9]{1,8})(?:\s|$)/g;
+    let match = null;
+    while ((match = pathLike.exec(normalized)) !== null) {
+        const raw = match[1];
+        if (!raw)
+            continue;
+        const rel = normalizePath(raw).replace(/^(\.\/|\/)+/, '');
+        if (!rel)
+            continue;
+        if (!isSafeRelativePath(rel))
+            continue;
+        const lower = rel.toLowerCase();
+        if (lower.startsWith('.'))
+            continue;
+        if (lower.includes('/.'))
+            continue;
+        if (lower.startsWith('.git/') || lower.startsWith('.salmonloop/'))
+            continue;
+        if (lower.includes('node_modules/'))
+            continue;
+        const ext = path.extname(rel).toLowerCase();
+        if (!SAFE_INFERRED_EXTENSIONS.has(ext))
+            continue;
+        candidates.push(rel);
+        if (candidates.length >= 3)
+            break;
+    }
+    return Array.from(new Set(candidates));
+}
+function extractInstructionText(messages) {
+    const lastUser = [...messages].reverse().find((m) => m.role === 'user');
+    const text = typeof lastUser?.content === 'string' ? lastUser.content : '';
+    if (!text)
+        return '';
+    const match = text.match(/(^|\n)# Instruction\s*\n([\s\S]*?)(\n# |$)/);
+    if (!match)
+        return text;
+    return match[2]?.trim() || '';
+}
+function prepareToolCallRequests(calls) {
+    return calls.map((call) => {
+        const callId = call?.id || crypto.randomUUID();
+        const toolName = call?.function?.name;
+        const rawArgs = call?.function?.arguments;
+        return { callId, toolName, rawArgs };
+    });
+}
+async function runToolExecutionPlan(params) {
+    const scheduler = new ParallelScheduler(params.session.toolstack.router, new InMemoryLockManager());
+    const runSignal = params.signal ?? new AbortController().signal;
+    let result = (await scheduler.run(params.plan, { ...params.session.runtime, phase: params.phase }, runSignal));
+    const persistEnabled = process.env.NODE_ENV !== 'test';
+    const persistenceRoot = params.session.runtime.persistenceRoot || params.session.runtime.repoRoot;
+    if (persistEnabled) {
+        await PlanPersistence.save(persistenceRoot, params.plan, result, {
+            repoRoot: params.session.runtime.repoRoot,
+            worktreeRoot: params.session.runtime.worktreeRoot,
+            persistenceRoot: params.session.runtime.persistenceRoot,
+            phase: params.phase,
+            model: params.session.runtime.model,
+        });
+    }
+    const waitForAuthorization = params.session.toolstack.router.waitForAuthorization;
+    const canWaitForAuth = typeof waitForAuthorization === 'function';
+    let resumeAttempts = 0;
+    while (result.blockedApprovals.length > 0 && canWaitForAuth && !runSignal.aborted) {
+        resumeAttempts++;
+        if (resumeAttempts > 10)
+            break;
+        await Promise.all(result.blockedApprovals.map(async (a) => {
+            await waitForAuthorization?.(a.nodeId, runSignal);
+        }));
+        result = (await scheduler.run(params.plan, { ...params.session.runtime, phase: params.phase }, runSignal, {
+            initialResults: result.nodeResults,
+            resumeBlockedApprovals: true,
+        }));
+        if (persistEnabled) {
+            await PlanPersistence.save(persistenceRoot, params.plan, result, {
+                repoRoot: params.session.runtime.repoRoot,
+                worktreeRoot: params.session.runtime.worktreeRoot,
+                persistenceRoot: params.session.runtime.persistenceRoot,
+                phase: params.phase,
+                model: params.session.runtime.model,
+            });
+        }
+    }
+    return result;
+}
+function applyStrictToolOutputSchemaValidation(params) {
+    if (params.result.status !== 'ok')
+        return;
+    const spec = params.session.toolstack.router.getSpec?.(params.toolName) ||
+        params.session.toolstack.registry.listAll().find((s) => s.name === params.toolName);
+    if (!spec?.outputSchema)
+        return;
+    const parsed = spec.outputSchema.safeParse(params.result.output);
+    if (parsed.success) {
+        params.result.output = parsed.data;
+        return;
+    }
+    const validationError = parsed.error.message;
+    getLogger().error(`[tool] schema violation for ${params.toolName} (callId: ${params.callId}): ${validationError}`);
+    params.result.status = 'error';
+    params.result.error = {
+        code: 'SCHEMA_VIOLATION',
+        message: `Tool output does not match expected schema: ${validationError}`,
+        retryable: false,
+        failurePhase: params.phase,
+    };
+}
+async function executeToolCalls(session, phase, round, calls, messages, signal) {
+    const prepared = prepareToolCallRequests(calls);
+    const { roundCap } = initToolCallRoundBudget({
+        session,
+        phase,
+        round,
+        preparedCount: prepared.length,
+    });
+    const toolResults = new Map();
+    const nodes = [];
+    const toolArgsPreviewByCallId = new Map();
+    const rawArgsPreviewByCallId = new Map();
+    const rawArgsTypeByCallId = new Map();
+    let allowedUsed = 0;
+    for (const item of prepared) {
+        const { callId, toolName, rawArgs } = item;
+        const normalizedToolName = typeof toolName === 'string' ? toolName : 'unknown';
+        let parsedArgsOk = true;
+        let argsValue = undefined;
+        let parsedArgsError;
+        const parsed = safeParseJson(rawArgs);
+        if (parsed.ok) {
+            argsValue = parsed.value;
+            rawArgsPreviewByCallId.set(callId, typeof rawArgs === 'string' ? redactJsonString(rawArgs) : undefined);
+            rawArgsTypeByCallId.set(callId, typeof rawArgs);
+        }
+        else {
+            parsedArgsOk = false;
+            parsedArgsError = parsed.error;
+            rawArgsPreviewByCallId.set(callId, typeof rawArgs === 'string' ? redactJsonString(rawArgs) : undefined);
+            rawArgsTypeByCallId.set(callId, typeof rawArgs);
+        }
+        // Repair common missing-args tool calls for weak tool-call models:
+        // - fs.read called with `{}` is almost always a missing `file` parameter.
+        // We only apply a conservative inference based on the explicit instruction block.
+        if (parsedArgsOk &&
+            ENABLE_TOOL_ARG_REPAIR &&
+            phase === Phase.EXPLORE &&
+            normalizedToolName === 'fs.read' &&
+            isObjectRecord(argsValue) &&
+            typeof argsValue.file !== 'string') {
+            const instruction = extractInstructionText(messages);
+            const inferred = inferHighConfidenceFiles(instruction);
+            if (inferred.length > 0) {
+                argsValue = { ...argsValue, file: inferred[0] };
+            }
+        }
+        if (parsedArgsOk) {
+            toolArgsPreviewByCallId.set(callId, safeStringifyForAudit(argsValue));
+        }
+        const input = session.eventPayload?.includeToolInput && parsedArgsOk
+            ? buildHeadlessToolInputPayload(argsValue)
+            : undefined;
+        const spec = typeof toolName === 'string'
+            ? session.toolstack.registry.listAll().find((s) => s.name === toolName)
+            : undefined;
+        if (typeof toolName === 'string') {
+            session.emit?.({
+                type: 'log',
+                level: 'debug',
+                message: `[tool] start ${toolName}`,
+                timestamp: new Date(),
+            });
+        }
+        session.emit?.({
+            type: 'tool.call.start',
+            callId,
+            toolName: normalizedToolName,
+            toolIntent: spec?.intent,
+            phase,
+            round,
+            input,
+            timestamp: new Date(),
+        });
+        // 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) {
+            toolResults.set(callId, {
+                id: callId,
+                toolName: typeof toolName === 'string' ? toolName : 'unknown',
+                source: 'builtin',
+                status: 'error',
+                error: {
+                    code: 'TOOL_CALL_BUDGET_EXCEEDED',
+                    message: 'Tool call denied: tool calling budget exceeded for this session. Continue without additional tool calls.',
+                    retryable: false,
+                    failurePhase: phase,
+                },
+                durationMs: 0,
+            });
+            continue;
+        }
+        allowedUsed++;
+        if (!toolName || typeof toolName !== 'string') {
+            getLogger().warn('Received malformed tool call (missing function.name)');
+            session.toolCallingAudit?.event({
+                timestamp: new Date().toISOString(),
+                phase,
+                round,
+                callId,
+                toolName: normalizedToolName,
+                rawArgsType: typeof rawArgs,
+                rawArgsPreview: typeof rawArgs === 'string' ? redactJsonString(rawArgs) : undefined,
+                parsedArgsOk: false,
+                parsedArgsError: 'Missing function.name',
+                toolResultStatus: 'error',
+                toolResultErrorCode: 'MALFORMED_TOOL_CALL',
+            });
+            toolResults.set(callId, {
+                id: callId,
+                toolName: normalizedToolName,
+                source: 'builtin',
+                status: 'error',
+                error: {
+                    code: 'MALFORMED_TOOL_CALL',
+                    message: 'Missing function.name',
+                    retryable: true,
+                    failurePhase: phase,
+                },
+            });
+            continue;
+        }
+        session.emit?.({
+            type: 'log',
+            level: 'debug',
+            message: `Tool call requested: ${toolName}`,
+            timestamp: new Date(),
+        });
+        if (!parsedArgsOk) {
+            const error = parsedArgsError ?? 'Invalid tool arguments';
+            session.toolCallingAudit?.event({
+                timestamp: new Date().toISOString(),
+                phase,
+                round,
+                callId,
+                toolName,
+                rawArgsType: typeof rawArgs,
+                rawArgsPreview: typeof rawArgs === 'string' ? redactJsonString(rawArgs) : undefined,
+                parsedArgsOk: false,
+                parsedArgsError: redactErrorMessage(error),
+                toolResultStatus: 'error',
+                toolResultErrorCode: 'INVALID_TOOL_ARGUMENTS_JSON',
+            });
+            toolResults.set(callId, {
+                id: callId,
+                toolName,
+                source: 'builtin',
+                status: 'error',
+                error: {
+                    code: 'INVALID_TOOL_ARGUMENTS_JSON',
+                    message: error,
+                    retryable: true,
+                    failurePhase: phase,
+                },
+            });
+            continue;
+        }
+        session.toolCallingAudit?.event({
+            timestamp: new Date().toISOString(),
+            phase,
+            round,
+            callId,
+            toolName,
+            toolIntent: spec?.intent,
+            rawArgsType: typeof rawArgs,
+            rawArgsPreview: typeof rawArgs === 'string' ? redactJsonString(rawArgs) : undefined,
+            parsedArgsOk: true,
+            parsedArgsPreview: safeStringifyForAudit(argsValue),
+        });
+        nodes.push({ id: callId, toolName, args: argsValue, deps: [] });
+    }
+    if (nodes.length > 0) {
+        const plan = {
+            id: `tool-round-${round}-${crypto.randomUUID()}`,
+            nodes,
+            policy: {
+                maxParallelism: Math.min(nodes.length, 8),
+                readParallelism: Math.min(nodes.length, 8),
+                writeParallelism: 1,
+                failFast: false,
+                deterministic: true,
+            },
+        };
+        const result = await runToolExecutionPlan({ session, phase, plan, signal });
+        for (const node of nodes) {
+            const r = result.nodeResults[node.id];
+            const toolResult = r?.toolResult;
+            if (toolResult) {
+                toolResults.set(node.id, toolResult);
+                continue;
+            }
+            toolResults.set(node.id, {
+                id: node.id,
+                toolName: node.toolName,
+                source: 'builtin',
+                status: 'error',
+                error: {
+                    code: 'PPD_TOOL_RESULT_MISSING',
+                    message: 'Parallel scheduler did not return tool result',
+                    retryable: true,
+                    failurePhase: phase,
+                },
+            });
+        }
+    }
+    for (const item of prepared) {
+        const { callId, toolName, rawArgs } = item;
+        const result = toolResults.get(callId);
+        if (!result)
+            continue;
+        // Strict output schema validation
+        if (typeof toolName === 'string') {
+            applyStrictToolOutputSchemaValidation({ session, phase, callId, toolName, result });
+        }
+        session.emit?.({
+            type: 'log',
+            level: result.status === 'ok' ? 'info' : 'warn',
+            message: `[tool] done ${toolName || 'unknown'} status=${result.status}`,
+            timestamp: new Date(),
+        });
+        session.emit?.({
+            type: 'tool.call.end',
+            callId,
+            toolName: typeof toolName === 'string' ? toolName : 'unknown',
+            phase,
+            round,
+            status: result.status,
+            durationMs: result.durationMs,
+            errorCode: result.error?.code,
+            outputSummary: session.eventPayload?.includeToolOutput &&
+                (typeof result.outputSummary === 'string' || typeof result.summary === 'string')
+                ? (result.outputSummary ?? result.summary)
+                : undefined,
+            timestamp: new Date(),
+        });
+        if (result.status !== 'ok' &&
+            result.error?.code === 'INTERRUPT_REQUIRED' &&
+            result.meta?.interrupt) {
+            const err = new Error(result.error.message || 'Interrupt required');
+            err.code = 'INTERRUPT_REQUIRED';
+            err.interrupt = result.meta.interrupt;
+            throw err;
+        }
+        if (result.status !== 'ok') {
+            const errorCode = result.error?.code;
+            const attachArgsPreview = errorCode === 'INVALID_INPUT';
+            session.toolCallingAudit?.event({
+                timestamp: new Date().toISOString(),
+                phase,
+                round,
+                callId,
+                toolName: typeof toolName === 'string' ? toolName : 'unknown',
+                rawArgsType: rawArgsTypeByCallId.get(callId) ?? typeof rawArgs,
+                parsedArgsOk: true,
+                toolResultStatus: result.status,
+                toolResultErrorCode: errorCode,
+                toolResultErrorMessage: attachArgsPreview && result.error?.message
+                    ? redactErrorMessage(result.error.message)
+                    : undefined,
+                rawArgsPreview: attachArgsPreview ? rawArgsPreviewByCallId.get(callId) : undefined,
+                parsedArgsPreview: attachArgsPreview ? toolArgsPreviewByCallId.get(callId) : undefined,
+            });
+        }
+        messages.push({
+            role: 'tool',
+            name: typeof toolName === 'string' ? toolName : 'unknown',
+            tool_call_id: callId,
+            content: formatToolResultForModel(result),
+        });
+    }
+}
+/**
+ * Streaming variant of {@link chatWithTools}. It consumes {@link LLM.chatStream} to assemble the
+ * assistant message (content + tool_calls), then executes tool calls the same way as the
+ * non-streaming loop.
+ *
+ * Notes:
+ * - Tool execution is still round-based: tools are executed only after the assistant turn completes.
+ * - Text deltas are only emitted when an LLM output policy enables them.
+ */
+export async function chatWithToolsStreaming(initialMessages, chatOptions, session) {
+    if (!session.llm.chatStream) {
+        return 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 canonicalEmitters = createCanonicalEmitterRegistry(session);
+    try {
+        for (let round = 0; round < maxRounds; round++) {
+            const roundStartedAt = Date.now();
+            const toolCalls = new ToolCallAccumulator();
+            const emittedModelToolCallIds = new Set();
+            const streamId = createStreamingStreamId({ session, phase, round });
+            const canonicalEmitter = canonicalEmitters.get(streamId);
+            let usedFallback = false;
+            let finishReason;
+            try {
+                let streamContent = '';
+                let finishUsage;
+                try {
+                    const consumed = await consumeAssistantStreamTurn({
+                        session,
+                        messages,
+                        chatOptions,
+                        openAITools,
+                        allowedSpecs,
+                        phase,
+                        round,
+                        streamId,
+                        canonicalEmitter,
+                        emittedModelToolCallIds,
+                        toolCalls,
+                    });
+                    streamContent = consumed.content;
+                    finishReason = consumed.finishReason;
+                    finishUsage = consumed.finishUsage;
+                }
+                catch (e) {
+                    recordAuditEvent('llm.round', {
+                        status: 'error',
+                        streamed: true,
+                        usedFallback: false,
+                        phase,
+                        round,
+                        model: session.runtime.model,
+                        durationMs: Date.now() - roundStartedAt,
+                        provider: extractProvider(e),
+                        statusCode: extractStatusCode(e),
+                        networkCode: extractNetworkCode(e),
+                        errorName: e instanceof Error ? e.name : 'UnknownError',
+                        errorCode: typeof e?.llmCode === 'string'
+                            ? e.llmCode
+                            : typeof e?.code === 'string'
+                                ? e.code
+                                : undefined,
+                    }, { source: 'llm', severity: 'low', scope: 'session', phase });
+                    throw e;
+                }
+                if (finishUsage) {
+                    recordAuditEvent('llm.usage', {
+                        promptTokens: finishUsage.promptTokens,
+                        completionTokens: finishUsage.completionTokens,
+                    }, { source: 'llm', severity: 'low', scope: 'session', phase });
+                }
+                const drainedToolCalls = toolCalls.drain();
+                const fallback = await applyEmptyStreamFallback({
+                    session,
+                    messages,
+                    chatOptions,
+                    openAITools,
+                    allowedSpecs,
+                    phase,
+                    round,
+                    content: streamContent,
+                    collectedToolCalls: drainedToolCalls,
+                });
+                usedFallback = fallback.usedFallback;
+                const assistant = {
+                    role: 'assistant',
+                    content: fallback.content,
+                    tool_calls: fallback.toolCalls.length > 0 ? fallback.toolCalls : undefined,
+                };
+                if (session.emit && session.llmOutput) {
+                    emitSynthesizedFunctionCallClosures({
+                        emit: session.emit,
+                        llmOutput: session.llmOutput,
+                        canonicalEmitter,
+                        streamId,
+                        phase,
+                        round,
+                        collectedToolCalls: fallback.toolCalls,
+                        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,
+                    usedFallback,
+                    phase,
+                    round,
+                    model: session.runtime.model,
+                    durationMs: Date.now() - roundStartedAt,
+                    finishReason,
+                    contentChars: assistant.content.length,
+                    toolCallCount: fallback.toolCalls.length,
+                }, { source: 'llm', severity: 'low', scope: 'session', phase });
+                messages.push(assistant);
+                const calls = assistant.tool_calls || [];
+                if (!Array.isArray(calls) || calls.length === 0) {
+                    return assistant;
+                }
+                await executeToolCalls(session, phase, round, calls, messages, chatOptions.signal);
+            }
+            finally {
+                canonicalEmitters.release(streamId);
+            }
+        }
+    }
+    finally {
+        canonicalEmitters.clear();
+    }
+    session.emit?.({
+        type: 'log',
+        level: 'warn',
+        message: `Tool calling exceeded maximum rounds (${maxRounds}); continuing without further tool execution`,
+        timestamp: new Date(),
+    });
+    const lastAssistant = [...messages].reverse().find((m) => m.role === 'assistant');
+    return lastAssistant || { role: 'assistant', content: '' };
+}
+//# sourceMappingURL=session.js.map