@tomsun28/pizza 0.0.9 → 0.1.1

package/dist/core/runtime/reactor.js

@@ -0,0 +1,992 @@
+/**
+ * Reactor — Event-Driven Agent Core
+ *
+ * Replaces the AgentLoop while-loop with a set of typed handlers that react
+ * to events appended to the EventStore. Each handler is a pure async function
+ * that may emit new events. The reactor itself is stateless — all mutable
+ * state lives in the EventStore.
+ *
+ * Event flow:
+ *
+ *   USER_MESSAGE / USER_INTERRUPT / TOOL_RESULTS_AGGREGATED / RETRY_SCHEDULED
+ *         ↓
+ *   [onUserMessage]  ──→ emit AGENT_TURN_REQUESTED
+ *         ↓
+ *   [onAgentTurnRequested]  ──→ emit LLM_CALL_REQUESTED
+ *         ↓
+ *   [onLlmCallRequested]  ──→ call LLM → emit AGENT_MESSAGE_START/CHUNK/END
+ *         ↓
+ *   [onAgentMessageEnd]
+ *       ├── if no tool_calls → emit AGENT_TURN_COMPLETED
+ *       └── if tool_calls → emit INTENT_TOOL_CALL (one per call)
+ *         ↓
+ *   [onIntentToolCall]  ──→ (approval gate) → emit TOOL_EXECUTION_START/END
+ *         ↓
+ *   [onToolExecutionEnd]  ──→ track count → if all done → emit TOOL_RESULTS_AGGREGATED
+ *         ↓
+ *   [onToolResultsAggregated]  ──→ emit AGENT_TURN_REQUESTED  ← loop back
+ *
+ * Other handlers (run in parallel, do not gate the main flow):
+ *   onAgentTurnCompleted  — UI notification
+ *   onLlmCallFailed        — retry scheduling
+ *   onUserInterrupt        — abort signal + turn completion
+ *   onCompactionRequested  — compaction orchestration
+ */
+import { extractToolCalls } from "../projection/event-to-message.js";
+import { DefaultRetryPolicy, NoopCompactionPolicy } from "./policies.js";
+/**
+ * Safety limit: if the model calls the exact same set of tools (by name) in this
+ * many consecutive turns, the reactor assumes it is stuck in an unproductive loop
+ * and completes the turn instead of requesting another. Prevents runaway loops
+ * (e.g. a model repeatedly calling a control tool like session_split).
+ */
+const MAX_CONSECUTIVE_IDENTICAL_TOOL_ROUNDS = 6;
+export class Reactor {
+    constructor(config) {
+        this.turnTrackers = new Map();
+        this.handlers = {};
+        this.unsubscribers = [];
+        this._isRunning = false;
+        /** Pending follow-up messages (delivered after current turn completes without interrupt). */
+        this.followUpQueue = [];
+        /** Retry timers waiting to re-enter the turn loop. */
+        this.retryTimers = new Map();
+        /** Set when abort() is called with no new content — next turn completion should discard queued follow-ups. */
+        this._abortedByUser = false;
+        /** Tool names called in each consecutive tool-use round within the current prompt cycle. */
+        this._toolRoundSignatures = [];
+        // ─── INTENT_TOOL_CALL ──────────────────────────────────────────────────
+        this._pendingApprovals = new Map();
+        this.config = config;
+        this.retryPolicy = config.retryPolicy ?? new DefaultRetryPolicy();
+        this.compactionPolicy = config.compactionPolicy ?? new NoopCompactionPolicy();
+        this._registerAllHandlers();
+    }
+    // =========================================================================
+    // Lifecycle
+    // =========================================================================
+    /** Subscribe to all events and start the reactor. */
+    async start() {
+        if (this._isRunning)
+            return;
+        this._isRunning = true;
+        this.abortController = new AbortController();
+        // Subscribe to the event store — all events flow through the store
+        const unsub = this.config.store.subscribe((event) => this._dispatch(event));
+        this.unsubscribers.push(unsub);
+        // Replay any pre-existing follow-up events that were queued while the reactor was idle
+        this._replayPendingFollowUps();
+        // Emit RUNTIME_STARTED if the store is fresh
+        if (this.config.store.size === 0) {
+            this._emit({
+                actor_id: "runtime",
+                type: "RUNTIME_STARTED",
+                payload: {},
+            });
+        }
+    }
+    /**
+     * Replay USER_FOLLOWUP_QUEUED events that were appended while the reactor was idle.
+     * Skips events that have already been consumed (i.e. an AGENT_TURN_COMPLETED with a
+     * caused_by chain that includes them).
+     *
+     * For now we use a simple heuristic: count followups vs followup-driven user messages.
+     * If followups outnumber the consumed ones, replay the difference into the in-memory queue.
+     */
+    _replayPendingFollowUps() {
+        const followups = this.config.store.query({ types: ["USER_FOLLOWUP_QUEUED"] });
+        if (followups.length === 0)
+            return;
+        // A USER_FOLLOWUP_QUEUED is "consumed" when a USER_MESSAGE event has it as caused_by.
+        const userMessages = this.config.store.query({ types: ["USER_MESSAGE"] });
+        const consumedCausedBy = new Set(userMessages.map((m) => m.caused_by).filter((id) => !!id));
+        for (const f of followups) {
+            if (consumedCausedBy.has(f.event_id))
+                continue;
+            const p = f.payload;
+            this.followUpQueue.push({ content: p.content, images: p.images });
+        }
+    }
+    /** Stop the reactor. Clears all subscriptions. */
+    stop() {
+        this._isRunning = false;
+        this.abortController?.abort();
+        for (const { timeout } of this.retryTimers.values()) {
+            clearTimeout(timeout);
+        }
+        this.retryTimers.clear();
+        for (const unsub of this.unsubscribers)
+            unsub();
+        this.unsubscribers = [];
+    }
+    /** Check if the reactor is running. */
+    get isRunning() {
+        return this._isRunning;
+    }
+    /** Abort signal for the currently active reactor run. */
+    get signal() {
+        return this.abortController?.signal;
+    }
+    // =========================================================================
+    // Event dispatch
+    // =========================================================================
+    async _dispatch(event) {
+        const handler = this.handlers[event.type];
+        if (!handler)
+            return;
+        try {
+            await handler(event);
+        }
+        catch (err) {
+            // Emit as RUNTIME_ERROR instead of throwing — the reactor must keep running
+            const msg = err instanceof Error ? err.message : String(err);
+            this._emit({
+                actor_id: "runtime",
+                type: "RUNTIME_ERROR",
+                payload: { error: msg, stack: err instanceof Error ? err.stack : undefined, causing_event_id: event.event_id },
+            });
+        }
+    }
+    _emit(input) {
+        return this.config.store.append(input);
+    }
+    /** Check if the reactor has been asked to stop. */
+    _shouldInterrupt() {
+        return this.abortController?.signal.aborted ?? false;
+    }
+    /** Interrupt the reactor. */
+    interrupt() {
+        this.abortController?.abort();
+    }
+    // =========================================================================
+    // Handler registration
+    // =========================================================================
+    _registerAllHandlers() {
+        this.handlers = {
+            USER_MESSAGE: this._onUserMessage.bind(this),
+            USER_INTERRUPT: this._onUserInterrupt.bind(this),
+            USER_FOLLOWUP_QUEUED: this._onUserFollowupQueued.bind(this),
+            AGENT_TURN_REQUESTED: this._onAgentTurnRequested.bind(this),
+            LLM_CALL_REQUESTED: this._onLlmCallRequested.bind(this),
+            AGENT_MESSAGE_END: this._onAgentMessageEnd.bind(this),
+            INTENT_TOOL_CALL: this._onIntentToolCall.bind(this),
+            TOOL_EXECUTION_END: this._onToolExecutionEnd.bind(this),
+            TOOL_RESULTS_AGGREGATED: this._onToolResultsAggregated.bind(this),
+            LLM_CALL_FAILED: this._onLlmCallFailed.bind(this),
+            AGENT_TURN_COMPLETED: this._onAgentTurnCompleted.bind(this),
+            USER_APPROVAL: this._onUserApproval.bind(this),
+            USER_REJECTION: this._onUserRejection.bind(this),
+            COMPACTION_REQUESTED: this._onCompactionRequested.bind(this),
+            SESSION_BOUNDARY_INFERRED: this._onSessionBoundaryInferred.bind(this),
+        };
+    }
+    // =========================================================================
+    // User-facing entry points (used by modes)
+    // =========================================================================
+    /**
+     * Send a user message to the agent (idle path).
+     * For interrupt-while-streaming use steer(). For after-turn-completion use followUp().
+     */
+    prompt(content, images) {
+        this._emit({
+            actor_id: "user",
+            type: "USER_MESSAGE",
+            payload: { content, images },
+        });
+    }
+    /**
+     * Steer: interrupt current turn with a new user message.
+     * The reactor aborts the current LLM call (if any) and treats the steer message
+     * as a fresh USER_MESSAGE once the turn settles.
+     */
+    steer(content, images) {
+        this._emit({
+            actor_id: "user",
+            type: "USER_INTERRUPT",
+            payload: { content, images, reason: "steer" },
+        });
+    }
+    /**
+     * Follow-up: queue a message to be delivered after the current turn naturally completes.
+     * Does not interrupt. If the reactor is idle, behaves like prompt().
+     */
+    followUp(content, images) {
+        this._emit({
+            actor_id: "user",
+            type: "USER_FOLLOWUP_QUEUED",
+            payload: { content, images },
+        });
+    }
+    /** Number of pending follow-up messages. */
+    get pendingFollowUpCount() {
+        return this.followUpQueue.length;
+    }
+    /** Number of scheduled retries waiting to re-enter the turn loop. */
+    get pendingRetryCount() {
+        return this.retryTimers.size;
+    }
+    /** Clear pending follow-ups (e.g. on user-explicit cancel). */
+    clearFollowUpQueue() {
+        this.followUpQueue = [];
+    }
+    // =========================================================================
+    // HANDLERS
+    // =========================================================================
+    // ─── USER_MESSAGE ───────────────────────────────────────────────────────
+    async _onUserMessage(event) {
+        const payload = event.payload;
+        if (this._shouldInterrupt())
+            return;
+        // Reset loop detection for a new prompt cycle
+        this._toolRoundSignatures = [];
+        // Emit thinking start
+        this._emit({
+            actor_id: "coder_agent",
+            type: "AGENT_THINKING_START",
+            payload: { model: this.config.model.model_id },
+            caused_by: event.event_id,
+        });
+        // Emit turn requested — this kicks off the reactor loop
+        this._emit({
+            actor_id: "coder_agent",
+            type: "AGENT_TURN_REQUESTED",
+            payload: { reason: "user_message" },
+            caused_by: event.event_id,
+        });
+    }
+    // ─── USER_INTERRUPT ─────────────────────────────────────────────────────
+    async _onUserInterrupt(event) {
+        const payload = event.payload;
+        this.interrupt();
+        // Track hard abort (no new content) so _onAgentTurnCompleted doesn't drain follow-ups.
+        if (payload.content === undefined) {
+            this._abortedByUser = true;
+        }
+        // If steer carried new content, queue it as a follow-up so the turn-completion
+        // handler picks it up after the current turn settles (aborted state).
+        if (payload.content !== undefined) {
+            this.followUpQueue.push({
+                content: payload.content,
+                images: payload.images,
+            });
+        }
+        // Cancel any pending compaction so we don't block turn completion
+        this.compactionAbort?.abort();
+        if (this.retryTimers.size > 0) {
+            for (const [scheduledEventId, retry] of this.retryTimers) {
+                clearTimeout(retry.timeout);
+                this._emit({
+                    actor_id: "runtime",
+                    type: "RETRY_ABORTED",
+                    payload: {
+                        attempt: retry.attempt,
+                        reason: "user_interrupt",
+                        error_message: retry.errorMessage,
+                        scheduled_event_id: scheduledEventId,
+                    },
+                    caused_by: event.event_id,
+                });
+            }
+            this.retryTimers.clear();
+            this._emit({
+                actor_id: "coder_agent",
+                type: "AGENT_TURN_END",
+                payload: { tool_calls_count: 0 },
+                caused_by: event.event_id,
+            });
+            this._emit({
+                actor_id: "coder_agent",
+                type: "AGENT_TURN_COMPLETED",
+                payload: { reason: "aborted" },
+                caused_by: event.event_id,
+            });
+        }
+    }
+    // ─── USER_FOLLOWUP_QUEUED ───────────────────────────────────────────────
+    async _onUserFollowupQueued(event) {
+        const payload = event.payload;
+        this.followUpQueue.push({ content: payload.content, images: payload.images });
+    }
+    // ─── AGENT_TURN_REQUESTED ───────────────────────────────────────────────
+    async _onAgentTurnRequested(event) {
+        if (this._shouldInterrupt())
+            return;
+        const payload = event.payload;
+        // Build context from projection
+        const context = this.config.projection.buildContext({
+            max_tokens: this.config.contextBudget,
+        });
+        // Stash context for the LLM_CALL_REQUESTED handler. MUST be set before _emit
+        // because store subscribers fire synchronously and _onLlmCallRequested reads
+        // _pendingContext during its sync portion before awaiting the LLM call.
+        this._pendingContext = context;
+        // Emit turn start
+        this._emit({
+            actor_id: "coder_agent",
+            type: "AGENT_TURN_START",
+            payload: { message_count: context.messages.length },
+            caused_by: event.event_id,
+        });
+        // Request an LLM call
+        this._emit({
+            actor_id: "coder_agent",
+            type: "LLM_CALL_REQUESTED",
+            payload: { message_count: context.messages.length },
+            caused_by: event.event_id,
+        });
+    }
+    // ─── LLM_CALL_REQUESTED ─────────────────────────────────────────────────
+    async _onLlmCallRequested(event) {
+        if (this._shouldInterrupt())
+            return;
+        const context = this._pendingContext ?? this.config.projection.buildContext({ max_tokens: this.config.contextBudget });
+        this._pendingContext = undefined;
+        // Emit AGENT_MESSAGE_START up front so chunks have a parent in the causal chain.
+        const msgStart = this._emit({
+            actor_id: "coder_agent",
+            type: "AGENT_MESSAGE_START",
+            payload: { model: { provider: this.config.model.provider, model_id: this.config.model.model_id } },
+            caused_by: event.event_id,
+        });
+        try {
+            const response = await this.config.llmClient.complete({
+                messages: context.messages,
+                systemPrompt: this.config.systemPrompt,
+                model: this.config.model,
+                tools: this.config.tools,
+                signal: this.abortController?.signal,
+                onChunk: (chunk) => {
+                    // Translate LLMChunk into an AGENT_MESSAGE_CHUNK event so projections / UI
+                    // can render the streaming response in real time.
+                    this._emit({
+                        actor_id: "coder_agent",
+                        type: "AGENT_MESSAGE_CHUNK",
+                        payload: { chunk: chunk },
+                        caused_by: msgStart.event_id,
+                    });
+                },
+            });
+            this._handleLlmResponse(response, event.event_id, msgStart.event_id);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const isRetryable = this.retryPolicy.isRetryable({ message: msg });
+            this._emit({
+                actor_id: "runtime",
+                type: "LLM_CALL_FAILED",
+                payload: { error: msg, retryable: isRetryable },
+                caused_by: event.event_id,
+            });
+        }
+    }
+    _handleLlmResponse(response, causedBy, msgStartEventId) {
+        // AGENT_MESSAGE_START is now emitted by _onLlmCallRequested before the call so chunks
+        // can reference it. For backwards compat with callers that don't stream, emit it here
+        // if not already emitted.
+        if (!msgStartEventId) {
+            const started = this._emit({
+                actor_id: "coder_agent",
+                type: "AGENT_MESSAGE_START",
+                payload: { model: { provider: response.provider, model_id: response.model } },
+                caused_by: causedBy,
+            });
+            msgStartEventId = started.event_id;
+        }
+        // Emit message end (the chunking is optional; for now we skip to end for simplicity)
+        const toolCalls = extractToolCalls(response.content);
+        // Append the AGENT_MESSAGE_END event.
+        const msgEnd = this._emit({
+            actor_id: "coder_agent",
+            type: "AGENT_MESSAGE_END",
+            payload: {
+                content: response.content,
+                model: { provider: response.provider, model_id: response.model },
+                usage: response.usage,
+                stop_reason: response.stopReason,
+                error_message: response.errorMessage,
+            },
+            caused_by: causedBy,
+        });
+        // Emit thinking end (turn_end is now emitted in _onAgentMessageEnd)
+        this._emit({
+            actor_id: "coder_agent",
+            type: "AGENT_THINKING_END",
+            payload: {},
+            caused_by: msgEnd.event_id,
+        });
+        // The ON_AGENT_MESSAGE_END handler will dispatch tool calls or complete the turn
+    }
+    // ─── AGENT_MESSAGE_END ──────────────────────────────────────────────────
+    async _onAgentMessageEnd(event) {
+        const payload = event.payload;
+        const toolCalls = extractToolCalls(payload.content);
+        if (this._shouldInterrupt()) {
+            // Emit turn end before completion when interrupted
+            this._emit({
+                actor_id: "coder_agent",
+                type: "AGENT_TURN_END",
+                payload: { tool_calls_count: toolCalls.length },
+                caused_by: event.event_id,
+            });
+            this._emit({
+                actor_id: "coder_agent",
+                type: "AGENT_TURN_COMPLETED",
+                payload: { reason: "aborted" },
+                caused_by: event.event_id,
+            });
+            return;
+        }
+        if (toolCalls.length === 0 || payload.stop_reason !== "tool_use") {
+            // No tool calls — emit turn end and complete the turn
+            this._emit({
+                actor_id: "coder_agent",
+                type: "AGENT_TURN_END",
+                payload: { tool_calls_count: 0 },
+                caused_by: event.event_id,
+            });
+            this._emit({
+                actor_id: "coder_agent",
+                type: "AGENT_TURN_COMPLETED",
+                payload: { reason: payload.stop_reason, error_message: payload.error_message },
+                caused_by: event.event_id,
+            });
+            return;
+        }
+        // Track this turn's tool executions
+        const tracker = {
+            assistantMessageEventId: event.event_id,
+            expectedCount: toolCalls.length,
+            expectedToolCallIds: new Set(toolCalls.map((toolCall) => toolCall.id)),
+            received: [],
+            abortSignal: this.abortController?.signal,
+        };
+        this.turnTrackers.set(event.event_id, tracker);
+        // Record the sorted tool-name signature for loop detection
+        const signature = toolCalls.map((tc) => tc.name).sort();
+        this._toolRoundSignatures.push(signature);
+        // Emit one INTENT_TOOL_CALL per tool call
+        for (const toolCall of toolCalls) {
+            const classification = this.config.classifier.classify(toolCall.name, toolCall.arguments);
+            this._emit({
+                actor_id: "coder_agent",
+                type: "INTENT_TOOL_CALL",
+                payload: {
+                    tool_call_id: toolCall.id,
+                    tool_name: toolCall.name,
+                    arguments: toolCall.arguments,
+                    requires_approval: classification.requires_approval,
+                    classification,
+                },
+                caused_by: event.event_id,
+            });
+        }
+    }
+    async _onIntentToolCall(event) {
+        if (this._shouldInterrupt())
+            return;
+        const payload = event.payload;
+        if (payload.requires_approval) {
+            if (!this.config.approvalHandler) {
+                this._emitToolExecutionEnd(payload.tool_call_id, payload.tool_name, {
+                    content: [{ type: "text", text: "Tool execution requires approval, but no approval handler is available." }],
+                    is_error: true,
+                    error_message: "Approval required but no approval handler is available",
+                }, event.event_id);
+                return;
+            }
+            // Wait for user approval/rejection
+            const approved = await new Promise((resolve) => {
+                this._pendingApprovals.set(event.event_id, {
+                    resolve,
+                    tool_call_id: payload.tool_call_id,
+                    tool_name: payload.tool_name,
+                    arguments: payload.arguments,
+                });
+                this.config.approvalHandler?.requestApproval(event.event_id, payload.classification);
+            });
+            if (!approved) {
+                this._emitToolExecutionEnd(payload.tool_call_id, payload.tool_name, {
+                    content: [{ type: "text", text: "Tool execution rejected by user." }],
+                    is_error: true,
+                    error_message: "User rejected the tool call",
+                }, event.event_id);
+                return;
+            }
+        }
+        // Execute the tool
+        await this._executeTool(event.event_id, payload.tool_call_id, payload.tool_name, payload.arguments);
+    }
+    async _executeTool(causedBy, tool_call_id, tool_name, args) {
+        const startTime = Date.now();
+        this._emit({
+            actor_id: "runtime",
+            type: "TOOL_EXECUTION_START",
+            payload: { tool_call_id, tool_name, arguments: args },
+            caused_by: causedBy,
+        });
+        try {
+            const result = await this.config.runtimeAdapter.executeTool({
+                tool_call_id,
+                tool_name,
+                arguments: args,
+                caused_by: causedBy,
+                signal: this.abortController?.signal,
+                onUpdate: (partial) => {
+                    this._emitToolExecutionUpdate(tool_call_id, partial, causedBy);
+                },
+            });
+            this._emitToolExecutionEnd(tool_call_id, tool_name, result, causedBy, startTime);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this._emitToolExecutionEnd(tool_call_id, tool_name, {
+                content: [{ type: "text", text: msg }],
+                is_error: true,
+                error_message: msg,
+            }, causedBy, startTime);
+        }
+    }
+    _emitToolExecutionUpdate(tool_call_id, partial, causedBy) {
+        this._emit({
+            actor_id: "runtime",
+            type: "TOOL_EXECUTION_UPDATE",
+            payload: {
+                tool_call_id,
+                update: stringifyToolUpdate(partial),
+                progress: partial.progress,
+            },
+            caused_by: causedBy,
+        });
+    }
+    _emitToolExecutionEnd(tool_call_id, tool_name, result, causedBy, startTime) {
+        this._emit({
+            actor_id: "runtime",
+            type: "TOOL_EXECUTION_END",
+            payload: {
+                tool_call_id,
+                tool_name,
+                result: result.content,
+                details: result.details,
+                is_error: result.is_error,
+                duration_ms: startTime !== undefined ? Date.now() - startTime : 0,
+                file_mutations: result.file_mutations,
+            },
+            caused_by: causedBy,
+        });
+    }
+    // ─── TOOL_EXECUTION_END ─────────────────────────────────────────────────
+    async _onToolExecutionEnd(event) {
+        const payload = event.payload;
+        // Emit FILE_MUTATION_APPLIED for each mutation reported by the tool
+        if (payload.file_mutations?.length) {
+            for (const mutation of payload.file_mutations) {
+                this._emit({
+                    actor_id: "runtime",
+                    type: "FILE_MUTATION_APPLIED",
+                    payload: {
+                        path: mutation.path,
+                        operation: mutation.operation,
+                        diff: mutation.diff,
+                        tool_name: payload.tool_name,
+                        tool_call_id: payload.tool_call_id,
+                    },
+                    caused_by: event.event_id,
+                });
+            }
+        }
+        // Find the tracker for this tool call's assistant message
+        // Walk up the causal chain from the TOOL_EXECUTION_END event
+        const causedBy = event.caused_by;
+        // The caused_by points to the INTENT_TOOL_CALL event.
+        // We need to find the INTENT_TOOL_CALL → AGENT_MESSAGE_END chain.
+        // Actually, the causal chain in EventStore should give us this.
+        // For now, find the tracker by looking up the chain:
+        const chain = causedBy ? this.config.store.getCausalChain(event.event_id) : [];
+        // Find the closest AGENT_MESSAGE_END in the causal chain. Consecutive
+        // tool-use turns include older assistant messages earlier in the chain.
+        let assistantMessageEventId;
+        for (let i = chain.length - 1; i >= 0; i--) {
+            const e = chain[i];
+            if (e.type === "AGENT_MESSAGE_END") {
+                assistantMessageEventId = e.event_id;
+                break;
+            }
+        }
+        let tracker = assistantMessageEventId ? this.turnTrackers.get(assistantMessageEventId) : undefined;
+        if (!tracker || !tracker.expectedToolCallIds.has(payload.tool_call_id)) {
+            assistantMessageEventId = undefined;
+            for (const [messageEventId, tracker] of this.turnTrackers) {
+                if (tracker.expectedToolCallIds.has(payload.tool_call_id)) {
+                    assistantMessageEventId = messageEventId;
+                    break;
+                }
+            }
+            tracker = assistantMessageEventId ? this.turnTrackers.get(assistantMessageEventId) : undefined;
+        }
+        if (!tracker || !assistantMessageEventId)
+            return;
+        if (tracker.received.some((result) => result.tool_call_id === payload.tool_call_id))
+            return;
+        tracker.received.push({
+            tool_call_id: payload.tool_call_id,
+            tool_name: payload.tool_name,
+            result: { content: payload.result, is_error: payload.is_error },
+            is_error: payload.is_error,
+        });
+        // If all tools have completed, emit TOOL_RESULTS_AGGREGATED
+        if (tracker.received.length === tracker.expectedCount) {
+            this.turnTrackers.delete(assistantMessageEventId);
+            this._emit({
+                actor_id: "coder_agent",
+                type: "TOOL_RESULTS_AGGREGATED",
+                payload: {
+                    assistant_message_event_id: assistantMessageEventId,
+                    tool_call_count: tracker.expectedCount,
+                    any_error: tracker.received.some((r) => r.is_error),
+                },
+                caused_by: event.event_id,
+            });
+        }
+    }
+    // ─── TOOL_RESULTS_AGGREGATED ────────────────────────────────────────────
+    async _onToolResultsAggregated(event) {
+        const payload = event.payload;
+        if (this._shouldInterrupt()) {
+            // Emit turn end before completion when interrupted
+            this._emit({
+                actor_id: "coder_agent",
+                type: "AGENT_TURN_END",
+                payload: { tool_calls_count: payload.tool_call_count },
+                caused_by: event.event_id,
+            });
+            this._emit({
+                actor_id: "coder_agent",
+                type: "AGENT_TURN_COMPLETED",
+                payload: { reason: "aborted" },
+                caused_by: event.event_id,
+            });
+            return;
+        }
+        // Emit turn end to signal completion of this tool-call turn
+        this._emit({
+            actor_id: "coder_agent",
+            type: "AGENT_TURN_END",
+            payload: { tool_calls_count: payload.tool_call_count },
+            caused_by: event.event_id,
+        });
+        // Loop detection: if the model has called the exact same set of tools
+        // (by name) in too many consecutive rounds, break the loop by completing
+        // the turn instead of requesting another LLM round.
+        if (this._isInToolLoop()) {
+            this._emit({
+                actor_id: "coder_agent",
+                type: "AGENT_TURN_COMPLETED",
+                payload: { reason: "loop_detected" },
+                caused_by: event.event_id,
+            });
+            return;
+        }
+        // Kick off the next turn with the tool results
+        this._emit({
+            actor_id: "coder_agent",
+            type: "AGENT_TURN_REQUESTED",
+            payload: { reason: "tool_results" },
+            caused_by: event.event_id,
+        });
+    }
+    // ─── SESSION_BOUNDARY_INFERRED ──────────────────────────────────────────
+    /**
+     * When a session split occurs, refresh the projection to point to the new
+     * session. The new session's start_event_id is set to the current USER_MESSAGE,
+     * so buildContext() will include the user's request + tool results but exclude
+     * old conversation history. This lets the model continue working in the same
+     * turn with a clean context.
+     */
+    _onSessionBoundaryInferred(_event) {
+        if (!this.config.sessionManager)
+            return;
+        const newProjection = this.config.sessionManager.getActiveSession();
+        if (newProjection) {
+            this.config.projection = newProjection;
+        }
+    }
+    /**
+     * Check whether the model is stuck in a loop — calling the exact same set
+     * of tool names in too many consecutive rounds.
+     */
+    _isInToolLoop() {
+        const sigs = this._toolRoundSignatures;
+        if (sigs.length < MAX_CONSECUTIVE_IDENTICAL_TOOL_ROUNDS)
+            return false;
+        const recent = sigs.slice(-MAX_CONSECUTIVE_IDENTICAL_TOOL_ROUNDS);
+        const first = recent[0].join(",");
+        return recent.every((sig) => sig.join(",") === first);
+    }
+    // ─── AGENT_TURN_COMPLETED ───────────────────────────────────────────────
+    //
+    // Drain the followUp queue (if any) or let the reactor go idle.
+    // Also triggers compaction check after a non-error turn.
+    _onAgentTurnCompleted(event) {
+        const payload = event.payload;
+        // If abort() was called, discard any pending follow-ups so the reactor stops.
+        // _abortedByUser is set by _onUserInterrupt when the interrupt has no new content.
+        if (this._abortedByUser) {
+            this.followUpQueue = [];
+            this._abortedByUser = false;
+            return;
+        }
+        if (this._scheduleRetryForCompletedError(event)) {
+            return;
+        }
+        // If a steer or follow-up message is queued, deliver it as a new USER_MESSAGE
+        // so the turn cycle restarts.
+        if (this.followUpQueue.length > 0) {
+            // Reset abort controller for the new turn — the previous turn's interrupt
+            // has already been handled.
+            this.abortController = new AbortController();
+            const next = this.followUpQueue.shift();
+            this._emit({
+                actor_id: "user",
+                type: "USER_MESSAGE",
+                payload: { content: next.content, images: next.images },
+                caused_by: event.event_id,
+            });
+            return;
+        }
+        // Check compaction policy after a non-aborted turn
+        if (payload.reason !== "aborted") {
+            this._checkCompaction(event);
+        }
+    }
+    // ─── LLM_CALL_FAILED ────────────────────────────────────────────────────
+    async _onLlmCallFailed(event) {
+        const payload = event.payload;
+        const retryResult = this._scheduleRetry(event, payload.error, payload.retryable);
+        if (retryResult === "scheduled")
+            return;
+        const attempt = this._attemptCount(event.event_id);
+        // Emit turn end before completion
+        this._emit({
+            actor_id: "coder_agent",
+            type: "AGENT_TURN_END",
+            payload: { tool_calls_count: 0 },
+            caused_by: event.event_id,
+        });
+        this._emit({
+            actor_id: "coder_agent",
+            type: "AGENT_TURN_COMPLETED",
+            payload: {
+                reason: "error",
+                error_message: retryResult === "max_attempts"
+                    ? `Max retries (${this.retryPolicy.maxAttempts}) exceeded: ${payload.error}`
+                    : retryResult === "backoff_exhausted"
+                        ? `Retry backoff exhausted: ${payload.error}`
+                        : payload.error,
+            },
+            caused_by: event.event_id,
+        });
+    }
+    _scheduleRetryForCompletedError(event) {
+        if (this.config.retryAssistantErrorCompletions === false)
+            return false;
+        const payload = event.payload;
+        if (payload.reason !== "error")
+            return false;
+        if (this._errorAlreadyHandledByLlmFailure(event))
+            return false;
+        const errorMessage = payload.error_message ?? "Agent turn completed with error";
+        return this._scheduleRetry(event, errorMessage, this.retryPolicy.isRetryable({ message: errorMessage })) === "scheduled";
+    }
+    _errorAlreadyHandledByLlmFailure(event) {
+        const causedBy = event.caused_by ? this.config.store.get(event.caused_by) : undefined;
+        return causedBy?.type === "LLM_CALL_FAILED";
+    }
+    _scheduleRetry(event, error, retryable) {
+        const attempt = this._attemptCount(event.event_id);
+        if (!retryable || attempt >= this.retryPolicy.maxAttempts) {
+            return retryable ? "max_attempts" : "not_retryable";
+        }
+        const nextAttempt = attempt + 1;
+        const delayMs = this.retryPolicy.nextDelayMs(nextAttempt);
+        if (delayMs === null) {
+            return "backoff_exhausted";
+        }
+        const retryScheduled = this._emit({
+            actor_id: "runtime",
+            type: "RETRY_SCHEDULED",
+            payload: {
+                attempt: nextAttempt,
+                max_attempts: this.retryPolicy.maxAttempts,
+                delay_ms: delayMs,
+                error_message: error,
+            },
+            caused_by: event.event_id,
+        });
+        const timeout = setTimeout(() => {
+            this.retryTimers.delete(retryScheduled.event_id);
+            if (!this._shouldInterrupt()) {
+                this._emit({
+                    actor_id: "coder_agent",
+                    type: "AGENT_TURN_REQUESTED",
+                    payload: { reason: "retry", retry_attempt: nextAttempt },
+                    caused_by: retryScheduled.event_id,
+                });
+            }
+        }, delayMs);
+        this.retryTimers.set(retryScheduled.event_id, {
+            timeout,
+            attempt: nextAttempt,
+            errorMessage: error,
+        });
+        return "scheduled";
+    }
+    /** Walk causal chain back to find the highest retry_attempt seen. */
+    _attemptCount(eventId) {
+        const chain = this.config.store.getCausalChain(eventId);
+        let attempt = 0;
+        for (const e of chain) {
+            if (e.type === "AGENT_TURN_REQUESTED") {
+                const p = e.payload;
+                if (p.retry_attempt !== undefined && p.retry_attempt > attempt) {
+                    attempt = p.retry_attempt;
+                }
+            }
+        }
+        return attempt;
+    }
+    // ─── USER_APPROVAL ──────────────────────────────────────────────────────
+    async _onUserApproval(event) {
+        const payload = event.payload;
+        const pending = this._pendingApprovals.get(payload.intent_event_id);
+        if (pending) {
+            this._pendingApprovals.delete(payload.intent_event_id);
+            pending.resolve(true);
+        }
+    }
+    // ─── USER_REJECTION ─────────────────────────────────────────────────────
+    async _onUserRejection(event) {
+        const payload = event.payload;
+        const pending = this._pendingApprovals.get(payload.intent_event_id);
+        if (pending) {
+            this._pendingApprovals.delete(payload.intent_event_id);
+            pending.resolve(false);
+        }
+    }
+    // ─── COMPACTION ─────────────────────────────────────────────────────────
+    async _onCompactionRequested(event) {
+        if (this.compactionAbort)
+            return; // Already running
+        const payload = event.payload;
+        const abortController = new AbortController();
+        this.compactionAbort = abortController;
+        this._emit({
+            actor_id: "compactor",
+            type: "COMPACTION_START",
+            payload: { token_count: payload.token_count },
+            caused_by: event.event_id,
+        });
+        try {
+            const outcome = await this.compactionPolicy.compact(payload.reason, abortController.signal);
+            this._emit({
+                actor_id: "compactor",
+                type: "COMPACTION_END",
+                payload: {
+                    summary: outcome.summary,
+                    first_kept_event_id: outcome.first_kept_event_id,
+                    tokens_before: outcome.tokens_before,
+                    tokens_after: outcome.tokens_after,
+                },
+                caused_by: event.event_id,
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (abortController.signal.aborted) {
+                this._emit({
+                    actor_id: "compactor",
+                    type: "COMPACTION_ABORTED",
+                    payload: {
+                        reason: "user_cancelled",
+                        message: msg,
+                        token_count: payload.token_count,
+                    },
+                    caused_by: event.event_id,
+                });
+                return;
+            }
+            this._emit({
+                actor_id: "compactor",
+                type: "COMPACTION_END",
+                payload: {
+                    summary: `Compaction failed: ${msg}`,
+                    first_kept_event_id: "",
+                    tokens_before: 0,
+                },
+                caused_by: event.event_id,
+            });
+        }
+        finally {
+            this.compactionAbort = undefined;
+        }
+    }
+    /**
+     * Check compaction policy after a non-error turn. Emits COMPACTION_REQUESTED if
+     * threshold or overflow conditions are met.
+     */
+    _checkCompaction(turnCompletedEvent) {
+        const policy = this.compactionPolicy;
+        // Walk the causal chain to find the AGENT_MESSAGE_END that produced this turn completion.
+        // This avoids mutable state (_lastAssistantMessageEvent) that races with synchronous event dispatch.
+        const lastAssistant = this._findLastAssistantMessage(turnCompletedEvent.event_id);
+        // Overflow takes priority — when it fires we skip the threshold check entirely.
+        // This prevents both "overflow" and "threshold" COMPACTION_REQUESTED events from
+        // being emitted in the same turn (overflow implies context is over threshold too).
+        if (policy.isOverflow(lastAssistant)) {
+            const tokens = policy.estimateContextTokens();
+            this._emit({
+                actor_id: "runtime",
+                type: "COMPACTION_REQUESTED",
+                payload: { reason: "overflow", token_count: tokens },
+                caused_by: turnCompletedEvent.event_id,
+            });
+            return;
+        }
+        const tokens = policy.estimateContextTokens();
+        const window = policy.contextWindow();
+        if (window > 0 && window !== Number.MAX_SAFE_INTEGER && tokens > window * policy.threshold()) {
+            this._emit({
+                actor_id: "runtime",
+                type: "COMPACTION_REQUESTED",
+                payload: { reason: "threshold", token_count: tokens },
+                caused_by: turnCompletedEvent.event_id,
+            });
+        }
+    }
+    /**
+     * Walk causal chain back from the given event to find the most recent AGENT_MESSAGE_END.
+     * Replaces the mutable _lastAssistantMessageEvent field which races with synchronous dispatch.
+     */
+    _findLastAssistantMessage(eventId) {
+        const chain = this.config.store.getCausalChain(eventId);
+        for (let i = chain.length - 1; i >= 0; i--) {
+            if (chain[i].type === "AGENT_MESSAGE_END")
+                return chain[i];
+        }
+        return undefined;
+    }
+}
+function stringifyToolUpdate(partial) {
+    const text = partial.content
+        .filter((block) => {
+        return block.type === "text" && "text" in block && typeof block.text === "string";
+    })
+        .map((block) => block.text)
+        .join("\n");
+    if (text)
+        return text;
+    if (partial.content.length > 0)
+        return JSON.stringify(partial.content);
+    if (partial.details !== undefined)
+        return JSON.stringify(partial.details);
+    return "";
+}