@ariaflowagents/core 0.5.0 → 0.5.2

package/dist/runtime/Runtime.js

@@ -1,4 +1,4 @@
-import { streamText, generateText, generateObject } from 'ai';
+import { streamText, generateText, Output, stepCountIs } from 'ai';
 import { z } from 'zod';
 import { FlowManager } from '../flows/FlowManager.js';
 import { createHandoffTool, isHandoffResult } from '../tools/handoff.js';
@@ -10,6 +10,8 @@ import { ToolEnforcer } from '../guards/ToolEnforcer.js';
 import { defaultEnforcementRules } from '../guards/rules.js';
 import { MemoryStore } from '../session/stores/MemoryStore.js';
 import { createHttpCallback } from '../callbacks/httpCallback.js';
+import { compileSanitizePattern, renderFlowTemplate } from '../flows/template.js';
+import { runInputProcessors, runOutputProcessors } from '../processors/ProcessorRunner.js';
 export class Runtime {
     config;
     agents = new Map();
@@ -26,6 +28,50 @@ export class Runtime {
     abortControllers = new Map();
     alwaysRouteThroughTriage;
     triageAgentId;
+    inputProcessors;
+    outputProcessors;
+    outputProcessorMode;
+    outputRedactions;
+    redactCarryBySession = new Map();
+    redactLookbehind = 64;
+    wrapToolsWithEnforcement(context, 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 callRecord = {
+                        toolCallId: options?.toolCallId ?? crypto.randomUUID(),
+                        toolName,
+                        args,
+                        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.).
+                    return exec(args, options);
+                },
+            };
+        }
+        return wrapped;
+    }
     constructor(config) {
         this.config = config;
         for (const agent of config.agents) {
@@ -58,6 +104,17 @@ export class Runtime {
         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 };
+            });
+        }
     }
     getActiveAbortController(sessionId) {
         return this.abortControllers.get(sessionId);
@@ -80,43 +137,28 @@ export class Runtime {
         else {
             session = this.createSession(effectiveSessionId, userId);
         }
-        session.messages.push({ role: 'user', content: input });
-        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);
-            session.messages = this.contextManager.beforeTurn(session.messages, {
-                turnCount: this.turnCount,
-                totalTokens,
-                sessionId: session.id,
-            });
-            const messagesAfter = session.messages.length;
-            if (messagesBefore !== messagesAfter) {
-                // NOTE: This is the only yield that bypasses emit() because RunContext
-                // doesn't exist yet at this point. The onStreamPart hook will NOT fire
-                // for context-compacted events. This is intentional - context compaction
-                // occurs before the agent loop begins.
-                yield {
-                    type: 'context-compacted',
-                    messagesBefore,
-                    messagesAfter,
-                };
-            }
-        }
-        this.turnCount++;
         if (this.alwaysRouteThroughTriage) {
-            const triageId = this.triageAgentId ?? this.defaultAgentId;
-            const triageAgent = this.agents.get(triageId);
-            if (triageAgent && this.isTriageAgent(triageAgent)) {
-                session.activeAgentId = triageId;
-                session.currentAgent = triageId;
+            // 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;
+                }
             }
         }
         const activeAgentId = session.activeAgentId ?? session.currentAgent ?? this.defaultAgentId;
         session.activeAgentId = activeAgentId;
         session.currentAgent = activeAgentId;
+        this.turnCount++;
         const context = {
             session,
             agentId: activeAgentId,
@@ -130,7 +172,11 @@ export class Runtime {
         const injectionQueue = new InjectionQueue();
         injectionQueue.add(commonInjections.professional);
         injectionQueue.add(commonInjections.noGuessing);
+        injectionQueue.add(commonInjections.noSecrets);
+        injectionQueue.add(commonInjections.invisibleHandoffs);
         injectionQueue.add(commonInjections.confirmDestructive);
+        // 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();
         this.abortControllers.set(session.id, controller);
         const abortHandler = () => {
@@ -144,8 +190,64 @@ export class Runtime {
             abortSignal.addEventListener('abort', externalAbortHandler);
         }
         await this.hookRunner.onStart(context);
+        // Run input processors BEFORE persisting the user message.
+        let processedInput = input;
         try {
-            yield* this.runLoop(context, injectionQueue, input, controller);
+            const turnInputProcessors = [...this.inputProcessors];
+            if (turnInputProcessors.length > 0) {
+                const candidateMessages = [
+                    ...session.messages,
+                    { role: 'user', content: processedInput },
+                ];
+                const procCtx = {
+                    session,
+                    agentId: activeAgentId,
+                    toolCallHistory: context.toolCallHistory,
+                };
+                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.
+            session.messages.push({ 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);
+                session.messages = this.contextManager.beforeTurn(session.messages, {
+                    turnCount: this.turnCount,
+                    totalTokens,
+                    sessionId: session.id,
+                });
+                const messagesAfter = session.messages.length;
+                if (messagesBefore !== messagesAfter) {
+                    yield* this.emit(context, {
+                        type: 'context-compacted',
+                        messagesBefore,
+                        messagesAfter,
+                    });
+                }
+            }
+            yield* this.runLoop(context, injectionQueue, processedInput, controller);
             await this.hookRunner.onEnd(context, { success: true });
         }
         catch (error) {
@@ -164,6 +266,7 @@ export class Runtime {
         yield* this.stream({ input, sessionId, userId });
     }
     async *runLoop(context, injectionQueue, input, abortController) {
+        let currentInput = input;
         while (context.handoffStack.length < this.maxHandoffs) {
             if (abortController?.signal.aborted) {
                 yield* this.emit(context, {
@@ -176,11 +279,16 @@ export class Runtime {
                 });
                 return;
             }
-            if (context.handoffStack.includes(context.agentId)) {
-                yield* this.emit(context, {
-                    type: 'error',
-                    error: `Circular handoff detected: ${context.handoffStack.join(' -> ')} -> ${context.agentId}`,
-                });
+            // 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) {
+                const err = `Circular handoff detected: ${context.handoffStack.join(' -> ')} -> ${context.agentId}`;
+                yield* this.emit(context, { type: 'error', error: err });
+                const fallback = "I ran into an internal routing issue. Please rephrase your request in one sentence. " +
+                    "For security, don't share passwords, API keys, or card numbers/CVV here.";
+                context.session.messages.push({ role: 'assistant', content: fallback });
+                yield* this.emit(context, { type: 'text-delta', text: fallback });
                 return;
             }
             context.handoffStack.push(context.agentId);
@@ -189,6 +297,40 @@ export class Runtime {
                 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,
+                };
+                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;
+                    }
+                }
+            }
             yield* this.emit(context, { type: 'agent-start', agentId: agent.id });
             await this.hookRunner.onAgentStart(context, agent.id);
             let autoContext;
@@ -198,7 +340,7 @@ export class Runtime {
                 const callRecord = {
                     toolCallId,
                     toolName,
-                    args: { input },
+                    args: { input: currentInput },
                     success: true,
                     timestamp: Date.now(),
                 };
@@ -217,7 +359,7 @@ export class Runtime {
                 });
                 let result = null;
                 try {
-                    result = await agent.autoRetrieve.run({ input, context });
+                    result = await agent.autoRetrieve.run({ input: currentInput, context });
                     callRecord.result = result;
                 }
                 catch (error) {
@@ -258,7 +400,9 @@ export class Runtime {
             }
             const system = this.buildSystemPrompt(agent, injectionQueue, autoContext, context);
             const handoffCandidates = this.getHandoffCandidates(agent);
-            const handoffTool = createHandoffTool(handoffCandidates, context.agentId);
+            const handoffTool = handoffCandidates.length > 0
+                ? createHandoffTool(handoffCandidates, context.agentId)
+                : null;
             let handoffTo = null;
             let handoffReason = 'No reason provided';
             if (this.isFlowAgent(agent)) {
@@ -277,7 +421,7 @@ export class Runtime {
                 await this.hookRunner.onStepStart(context, context.stepCount);
                 const toolCalls = [];
                 try {
-                    for await (const part of this.runFlowAgent(agent, context, input, system, handoffTool, (target, reason) => {
+                    for await (const part of this.runFlowAgent(agent, context, currentInput, system, handoffTool ?? undefined, (target, reason) => {
                         handoffTo = target;
                         handoffReason = reason ?? 'No reason provided';
                     }, toolCalls)) {
@@ -305,7 +449,7 @@ export class Runtime {
                 }
             }
             else {
-                const tools = { ...agent.tools, handoff: handoffTool };
+                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) {
@@ -330,13 +474,14 @@ export class Runtime {
                                 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.'),
                             });
-                            const result = await generateObject({
+                            // AI SDK v6+ recommended structured output approach.
+                            const { output: decision } = await generateText({
                                 model: model,
-                                schema,
+                                output: Output.object({ schema }),
                                 system: this.buildStructuredTriagePrompt(agent),
                                 messages: context.session.messages,
+                                experimental_telemetry: agent.telemetry ?? this.config.telemetry,
                             });
-                            const decision = result.object;
                             const allowed = new Set(agent.routes.map(route => route.agentId));
                             let target = decision.agentId;
                             if (!allowed.has(target)) {
@@ -358,16 +503,34 @@ export class Runtime {
                             system,
                             messages: context.session.messages,
                             tools,
+                            // 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;
                                 }
-                                yield* this.emit(context, { type: 'text-delta', text: chunk.text });
+                                if (bufferOutput) {
+                                    bufferedText += chunk.text;
+                                }
+                                else {
+                                    yield* this.emit(context, { type: 'text-delta', text: chunk.text });
+                                }
                             }
                             if (chunk.type === 'tool-call') {
                                 const args = 'args' in chunk ? chunk.args : chunk.input;
@@ -397,6 +560,27 @@ export class Runtime {
                                     args,
                                 });
                             }
+                            if (chunk.type === 'tool-error') {
+                                const errText = typeof chunk.error === 'string'
+                                    ? chunk.error
+                                    : chunk.error?.message ?? 'Tool execution error';
+                                const args = chunk.input ?? chunk.args;
+                                const callRecord = toolCalls.find(call => call.toolCallId === chunk.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);
+                                }
+                                yield* this.emit(context, {
+                                    type: 'tool-error',
+                                    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 = 'result' in chunk ? chunk.result : chunk.output;
@@ -435,7 +619,12 @@ export class Runtime {
                                         finalResult = { type: 'final', text: reason };
                                         if (!finalEmitted) {
                                             finalEmitted = true;
-                                            yield* this.emit(context, { type: 'text-delta', text: reason });
+                                            if (bufferOutput) {
+                                                bufferedText += reason;
+                                            }
+                                            else {
+                                                yield* this.emit(context, { type: 'text-delta', text: reason });
+                                            }
                                         }
                                         continue;
                                     }
@@ -446,11 +635,23 @@ export class Runtime {
                                     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;
-                                        yield* this.emit(context, { type: 'text-delta', text: toolResult.text });
+                                        if (bufferOutput) {
+                                            bufferedText += toolResult.text;
+                                        }
+                                        else {
+                                            yield* this.emit(context, { type: 'text-delta', text: toolResult.text });
+                                        }
                                     }
                                     continue;
                                 }
@@ -461,12 +662,45 @@ export class Runtime {
                                 }
                             }
                         }
+                        if (stoppedByGuard) {
+                            return;
+                        }
                         const response = await result.response;
-                        if (finalResult) {
-                            context.session.messages.push({ role: 'assistant', content: finalResult.text });
+                        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')) {
+                            const rawText = finalResult ? finalResult.text : bufferedText;
+                            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) {
+                                yield* this.emit(context, { type: 'text-delta', text: processed.text });
+                            }
+                            context.session.messages.push({ role: 'assistant', content: processed.text });
                         }
                         else {
+                            const beforeLen = context.session.messages.length;
                             context.session.messages.push(...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;
@@ -476,7 +710,6 @@ export class Runtime {
                             context.session.metadata.totalSteps += 1;
                         }
                         context.consecutiveErrors = 0;
-                        const finishReason = finalResult ? 'final' : await result.finishReason;
                         yield* this.emit(context, { type: 'step-end', step: context.stepCount, agentId: agent.id });
                         await this.hookRunner.onStepEnd(context, context.stepCount, {
                             toolCalls,
@@ -618,7 +851,14 @@ ${routeDescriptions}
                 .map(route => this.agents.get(route.agentId))
                 .filter((candidate) => Boolean(candidate));
         }
-        return Array.from(this.agents.values());
+        // 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;
@@ -638,20 +878,40 @@ ${routeDescriptions}
         delete session.agentStates[agentId];
     }
     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 ?? {};
-                if (existingTools.handoff) {
+                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: {
-                        ...existingTools,
+                        ...toolSet,
                         handoff: handoffTool,
                     },
                     ...(shouldSuppress ? { autoRespond: false } : {}),
@@ -666,17 +926,42 @@ ${routeDescriptions}
         return agent.flow.nodes.find(node => node.id === nodeId);
     }
     async shouldHandleFlowInput(agent, input, flowState) {
+        // Before the flow is initialized, be conservative: run the flow.
+        // This avoids misrouting the very first user message after a handoff into "detour",
+        // which can lead to unnecessary specialist handoffs and handoff loops.
+        if (!flowState?.initialized) {
+            return true;
+        }
         const nodeId = flowState?.context.currentNode ?? agent.initialNode;
         const node = this.getFlowNode(agent, nodeId);
         if (!node) {
             return true;
         }
+        const rules = agent.detourRules;
+        if (rules) {
+            const normalized = input.trim().toLowerCase();
+            if (rules.allowShortAffirmations !== false &&
+                /^(yes|yep|yeah|ok|okay|sure|great|thanks|thank you|please|proceed|go ahead)\b/.test(normalized)) {
+                return true;
+            }
+            if (rules.allowDateTime !== false &&
+                (/\b20\d{2}-\d{2}-\d{2}\b/.test(normalized) || /\b\d{1,2}:\d{2}\b/.test(normalized))) {
+                return true;
+            }
+            if (this.matchesDetourRule(normalized, rules.deny)) {
+                return false;
+            }
+            if (this.matchesDetourRule(normalized, rules.allow)) {
+                return true;
+            }
+        }
         const collectedData = flowState?.context.collectedData ?? {};
+        const renderedNodePrompt = renderFlowTemplate(node.prompt, collectedData, { missing: 'keep' });
         const routerPrompt = `You are routing a message for a structured conversation flow.
 Decide if the user input is answering the current flow step or is a side question.
 
 Current flow step:
-${node.prompt}
+${renderedNodePrompt}
 
 Collected data:
 ${JSON.stringify(collectedData, null, 2)}
@@ -686,6 +971,7 @@ Return only one word: "flow" if the input should be handled by the flow step, or
             model: (agent.model ?? this.defaultModel),
             system: routerPrompt,
             prompt: input,
+            experimental_telemetry: agent.telemetry ?? this.config.telemetry,
         });
         const decision = result.text.trim().toLowerCase();
         if (decision.startsWith('detour')) {
@@ -696,13 +982,37 @@ Return only one word: "flow" if the input should be handled by the flow step, or
         }
         return true;
     }
-    async *runDetourResponse(agent, context, input, flowState) {
+    matchesDetourRule(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;
+                }
+            }
+            catch {
+                if (input.includes(pattern.toLowerCase())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    async *runDetourResponse(agent, context, input, flowState, handoffTool, onHandoff) {
         const nodeId = flowState?.context.currentNode ?? agent.initialNode;
         const node = this.getFlowNode(agent, nodeId);
-        const nodePrompt = node?.prompt ?? 'Continue the flow.';
         const collectedData = flowState?.context.collectedData ?? {};
+        const nodePrompt = node
+            ? renderFlowTemplate(node.prompt, collectedData, { missing: 'keep' })
+            : 'Continue the flow.';
+        const handoffLine = handoffTool
+            ? 'If the request should be handled by a specialist agent, use the handoff tool instead of answering.'
+            : 'Do not attempt to route to other agents. Handle the detour here and then resume the flow.';
         const detourPrompt = `You are handling a short detour during a structured flow.
-Answer the user's question clearly and briefly. Then ask the user to continue with the current flow step.
+Answer the user's question clearly and briefly. ${handoffLine} Then ask the user to continue with the current flow step.
 
 Current flow step:
 ${nodePrompt}
@@ -715,14 +1025,79 @@ Do not change the flow requirements. Keep the reply concise.`;
             model: (agent.model ?? this.defaultModel),
             system: detourPrompt,
             messages: context.session.messages,
+            tools: handoffTool ? { handoff: handoffTool } : undefined,
+            experimental_telemetry: agent.telemetry ?? this.config.telemetry,
         });
+        let handoffTriggered = false;
+        const outputProcessors = this.getAgentOutputProcessors(agent);
+        const bufferOutput = this.outputProcessorMode === 'buffer' && outputProcessors.length > 0;
+        let bufferedText = '';
         for await (const chunk of result.fullStream) {
             if (chunk.type === 'text-delta') {
-                yield* this.emit(context, { type: 'text-delta', text: chunk.text });
+                if (handoffTriggered) {
+                    continue;
+                }
+                if (bufferOutput) {
+                    bufferedText += chunk.text;
+                }
+                else {
+                    yield* this.emit(context, { type: 'text-delta', text: chunk.text });
+                }
+            }
+            if (chunk.type === 'tool-call') {
+                const args = 'args' in chunk ? chunk.args : chunk.input;
+                yield* this.emit(context, {
+                    type: 'tool-call',
+                    toolCallId: chunk.toolCallId,
+                    toolName: chunk.toolName,
+                    args,
+                });
+            }
+            if (chunk.type === 'tool-result') {
+                const toolResult = 'result' in chunk ? chunk.result : chunk.output;
+                yield* this.emit(context, {
+                    type: 'tool-result',
+                    toolCallId: chunk.toolCallId,
+                    toolName: chunk.toolName,
+                    result: toolResult,
+                });
+                if (isHandoffResult(toolResult)) {
+                    const targetAgent = toolResult.targetAgent ?? toolResult.targetAgentId;
+                    onHandoff(targetAgent, toolResult.reason);
+                    handoffTriggered = true;
+                    break;
+                }
             }
         }
         const response = await result.response;
-        context.session.messages.push(...response.messages);
+        if (bufferOutput) {
+            const processed = await this.runOutputProcessing(agent, context, bufferedText);
+            if (processed.tripwire) {
+                yield* this.emit(context, {
+                    type: 'tripwire',
+                    phase: 'output',
+                    processorId: processed.tripwire.processorId,
+                    reason: processed.tripwire.reason,
+                    message: processed.tripwire.message,
+                });
+            }
+            yield* this.emit(context, { type: 'text-delta', text: processed.text });
+            context.session.messages.push({ role: 'assistant', content: processed.text });
+        }
+        else {
+            const beforeLen = context.session.messages.length;
+            context.session.messages.push(...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;
@@ -730,22 +1105,46 @@ Do not change the flow requirements. Keep the reply concise.`;
             context.session.metadata.totalTokens += totalTokens;
             context.session.metadata.totalSteps += 1;
         }
-        yield* this.emit(context, { type: 'turn-end' });
+        if (!handoffTriggered) {
+            yield* this.emit(context, { type: 'turn-end' });
+        }
     }
     async *runFlowAgent(agent, context, input, systemPrompt, handoffTool, onHandoff, toolCalls) {
         const model = agent.model ?? this.defaultModel;
         if (!model) {
             throw new Error(`Agent "${agent.id}" is missing a model`);
         }
+        const detourRules = agent.detourRules;
+        if (detourRules?.emergency && this.matchesDetourRule(input, detourRules.emergency)) {
+            const emergencyText = detourRules.emergencyMessage
+                ?? 'This sounds urgent. Please call local emergency services immediately or go to the nearest emergency room.';
+            const processed = await this.runOutputProcessing(agent, context, emergencyText);
+            if (processed.tripwire) {
+                yield* this.emit(context, {
+                    type: 'tripwire',
+                    phase: 'output',
+                    processorId: processed.tripwire.processorId,
+                    reason: processed.tripwire.reason,
+                    message: processed.tripwire.message,
+                });
+            }
+            context.session.messages.push({ role: 'assistant', content: processed.text });
+            yield* this.emit(context, { type: 'text-delta', text: processed.text });
+            yield* this.emit(context, { type: 'turn-end' });
+            if (detourRules.emergencyHandoffAgent) {
+                onHandoff(detourRules.emergencyHandoffAgent, 'Emergency pattern matched');
+            }
+            return;
+        }
         const flowState = this.getFlowState(context.session, agent.id);
         if (agent.mode === 'hybrid') {
             const shouldRunFlow = await this.shouldHandleFlowInput(agent, input, flowState);
             if (!shouldRunFlow) {
-                yield* this.runDetourResponse(agent, context, input, flowState);
+                yield* this.runDetourResponse(agent, context, input, flowState, handoffTool, onHandoff);
                 return;
             }
         }
-        const suppressAutoRespond = context.session.messages.length > 1 && !flowState?.initialized;
+        const suppressAutoRespond = !flowState?.initialized;
         const flow = this.buildFlowWithHandoff(agent, handoffTool, suppressAutoRespond);
         const flowManager = new FlowManager({
             flow,
@@ -755,7 +1154,27 @@ Do not change the flow requirements. Keep the reply concise.`;
             contextMessages: flowState?.context.messages ?? [],
             sessionMessages: context.session.messages,
             state: flowState,
+            telemetry: agent.telemetry ?? this.config.telemetry,
+            toolCallGuard: async ({ toolName, args }) => {
+                const callRecord = {
+                    toolCallId: crypto.randomUUID(),
+                    toolName,
+                    args,
+                    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) {
+                    return { allowed: false, reason: enforcement.reason ?? 'Tool call blocked by enforcement' };
+                }
+                return { allowed: true };
+            },
         });
+        let persistedStartIndex = context.session.messages.length;
         if (!flowState?.initialized) {
             for await (const part of flowManager.initialize()) {
                 switch (part.type) {
@@ -819,6 +1238,26 @@ Do not change the flow requirements. Keep the reply concise.`;
                         });
                         break;
                     }
+                    case 'tool-error': {
+                        const toolCallId = part.toolCallId
+                            ?? toolCalls.find(call => call.toolName === part.toolName && call.error === undefined)?.toolCallId
+                            ?? crypto.randomUUID();
+                        const callRecord = toolCalls.find(call => call.toolCallId === toolCallId);
+                        if (callRecord) {
+                            callRecord.success = false;
+                            callRecord.error = new Error(part.error);
+                            callRecord.durationMs = Date.now() - callRecord.timestamp;
+                            context.toolCallHistory.push(callRecord);
+                            await this.hookRunner.onToolError(context, callRecord, callRecord.error);
+                        }
+                        yield* this.emit(context, {
+                            type: 'tool-error',
+                            toolCallId,
+                            toolName: part.toolName,
+                            error: part.error,
+                        });
+                        break;
+                    }
                     case 'handoff':
                         onHandoff(part.targetAgent, part.reason);
                         break;
@@ -844,6 +1283,18 @@ Do not change the flow requirements. Keep the reply concise.`;
                         break;
                 }
             }
+            // Sanitize/redact anything FlowManager persisted during initialization.
+            const tripwires = await this.postProcessPersistedAssistantMessages(agent, context, persistedStartIndex);
+            for (const t of tripwires) {
+                yield* this.emit(context, {
+                    type: 'tripwire',
+                    phase: 'output',
+                    processorId: t.processorId,
+                    reason: t.reason,
+                    message: t.message,
+                });
+            }
+            persistedStartIndex = context.session.messages.length;
         }
         for await (const part of flowManager.process(input, { appendUserToSession: false })) {
             switch (part.type) {
@@ -907,6 +1358,26 @@ Do not change the flow requirements. Keep the reply concise.`;
                     });
                     break;
                 }
+                case 'tool-error': {
+                    const toolCallId = part.toolCallId
+                        ?? toolCalls.find(call => call.toolName === part.toolName && call.error === undefined)?.toolCallId
+                        ?? crypto.randomUUID();
+                    const callRecord = toolCalls.find(call => call.toolCallId === toolCallId);
+                    if (callRecord) {
+                        callRecord.success = false;
+                        callRecord.error = new Error(part.error);
+                        callRecord.durationMs = Date.now() - callRecord.timestamp;
+                        context.toolCallHistory.push(callRecord);
+                        await this.hookRunner.onToolError(context, callRecord, callRecord.error);
+                    }
+                    yield* this.emit(context, {
+                        type: 'tool-error',
+                        toolCallId,
+                        toolName: part.toolName,
+                        error: part.error,
+                    });
+                    break;
+                }
                 case 'handoff':
                     onHandoff(part.targetAgent, part.reason);
                     break;
@@ -932,6 +1403,17 @@ Do not change the flow requirements. Keep the reply concise.`;
                     break;
             }
         }
+        // Sanitize/redact anything FlowManager persisted during this user turn.
+        const tripwires = await this.postProcessPersistedAssistantMessages(agent, context, persistedStartIndex);
+        for (const t of tripwires) {
+            yield* this.emit(context, {
+                type: 'tripwire',
+                phase: 'output',
+                processorId: t.processorId,
+                reason: t.reason,
+                message: t.message,
+            });
+        }
         if (flowManager.hasEnded) {
             this.clearFlowState(context.session, agent.id);
         }
@@ -951,10 +1433,112 @@ Do not change the flow requirements. Keep the reply concise.`;
     getAllAgents() {
         return Array.from(this.agents.values());
     }
+    buildProcessorContext(context) {
+        return {
+            session: context.session,
+            agentId: context.agentId,
+            toolCallHistory: context.toolCallHistory,
+        };
+    }
+    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 outcome = await runOutputProcessors({
+                processors,
+                text: cur,
+                messages: context.session.messages,
+                context: this.buildProcessorContext(context),
+            });
+            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(sessionId, part.text, false);
+                if (next) {
+                    const redacted = { ...part, text: next };
+                    await this.hookRunner.onStreamPart(context, redacted);
+                    yield redacted;
+                }
+                return;
+            }
+            if (part.type === 'turn-end' || part.type === 'done') {
+                const flushed = this.applyOutputRedactions(sessionId, '', true);
+                if (flushed) {
+                    const carryPart = { type: 'text-delta', text: flushed };
+                    await this.hookRunner.onStreamPart(context, carryPart);
+                    yield carryPart;
+                }
+                this.redactCarryBySession.delete(sessionId);
+            }
+        }
         await this.hookRunner.onStreamPart(context, part);
         yield part;
     }
+    applyOutputRedactions(sessionId, text, flush) {
+        if (!this.outputRedactions || this.outputRedactions.length === 0)
+            return text;
+        const carry = this.redactCarryBySession.get(sessionId) ?? '';
+        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) {
+            this.redactCarryBySession.set(sessionId, '');
+            return combined;
+        }
+        if (combined.length <= keep) {
+            this.redactCarryBySession.set(sessionId, combined);
+            return '';
+        }
+        const out = combined.slice(0, combined.length - keep);
+        this.redactCarryBySession.set(sessionId, combined.slice(-keep));
+        return out;
+    }
 }
 export function createRuntime(config) {
     return new Runtime(config);