@falai/agent 0.6.9 → 0.7.0

package/dist/core/RoutingEngine.js

@@ -1,4 +1,4 @@
-import { enterRoute, mergeExtracted } from "../types/session";
+import { enterRoute, mergeCollected } from "../types/session";
 import { PromptComposer } from "./PromptComposer";
 import { getLastMessageFromHistory } from "../utils/event";
 import { logger } from "../utils/logger";
@@ -8,10 +8,10 @@ export class RoutingEngine {
     }
     /**
      * Optimized decision for single-route scenarios
-     * Skips route scoring and only does state selection
+     * Skips route scoring and only does step selection
      * @private
      */
-    async decideSingleRouteState(params) {
+    async decideSingleRouteStep(params) {
         const { route, session, history, agentMeta, ai, context, signal } = params;
         let updatedSession = session;
         const selectedRoute = route;
@@ -19,237 +19,237 @@ export class RoutingEngine {
         if (!session.currentRoute || session.currentRoute.id !== route.id) {
             updatedSession = enterRoute(session, route.id, route.title);
             if (route.initialData) {
-                updatedSession = mergeExtracted(updatedSession, route.initialData);
+                updatedSession = mergeCollected(updatedSession, route.initialData);
                 logger.debug(`[RoutingEngine] Single-route: Merged initial data:`, route.initialData);
             }
             logger.debug(`[RoutingEngine] Single-route: Entered route: ${route.title}`);
         }
-        // Get candidate states
-        const currentState = updatedSession.currentState
-            ? route.getState(updatedSession.currentState.id)
+        // Get candidate steps
+        const currentStep = updatedSession.currentStep
+            ? route.getStep(updatedSession.currentStep.id)
             : undefined;
-        const candidates = this.getCandidateStates(route, currentState, updatedSession.extracted || {});
+        const candidates = this.getCandidateSteps(route, currentStep, updatedSession.data || {});
         if (candidates.length === 0) {
-            logger.warn(`[RoutingEngine] Single-route: No valid states found`);
+            logger.warn(`[RoutingEngine] Single-route: No valid steps found`);
             return { selectedRoute, session: updatedSession };
         }
         // If only one candidate, check if route is complete
         if (candidates.length === 1) {
             const isRouteComplete = candidates[0].isRouteComplete;
             if (isRouteComplete) {
-                logger.debug(`[RoutingEngine] Single-route: Route complete - all data collected, END_STATE reached`);
-                // Don't return a selectedState when route is complete - there's no state to enter
+                logger.debug(`[RoutingEngine] Single-route: Route complete - all data collected, END_ROUTE reached`);
+                // Don't return a selectedStep when route is complete - there's no step to enter
                 return {
                     selectedRoute,
-                    selectedState: undefined,
+                    selectedStep: undefined,
                     session: updatedSession,
                     isRouteComplete: true,
                 };
             }
             else {
-                logger.debug(`[RoutingEngine] Single-route: Only one valid state: ${candidates[0].state.id}`);
+                logger.debug(`[RoutingEngine] Single-route: Only one valid step: ${candidates[0].step.id}`);
                 return {
                     selectedRoute,
-                    selectedState: candidates[0].state,
+                    selectedStep: candidates[0].step,
                     session: updatedSession,
                     isRouteComplete: false,
                 };
             }
         }
-        // Multiple candidates - use AI to select best state
+        // Multiple candidates - use AI to select best step
         const lastUserMessage = getLastMessageFromHistory(history);
-        const statePrompt = this.buildStateSelectionPrompt(route, currentState, candidates, updatedSession.extracted || {}, history, lastUserMessage, agentMeta);
-        const stateSchema = this.buildStateSelectionSchema(candidates.map((c) => c.state.id));
-        const stateResult = await ai.generateMessage({
-            prompt: statePrompt,
+        const stepPrompt = this.buildStepSelectionPrompt(route, currentStep, candidates, updatedSession.data || {}, history, lastUserMessage, agentMeta);
+        const stepSchema = this.buildStepSelectionSchema(candidates.map((c) => c.step.id));
+        const stepResult = await ai.generateMessage({
+            prompt: stepPrompt,
             history,
             context,
             signal,
             parameters: {
-                jsonSchema: stateSchema,
-                schemaName: "state_selection",
+                jsonSchema: stepSchema,
+                schemaName: "step_selection",
             },
         });
-        const selectedStateId = stateResult.structured?.selectedStateId;
-        const selectedState = candidates.find((c) => c.state.id === selectedStateId)?.state;
-        if (selectedState) {
-            logger.debug(`[RoutingEngine] Single-route: AI selected state: ${selectedState.id}`);
-            logger.debug(`[RoutingEngine] Single-route: Reasoning: ${stateResult.structured?.reasoning}`);
+        const selectedStepId = stepResult.structured?.selectedStepId;
+        const selectedStep = candidates.find((c) => c.step.id === selectedStepId)?.step;
+        if (selectedStep) {
+            logger.debug(`[RoutingEngine] Single-route: AI selected step: ${selectedStep.id}`);
+            logger.debug(`[RoutingEngine] Single-route: Reasoning: ${stepResult.structured?.reasoning}`);
         }
         else {
-            logger.warn(`[RoutingEngine] Single-route: Invalid state ID returned, using first candidate`);
+            logger.warn(`[RoutingEngine] Single-route: Invalid step ID returned, using first candidate`);
         }
         return {
             selectedRoute,
-            selectedState: selectedState || candidates[0].state,
-            responseDirectives: stateResult.structured?.responseDirectives,
+            selectedStep: selectedStep || candidates[0].step,
+            responseDirectives: stepResult.structured?.responseDirectives,
             session: updatedSession,
         };
     }
     /**
-     * Recursively traverse state chain to find first non-skipped state or END_STATE
+     * Recursively traverse step chain to find first non-skipped step or END_ROUTE
      * @private
      */
-    findFirstValidStateRecursive(currentState, extracted, visited) {
+    findFirstValidStepRecursive(currentStep, data, visited) {
         // Prevent infinite loops
-        if (visited.has(currentState.id)) {
+        if (visited.has(currentStep.id)) {
             return {};
         }
-        visited.add(currentState.id);
-        const transitions = currentState.getTransitions();
+        visited.add(currentStep.id);
+        const transitions = currentStep.getTransitions();
         for (const transition of transitions) {
             const target = transition.getTarget();
-            // Check for END_STATE transition
+            // Check for END_ROUTE transition
             if (!target &&
-                transition.spec.state &&
-                typeof transition.spec.state === "symbol") {
-                // Found END_STATE - route is complete
+                transition.spec.step &&
+                typeof transition.spec.step === "symbol") {
+                // Found END_ROUTE - route is complete
                 return {
-                    isRouteComplete: true
+                    isRouteComplete: true,
                 };
             }
             if (!target)
                 continue;
-            // If target should NOT be skipped, we found our state
-            if (!target.shouldSkip(extracted)) {
-                logger.debug(`[RoutingEngine] Found valid state after skipping: ${target.id}`);
+            // If target should NOT be skipped, we found our step
+            if (!target.shouldSkip(data)) {
+                logger.debug(`[RoutingEngine] Found valid step after skipping: ${target.id}`);
                 return {
-                    state: target,
+                    step: target,
                     condition: transition.condition,
                 };
             }
             // Target should be skipped too - recurse deeper
-            logger.debug(`[RoutingEngine] Skipping state ${target.id} (skipIf condition met), continuing traversal...`);
-            const result = this.findFirstValidStateRecursive(target, extracted, visited);
-            // If we found something (a valid state or END_STATE), return it
-            if (result.state || result.isRouteComplete) {
+            logger.debug(`[RoutingEngine] Skipping step ${target.id} (skipIf condition met), continuing traversal...`);
+            const result = this.findFirstValidStepRecursive(target, data, visited);
+            // If we found something (a valid step or END_ROUTE), return it
+            if (result.step || result.isRouteComplete) {
                 return result;
             }
         }
-        // No valid states or END_STATE found in this branch
+        // No valid steps or END_ROUTE found in this branch
         return {};
     }
     /**
-     * Identify valid next candidate states based on current state and extracted data
-     * Returns state with isRouteComplete flag if route is complete (all states skipped + has END_STATE transition)
+     * Identify valid next candidate steps based on current step and collected data
+     * Returns step with isRouteComplete flag if route is complete (all steps skipped + has END_ROUTE transition)
      */
-    getCandidateStates(route, currentState, extracted) {
+    getCandidateSteps(route, currentStep, data) {
         const candidates = [];
-        if (!currentState) {
-            const initialState = route.initialState;
-            if (initialState.shouldSkip(extracted)) {
-                // Initial state should be skipped - recursively traverse to find first non-skipped state or END_STATE
-                const result = this.findFirstValidStateRecursive(initialState, extracted, new Set());
+        if (!currentStep) {
+            const initialStep = route.initialStep;
+            if (initialStep.shouldSkip(data)) {
+                // Initial step should be skipped - recursively traverse to find first non-skipped step or END_ROUTE
+                const result = this.findFirstValidStepRecursive(initialStep, data, new Set());
                 if (result.isRouteComplete) {
-                    // All states are skipped and we reached END_STATE
-                    logger.debug(`[RoutingEngine] Route complete on entry: all states skipped, END_STATE reached`);
+                    // All steps are skipped and we reached END_ROUTE
+                    logger.debug(`[RoutingEngine] Route complete on entry: all steps skipped, END_ROUTE reached`);
                     return [
                         {
-                            state: initialState,
+                            step: initialStep,
                             condition: "Route complete - all data collected on entry",
                             isRouteComplete: true,
                         },
                     ];
                 }
-                else if (result.state) {
-                    // Found a non-skipped state
+                else if (result.step) {
+                    // Found a non-skipped step
                     candidates.push({
-                        state: result.state,
+                        step: result.step,
                         condition: result.condition,
-                        requiredData: result.state.requiredData,
-                        gatherFields: result.state.gatherFields,
+                        requires: result.step.requires,
+                        collectFields: result.step.collectFields,
                     });
                 }
-                // If no state found and not complete, fall through to return empty candidates
+                // If no step found and not complete, fall through to return empty candidates
             }
             else {
                 candidates.push({
-                    state: initialState,
-                    requiredData: initialState.requiredData,
-                    gatherFields: initialState.gatherFields,
+                    step: initialStep,
+                    requires: initialStep.requires,
+                    collectFields: initialStep.collectFields,
                 });
             }
             return candidates;
         }
-        const transitions = currentState.getTransitions();
+        const transitions = currentStep.getTransitions();
         let hasEndRoute = false;
         for (const transition of transitions) {
             const target = transition.getTarget();
-            // Check for END_STATE transition (no target state)
+            // Check for END_ROUTE transition (no target step)
             if (!target &&
-                transition.spec.state &&
-                typeof transition.spec.state === "symbol") {
+                transition.spec.step &&
+                typeof transition.spec.step === "symbol") {
                 hasEndRoute = true;
                 continue;
             }
             if (!target)
                 continue;
-            if (target.shouldSkip(extracted)) {
-                logger.debug(`[RoutingEngine] Skipping state ${target.id} (skipIf condition met)`);
-                // Recursively traverse to find next valid state or END_STATE
-                const result = this.findFirstValidStateRecursive(target, extracted, new Set([currentState.id]) // Already visited current state
+            if (target.shouldSkip(data)) {
+                logger.debug(`[RoutingEngine] Skipping step ${target.id} (skipIf condition met)`);
+                // Recursively traverse to find next valid step or END_ROUTE
+                const result = this.findFirstValidStepRecursive(target, data, new Set([currentStep.id]) // Already visited current step
                 );
                 if (result.isRouteComplete) {
                     hasEndRoute = true;
                 }
-                else if (result.state) {
-                    // Found a non-skipped state deeper in the chain
+                else if (result.step) {
+                    // Found a non-skipped step deeper in the chain
                     candidates.push({
-                        state: result.state,
+                        step: result.step,
                         condition: result.condition || transition.condition,
-                        requiredData: result.state.requiredData,
-                        gatherFields: result.state.gatherFields,
+                        requires: result.step.requires,
+                        collectFields: result.step.collectFields,
                     });
                 }
                 continue;
             }
             candidates.push({
-                state: target,
+                step: target,
                 condition: transition.condition,
-                requiredData: target.requiredData,
-                gatherFields: target.gatherFields,
+                requires: target.requires,
+                collectFields: target.collectFields,
             });
         }
         // If no valid candidates found
         if (candidates.length === 0) {
-            // If current state has END_STATE transition, the route is complete
+            // If current step has END_ROUTE transition, the route is complete
             if (hasEndRoute) {
-                logger.debug(`[RoutingEngine] Route complete: all states processed, END_STATE reached`);
-                // Return current state with completion flag
+                logger.debug(`[RoutingEngine] Route complete: all steps processed, END_ROUTE reached`);
+                // Return current step with completion flag
                 return [
                     {
-                        state: currentState,
+                        step: currentStep,
                         condition: "Route complete - all data collected",
                         isRouteComplete: true,
                     },
                 ];
             }
-            // Otherwise, stay in current state if it's still valid
-            if (!currentState.shouldSkip(extracted)) {
+            // Otherwise, stay in current step if it's still valid
+            if (!currentStep.shouldSkip(data)) {
                 candidates.push({
-                    state: currentState,
-                    condition: "Continue in current state (no valid transitions)",
-                    requiredData: currentState.requiredData,
-                    gatherFields: currentState.gatherFields,
+                    step: currentStep,
+                    condition: "Continue in current step (no valid transitions)",
+                    requires: currentStep.requires,
+                    collectFields: currentStep.collectFields,
                 });
             }
         }
         return candidates;
     }
     /**
-     * Full routing orchestration: builds prompt and schema, calls AI, selects route/state,
+     * Full routing orchestration: builds prompt and schema, calls AI, selects route/step,
      * and updates the session (including initialData merge when entering a new route).
      *
-     * OPTIMIZATION: If there's only 1 route, skips route scoring and only does state selection.
+     * OPTIMIZATION: If there's only 1 route, skips route scoring and only does step selection.
      */
-    async decideRouteAndState(params) {
+    async decideRouteAndStep(params) {
         const { routes, session, history, agentMeta, ai, context, signal } = params;
         if (routes.length === 0) {
             return { session };
         }
-        // OPTIMIZATION: Single route - skip route scoring, only do state selection
+        // OPTIMIZATION: Single route - skip route scoring, only do step selection
         if (routes.length === 1) {
-            return this.decideSingleRouteState({
+            return this.decideSingleRouteStep({
                 route: routes[0],
                 session,
                 history,
@@ -260,37 +260,37 @@ export class RoutingEngine {
             });
         }
         const lastUserMessage = getLastMessageFromHistory(history);
-        let activeRouteStates;
+        let activeRouteSteps;
         let activeRoute;
         let isRouteComplete = false;
         if (session.currentRoute) {
             activeRoute = routes.find((r) => r.id === session.currentRoute?.id);
             if (activeRoute) {
-                const currentState = session.currentState
-                    ? activeRoute.getState(session.currentState.id)
+                const currentStep = session.currentStep
+                    ? activeRoute.getStep(session.currentStep.id)
                     : undefined;
-                const candidates = this.getCandidateStates(activeRoute, currentState, session.extracted || {});
+                const candidates = this.getCandidateSteps(activeRoute, currentStep, session.data || {});
                 // Check if route is complete
                 if (candidates.length === 1 && candidates[0].isRouteComplete) {
                     isRouteComplete = true;
                     logger.debug(`[RoutingEngine] Route ${activeRoute.title} is complete - all data collected`);
-                    // Don't include states in routing if route is complete
-                    activeRouteStates = undefined;
+                    // Don't include steps in routing if route is complete
+                    activeRouteSteps = undefined;
                 }
                 else {
-                    activeRouteStates = candidates.map((c) => ({
-                        stateId: c.state.id,
-                        description: c.state.description || "",
+                    activeRouteSteps = candidates.map((c) => ({
+                        stepId: c.step.id,
+                        description: c.step.description || "",
                         condition: c.condition,
-                        requiredData: c.requiredData,
-                        gatherFields: c.gatherFields,
+                        requires: c.requires,
+                        collectFields: c.collectFields,
                     }));
-                    logger.debug(`[RoutingEngine] Found ${activeRouteStates.length} candidate states for active route`);
+                    logger.debug(`[RoutingEngine] Found ${activeRouteSteps.length} candidate steps for active route`);
                 }
             }
         }
-        const routingSchema = this.buildDynamicRoutingSchema(routes, undefined, activeRouteStates);
-        const routingPrompt = this.buildRoutingPrompt(history, routes, lastUserMessage, agentMeta, session, activeRouteStates);
+        const routingSchema = this.buildDynamicRoutingSchema(routes, undefined, activeRouteSteps);
+        const routingPrompt = this.buildRoutingPrompt(history, routes, lastUserMessage, agentMeta, session, activeRouteSteps);
         const routingResult = await ai.generateMessage({
             prompt: routingPrompt,
             history,
@@ -302,7 +302,7 @@ export class RoutingEngine {
             },
         });
         let selectedRoute;
-        let selectedState;
+        let selectedStep;
         let responseDirectives;
         let updatedSession = session;
         if (routingResult.structured?.routes) {
@@ -314,12 +314,12 @@ export class RoutingEngine {
             selectedRoute = routes.find((r) => r.id === decision.routeId);
             responseDirectives = routingResult.structured.responseDirectives;
             if (selectedRoute === activeRoute &&
-                routingResult.structured.selectedStateId &&
+                routingResult.structured.selectedStepId &&
                 activeRoute) {
-                selectedState = activeRoute.getState(routingResult.structured.selectedStateId);
-                if (selectedState) {
-                    logger.debug(`[RoutingEngine] AI selected state: ${selectedState.id} in active route`);
-                    logger.debug(`[RoutingEngine] State reasoning: ${routingResult.structured.stateReasoning}`);
+                selectedStep = activeRoute.getStep(routingResult.structured.selectedStepId);
+                if (selectedStep) {
+                    logger.debug(`[RoutingEngine] AI selected step: ${selectedStep.id} in active route`);
+                    logger.debug(`[RoutingEngine] Step reasoning: ${routingResult.structured.stepReasoning}`);
                 }
             }
             if (selectedRoute) {
@@ -328,7 +328,7 @@ export class RoutingEngine {
                     session.currentRoute.id !== selectedRoute.id) {
                     updatedSession = enterRoute(session, selectedRoute.id, selectedRoute.title);
                     if (selectedRoute.initialData) {
-                        updatedSession = mergeExtracted(updatedSession, selectedRoute.initialData);
+                        updatedSession = mergeCollected(updatedSession, selectedRoute.initialData);
                         logger.debug(`[RoutingEngine] Merged initial data:`, selectedRoute.initialData);
                     }
                     logger.debug(`[RoutingEngine] Entered route: ${selectedRoute.title}`);
@@ -337,17 +337,17 @@ export class RoutingEngine {
         }
         return {
             selectedRoute,
-            selectedState,
+            selectedStep,
             responseDirectives,
             session: updatedSession,
             isRouteComplete,
         };
     }
     /**
-     * Build prompt for state selection within a single route
+     * Build prompt for step selection within a single route
      * @private
      */
-    buildStateSelectionPrompt(route, currentState, candidates, extracted, history, lastMessage, agentMeta) {
+    buildStepSelectionPrompt(route, currentStep, candidates, data, history, lastMessage, agentMeta) {
         const pc = new PromptComposer();
         // Add agent metadata
         if (agentMeta?.name || agentMeta?.goal || agentMeta?.description) {
@@ -361,79 +361,79 @@ export class RoutingEngine {
         pc.addPersonality(personality);
         // Add route context
         pc.addInstruction(`Active Route: ${route.title}\nDescription: ${route.description || "N/A"}`);
-        // Add current state context
-        if (currentState) {
-            pc.addInstruction(`Current State: ${currentState.id}\nDescription: ${currentState.description || "N/A"}`);
+        // Add current step context
+        if (currentStep) {
+            pc.addInstruction(`Current Step: ${currentStep.id}\nDescription: ${currentStep.description || "N/A"}`);
         }
         else {
-            pc.addInstruction("Current State: None (entering route)");
+            pc.addInstruction("Current Step: None (entering route)");
         }
-        // Add extracted data context
-        if (Object.keys(extracted).length > 0) {
-            pc.addInstruction(`Extracted Data So Far:\n${JSON.stringify(extracted, null, 2)}`);
+        // Add collected data context
+        if (Object.keys(data).length > 0) {
+            pc.addInstruction(`Collected Data So Far:\n${JSON.stringify(data, null, 2)}`);
         }
         else {
-            pc.addInstruction("Extracted Data: None yet");
+            pc.addInstruction("Collected Data: None yet");
         }
         // Add conversation history
         pc.addInteractionHistory(history);
         pc.addLastMessage(lastMessage);
-        // Add candidate states
-        const stateDescriptions = candidates.map((candidate, idx) => {
+        // Add candidate steps
+        const stepDescriptions = candidates.map((candidate, idx) => {
             const parts = [
-                `${idx + 1}. State ID: ${candidate.state.id}`,
-                `   Description: ${candidate.state.description || "N/A"}`,
+                `${idx + 1}. Step ID: ${candidate.step.id}`,
+                `   Description: ${candidate.step.description || "N/A"}`,
             ];
             if (candidate.condition) {
                 parts.push(`   Condition: ${candidate.condition}`);
             }
-            if (candidate.requiredData && candidate.requiredData.length > 0) {
-                parts.push(`   Required Data: ${candidate.requiredData.join(", ")}`);
+            if (candidate.requires && candidate.requires.length > 0) {
+                parts.push(`   Required Data: ${candidate.requires.join(", ")}`);
             }
-            if (candidate.gatherFields && candidate.gatherFields.length > 0) {
-                parts.push(`   Gathers: ${candidate.gatherFields.join(", ")}`);
+            if (candidate.collectFields && candidate.collectFields.length > 0) {
+                parts.push(`   Collects: ${candidate.collectFields.join(", ")}`);
             }
             return parts.join("\n");
         });
-        pc.addInstruction(`Available States to Transition To:\n${stateDescriptions.join("\n\n")}`);
+        pc.addInstruction(`Available Steps to Transition To:\n${stepDescriptions.join("\n\n")}`);
         // Add decision instructions
         pc.addInstruction([
-            "Task: Decide which state to transition to based on:",
+            "Task: Decide which step to transition to based on:",
             "1. The user's current message and intent",
             "2. The conversation history and context",
-            "3. The extracted data we already have",
-            "4. The conditions and requirements of each state",
+            "3. The collected data we already have",
+            "4. The conditions and requirements of each step",
             "5. The logical flow of the conversation",
             "",
             "Rules:",
-            "- If a state has a condition, evaluate whether it's met based on context",
-            "- If a state requires data we don't have, consider if we should gather it now",
-            "- Choose the state that makes the most sense for moving the conversation forward",
-            "- States with skipIf conditions that are met have already been filtered out",
+            "- If a step has a condition, evaluate whether it's met based on context",
+            "- If a step requires data we don't have, consider if we should collect it now",
+            "- Choose the step that makes the most sense for moving the conversation forward",
+            "- Steps with skipIf conditions that are met have already been filtered out",
             "",
             "Return ONLY JSON matching the provided schema.",
         ].join("\n"));
         return pc.build();
     }
     /**
-     * Build schema for state selection
+     * Build schema for step selection
      * @private
      */
-    buildStateSelectionSchema(validStateIds) {
+    buildStepSelectionSchema(validStepIds) {
         return {
-            description: "State transition decision based on conversation context and extracted data",
+            description: "Step transition decision based on conversation context and collected data",
             type: "object",
             properties: {
                 reasoning: {
                     type: "string",
                     nullable: false,
-                    description: "Brief explanation of why this state was selected",
+                    description: "Brief explanation of why this step was selected",
                 },
-                selectedStateId: {
+                selectedStepId: {
                     type: "string",
                     nullable: false,
-                    description: "The ID of the selected state to transition to",
-                    enum: validStateIds,
+                    description: "The ID of the selected step to transition to",
+                    enum: validStepIds,
                 },
                 responseDirectives: {
                     type: "array",
@@ -441,11 +441,11 @@ export class RoutingEngine {
                     description: "Optional bullet points the response should address (concise)",
                 },
             },
-            required: ["reasoning", "selectedStateId"],
+            required: ["reasoning", "selectedStepId"],
             additionalProperties: false,
         };
     }
-    buildDynamicRoutingSchema(routes, extrasSchema, activeRouteStates) {
+    buildDynamicRoutingSchema(routes, extrasSchema, activeRouteSteps) {
         const routeIds = routes.map((r) => r.id);
         const routeProperties = {};
         for (const id of routeIds) {
@@ -482,24 +482,24 @@ export class RoutingEngine {
             required: ["context", "routes"],
             additionalProperties: false,
         };
-        // Add state selection fields if there's an active route with states
-        if (activeRouteStates && activeRouteStates.length > 0) {
+        // Add step selection fields if there's an active route with steps
+        if (activeRouteSteps && activeRouteSteps.length > 0) {
             base.properties = base.properties || {};
-            base.properties.selectedStateId = {
+            base.properties.selectedStepId = {
                 type: "string",
                 nullable: false,
-                description: "The state ID to transition to within the active route (required if continuing in current route)",
-                enum: activeRouteStates.map((s) => s.stateId),
+                description: "The step ID to transition to within the active route (required if continuing in current route)",
+                enum: activeRouteSteps.map((s) => s.stepId),
             };
-            base.properties.stateReasoning = {
+            base.properties.stepReasoning = {
                 type: "string",
                 nullable: false,
-                description: "Brief explanation of why this state was selected",
+                description: "Brief explanation of why this step was selected",
             };
             base.required = [
                 ...(base.required || []),
-                "selectedStateId",
-                "stateReasoning",
+                "selectedStepId",
+                "stepReasoning",
             ];
         }
         if (extrasSchema) {
@@ -508,7 +508,7 @@ export class RoutingEngine {
         }
         return base;
     }
-    buildRoutingPrompt(history, routes, lastMessage, agentMeta, session, activeRouteStates) {
+    buildRoutingPrompt(history, routes, lastMessage, agentMeta, session, activeRouteSteps) {
         const pc = new PromptComposer();
         if (agentMeta?.name || agentMeta?.goal || agentMeta?.description) {
             pc.addAgentMeta({
@@ -526,45 +526,45 @@ export class RoutingEngine {
                 "Current conversation context:",
                 `- Active route: ${session.currentRoute.title} (${session.currentRoute.id})`,
             ];
-            if (session.currentState) {
-                sessionInfo.push(`- Current state: ${session.currentState.id}`);
-                if (session.currentState.description) {
-                    sessionInfo.push(`  "${session.currentState.description}"`);
+            if (session.currentStep) {
+                sessionInfo.push(`- Current step: ${session.currentStep.id}`);
+                if (session.currentStep.description) {
+                    sessionInfo.push(`  "${session.currentStep.description}"`);
                 }
             }
-            if (session.extracted && Object.keys(session.extracted).length > 0) {
-                sessionInfo.push(`- Extracted data: ${JSON.stringify(session.extracted)}`);
+            if (session.data && Object.keys(session.data).length > 0) {
+                sessionInfo.push(`- Collected data: ${JSON.stringify(session.data)}`);
             }
             sessionInfo.push("Note: User is mid-conversation. They may want to continue current route or switch to a new one based on their intent.");
             pc.addInstruction(sessionInfo.join("\n"));
-            // Add available states for the active route
-            if (activeRouteStates && activeRouteStates.length > 0) {
-                const stateInfo = [
+            // Add available steps for the active route
+            if (activeRouteSteps && activeRouteSteps.length > 0) {
+                const stepInfo = [
                     "",
-                    "Available states in active route (choose one to transition to):",
+                    "Available steps in active route (choose one to transition to):",
                 ];
-                activeRouteStates.forEach((state, idx) => {
-                    stateInfo.push(`${idx + 1}. State: ${state.stateId}`);
-                    if (state.description) {
-                        stateInfo.push(`   Description: ${state.description}`);
+                activeRouteSteps.forEach((step, idx) => {
+                    stepInfo.push(`${idx + 1}. Step: ${step.stepId}`);
+                    if (step.description) {
+                        stepInfo.push(`   Description: ${step.description}`);
                     }
-                    if (state.condition) {
-                        stateInfo.push(`   Condition: ${state.condition}`);
+                    if (step.condition) {
+                        stepInfo.push(`   Condition: ${step.condition}`);
                     }
-                    if (state.requiredData && state.requiredData.length > 0) {
-                        stateInfo.push(`   Required data: ${state.requiredData.join(", ")}`);
+                    if (step.requires && step.requires.length > 0) {
+                        stepInfo.push(`   Required data: ${step.requires.join(", ")}`);
                     }
-                    if (state.gatherFields && state.gatherFields.length > 0) {
-                        stateInfo.push(`   Will gather: ${state.gatherFields.join(", ")}`);
+                    if (step.collectFields && step.collectFields.length > 0) {
+                        stepInfo.push(`   Will collect: ${step.collectFields.join(", ")}`);
                     }
                 });
-                stateInfo.push("");
-                stateInfo.push("IMPORTANT: You MUST select a state to transition to. Evaluate which state makes the most sense based on:");
-                stateInfo.push("- The conversation flow and what's been collected");
-                stateInfo.push("- What data is still needed vs already present");
-                stateInfo.push("- The logical next step in the conversation");
-                stateInfo.push("- Whether conditions for states are met");
-                pc.addInstruction(stateInfo.join("\n"));
+                stepInfo.push("");
+                stepInfo.push("IMPORTANT: You MUST select a step to transition to. Evaluate which step makes the most sense based on:");
+                stepInfo.push("- The conversation flow and what's been collected");
+                stepInfo.push("- What data is still needed vs already present");
+                stepInfo.push("- The logical next step in the conversation");
+                stepInfo.push("- Whether conditions for steps are met");
+                pc.addInstruction(stepInfo.join("\n"));
             }
         }
         pc.addInteractionHistory(history);