@ai-setting/roy-agent-core 1.0.0

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

@@ -0,0 +1,493 @@
+/**
+ * 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';