@ai-setting/roy-agent-core 1.3.9 → 1.3.11

package/src/env/workflow/nodes/tool-node.ts

@@ -1,493 +0,0 @@
-/**
- * Tool Registry interface for looking up tools
- * Supports both the full ToolRegistration and simplified Tool interface
- */
-export interface ToolRegistry {
-  // Full registration interface (from ToolComponent)
-  getTool?(name: string): ToolRegistration | undefined;
-  // Simplified tool interface (from ToolNode's own interface)
-  getToolByName?(name: string): Tool | undefined;
-  hasTool?(name: string): boolean;
-}
-
-/**
- * Tool Registration interface (from ToolComponent)
- */
-export interface ToolRegistration {
-  tool: Tool;
-  enabled: boolean;
-  source?: string;
-}
-
-/**
- * Tool interface for execution
- */
-export interface Tool {
-  name: string;
-  execute(input: any, context?: any): Promise<any>;
-}
-
-/**
- * ToolNode executes a registered Tool with the provided input.
- * 
- * Input can contain template strings like {{nodeId.output.path}} that will be
- * resolved from previousOutputs.
- */
-export class ToolNode implements Node {
-  readonly type = 'tool';
-  readonly id: string;
-  
-  constructor(
-    private definition: NodeDefinition,
-    private toolRegistry: ToolRegistry
-  ) {
-    this.id = definition.id;
-  }
-  
-  async execute(context: NodeExecutionContext): Promise<NodeExecutionResult> {
-    const startTime = Date.now();
-    
-    try {
-      // 1. Get tool name from definition.config.tool or config.toolName
-      const toolName = (this.definition.config?.tool ?? this.definition.config?.toolName) as string | undefined;
-      
-      if (!toolName) {
-        throw new Error('Tool name is required. Please specify config.tool or config.toolName in the node definition.');
-      }
-      
-      // 2. Look up tool from registry (support both interfaces)
-      let tool: Tool | undefined;
-      
-      if (this.toolRegistry.getTool) {
-        // getTool may return ToolRegistration or Tool depending on implementation
-        const result = this.toolRegistry.getTool(toolName);
-        if (!result) {
-          throw new Error(`Tool not found: ${toolName}`);
-        }
-        // Check if result has .tool property (ToolRegistration) or is a Tool directly
-        if ('tool' in result) {
-          tool = (result as ToolRegistration).tool;
-        } else {
-          tool = result as Tool;
-        }
-      } else if (this.toolRegistry.getToolByName) {
-        // Simplified interface: getToolByName returns Tool directly
-        tool = this.toolRegistry.getToolByName(toolName);
-      }
-      
-      if (!tool) {
-        throw new Error(`Tool not found: ${toolName}`);
-      }
-      
-      // 3. Prepare input (may reference previous outputs and workflow input)
-      // Support multiple formats:
-      // - config.input: { param1: value1, param2: value2 }
-      // - config.args: { param1: value1, param2: value2 } (alias)
-      // - config.command: "string command" (for tools like bash that use command field)
-      // - config.message: "string message" (for tools like echo that use message field)
-      let input: any;
-      
-      if (this.definition.config?.command !== undefined) {
-        // Special case: single command parameter (e.g., bash tool)
-        // Resolve the command template and pass as { command: resolvedCommand }
-        const commandTemplate = this.definition.config.command;
-        const resolvedCommand = this.resolveTemplateReferences(commandTemplate, context.previousOutputs, context.input as any);
-        input = { command: resolvedCommand };
-        console.log(`[ToolNode] command input: ${resolvedCommand}`);
-      } else if (this.definition.config?.message !== undefined && Object.keys(this.definition.config).length === 1) {
-        // Special case: single message parameter (e.g., echo tool)
-        // Resolve the message template and pass as { message: resolvedMessage }
-        const messageTemplate = this.definition.config.message;
-        const resolvedMessage = this.resolveTemplateReferences(messageTemplate, context.previousOutputs, context.input as any);
-        input = { message: resolvedMessage };
-        console.log(`[ToolNode] message input: ${resolvedMessage}`);
-      } else {
-        // Normal case: multiple parameters
-        input = this.definition.config?.input ?? this.definition.config?.args ?? {};
-        input = this.resolveTemplateReferences(input, context.previousOutputs, context.input as any);
-      }
-      
-      // 4. Execute tool
-      // Try to pass context if the tool supports it, otherwise just pass input
-      let output: any;
-      try {
-        // First try with context (for tools that expect it)
-        const toolContext = {
-          session_id: context.sessionId || `workflow_${context.runId}`,
-          message_id: context.nodeId,
-          metadata: {
-            workflowRunId: context.runId,
-            workflowName: context.workflowName,
-            nodeId: context.nodeId,
-          },
-        };
-        
-        // Execute tool with timeout to detect hanging
-        const executePromise = tool.execute(input, toolContext as any);
-        const timeoutPromise = new Promise<never>((_, reject) => {
-          setTimeout(() => reject(new Error(`Tool ${toolName} execution timeout after 30s`)), 30000);
-        });
-        
-        output = await Promise.race([executePromise, timeoutPromise]);
-      } catch (err) {
-        // If the tool doesn't support context parameter, try without it
-        console.log(`[ToolNode] Tool ${toolName} doesn't support context, retrying without context...`);
-        output = await tool.execute(input);
-      }
-      
-      // 5. Return result
-      return {
-        output,
-        error: undefined,
-        durationMs: Date.now() - startTime,
-      };
-    } catch (error) {
-      return {
-        output: undefined,
-        error: error instanceof Error ? error : new Error(String(error)),
-        durationMs: Date.now() - startTime,
-      };
-    }
-  }
-  
-  /**
-   * Resolve template references in input values.
-   * Templates can be in the format:
-   * - {{input.key}} - from workflow input
-   * - {{nodeId}} - entire previous node output
-   * - {{nodeId.path}} - nested path within previous node output
-   * - {{nodes.nodeId}} - entire previous node output (alias)
-   * - {{nodes.nodeId.path}} - nested path within previous node output
-   * - ${nodeId.output} - dollar-style template (same as {{nodeId.output}})
-   * 
-   * 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 - The input object that may contain template strings
-   * @param previousOutputs - Map of previous node outputs
-   * @param workflowInput - The workflow input parameters
-   * @returns The input with template references resolved
-   */
-  private resolveTemplateReferences(
-    input: any, 
-    previousOutputs: Map<string, any>,
-    workflowInput?: Record<string, unknown>
-  ): any {
-    if (typeof input === 'string') {
-      // Check if this is a pure template reference (no surrounding text)
-      // Support both {{nodeId.output}} and ${nodeId.output} formats
-      const pureTemplate = this.extractPureTemplate(input) || this.extractDollarTemplate(input);
-      if (pureTemplate) {
-        // Pure template reference - resolve and return value as-is (preserve objects/arrays)
-        return this.resolvePureTemplate(pureTemplate, previousOutputs, workflowInput);
-      }
-      // Mixed text + templates - return resolved string
-      return this.resolveStringTemplate(input, previousOutputs, workflowInput);
-    }
-    
-    if (Array.isArray(input)) {
-      return input.map(item => this.resolveTemplateReferences(item, previousOutputs, workflowInput));
-    }
-    
-    if (input !== null && typeof input === 'object') {
-      const resolved: Record<string, any> = {};
-      for (const [key, value] of Object.entries(input)) {
-        resolved[key] = this.resolveTemplateReferences(value, previousOutputs, workflowInput);
-      }
-      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)
-      if (!content.includes('{{') && !content.includes('}}')) {
-        return content;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Check if a string is a dollar-style template reference (starts with ${ and ends with })
-   * @param str - String to check
-   * @returns The template content if pure, null otherwise
-   */
-  private extractDollarTemplate(str: string): string | null {
-    const trimmed = str.trim();
-    if (trimmed.startsWith('${') && trimmed.endsWith('}') && trimmed.length > 3) {
-      // Extract content between ${ and }
-      const content = trimmed.slice(2, -1).trim();
-      // Check there's no other text (except the template patterns themselves)
-      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 }} or ${ and }
-   * @param previousOutputs - Map of previous node outputs
-   * @param workflowInput - The workflow input parameters
-   * @returns The resolved value (may be object, array, or primitive), 
-   *          or the original template string if unresolved
-   */
-  private resolvePureTemplate(
-    templateContent: string,
-    previousOutputs: Map<string, any>,
-    workflowInput?: Record<string, unknown>
-  ): any {
-    const trimmed = templateContent.trim();
-    const originalTemplate = `{{${templateContent}}}`;
-
-    // Pattern 1: {{input.key}} or ${input.key}
-    if (trimmed.startsWith('input.')) {
-      const value = this.getNestedValue(workflowInput, trimmed.slice(6));
-      return value !== undefined ? value : originalTemplate;
-    }
-    
-    // Pattern 2: {{nodes.nodeId}} or ${nodes.nodeId}
-    if (trimmed.startsWith('nodes.')) {
-      const path = trimmed.slice(6);
-      const segments = path.split('.');
-      const nodeId = segments[0];
-      const restPath = segments.slice(1).join('.') || undefined;
-      const value = this.resolvePath(nodeId, restPath, previousOutputs);
-      return value !== undefined ? value : originalTemplate;
-    }
-    
-    // Pattern 3: Bare nodeId (backward compatibility) - e.g., "node-1" or "node-1.output.task_id"
-    if (trimmed !== 'input' && trimmed !== 'nodes') {
-      const segments = trimmed.split('.');
-      const nodeId = segments[0];
-      const restPath = segments.slice(1).join('.') || undefined;
-      const value = this.resolvePath(nodeId, restPath, previousOutputs);
-      return value !== undefined ? value : originalTemplate;
-    }
-    
-    return originalTemplate;
-  }
-  
-  /**
-   * Resolve template references in a single string (for mixed text + templates).
-   * Supports formats:
-   * - {{input.key}} - from workflow input
-   * - {{nodeId}} - entire previous node output
-   * - {{nodeId.path}} - nested path within previous node output
-   * - {{nodes.nodeId}} - entire previous node output (alias)
-   * - {{nodes.nodeId.path}} - nested path within previous node output
-   * - ${nodeId.output} - dollar-style template
-   * 
-   * Note: Returns string because the input contains text around the template.
-   * For pure template references, use resolvePureTemplate instead.
-   */
-  private resolveStringTemplate(
-    template: string, 
-    previousOutputs: Map<string, any>,
-    workflowInput?: Record<string, unknown>
-  ): string {
-    let resolved = template;
-
-    // Pattern 1: {{input.key}} or ${input.key}
-    resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
-      const value = this.getNestedValue(workflowInput, path.trim());
-      return this.stringifyValue(value, match);
-    });
-    resolved = resolved.replace(/\$\{input\.([^}]+)\}/g, (match, path) => {
-      const value = this.getNestedValue(workflowInput, path.trim());
-      return this.stringifyValue(value, match);
-    });
-
-    // Pattern 2: {{nodeId}} or {{nodeId.path}} (bare nodeId without 'nodes.' prefix)
-    resolved = resolved.replace(/\{\{([^:.{}][^}]*?)\}\}/g, (match, path) => {
-      // Skip if it starts with 'nodes.' (handled by pattern 3) or 'input.' (handled by pattern 1)
-      if (path.trim().startsWith('nodes.') || path.trim().startsWith('input.')) {
-        return match;
-      }
-      // Split into nodeId and optional path
-      const segments = path.trim().split('.');
-      const nodeId = segments[0];
-      const restPath = segments.slice(1).join('.') || undefined;
-      const value = this.resolvePath(nodeId, restPath, previousOutputs);
-      return this.stringifyValue(value, match);
-    });
-    
-    // Pattern 3: ${nodeId.output} - dollar-style template
-    resolved = resolved.replace(/\$\{([^}]+)\}/g, (match, path) => {
-      // Skip if it starts with 'nodes.' or 'input.'
-      if (path.trim().startsWith('nodes.') || path.trim().startsWith('input.')) {
-        return match;
-      }
-      // Split into nodeId and optional path
-      const segments = path.trim().split('.');
-      const nodeId = segments[0];
-      const restPath = segments.slice(1).join('.') || undefined;
-      const value = this.resolvePath(nodeId, restPath, previousOutputs);
-      return this.stringifyValue(value, match);
-    });
-
-    // Pattern 4: {{nodes.nodeId}} or {{nodes.nodeId.path}}
-    resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
-      const segments = path.trim().split('.');
-      const nodeId = segments[0];
-      const restPath = segments.slice(1).join('.') || undefined;
-      // Get raw node output and extract from wrapper format
-      const nodeOutput = this.resolvePath(nodeId, undefined, previousOutputs);
-      let extractedValue = this.extractFromWrapper(nodeOutput);
-      
-      // If extracted value is a string and restPath is "output", the user is trying
-      // to access the output property of a tool result. In this case, the string
-      // itself IS the output, so return it directly.
-      if (typeof extractedValue === 'string' && restPath === 'output') {
-        return this.stringifyValue(extractedValue, match);
-      }
-      
-      if (restPath) {
-        const value = this.getNestedValue(extractedValue, restPath);
-        return this.stringifyValue(value, match);
-      } else {
-        return this.stringifyValue(extractedValue, match);
-      }
-    });
-
-    return resolved;
-  }
-  
-  /**
-   * Resolve a value from previous outputs.
-   * @param nodeId - The node ID to look up
-   * @param path - Optional dot-notation path within the node output
-   * @param previousOutputs - Map of previous node outputs
-   */
-  private resolvePath(nodeId: string, path: string | undefined, previousOutputs: Map<string, any>): any {
-    // Try exact match first, then try normalized versions (hyphen <-> underscore)
-    let nodeOutput = previousOutputs.get(nodeId);
-    
-    if (nodeOutput === undefined) {
-      const normalizedUnderscore = nodeId.replace(/-/g, '_');
-      const normalizedHyphen = nodeId.replace(/_/g, '-');
-      
-      if (normalizedUnderscore !== nodeId) {
-        nodeOutput = previousOutputs.get(normalizedUnderscore);
-      }
-      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-        nodeOutput = previousOutputs.get(normalizedHyphen);
-      }
-    }
-    
-    if (nodeOutput === undefined) {
-      return undefined;
-    }
-    
-    if (path === undefined || path === '') {
-      return nodeOutput;
-    }
-    
-    // Navigate through the path
-    return this.getNestedValue(nodeOutput, path);
-  }
-  
-  /**
-   * Get a nested value from an object using dot notation.
-   * @param obj - The object to traverse
-   * @param path - Dot-notation path (e.g., "metadata.task_id")
-   */
-  private getNestedValue(obj: any, path: string): any {
-    if (obj === null || obj === undefined) {
-      return undefined;
-    }
-    
-    const segments = path.split('.');
-    let current = obj;
-    
-    for (const segment of segments) {
-      if (current === null || current === undefined) {
-        return undefined;
-      }
-      current = current[segment];
-    }
-    
-    return current;
-  }
-  
-  /**
-   * Extract the actual output value from wrapper formats.
-   * For strings, removes trailing whitespace (especially newlines from bash commands).
-   */
-  private extractFromWrapper(value: unknown): unknown {
-    if (value === null || value === undefined) {
-      return value;
-    }
-    if (typeof value !== 'object') {
-      return value;
-    }
-    let result: unknown;
-    if ('output' in value) {
-      result = (value as { output: unknown }).output;
-    } else if ('result' in value && !('output' in value)) {
-      result = (value as { result: unknown }).result;
-    } else {
-      return value;
-    }
-    // For string results from tools (like bash), trim trailing whitespace
-    // This prevents double newlines when embedding in shell commands
-    if (typeof result === 'string') {
-      return result.trimEnd();
-    }
-    return result;
-  }
-
-  /**
-   * Convert a value to string for template interpolation.
-   * @param value - The value to convert
-   * @param fallback - Fallback string if value is undefined
-   */
-  private stringifyValue(value: any, fallback: string): string {
-    if (value === undefined || value === null) {
-      return fallback;
-    }
-    
-    let str: string;
-    if (typeof value === 'object') {
-      str = JSON.stringify(value);
-    } else {
-      str = String(value);
-    }
-    
-    // Escape special characters for shell:
-    // - \ \ -> \\\ (for echo to show literal \)
-    // - " -> \"
-    // - ` -> \`
-    // - $ -> \$
-    // - \n -> \\n (for echo to show literal \n, not newline)
-    // - \r -> \\r
-    // - \t -> \\t
-    return str
-      .replace(/\\/g, '\\\\')
-      .replace(/\n/g, '\\n')
-      .replace(/\r/g, '\\r')
-      .replace(/\t/g, '\\t')
-      .replace(/"/g, '\\"')
-      .replace(/`/g, '\\`')
-      .replace(/\$/g, '\\$');
-  }
-}
-
-// Re-export types from workflow types
-import type { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';