@falai/agent 1.1.1 → 1.1.2

package/dist/core/Agent.js

@@ -1,6 +1,7 @@
 /**
  * Core Agent implementation
  */
+import { CompositionMode } from "../types";
 import { mergeCollected, logger, LoggerLevel, render, createTemplateContext, createConditionEvaluator, } from "../utils";
 import { Route } from "./Route";
 import { PersistenceManager } from "./PersistenceManager";
@@ -36,14 +37,14 @@ class RouteConfigurationError extends Error {
 export class Agent {
     constructor(options) {
         this.options = options;
-        this.terms = [];
-        this.guidelines = [];
-        this.tools = [];
-        this.routes = [];
-        this.agentRules = [];
-        this.agentProhibitions = [];
-        this.knowledgeBase = {};
-        this.collectedData = {};
+        this._terms = [];
+        this._guidelines = [];
+        this._tools = [];
+        this._routes = [];
+        this._rules = [];
+        this._prohibitions = [];
+        this._knowledgeBase = {};
+        this._collectedData = {};
         // Set log level based on debug option
         if (options.debug) {
             logger.setLevel(LoggerLevel.DEBUG);
@@ -54,31 +55,31 @@ export class Agent {
         }
         // 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(`Initial data validation failed: ${validation.errors.map(e => e.message).join(', ')}`);
                 }
             }
-            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({
+        this._routingEngine = new RoutingEngine({
             routeSwitchMargin: options.routeSwitchMargin,
         });
         // Initialize ResponseModal for handling all response generation
-        this.responseModal = new ResponseModal(this);
+        this._responseModal = new ResponseModal(this);
         // Initialize persistence if configured
         if (options.persistence) {
             try {
@@ -92,7 +93,7 @@ export class Agent {
                 if (!options.persistence.adapter.messageRepository) {
                     throw new Error("Persistence adapter must provide a messageRepository");
                 }
-                this.persistenceManager = new PersistenceManager(options.persistence);
+                this._persistenceManager = new PersistenceManager(options.persistence);
                 // Initialize the adapter if it has an initialize method
                 if (options.persistence.adapter.initialize) {
                     options.persistence.adapter.initialize().catch((error) => {
@@ -124,10 +125,10 @@ export class Agent {
         }
         // 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) {
             options.routes.forEach((routeOptions) => {
@@ -136,10 +137,10 @@ export class Agent {
         }
         // 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(this.persistenceManager, this);
+        this.session = new SessionManager(this._persistenceManager, this);
         // Initialize tool manager with proper type inference
         this.tool = new ToolManager(this);
         // Store sessionId for later use in getOrCreate calls
@@ -149,8 +150,8 @@ export class Agent {
             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);
@@ -180,16 +181,16 @@ export class Agent {
      * Validate data against the agent-level schema
      */
     validateData(data) {
-        if (!this.schema) {
+        if (!this._schema) {
             // No schema defined, consider all data valid
             return { valid: true, errors: [], warnings: [] };
         }
         const errors = [];
         const warnings = [];
         // 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,
@@ -200,8 +201,8 @@ export class Agent {
             }
         }
         // 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] === undefined) {
                     warnings.push({
                         field: requiredField,
@@ -224,11 +225,11 @@ export class Agent {
      * @returns true if field exists in schema or no schema is defined, false otherwise
      */
     isValidSchemaField(field) {
-        if (!this.schema || !this.schema.properties) {
+        if (!this._schema || !this._schema.properties) {
             // No schema defined, consider all fields valid
             return true;
         }
-        return field in this.schema.properties;
+        return field in this._schema.properties;
     }
     /**
      * Get the current collected data
@@ -236,7 +237,7 @@ export class Agent {
     getCollectedData() {
         // Ensure agent collected data is synced with session
         this.syncSessionDataToCollectedData();
-        return { ...this.collectedData };
+        return { ...this._collectedData };
     }
     /**
      * Update collected data with validation
@@ -254,80 +255,366 @@ export class Agent {
             logger.warn(`[Agent] Data validation warnings: ${warningMessages}`);
         }
         // 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, previousData);
+            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
      */
     get name() {
         return this.options.name;
     }
+    /**
+     * Set agent name
+     */
+    set name(value) {
+        this.options.name = value;
+    }
     /**
      * Get agent description
      */
     get description() {
         return this.options.description;
     }
+    /**
+     * Set agent description
+     */
+    set description(value) {
+        this.options.description = value;
+    }
     /**
      * Get agent goal
      */
     get goal() {
         return this.options.goal;
     }
+    /**
+     * Set agent goal
+     */
+    set goal(value) {
+        this.options.goal = value;
+    }
     /**
      * Get agent identity
      */
     get identity() {
         return this.options.identity;
     }
+    /**
+     * Set agent identity
+     */
+    set identity(value) {
+        this.options.identity = value;
+    }
+    /**
+     * Get agent personality
+     */
+    get personality() {
+        return this.options.personality;
+    }
+    /**
+     * Set agent personality
+     */
+    set personality(value) {
+        this.options.personality = value;
+    }
+    /**
+     * Get whether debug mode is enabled
+     */
+    get debug() {
+        return this.options.debug ?? false;
+    }
+    /**
+     * Set debug mode (also updates logger level)
+     */
+    set debug(value) {
+        this.options.debug = value;
+        logger.setLevel(value ? LoggerLevel.DEBUG : LoggerLevel.INFO);
+    }
+    /**
+     * Get the AI provider
+     */
+    get provider() {
+        return this.options.provider;
+    }
+    /**
+     * Set the AI provider
+     */
+    set provider(value) {
+        this.options.provider = value;
+    }
+    /**
+     * Get the composition mode
+     */
+    get compositionMode() {
+        return this.options.compositionMode ?? CompositionMode.FLUID;
+    }
+    /**
+     * Set the composition mode
+     */
+    set compositionMode(value) {
+        this.options.compositionMode = value;
+    }
+    /**
+     * Get the route switch margin
+     * @default 15
+     */
+    get routeSwitchMargin() {
+        return this.options.routeSwitchMargin ?? 15;
+    }
+    /**
+     * Set the route switch margin
+     */
+    set routeSwitchMargin(value) {
+        this.options.routeSwitchMargin = value;
+    }
+    /**
+     * Get the maximum steps per batch
+     * @default 1
+     */
+    get maxStepsPerBatch() {
+        return this.options.maxStepsPerBatch ?? 1;
+    }
+    /**
+     * Set the maximum steps per batch
+     */
+    set maxStepsPerBatch(value) {
+        this.options.maxStepsPerBatch = value;
+    }
+    /**
+     * Get all terms
+     */
+    get terms() {
+        return [...this._terms];
+    }
+    /**
+     * Get all guidelines
+     */
+    get guidelines() {
+        return [...this._guidelines];
+    }
+    /**
+     * Get all tools
+     */
+    get tools() {
+        return [...this._tools];
+    }
+    /**
+     * Get all routes
+     */
+    get routes() {
+        return [...this._routes];
+    }
+    /**
+     * Get agent-level rules
+     */
+    get rules() {
+        return [...this._rules];
+    }
+    /**
+     * Set agent-level rules
+     */
+    set rules(value) {
+        this._rules = [...value];
+    }
+    /**
+     * Get agent-level prohibitions
+     */
+    get prohibitions() {
+        return [...this._prohibitions];
+    }
+    /**
+     * Set agent-level prohibitions
+     */
+    set prohibitions(value) {
+        this._prohibitions = [...value];
+    }
+    /**
+     * Get current schema
+     */
+    get schema() {
+        return this._schema;
+    }
+    /**
+     * Set schema (validates structure)
+     */
+    set schema(value) {
+        if (value) {
+            this.validateSchema(value);
+        }
+        this._schema = value;
+    }
+    /**
+     * Get the agent's knowledge base
+     */
+    get knowledgeBase() {
+        return { ...this._knowledgeBase };
+    }
+    /**
+     * Set the agent's knowledge base
+     */
+    set knowledgeBase(value) {
+        this._knowledgeBase = { ...value };
+    }
+    /**
+     * Get the current session (if set)
+     */
+    get currentSession() {
+        return this._currentSession;
+    }
+    /**
+     * Set the current session for convenience methods
+     * Set to undefined to clear the current session
+     */
+    set currentSession(value) {
+        this._currentSession = value;
+    }
+    // ---------------------------------------------------------------------------
+    // Deprecated method-based accessors (for backward compatibility)
+    // ---------------------------------------------------------------------------
+    /**
+     * Get all terms
+     * @deprecated Use `agent.terms` instead
+     */
+    getTerms() {
+        return this.terms;
+    }
+    /**
+     * Get all tools
+     * @deprecated Use `agent.tools` instead
+     */
+    getTools() {
+        return this.tools;
+    }
+    /**
+     * Get all guidelines
+     * @deprecated Use `agent.guidelines` instead
+     */
+    getGuidelines() {
+        return this.guidelines;
+    }
+    /**
+     * Get all routes
+     * @deprecated Use `agent.routes` instead
+     */
+    getRoutes() {
+        return this.routes;
+    }
+    /**
+     * Get agent-level rules
+     * @deprecated Use `agent.rules` instead
+     */
+    getRules() {
+        return this.rules;
+    }
+    /**
+     * Get agent-level prohibitions
+     * @deprecated Use `agent.prohibitions` instead
+     */
+    getProhibitions() {
+        return this.prohibitions;
+    }
+    /**
+     * Get current schema
+     * @deprecated Use `agent.schema` instead
+     */
+    getSchema() {
+        return this.schema;
+    }
+    /**
+     * Get the agent's knowledge base
+     * @deprecated Use `agent.knowledgeBase` instead
+     */
+    getKnowledgeBase() {
+        return this.knowledgeBase;
+    }
+    /**
+     * Get the current session (if set)
+     * @deprecated Use `agent.currentSession` instead
+     */
+    getCurrentSession() {
+        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) {
+        this.currentSession = session;
+    }
+    /**
+     * Clear the current session
+     * @deprecated Use `agent.currentSession = undefined` instead
+     */
+    clearCurrentSession() {
+        this._currentSession = undefined;
+    }
+    /**
+     * Get the persistence manager (if configured)
+     */
+    getPersistenceManager() {
+        return this._persistenceManager;
+    }
+    /**
+     * Check if persistence is enabled
+     */
+    hasPersistence() {
+        return this._persistenceManager !== undefined;
+    }
+    // ---------------------------------------------------------------------------
+    // Core methods
+    // ---------------------------------------------------------------------------
     /**
      * Create a new route (journey) using agent-level data type
      */
     createRoute(options) {
         // Validate that requiredFields exist in agent schema
-        if (options.requiredFields && this.schema?.properties) {
-            const invalidRequiredFields = options.requiredFields.filter(field => !(String(field) in this.schema.properties));
+        if (options.requiredFields && this._schema?.properties) {
+            const invalidRequiredFields = options.requiredFields.filter(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) {
-            const invalidOptionalFields = options.optionalFields.filter(field => !(String(field) in this.schema.properties));
+        if (options.optionalFields && this._schema?.properties) {
+            const invalidOptionalFields = options.optionalFields.filter(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(options, this);
-        this.routes.push(route);
+        this._routes.push(route);
         return route;
     }
     /**
      * Create a domain term for the glossary
      */
     createTerm(term) {
-        this.terms.push(term);
+        this._terms.push(term);
         return this;
     }
     /**
@@ -336,10 +623,10 @@ export class Agent {
     createGuideline(guideline) {
         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;
     }
     /**
@@ -353,7 +640,7 @@ export class Agent {
             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;
     }
@@ -367,7 +654,7 @@ export class Agent {
         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;
     }
@@ -381,7 +668,7 @@ export class Agent {
             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;
@@ -391,23 +678,23 @@ export class Agent {
      * Triggers both agent-level and route-specific onContextUpdate lifecycle hooks if configured
      */
     async updateContext(updates) {
-        const previousContext = this.context;
+        const previousContext = this._context;
         // Merge updates with current context
-        this.context = {
-            ...this.context,
+        this._context = {
+            ...this._context,
             ...updates,
         };
         // 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);
         }
     }
     /**
@@ -424,7 +711,7 @@ export class Agent {
         };
         // Trigger route-specific lifecycle hook if configured and session has a current route
         if (session.currentRoute) {
-            const currentRoute = this.routes.find((r) => r.id === session.currentRoute?.id);
+            const currentRoute = this._routes.find((r) => r.id === session.currentRoute?.id);
             if (currentRoute?.hooks?.onDataUpdate) {
                 newCollected = await currentRoute.handleDataUpdate(newCollected, previousCollected);
             }
@@ -434,7 +721,7 @@ export class Agent {
             newCollected = (await this.options.hooks.onDataUpdate(newCollected, previousCollected));
         }
         // Update agent's collected data to stay in sync
-        this.collectedData = { ...newCollected };
+        this._collectedData = { ...newCollected };
         // Return updated session
         return mergeCollected(session, newCollected);
     }
@@ -447,33 +734,21 @@ export class Agent {
             return await this.options.contextProvider();
         }
         // Otherwise return the stored context
-        return this.context;
-    }
-    /**
-     * Get current schema
-     */
-    getSchema() {
-        return this.schema;
+        return this._context;
     }
     /**
      * Generate a response based on history and context as a stream
      */
     async *respondStream(params) {
         // Delegate to ResponseModal
-        yield* this.responseModal.respondStream(params);
+        yield* this._responseModal.respondStream(params);
     }
     /**
      * Generate a response based on history and context
      */
     async respond(params) {
         // Delegate to ResponseModal
-        return this.responseModal.respond(params);
-    }
-    /**
-     * Get all routes
-     */
-    getRoutes() {
-        return [...this.routes];
+        return this._responseModal.respond(params);
     }
     /**
      * Get agent options
@@ -487,7 +762,7 @@ export class Agent {
      * @internal Used by ResponseModal
      */
     getRoutingEngine() {
-        return this.routingEngine;
+        return this._routingEngine;
     }
     /**
      * Get the updateData method bound to this agent
@@ -496,36 +771,6 @@ export class Agent {
     getUpdateDataMethod() {
         return this.updateData.bind(this);
     }
-    /**
-     * Get all terms
-     */
-    getTerms() {
-        return [...this.terms];
-    }
-    /**
-     * Get all tools
-     */
-    getTools() {
-        return [...this.tools];
-    }
-    /**
-     * Get all guidelines
-     */
-    getGuidelines() {
-        return [...this.guidelines];
-    }
-    /**
-     * Get agent-level rules
-     */
-    getRules() {
-        return [...this.agentRules];
-    }
-    /**
-     * Get agent-level prohibitions
-     */
-    getProhibitions() {
-        return [...this.agentProhibitions];
-    }
     /**
      * Evaluate and match active guidelines based on their conditions
      * Returns guidelines that should be active given the current context
@@ -534,7 +779,7 @@ export class Agent {
         const templateContext = { context, session, history, data: session?.data };
         const evaluator = createConditionEvaluator(templateContext);
         const matches = [];
-        for (const guideline of this.guidelines) {
+        for (const guideline of this._guidelines) {
             // Skip disabled guidelines
             if (guideline.enabled === false) {
                 continue;
@@ -566,37 +811,6 @@ export class Agent {
         }
         return matches;
     }
-    /**
-     * Get the agent's knowledge base
-     */
-    getKnowledgeBase() {
-        return { ...this.knowledgeBase };
-    }
-    /**
-     * Get the persistence manager (if configured)
-     */
-    getPersistenceManager() {
-        return this.persistenceManager;
-    }
-    /**
-     * Check if persistence is enabled
-     */
-    hasPersistence() {
-        return this.persistenceManager !== undefined;
-    }
-    /**
-     * Set the current session for convenience methods
-     * @param session - Session step to use for subsequent calls
-     */
-    setCurrentSession(session) {
-        this.currentSession = session;
-    }
-    /**
-     * Get the current session (if set)
-     */
-    getCurrentSession() {
-        return this.currentSession;
-    }
     /**
      * Execute a prepare or finalize function/tool
      * @internal Used by ResponseModal
@@ -647,12 +861,6 @@ export class Agent {
             }
         }
     }
-    /**
-     * Clear the current session
-     */
-    clearCurrentSession() {
-        this.currentSession = undefined;
-    }
     /**
      * Sync session data to agent collected data
      * @internal Used to keep agent and session data in sync
@@ -660,8 +868,8 @@ export class Agent {
     syncSessionDataToCollectedData() {
         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);
         }
     }
     /**
@@ -673,10 +881,10 @@ export class Agent {
         // 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
         return this.getCollectedData();
@@ -699,22 +907,22 @@ export class Agent {
      * }
      */
     async nextStepRoute(routeIdOrTitle, session, condition, history) {
-        const targetSession = session || this.currentSession;
+        const targetSession = session || this._currentSession;
         if (!targetSession) {
             throw new Error("No session provided and no current session available. Please provide a session to transition.");
         }
         // Find target route by ID or title
-        const targetRoute = this.routes.find((r) => r.id === routeIdOrTitle || r.title === routeIdOrTitle);
+        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
+            throw new Error(`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);
         const updatedSession = {
@@ -726,8 +934,8 @@ export class Agent {
             },
         };
         // Update current session if using it
-        if (!session && this.currentSession) {
-            this.currentSession = updatedSession;
+        if (!session && this._currentSession) {
+            this._currentSession = updatedSession;
         }
         logger.debug(`[Agent] Set pending transition to route: ${targetRoute.title}`);
         return updatedSession;
@@ -738,7 +946,7 @@ export class Agent {
      */
     async chat(message, options) {
         // Delegate to ResponseModal.generate()
-        return this.responseModal.generate(message, options);
+        return this._responseModal.generate(message, options);
     }
     /**
      * Modern streaming API - simple interface like chat() but returns a stream
@@ -746,7 +954,7 @@ export class Agent {
      */
     async *stream(message, options) {
         // 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,