@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

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

@@ -1,138 +0,0 @@
-/**
- * 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

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

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

@@ -1,263 +0,0 @@
-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

@@ -1,161 +0,0 @@
-/**
- * @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