@ariaflowagents/core 0.7.1 → 0.9.0

package/dist/runtime/Runtime.js

@@ -1,10 +1,3 @@
-import crypto from 'node:crypto';
-import { streamText, generateText, Output, stepCountIs } from 'ai';
-import { z } from 'zod';
-import { createHandoffTool, isHandoffResult } from '../tools/handoff.js';
-import { isFinalResult } from '../tools/final.js';
-import { InjectionQueue, getPolicyProfileInjections } from './InjectionQueue.js';
-import { checkStopConditions, defaultStopConditions } from '../guards/StopConditions.js';
 import { HookRunner } from '../hooks/HookRunner.js';
 import { ToolEnforcer } from '../guards/ToolEnforcer.js';
 import { defaultEnforcementRules } from '../guards/rules.js';
@@ -12,169 +5,224 @@ import { MemoryStore } from '../session/stores/MemoryStore.js';
 import { createHttpCallback } from '../callbacks/httpCallback.js';
 import { createStreamCallbackAdapter } from '../callbacks/streamCallback.js';
 import { compileSanitizePattern } from '../flows/template.js';
-import { runInputProcessors, runOutputProcessors } from '../processors/ProcessorRunner.js';
-import { getChunkArgs, getChunkErrorMessage, getChunkResult, getChunkToolCallId } from '../utils/streamChunk.js';
-import { normalizeModelMessage } from '../utils/messageNormalization.js';
-import { isRecord } from '../utils/isRecord.js';
+import { defaultStopConditions } from '../guards/StopConditions.js';
 import { ExtractionEngine } from './ExtractionEngine.js';
-import { SessionEventManager } from './SessionEventManager.js';
 import { SuggestionManager } from './SuggestionManager.js';
 import { FlowExecutor } from './FlowExecutor.js';
-import { SessionWorkingMemory } from './WorkingMemory.js';
+import { DefaultToolExecutor } from '../foundation/DefaultToolExecutor.js';
+import { DefaultConversationState } from '../foundation/DefaultConversationState.js';
+import { DefaultConversationEventLog } from '../foundation/DefaultConversationEventLog.js';
+import { DefaultAgentStateController } from '../foundation/DefaultAgentStateController.js';
+import { SessionCache } from './SessionCache.js';
+import { StreamEmitter } from './StreamEmitter.js';
+import { SessionMutex } from './SessionMutex.js';
+import { runIntakeStage } from './pipeline/IntakeStage.js';
+import { runAgentExecuteStage } from './pipeline/AgentExecuteStage.js';
+import { runPostStreamStage } from './pipeline/PostStreamStage.js';
+import { DefaultOrchestrationAuthority } from '../orchestration/DefaultOrchestrationAuthority.js';
 export class Runtime {
     config;
-    agents = new Map();
-    defaultAgentId;
-    defaultModel;
-    maxSteps;
-    maxHandoffs;
-    stopConditions;
-    _sessionStore;
-    hookRunner;
-    enforcer;
-    contextManager;
-    turnCount = 0;
     abortControllers = new Map();
-    alwaysRouteThroughTriage;
-    triageAgentId;
-    inputProcessors;
-    outputProcessors;
-    outputProcessorMode;
-    outputRedactions;
-    redactCarryKey = '__ariaRedactCarry';
-    redactLookbehind = 64;
-    runtimeEventLogKey = 'runtimeEventLog';
-    runtimeSessionTurnKey = '__ariaSessionTurn';
-    runtimeEventLogMaxEntries = 2000;
-    checkpointEventTypes = new Set([
-        'tool-result',
-        'tool-error',
-        'flow-transition',
-    ]);
-    extractionEngine;
-    sessionEventManager;
-    suggestionManager;
-    flowExecutor;
-    wrapToolsWithEnforcement(context, tools) {
-        console.log('[Runtime] Wrapping tools:', Object.keys(tools));
-        const wrapped = {};
-        for (const [toolName, toolDef] of Object.entries(tools ?? {})) {
-            const exec = toolDef?.execute;
-            if (typeof exec !== 'function') {
-                wrapped[toolName] = toolDef;
-                continue;
-            }
-            wrapped[toolName] = {
-                ...toolDef,
-                execute: async (args, options) => {
-                    const toolCallId = typeof options?.toolCallId === 'string'
-                        ? options.toolCallId
-                        : crypto.randomUUID();
-                    const idempotencyKey = this.buildToolIdempotencyKey(context, toolName, toolCallId);
-                    const callRecord = {
-                        toolCallId,
-                        toolName,
-                        args,
-                        idempotencyKey,
-                        success: true,
-                        timestamp: Date.now(),
-                    };
-                    const enforcement = await this.enforcer.check(callRecord, {
-                        previousCalls: context.toolCallHistory,
-                        currentStep: context.stepCount,
-                        sessionState: context.session.state ?? {},
-                    });
-                    if (!enforcement.allowed) {
-                        const reason = enforcement.reason ?? 'Tool call blocked by enforcement';
-                        callRecord.success = false;
-                        callRecord.error = new Error(reason);
-                        context.toolCallHistory.push(callRecord);
-                        await this.hookRunner.onToolError(context, callRecord, callRecord.error);
-                        throw callRecord.error;
-                    }
-                    // Preserve AI SDK tool execution context (toolCallId, messages, experimental_context, etc.).
-                    const enrichedOptions = this.withToolExecutionMetadata(options, context, toolName, toolCallId, idempotencyKey);
-                    try {
-                        console.log(`[Runtime] Executing tool ${toolName}...`);
-                        return await exec(args, enrichedOptions);
-                    }
-                    catch (error) {
-                        console.error(`[Runtime] Tool execution failed for ${toolName}:`, error);
-                        throw error;
-                    }
-                },
-            };
-        }
-        return wrapped;
-    }
+    _userIdWarned = new Set();
+    sessionMutex = new SessionMutex();
+    turnServices;
+    _authority;
+    // Keep references for public API getters
+    _sessionStore;
+    _memoryService;
+    _toolExecutor;
+    _conversationState;
+    _eventLog;
+    _agentStateController;
     constructor(config) {
         this.config = config;
+        // Build agent map
+        const agents = new Map();
         for (const agent of config.agents) {
-            this.agents.set(agent.id, agent);
+            agents.set(agent.id, agent);
+        }
+        // Config scalars
+        const defaultAgentId = config.defaultAgentId;
+        const defaultModel = config.defaultModel;
+        const maxSteps = config.maxSteps ?? 20;
+        const maxHandoffs = config.maxHandoffs ?? 10;
+        const stopConditions = config.stopConditions ?? defaultStopConditions;
+        const sessionStore = config.sessionStore ?? new MemoryStore();
+        const inputProcessors = config.inputProcessors ?? [];
+        const outputProcessors = config.outputProcessors ?? [];
+        const outputProcessorMode = config.outputProcessorMode ?? 'stream';
+        const alwaysRouteThroughTriage = config.alwaysRouteThroughTriage ?? false;
+        const triageAgentId = config.triageAgentId;
+        // Output redactions
+        let outputRedactions;
+        if (config.outputRedaction && config.outputRedaction.length > 0) {
+            outputRedactions = config.outputRedaction.map(r => {
+                const base = compileSanitizePattern(r.pattern);
+                const flags = base.flags.includes('g') ? base.flags : `${base.flags}g`;
+                const re = new RegExp(base.source, flags);
+                return { re, replacement: r.replacement };
+            });
         }
-        this.defaultAgentId = config.defaultAgentId;
-        this.defaultModel = config.defaultModel;
-        this.maxSteps = config.maxSteps ?? 20;
-        this.maxHandoffs = config.maxHandoffs ?? 10;
-        this.stopConditions = config.stopConditions ?? defaultStopConditions;
-        this._sessionStore = config.sessionStore ?? new MemoryStore();
+        // Hooks setup
         const hooks = { ...config.hooks };
         const appendOnStreamPart = (fn) => {
             const originalHook = hooks.onStreamPart;
             hooks.onStreamPart = async (context, part) => {
-                if (originalHook) {
+                if (originalHook)
                     await originalHook(context, part);
-                }
                 await fn(context, part);
             };
         };
         if (config.callback) {
-            const httpCallback = createHttpCallback(config.callback);
-            appendOnStreamPart(httpCallback);
+            appendOnStreamPart(createHttpCallback(config.callback));
         }
         if (config.streamCallback) {
             const adapter = createStreamCallbackAdapter(config.streamCallback);
             appendOnStreamPart(adapter.onStreamPart);
             const originalOnEnd = hooks.onEnd;
             hooks.onEnd = async (context, result) => {
-                if (originalOnEnd) {
+                if (originalOnEnd)
                     await originalOnEnd(context, result);
-                }
                 if (config.streamCallback?.flushOnEnd) {
                     await adapter.flush(config.streamCallback.flushTimeoutMs ?? 2000);
                 }
             };
         }
-        this.hookRunner = new HookRunner(hooks);
-        this.enforcer = new ToolEnforcer(config.enforcementRules ?? defaultEnforcementRules);
-        this.contextManager = config.contextManager;
-        this.alwaysRouteThroughTriage = config.alwaysRouteThroughTriage ?? false;
-        this.triageAgentId = config.triageAgentId;
-        this.inputProcessors = config.inputProcessors ?? [];
-        this.outputProcessors = config.outputProcessors ?? [];
-        this.outputProcessorMode = config.outputProcessorMode ?? 'stream';
-        if (config.outputRedaction && config.outputRedaction.length > 0) {
-            this.outputRedactions = config.outputRedaction.map(r => {
-                const base = compileSanitizePattern(r.pattern);
-                const flags = base.flags.includes('g') ? base.flags : `${base.flags}g`;
-                const re = new RegExp(base.source, flags);
-                return { re, replacement: r.replacement };
-            });
-        }
-        this.extractionEngine = new ExtractionEngine({
-            defaultModel: this.defaultModel,
-            telemetry: config.telemetry,
+        const hookRunner = new HookRunner(hooks);
+        const enforcer = new ToolEnforcer(config.enforcementRules ?? defaultEnforcementRules);
+        const contextManager = config.contextManager;
+        // Service instances
+        const extractionEngine = new ExtractionEngine({ defaultModel, telemetry: config.telemetry });
+        const suggestionManager = new SuggestionManager(config);
+        const flowExecutor = new FlowExecutor(config);
+        const memoryService = config.memoryService;
+        const conversationState = new DefaultConversationState({
+            sessionStore,
+            defaultAgentId,
         });
-        this.sessionEventManager = new SessionEventManager({
-            touchSession: session => this.touchSession(session),
-            getSessionTurn: session => this.getSessionTurn(session),
+        const eventLog = new DefaultConversationEventLog({ sessionStore });
+        const agentStateController = new DefaultAgentStateController();
+        const toolExecutor = new DefaultToolExecutor({
+            enforcer,
+            hookRunner,
+            memoryService,
+        });
+        let sessionCache;
+        if (config.sessionCache) {
+            sessionCache = new SessionCache(config.sessionCache);
+        }
+        const streamEmitter = new StreamEmitter({
+            hookRunner,
+            eventLog,
+            hasStreamPartHook: Boolean(hooks.onStreamPart),
+            outputRedactions,
+            redactCarryKey: '__ariaRedactCarry',
+            redactLookbehind: 64,
+            saveSessionCheckpoint: async (session) => {
+                await eventLog.checkpoint(session);
+                if (sessionCache)
+                    sessionCache.put(session);
+            },
+        });
+        // Store references for public API
+        this._sessionStore = sessionStore;
+        this._memoryService = memoryService;
+        this._toolExecutor = toolExecutor;
+        this._conversationState = conversationState;
+        this._eventLog = eventLog;
+        this._agentStateController = agentStateController;
+        // Build TurnServices — one plain struct, no closures
+        this.turnServices = {
+            conversationState,
+            agentStateController,
+            eventLog,
+            toolExecutor,
+            streamEmitter,
+            hookRunner,
+            enforcer,
+            extractionEngine,
+            suggestionManager,
+            flowExecutor,
+            contextManager,
+            memoryService,
+            sessionCache,
+            sessionStore,
+            agents,
+            config,
+            defaultAgentId,
+            defaultModel,
+            maxSteps,
+            maxHandoffs,
+            stopConditions,
+            inputProcessors,
+            outputProcessors,
+            outputProcessorMode,
+            outputRedactions,
+            alwaysRouteThroughTriage,
+            triageAgentId,
+        };
+        // Build OrchestrationAuthority that shares the same backing services.
+        // This establishes the architectural connection: both text (this Runtime)
+        // and realtime (RealtimeRuntime) can compose the same authority, sharing
+        // session store, hooks, tool executor, and all foundation services.
+        this._authority = new DefaultOrchestrationAuthority({
+            agents: config.agents,
+            defaultAgentId,
+            hooks,
+            sessionStore,
+            memoryService,
+            memoryIngestion: config.memoryIngestion,
+            defaultModel,
+            extractionModel: config.extractionModel,
+            enforcementRules: config.enforcementRules,
+            telemetry: config.telemetry,
+            injectedServices: {
+                toolExecutor,
+                conversationState,
+                eventLog,
+                agentState: agentStateController,
+                hookRunner,
+            },
         });
-        this.suggestionManager = new SuggestionManager(config);
-        this.flowExecutor = new FlowExecutor(config);
     }
+    // --- Public API ---
     get sessionStore() {
         return this._sessionStore;
     }
+    get memoryService() {
+        return this._memoryService;
+    }
+    /** Foundation services — shared primitives reusable by VoiceEngine etc. */
+    get foundation() {
+        return {
+            toolExecutor: this._toolExecutor,
+            conversationState: this._conversationState,
+            eventLog: this._eventLog,
+            agentState: this._agentStateController,
+        };
+    }
+    /**
+     * The core orchestration authority shared by this Runtime.
+     *
+     * This authority uses the same backing services (session store, hook runner,
+     * tool executor, etc.) as the text pipeline. Use it to construct a
+     * RealtimeRuntime that shares state with this Runtime:
+     *
+     * ```typescript
+     * const runtime = createRuntime(config);
+     * const realtimeRuntime = new RealtimeRuntime({
+     *   agents: config.agents,
+     *   defaultAgentId: config.defaultAgentId,
+     *   authority: runtime.authority,
+     * });
+     * ```
+     *
+     * This ensures text and realtime sessions share the same session store,
+     * the same hooks fire for both paths, and agent state is consistent.
+     */
+    get authority() {
+        return this._authority;
+    }
     getActiveAbortController(sessionId) {
         return this.abortControllers.get(sessionId);
     }
@@ -185,144 +233,84 @@ export class Runtime {
             this.abortControllers.delete(sessionId);
         }
     }
+    async getSession(id) {
+        return this._sessionStore.get(id);
+    }
+    async deleteSession(id) {
+        await this._sessionStore.delete(id);
+    }
+    getAgent(id) {
+        return this.turnServices.agents.get(id);
+    }
+    getAllAgents() {
+        return Array.from(this.turnServices.agents.values());
+    }
+    async *chat(sessionId, input, userId) {
+        yield* this.stream({ input, sessionId, userId });
+    }
+    // --- Main orchestration ---
     async *stream(options) {
-        const { userId, abortSignal } = options;
-        const input = options.input;
-        if (typeof input !== 'string') {
-            throw new Error('Runtime.stream: "input" is required and must be a string.');
-        }
-        const effectiveSessionId = options.sessionId ?? crypto.randomUUID();
-        let session;
+        const svc = this.turnServices;
+        // Warn when memoryService is configured but userId is missing
+        if (svc.memoryService && !options.userId) {
+            const sessionId = options.sessionId ?? 'new';
+            if (!this._userIdWarned.has(sessionId)) {
+                this._userIdWarned.add(sessionId);
+                console.warn('[AriaFlow] memoryService is configured but session has no userId. ' +
+                    'Memory operations will be skipped. Pass userId via stream({ input, sessionId, userId }).');
+            }
+        }
+        // Acquire per-session mutex to prevent concurrent read-modify-write races.
+        // Only lock when a sessionId is provided (existing session). New sessions
+        // get a random UUID and cannot have concurrent callers.
+        let releaseMutex;
         if (options.sessionId) {
-            const existing = await this._sessionStore.get(options.sessionId);
-            session = existing ?? this.createSession(effectiveSessionId, userId);
+            releaseMutex = await this.sessionMutex.acquire(options.sessionId);
         }
-        else {
-            session = this.createSession(effectiveSessionId, userId);
-        }
-        if (this.alwaysRouteThroughTriage) {
-            // If a flow agent is currently active and has an initialized, non-ended flow state,
-            // keep routing to it so multi-turn flows can complete without triage interference.
-            const currentAgentId = session.activeAgentId ?? session.currentAgent;
-            const currentAgent = currentAgentId ? this.agents.get(currentAgentId) : undefined;
-            const hasActiveFlow = Boolean(currentAgent) &&
-                this.isFlowAgent(currentAgent) &&
-                Boolean(this.getFlowState(session, currentAgent.id)?.initialized) &&
-                !Boolean(this.getFlowState(session, currentAgent.id)?.flowEnded);
-            if (!hasActiveFlow) {
-                const triageId = this.triageAgentId ?? this.defaultAgentId;
-                const triageAgent = this.agents.get(triageId);
-                if (triageAgent && this.isTriageAgent(triageAgent)) {
-                    session.activeAgentId = triageId;
-                    session.currentAgent = triageId;
-                }
-            }
+        try {
+            yield* this._streamInner(options, svc);
         }
-        const activeAgentId = session.activeAgentId ?? session.currentAgent ?? this.defaultAgentId;
-        session.activeAgentId = activeAgentId;
-        session.currentAgent = activeAgentId;
-        this.turnCount++;
-        const context = {
-            session,
-            agentId: activeAgentId,
-            stepCount: 0,
-            totalTokens: 0,
-            handoffStack: [],
-            startTime: Date.now(),
-            consecutiveErrors: 0,
-            toolCallHistory: [],
-        };
-        this.bumpSessionTurn(session);
-        const injectionQueue = this.buildPolicyInjectionQueue();
-        // Yield input through emit so hooks see it (once).
-        yield* this.emit(context, { type: 'input', text: input, userId: session.userId || undefined });
-        const controller = new AbortController();
+        finally {
+            releaseMutex?.();
+        }
+    }
+    /**
+     * Inner stream implementation — separated so the mutex can wrap the
+     * entire async generator lifecycle from IntakeStage through PostStreamStage.
+     */
+    async *_streamInner(options, svc) {
+        // Stage 1: Intake
+        const intakeGen = runIntakeStage(options, svc);
+        let intakeNext = await intakeGen.next();
+        while (!intakeNext.done) {
+            yield intakeNext.value;
+            intakeNext = await intakeGen.next();
+        }
+        const intake = intakeNext.value;
+        if (!intake)
+            return;
+        const { session, context, processedInput, injectionQueue, controller } = intake;
         this.abortControllers.set(session.id, controller);
-        const abortHandler = () => {
-            this.abortControllers.delete(session.id);
-        };
-        controller.signal.addEventListener('abort', abortHandler);
-        let externalAbortHandler;
-        if (abortSignal) {
-            externalAbortHandler = () => {
-                controller.abort(abortSignal.reason ?? 'External abort');
-            };
-            if (abortSignal.aborted) {
-                controller.abort(abortSignal.reason ?? 'External abort');
-            }
-            else {
-                abortSignal.addEventListener('abort', externalAbortHandler);
-            }
-        }
-        await this.hookRunner.onStart(context);
-        // Run input processors BEFORE persisting the user message.
-        let processedInput = input;
+        const cleanup = this.setupAbortHandlers(session.id, controller, options.abortSignal);
         try {
-            const turnInputProcessors = [...this.inputProcessors];
-            if (turnInputProcessors.length > 0) {
-                const candidateMessages = [
-                    ...session.messages,
-                    { role: 'user', content: processedInput },
-                ];
-                const procCtx = {
-                    session,
-                    agentId: activeAgentId,
-                    toolCallHistory: context.toolCallHistory,
-                    abortSignal: controller.signal,
-                };
-                const outcome = await runInputProcessors({
-                    processors: turnInputProcessors,
-                    input: processedInput,
-                    messages: candidateMessages,
-                    context: procCtx,
-                });
-                if (outcome.blocked) {
-                    yield* this.emit(context, {
-                        type: 'tripwire',
-                        phase: 'input',
-                        processorId: outcome.processorId,
-                        reason: outcome.reason,
-                        message: outcome.message,
-                    });
-                    yield* this.emit(context, { type: 'text-delta', text: outcome.message });
-                    yield* this.emit(context, { type: 'turn-end' });
-                    await this.hookRunner.onEnd(context, { success: true });
-                    return;
-                }
-                processedInput = outcome.input;
-            }
-            // Persist the (possibly modified) user message after input processors.
-            this.appendSessionMessage(session, { role: 'user', content: processedInput });
-            if (this.contextManager) {
-                const messagesBefore = session.messages.length;
-                const totalTokens = session.messages.reduce((sum, m) => {
-                    const text = typeof m.content === 'string' ? m.content : '';
-                    return sum + Math.ceil(text.length / 4);
-                }, 0);
-                const compacted = await this.contextManager.beforeTurn(session.messages, {
-                    turnCount: this.turnCount,
-                    totalTokens,
-                    sessionId: session.id,
-                });
-                session.messages = this.normalizeSessionHistory(compacted);
-                const messagesAfter = session.messages.length;
-                if (messagesBefore !== messagesAfter) {
-                    yield* this.emit(context, {
-                        type: 'context-compacted',
-                        messagesBefore,
-                        messagesAfter,
-                    });
-                }
+            // Stages 2-4: Agent execute (includes gather, assemble, handoff loop)
+            yield* runAgentExecuteStage({
+                context,
+                input: processedInput,
+                injectionQueue,
+                abortController: controller,
+            }, svc);
+            if (svc.config.suggestionModel) {
+                yield* svc.suggestionManager.generateSuggestions(context);
             }
-            yield* this.runLoop(context, injectionQueue, processedInput, controller);
-            if (this.config.suggestionModel) {
-                yield* this.generateSuggestions(context);
+            if (session.metadata) {
+                session.metadata.lastTurnHadToolCalls = context.toolCallHistory.length > 0;
             }
-            await this.hookRunner.onEnd(context, { success: true });
+            await svc.hookRunner.onEnd(context, { success: true });
         }
         catch (error) {
             if (controller.signal.aborted) {
-                yield* this.emit(context, {
+                yield* svc.streamEmitter.emit(context, {
                     type: 'interrupted',
                     sessionId: context.session.id,
                     reason: controller.signal.reason ?? 'Operation cancelled',
@@ -330,1167 +318,45 @@ export class Runtime {
                     lastAgentId: context.agentId,
                     lastStep: context.stepCount,
                 });
-                await this.hookRunner.onEnd(context, { success: false });
+                await svc.hookRunner.onEnd(context, { success: false });
             }
             else {
-                await this.hookRunner.onError(context, error);
-                await this.hookRunner.onEnd(context, { success: false, error: error });
-                yield* this.emit(context, { type: 'error', error: error.message });
+                await svc.hookRunner.onError(context, error);
+                await svc.hookRunner.onEnd(context, { success: false, error: error });
+                yield* svc.streamEmitter.emit(context, { type: 'error', error: error.message });
             }
         }
         finally {
-            controller.signal.removeEventListener('abort', abortHandler);
-            if (abortSignal && externalAbortHandler) {
-                abortSignal.removeEventListener('abort', externalAbortHandler);
-            }
+            cleanup();
             this.abortControllers.delete(session.id);
-            await this.saveSessionCheckpoint(session);
-            yield* this.emit(context, { type: 'done', sessionId: session.id });
-            await this.saveSessionCheckpoint(session);
-        }
-    }
-    async *generateSuggestions(context) {
-        yield* this.suggestionManager.generateSuggestions(context);
-    }
-    async *chat(sessionId, input, userId) {
-        yield* this.stream({ input, sessionId, userId });
-    }
-    async *runLoop(context, injectionQueue, input, abortController) {
-        let currentInput = input;
-        const abortSignal = abortController?.signal;
-        let interruptionEmitted = false;
-        let circularRecoveryActive = false;
-        let circularRecoveryAttempts = 0;
-        while (context.handoffStack.length < this.maxHandoffs) {
-            if (abortSignal?.aborted) {
-                if (!interruptionEmitted) {
-                    interruptionEmitted = true;
-                    yield* this.emit(context, {
-                        type: 'interrupted',
-                        sessionId: context.session.id,
-                        reason: abortSignal.reason ?? 'Operation cancelled',
-                        timestamp: new Date(),
-                        lastAgentId: context.agentId,
-                        lastStep: context.stepCount,
-                    });
-                }
-                return;
-            }
-            // Allow a single "bounce back" (A -> B -> A) for detours and multi-intent turns.
-            // Stop only when an agent would be visited a third time in the same user turn.
-            const priorVisits = context.handoffStack.filter(id => id === context.agentId).length;
-            if (priorVisits >= 2 && !circularRecoveryActive) {
-                const err = `Circular handoff detected: ${context.handoffStack.join(' -> ')} -> ${context.agentId}`;
-                yield* this.emit(context, { type: 'error', error: err });
-                circularRecoveryAttempts += 1;
-                if (circularRecoveryAttempts > 1) {
-                    yield* this.emitCircularHandoffFallback(context);
-                    return;
-                }
-                circularRecoveryActive = true;
-                // Reset path tracking for this turn and force a single in-agent recovery pass.
-                context.handoffStack = [];
-            }
-            context.handoffStack.push(context.agentId);
-            const agent = this.agents.get(context.agentId);
-            if (!agent) {
-                yield* this.emit(context, { type: 'error', error: `Agent "${context.agentId}" not found` });
-                return;
-            }
-            // Agent-specific input processors. These run after the user message is in history and
-            // before the agent gets a chance to call the model/tools.
-            if (agent.inputProcessors && agent.inputProcessors.length > 0) {
-                const procCtx = {
-                    session: context.session,
-                    agentId: agent.id,
-                    toolCallHistory: context.toolCallHistory,
-                    abortSignal,
-                };
-                const outcome = await runInputProcessors({
-                    processors: agent.inputProcessors,
-                    input: currentInput,
-                    messages: context.session.messages,
-                    context: procCtx,
-                });
-                if (outcome.blocked) {
-                    yield* this.emit(context, {
-                        type: 'tripwire',
-                        phase: 'input',
-                        processorId: outcome.processorId,
-                        reason: outcome.reason,
-                        message: outcome.message,
-                    });
-                    yield* this.emit(context, { type: 'text-delta', text: outcome.message });
-                    yield* this.emit(context, { type: 'turn-end' });
-                    return;
-                }
-                if (outcome.input !== currentInput) {
-                    currentInput = outcome.input;
-                    const last = context.session.messages[context.session.messages.length - 1];
-                    if (last && last.role === 'user' && typeof last.content === 'string') {
-                        last.content = currentInput;
-                        this.touchSession(context.session);
-                    }
-                }
-            }
-            yield* this.emit(context, { type: 'agent-start', agentId: agent.id });
-            await this.hookRunner.onAgentStart(context, agent.id);
-            let autoContext;
-            if (agent.autoRetrieve) {
-                const toolName = agent.autoRetrieve.toolName ?? 'auto_retrieve';
-                const toolCallId = crypto.randomUUID();
-                const idempotencyKey = this.buildToolIdempotencyKey(context, toolName, toolCallId);
-                const callRecord = {
-                    toolCallId,
-                    toolName,
-                    args: { input: currentInput },
-                    idempotencyKey,
-                    success: true,
-                    timestamp: Date.now(),
-                };
-                await this.hookRunner.onToolCall(context, callRecord);
-                yield* this.emit(context, {
-                    type: 'tool-start',
-                    toolCallId,
-                    toolName,
-                    message: agent.autoRetrieve.message ?? 'Retrieving context...',
-                });
-                yield* this.emit(context, {
-                    type: 'tool-call',
-                    toolCallId,
-                    toolName,
-                    args: callRecord.args,
-                });
-                let result = null;
-                try {
-                    result = await agent.autoRetrieve.run({ input: currentInput, context, abortSignal });
-                    callRecord.result = result;
-                }
-                catch (error) {
-                    callRecord.success = false;
-                    callRecord.error = error;
-                    await this.hookRunner.onToolError(context, callRecord, callRecord.error);
-                    yield* this.emit(context, {
-                        type: 'tool-error',
-                        toolCallId,
-                        toolName,
-                        error: callRecord.error.message,
-                    });
-                }
-                finally {
-                    callRecord.durationMs = Date.now() - callRecord.timestamp;
-                }
-                if (callRecord.result) {
-                    await this.hookRunner.onToolResult(context, callRecord);
-                    yield* this.emit(context, {
-                        type: 'tool-result',
-                        toolCallId,
-                        toolName,
-                        result: callRecord.result,
-                    });
-                }
-                yield* this.emit(context, {
-                    type: 'tool-done',
-                    toolCallId,
-                    toolName,
-                    durationMs: callRecord.durationMs ?? 0,
-                });
-                if (result?.text?.trim()) {
-                    autoContext = {
-                        label: agent.autoRetrieve.label ?? 'Relevant Context',
-                        text: result.text,
-                    };
-                }
-            }
-            const extractionSnapshot = await this.runTurnExtraction(agent, context, currentInput, abortSignal);
-            let activeRoutes;
-            if (this.isTriageAgent(agent)) {
-                const agentContext = this.buildAgentContext(currentInput, context, abortSignal);
-                const results = await Promise.all(agent.routes.map(async (route) => {
-                    if (!route.condition)
-                        return { route, active: true };
-                    try {
-                        const active = await route.condition(currentInput, agentContext);
-                        return { route, active };
-                    }
-                    catch (error) {
-                        console.error(`Error evaluating condition for route ${route.agentId}:`, error);
-                        return { route, active: false }; // Fail-closed on error
-                    }
-                }));
-                activeRoutes = results.filter(r => r.active).map(r => r.route);
-            }
-            let system = this.buildSystemPrompt(agent, injectionQueue, autoContext, context, activeRoutes);
-            const turnToolErrors = [];
-            if (extractionSnapshot?.includeInSystemPrompt) {
-                system += this.extractionEngine.buildExtractionSystemBlock(extractionSnapshot);
-            }
-            if (circularRecoveryActive) {
-                system = `${system}\n\n## Routing Recovery
-A circular handoff was detected in this turn.
-Stay with the current agent and provide the best direct answer.
-Do not call or suggest handoff/transfer tools in this response.`;
-            }
-            const handoffCandidates = circularRecoveryActive ? [] : this.getHandoffCandidates(agent, activeRoutes);
-            const handoffTool = handoffCandidates.length > 0
-                ? createHandoffTool(handoffCandidates, context.agentId)
-                : null;
-            let handoffTo = null;
-            let handoffReason = 'No reason provided';
-            if (this.isFlowAgent(agent)) {
-                const stopResult = checkStopConditions(context, this.stopConditions);
-                if (stopResult.shouldStop) {
-                    yield* this.emit(context, { type: 'error', error: `Stopped: ${stopResult.reason}` });
-                    return;
-                }
-                const agentMaxSteps = agent.maxSteps ?? agent.maxTurns ?? this.maxSteps;
-                if (agentMaxSteps <= 0) {
-                    yield* this.emit(context, { type: 'error', error: `Max steps exceeded for agent "${agent.id}"` });
-                    return;
-                }
-                context.stepCount += 1;
-                yield* this.emit(context, { type: 'step-start', step: context.stepCount, agentId: agent.id });
-                await this.hookRunner.onStepStart(context, context.stepCount);
-                const toolCalls = [];
-                try {
-                    for await (const part of this.runFlowAgent(agent, context, currentInput, system, handoffTool ?? undefined, (target, reason) => {
-                        handoffTo = target;
-                        handoffReason = reason ?? 'No reason provided';
-                    }, toolCalls, abortSignal)) {
-                        yield part;
-                    }
-                    context.consecutiveErrors = 0;
-                    if (context.session.metadata) {
-                        context.session.metadata.totalSteps += 1;
-                    }
-                    yield* this.emit(context, { type: 'step-end', step: context.stepCount, agentId: agent.id });
-                    await this.hookRunner.onStepEnd(context, context.stepCount, {
-                        toolCalls,
-                        finishReason: 'flow',
-                        tokensUsed: 0,
-                        handoffTo: handoffTo ?? undefined,
-                    });
-                }
-                catch (error) {
-                    if (abortSignal?.aborted) {
-                        if (!interruptionEmitted) {
-                            interruptionEmitted = true;
-                            yield* this.emit(context, {
-                                type: 'interrupted',
-                                sessionId: context.session.id,
-                                reason: abortSignal.reason ?? 'Operation cancelled',
-                                timestamp: new Date(),
-                                lastAgentId: context.agentId,
-                                lastStep: context.stepCount,
-                            });
-                        }
-                        return;
-                    }
-                    context.consecutiveErrors += 1;
-                    await this.hookRunner.onError(context, error);
-                    yield* this.emit(context, { type: 'error', error: error.message });
-                    if (context.consecutiveErrors >= 3) {
-                        return;
-                    }
-                }
-            }
-            else {
-                const tools = this.wrapToolsWithEnforcement(context, handoffTool ? { ...agent.tools, handoff: handoffTool } : { ...agent.tools });
-                let agentSteps = 0;
-                const agentMaxSteps = agent.maxSteps ?? agent.maxTurns ?? this.maxSteps;
-                while (agentSteps < agentMaxSteps) {
-                    const stopResult = checkStopConditions(context, this.stopConditions);
-                    if (stopResult.shouldStop) {
-                        yield* this.emit(context, { type: 'error', error: `Stopped: ${stopResult.reason}` });
-                        return;
-                    }
-                    agentSteps += 1;
-                    context.stepCount += 1;
-                    yield* this.emit(context, { type: 'step-start', step: context.stepCount, agentId: agent.id });
-                    await this.hookRunner.onStepStart(context, context.stepCount);
-                    try {
-                        const model = agent.model ?? this.defaultModel;
-                        if (!model) {
-                            throw new Error(`Agent "${agent.id}" is missing a model`);
-                        }
-                        if (this.isTriageAgent(agent) && agent.triageMode === 'structured') {
-                            const schema = z.object({
-                                agentId: z.string().describe('Target agent ID for this request.'),
-                                reason: z.string().describe('Short, concrete reason grounded in the user request.'),
-                                confidence: z.number().min(0).max(1).describe('Routing confidence from 0 to 1.'),
-                                stayWithCurrent: z.boolean().describe('True only if the current agent is best fit.'),
-                            });
-                            try {
-                                // AI SDK v6+ recommended structured output approach.
-                                const { output: decision } = await generateText({
-                                    model: model,
-                                    output: Output.object({ schema }),
-                                    system: this.buildStructuredTriagePrompt(agent, activeRoutes),
-                                    messages: context.session.messages,
-                                    abortSignal,
-                                    experimental_telemetry: agent.telemetry ?? this.config.telemetry,
-                                });
-                                const allowed = new Set(agent.routes.map(route => route.agentId));
-                                let target = decision.agentId;
-                                if (!allowed.has(target)) {
-                                    target = agent.defaultAgent ?? agent.routes[0]?.agentId ?? agent.id;
-                                }
-                                handoffTo = target;
-                                handoffReason = decision.reason ?? 'Routed by triage';
-                            }
-                            catch (err) {
-                                throw err;
-                            }
-                            yield* this.emit(context, { type: 'step-end', step: context.stepCount, agentId: agent.id });
-                            await this.hookRunner.onStepEnd(context, context.stepCount, {
-                                toolCalls: [],
-                                finishReason: 'handoff',
-                                tokensUsed: 0,
-                                handoffTo,
-                            });
-                            break;
-                        }
-                        const result = streamText({
-                            model: model,
-                            system,
-                            messages: context.session.messages,
-                            tools,
-                            abortSignal,
-                            // Let the AI SDK handle tool-calling steps internally.
-                            // Default is stepCountIs(1), which ends right after tool-calls.
-                            stopWhen: stepCountIs(agent.toolMaxSteps ?? 5),
-                            // Tool execution can read this via options.experimental_context.
-                            experimental_context: {
-                                session: context.session,
-                                agentId: agent.id,
-                            },
-                            experimental_telemetry: agent.telemetry ?? this.config.telemetry,
-                        });
-                        const toolCalls = [];
-                        let finalResult = null;
-                        let finalEmitted = false;
-                        const outputProcessors = this.getAgentOutputProcessors(agent);
-                        const bufferOutput = this.outputProcessorMode === 'buffer' && outputProcessors.length > 0;
-                        let bufferedText = '';
-                        let stoppedByGuard = false;
-                        for await (const chunk of result.fullStream) {
-                            if (chunk.type === 'text-delta') {
-                                if (finalResult) {
-                                    continue;
-                                }
-                                // Fail-closed: Suppress text delta if critical tool errors have occurred in this turn.
-                                if (turnToolErrors.length > 0) {
-                                    continue;
-                                }
-                                if (bufferOutput) {
-                                    bufferedText += chunk.text;
-                                }
-                                else {
-                                    yield* this.emit(context, { type: 'text-delta', text: chunk.text });
-                                }
-                            }
-                            if (chunk.type === 'tool-call') {
-                                const args = getChunkArgs(chunk);
-                                const callRecord = {
-                                    toolCallId: chunk.toolCallId,
-                                    toolName: chunk.toolName,
-                                    args,
-                                    idempotencyKey: this.buildToolIdempotencyKey(context, chunk.toolName, chunk.toolCallId),
-                                    success: true,
-                                    timestamp: Date.now(),
-                                };
-                                toolCalls.push(callRecord);
-                                await this.hookRunner.onToolCall(context, callRecord);
-                                // Emit tool-start with optional filler from tool config
-                                const toolConfig = this.agents.get(context.agentId)?.tools;
-                                const toolDef = toolConfig?.[chunk.toolName];
-                                const filler = toolDef?.filler ?? `Let me check ${chunk.toolName}...`;
-                                yield* this.emit(context, {
-                                    type: 'tool-start',
-                                    toolCallId: chunk.toolCallId,
-                                    toolName: chunk.toolName,
-                                    message: filler,
-                                });
-                                yield* this.emit(context, {
-                                    type: 'tool-call',
-                                    toolCallId: chunk.toolCallId,
-                                    toolName: chunk.toolName,
-                                    args,
-                                });
-                            }
-                            if (chunk.type === 'tool-error') {
-                                const errText = getChunkErrorMessage(chunk);
-                                const args = getChunkArgs(chunk);
-                                const toolCallId = getChunkToolCallId(chunk);
-                                const callRecord = toolCalls.find(call => call.toolCallId === toolCallId);
-                                if (callRecord) {
-                                    callRecord.success = false;
-                                    callRecord.error = new Error(errText);
-                                    if (args !== undefined)
-                                        callRecord.args = args;
-                                    context.toolCallHistory.push(callRecord);
-                                    await this.hookRunner.onToolError(context, callRecord, callRecord.error);
-                                    // Fail-closed: Track critical tool errors to block turn finalization.
-                                    const toolPolicy = agent.toolPolicies?.[callRecord.toolName];
-                                    const toolDef = agent.tools?.[callRecord.toolName];
-                                    const isCritical = toolPolicy?.critical ?? toolDef?.critical ?? true;
-                                    if (isCritical) {
-                                        turnToolErrors.push(callRecord);
-                                    }
-                                }
-                                yield* this.emit(context, {
-                                    type: 'tool-error',
-                                    toolCallId: toolCallId ?? chunk.toolCallId,
-                                    toolName: chunk.toolName,
-                                    error: errText,
-                                });
-                            }
-                            if (chunk.type === 'tool-result') {
-                                const startTime = toolCalls.find(call => call.toolCallId === chunk.toolCallId)?.timestamp ?? Date.now();
-                                const toolResult = getChunkResult(chunk);
-                                const callRecord = toolCalls.find(call => call.toolCallId === chunk.toolCallId);
-                                if (callRecord) {
-                                    callRecord.result = toolResult;
-                                    callRecord.durationMs = Date.now() - callRecord.timestamp;
-                                    context.toolCallHistory.push(callRecord);
-                                    await this.hookRunner.onToolResult(context, callRecord);
-                                }
-                                // Emit tool-done with duration
-                                const durationMs = Date.now() - startTime;
-                                yield* this.emit(context, {
-                                    type: 'tool-done',
-                                    toolCallId: chunk.toolCallId,
-                                    toolName: chunk.toolName,
-                                    durationMs,
-                                });
-                                if (callRecord) {
-                                    const enforcement = await this.enforcer.checkResult(callRecord, {
-                                        previousCalls: context.toolCallHistory,
-                                        currentStep: context.stepCount,
-                                        sessionState: context.session.state ?? {},
-                                    });
-                                    if (!enforcement.allowed) {
-                                        const reason = enforcement.reason ?? 'Tool result blocked by enforcement';
-                                        callRecord.success = false;
-                                        callRecord.error = new Error(reason);
-                                        await this.hookRunner.onToolError(context, callRecord, callRecord.error);
-                                        // Fail-closed: Track enforcement failures as critical errors.
-                                        turnToolErrors.push(callRecord);
-                                        yield* this.emit(context, {
-                                            type: 'tool-error',
-                                            toolCallId: chunk.toolCallId,
-                                            toolName: chunk.toolName,
-                                            error: reason,
-                                        });
-                                        finalResult = { type: 'final', text: reason };
-                                        if (!finalEmitted) {
-                                            finalEmitted = true;
-                                            if (bufferOutput) {
-                                                bufferedText += reason;
-                                            }
-                                            else {
-                                                yield* this.emit(context, { type: 'text-delta', text: reason });
-                                            }
-                                        }
-                                        continue;
-                                    }
-                                }
-                                yield* this.emit(context, {
-                                    type: 'tool-result',
-                                    toolCallId: chunk.toolCallId,
-                                    toolName: chunk.toolName,
-                                    result: toolResult,
-                                });
-                                // Stop as soon as a stop condition triggers, even mid-stream.
-                                const stopResult = checkStopConditions(context, this.stopConditions);
-                                if (stopResult.shouldStop) {
-                                    yield* this.emit(context, { type: 'error', error: `Stopped: ${stopResult.reason}` });
-                                    stoppedByGuard = true;
-                                    break;
-                                }
-                                if (isFinalResult(toolResult)) {
-                                    finalResult = toolResult;
-                                    if (!finalEmitted) {
-                                        finalEmitted = true;
-                                        if (bufferOutput) {
-                                            bufferedText += toolResult.text;
-                                        }
-                                        else {
-                                            yield* this.emit(context, { type: 'text-delta', text: toolResult.text });
-                                        }
-                                    }
-                                    continue;
-                                }
-                                if (isHandoffResult(toolResult)) {
-                                    const targetAgent = toolResult.targetAgent ?? toolResult.targetAgentId;
-                                    handoffTo = targetAgent;
-                                    handoffReason = toolResult.reason ?? 'No reason provided';
-                                }
-                            }
-                        }
-                        if (stoppedByGuard) {
-                            return;
-                        }
-                        const response = await result.response;
-                        const finishReason = finalResult ? 'final' : await result.finishReason;
-                        // Only finalize buffered output when the model has completed a non-tool finish.
-                        // If the model ended on tool-calls, we must persist the tool messages and
-                        // continue the loop (or let AI SDK continue in maxSteps) instead of emitting
-                        // synthetic assistant text, which can duplicate responses.
-                        if (finalResult || (bufferOutput && finishReason !== 'tool-calls') || turnToolErrors.length > 0) {
-                            let rawText = finalResult ? finalResult.text : bufferedText;
-                            // Fail-closed: Suppress success message if critical tool failed.
-                            if (turnToolErrors.length > 0) {
-                                const failedTools = turnToolErrors.map(e => `\`${e.toolName}\``).join(', ');
-                                rawText = `I encountered an error while using the following tools: ${failedTools}. I cannot proceed with the requested action at this time.`;
-                                yield* this.emit(context, {
-                                    type: 'error',
-                                    error: `Turn blocked by critical tool failures: ${failedTools}`,
-                                });
-                            }
-                            const processed = await this.runOutputProcessing(agent, context, rawText);
-                            if (processed.tripwire) {
-                                yield* this.emit(context, {
-                                    type: 'tripwire',
-                                    phase: 'output',
-                                    processorId: processed.tripwire.processorId,
-                                    reason: processed.tripwire.reason,
-                                    message: processed.tripwire.message,
-                                });
-                            }
-                            if (bufferOutput || turnToolErrors.length > 0) {
-                                yield* this.emit(context, { type: 'text-delta', text: processed.text });
-                            }
-                            this.appendSessionMessage(context.session, { role: 'assistant', content: processed.text });
-                        }
-                        else {
-                            const beforeLen = context.session.messages.length;
-                            this.appendSessionMessages(context.session, response.messages);
-                            const tripwires = await this.postProcessPersistedAssistantMessages(agent, context, beforeLen);
-                            for (const t of tripwires) {
-                                yield* this.emit(context, {
-                                    type: 'tripwire',
-                                    phase: 'output',
-                                    processorId: t.processorId,
-                                    reason: t.reason,
-                                    message: t.message,
-                                });
-                            }
-                        }
-                        const usage = await result.usage;
-                        const totalTokens = usage.totalTokens ?? 0;
-                        context.totalTokens += totalTokens;
-                        if (context.session.metadata) {
-                            context.session.metadata.totalTokens += totalTokens;
-                            context.session.metadata.totalSteps += 1;
-                        }
-                        context.consecutiveErrors = 0;
-                        yield* this.emit(context, { type: 'step-end', step: context.stepCount, agentId: agent.id });
-                        await this.hookRunner.onStepEnd(context, context.stepCount, {
-                            toolCalls,
-                            finishReason,
-                            tokensUsed: totalTokens,
-                            handoffTo: handoffTo ?? undefined,
-                        });
-                        if (finalResult || finishReason !== 'tool-calls' || handoffTo) {
-                            break;
-                        }
-                    }
-                    catch (error) {
-                        console.error('RUNTIME_LOOP_ERROR:', error);
-                        if (abortSignal?.aborted) {
-                            if (!interruptionEmitted) {
-                                interruptionEmitted = true;
-                                yield* this.emit(context, {
-                                    type: 'interrupted',
-                                    sessionId: context.session.id,
-                                    reason: abortSignal.reason ?? 'Operation cancelled',
-                                    timestamp: new Date(),
-                                    lastAgentId: context.agentId,
-                                    lastStep: context.stepCount,
-                                });
-                            }
-                            return;
-                        }
-                        context.consecutiveErrors += 1;
-                        await this.hookRunner.onError(context, error);
-                        yield* this.emit(context, { type: 'error', error: error.message });
-                        if (context.consecutiveErrors >= 3) {
-                            return;
-                        }
-                    }
-                }
-            }
-            yield* this.emit(context, { type: 'agent-end', agentId: agent.id });
-            await this.hookRunner.onAgentEnd(context, agent.id);
-            if (circularRecoveryActive && handoffTo) {
-                yield* this.emit(context, {
-                    type: 'error',
-                    error: `Circular handoff recovery failed: attempted handoff ${context.agentId} -> ${handoffTo}`,
-                });
-                yield* this.emitCircularHandoffFallback(context);
-                return;
-            }
-            if (circularRecoveryActive) {
-                circularRecoveryActive = false;
-            }
-            if (!handoffTo) {
-                break;
-            }
-            await this.hookRunner.onHandoff(context, context.agentId, handoffTo, handoffReason);
-            yield* this.emit(context, {
-                type: 'handoff',
-                from: context.agentId,
-                to: handoffTo,
-                reason: handoffReason,
-            });
-            context.session.handoffHistory.push({
-                from: context.agentId,
-                to: handoffTo,
-                reason: handoffReason,
-                timestamp: new Date(),
-            });
-            if (context.session.metadata) {
-                context.session.metadata.handoffHistory.push({
-                    from: context.agentId,
-                    to: handoffTo,
-                    reason: handoffReason,
-                    timestamp: new Date(),
-                });
-            }
-            context.session.activeAgentId = handoffTo;
-            context.session.currentAgent = handoffTo;
-            await this.saveSessionCheckpoint(context.session);
-            context.agentId = handoffTo;
-        }
-        if (context.handoffStack.length >= this.maxHandoffs) {
-            yield* this.emit(context, { type: 'error', error: `Maximum handoffs (${this.maxHandoffs}) exceeded` });
-        }
-    }
-    getCircularHandoffFallbackMessage() {
-        const configured = this.config.circularHandoffFallbackMessage?.trim();
-        if (configured) {
-            return configured;
+            yield* runPostStreamStage(context, session, svc);
         }
-        return 'I hit a routing issue between agents. I will continue here. Tell me the exact outcome you need in one sentence.';
     }
-    async *emitCircularHandoffFallback(context) {
-        const fallback = this.getCircularHandoffFallbackMessage();
-        this.appendSessionMessage(context.session, { role: 'assistant', content: fallback });
-        yield* this.emit(context, { type: 'text-delta', text: fallback });
-    }
-    buildPolicyInjectionQueue() {
-        const queue = new InjectionQueue();
-        const profile = this.config.policyProfile ?? 'minimal';
-        queue.addBatch(getPolicyProfileInjections(profile));
-        if (this.config.policyInjections && this.config.policyInjections.length > 0) {
-            queue.addBatch(this.config.policyInjections);
-        }
-        return queue;
-    }
-    createSession(id, userId) {
-        const now = new Date();
-        return {
-            id: id ?? crypto.randomUUID(),
-            userId,
-            messages: [],
-            createdAt: now,
-            updatedAt: now,
-            workingMemory: {},
-            currentAgent: this.defaultAgentId,
-            activeAgentId: this.defaultAgentId,
-            state: {},
-            metadata: {
-                createdAt: now,
-                lastActiveAt: now,
-                totalTokens: 0,
-                totalSteps: 0,
-                handoffHistory: [],
-            },
-            agentStates: {},
-            handoffHistory: [],
-        };
-    }
-    isFlowAgent(agent) {
-        return agent.type === 'flow';
-    }
-    isTriageAgent(agent) {
-        return agent.type === 'triage';
-    }
-    buildPromptMemoryView(session, agent) {
-        const memory = session.workingMemory ?? {};
-        const allowlist = agent.promptMemoryAllowlist ?? this.config.promptMemoryAllowlist;
-        const internalKeys = [
-            this.runtimeEventLogKey,
-            this.runtimeSessionTurnKey,
-            this.redactCarryKey,
-        ];
-        const filtered = {};
-        for (const [key, value] of Object.entries(memory)) {
-            if (internalKeys.includes(key)) {
-                continue;
-            }
-            if (allowlist && !allowlist.includes(key)) {
-                continue;
-            }
-            filtered[key] = value;
-        }
-        return filtered;
-    }
-    buildSystemPrompt(agent, injectionQueue, autoContext, context, activeRoutes) {
-        const basePrompt = this.isTriageAgent(agent)
-            ? this.buildTriagePrompt(agent, activeRoutes)
-            : agent.systemPrompt;
-        const autoBlock = autoContext?.text?.trim()
-            ? `\n\n## ${autoContext.label}\n${autoContext.text}`
-            : '';
-        const systemInjections = injectionQueue.getFor('system');
-        const memory = context?.session ? this.buildPromptMemoryView(context.session, agent) : {};
-        const memoryBlock = Object.keys(memory).length > 0
-            ? `\n\n## Known Information\n${JSON.stringify(memory, null, 2)}`
-            : '';
-        const merged = `${basePrompt}${autoBlock}${memoryBlock}`;
-        return systemInjections ? `${merged}\n\n${systemInjections}` : merged;
-    }
-    buildStructuredTriagePrompt(agent, activeRoutes) {
-        const routes = activeRoutes ?? agent.routes;
-        const routeDescriptions = routes
-            .map(route => `- ${route.agentId}: ${route.description}`)
-            .join('\n');
-        const allowed = routes.map(route => route.agentId);
-        const defaultNote = agent.defaultAgent ? `Default: ${agent.defaultAgent}` : 'Default: none';
-        return `${agent.systemPrompt}
-
-## Available Specialists
-${routeDescriptions}
-
-## Output (JSON)
-Return a JSON object with:
-- agentId: one of [${allowed.join(', ')}]
-- reason: short, concrete reason grounded in the user request
-- confidence: number 0-1 (0 = weak match, 1 = perfect match)
-- stayWithCurrent: boolean (true only if current agent is best fit)
-${defaultNote}`;
-    }
-    buildTriagePrompt(agent, activeRoutes) {
-        const routes = activeRoutes ?? agent.routes;
-        const routeDescriptions = routes
-            .map(route => `- **${route.agentId}**: ${route.description}`)
-            .join('\n');
-        const defaultNote = agent.defaultAgent
-            ? `\n- Use "${agent.defaultAgent}" when no specialist applies.`
-            : '';
-        return `${agent.systemPrompt}
-
-## Available Specialists
-${routeDescriptions}
-
-## Instructions
-- For general questions, answer directly
-- When the customer needs specialized help, use the handoff tool
-- Always provide a brief reason for the handoff${defaultNote}`;
-    }
-    getHandoffCandidates(agent, activeRoutes) {
-        if (this.isTriageAgent(agent)) {
-            const routes = activeRoutes ?? agent.routes;
-            return routes
-                .map(route => this.agents.get(route.agentId))
-                .filter((candidate) => Boolean(candidate));
-        }
-        // Production default: only triage routes by default. Other agents can handoff only if explicitly configured.
-        const targets = agent.canHandoffTo;
-        if (!targets || targets.length === 0) {
-            return [];
-        }
-        return targets
-            .map(id => this.agents.get(id))
-            .filter((candidate) => Boolean(candidate));
-    }
-    getFlowState(session, agentId) {
-        const stored = session.agentStates?.[agentId]?.state;
-        if (!stored) {
-            return undefined;
-        }
-        return stored;
-    }
-    buildAgentContext(input, context, abortSignal) {
-        return {
-            session: context.session,
-            messages: context.session.messages,
-            workingMemory: new SessionWorkingMemory(context.session),
-            currentAgent: context.agentId,
-            turnCount: this.turnCount,
-            metadata: context.session.metadata,
-            abortSignal,
-        };
-    }
-    setFlowState(session, agentId, state) {
-        session.agentStates[agentId] = {
-            agentId,
-            state: state,
-            lastActive: new Date(),
-        };
-        this.updateFlowStateSnapshot(session, agentId, state);
-        this.touchSession(session);
-    }
-    clearFlowState(session, agentId) {
-        delete session.agentStates[agentId];
-        this.touchSession(session);
-    }
-    updateFlowStateSnapshot(session, agentId, state) {
-        const existing = session.workingMemory.flowStateByAgent;
-        const byAgent = typeof existing === 'object' && existing !== null
-            ? { ...existing }
-            : {};
-        byAgent[agentId] = {
-            currentNode: state.context.currentNode,
-            collectedData: state.context.collectedData,
-            nodeHistory: state.context.nodeHistory,
-            initialized: state.initialized,
-            flowEnded: state.flowEnded,
-            updatedAt: new Date().toISOString(),
-        };
-        session.workingMemory.flowStateByAgent = byAgent;
-        this.touchSession(session);
-    }
-    buildFlowWithHandoff(agent, handoffTool, suppressAutoRespond) {
-        // If we don't need to inject a handoff tool and we don't need to suppress the initial autoRespond,
-        // we can return the flow as-is. Otherwise we must clone nodes to apply changes.
-        const needsInitialSuppression = suppressAutoRespond &&
-            agent.flow.nodes.some(n => n.id === agent.initialNode && n.autoRespond === undefined);
-        if (!handoffTool && !needsInitialSuppression)
-            return agent.flow;
-        return {
-            ...agent.flow,
-            nodes: agent.flow.nodes.map(node => {
-                const shouldSuppress = suppressAutoRespond
-                    && node.id === agent.initialNode
-                    && node.autoRespond === undefined;
-                const existingTools = node.tools;
-                // Support tool factories (tools: (ctx) => ToolSet) as well as static ToolSets.
-                if (typeof existingTools === 'function') {
-                    return {
-                        ...node,
-                        tools: (ctx) => {
-                            const resolved = existingTools(ctx) ?? {};
-                            if (!handoffTool)
-                                return resolved;
-                            return resolved.handoff ? resolved : { ...resolved, handoff: handoffTool };
-                        },
-                        ...(shouldSuppress ? { autoRespond: false } : {}),
-                    };
-                }
-                const toolSet = existingTools ?? {};
-                if (!handoffTool || toolSet.handoff) {
-                    return shouldSuppress ? { ...node, autoRespond: false } : node;
-                }
-                return {
-                    ...node,
-                    tools: {
-                        ...toolSet,
-                        handoff: handoffTool,
-                    },
-                    ...(shouldSuppress ? { autoRespond: false } : {}),
-                };
-            }),
-        };
-    }
-    getFlowNode(agent, nodeId) {
-        if (!nodeId) {
-            return undefined;
-        }
-        return agent.flow.nodes.find(node => node.id === nodeId);
-    }
-    getExtractionConfig(agent, session) {
-        if (this.isFlowAgent(agent)) {
-            const flowState = this.getFlowState(session, agent.id);
-            const nodeId = flowState?.context.currentNode ?? agent.initialNode;
-            const node = this.getFlowNode(agent, nodeId);
-            const config = node?.extraction ?? agent.extraction;
-            if (!config) {
-                return null;
-            }
-            return { config, nodeId };
-        }
-        if (!agent.extraction) {
-            return null;
-        }
-        return { config: agent.extraction };
-    }
-    async runTurnExtraction(agent, context, input, abortSignal) {
-        return this.extractionEngine.runTurnExtraction(agent, context, input, {
-            getFlowState: (s, id) => this.getFlowState(s, id),
-            setFlowState: (s, id, st) => this.setFlowState(s, id, st),
-            getFlowNode: (a, nid) => this.getFlowNode(a, nid),
-            isFlowAgent: (a) => this.isFlowAgent(a),
-            touchSession: (s) => this.touchSession(s),
-        }, abortSignal);
-    }
-    async shouldHandleFlowInput(agent, input, flowState, abortSignal) {
-        return this.flowExecutor.shouldHandleFlowInput(agent, input, flowState, this.getFlowExecutorHelpers(), abortSignal);
-    }
-    async *runDetourResponse(agent, context, input, flowState, handoffTool, onHandoff, abortSignal) {
-        yield* this.flowExecutor.runDetourResponse(agent, context, input, flowState, handoffTool, onHandoff, this.getFlowExecutorHelpers(), abortSignal);
-    }
-    async *runFlowAgent(agent, context, input, systemPrompt, handoffTool, onHandoff, toolCalls, abortSignal) {
-        yield* this.flowExecutor.runFlowAgent(agent, context, input, systemPrompt, handoffTool, onHandoff, toolCalls, this.getFlowExecutorHelpers(), abortSignal);
-    }
-    getFlowExecutorHelpers() {
-        return {
-            emit: (ctx, part) => this.emit(ctx, part),
-            runOutputProcessing: (agent, ctx, text) => this.runOutputProcessing(agent, ctx, text),
-            appendSessionMessage: (s, m) => this.appendSessionMessage(s, m),
-            appendSessionMessages: (s, ms) => this.appendSessionMessages(s, ms),
-            postProcessPersistedAssistantMessages: (agent, ctx, start) => this.postProcessPersistedAssistantMessages(agent, ctx, start),
-            getAgentOutputProcessors: (agent) => this.getAgentOutputProcessors(agent),
-            getSessionTurn: (s) => this.getSessionTurn(s),
-            buildToolIdempotencyKey: (ctx, tn, tcid) => this.buildToolIdempotencyKey(ctx, tn, tcid),
-            setFlowState: (s, id, st) => this.setFlowState(s, id, st),
-            getFlowState: (s, id) => this.getFlowState(s, id),
-            updateFlowStateSnapshot: (s, id, st) => this.updateFlowStateSnapshot(s, id, st),
-            clearFlowState: (s, id) => this.clearFlowState(s, id),
-            buildFlowWithHandoff: (a, ht, s) => this.buildFlowWithHandoff(a, ht, s),
-            getFlowNode: (a, ni) => this.getFlowNode(a, ni),
-            touchSession: (s) => this.touchSession(s),
-            matchesDetourRule: (i, p) => this.matchesDetourRuleHelper(i, p),
-            enforcecheck: (call, ctx) => this.enforcer.check(call, {
-                previousCalls: ctx.toolCallHistory,
-                currentStep: ctx.stepCount,
-                sessionState: ctx.session.state ?? {},
-            }),
-            enforcecheckResult: (call, ctx) => this.enforcer.checkResult(call, {
-                previousCalls: ctx.toolCallHistory,
-                currentStep: ctx.stepCount,
-                sessionState: ctx.session.state ?? {},
-            }),
-            onToolCallHook: (ctx, call) => this.hookRunner.onToolCall(ctx, call),
-            onToolResultHook: (ctx, call) => this.hookRunner.onToolResult(ctx, call),
-            onToolErrorHook: (ctx, call, error) => this.hookRunner.onToolError(ctx, call, error),
+    // --- Private helpers ---
+    setupAbortHandlers(sessionId, controller, externalSignal) {
+        const abortHandler = () => {
+            this.abortControllers.delete(sessionId);
         };
-    }
-    matchesDetourRuleHelper(input, patterns) {
-        if (!patterns || patterns.length === 0) {
-            return false;
-        }
-        for (const pattern of patterns) {
-            try {
-                const regex = new RegExp(pattern, 'i');
-                if (regex.test(input)) {
-                    return true;
-                }
+        controller.signal.addEventListener('abort', abortHandler);
+        let externalAbortHandler;
+        if (externalSignal) {
+            externalAbortHandler = () => {
+                controller.abort(externalSignal.reason ?? 'External abort');
+            };
+            if (externalSignal.aborted) {
+                controller.abort(externalSignal.reason ?? 'External abort');
             }
-            catch {
-                if (input.includes(pattern.toLowerCase())) {
-                    return true;
-                }
+            else {
+                externalSignal.addEventListener('abort', externalAbortHandler);
             }
         }
-        return false;
-    }
-    async getSession(id) {
-        return this.sessionStore.get(id);
-    }
-    async deleteSession(id) {
-        await this.sessionStore.delete(id);
-    }
-    getAgent(id) {
-        return this.agents.get(id);
-    }
-    getAllAgents() {
-        return Array.from(this.agents.values());
-    }
-    normalizeSessionMessage(message) {
-        return normalizeModelMessage(message);
-    }
-    normalizeSessionHistory(messages) {
-        const normalized = [];
-        for (const message of messages) {
-            const next = this.normalizeSessionMessage(message);
-            if (next) {
-                normalized.push(next);
+        return () => {
+            controller.signal.removeEventListener('abort', abortHandler);
+            if (externalSignal && externalAbortHandler) {
+                externalSignal.removeEventListener('abort', externalAbortHandler);
             }
-        }
-        return normalized;
-    }
-    appendSessionMessage(session, message) {
-        const normalized = this.normalizeSessionMessage(message);
-        if (!normalized) {
-            return;
-        }
-        session.messages.push(normalized);
-        this.touchSession(session);
-    }
-    appendSessionMessages(session, messages) {
-        for (const message of messages) {
-            this.appendSessionMessage(session, message);
-        }
-    }
-    touchSession(session) {
-        const now = new Date();
-        session.updatedAt = now;
-        if (session.metadata) {
-            session.metadata.lastActiveAt = now;
-        }
-    }
-    getSessionTurn(session) {
-        const value = session.workingMemory[this.runtimeSessionTurnKey];
-        return typeof value === 'number' && Number.isFinite(value) ? value : 0;
-    }
-    bumpSessionTurn(session) {
-        const next = this.getSessionTurn(session) + 1;
-        session.workingMemory[this.runtimeSessionTurnKey] = next;
-        this.touchSession(session);
-        return next;
-    }
-    async saveSessionCheckpoint(session) {
-        this.touchSession(session);
-        await this._sessionStore.save(session);
-    }
-    shouldCheckpointAfterPart(part) {
-        return this.checkpointEventTypes.has(part.type);
-    }
-    recordRuntimeEvent(context, part) {
-        this.sessionEventManager.recordRuntimeEvent(context, part);
-    }
-    buildToolIdempotencyKey(context, toolName, toolCallId) {
-        return `${context.session.id}:${context.agentId}:${context.stepCount}:${toolName}:${toolCallId}`;
-    }
-    withToolExecutionMetadata(options, context, toolName, toolCallId, idempotencyKey) {
-        const baseOptions = isRecord(options) ? options : {};
-        const existingContext = isRecord(baseOptions.experimental_context)
-            ? baseOptions.experimental_context
-            : {};
-        return {
-            ...baseOptions,
-            toolCallId,
-            experimental_context: {
-                ...existingContext,
-                session: context.session,
-                sessionId: context.session.id,
-                agentId: context.agentId,
-                step: context.stepCount,
-                turn: this.getSessionTurn(context.session),
-                toolName,
-                toolCallId,
-                idempotencyKey,
-            },
         };
     }
-    buildProcessorContext(context, abortSignal) {
-        return {
-            session: context.session,
-            agentId: context.agentId,
-            toolCallHistory: context.toolCallHistory,
-            abortSignal,
-        };
-    }
-    getAgentOutputProcessors(agent) {
-        return [
-            ...this.outputProcessors,
-            ...(agent.outputProcessors ?? []),
-        ];
-    }
-    applyRedactionsToText(text) {
-        if (!this.outputRedactions || this.outputRedactions.length === 0)
-            return text;
-        let out = text;
-        for (const r of this.outputRedactions) {
-            out = out.replace(r.re, r.replacement);
-        }
-        return out;
-    }
-    async runOutputProcessing(agent, context, text) {
-        const processors = this.getAgentOutputProcessors(agent);
-        let cur = text;
-        if (processors.length > 0) {
-            const abortSignal = this.getActiveAbortController(context.session.id)?.signal;
-            const outcome = await runOutputProcessors({
-                processors,
-                text: cur,
-                messages: context.session.messages,
-                context: this.buildProcessorContext(context, abortSignal),
-            });
-            if (outcome.blocked) {
-                const msg = this.applyRedactionsToText(outcome.message);
-                return {
-                    text: msg,
-                    tripwire: { processorId: outcome.processorId, reason: outcome.reason, message: msg },
-                };
-            }
-            cur = outcome.text;
-        }
-        cur = this.applyRedactionsToText(cur);
-        return { text: cur };
-    }
-    async postProcessPersistedAssistantMessages(agent, context, startIndex) {
-        const tripwires = [];
-        const msgs = context.session.messages;
-        for (let i = startIndex; i < msgs.length; i++) {
-            const m = msgs[i];
-            if (!m || m.role !== 'assistant' || typeof m.content !== 'string')
-                continue;
-            const res = await this.runOutputProcessing(agent, context, m.content);
-            msgs[i] = { ...m, content: res.text };
-            if (res.tripwire) {
-                tripwires.push(res.tripwire);
-            }
-        }
-        return tripwires;
-    }
-    async *emit(context, part) {
-        // Defense-in-depth redaction of streamed assistant output.
-        if (this.outputRedactions && this.outputRedactions.length > 0) {
-            const sessionId = context.session.id;
-            if (part.type === 'text-delta') {
-                const next = this.applyOutputRedactions(context.session, part.text, false);
-                if (next) {
-                    const redacted = { ...part, text: next };
-                    yield* this.emitWithHooks(context, redacted);
-                }
-                return;
-            }
-            if (part.type === 'turn-end' || part.type === 'done') {
-                const flushed = this.applyOutputRedactions(context.session, '', true);
-                if (flushed) {
-                    const carryPart = { type: 'text-delta', text: flushed };
-                    yield* this.emitWithHooks(context, carryPart);
-                }
-                delete context.session.workingMemory[this.redactCarryKey];
-            }
-        }
-        yield* this.emitWithHooks(context, part);
-    }
-    async *emitWithHooks(context, part) {
-        this.recordRuntimeEvent(context, part);
-        await this.hookRunner.onStreamPart(context, part);
-        if (this.shouldCheckpointAfterPart(part)) {
-            await this.saveSessionCheckpoint(context.session);
-        }
-        yield part;
-    }
-    applyOutputRedactions(session, text, flush) {
-        if (!this.outputRedactions || this.outputRedactions.length === 0)
-            return text;
-        const carry = typeof session.workingMemory[this.redactCarryKey] === 'string'
-            ? session.workingMemory[this.redactCarryKey]
-            : '';
-        let combined = `${carry}${text}`;
-        for (const r of this.outputRedactions) {
-            combined = combined.replace(r.re, r.replacement);
-        }
-        const keep = flush ? 0 : this.redactLookbehind;
-        if (keep === 0) {
-            session.workingMemory[this.redactCarryKey] = '';
-            return combined;
-        }
-        if (combined.length <= keep) {
-            session.workingMemory[this.redactCarryKey] = combined;
-            return '';
-        }
-        const out = combined.slice(0, combined.length - keep);
-        session.workingMemory[this.redactCarryKey] = combined.slice(-keep);
-        return out;
-    }
 }
 export function createRuntime(config) {
     return new Runtime(config);