@falai/agent 1.1.1 → 1.1.3

package/src/core/Agent.ts

@@ -17,8 +17,9 @@ import type {
   StructuredSchema,
   ValidationError,
   ValidationResult,
-
+  AiProvider,
 } from "../types";
+import { CompositionMode } from "../types";
 import type { StreamOptions, GenerateOptions, RespondParams } from "./ResponseModal";
 import {
   mergeCollected,
@@ -63,20 +64,20 @@ class RouteConfigurationError extends Error {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class Agent<TContext = any, TData = any> {
-  private terms: Term<TContext, TData>[] = [];
-  private guidelines: Guideline<TContext, TData>[] = [];
-  private tools: Tool<TContext, TData>[] = [];
-  private routes: Route<TContext, TData>[] = [];
-  private agentRules: Template<TContext, TData>[] = [];
-  private agentProhibitions: Template<TContext, TData>[] = [];
-  private context: TContext | undefined;
-  private persistenceManager: PersistenceManager<TData> | undefined;
-  private routingEngine: RoutingEngine<TContext, TData>;
-  private responseModal: ResponseModal<TContext, TData>;
-  private currentSession?: SessionState<TData>;
-  private knowledgeBase: Record<string, unknown> = {};
-  private schema?: StructuredSchema;
-  private collectedData: Partial<TData> = {};
+  private _terms: Term<TContext, TData>[] = [];
+  private _guidelines: Guideline<TContext, TData>[] = [];
+  private _tools: Tool<TContext, TData>[] = [];
+  private _routes: Route<TContext, TData>[] = [];
+  private _rules: Template<TContext, TData>[] = [];
+  private _prohibitions: Template<TContext, TData>[] = [];
+  private _context: TContext | undefined;
+  private _persistenceManager: PersistenceManager<TData> | undefined;
+  private _routingEngine: RoutingEngine<TContext, TData>;
+  private _responseModal: ResponseModal<TContext, TData>;
+  private _currentSession?: SessionState<TData>;
+  private _knowledgeBase: Record<string, unknown> = {};
+  private _schema?: StructuredSchema;
+  private _collectedData: Partial<TData> = {};
 
   /** Public session manager for easy session management */
   public session: SessionManager<TData>;
@@ -84,7 +85,7 @@ export class Agent<TContext = any, TData = any> {
   /** Public tool manager for simplified tool creation and management */
   public tool: ToolManager<TContext, TData>;
 
-  constructor(private readonly options: AgentOptions<TContext, TData>) {
+  constructor(private options: AgentOptions<TContext, TData>) {
     // Set log level based on debug option
     if (options.debug) {
       logger.setLevel(LoggerLevel.DEBUG);
@@ -99,17 +100,17 @@ export class Agent<TContext = any, TData = any> {
 
     // Initialize and validate agent-level schema if provided
     if (options.schema) {
-      this.schema = options.schema;
-      this.validateSchema(this.schema);
+      this._schema = options.schema;
+      this.validateSchema(this._schema);
       logger.debug("[Agent] Agent-level schema initialized and validated");
     }
 
     // Initialize context if provided
-    this.context = options.context;
+    this._context = options.context;
 
     // Initialize collected data with initial data if provided
     if (options.initialData) {
-      if (this.schema) {
+      if (this._schema) {
         const validation = this.validateData(options.initialData);
         if (!validation.valid) {
           throw new Error(
@@ -117,20 +118,20 @@ export class Agent<TContext = any, TData = any> {
           );
         }
       }
-      this.collectedData = { ...options.initialData };
-      logger.debug("[Agent] Initial data set:", this.collectedData);
+      this._collectedData = { ...options.initialData };
+      logger.debug("[Agent] Initial data set:", this._collectedData);
     }
 
     // Initialize current session if provided
-    this.currentSession = options.session;
+    this._currentSession = options.session;
 
     // Initialize routing engine
-    this.routingEngine = new RoutingEngine<TContext, TData>({
+    this._routingEngine = new RoutingEngine<TContext, TData>({
       routeSwitchMargin: options.routeSwitchMargin,
     });
 
     // Initialize ResponseModal for handling all response generation
-    this.responseModal = new ResponseModal<TContext, TData>(this);
+    this._responseModal = new ResponseModal<TContext, TData>(this);
 
     // Initialize persistence if configured
     if (options.persistence) {
@@ -148,7 +149,7 @@ export class Agent<TContext = any, TData = any> {
           throw new Error("Persistence adapter must provide a messageRepository");
         }
 
-        this.persistenceManager = new PersistenceManager<TData>(options.persistence);
+        this._persistenceManager = new PersistenceManager<TData>(options.persistence);
 
         // Initialize the adapter if it has an initialize method
         if (options.persistence.adapter.initialize) {
@@ -187,10 +188,10 @@ export class Agent<TContext = any, TData = any> {
 
     // Initialize agent-level rules and prohibitions
     if (options.rules) {
-      this.agentRules = [...options.rules];
+      this._rules = [...options.rules];
     }
     if (options.prohibitions) {
-      this.agentProhibitions = [...options.prohibitions];
+      this._prohibitions = [...options.prohibitions];
     }
 
     if (options.routes) {
@@ -201,11 +202,11 @@ export class Agent<TContext = any, TData = any> {
 
     // Initialize knowledge base
     if (options.knowledgeBase) {
-      this.knowledgeBase = { ...options.knowledgeBase };
+      this._knowledgeBase = { ...options.knowledgeBase };
     }
 
     // Initialize session manager with reference to this agent for bidirectional sync
-    this.session = new SessionManager<TData>(this.persistenceManager, this);
+    this.session = new SessionManager<TData>(this._persistenceManager, this);
 
     // Initialize tool manager with proper type inference
     this.tool = new ToolManager<TContext, TData>(this);
@@ -217,8 +218,8 @@ export class Agent<TContext = any, TData = any> {
       this.session.getOrCreate(options.sessionId).then((session) => {
         // Sync session data to agent collected data
         if (session.data && Object.keys(session.data).length > 0) {
-          this.collectedData = { ...session.data };
-          logger.debug("[Agent] Synced session data to collected data:", this.collectedData);
+          this._collectedData = { ...session.data };
+          logger.debug("[Agent] Synced session data to collected data:", this._collectedData);
         }
       }).catch((err) => {
         logger.error("Failed to start session", err);
@@ -259,7 +260,7 @@ export class Agent<TContext = any, TData = any> {
    * Validate data against the agent-level schema
    */
   validateData(data: Partial<TData>): ValidationResult {
-    if (!this.schema) {
+    if (!this._schema) {
       // No schema defined, consider all data valid
       return { valid: true, errors: [], warnings: [] };
     }
@@ -268,9 +269,9 @@ export class Agent<TContext = any, TData = any> {
     const warnings: ValidationError[] = [];
 
     // Basic validation - check if provided fields exist in schema
-    if (this.schema.properties) {
+    if (this._schema.properties) {
       for (const [key, value] of Object.entries(data)) {
-        if (!(key in this.schema.properties)) {
+        if (!(key in this._schema.properties)) {
           errors.push({
             field: key,
             value,
@@ -282,8 +283,8 @@ export class Agent<TContext = any, TData = any> {
     }
 
     // Check required fields if specified
-    if (this.schema.required && Array.isArray(this.schema.required)) {
-      for (const requiredField of this.schema.required) {
+    if (this._schema.required && Array.isArray(this._schema.required)) {
+      for (const requiredField of this._schema.required) {
         if (!(requiredField in data) || data[requiredField as keyof TData] === undefined) {
           warnings.push({
             field: requiredField,
@@ -308,12 +309,12 @@ export class Agent<TContext = any, TData = any> {
    * @returns true if field exists in schema or no schema is defined, false otherwise
    */
   isValidSchemaField(field: keyof TData): boolean {
-    if (!this.schema || !this.schema.properties) {
+    if (!this._schema || !this._schema.properties) {
       // No schema defined, consider all fields valid
       return true;
     }
 
-    return field as string in this.schema.properties;
+    return field as string in this._schema.properties;
   }
 
   /**
@@ -322,7 +323,7 @@ export class Agent<TContext = any, TData = any> {
   getCollectedData(): Partial<TData> {
     // Ensure agent collected data is synced with session
     this.syncSessionDataToCollectedData();
-    return { ...this.collectedData };
+    return { ...this._collectedData };
   }
 
   /**
@@ -343,35 +344,39 @@ export class Agent<TContext = any, TData = any> {
     }
 
     // Merge updates with current data
-    const previousData = { ...this.collectedData };
-    this.collectedData = {
-      ...this.collectedData,
+    const previousData = { ...this._collectedData };
+    this._collectedData = {
+      ...this._collectedData,
       ...updates
     };
 
     // Trigger agent-level lifecycle hook if configured
     if (this.options.hooks?.onDataUpdate) {
-      this.collectedData = await this.options.hooks.onDataUpdate(
-        this.collectedData,
+      this._collectedData = await this.options.hooks.onDataUpdate(
+        this._collectedData,
         previousData
       );
     }
 
     // Update current session if it exists to keep it in sync
-    if (this.currentSession) {
-      this.currentSession = mergeCollected(this.currentSession, this.collectedData);
+    if (this._currentSession) {
+      this._currentSession = mergeCollected(this._currentSession, this._collectedData);
     }
 
     // Also update the session manager's session data (avoid circular call)
     const sessionManagerSession = this.session.current;
     if (sessionManagerSession) {
-      sessionManagerSession.data = { ...this.collectedData };
+      sessionManagerSession.data = { ...this._collectedData };
       sessionManagerSession.metadata!.lastUpdatedAt = new Date();
     }
 
     logger.debug("[Agent] Collected data updated:", updates);
   }
 
+  // ---------------------------------------------------------------------------
+  // Property accessors (get / set)
+  // ---------------------------------------------------------------------------
+
   /**
    * Get agent name
    */
@@ -379,6 +384,13 @@ export class Agent<TContext = any, TData = any> {
     return this.options.name;
   }
 
+  /**
+   * Set agent name
+   */
+  set name(value: string) {
+    this.options.name = value;
+  }
+
   /**
    * Get agent description
    */
@@ -386,6 +398,13 @@ export class Agent<TContext = any, TData = any> {
     return this.options.description;
   }
 
+  /**
+   * Set agent description
+   */
+  set description(value: string | undefined) {
+    this.options.description = value;
+  }
+
   /**
    * Get agent goal
    */
@@ -393,6 +412,13 @@ export class Agent<TContext = any, TData = any> {
     return this.options.goal;
   }
 
+  /**
+   * Set agent goal
+   */
+  set goal(value: string | undefined) {
+    this.options.goal = value;
+  }
+
   /**
    * Get agent identity
    */
@@ -400,6 +426,313 @@ export class Agent<TContext = any, TData = any> {
     return this.options.identity;
   }
 
+  /**
+   * Set agent identity
+   */
+  set identity(value: Template<TContext> | undefined) {
+    this.options.identity = value;
+  }
+
+  /**
+   * Get agent personality
+   */
+  get personality(): Template<TContext> | undefined {
+    return this.options.personality;
+  }
+
+  /**
+   * Set agent personality
+   */
+  set personality(value: Template<TContext> | undefined) {
+    this.options.personality = value;
+  }
+
+  /**
+   * Get whether debug mode is enabled
+   */
+  get debug(): boolean {
+    return this.options.debug ?? false;
+  }
+
+  /**
+   * Set debug mode (also updates logger level)
+   */
+  set debug(value: boolean) {
+    this.options.debug = value;
+    logger.setLevel(value ? LoggerLevel.DEBUG : LoggerLevel.INFO);
+  }
+
+  /**
+   * Get the AI provider
+   */
+  get provider(): AiProvider {
+    return this.options.provider;
+  }
+
+  /**
+   * Set the AI provider
+   */
+  set provider(value: AiProvider) {
+    this.options.provider = value;
+  }
+
+  /**
+   * Get the composition mode
+   */
+  get compositionMode(): CompositionMode {
+    return this.options.compositionMode ?? CompositionMode.FLUID;
+  }
+
+  /**
+   * Set the composition mode
+   */
+  set compositionMode(value: CompositionMode) {
+    this.options.compositionMode = value;
+  }
+
+  /**
+   * Get the route switch margin
+   * @default 15
+   */
+  get routeSwitchMargin(): number {
+    return this.options.routeSwitchMargin ?? 15;
+  }
+
+  /**
+   * Set the route switch margin
+   */
+  set routeSwitchMargin(value: number) {
+    this.options.routeSwitchMargin = value;
+  }
+
+  /**
+   * Get the maximum steps per batch
+   * @default 1
+   */
+  get maxStepsPerBatch(): number {
+    return this.options.maxStepsPerBatch ?? 1;
+  }
+
+  /**
+   * Set the maximum steps per batch
+   */
+  set maxStepsPerBatch(value: number) {
+    this.options.maxStepsPerBatch = value;
+  }
+
+  /**
+   * Get all terms
+   */
+  get terms(): Term<TContext, TData>[] {
+    return [...this._terms];
+  }
+
+  /**
+   * Get all guidelines
+   */
+  get guidelines(): Guideline<TContext, TData>[] {
+    return [...this._guidelines];
+  }
+
+  /**
+   * Get all tools
+   */
+  get tools(): Tool<TContext, TData>[] {
+    return [...this._tools];
+  }
+
+  /**
+   * Get all routes
+   */
+  get routes(): Route<TContext, TData>[] {
+    return [...this._routes];
+  }
+
+  /**
+   * Get agent-level rules
+   */
+  get rules(): Template<TContext, TData>[] {
+    return [...this._rules];
+  }
+
+  /**
+   * Set agent-level rules
+   */
+  set rules(value: Template<TContext, TData>[]) {
+    this._rules = [...value];
+  }
+
+  /**
+   * Get agent-level prohibitions
+   */
+  get prohibitions(): Template<TContext, TData>[] {
+    return [...this._prohibitions];
+  }
+
+  /**
+   * Set agent-level prohibitions
+   */
+  set prohibitions(value: Template<TContext, TData>[]) {
+    this._prohibitions = [...value];
+  }
+
+  /**
+   * Get current schema
+   */
+  get schema(): StructuredSchema | undefined {
+    return this._schema;
+  }
+
+  /**
+   * Set schema (validates structure)
+   */
+  set schema(value: StructuredSchema | undefined) {
+    if (value) {
+      this.validateSchema(value);
+    }
+    this._schema = value;
+  }
+
+  /**
+   * Get the agent's knowledge base
+   */
+  get knowledgeBase(): Record<string, unknown> {
+    return { ...this._knowledgeBase };
+  }
+
+  /**
+   * Set the agent's knowledge base
+   */
+  set knowledgeBase(value: Record<string, unknown>) {
+    this._knowledgeBase = { ...value };
+  }
+
+  /**
+   * Get the current session (if set)
+   */
+  get currentSession(): SessionState | undefined {
+    return this._currentSession;
+  }
+
+  /**
+   * Set the current session for convenience methods
+   * Set to undefined to clear the current session
+   */
+  set currentSession(value: SessionState | undefined) {
+    this._currentSession = value;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Deprecated method-based accessors (for backward compatibility)
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Get all terms
+   * @deprecated Use `agent.terms` instead
+   */
+  getTerms(): Term<TContext, TData>[] {
+    return this.terms;
+  }
+
+  /**
+   * Get all tools
+   * @deprecated Use `agent.tools` instead
+   */
+  getTools(): Tool<TContext, TData>[] {
+    return this.tools;
+  }
+
+  /**
+   * Get all guidelines
+   * @deprecated Use `agent.guidelines` instead
+   */
+  getGuidelines(): Guideline<TContext, TData>[] {
+    return this.guidelines;
+  }
+
+  /**
+   * Get all routes
+   * @deprecated Use `agent.routes` instead
+   */
+  getRoutes(): Route<TContext, TData>[] {
+    return this.routes;
+  }
+
+  /**
+   * Get agent-level rules
+   * @deprecated Use `agent.rules` instead
+   */
+  getRules(): Template<TContext, TData>[] {
+    return this.rules;
+  }
+
+  /**
+   * Get agent-level prohibitions
+   * @deprecated Use `agent.prohibitions` instead
+   */
+  getProhibitions(): Template<TContext, TData>[] {
+    return this.prohibitions;
+  }
+
+  /**
+   * Get current schema
+   * @deprecated Use `agent.schema` instead
+   */
+  getSchema(): StructuredSchema | undefined {
+    return this.schema;
+  }
+
+  /**
+   * Get the agent's knowledge base
+   * @deprecated Use `agent.knowledgeBase` instead
+   */
+  getKnowledgeBase(): Record<string, unknown> {
+    return this.knowledgeBase;
+  }
+
+  /**
+   * Get the current session (if set)
+   * @deprecated Use `agent.currentSession` instead
+   */
+  getCurrentSession(): SessionState | undefined {
+    return this.currentSession;
+  }
+
+  /**
+   * Set the current session for convenience methods
+   * @deprecated Use `agent.currentSession = session` instead
+   * @param session - Session step to use for subsequent calls
+   */
+  setCurrentSession(session: SessionState): void {
+    this.currentSession = session;
+  }
+
+  /**
+   * Clear the current session
+   * @deprecated Use `agent.currentSession = undefined` instead
+   */
+  clearCurrentSession(): void {
+    this._currentSession = undefined;
+  }
+
+  /**
+   * Get the persistence manager (if configured)
+   */
+  getPersistenceManager(): PersistenceManager<TData> | undefined {
+    return this._persistenceManager;
+  }
+
+  /**
+   * Check if persistence is enabled
+   */
+  hasPersistence(): boolean {
+    return this._persistenceManager !== undefined;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Core methods
+  // ---------------------------------------------------------------------------
+
   /**
    * Create a new route (journey) using agent-level data type
    */
@@ -407,37 +740,37 @@ export class Agent<TContext = any, TData = any> {
     options: RouteOptions<TContext, TData>
   ): Route<TContext, TData> {
     // Validate that requiredFields exist in agent schema
-    if (options.requiredFields && this.schema?.properties) {
+    if (options.requiredFields && this._schema?.properties) {
       const invalidRequiredFields = options.requiredFields.filter(
-        field => !(String(field) in this.schema!.properties!)
+        field => !(String(field) in this._schema!.properties!)
       );
       if (invalidRequiredFields.length > 0) {
         throw new RouteConfigurationError(
           options.title,
           invalidRequiredFields.map(f => String(f)),
           `Invalid required fields in route '${options.title}': ${invalidRequiredFields.join(', ')}. ` +
-          `Must be valid keys from agent schema. Available fields: ${Object.keys(this.schema.properties).join(', ')}.`
+          `Must be valid keys from agent schema. Available fields: ${Object.keys(this._schema.properties).join(', ')}.`
         );
       }
     }
 
     // Validate that optionalFields exist in agent schema
-    if (options.optionalFields && this.schema?.properties) {
+    if (options.optionalFields && this._schema?.properties) {
       const invalidOptionalFields = options.optionalFields.filter(
-        field => !(String(field) in this.schema!.properties!)
+        field => !(String(field) in this._schema!.properties!)
       );
       if (invalidOptionalFields.length > 0) {
         throw new RouteConfigurationError(
           options.title,
           invalidOptionalFields.map(f => String(f)),
           `Invalid optional fields in route '${options.title}': ${invalidOptionalFields.join(', ')}. ` +
-          `Must be valid keys from agent schema. Available fields: ${Object.keys(this.schema.properties).join(', ')}.`
+          `Must be valid keys from agent schema. Available fields: ${Object.keys(this._schema.properties).join(', ')}.`
         );
       }
     }
 
     const route = new Route<TContext, TData>(options, this);
-    this.routes.push(route);
+    this._routes.push(route);
     return route;
   }
 
@@ -445,7 +778,7 @@ export class Agent<TContext = any, TData = any> {
    * Create a domain term for the glossary
    */
   createTerm(term: Term<TContext, TData>): this {
-    this.terms.push(term);
+    this._terms.push(term);
     return this;
   }
 
@@ -455,10 +788,10 @@ export class Agent<TContext = any, TData = any> {
   createGuideline(guideline: Guideline<TContext, TData>): this {
     const guidelineWithId = {
       ...guideline,
-      id: guideline.id || `guideline_${this.guidelines.length}`,
+      id: guideline.id || `guideline_${this._guidelines.length}`,
       enabled: guideline.enabled !== false, // Default to true
     };
-    this.guidelines.push(guidelineWithId);
+    this._guidelines.push(guidelineWithId);
     return this;
   }
 
@@ -474,9 +807,9 @@ export class Agent<TContext = any, TData = any> {
     if (!tool || !tool.id || !tool.handler) {
       throw new Error('Invalid tool: must have id and handler properties');
     }
-    
+
     // Add directly to agent's tools array, preserving the TResult type
-    this.tools.push(tool);
+    this._tools.push(tool);
     logger.debug(`[Agent] Added tool to agent scope: ${tool.id}`);
     return this;
   }
@@ -491,8 +824,8 @@ export class Agent<TContext = any, TData = any> {
     if (!tool || !tool.id || !tool.handler) {
       throw new Error('Invalid tool: must have id and handler properties');
     }
-    
-    this.tools.push(tool);
+
+    this._tools.push(tool);
     logger.debug(`[Agent] Created tool (legacy): ${tool.id}`);
     return this;
   }
@@ -507,7 +840,7 @@ export class Agent<TContext = any, TData = any> {
       if (!tool || !tool.id || !tool.handler) {
         throw new Error(`Invalid tool in batch: must have id and handler properties (tool: ${tool?.id || 'unknown'})`);
       }
-      this.tools.push(tool);
+      this._tools.push(tool);
     });
     logger.debug(`[Agent] Registered ${tools.length} tools`);
     return this;
@@ -518,30 +851,30 @@ export class Agent<TContext = any, TData = any> {
    * Triggers both agent-level and route-specific onContextUpdate lifecycle hooks if configured
    */
   async updateContext(updates: Partial<TContext>): Promise<void> {
-    const previousContext = this.context;
+    const previousContext = this._context;
 
     // Merge updates with current context
-    this.context = {
-      ...(this.context as Record<string, unknown>),
+    this._context = {
+      ...(this._context as Record<string, unknown>),
       ...(updates as Record<string, unknown>),
     } as TContext;
 
     // Trigger route-specific lifecycle hook if configured and session has current route
-    if (this.currentSession?.currentRoute) {
-      const currentRoute = this.routes.find(
-        (r) => r.id === this.currentSession!.currentRoute?.id
+    if (this._currentSession?.currentRoute) {
+      const currentRoute = this._routes.find(
+        (r) => r.id === this._currentSession!.currentRoute?.id
       );
       if (
         currentRoute?.hooks?.onContextUpdate &&
         previousContext !== undefined
       ) {
-        await currentRoute.handleContextUpdate(this.context, previousContext);
+        await currentRoute.handleContextUpdate(this._context, previousContext);
       }
     }
 
     // Trigger agent-level lifecycle hook if configured
     if (this.options.hooks?.onContextUpdate && previousContext !== undefined) {
-      await this.options.hooks.onContextUpdate(this.context, previousContext);
+      await this.options.hooks.onContextUpdate(this._context, previousContext);
     }
   }
 
@@ -564,7 +897,7 @@ export class Agent<TContext = any, TData = any> {
 
     // Trigger route-specific lifecycle hook if configured and session has a current route
     if (session.currentRoute) {
-      const currentRoute = this.routes.find(
+      const currentRoute = this._routes.find(
         (r) => r.id === session.currentRoute?.id
       );
       if (currentRoute?.hooks?.onDataUpdate) {
@@ -584,7 +917,7 @@ export class Agent<TContext = any, TData = any> {
     }
 
     // Update agent's collected data to stay in sync
-    this.collectedData = { ...newCollected };
+    this._collectedData = { ...newCollected };
 
     // Return updated session
     return mergeCollected(session, newCollected);
@@ -600,13 +933,7 @@ export class Agent<TContext = any, TData = any> {
     }
 
     // Otherwise return the stored context
-    return this.context;
-  }
-  /**
-   * Get current schema
-   */
-  getSchema(): StructuredSchema | undefined {
-    return this.schema;
+    return this._context;
   }
 
   /**
@@ -614,7 +941,7 @@ export class Agent<TContext = any, TData = any> {
    */
   async *respondStream(params: RespondParams<TContext, TData>): AsyncGenerator<AgentResponseStreamChunk<TData>> {
     // Delegate to ResponseModal
-    yield* this.responseModal.respondStream(params);
+    yield* this._responseModal.respondStream(params);
   }
 
   /**
@@ -622,14 +949,7 @@ export class Agent<TContext = any, TData = any> {
    */
   async respond(params: RespondParams<TContext, TData>): Promise<AgentResponse<TData>> {
     // Delegate to ResponseModal
-    return this.responseModal.respond(params);
-  }
-
-  /**
-   * Get all routes
-   */
-  getRoutes(): Route<TContext, TData>[] {
-    return [...this.routes];
+    return this._responseModal.respond(params);
   }
 
   /**
@@ -645,7 +965,7 @@ export class Agent<TContext = any, TData = any> {
    * @internal Used by ResponseModal
    */
   getRoutingEngine(): RoutingEngine<TContext, TData> {
-    return this.routingEngine;
+    return this._routingEngine;
   }
 
   /**
@@ -656,49 +976,6 @@ export class Agent<TContext = any, TData = any> {
     return this.updateData.bind(this);
   }
 
-
-
-  /**
-   * Get all terms
-   */
-  getTerms(): Term<TContext, TData>[] {
-    return [...this.terms];
-  }
-
-  /**
-   * Get all tools
-   */
-  getTools(): Tool<TContext, TData>[] {
-    return [...this.tools];
-  }
-
-
-
-
-
-
-
-  /**
-   * Get all guidelines
-   */
-  getGuidelines(): Guideline<TContext, TData>[] {
-    return [...this.guidelines];
-  }
-
-  /**
-   * Get agent-level rules
-   */
-  getRules(): Template<TContext, TData>[] {
-    return [...this.agentRules];
-  }
-
-  /**
-   * Get agent-level prohibitions
-   */
-  getProhibitions(): Template<TContext, TData>[] {
-    return [...this.agentProhibitions];
-  }
-
   /**
    * Evaluate and match active guidelines based on their conditions
    * Returns guidelines that should be active given the current context
@@ -712,7 +989,7 @@ export class Agent<TContext = any, TData = any> {
     const evaluator = createConditionEvaluator(templateContext);
     const matches: GuidelineMatch<TContext, TData>[] = [];
 
-    for (const guideline of this.guidelines) {
+    for (const guideline of this._guidelines) {
       // Skip disabled guidelines
       if (guideline.enabled === false) {
         continue;
@@ -720,7 +997,7 @@ export class Agent<TContext = any, TData = any> {
 
       if (guideline.condition) {
         const evaluation = await evaluator.evaluateCondition(guideline.condition, 'AND');
-        
+
         // Include guideline if:
         // 1. No programmatic conditions (only strings) - always active
         // 2. Programmatic conditions evaluate to true
@@ -730,7 +1007,7 @@ export class Agent<TContext = any, TData = any> {
             : evaluation.hasProgrammaticConditions
               ? "Programmatic condition evaluated to true"
               : "Always active (no conditions)";
-          
+
           matches.push({
             guideline,
             rationale
@@ -748,44 +1025,6 @@ export class Agent<TContext = any, TData = any> {
     return matches;
   }
 
-  /**
-   * Get the agent's knowledge base
-   */
-  getKnowledgeBase(): Record<string, unknown> {
-    return { ...this.knowledgeBase };
-  }
-
-
-
-  /**
-   * Get the persistence manager (if configured)
-   */
-  getPersistenceManager(): PersistenceManager<TData> | undefined {
-    return this.persistenceManager;
-  }
-
-  /**
-   * Check if persistence is enabled
-   */
-  hasPersistence(): boolean {
-    return this.persistenceManager !== undefined;
-  }
-
-  /**
-   * Set the current session for convenience methods
-   * @param session - Session step to use for subsequent calls
-   */
-  setCurrentSession(session: SessionState): void {
-    this.currentSession = session;
-  }
-
-  /**
-   * Get the current session (if set)
-   */
-  getCurrentSession(): SessionState | undefined {
-    return this.currentSession;
-  }
-
   /**
    * Execute a prepare or finalize function/tool
    * @internal Used by ResponseModal
@@ -851,13 +1090,6 @@ export class Agent<TContext = any, TData = any> {
     }
   }
 
-  /**
-   * Clear the current session
-   */
-  clearCurrentSession(): void {
-    this.currentSession = undefined;
-  }
-
   /**
    * Sync session data to agent collected data
    * @internal Used to keep agent and session data in sync
@@ -865,8 +1097,8 @@ export class Agent<TContext = any, TData = any> {
   private syncSessionDataToCollectedData(): void {
     const sessionData = this.session.getData();
     if (sessionData && Object.keys(sessionData).length > 0) {
-      this.collectedData = { ...sessionData };
-      logger.debug("[Agent] Synced session data to collected data:", this.collectedData);
+      this._collectedData = { ...sessionData };
+      logger.debug("[Agent] Synced session data to collected data:", this._collectedData);
     }
   }
 
@@ -878,12 +1110,12 @@ export class Agent<TContext = any, TData = any> {
   getData(): Partial<TData> {
     // Ensure agent collected data is synced with session
     this.syncSessionDataToCollectedData();
-    
+
     // If we have a current session, use session data
-    if (this.currentSession) {
+    if (this._currentSession) {
       // With agent-level data, all routes share the same data structure
       // No need for route-specific data access
-      return (this.currentSession.data) || {};
+      return (this._currentSession.data) || {};
     }
 
     // Otherwise, return agent-level collected data
@@ -913,7 +1145,7 @@ export class Agent<TContext = any, TData = any> {
     condition?: Template<TContext, TData>,
     history?: Event[]
   ): Promise<SessionState<TData>> {
-    const targetSession = session || this.currentSession;
+    const targetSession = session || this._currentSession;
 
     if (!targetSession) {
       throw new Error(
@@ -922,22 +1154,22 @@ export class Agent<TContext = any, TData = any> {
     }
 
     // Find target route by ID or title
-    const targetRoute = this.routes.find(
+    const targetRoute = this._routes.find(
       (r) => r.id === routeIdOrTitle || r.title === routeIdOrTitle
     );
 
     if (!targetRoute) {
       throw new Error(
-        `Route not found: ${routeIdOrTitle}. Available routes: ${this.routes
+        `Route not found: ${routeIdOrTitle}. Available routes: ${this._routes
           .map((r) => r.title)
           .join(", ")}`
       );
     }
     const templateContext = createTemplateContext({
-      context: this.context,
+      context: this._context,
       session,
       history,
-      data: this.currentSession?.data,
+      data: this._currentSession?.data,
     });
     const renderedCondition = await render(condition, templateContext);
 
@@ -951,8 +1183,8 @@ export class Agent<TContext = any, TData = any> {
     };
 
     // Update current session if using it
-    if (!session && this.currentSession) {
-      this.currentSession = updatedSession;
+    if (!session && this._currentSession) {
+      this._currentSession = updatedSession;
     }
 
     logger.debug(
@@ -971,7 +1203,7 @@ export class Agent<TContext = any, TData = any> {
     options?: GenerateOptions<TContext>
   ): Promise<AgentResponse<TData>> {
     // Delegate to ResponseModal.generate()
-    return this.responseModal.generate(message, options);
+    return this._responseModal.generate(message, options);
   }
 
   /**
@@ -983,7 +1215,7 @@ export class Agent<TContext = any, TData = any> {
     options?: StreamOptions<TContext>
   ): AsyncGenerator<AgentResponseStreamChunk<TData>> {
     // Delegate to ResponseModal with the same options structure as chat()
-    yield* this.responseModal.stream(message, {
+    yield* this._responseModal.stream(message, {
       history: options?.history,
       contextOverride: options?.contextOverride,
       signal: options?.signal,