@falai/agent 0.9.0 → 1.0.0

package/src/core/ResponsePipeline.ts

@@ -19,10 +19,11 @@ import {
   logger,
   render,
 } from "../utils";
+import { createTemplateContext } from "../utils/template";
 import { Route } from "../core/Route";
 import { Step } from "../core/Step";
 import { RoutingEngine } from "../core/RoutingEngine";
-import { ToolExecutor } from "../core/ToolExecutor";
+import type { ToolManager } from "../core/ToolManager";
 import { END_ROUTE_ID } from "../constants";
 
 export interface ResponsePreparationResult<TContext, TData = unknown> {
@@ -42,8 +43,8 @@ export interface RoutingResult<TContext, TData = unknown> {
 export interface ToolExecutionResult<TData = unknown> {
   session: SessionState<TData>;
   toolCalls:
-    | Array<{ toolName: string; arguments: Record<string, unknown> }>
-    | undefined;
+  | Array<{ toolName: string; arguments: Record<string, unknown> }>
+  | undefined;
 }
 
 export interface DataCollectionResult<TData = unknown> {
@@ -57,8 +58,8 @@ export interface DataCollectionResult<TData = unknown> {
 export class ResponsePipeline<TContext = unknown, TData = unknown> {
   constructor(
     private readonly options: AgentOptions<TContext, TData>,
-    private readonly routes: Route<TContext, TData>[],
-    private readonly tools: Tool<TContext, TData, unknown[], unknown>[],
+    private readonly getRoutes: () => Route<TContext, TData>[],
+    private readonly tools: Tool<TContext, TData>[],
     private readonly routingEngine: RoutingEngine<TContext, TData>,
     private readonly updateContext: (
       updates: Partial<TContext>
@@ -69,8 +70,9 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
     ) => Promise<SessionState<TData>>,
     private readonly updateCollectedData?: (
       updates: Partial<TData>
-    ) => Promise<void>
-  ) {}
+    ) => Promise<void>,
+    private readonly toolManager?: ToolManager<TContext, TData>
+  ) { }
 
   /**
    * Prepare context and session for response generation
@@ -125,9 +127,12 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
     let completedRoutes: Route<TContext, TData>[] = [];
     let targetSession = session;
 
+    // Get routes early since we need them for pending transitions
+    const routes = this.getRoutes();
+
     // Check for pending transition from previous route completion
     if (targetSession.pendingTransition) {
-      const targetRoute = this.routes.find(
+      const targetRoute = routes.find(
         (r) => r.id === targetSession.pendingTransition?.targetRouteId
       );
 
@@ -166,11 +171,11 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
         };
       }
     }
-
+    
     // If no pending transition or transition handled, do normal routing
-    if (this.routes.length > 0 && !selectedRoute) {
+    if (routes.length > 0 && !selectedRoute) {
       const orchestration = await this.routingEngine.decideRouteAndStep({
-        routes: this.routes,
+        routes: routes,
         session: targetSession,
         history,
         agentOptions: this.options,
@@ -207,12 +212,12 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
   /**
    * Determine next step and update session
    */
-  determineNextStep(params: {
+  async determineNextStep(params: {
     selectedRoute: Route<TContext, TData> | undefined;
     selectedStep: Step<TContext, TData> | undefined;
     session: SessionState<TData>;
     isRouteComplete: boolean;
-  }): { nextStep: Step<TContext, TData> | undefined; session: SessionState<TData> } {
+  }): Promise<{ nextStep: Step<TContext, TData> | undefined; session: SessionState<TData> }> {
     const { selectedRoute, selectedStep, session, isRouteComplete } = params;
 
     if (!selectedRoute || isRouteComplete) {
@@ -225,16 +230,23 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
     if (selectedStep) {
       nextStep = selectedStep;
     } else {
-      // New route or no step selected - get initial step or first valid step
-      const candidates = this.routingEngine.getCandidateSteps(
+      // Determine current step from session if we're already in this route
+      const currentStep = session.currentRoute?.id === selectedRoute.id && session.currentStep
+        ? selectedRoute.getStep(session.currentStep.id)
+        : undefined;
+
+      const contextToUse = this.getStoredContext();
+      // Get candidate steps based on current position in the route
+      const candidates = await this.routingEngine.getCandidateStepsWithConditions(
         selectedRoute,
-        undefined,
-        session.data || {}
+        currentStep, // Pass current step instead of undefined to maintain progression
+        createTemplateContext({ data: session.data, session, context: contextToUse })
       );
+      
       if (candidates.length > 0) {
         nextStep = candidates[0].step;
         logger.debug(
-          `[ResponseHandler] Using first valid step: ${nextStep.id} for new route`
+          `[ResponseHandler] Using first valid step: ${nextStep.id}${currentStep ? ' (progressing from ' + currentStep.id + ')' : ' for new route'}`
         );
       } else {
         // Fallback to initial step even if it should be skipped
@@ -281,8 +293,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
     }
 
     logger.debug(
-      `[ResponseHandler] Executing ${toolCalls.length} ${
-        isStreaming ? "streaming " : ""
+      `[ResponseHandler] Executing ${toolCalls.length} ${isStreaming ? "streaming " : ""
       }tool calls`
     );
 
@@ -299,15 +310,21 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
         continue;
       }
 
-      const toolExecutor = new ToolExecutor<TContext, TData>();
-      const result = await toolExecutor.executeTool({
-        tool,
-        context,
-        updateContext: this.updateContext,
-        updateData: this.updateCollectedData || (async () => {}),
-        history,
-        data: updatedSession.data,
-      });
+      // Use ToolManager for unified tool execution
+      let result;
+      if (this.toolManager) {
+        result = await this.toolManager.executeTool({
+          tool,
+          context,
+          updateContext: this.updateContext,
+          updateData: this.updateCollectedData || (async () => { }),
+          history,
+          data: updatedSession.data,
+        });
+      } else {
+        // Fallback: execute tool directly if ToolManager not available
+        throw new Error(`ToolManager not available for tool execution: ${toolCall.toolName}`);
+      }
 
       executedToolCalls.push(toolCall);
 
@@ -323,16 +340,14 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
           result.dataUpdate as Partial<TData>
         );
         logger.debug(
-          `[ResponseHandler] ${
-            isStreaming ? "Streaming " : ""
+          `[ResponseHandler] ${isStreaming ? "Streaming " : ""
           }Tool updated collected data:`,
           result.dataUpdate
         );
       }
 
       logger.debug(
-        `[ResponseHandler] Executed ${isStreaming ? "streaming " : ""}tool: ${
-          result.toolName
+        `[ResponseHandler] Executed ${isStreaming ? "streaming " : ""}tool: ${String(tool.id || tool.name || 'unknown')
         } (success: ${result.success})`
       );
     }
@@ -348,8 +363,8 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
    */
   async executeToolLoop(params: {
     initialToolCalls:
-      | Array<{ toolName: string; arguments: Record<string, unknown> }>
-      | undefined;
+    | Array<{ toolName: string; arguments: Record<string, unknown> }>
+    | undefined;
     selectedRoute?: Route<TContext, TData>;
     nextStep: Step<TContext, TData>;
     responsePrompt: string;
@@ -380,8 +395,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
     while (hasToolCalls && toolLoopCount < MAX_TOOL_LOOPS) {
       toolLoopCount++;
       logger.debug(
-        `[ResponseHandler] Starting ${
-          isStreaming ? "streaming " : ""
+        `[ResponseHandler] Starting ${isStreaming ? "streaming " : ""
         }tool loop ${toolLoopCount}/${MAX_TOOL_LOOPS}`
       );
 
@@ -430,8 +444,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
 
       if (hasToolCalls) {
         logger.debug(
-          `[ResponseHandler] Follow-up call produced ${
-            followUpToolCalls!.length
+          `[ResponseHandler] Follow-up call produced ${followUpToolCalls!.length
           } additional tool calls`
         );
 
@@ -449,8 +462,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
         currentToolCalls = followUpToolCalls;
       } else {
         logger.debug(
-          `[ResponseHandler] ${
-            isStreaming ? "Streaming " : ""
+          `[ResponseHandler] ${isStreaming ? "Streaming " : ""
           }Tool loop completed after ${toolLoopCount} iterations`
         );
         // Update final toolCalls from follow-up result if no more tools
@@ -461,8 +473,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
 
     if (toolLoopCount >= MAX_TOOL_LOOPS) {
       logger.warn(
-        `[ResponseHandler] ${
-          isStreaming ? "Streaming " : ""
+        `[ResponseHandler] ${isStreaming ? "Streaming " : ""
         }Tool loop limit reached (${MAX_TOOL_LOOPS}), stopping`
       );
     }
@@ -505,7 +516,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
       if (this.updateCollectedData) {
         await this.updateCollectedData(collectedData);
       }
-      
+
       // Update session with validated data
       updatedSession = await this.updateData(session, collectedData);
       logger.debug(`[ResponseHandler] Collected data:`, collectedData);
@@ -554,18 +565,18 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
 
     if (transitionConfig) {
       // Find target route by ID or title
-      const targetRoute = this.routes.find(
+      const targetRoute = this.getRoutes().find(
         (r) =>
           r.id === transitionConfig.nextStep ||
           r.title === transitionConfig.nextStep
       );
 
       if (targetRoute) {
-        const templateContext = {
+        const templateContext = createTemplateContext({
           context,
           session,
           history,
-        };
+        });
         const renderedCondition: string =
           (await render(transitionConfig.condition, templateContext)) ||
           (typeof transitionConfig.condition === "string"
@@ -602,12 +613,21 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
   }
 
   /**
-   * Find an available tool by name for the given route
+   * Find an available tool by name for the given route using ToolManager
+   * Delegates to ToolManager for unified tool resolution
    */
   private findAvailableTool(
     toolName: string,
     route?: Route<TContext, TData>
-  ): Tool<TContext, TData, unknown[], unknown> | undefined {
+  ): Tool<TContext, TData> | undefined {
+    // Use ToolManager for unified tool resolution if available
+    if (this.toolManager) {
+      return this.toolManager.find(toolName, undefined, undefined, route);
+    }
+
+    // Fallback to legacy resolution if ToolManager not available
+    logger.warn(`[ResponsePipeline] ToolManager not available, using legacy tool resolution for: ${toolName}`);
+
     // Check route-level tools first (if route provided)
     if (route) {
       const routeTool = route
@@ -623,15 +643,29 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
   }
 
   /**
-   * Collect all available tools for the given route and step context
+   * Collect all available tools for the given route and step context using ToolManager
+   * Delegates to ToolManager for unified tool resolution and deduplication
    */
   private collectAvailableTools(
     route?: Route<TContext, TData>,
     step?: Step<TContext, TData>
   ): Array<{ id: string; description?: string; parameters?: unknown }> {
+    // Use ToolManager for unified tool collection if available
+    if (this.toolManager) {
+      const availableTools = this.toolManager.getAvailable(undefined, step, route);
+      return availableTools.map((tool) => ({
+        id: tool.id,
+        description: tool.description,
+        parameters: tool.parameters,
+      }));
+    }
+
+    // Fallback to legacy collection logic if ToolManager not available
+    logger.warn(`[ResponsePipeline] ToolManager not available, using legacy tool collection`);
+
     const availableTools = new Map<
       string,
-      Tool<TContext, TData, unknown[], unknown>
+      Tool<TContext, TData>
     >();
 
     // Add agent-level tools
@@ -649,7 +683,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
     // Filter by step-level allowed tools if specified
     if (step?.tools) {
       const allowedToolIds = new Set<string>();
-      const stepTools: Tool<TContext, TData, unknown[], unknown>[] = [];
+      const stepTools: Tool<TContext, TData>[] = [];
 
       for (const toolRef of step.tools) {
         if (typeof toolRef === "string") {
@@ -668,7 +702,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
       if (allowedToolIds.size > 0) {
         const filteredTools = new Map<
           string,
-          Tool<TContext, TData, unknown[], unknown>
+          Tool<TContext, TData>
         >();
         for (const toolId of Array.from(allowedToolIds)) {
           const tool = availableTools.get(toolId);
@@ -747,35 +781,35 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
     }>;
   }> {
     const { routes, session, context } = params;
-    
+
     // Evaluate all routes for completion
     const completedRoutes: Route<TContext, TData>[] = [];
     const pendingTransitions: Array<{
       route: Route<TContext, TData>;
       transitionConfig: RouteTransitionConfig<TContext, TData>;
     }> = [];
-    
+
     for (const route of routes) {
       if (route.isComplete(session.data || {})) {
         completedRoutes.push(route);
-        
+
         // Check for onComplete transitions
         const transitionConfig = await route.evaluateOnComplete(
           { data: session.data },
           context
         );
-        
+
         if (transitionConfig) {
           pendingTransitions.push({ route, transitionConfig });
         }
-        
+
         logger.debug(
           `[ResponsePipeline] Route completed: ${route.title} ` +
           `(${Math.round(route.getCompletionProgress(session.data || {}) * 100)}%)`
         );
       }
     }
-    
+
     // Log completion status for all routes
     if (completedRoutes.length > 0) {
       logger.debug(
@@ -783,7 +817,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
         `${completedRoutes.length}/${routes.length} routes complete`
       );
     }
-    
+
     return {
       session,
       completedRoutes,
@@ -801,15 +835,15 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
     routes: Route<TContext, TData>[];
   }): Promise<SessionState<TData>> {
     const { session, dataUpdate, routes } = params;
-    
+
     // Update session data
     const updatedSession = await this.updateData(session, dataUpdate);
-    
+
     // Update agent-level data if handler is available
     if (this.updateCollectedData) {
       await this.updateCollectedData(dataUpdate);
     }
-    
+
     // Evaluate route completions after data update
     const completionResults = await this.handleCrossRouteCompletion({
       routes,
@@ -817,14 +851,14 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
       context: this.context!,
       history: [],
     });
-    
+
     // Log any newly completed routes
     if (completionResults.completedRoutes.length > 0) {
       logger.debug(
         `[ResponsePipeline] Data update resulted in ${completionResults.completedRoutes.length} completed routes`
       );
     }
-    
+
     return completionResults.session;
   }
 }