@ai-setting/roy-agent-core 1.3.10 → 1.3.14

package/src/env/workflow/utils/template-resolver.test.ts

@@ -1,258 +0,0 @@
-import { describe, test, expect, beforeEach } from 'vitest';
-import { TemplateResolver } from './template-resolver';
-import type { NodeExecutionContext } from '../types';
-
-describe('TemplateResolver', () => {
-  let resolver: TemplateResolver;
-
-  beforeEach(() => {
-    resolver = new TemplateResolver({
-      input: { query: 'weather', city: 'Beijing' },
-      previousOutputs: new Map([
-        ['fetch', { data: { temp: 25, condition: 'sunny', items: [1, 2, 3] } }],
-        ['process', { result: 'processed', score: 0.95 }],
-        ['agent', { result: { summary: 'Great day!', metadata: { source: 'weather-api' } }, metadata: { tokens: 100 } }],
-      ]),
-    });
-  });
-
-  describe('resolveString', () => {
-    test('should return primitive values unchanged', () => {
-      expect(resolver.resolveString('hello')).toBe('hello');
-      expect(resolver.resolveString('123')).toBe('123');
-      expect(resolver.resolveString('')).toBe('');
-    });
-
-    test('should resolve input references with prefix', () => {
-      expect(resolver.resolveString('Query: {{input.query}}')).toBe('Query: weather');
-      expect(resolver.resolveString('City: {{input.city}}')).toBe('City: Beijing');
-    });
-
-    test('should resolve nested input references', () => {
-      resolver = new TemplateResolver({
-        input: { user: { profile: { name: 'John' } } },
-      });
-      expect(resolver.resolveString('Name: {{input.user.profile.name}}')).toBe('Name: John');
-    });
-
-    test('should resolve node output with prefix', () => {
-      expect(resolver.resolveString('Condition: {{nodes.fetch}}')).toBe('Condition: {"data":{"temp":25,"condition":"sunny","items":[1,2,3]}}');
-      expect(resolver.resolveString('Temp: {{nodes.fetch.data.temp}}')).toBe('Temp: 25');
-      expect(resolver.resolveString('Condition: {{nodes.fetch.data.condition}}')).toBe('Condition: sunny');
-    });
-
-    test('should resolve node output without prefix (backward compatibility)', () => {
-      expect(resolver.resolveString('Temp: {{fetch.data.temp}}')).toBe('Temp: 25');
-      expect(resolver.resolveString('Condition: {{fetch.data.condition}}')).toBe('Condition: sunny');
-    });
-
-    test('should resolve agent node result', () => {
-      // Bare {{agent}} extracts the result field from AgentNode output format
-      expect(resolver.resolveString('Summary: {{agent}}')).toBe('Summary: {"summary":"Great day!","metadata":{"source":"weather-api"}}');
-      // Explicit {{agent.result}} also works
-      expect(resolver.resolveString('Summary: {{agent.result.summary}}')).toBe('Summary: Great day!');
-      // Can also access metadata directly
-      expect(resolver.resolveString('Tokens: {{agent.metadata.tokens}}')).toBe('Tokens: 100');
-    });
-
-    test('should resolve multiple templates in one string', () => {
-      expect(resolver.resolveString('Query: {{input.query}}, Condition: {{nodes.fetch.data.condition}}'))
-        .toBe('Query: weather, Condition: sunny');
-    });
-
-    test('should leave unresolved templates unchanged', () => {
-      expect(resolver.resolveString('Missing: {{nodes.nonexistent}}')).toBe('Missing: {{nodes.nonexistent}}');
-      expect(resolver.resolveString('Missing: {{nonexistent}}')).toBe('Missing: {{nonexistent}}');
-    });
-
-    test('should handle empty template', () => {
-      expect(resolver.resolveString('Empty: {{}}')).toBe('Empty: {{}}');
-    });
-  });
-
-  describe('resolveValue', () => {
-    test('should resolve string values', () => {
-      expect(resolver.resolveValue('Temperature: {{nodes.fetch.data.temp}}°C'))
-        .toBe('Temperature: 25°C');
-    });
-
-    test('should resolve object values', () => {
-      const result = resolver.resolveValue({
-        query: '{{input.query}}',
-        temp: '{{nodes.fetch.data.temp}}',
-      });
-      expect(result).toEqual({
-        query: 'weather',
-        temp: 25,  // Pure template references preserve original types
-      });
-    });
-
-    test('should resolve array values', () => {
-      const result = resolver.resolveValue([
-        '{{input.query}}',
-        '{{nodes.fetch.data.condition}}',
-        'static',
-      ]);
-      expect(result).toEqual(['weather', 'sunny', 'static']);
-    });
-
-    test('should resolve nested structures', () => {
-      const result = resolver.resolveValue({
-        level1: {
-          level2: '{{input.query}}',
-          items: ['{{input.city}}', '{{nodes.fetch.data.temp}}'],
-        },
-      });
-      expect(result).toEqual({
-        level1: {
-          level2: 'weather',
-          items: ['Beijing', 25],  // Pure template references preserve original types
-        },
-      });
-    });
-
-    test('should handle null and undefined', () => {
-      expect(resolver.resolveValue(null)).toBe(null);
-      expect(resolver.resolveValue(undefined)).toBe(undefined);
-    });
-  });
-
-  describe('containsTemplates', () => {
-    test('should detect templates in strings', () => {
-      expect(resolver.containsTemplates('{{input.query}}')).toBe(true);
-      expect(resolver.containsTemplates('Query: {{input.query}}')).toBe(true);
-      expect(resolver.containsTemplates('No templates')).toBe(false);
-    });
-
-    test('should return false for non-strings', () => {
-      expect(resolver.containsTemplates(123 as any)).toBe(false);
-      expect(resolver.containsTemplates(null)).toBe(false);
-    });
-  });
-
-  describe('extractTemplates', () => {
-    test('should extract all template references', () => {
-      const templates = resolver.extractTemplates(
-        'Query: {{input.query}}, Temp: {{nodes.fetch.data.temp}}'
-      );
-      expect(templates).toEqual(['{{input.query}}', '{{nodes.fetch.data.temp}}']);
-    });
-
-    test('should return empty array for strings without templates', () => {
-      expect(resolver.extractTemplates('No templates')).toEqual([]);
-    });
-  });
-
-  describe('fromContext', () => {
-    test('should create resolver from NodeExecutionContext', () => {
-      const context: NodeExecutionContext = {
-        runId: 'run_123',
-        workflowName: 'test-workflow',
-        nodeId: 'test-node',
-        input: { key: 'value' },
-        previousOutputs: new Map([['prev', { out: 'result' }]]),
-        config: {},
-        debug: false,
-        eventBus: {} as any,
-        nodeOutputs: new Map(),
-      };
-
-      const contextResolver = TemplateResolver.fromContext(context);
-      expect(contextResolver.resolveString('{{input.key}}')).toBe('value');
-      expect(contextResolver.resolveString('{{prev.out}}')).toBe('result');
-    });
-  });
-});
-
-describe('TemplateResolver Edge Cases', () => {
-  test('should handle complex nested paths', () => {
-    const resolver = new TemplateResolver({
-      previousOutputs: new Map([
-        ['node', { a: { b: { c: { d: 'deep value' } } } }],
-      ]),
-    });
-
-    expect(resolver.resolveString('{{node.a.b.c.d}}')).toBe('deep value');
-  });
-
-  test('should handle arrays in path', () => {
-    const resolver = new TemplateResolver({
-      previousOutputs: new Map([
-        ['node', { items: [{ name: 'item1' }, { name: 'item2' }] }],
-      ]),
-    });
-
-    expect(resolver.resolveString('{{node.items.0.name}}')).toBe('item1');
-    expect(resolver.resolveString('{{node.items.1.name}}')).toBe('item2');
-  });
-
-  test('should handle special characters in values', () => {
-    const resolver = new TemplateResolver({
-      previousOutputs: new Map([
-        ['node', { special: 'value with "quotes" and \'apostrophes\'' }],
-      ]),
-    });
-
-    expect(resolver.resolveString('{{node.special}}')).toBe('value with "quotes" and \'apostrophes\'');
-  });
-
-  test('should handle numeric values', () => {
-    const resolver = new TemplateResolver({
-      previousOutputs: new Map([
-        ['node', { count: 42, ratio: 0.5, negative: -10 }],
-      ]),
-    });
-
-    expect(resolver.resolveString('Count: {{node.count}}')).toBe('Count: 42');
-    expect(resolver.resolveString('Ratio: {{node.ratio}}')).toBe('Ratio: 0.5');
-    expect(resolver.resolveString('Negative: {{node.negative}}')).toBe('Negative: -10');
-  });
-
-  test('should handle boolean values', () => {
-    const resolver = new TemplateResolver({
-      previousOutputs: new Map([
-        ['node', { active: true, deleted: false }],
-      ]),
-    });
-
-    expect(resolver.resolveString('Active: {{node.active}}')).toBe('Active: true');
-    expect(resolver.resolveString('Deleted: {{node.deleted}}')).toBe('Deleted: false');
-  });
-
-  test('should handle empty previousOutputs map', () => {
-    const resolver = new TemplateResolver({
-      previousOutputs: new Map(),
-    });
-
-    expect(resolver.resolveString('{{node.output}}')).toBe('{{node.output}}');
-    expect(resolver.resolveString('Missing: {{nodes.nodeId}}')).toBe('Missing: {{nodes.nodeId}}');
-  });
-
-  test('should handle null values in chain', () => {
-    const resolver = new TemplateResolver({
-      previousOutputs: new Map([
-        ['node', { a: null }],
-      ]),
-    });
-
-    expect(resolver.resolveString('{{node.a.b}}')).toBe('{{node.a.b}}');
-  });
-
-  test('should handle undefined intermediate values', () => {
-    const resolver = new TemplateResolver({
-      previousOutputs: new Map([
-        ['node', { a: undefined }],
-      ]),
-    });
-
-    expect(resolver.resolveString('{{node.a.b}}')).toBe('{{node.a.b}}');
-  });
-
-  test('should handle missing node', () => {
-    const resolver = new TemplateResolver({
-      previousOutputs: new Map(),
-    });
-
-    expect(resolver.resolveString('Value: {{missing.value}}')).toBe('Value: {{missing.value}}');
-  });
-});

package/src/env/workflow/utils/template-resolver.ts

@@ -1,436 +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';
-
-// ============================================================================
-// 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 Class
-// ============================================================================
-
-/**
- * TemplateResolver
- * 
- * Resolves template strings that reference workflow inputs and node outputs.
- */
-export class TemplateResolver {
-  private input: Record<string, unknown>;
-  private previousOutputs: Map<string, unknown>;
-
-  constructor(options: TemplateResolverOptions = {}) {
-    this.input = options.input ?? {};
-    this.previousOutputs = options.previousOutputs ?? new Map();
-  }
-
-  /**
-   * Create a TemplateResolver from NodeExecutionContext
-   * 
-   * @param context - Node execution context
-   * @returns TemplateResolver instance
-   */
-  static fromContext(context: NodeExecutionContext): TemplateResolver {
-    return new TemplateResolver({
-      input: context.input as Record<string, unknown>,
-      previousOutputs: context.previousOutputs,
-    });
-  }
-
-  /**
-   * 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 {
-    if (input === null || input === undefined) {
-      return input;
-    }
-
-    if (typeof input === 'string') {
-      // Check if this is a pure template reference (no surrounding text)
-      const pureTemplate = this.extractPureTemplate(input);
-      if (pureTemplate) {
-        // Pure template reference - resolve and return value as-is (preserve objects/arrays)
-        return this.resolvePureTemplate(pureTemplate);
-      }
-      // Mixed text + templates - return resolved string
-      return this.resolveString(input);
-    }
-
-    if (Array.isArray(input)) {
-      return input.map(item => this.resolveValue(item));
-    }
-
-    if (typeof input === 'object') {
-      const resolved: Record<string, unknown> = {};
-      for (const [key, value] of Object.entries(input)) {
-        resolved[key] = this.resolveValue(value);
-      }
-      return resolved;
-    }
-
-    // Return primitive values as-is
-    return input;
-  }
-
-  /**
-   * 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(str: string): string | null {
-    const trimmed = str.trim();
-    if (trimmed.startsWith('{{') && trimmed.endsWith('}}') && trimmed.length > 4) {
-      // Extract content between {{ and }}
-      const content = trimmed.slice(2, -2).trim();
-      // Check there's no other text (except the template patterns themselves)
-      // This ensures we don't treat "Hello {{name}}" as pure template
-      if (!content.includes('{{') && !content.includes('}}')) {
-        return content;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * 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(templateContent: string): unknown {
-    // Try to resolve the template
-    const value = this.resolveTemplateContent(templateContent);
-    return value;
-  }
-
-  /**
-   * 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(templateContent: string): unknown {
-    const trimmed = templateContent.trim();
-    
-    // Pattern 1: {{input.key}} or {{input.key.nested}}
-    if (trimmed.startsWith('input.')) {
-      return this.getNestedValue(this.input, trimmed.slice(6)); // "input." is 6 chars
-    }
-    
-    // Pattern 2: {{nodes.nodeId}} or {{nodes.nodeId.output}}
-    if (trimmed.startsWith('nodes.')) {
-      return this.resolveNodePath(trimmed.slice(6)); // "nodes." is 6 chars
-    }
-    
-    // Pattern 3: Bare nodeId (backward compatibility)
-    // Skip reserved keywords
-    if (trimmed !== 'input' && trimmed !== 'nodes') {
-      const segments = trimmed.split('.');
-      const nodeId = segments[0];
-      const restPath = segments.slice(1).join('.') || undefined;
-      return this.resolveNodePath(`${nodeId}${restPath ? '.' + restPath : ''}`);
-    }
-    
-    return undefined;
-  }
-
-  /**
-   * 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 {
-    if (!template || typeof template !== 'string') {
-      return template;
-    }
-
-    let resolved = template;
-
-    // Pattern 1: {{input.key}} or {{input.key.nested}}
-    resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
-      const value = this.getNestedValue(this.input, path);
-      return this.stringify(value, match);
-    });
-
-    // Pattern 2: {{nodes.nodeId}} or {{nodes.nodeId.output.path}}
-    // Also handles {{nodes.nodeId.output}} format
-    resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
-      const value = this.resolveNodePath(path);
-      return this.stringify(value, match);
-    });
-
-    // Pattern 3: {{nodeId}} or {{nodeId.output}} or {{nodeId.output.path}}
-    // This is for backward compatibility with SkillNode's bare nodeId format
-    // Only matches if not already matched by nodes. pattern
-    // We need to be careful not to match {{input.xxx}} patterns
-    // Supports node IDs with alphanumeric, underscore, hyphen characters
-    resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_-]*)(?:\.([^}]+))?\}\}/g, (match, nodeId, path) => {
-      // Skip if this looks like an input reference without the prefix
-      // This is a heuristic: 'input' as first segment is handled above
-      if (nodeId === 'input') {
-        return match;
-      }
-      
-      // Skip 'nodes' prefix (already handled above)
-      if (nodeId === 'nodes') {
-        return match;
-      }
-
-      const value = this.resolveNodePath(`${nodeId}${path ? '.' + path : ''}`);
-      return this.stringify(value, match);
-    });
-
-    return resolved;
-  }
-
-  /**
-   * 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(path: string): unknown {
-    const segments = path.split('.');
-    const nodeId = segments[0];
-    
-    if (!nodeId) {
-      return undefined;
-    }
-
-    // Get node output from previous outputs
-    // Try exact match first, then try normalized versions (hyphen <-> underscore)
-    let value = this.previousOutputs.get(nodeId);
-    
-    if (value === undefined) {
-      // Try normalized versions for flexibility
-      // This handles cases where workflow defines node with underscore but template uses hyphen, or vice versa
-      const normalizedUnderscore = nodeId.replace(/-/g, '_');
-      const normalizedHyphen = nodeId.replace(/_/g, '-');
-      
-      if (normalizedUnderscore !== nodeId) {
-        value = this.previousOutputs.get(normalizedUnderscore);
-      }
-      if (value === undefined && normalizedHyphen !== nodeId) {
-        value = this.previousOutputs.get(normalizedHyphen);
-      }
-    }
-    
-    if (value === undefined) {
-      return undefined;
-    }
-
-    // If no additional path (bare nodeId), handle AgentNode output format
-    if (segments.length === 1) {
-      // Special handling for AgentNode output format: { result, metadata }
-      // If output has this shape, extract the result
-      if (value && typeof value === 'object' && 'result' in value && !('nodes' in value)) {
-        value = (value as { result: unknown }).result;
-      }
-      return value;
-    }
-
-    // Navigate nested path
-    // Special handling for AgentNode output format: { result, metadata }
-    // If path starts with 'result' or 'output', try to extract from wrapper
-    const secondSegment = segments[1];
-    if (secondSegment === 'result' || secondSegment === 'output') {
-      // Check if current value is an AgentNode-style wrapper
-      if (value && typeof value === 'object' && 'result' in value) {
-        value = (value as { result: unknown }).result;
-        
-        if (segments.length === 2) {
-          // Path was {{nodeId.result}} - return the result directly
-          return value;
-        }
-        
-        // Skip the 'result' segment and continue navigating
-        for (let i = 2; i < segments.length; i++) {
-          if (value === null || value === undefined) {
-            return undefined;
-          }
-          value = (value as any)[segments[i]];
-        }
-        return value;
-      }
-    }
-
-    // Standard nested path navigation
-    for (let i = 1; i < segments.length; i++) {
-      if (value === null || value === undefined) {
-        return undefined;
-      }
-      value = (value as any)[segments[i]];
-    }
-
-    return value;
-  }
-
-  /**
-   * 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(obj: Record<string, unknown> | undefined, path: string): unknown {
-    if (!obj || !path) {
-      return undefined;
-    }
-
-    const segments = path.split('.');
-    let current: unknown = obj;
-
-    for (const segment of segments) {
-      if (current === null || current === undefined) {
-        return undefined;
-      }
-      if (typeof current !== 'object') {
-        return undefined;
-      }
-      current = (current as Record<string, unknown>)[segment];
-    }
-
-    return current;
-  }
-
-  /**
-   * Convert a value to string, or return the original template if value is undefined.
-   */
-  private stringify(value: unknown, originalTemplate: string): string {
-    if (value === undefined) {
-      return originalTemplate;
-    }
-    if (typeof value === 'string') {
-      return value;
-    }
-    if (value === null) {
-      return 'null';
-    }
-    return JSON.stringify(value);
-  }
-
-  /**
-   * Check if a string contains template references.
-   * 
-   * @param str - String to check
-   * @returns True if the string contains template references
-   */
-  containsTemplates(str: string): boolean {
-    if (typeof str !== 'string') {
-      return false;
-    }
-    return /\{\{[^}]+\}\}/.test(str);
-  }
-
-  /**
-   * Extract all template references from a string.
-   * 
-   * @param str - String to extract from
-   * @returns Array of template references
-   */
-  extractTemplates(str: string): string[] {
-    if (typeof str !== 'string') {
-      return [];
-    }
-    const matches = str.match(/\{\{[^}]+\}\}/g);
-    return matches ?? [];
-  }
-}
-
-// ============================================================================
-// Convenience Functions
-// ============================================================================
-
-/**
- * Resolve template references in input using context.
- * 
- * @param input - Input value with potential templates
- * @param context - Node execution context
- * @returns Resolved input
- */
-export function resolveTemplates(
-  input: unknown,
-  context: NodeExecutionContext
-): unknown {
-  const resolver = TemplateResolver.fromContext(context);
-  return resolver.resolveValue(input);
-}
-
-/**
- * Resolve a template string using context.
- * 
- * @param template - Template string
- * @param context - Node execution context
- * @returns Resolved string
- */
-export function resolveTemplateString(
-  template: string,
-  context: NodeExecutionContext
-): string {
-  const resolver = TemplateResolver.fromContext(context);
-  return resolver.resolveString(template);
-}