@ariaflowagents/core 0.6.3 → 0.7.1

package/dist/flows/FlowManager.js

@@ -1,8 +1,16 @@
-import { streamText, generateText } from 'ai';
-import { isFlowTransition, isFlowUpdate } from './transitions.js';
+import { streamText, generateText, tool } from 'ai';
+import { z } from 'zod';
+import { createFlowTransition, isFlowTransition, isFlowUpdate } from './transitions.js';
+import { validateFlowConfig } from './validation.js';
 import { isHandoffResult } from '../tools/handoff.js';
 import { isFinalResult } from '../tools/final.js';
 import { compileSanitizePattern, renderNodePrompt } from './template.js';
+import { normalizeModelMessage } from '../utils/messageNormalization.js';
+import { processAIStream } from '../utils/aiStream.js';
+const implicitTransitionToolInputSchema = z.object({
+    data: z.record(z.unknown()).optional(),
+    message: z.string().optional(),
+});
 export class FlowManager {
     config;
     nodes = new Map();
@@ -11,10 +19,12 @@ export class FlowManager {
     currentNodeConfig = null;
     initialized = false;
     pendingEvents = [];
+    deferredActions = [];
     flowEnded = false;
     sessionMessages;
     constructor(config) {
         this.config = config;
+        validateFlowConfig(config.flow, config.initialNode);
         for (const node of config.flow.nodes) {
             this.nodes.set(node.id, node);
         }
@@ -37,7 +47,6 @@ export class FlowManager {
                 messages: config.contextMessages ?? [],
             };
         }
-        this.sessionMessages = config.sessionMessages;
         if (this.initialized) {
             this.currentNodeConfig = this.nodes.get(this.context.currentNode) ?? null;
         }
@@ -48,11 +57,12 @@ export class FlowManager {
         }
         yield* this.transitionToGenerator(this.config.initialNode);
         this.initialized = true;
-        if (this.currentNodeConfig?.autoRespond !== false) {
-            yield* this.runInference();
+        if (!this.flowEnded && this.currentNodeConfig?.autoRespond !== false) {
+            yield* this.runInference(false);
         }
+        yield* this.flushDeferredActions();
     }
-    async *process(userInput, options = {}) {
+    async *process(userInput) {
         if (!this.initialized) {
             throw new Error('Flow not initialized. Call initialize() first.');
         }
@@ -64,15 +74,15 @@ export class FlowManager {
             yield { type: 'error', error: 'No current node' };
             return;
         }
-        this.appendMessage({ role: 'user', content: userInput }, options.appendUserToSession !== false);
+        this.appendMessage({ role: 'user', content: userInput });
         const nodeId = this.currentNodeConfig.id;
         this.context.nodeTurnCounts[nodeId] = (this.context.nodeTurnCounts[nodeId] ?? 0) + 1;
         if (this.currentNodeConfig.maxTurns && this.context.nodeTurnCounts[nodeId] > this.currentNodeConfig.maxTurns) {
             yield { type: 'error', error: `Max turns exceeded for node "${nodeId}"` };
             return;
         }
-        yield* this.runInference();
-        yield { type: 'turn-end' };
+        yield* this.runInference(true);
+        yield* this.flushDeferredActions();
     }
     async transitionTo(nodeId, data) {
         for await (const _part of this.transitionToGenerator(nodeId, data)) {
@@ -95,6 +105,9 @@ export class FlowManager {
         const previousNode = this.currentNodeConfig;
         if (previousNode) {
             yield* this.runActions(previousNode.postActions ?? []);
+            if (this.flowEnded) {
+                return;
+            }
             yield { type: 'node-exit', nodeName: previousNode.name ?? previousNode.id };
         }
         this.currentNodeConfig = nextNode;
@@ -106,6 +119,9 @@ export class FlowManager {
         await this.applyContextStrategy(nextNode);
         yield { type: 'node-enter', nodeName: nextNode.name ?? nextNode.id };
         yield* this.runActions(nextNode.preActions ?? []);
+        if (this.flowEnded) {
+            return;
+        }
         if (previousNode) {
             yield { type: 'flow-transition', from: previousNode.id, to: nextNode.id };
         }
@@ -126,63 +142,56 @@ export class FlowManager {
             flowEnded: this.flowEnded,
         };
     }
-    async *runInference() {
-        if (!this.currentNodeConfig) {
+    async *runInference(triggeredByUserTurn) {
+        if (this.flowEnded || !this.currentNodeConfig) {
             return;
         }
         const node = this.currentNodeConfig;
         const systemPrompt = this.buildSystemPrompt(node);
         const tools = this.resolveTools(node);
         const maxSteps = node.maxSteps ?? this.config.maxSteps ?? this.config.flow.maxSteps ?? 25;
-        const streamConfig = {
+        const streamOptions = {
             model: this.config.model,
             system: systemPrompt,
             tools,
             maxSteps,
+            abortSignal: this.config.abortSignal,
             experimental_telemetry: this.config.telemetry,
         };
         // On first turn of a node (after context reset), use the node's prompt as the user message
         // This respects the flow design without auto-generating greetings
         if (this.context.messages.length === 0) {
-            streamConfig.prompt = renderNodePrompt(node.prompt, this.context);
+            streamOptions.prompt = renderNodePrompt(node.prompt, this.context);
         }
         else {
-            streamConfig.messages = this.context.messages;
+            streamOptions.messages = this.context.messages;
         }
-        const result = streamText(streamConfig);
+        const result = streamText(streamOptions);
         const outputMode = node.output?.mode ?? 'stream';
         const shouldBuffer = outputMode === 'buffer';
         let responseText = '';
         let bufferedOutputEmitted = false;
-        let pendingTransition = null;
-        let pendingHandoff = null;
+        const pendingTransitions = [];
+        const pendingHandoffs = [];
         let finalResult = null;
         let finalEmitted = false;
         let hadToolResult = false;
         let pendingToolMessage = null;
-        for await (const chunk of result.fullStream) {
-            if (chunk.type === 'text-delta') {
+        for await (const part of processAIStream(result.fullStream)) {
+            // In buffered mode, hold text-delta tokens until we decide whether to emit.
+            // This allows transition/handoff turns to stay silent in routing nodes.
+            if (!(shouldBuffer && part.type === 'text-delta')) {
+                yield part;
+            }
+            if (part.type === 'text-delta') {
                 if (finalResult) {
                     continue;
                 }
-                responseText += chunk.text;
-                if (!shouldBuffer) {
-                    yield { type: 'text-delta', text: chunk.text };
-                }
-            }
-            if (chunk.type === 'tool-call') {
-                const args = 'args' in chunk ? chunk.args : chunk.input;
-                yield { type: 'tool-call', toolName: chunk.toolName, args, toolCallId: chunk.toolCallId };
+                responseText += part.text;
             }
-            if (chunk.type === 'tool-result') {
-                const toolResult = 'result' in chunk ? chunk.result : chunk.output;
+            if (part.type === 'tool-result') {
+                const toolResult = part.result;
                 hadToolResult = true;
-                yield {
-                    type: 'tool-result',
-                    toolName: chunk.toolName,
-                    result: toolResult,
-                    toolCallId: chunk.toolCallId,
-                };
                 if (isFinalResult(toolResult)) {
                     finalResult = toolResult;
                     if (!finalEmitted) {
@@ -208,18 +217,22 @@ export class FlowManager {
                     continue;
                 }
                 if (isFlowTransition(toolResult)) {
-                    pendingTransition = {
+                    pendingTransitions.push({
                         targetNode: toolResult.targetNode,
                         data: toolResult.data,
                         node: toolResult.node,
-                    };
+                        toolName: part.toolName,
+                        toolCallId: part.toolCallId,
+                    });
                 }
                 if (isHandoffResult(toolResult)) {
                     const targetAgent = toolResult.targetAgent ?? toolResult.targetAgentId;
-                    pendingHandoff = {
+                    pendingHandoffs.push({
                         targetAgent,
                         reason: toolResult.reason,
-                    };
+                        toolName: part.toolName,
+                        toolCallId: part.toolCallId,
+                    });
                 }
                 if (typeof toolResult === 'object' &&
                     toolResult !== null &&
@@ -229,17 +242,6 @@ export class FlowManager {
                     pendingToolMessage = toolResult.message;
                 }
             }
-            if (chunk.type === 'tool-error') {
-                const errText = typeof chunk.error === 'string'
-                    ? chunk.error
-                    : chunk.error?.message ?? 'Tool execution error';
-                yield {
-                    type: 'tool-error',
-                    toolName: chunk.toolName,
-                    error: errText,
-                    toolCallId: chunk.toolCallId,
-                };
-            }
         }
         const response = await result.response;
         let safeText = responseText;
@@ -249,28 +251,22 @@ export class FlowManager {
                 safeText = node.output.sanitize.message;
             }
         }
-        if (finalResult) {
-            this.appendMessage({ role: 'assistant', content: finalResult.text });
-        }
-        else if (shouldBuffer) {
-            let appendedAssistant = false;
-            for (const message of response.messages) {
-                if (message.role === 'assistant' && typeof message.content === 'string') {
-                    if (!appendedAssistant) {
-                        this.appendMessage({ role: 'assistant', content: safeText });
-                        appendedAssistant = true;
-                    }
-                    continue;
-                }
-                this.appendMessage(message);
-            }
-            if (!appendedAssistant) {
-                this.appendMessage({ role: 'assistant', content: safeText });
-            }
+        for (const message of response.messages) {
+            this.appendMessage(message);
         }
-        else {
-            for (const message of response.messages) {
-                this.appendMessage(message);
+        yield { type: 'turn-end', metadata: { response } };
+        const signalResolution = this.resolvePendingSignals(pendingTransitions, pendingHandoffs);
+        if (signalResolution.conflict) {
+            yield { type: 'error', error: signalResolution.conflict };
+            return;
+        }
+        let pendingTransition = signalResolution.transition ?? null;
+        const pendingHandoff = signalResolution.handoff ?? null;
+        if (pendingTransition) {
+            const policy = this.checkTransitionPolicy(node.id, pendingTransition.targetNode, 'tool', triggeredByUserTurn);
+            if (policy) {
+                pendingTransition = null;
+                yield { type: 'error', error: policy };
             }
         }
         if (!finalResult && !pendingTransition && !pendingHandoff && responseText.trim().length === 0 && pendingToolMessage) {
@@ -299,6 +295,7 @@ export class FlowManager {
                 model: this.config.model,
                 system: `${systemPrompt}\n\nRespond to the user now using the tool results above.`,
                 messages: this.context.messages,
+                abortSignal: this.config.abortSignal,
                 experimental_telemetry: this.config.telemetry,
             });
             responseText = followup.text;
@@ -308,7 +305,7 @@ export class FlowManager {
                 bufferedOutputEmitted = true;
             }
         }
-        if (!finalResult && shouldBuffer && responseText.trim().length > 0 && !bufferedOutputEmitted) {
+        if (!finalResult && !pendingTransition && !pendingHandoff && shouldBuffer && responseText.trim().length > 0 && !bufferedOutputEmitted) {
             yield { type: 'text-delta', text: safeText };
         }
         if (finalResult) {
@@ -326,11 +323,16 @@ export class FlowManager {
             yield { type: 'flow-end', reason: 'handoff' };
             return;
         }
-        const nextTransition = pendingTransition ?? (await this.evaluateTransitions());
+        const evaluated = await this.evaluateTransitions(triggeredByUserTurn);
+        if (evaluated.blockedError) {
+            yield { type: 'error', error: evaluated.blockedError };
+            return;
+        }
+        const nextTransition = pendingTransition ?? evaluated.transition;
         if (nextTransition) {
             yield* this.transitionToGenerator(nextTransition.targetNode, nextTransition.data, nextTransition.node);
-            if (this.currentNodeConfig?.autoRespond !== false) {
-                yield* this.runInference();
+            if (!this.flowEnded && this.currentNodeConfig?.autoRespond !== false) {
+                yield* this.runInference(false);
             }
         }
         if (node.postActions?.some(action => action.type === 'end')) {
@@ -339,7 +341,10 @@ export class FlowManager {
         }
     }
     buildSystemPrompt(node) {
-        const rolePrompt = this.config.defaultRolePrompt ?? this.config.flow.defaultRolePrompt ?? '';
+        const includeGlobalPrompt = node.addGlobalPrompt !== false;
+        const rolePrompt = includeGlobalPrompt
+            ? (this.config.defaultRolePrompt ?? this.config.flow.defaultRolePrompt ?? '')
+            : '';
         const renderedPrompt = renderNodePrompt(node.prompt, this.context);
         const dataKeys = Object.keys(this.context.collectedData);
         const dataContext = dataKeys.length > 0
@@ -348,15 +353,19 @@ export class FlowManager {
         const historyContext = this.context.nodeHistory.length > 1
             ? `\n\n## Progress\n${this.context.nodeHistory.slice(0, -1).join(' -> ')} -> **${node.name ?? node.id}**`
             : '';
-        return `${rolePrompt}
-
-## Current Task
-${renderedPrompt}${dataContext}${historyContext}
-
-## Instructions
+        const currentTaskSection = `## Current Task
+${renderedPrompt}${dataContext}${historyContext}`;
+        const instructionsSection = `## Instructions
 - Focus only on the current task
 - Use the available tools to progress the conversation
 - Do not attempt tasks outside your current scope`;
+        const sections = [];
+        if (rolePrompt.trim().length > 0) {
+            sections.push(rolePrompt.trim());
+        }
+        sections.push(currentTaskSection);
+        sections.push(instructionsSection);
+        return sections.join('\n\n');
     }
     async applyContextStrategy(node) {
         const strategy = node.contextStrategy ?? this.config.flow.contextStrategy ?? 'append';
@@ -367,9 +376,11 @@ ${renderedPrompt}${dataContext}${historyContext}
             case 'reset_with_summary':
                 if (this.context.messages.length > 0) {
                     const summary = await this.generateSummary(node);
-                    this.context.messages = [
-                        { role: 'system', content: `Previous conversation summary: ${summary}` },
-                    ];
+                    if (summary && summary.trim().length > 0) {
+                        this.context.messages = [
+                            { role: 'system', content: `Previous conversation summary: ${summary}` },
+                        ];
+                    }
                 }
                 break;
             case 'append':
@@ -382,26 +393,166 @@ ${renderedPrompt}${dataContext}${historyContext}
             ?? this.config.flow.summaryPrompt
             ?? 'Summarize the key points from this conversation in 2-3 sentences.';
         const maxTokens = node.summaryMaxTokens ?? this.config.flow.summaryMaxTokens;
-        const result = await generateText({
-            model: this.config.model,
-            system: prompt,
-            messages: this.context.messages,
-            ...(typeof maxTokens === 'number' ? { maxTokens } : {}),
-            experimental_telemetry: this.config.telemetry,
-        });
-        return result.text;
+        const timeoutMs = node.summaryTimeoutMs ?? this.config.flow.summaryTimeoutMs ?? 5000;
+        try {
+            const generate = async () => {
+                const result = await generateText({
+                    model: this.config.model,
+                    system: prompt,
+                    messages: this.context.messages,
+                    ...(typeof maxTokens === 'number' ? { maxTokens } : {}),
+                    abortSignal: this.config.abortSignal,
+                    experimental_telemetry: this.config.telemetry,
+                });
+                return result.text;
+            };
+            if (timeoutMs <= 0) {
+                return await generate();
+            }
+            let timeoutHandle;
+            const timeout = new Promise(resolve => {
+                timeoutHandle = setTimeout(() => resolve(null), timeoutMs);
+            });
+            const summary = await Promise.race([generate().catch(() => null), timeout]);
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            return summary;
+        }
+        catch {
+            return null;
+        }
+    }
+    normalizeForComparison(value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (Array.isArray(value)) {
+            return value.map(item => this.normalizeForComparison(item));
+        }
+        if (typeof value === 'function') {
+            return '[function]';
+        }
+        if (typeof value === 'object') {
+            const input = value;
+            const sortedKeys = Object.keys(input).sort();
+            const output = {};
+            for (const key of sortedKeys) {
+                output[key] = this.normalizeForComparison(input[key]);
+            }
+            return output;
+        }
+        return value;
+    }
+    isEquivalentPayload(a, b) {
+        return JSON.stringify(this.normalizeForComparison(a)) === JSON.stringify(this.normalizeForComparison(b));
+    }
+    resolvePendingSignals(transitions, handoffs) {
+        if (transitions.length === 0 && handoffs.length === 0) {
+            return {};
+        }
+        if (transitions.length > 0 && handoffs.length > 0) {
+            const transitionTool = transitions[0];
+            const handoffTool = handoffs[0];
+            return {
+                conflict: `Conflicting flow signals: both transition (${transitionTool.targetNode}) and handoff (${handoffTool.targetAgent}) requested in the same turn.`,
+            };
+        }
+        if (handoffs.length > 0) {
+            const first = handoffs[0];
+            for (let i = 1; i < handoffs.length; i++) {
+                const next = handoffs[i];
+                if (next.targetAgent !== first.targetAgent) {
+                    return {
+                        conflict: `Conflicting handoffs requested in the same turn: "${first.targetAgent}" and "${next.targetAgent}".`,
+                    };
+                }
+            }
+            return {
+                handoff: {
+                    targetAgent: first.targetAgent,
+                    reason: first.reason,
+                },
+            };
+        }
+        const firstTransition = transitions[0];
+        for (let i = 1; i < transitions.length; i++) {
+            const next = transitions[i];
+            if (next.targetNode !== firstTransition.targetNode) {
+                return {
+                    conflict: `Conflicting transitions requested in the same turn: "${firstTransition.targetNode}" and "${next.targetNode}".`,
+                };
+            }
+            if (!this.isEquivalentPayload(next.data, firstTransition.data)) {
+                return {
+                    conflict: `Conflicting transition payloads for node "${firstTransition.targetNode}" in the same turn.`,
+                };
+            }
+            if ((next.node?.id ?? null) !== (firstTransition.node?.id ?? null)) {
+                return {
+                    conflict: `Conflicting dynamic node definitions for transition target "${firstTransition.targetNode}" in the same turn.`,
+                };
+            }
+        }
+        return {
+            transition: {
+                targetNode: firstTransition.targetNode,
+                data: firstTransition.data,
+                node: firstTransition.node,
+            },
+        };
     }
     resolveTools(node) {
-        if (!node.tools)
+        const implicitTools = this.buildImplicitTransitionTools(node);
+        let explicitTools = {};
+        if (node.tools) {
+            explicitTools =
+                typeof node.tools === 'function'
+                    ? (node.tools(this.context) ?? {})
+                    : node.tools;
+        }
+        // Explicit node tools win on name collision to preserve backwards compatibility.
+        return this.wrapTools({
+            ...implicitTools,
+            ...explicitTools,
+        });
+    }
+    buildImplicitTransitionTools(node) {
+        const transitions = this.transitions.get(node.id) ?? [];
+        if (transitions.length === 0) {
             return {};
-        if (typeof node.tools === 'function') {
-            return this.wrapTools(node.tools(this.context) ?? {});
         }
-        return this.wrapTools(node.tools);
+        const implicitTools = {};
+        const seenNames = new Set();
+        for (const transition of transitions) {
+            const eventName = typeof transition.on === 'string' ? transition.on.trim() : '';
+            if (!eventName || seenNames.has(eventName)) {
+                continue;
+            }
+            seenNames.add(eventName);
+            const label = transition.contract?.label?.trim();
+            const conditionText = transition.contract?.conditionText?.trim();
+            const descriptionParts = [
+                `Transition from "${node.id}" to "${transition.to}".`,
+                label ? `Label: ${label}.` : '',
+                conditionText ? `Condition: ${conditionText}.` : '',
+                'Call only when transition criteria are satisfied.',
+            ].filter(Boolean);
+            implicitTools[eventName] = tool({
+                description: descriptionParts.join(' '),
+                inputSchema: implicitTransitionToolInputSchema,
+                execute: async (input) => createFlowTransition(transition.to, input.data, input.message),
+            });
+        }
+        return implicitTools;
     }
     wrapTools(tools) {
         const guard = this.config.toolCallGuard;
-        if (!guard)
+        const optionsFactory = this.config.toolExecutionOptionsFactory;
+        if (!guard && !optionsFactory)
             return tools;
         const wrapped = {};
         for (const [toolName, toolDef] of Object.entries(tools ?? {})) {
@@ -412,51 +563,72 @@ ${renderedPrompt}${dataContext}${historyContext}
             }
             wrapped[toolName] = {
                 ...toolDef,
-                execute: async (args) => {
-                    const decision = await guard({ toolName, args });
-                    if (!decision.allowed) {
-                        throw new Error(decision.reason || 'Tool call blocked');
+                execute: async (args, options) => {
+                    const toolCallId = typeof options?.toolCallId === 'string' ? options.toolCallId : undefined;
+                    if (guard) {
+                        const decision = await guard({ toolName, args, toolCallId });
+                        if (!decision.allowed) {
+                            throw new Error(decision.reason || 'Tool call blocked');
+                        }
                     }
-                    return exec(args);
+                    const extraContext = optionsFactory?.({ toolName, args, toolCallId });
+                    const mergedOptions = mergeToolExecutionOptions(options, extraContext);
+                    return exec(args, mergedOptions);
                 },
             };
         }
         return wrapped;
     }
-    appendMessage(message, persistToSession = true) {
+    appendMessage(message) {
         const normalized = this.normalizeMessage(message);
         if (!normalized) {
             return;
         }
         this.context.messages.push(normalized);
-        if (persistToSession && this.sessionMessages && this.sessionMessages !== this.context.messages) {
-            this.sessionMessages.push(normalized);
-        }
     }
     normalizeMessage(message) {
-        // Keep only simple string messages in history to avoid provider-specific structured parts
-        // causing failures on subsequent turns. Tool results are already reflected in collectedData.
-        const role = message.role;
-        if (role === 'tool') {
-            return null;
-        }
-        const content = message.content;
-        if (typeof content === 'string') {
-            return message;
-        }
-        if (Array.isArray(content)) {
-            const text = content
-                .map((p) => (p && typeof p === 'object' && p.type === 'text' ? String(p.text ?? '') : ''))
-                .join('')
-                .trim();
-            if (text.length === 0) {
-                return null;
+        return normalizeModelMessage(message);
+    }
+    async *runActions(actions) {
+        for (const action of actions) {
+            if (action.deferUntil === 'turn-end') {
+                this.deferredActions.push(action);
+                continue;
+            }
+            switch (action.type) {
+                case 'say':
+                    yield { type: 'text-delta', text: action.text };
+                    break;
+                case 'end':
+                    this.flowEnded = true;
+                    yield { type: 'flow-end', reason: action.reason ?? 'action' };
+                    break;
+                case 'function':
+                    await action.handler(this.context);
+                    break;
+                case 'emit':
+                    this.pendingEvents.push({ name: action.event, data: action.data });
+                    yield {
+                        type: 'custom',
+                        name: action.event,
+                        data: action.data,
+                        timestamp: new Date(),
+                    };
+                    break;
+                default:
+                    break;
             }
-            return { role, content: text };
         }
-        return null;
     }
-    async *runActions(actions) {
+    async *flushDeferredActions() {
+        if (this.deferredActions.length === 0) {
+            return;
+        }
+        const actions = this.deferredActions;
+        this.deferredActions = [];
+        if (this.flowEnded) {
+            return;
+        }
         for (const action of actions) {
             switch (action.type) {
                 case 'say':
@@ -471,24 +643,57 @@ ${renderedPrompt}${dataContext}${historyContext}
                     break;
                 case 'emit':
                     this.pendingEvents.push({ name: action.event, data: action.data });
+                    yield {
+                        type: 'custom',
+                        name: action.event,
+                        data: action.data,
+                        timestamp: new Date(),
+                    };
                     break;
                 default:
                     break;
             }
+            if (this.flowEnded) {
+                return;
+            }
         }
     }
-    async evaluateTransitions() {
+    checkTransitionPolicy(currentNodeId, targetNodeId, source, triggeredByUserTurn) {
+        const candidates = (this.transitions.get(currentNodeId) ?? []).filter(transition => transition.to === targetNodeId);
+        const candidate = candidates.find(transition => transition.contract) ?? candidates[0];
+        const contract = candidate?.contract;
+        if (!contract) {
+            return null;
+        }
+        if (contract.toolOnly && source === 'condition') {
+            return `Transition "${currentNodeId}" -> "${targetNodeId}" is blocked: contract.toolOnly=true requires a tool/event signal.`;
+        }
+        if (contract.requiresUserTurn && !triggeredByUserTurn) {
+            return `Transition "${currentNodeId}" -> "${targetNodeId}" is blocked: contract.requiresUserTurn=true requires a user turn before transition.`;
+        }
+        return null;
+    }
+    async evaluateTransitions(triggeredByUserTurn) {
         const currentNode = this.currentNodeConfig?.id;
         if (!currentNode) {
-            return null;
+            return {};
         }
         const transitions = this.transitions.get(currentNode) ?? [];
         if (this.pendingEvents.length > 0) {
             for (const [index, event] of this.pendingEvents.entries()) {
                 const match = transitions.find(transition => transition.on === event.name);
                 if (match) {
+                    const policy = this.checkTransitionPolicy(currentNode, match.to, 'event', triggeredByUserTurn);
                     this.pendingEvents.splice(index, 1);
-                    return { targetNode: match.to, data: event.data };
+                    if (policy) {
+                        return { blockedError: policy };
+                    }
+                    return {
+                        transition: {
+                            targetNode: match.to,
+                            data: event.data,
+                        },
+                    };
                 }
             }
         }
@@ -498,10 +703,33 @@ ${renderedPrompt}${dataContext}${historyContext}
             }
             const shouldTransition = await transition.condition(this.context);
             if (shouldTransition) {
-                return { targetNode: transition.to };
+                const policy = this.checkTransitionPolicy(currentNode, transition.to, 'condition', triggeredByUserTurn);
+                if (policy) {
+                    return { blockedError: policy };
+                }
+                return { transition: { targetNode: transition.to } };
             }
         }
-        return null;
+        return {};
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function mergeToolExecutionOptions(options, extraContext) {
+    if (!extraContext || Object.keys(extraContext).length === 0) {
+        return options;
     }
+    const baseOptions = isRecord(options) ? options : {};
+    const existingContext = isRecord(baseOptions.experimental_context)
+        ? baseOptions.experimental_context
+        : {};
+    return {
+        ...baseOptions,
+        experimental_context: {
+            ...existingContext,
+            ...extraContext,
+        },
+    };
 }
 //# sourceMappingURL=FlowManager.js.map