@falai/agent 0.3.0 → 0.3.10

package/src/core/PromptBuilder.ts

@@ -26,6 +26,7 @@ export enum BuiltInSection {
   OBSERVATIONS = "observations",
   CAPABILITIES = "capabilities",
   ACTIVE_ROUTES = "active_routes",
+  DOMAINS = "domains",
 }
 
 /**
@@ -431,7 +432,14 @@ When you detect any of these situations, consider which route would be most appr
    * Add active routes information
    */
   addActiveRoutes(
-    routes: Array<{ title: string; description?: string; conditions: string[] }>
+    routes: Array<{
+      title: string;
+      description?: string;
+      conditions: string[];
+      domains?: string[];
+      rules?: string[];
+      prohibitions?: string[];
+    }>
   ): this {
     if (routes.length > 0) {
       const routesString = routes
@@ -441,7 +449,29 @@ When you detect any of these situations, consider which route would be most appr
               ? `\n  Triggered when: ${route.conditions.join(" OR ")}`
               : "";
           const desc = route.description ? `\n  ${route.description}` : "";
-          return `${i + 1}) ${route.title}${desc}${conditions}`;
+          
+          let domainInfo = "";
+          if (route.domains !== undefined) {
+            if (route.domains.length === 0) {
+              domainInfo = "\n  Available tools: None (conversation only)";
+            } else {
+              domainInfo = `\n  Available tools: ${route.domains.join(", ")}`;
+            }
+          }
+
+          let rulesInfo = "";
+          if (route.rules && route.rules.length > 0) {
+            const rulesList = route.rules.map((r, idx) => `${idx + 1}. ${r}`).join("; ");
+            rulesInfo = `\n  RULES: ${rulesList}`;
+          }
+
+          let prohibitionsInfo = "";
+          if (route.prohibitions && route.prohibitions.length > 0) {
+            const prohibitionsList = route.prohibitions.map((p, idx) => `${idx + 1}. ${p}`).join("; ");
+            prohibitionsInfo = `\n  PROHIBITIONS: ${prohibitionsList}`;
+          }
+
+          return `${i + 1}) ${route.title}${desc}${conditions}${domainInfo}${rulesInfo}${prohibitionsInfo}`;
         })
         .join("\n\n");
 
@@ -452,7 +482,11 @@ When you detect any of these situations, consider which route would be most appr
 {routes_string}
 ###
 
-These routes represent different paths the conversation can take. Choose the most appropriate route based on the user's needs.`,
+These routes represent different paths the conversation can take. Choose the most appropriate route based on the user's needs.
+IMPORTANT: 
+- If a route specifies available tools, you can ONLY call tools from those domains when following that route.
+- If a route has RULES, you MUST follow them when you choose that route.
+- If a route has PROHIBITIONS, you MUST NEVER do those things when you choose that route.`,
         { routes_string: routesString },
         SectionStatus.ACTIVE
       );
@@ -460,6 +494,39 @@ These routes represent different paths the conversation can take. Choose the mos
     return this;
   }
 
+  /**
+   * Add domains (tools) information
+   */
+  addDomains(
+    domains: Record<string, Record<string, unknown>>
+  ): this {
+    const domainNames = Object.keys(domains);
+    if (domainNames.length > 0) {
+      const domainsString = domainNames
+        .map((name, i) => {
+          const toolNames = Object.keys(domains[name]);
+          const tools = toolNames.join(", ");
+          return `${i + 1}) Domain "${name}": ${tools}`;
+        })
+        .join("\n");
+
+      this.addSection(
+        BuiltInSection.DOMAINS,
+        `Available tool domains:
+###
+{domains_string}
+###
+
+These are the tool domains registered in the system. Each domain contains specific tools/methods.
+When calling tools, use the format: domain.toolName (e.g., "payment.processPayment").`,
+        { domains_string: domainsString },
+        SectionStatus.ACTIVE
+      );
+    }
+    return this;
+  }
+
+
   /**
    * Add JSON response schema instructions
    */

package/src/core/Route.ts

@@ -16,6 +16,9 @@ export class Route<TContext = unknown> {
   public readonly title: string;
   public readonly description?: string;
   public readonly conditions: string[];
+  public readonly domains?: string[];
+  public readonly rules: string[];
+  public readonly prohibitions: string[];
   public readonly initialState: State<TContext>;
   private guidelines: Guideline[] = [];
 
@@ -25,6 +28,9 @@ export class Route<TContext = unknown> {
     this.title = options.title;
     this.description = options.description;
     this.conditions = options.conditions || [];
+    this.domains = options.domains;
+    this.rules = options.rules || ([] as string[]);
+    this.prohibitions = options.prohibitions || ([] as string[]);
     this.initialState = new State<TContext>(this.id, "Initial state");
 
     // Initialize guidelines from options
@@ -54,6 +60,28 @@ export class Route<TContext = unknown> {
     return [...this.guidelines];
   }
 
+  /**
+   * Get allowed domain names for this route
+   * @returns Array of domain names, or undefined if all domains are allowed
+   */
+  getDomains(): string[] | undefined {
+    return this.domains ? [...this.domains] : undefined;
+  }
+
+  /**
+   * Get rules for this route
+   */
+  getRules(): string[] {
+    return [...this.rules];
+  }
+
+  /**
+   * Get prohibitions for this route
+   */
+  getProhibitions(): string[] {
+    return [...this.prohibitions];
+  }
+
   /**
    * Get route reference
    */

package/src/types/route.ts

@@ -41,6 +41,12 @@ export interface RouteOptions {
   conditions?: string[];
   /** Initial guidelines for this route */
   guidelines?: Guideline[];
+  /** Domain names that are allowed in this route (undefined = all domains) */
+  domains?: string[];
+  /** Absolute rules the agent must follow in this route */
+  rules?: string[];
+  /** Absolute prohibitions the agent must never do in this route */
+  prohibitions?: string[];
 }
 
 /**