@falai/agent 1.1.3 → 1.2.0

package/src/core/ResponseEngine.ts

@@ -10,6 +10,7 @@ import type {
 import type { Route } from "./Route";
 import type { Step } from "./Step";
 import { PromptComposer } from "./PromptComposer";
+import { PromptSectionCache } from "./PromptSectionCache";
 import { createTemplateContext, render } from "../utils/template";
 
 export interface BuildResponsePromptParams<
@@ -43,6 +44,8 @@ export interface BuildFallbackPromptParams<TContext = unknown, TData = unknown>
 }
 
 export class ResponseEngine<TContext = unknown, TData = unknown> {
+  constructor(private readonly promptSectionCache?: PromptSectionCache) { }
+
   responseSchemaForRoute(
     route: Route<TContext, TData>,
     currentStep?: Step<TContext, TData>,
@@ -96,7 +99,6 @@ export class ResponseEngine<TContext = unknown, TData = unknown> {
       prohibitions,
       directives,
       history,
-      lastMessage,
       agentOptions,
       combinedGuidelines,
       combinedTerms,
@@ -105,7 +107,7 @@ export class ResponseEngine<TContext = unknown, TData = unknown> {
       agentSchema,
     } = params;
     const templateContext = createTemplateContext({ context, session, history });
-    const pc = new PromptComposer(templateContext);
+    const pc = new PromptComposer(templateContext, this.promptSectionCache);
 
     // Create combined agent options with route overrides
     let effectiveAgentOptions = agentOptions;
@@ -153,8 +155,8 @@ export class ResponseEngine<TContext = unknown, TData = unknown> {
       await pc.addGlossary(combinedTerms);
     }
 
-    await pc.addInteractionHistory(history);
-    await pc.addLastMessage(lastMessage);
+    // History is now passed natively via GenerateMessageInput.history
+    // instead of being embedded in the prompt string (Requirements 17.1, 17.2)
 
     // Add data collection instructions - include ALL route fields, not just current step
     // Collect all fields from route's required and optional fields
@@ -297,10 +299,11 @@ export class ResponseEngine<TContext = unknown, TData = unknown> {
     const { history, agentOptions, terms, guidelines, context, session } =
       params;
     const templateContext = createTemplateContext({ context, session, history });
-    const pc = new PromptComposer(templateContext);
+    const pc = new PromptComposer(templateContext, this.promptSectionCache);
 
     await pc.addAgentMeta(agentOptions);
-    await pc.addInteractionHistory(history);
+    // History is now passed natively via GenerateMessageInput.history
+    // instead of being embedded in the prompt string (Requirements 17.1, 17.2)
     await pc.addGlossary(terms);
     await pc.addGuidelines(guidelines);
     await pc.addKnowledgeBase(agentOptions.knowledgeBase);

package/src/core/ResponseModal.ts

@@ -16,6 +16,7 @@ import type {
     AgentStructuredResponse,
     Term,
     StoppedReason,
+    ToolCallRequest,
 } from "../types";
 import { EventKind, MessageRole } from "../types";
 import type { Agent } from "./Agent";
@@ -157,7 +158,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         private readonly options?: ResponseModalOptions
     ) {
         // Initialize response engine
-        this.responseEngine = new ResponseEngine<TContext, TData>();
+        this.responseEngine = new ResponseEngine<TContext, TData>(this.agent.promptSectionCache);
 
         // Initialize response pipeline with agent dependencies
         this.responsePipeline = new ResponsePipeline<TContext, TData>(
@@ -175,7 +176,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         this.batchExecutor = new BatchExecutor<TContext, TData>();
 
         // Initialize batch prompt builder for combined prompts
-        this.batchPromptBuilder = new BatchPromptBuilder<TContext, TData>();
+        this.batchPromptBuilder = new BatchPromptBuilder<TContext, TData>(this.agent.promptSectionCache);
     }
 
     /**
@@ -1640,21 +1641,81 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
             if (chunk.done && chunk.structured?.toolCalls) {
                 toolCalls = chunk.structured.toolCalls;
 
-                // Execute tools with unified loop handling
-                const toolResult = await this.executeUnifiedToolLoop({
-                    toolCalls,
-                    context,
-                    session,
-                    history,
-                    selectedRoute,
-                    responsePrompt,
-                    availableTools,
-                    responseSchema,
-                    signal,
-                });
+                const toolManager = this.getToolManager();
+
+                // Use concurrent execution for the initial batch of tool calls
+                if (toolManager && typeof toolManager.executeWithConcurrency === 'function') {
+                    const toolCallRequests: ToolCallRequest[] = toolCalls.map((tc, i) => ({
+                        id: `${tc.toolName}-${i}-${Date.now()}`,
+                        toolName: tc.toolName,
+                        arguments: tc.arguments,
+                    }));
+
+                    const historyEvents = historyToEvents(history);
+
+                    try {
+                        for await (const update of toolManager.executeWithConcurrency({
+                            toolCalls: toolCallRequests,
+                            context,
+                            data: session.data,
+                            history: historyEvents,
+                            signal,
+                            route: selectedRoute,
+                            step: nextStep,
+                        })) {
+                            // Apply context updates
+                            if (update.contextUpdate) {
+                                try {
+                                    await this.agent.updateContext(update.contextUpdate as Partial<TContext>);
+                                } catch (error) {
+                                    logger.error(`[ResponseModal] Failed to update context from concurrent tool:`, error);
+                                }
+                            }
 
-                session = toolResult.session;
-                toolCalls = toolResult.finalToolCalls;
+                            // Apply data updates
+                            if (update.dataUpdate) {
+                                try {
+                                    const updateDataMethod = this.agent.getUpdateDataMethod();
+                                    session = await updateDataMethod(session, update.dataUpdate);
+                                } catch (error) {
+                                    logger.error(`[ResponseModal] Failed to update data from concurrent tool:`, error);
+                                }
+                            }
+
+                            // Yield progress updates immediately
+                            if (update.progress) {
+                                yield {
+                                    delta: '',
+                                    accumulated: chunk.accumulated,
+                                    done: false,
+                                    session,
+                                    toolCalls: undefined,
+                                    isRouteComplete: false,
+                                    metadata: { toolProgress: update.progress, toolCallId: update.toolCallId },
+                                };
+                            }
+                        }
+
+                        logger.debug(`[ResponseModal] Concurrent tool execution completed for ${toolCallRequests.length} tools`);
+                    } catch (error) {
+                        logger.error(`[ResponseModal] Concurrent tool execution failed, falling back to sequential:`, error);
+                        // Fall back to the unified tool loop on failure
+                        const toolResult = await this.executeUnifiedToolLoop({
+                            toolCalls, context, session, history, selectedRoute,
+                            responsePrompt, availableTools, responseSchema, signal,
+                        });
+                        session = toolResult.session;
+                        toolCalls = toolResult.finalToolCalls;
+                    }
+                } else {
+                    // Fallback: no ToolManager or no executeWithConcurrency, use unified tool loop
+                    const toolResult = await this.executeUnifiedToolLoop({
+                        toolCalls, context, session, history, selectedRoute,
+                        responsePrompt, availableTools, responseSchema, signal,
+                    });
+                    session = toolResult.session;
+                    toolCalls = toolResult.finalToolCalls;
+                }
             }
 
             // Extract collected data on final chunk

package/src/core/RoutingEngine.ts

@@ -10,6 +10,7 @@ import { enterRoute, mergeCollected } from "../utils";
 import type { Route } from "./Route";
 import type { Step } from "./Step";
 import { PromptComposer } from "./PromptComposer";
+import { PromptSectionCache } from "./PromptSectionCache";
 import { END_ROUTE_ID } from "../constants";
 import { createTemplateContext, getLastMessageFromHistory, logger } from "../utils";
 
@@ -41,6 +42,15 @@ export interface RoutingEngineOptions {
    * @default 15
    */
   routeSwitchMargin?: number;
+  /**
+   * Callback invoked when the active route changes.
+   * Used by Agent to invalidate route-dependent prompt cache sections.
+   */
+  onRouteSwitch?: () => void;
+  /**
+   * Shared prompt section cache for memoizing static prompt sections.
+   */
+  promptSectionCache?: PromptSectionCache;
 }
 
 export interface BuildStepSelectionPromptParams<
@@ -91,6 +101,7 @@ export class RoutingEngine<TContext = unknown, TData = unknown> {
         );
       }
       logger.debug(`[RoutingEngine] Entered route: ${route.title}`);
+      this.options?.onRouteSwitch?.();
       return updatedSession;
     }
     return session;
@@ -921,7 +932,7 @@ export class RoutingEngine<TContext = unknown, TData = unknown> {
       includeEndRoute = false,
     } = params;
     const templateContext = createTemplateContext({ context, session, history });
-    const pc = new PromptComposer<TContext, TData>(templateContext);
+    const pc = new PromptComposer<TContext, TData>(templateContext, this.options?.promptSectionCache);
 
     // Add agent metadata
     if (agentOptions) {
@@ -1173,7 +1184,7 @@ export class RoutingEngine<TContext = unknown, TData = unknown> {
       routeConditionContext,
     } = params;
     const templateContext = createTemplateContext({ context, session, history });
-    const pc = new PromptComposer<TContext, TData>(templateContext);
+    const pc = new PromptComposer<TContext, TData>(templateContext, this.options?.promptSectionCache);
     if (agentOptions) {
       await pc.addAgentMeta(agentOptions);
     }

package/src/core/SessionManager.ts

@@ -5,9 +5,11 @@
  * in both server and client environments.
  */
 
+import log from "loglevel";
 import type { SessionState } from "../types/session";
 import type { History, HistoryItem } from "../types/history";
 import { PersistenceManager } from "./PersistenceManager";
+import { CompactionEngine } from "./CompactionEngine";
 import type { PersistenceAdapter } from "../types/persistence";
 import type { Agent } from "./Agent";
 import { createSession } from "../utils";
@@ -135,6 +137,23 @@ export class SessionManager<TData = unknown> {
     // Ensure currentSession is updated
     this.currentSession = session;
 
+    // Apply compaction if configured
+    try {
+      const compactionOptions = this.agent?.getCompactionOptions();
+      if (compactionOptions) {
+        const result = await CompactionEngine.checkAndCompact(session.history, compactionOptions);
+        if (result.strategy !== 'none') {
+          session.history = result.history;
+          log.info(
+            `CompactionEngine: applied strategy '${result.strategy}', ` +
+            `estimatedTokens=${result.estimatedTokens}, messagesCompacted=${result.messagesCompacted}`
+          );
+        }
+      }
+    } catch (error) {
+      log.warn("CompactionEngine: compaction failed, continuing without compaction", error);
+    }
+
     // Auto-save to persistence
     await this.save();
   }