@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/core/src/env/workflow/utils/session-recovery.js

@@ -0,0 +1,138 @@
+/**
+ * Session Recovery Utilities
+ *
+ * Utilities for inferring the next execution point from session messages.
+ * This is the core of the unified run/resume mechanism.
+ */
+/**
+ * Infer the next node to execute based on session messages
+ *
+ * Decision logic:
+ * - No messages → execute entry node
+ * - Last = workflow.node.call → resume this node (incomplete)
+ * - Last = workflow.node.interrupt → resume this node (ask_user)
+ * - Last = workflow.node.result → execute next nodes from DAG
+ * - Unknown → find last call, resume it, or fallback to entry
+ */
+export function inferNextNode(messages, definition) {
+    if (messages.length === 0) {
+        // First run - execute entry node
+        return { type: 'entry_node', nodeId: definition.entryNode };
+    }
+    const lastMessage = messages[messages.length - 1];
+    const metadata = lastMessage.metadata;
+    switch (metadata?.type) {
+        case 'workflow.node.call':
+            // Node was interrupted (not completed)
+            return {
+                type: 'resume_node',
+                nodeId: metadata.workflowNodeId,
+                agentSessionId: metadata.agentSessionId,
+            };
+        case 'workflow.node.interrupt':
+            // Ask_user or ESC interrupted
+            return {
+                type: 'ask_user',
+                nodeId: metadata.workflowNodeId,
+                agentSessionId: metadata.agentSessionId,
+            };
+        case 'workflow.node.result':
+            // Node completed, get next from DAG
+            return getNextNodes(metadata.workflowNodeId, definition);
+        default:
+            // Unknown message type, try to find last call
+            const lastCall = findLastCallMessage(messages);
+            if (lastCall) {
+                const callMetadata = lastCall.metadata;
+                return {
+                    type: 'resume_node',
+                    nodeId: callMetadata.workflowNodeId,
+                    agentSessionId: callMetadata.agentSessionId,
+                };
+            }
+            // No call found, fallback to entry
+            return { type: 'entry_node', nodeId: definition.entryNode };
+    }
+}
+/**
+ * Get next nodes from DAG edges
+ */
+function getNextNodes(completedNodeId, definition) {
+    if (!definition.edges) {
+        return { type: 'next_nodes', nodeIds: [] };
+    }
+    const nextNodeIds = definition.edges
+        .filter(edge => edge.from === completedNodeId)
+        .map(edge => edge.to);
+    return { type: 'next_nodes', nodeIds: nextNodeIds };
+}
+/**
+ * Find the last interrupt message in the session
+ */
+export function findLastInterruptMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.metadata?.type === 'workflow.node.interrupt') {
+            return msg;
+        }
+    }
+    return null;
+}
+/**
+ * Find the last call message in the session
+ */
+export function findLastCallMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.metadata?.type === 'workflow.node.call') {
+            return msg;
+        }
+    }
+    return null;
+}
+/**
+ * Parse node outputs from session messages
+ *
+ * Extracts outputs by matching workflow.node.call with workflow.node.result pairs
+ */
+export function parseNodeOutputs(messages) {
+    const outputs = new Map();
+    let lastCallNodeId = null;
+    for (const msg of messages) {
+        const metadata = msg.metadata;
+        if (metadata?.type === 'workflow.node.call') {
+            lastCallNodeId = metadata.workflowNodeId;
+        }
+        else if (metadata?.type === 'workflow.node.result' && lastCallNodeId) {
+            try {
+                outputs.set(lastCallNodeId, JSON.parse(msg.content));
+            }
+            catch {
+                outputs.set(lastCallNodeId, msg.content);
+            }
+            lastCallNodeId = null;
+        }
+    }
+    return outputs;
+}
+/**
+ * Check if session has pending ask_user interrupt
+ */
+export function hasPendingAskUser(messages) {
+    if (messages.length === 0)
+        return false;
+    const lastMessage = messages[messages.length - 1];
+    const metadata = lastMessage.metadata;
+    return metadata?.type === 'workflow.node.interrupt';
+}
+/**
+ * Get agent session ID from last interrupt message
+ */
+export function getAgentSessionIdFromInterrupt(messages) {
+    const lastInterrupt = findLastInterruptMessage(messages);
+    if (!lastInterrupt)
+        return null;
+    const metadata = lastInterrupt.metadata;
+    return metadata?.agentSessionId || null;
+}
+//# sourceMappingURL=session-recovery.js.map

package/dist/core/src/env/workflow/utils/session-recovery.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-recovery.test.d.ts.map

package/dist/core/src/env/workflow/utils/session-recovery.test.js

@@ -0,0 +1,263 @@
+import { describe, it, expect } from 'vitest';
+import { inferNextNode, findLastInterruptMessage, findLastCallMessage, parseNodeOutputs, } from "./session-recovery.js";
+function createMessage(role, content, metadata) {
+    return { role, content, metadata };
+}
+describe('inferNextNode', () => {
+    describe('when no messages', () => {
+        it('should return entry node from definition', () => {
+            const messages = [];
+            const definition = {
+                entryNode: 'node_A',
+                nodes: { node_A: { id: 'node_A' } },
+            };
+            const result = inferNextNode(messages, definition);
+            expect(result.type).toBe('entry_node');
+            expect(result.nodeId).toBe('node_A');
+        });
+        it('should handle missing entryNode', () => {
+            const messages = [];
+            const definition = {};
+            const result = inferNextNode(messages, definition);
+            expect(result.type).toBe('entry_node');
+            expect(result.nodeId).toBeUndefined();
+        });
+    });
+    describe('when last message is workflow.node.call', () => {
+        it('should return resume_node type with nodeId', () => {
+            const messages = [
+                createMessage('workflow.node.call', '{}', {
+                    type: 'workflow.node.call',
+                    workflowNodeId: 'node_A',
+                    workflowNodeType: 'tool',
+                }),
+            ];
+            const result = inferNextNode(messages, {});
+            expect(result.type).toBe('resume_node');
+            expect(result.nodeId).toBe('node_A');
+        });
+        it('should include agentSessionId if present', () => {
+            const messages = [
+                createMessage('workflow.node.call', '{}', {
+                    type: 'workflow.node.call',
+                    workflowNodeId: 'agent_1',
+                    workflowNodeType: 'agent',
+                    agentSessionId: 'agent_agent_1_123',
+                }),
+            ];
+            const result = inferNextNode(messages, {});
+            expect(result.type).toBe('resume_node');
+            expect(result.nodeId).toBe('agent_1');
+            expect(result.agentSessionId).toBe('agent_agent_1_123');
+        });
+    });
+    describe('when last message is workflow.node.interrupt', () => {
+        it('should return ask_user type with nodeId', () => {
+            const messages = [
+                createMessage('workflow.node.interrupt', 'Continue?', {
+                    type: 'workflow.node.interrupt',
+                    workflowNodeId: 'ask_user_1',
+                    workflowNodeType: 'ask_user',
+                    query: 'Continue?',
+                }),
+            ];
+            const result = inferNextNode(messages, {});
+            expect(result.type).toBe('ask_user');
+            expect(result.nodeId).toBe('ask_user_1');
+        });
+        it('should include agentSessionId if present', () => {
+            const messages = [
+                createMessage('workflow.node.interrupt', 'Confirm?', {
+                    type: 'workflow.node.interrupt',
+                    workflowNodeId: 'agent_1',
+                    workflowNodeType: 'agent',
+                    query: 'Confirm?',
+                    agentSessionId: 'agent_agent_1_456',
+                }),
+            ];
+            const result = inferNextNode(messages, {});
+            expect(result.type).toBe('ask_user');
+            expect(result.nodeId).toBe('agent_1');
+            expect(result.agentSessionId).toBe('agent_agent_1_456');
+        });
+    });
+    describe('when last message is workflow.node.result', () => {
+        it('should return next_nodes from DAG edges', () => {
+            const messages = [
+                createMessage('workflow.node.call', '{}', {
+                    type: 'workflow.node.call',
+                    workflowNodeId: 'node_A',
+                }),
+                createMessage('workflow.node.result', '{"output":"done"}', {
+                    type: 'workflow.node.result',
+                    workflowNodeId: 'node_A',
+                    workflowNodeType: 'tool',
+                    success: true,
+                }),
+            ];
+            const definition = {
+                edges: [
+                    { from: 'node_A', to: 'node_B' },
+                    { from: 'node_A', to: 'node_C' },
+                ],
+            };
+            const result = inferNextNode(messages, definition);
+            expect(result.type).toBe('next_nodes');
+            expect(result.nodeIds).toEqual(['node_B', 'node_C']);
+        });
+        it('should return empty array if no edges from node', () => {
+            const messages = [
+                createMessage('workflow.node.result', '{"output":"done"}', {
+                    type: 'workflow.node.result',
+                    workflowNodeId: 'node_A',
+                    success: true,
+                }),
+            ];
+            const definition = {
+                edges: [
+                    { from: 'node_B', to: 'node_C' },
+                ],
+            };
+            const result = inferNextNode(messages, definition);
+            expect(result.type).toBe('next_nodes');
+            expect(result.nodeIds).toEqual([]);
+        });
+        it('should return empty array if no edges defined', () => {
+            const messages = [
+                createMessage('workflow.node.result', '{"output":"done"}', {
+                    type: 'workflow.node.result',
+                    workflowNodeId: 'node_A',
+                    success: true,
+                }),
+            ];
+            const result = inferNextNode(messages, {});
+            expect(result.type).toBe('next_nodes');
+            expect(result.nodeIds).toEqual([]);
+        });
+    });
+    describe('when last message has unknown type', () => {
+        it('should find last call message and resume', () => {
+            const messages = [
+                createMessage('user', 'hello', {}),
+                createMessage('workflow.node.call', '{}', {
+                    type: 'workflow.node.call',
+                    workflowNodeId: 'node_A',
+                }),
+                createMessage('system', 'some status', {
+                    type: 'unknown',
+                }),
+            ];
+            const result = inferNextNode(messages, {});
+            expect(result.type).toBe('resume_node');
+            expect(result.nodeId).toBe('node_A');
+        });
+        it('should fallback to entry node if no call found', () => {
+            const messages = [
+                createMessage('user', 'hello', {}),
+            ];
+            const definition = { entryNode: 'start' };
+            const result = inferNextNode(messages, definition);
+            expect(result.type).toBe('entry_node');
+            expect(result.nodeId).toBe('start');
+        });
+    });
+});
+describe('findLastInterruptMessage', () => {
+    it('should return last interrupt message', () => {
+        const messages = [
+            createMessage('workflow.node.call', '{}', { type: 'workflow.node.call' }),
+            createMessage('workflow.node.result', '{}', { type: 'workflow.node.result' }),
+            createMessage('workflow.node.interrupt', 'Continue?', {
+                type: 'workflow.node.interrupt',
+                workflowNodeId: 'ask_1',
+            }),
+        ];
+        const result = findLastInterruptMessage(messages);
+        expect(result).not.toBeNull();
+        expect(result.metadata.workflowNodeId).toBe('ask_1');
+    });
+    it('should return null if no interrupt message', () => {
+        const messages = [
+            createMessage('workflow.node.call', '{}', { type: 'workflow.node.call' }),
+            createMessage('workflow.node.result', '{}', { type: 'workflow.node.result' }),
+        ];
+        const result = findLastInterruptMessage(messages);
+        expect(result).toBeNull();
+    });
+    it('should return null for empty array', () => {
+        const result = findLastInterruptMessage([]);
+        expect(result).toBeNull();
+    });
+});
+describe('findLastCallMessage', () => {
+    it('should return last call message', () => {
+        const messages = [
+            createMessage('workflow.node.call', '{}', {
+                type: 'workflow.node.call',
+                workflowNodeId: 'node_A',
+            }),
+            createMessage('workflow.node.call', '{}', {
+                type: 'workflow.node.call',
+                workflowNodeId: 'node_B',
+            }),
+        ];
+        const result = findLastCallMessage(messages);
+        expect(result).not.toBeNull();
+        expect(result.metadata.workflowNodeId).toBe('node_B');
+    });
+    it('should return null if no call message', () => {
+        const messages = [
+            createMessage('user', 'hello', {}),
+            createMessage('workflow.node.result', '{}', { type: 'workflow.node.result' }),
+        ];
+        const result = findLastCallMessage(messages);
+        expect(result).toBeNull();
+    });
+});
+describe('parseNodeOutputs', () => {
+    it('should parse outputs from call-result pairs', () => {
+        const messages = [
+            createMessage('workflow.node.call', '{}', {
+                type: 'workflow.node.call',
+                workflowNodeId: 'node_A',
+            }),
+            createMessage('workflow.node.result', '{"output":"result_A"}', {
+                type: 'workflow.node.result',
+                workflowNodeId: 'node_A',
+            }),
+            createMessage('workflow.node.call', '{}', {
+                type: 'workflow.node.call',
+                workflowNodeId: 'node_B',
+            }),
+            createMessage('workflow.node.result', '{"output":"result_B"}', {
+                type: 'workflow.node.result',
+                workflowNodeId: 'node_B',
+            }),
+        ];
+        const result = parseNodeOutputs(messages);
+        expect(result.get('node_A')).toEqual({ output: 'result_A' });
+        expect(result.get('node_B')).toEqual({ output: 'result_B' });
+    });
+    it('should handle JSON parse error gracefully', () => {
+        const messages = [
+            createMessage('workflow.node.call', '{}', {
+                type: 'workflow.node.call',
+                workflowNodeId: 'node_A',
+            }),
+            createMessage('workflow.node.result', 'not json', {
+                type: 'workflow.node.result',
+                workflowNodeId: 'node_A',
+            }),
+        ];
+        const result = parseNodeOutputs(messages);
+        expect(result.get('node_A')).toBe('not json');
+    });
+    it('should return empty map for no outputs', () => {
+        const messages = [
+            createMessage('user', 'hello', {}),
+        ];
+        const result = parseNodeOutputs(messages);
+        expect(result.size).toBe(0);
+    });
+});
+//# sourceMappingURL=session-recovery.test.js.map

package/dist/core/src/env/workflow/utils/template-resolver.d.ts

@@ -0,0 +1,161 @@
+/**
+ * @fileoverview Template Resolver - Unified template resolution for workflow nodes
+ *
+ * This module provides a unified template resolution system for workflow nodes.
+ * Templates are in the format {{path}} where path can reference:
+ *
+ * - Input variables: {{input.key}} or {{input.key.nested}}
+ * - Node outputs: {{nodeId}} or {{nodeId.output}} or {{nodeId.output.path}}
+ * - With prefix: {{nodes.nodeId}} or {{nodes.nodeId.output.path}}
+ *
+ * @example
+ * ```typescript
+ * const resolver = new TemplateResolver({
+ *   input: { query: 'weather' },
+ *   previousOutputs: new Map([
+ *     ['fetch', { data: { temp: 25, condition: 'sunny' } }]
+ *   ])
+ * });
+ *
+ * resolver.resolve('Weather in {{input.query}}: {{nodes.fetch.data.condition}}');
+ * // => 'Weather in weather: sunny'
+ * ```
+ */
+import type { NodeExecutionContext } from '../types';
+/**
+ * Template resolution options
+ */
+export interface TemplateResolverOptions {
+    /** Input passed to the workflow/node */
+    input?: Record<string, unknown>;
+    /** Map of previous node outputs */
+    previousOutputs?: Map<string, unknown>;
+}
+/**
+ * Result of template resolution
+ */
+export interface ResolvedValue {
+    /** Whether the value was resolved */
+    resolved: boolean;
+    /** The resolved value */
+    value: unknown;
+}
+/**
+ * TemplateResolver
+ *
+ * Resolves template strings that reference workflow inputs and node outputs.
+ */
+export declare class TemplateResolver {
+    private input;
+    private previousOutputs;
+    constructor(options?: TemplateResolverOptions);
+    /**
+     * Create a TemplateResolver from NodeExecutionContext
+     *
+     * @param context - Node execution context
+     * @returns TemplateResolver instance
+     */
+    static fromContext(context: NodeExecutionContext): TemplateResolver;
+    /**
+     * Resolve template references in an input value.
+     *
+     * Handles:
+     * - Primitive values (returned as-is)
+     * - Objects (recursively resolved)
+     * - Arrays (recursively resolved)
+     * - Strings (template resolution)
+     *
+     * Key behavior for template strings:
+     * - If the string is a pure template reference (e.g., "{{nodes.fetch}}"),
+     *   the resolved value is returned as-is (preserving objects/arrays)
+     * - If the string contains text + templates (e.g., "Hello {{name}}"),
+     *   returns a string with interpolated values
+     *
+     * @param input - Input value that may contain template strings
+     * @returns Input with template references resolved
+     */
+    resolveValue(input: unknown): unknown;
+    /**
+     * Check if a string is a pure template reference (starts with {{ and ends with }})
+     * @param str - String to check
+     * @returns The template content if pure, null otherwise
+     */
+    private extractPureTemplate;
+    /**
+     * Resolve a pure template reference and return the value as-is.
+     * @param templateContent - Content between {{ and }}
+     * @returns The resolved value (may be object, array, or primitive)
+     */
+    private resolvePureTemplate;
+    /**
+     * Resolve template content (the part inside {{ }}) and return the value.
+     * @param templateContent - The path to resolve (e.g., "input.key", "nodes.fetch.data")
+     * @returns The resolved value
+     */
+    private resolveTemplateContent;
+    /**
+     * Resolve a single template string.
+     *
+     * Supports patterns:
+     * - {{input.key}} - Input variable
+     * - {{nodeId}} - Node's entire output
+     * - {{nodeId.output}} - Node's output property
+     * - {{nodeId.output.path}} - Node's nested output property
+     * - {{nodes.nodeId}} - Node's entire output (with prefix)
+     * - {{nodes.nodeId.output.path}} - Node's nested property (with prefix)
+     *
+     * @param template - Template string to resolve
+     * @returns Resolved string
+     */
+    resolveString(template: string): string;
+    /**
+     * Resolve a node output path.
+     *
+     * @param path - Path like "nodeId" or "nodeId.output" or "nodeId.output.path"
+     * @returns The resolved value or undefined
+     */
+    private resolveNodePath;
+    /**
+     * Get a nested value from an object using dot notation.
+     *
+     * @param obj - Object to traverse
+     * @param path - Dot-separated path
+     * @returns The nested value or undefined
+     */
+    private getNestedValue;
+    /**
+     * Convert a value to string, or return the original template if value is undefined.
+     */
+    private stringify;
+    /**
+     * Check if a string contains template references.
+     *
+     * @param str - String to check
+     * @returns True if the string contains template references
+     */
+    containsTemplates(str: string): boolean;
+    /**
+     * Extract all template references from a string.
+     *
+     * @param str - String to extract from
+     * @returns Array of template references
+     */
+    extractTemplates(str: string): string[];
+}
+/**
+ * Resolve template references in input using context.
+ *
+ * @param input - Input value with potential templates
+ * @param context - Node execution context
+ * @returns Resolved input
+ */
+export declare function resolveTemplates(input: unknown, context: NodeExecutionContext): unknown;
+/**
+ * Resolve a template string using context.
+ *
+ * @param template - Template string
+ * @param context - Node execution context
+ * @returns Resolved string
+ */
+export declare function resolveTemplateString(template: string, context: NodeExecutionContext): string;
+//# sourceMappingURL=template-resolver.d.ts.map