@falai/agent 0.5.5 → 0.6.1

package/examples/travel-agent.ts

@@ -223,7 +223,7 @@ async function createTravelAgent() {
     description:
       "Helps the customer find and book a flight to their desired destination.",
     conditions: ["The customer wants to book a flight"],
-    gatherSchema: {
+    extractionSchema: {
       type: "object",
       properties: {
         destination: {
@@ -270,85 +270,67 @@ async function createTravelAgent() {
   });
 
   // Build the route flow with data extraction and smart state progression
-  const askDestination = flightBookingRoute.initialState.transitionTo(
-    {
-      chatState: "Ask about the destination",
-      gather: ["destination"],
-      skipIf: (extracted) => !!extracted.destination,
-    },
-    "Customer needs to specify their travel destination"
-  );
+  const askDestination = flightBookingRoute.initialState.transitionTo({
+    chatState: "Ask about the destination",
+    gather: ["destination"],
+    skipIf: (extracted) => !!extracted.destination,
+    condition: "Customer needs to specify their travel destination",
+  });
 
-  const enrichDestination = askDestination.transitionTo(
-    {
-      toolState: lookupDestinationCode,
-      requiredData: ["destination"],
-    },
-    "Destination provided, lookup airport code"
-  );
+  const enrichDestination = askDestination.transitionTo({
+    toolState: lookupDestinationCode,
+    requiredData: ["destination"],
+    condition: "Destination provided, lookup airport code",
+  });
 
-  const askDates = enrichDestination.transitionTo(
-    {
-      chatState: "Ask about preferred travel dates",
-      gather: ["departureDate"],
-      skipIf: (extracted) => !!extracted.departureDate,
-      requiredData: ["destination"],
-    },
-    "Destination confirmed, need travel dates"
-  );
+  const askDates = enrichDestination.transitionTo({
+    chatState: "Ask about preferred travel dates",
+    gather: ["departureDate"],
+    skipIf: (extracted) => !!extracted.departureDate,
+    requiredData: ["destination"],
+    condition: "Destination confirmed, need travel dates",
+  });
 
-  const askPassengers = askDates.transitionTo(
-    {
-      chatState: "Ask for number of passengers",
-      gather: ["passengers"],
-      skipIf: (extracted) => !!extracted.passengers,
-      requiredData: ["destination", "departureDate"],
-    },
-    "Dates confirmed, need passenger count"
-  );
+  const askPassengers = askDates.transitionTo({
+    chatState: "Ask for number of passengers",
+    gather: ["passengers"],
+    skipIf: (extracted) => !!extracted.passengers,
+    requiredData: ["destination", "departureDate"],
+    condition: "Dates confirmed, need passenger count",
+  });
 
-  const searchFlightsState = askPassengers.transitionTo(
-    {
-      toolState: searchFlights,
-      // Triggered when shouldSearchFlights flag is set by hook
-    },
-    "All basic info gathered, search for available flights"
-  );
+  const searchFlightsState = askPassengers.transitionTo({
+    toolState: searchFlights,
+    // Triggered when shouldSearchFlights flag is set by hook
+    condition: "All basic info gathered, search for available flights",
+  });
 
-  const presentFlights = searchFlightsState.transitionTo(
-    {
-      chatState: "Present available flights and ask which one works for them",
-    },
-    "Flight search complete, present options to customer"
-  );
+  const presentFlights = searchFlightsState.transitionTo({
+    chatState: "Present available flights and ask which one works for them",
+    condition: "Flight search complete, present options to customer",
+  });
 
   // Happy path: customer selects a flight
-  const confirmBooking = presentFlights.transitionTo(
-    {
-      chatState: "Confirm booking details before proceeding",
-      gather: ["cabinClass", "urgency"], // Additional optional data
-    },
-    "Customer interested in a flight, confirm booking details"
-  );
+  const confirmBooking = presentFlights.transitionTo({
+    chatState: "Confirm booking details before proceeding",
+    gather: ["cabinClass", "urgency"], // Additional optional data
+    condition: "Customer interested in a flight, confirm booking details",
+  });
 
-  const bookFlightState = confirmBooking.transitionTo(
-    {
-      toolState: bookFlight,
-    },
-    "Customer confirmed, proceed with booking"
-  );
+  const bookFlightState = confirmBooking.transitionTo({
+    toolState: bookFlight,
+    condition: "Customer confirmed, proceed with booking",
+  });
 
-  const provideConfirmation = bookFlightState.transitionTo(
-    {
-      chatState: "Provide confirmation number and booking summary",
-    },
-    "Booking completed successfully"
-  );
+  const provideConfirmation = bookFlightState.transitionTo({
+    chatState: "Provide confirmation number and booking summary",
+    condition: "Booking completed successfully",
+  });
 
-  provideConfirmation.transitionTo(
-    { state: END_ROUTE },
-    "Customer has confirmation, booking flow complete"
-  );
+  provideConfirmation.transitionTo({
+    state: END_ROUTE,
+    condition: "Customer has confirmation, booking flow complete",
+  });
 
   // Add route-specific guidelines
   flightBookingRoute.createGuideline({
@@ -370,7 +352,7 @@ async function createTravelAgent() {
     description:
       "Retrieves the customer's booking status and provides relevant information.",
     conditions: ["The customer wants to check their booking status"],
-    gatherSchema: {
+    extractionSchema: {
       type: "object",
       properties: {
         confirmationNumber: {
@@ -386,34 +368,29 @@ async function createTravelAgent() {
     },
   });
 
-  const askConfirmation = bookingStatusRoute.initialState.transitionTo(
-    {
-      chatState: "Ask for the confirmation number or booking reference",
-      gather: ["confirmationNumber"],
-      skipIf: (extracted) => !!extracted.confirmationNumber,
-    },
-    "Customer wants to check booking status but hasn't provided confirmation number"
-  );
+  const askConfirmation = bookingStatusRoute.initialState.transitionTo({
+    chatState: "Ask for the confirmation number or booking reference",
+    gather: ["confirmationNumber"],
+    skipIf: (extracted) => !!extracted.confirmationNumber,
+    condition:
+      "Customer wants to check booking status but hasn't provided confirmation number",
+  });
 
-  const checkStatus = askConfirmation.transitionTo(
-    {
-      toolState: getBookingStatus,
-      requiredData: ["confirmationNumber"],
-    },
-    "Confirmation number provided, look up booking details"
-  );
+  const checkStatus = askConfirmation.transitionTo({
+    toolState: getBookingStatus,
+    requiredData: ["confirmationNumber"],
+    condition: "Confirmation number provided, look up booking details",
+  });
 
-  const provideStatus = checkStatus.transitionTo(
-    {
-      chatState: "Provide booking status and relevant information",
-    },
-    "Booking status retrieved successfully"
-  );
+  const provideStatus = checkStatus.transitionTo({
+    chatState: "Provide booking status and relevant information",
+    condition: "Booking status retrieved successfully",
+  });
 
-  provideStatus.transitionTo(
-    { state: END_ROUTE },
-    "Booking information provided to customer"
-  );
+  provideStatus.transitionTo({
+    state: END_ROUTE,
+    condition: "Booking information provided to customer",
+  });
 
   // Global guidelines
   agent.createGuideline({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@falai/agent",
-  "version": "0.5.5",
+  "version": "0.6.1",
   "description": "Standalone, strongly-typed AI Agent framework with route DSL and AI provider strategy",
   "type": "module",
   "main": "./dist/cjs/index.js",

package/src/core/ResponseEngine.ts

@@ -30,9 +30,9 @@ export class ResponseEngine<TContext = unknown> {
     }
 
     // Add gather fields from current state
-    if (currentState?.gatherFields && route.gatherSchema?.properties) {
+    if (currentState?.gatherFields && route.extractionSchema?.properties) {
       for (const field of currentState.gatherFields) {
-        const fieldSchema = route.gatherSchema.properties[field];
+        const fieldSchema = route.extractionSchema.properties[field];
         if (fieldSchema) {
           base.properties![field] = fieldSchema;
         }

package/src/core/Route.ts

@@ -2,7 +2,12 @@
  * Route (Journey) DSL implementation
  */
 
-import type { RouteOptions, RouteRef } from "../types/route";
+import type {
+  RouteOptions,
+  RouteRef,
+  TransitionSpec,
+  TransitionResult,
+} from "../types/route";
 import type { StructuredSchema } from "../types/schema";
 import type { Guideline } from "../types/agent";
 
@@ -22,7 +27,7 @@ export class Route<TContext = unknown, TExtracted = unknown> {
   public readonly prohibitions: string[];
   public readonly initialState: State<TContext, TExtracted>;
   public readonly responseOutputSchema?: StructuredSchema;
-  public readonly gatherSchema?: StructuredSchema;
+  public readonly extractionSchema?: StructuredSchema;
   public readonly initialData?: Partial<TExtracted>;
   private routingExtrasSchema?: StructuredSchema;
   private guidelines: Guideline[] = [];
@@ -42,7 +47,7 @@ export class Route<TContext = unknown, TExtracted = unknown> {
     );
     this.routingExtrasSchema = options.routingExtrasSchema;
     this.responseOutputSchema = options.responseOutputSchema;
-    this.gatherSchema = options.gatherSchema;
+    this.extractionSchema = options.extractionSchema;
     this.initialData = options.initialData;
 
     // Initialize guidelines from options
@@ -51,6 +56,32 @@ export class Route<TContext = unknown, TExtracted = unknown> {
         this.createGuideline(guideline);
       });
     }
+
+    // Build sequential steps if provided
+    if (options.steps && options.steps.length > 0) {
+      this.buildSequentialSteps(options.steps);
+    }
+  }
+
+  /**
+   * Build a sequential state machine from an array of steps
+   * @private
+   */
+  private buildSequentialSteps(
+    steps: Array<TransitionSpec<TContext, TExtracted>>
+  ): void {
+    // Import END_ROUTE dynamically to avoid circular dependency
+    const END_ROUTE = Symbol.for("END_ROUTE");
+
+    let currentState: TransitionResult<TContext, TExtracted> =
+      this.initialState;
+
+    for (const step of steps) {
+      currentState = currentState.transitionTo(step);
+    }
+
+    // End the route
+    currentState.transitionTo({ state: END_ROUTE });
   }
 
   /**

package/src/core/State.ts

@@ -43,12 +43,10 @@ export class State<TContext = unknown, TExtracted = unknown> {
    * Create a transition from this state to another
    *
    * @param spec - Transition specification (chatState, toolState, or direct state)
-   * @param condition - Optional condition for this transition
    * @returns TransitionResult that supports chaining
    */
   transitionTo(
-    spec: TransitionSpec<TContext, TExtracted>,
-    condition?: string
+    spec: TransitionSpec<TContext, TExtracted>
   ): TransitionResult<TContext, TExtracted> {
     // Handle END_ROUTE
     if (
@@ -58,8 +56,7 @@ export class State<TContext = unknown, TExtracted = unknown> {
     ) {
       const endTransition = new Transition<TContext, TExtracted>(
         this.getRef(),
-        { state: END_ROUTE },
-        condition
+        { state: END_ROUTE, condition: spec.condition }
       );
       this.transitions.push(endTransition);
 
@@ -71,8 +68,7 @@ export class State<TContext = unknown, TExtracted = unknown> {
     if (spec.state && typeof spec.state !== "symbol") {
       const transition = new Transition<TContext, TExtracted>(
         this.getRef(),
-        spec,
-        condition
+        spec
       );
       this.transitions.push(transition);
 
@@ -90,8 +86,7 @@ export class State<TContext = unknown, TExtracted = unknown> {
     );
     const transition = new Transition<TContext, TExtracted>(
       this.getRef(),
-      spec,
-      condition
+      spec
     );
     transition.setTarget(targetState);
 
@@ -160,10 +155,8 @@ export class State<TContext = unknown, TExtracted = unknown> {
 
     return {
       ...ref,
-      transitionTo: (
-        spec: TransitionSpec<TContext, TExtracted>,
-        condition?: string
-      ) => stateInstance.transitionTo(spec, condition),
+      transitionTo: (spec: TransitionSpec<TContext, TExtracted>) =>
+        stateInstance.transitionTo(spec),
     };
   }
 

package/src/core/Transition.ts

@@ -10,12 +10,15 @@ import type { State } from "./State";
  */
 export class Transition<TContext = unknown, TExtracted = unknown> {
   private target?: State<TContext, TExtracted>;
+  public readonly condition?: string;
 
   constructor(
     public readonly source: StateRef,
-    public readonly spec: TransitionSpec<TContext, TExtracted>,
-    public readonly condition?: string
-  ) {}
+    public readonly spec: TransitionSpec<TContext, TExtracted>
+  ) {
+    // Extract condition from spec for convenience
+    this.condition = spec.condition;
+  }
 
   /**
    * Set the target state for this transition

package/src/types/route.ts

@@ -30,7 +30,7 @@ import type { Guideline } from "./agent";
 
 /**
  * Options for creating a route
- * @template TExtracted - Type of data extracted throughout the route (inferred from gatherSchema)
+ * @template TExtracted - Type of data extracted throughout the route (inferred from extractionSchema)
  */
 export interface RouteOptions<TExtracted = unknown> {
   /** Custom ID for the route (optional - will generate deterministic ID from title if not provided) */
@@ -57,13 +57,19 @@ export interface RouteOptions<TExtracted = unknown> {
    * NEW: Schema defining data to extract throughout this route
    * This creates a type-safe contract for what data the route collects
    */
-  gatherSchema?: StructuredSchema;
+  extractionSchema?: StructuredSchema;
   /**
    * NEW: Initial data to pre-populate when entering this route
    * Useful for restoring sessions or pre-filling known information
    * States with skipIf conditions will be automatically bypassed if data is present
    */
   initialData?: Partial<TExtracted>;
+  /**
+   * NEW: Sequential steps for simple linear flows
+   * If provided, automatically chains the steps from initialState to END_ROUTE
+   * For complex flows with branching, build the state machine manually instead
+   */
+  steps?: TransitionSpec<unknown, TExtracted>[];
 }
 
 /**
@@ -81,7 +87,7 @@ export interface TransitionSpec<TContext = unknown, TExtracted = unknown> {
   state?: StateRef | symbol;
   /**
    * NEW: Fields to gather from the conversation in this state
-   * These should match keys in the route's gatherSchema
+   * These should match keys in the route's extractionSchema
    */
   gather?: string[];
   /**
@@ -97,6 +103,11 @@ export interface TransitionSpec<TContext = unknown, TExtracted = unknown> {
    * Uses string[] for developer-friendly usage (same as gather)
    */
   requiredData?: string[];
+  /**
+   * Optional condition for this transition
+   * Description of when this transition should be taken
+   */
+  condition?: string;
 }
 
 /**
@@ -107,7 +118,6 @@ export interface TransitionResult<TContext = unknown, TExtracted = unknown>
   extends StateRef {
   /** Allow chaining transitions */
   transitionTo: (
-    spec: TransitionSpec<TContext, TExtracted>,
-    condition?: string
+    spec: TransitionSpec<TContext, TExtracted>
   ) => TransitionResult<TContext, TExtracted>;
 }