@falai/agent 1.1.3 → 1.2.1

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<
@@ -22,7 +23,6 @@ export interface BuildResponsePromptParams<
   prohibitions: Template<TContext, TData>[];
   directives: string[] | undefined;
   history: Event[];
-  lastMessage: string;
   agentOptions?: AgentOptions<TContext, TData>;
   // Combined properties from agent and route
   combinedGuidelines?: Guideline<TContext, TData>[];
@@ -34,7 +34,6 @@ export interface BuildResponsePromptParams<
 }
 
 export interface BuildFallbackPromptParams<TContext = unknown, TData = unknown> {
-  history: Event[];
   agentOptions: AgentOptions<TContext, TData>;
   terms: Term<TContext, TData>[];
   guidelines: Guideline<TContext, TData>[];
@@ -43,6 +42,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 +97,6 @@ export class ResponseEngine<TContext = unknown, TData = unknown> {
       prohibitions,
       directives,
       history,
-      lastMessage,
       agentOptions,
       combinedGuidelines,
       combinedTerms,
@@ -105,7 +105,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,9 +153,6 @@ export class ResponseEngine<TContext = unknown, TData = unknown> {
       await pc.addGlossary(combinedTerms);
     }
 
-    await pc.addInteractionHistory(history);
-    await pc.addLastMessage(lastMessage);
-
     // Add data collection instructions - include ALL route fields, not just current step
     // Collect all fields from route's required and optional fields
     const allRouteFields = new Set<string>();
@@ -294,13 +291,12 @@ export class ResponseEngine<TContext = unknown, TData = unknown> {
   async buildFallbackPrompt(
     params: BuildFallbackPromptParams<TContext, TData>
   ): Promise<string> {
-    const { history, agentOptions, terms, guidelines, context, session } =
+    const { agentOptions, terms, guidelines, context, session } =
       params;
-    const templateContext = createTemplateContext({ context, session, history });
-    const pc = new PromptComposer(templateContext);
+    const templateContext = createTemplateContext({ context, session });
+    const pc = new PromptComposer(templateContext, this.promptSectionCache);
 
     await pc.addAgentMeta(agentOptions);
-    await pc.addInteractionHistory(history);
     await pc.addGlossary(terms);
     await pc.addGuidelines(guidelines);
     await pc.addKnowledgeBase(agentOptions.knowledgeBase);

package/src/core/ResponseModal.ts

@@ -12,12 +12,11 @@ import type {
     HistoryItem,
     Tool,
     Event,
-    ToolEventData,
     AgentStructuredResponse,
     Term,
     StoppedReason,
+    ToolCallRequest,
 } from "../types";
-import { EventKind, MessageRole } from "../types";
 import type { Agent } from "./Agent";
 import type { Route } from "./Route";
 import { Step } from "./Step";
@@ -25,7 +24,7 @@ import { ResponseEngine } from "./ResponseEngine";
 import { ResponsePipeline } from "./ResponsePipeline";
 import { BatchExecutor, type HookFunction } from "./BatchExecutor";
 import { BatchPromptBuilder } from "./BatchPromptBuilder";
-import { cloneDeep, mergeCollected, enterStep, getLastMessageFromHistory, render, logger, historyToEvents } from "../utils";
+import { cloneDeep, mergeCollected, enterStep, getLastMessageFromHistory, render, logger, historyToEvents, eventsToHistory } from "../utils";
 import { createTemplateContext } from "../utils/template";
 import type { ToolManager } from "./ToolManager";
 import { END_ROUTE_ID } from "../constants";
@@ -157,7 +156,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 +174,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);
     }
 
     /**
@@ -668,12 +667,15 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
             `Return ONLY the extracted data as JSON. If no data can be extracted, return an empty object {}.`
         );
 
+        // Convert Event[] to HistoryItem[] for provider call
+        const historyItems = eventsToHistory(history);
+
         // Call AI to extract data
         const agentOptions = this.agent.getAgentOptions();
         try {
             const result = await agentOptions.provider.generateMessage<TContext, Partial<TData>>({
                 prompt: extractionPrompt.join('\n'),
-                history,
+                history: historyItems,
                 context: {} as TContext, // Passed as empty object so AI doesn't "extract" from context
                 // NOTE: context is intentionally NOT passed here.
                 // Passing context caused the AI to "extract" data from the lead's context
@@ -715,7 +717,6 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         // Get last user message (needed for both route and completion handling)
         // Convert HistoryItem[] to Event[] for internal processing
         const historyEvents = historyToEvents(history);
-        const lastMessageText = getLastMessageFromHistory(historyEvents);
 
         let message: string;
         let toolCalls: Array<{ toolName: string; arguments: Record<string, unknown> }> | undefined = undefined;
@@ -756,7 +757,6 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
                     session,
                     history,
                     context: effectiveContext,
-                    lastMessageText,
                     historyEvents,
                     signal: undefined,
                 });
@@ -784,7 +784,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
                     selectedRoute,
                     session,
                     context: effectiveContext,
-                    lastMessageText,
+                    history,
                     historyEvents,
                     signal: undefined,
                 });
@@ -805,7 +805,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
             // Fallback: No routes defined, generate a simple response
 
             message = await this.generateFallbackResponse({
-                history: historyEvents, // Use Event[] for fallback response
+                history,
                 context: effectiveContext,
                 session,
             });
@@ -925,7 +925,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         const agentOptions = this.agent.getAgentOptions();
         const result = await agentOptions.provider.generateMessage({
             prompt: batchPromptResult.prompt,
-            history: historyEvents,
+            history, // Use HistoryItem[] for AI provider
             context,
             tools: availableTools,
             signal,
@@ -1124,7 +1124,6 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         // Get last user message (needed for both route and completion handling)
         // Convert HistoryItem[] to Event[] for internal processing
         const historyEvents = historyToEvents(history);
-        const lastMessageText = getLastMessageFromHistory(historyEvents);
 
         if (selectedRoute && !isRouteComplete) {
             // Check if we have batch steps to execute
@@ -1152,7 +1151,6 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
                     session,
                     history,
                     context: effectiveContext,
-                    lastMessageText,
                     historyEvents,
                 });
             }
@@ -1163,14 +1161,14 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
                 selectedRoute,
                 session,
                 context: effectiveContext,
-                lastMessageText,
+                history,
                 historyEvents,
             });
 
         } else {
             // Fallback: No routes defined, stream a simple response
             yield* this.streamFallbackResponse({
-                history: historyEvents, // Use Event[] for fallback response
+                history,
                 context: effectiveContext,
                 session,
             });
@@ -1195,7 +1193,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         batchStoppedReason?: StoppedReason;
         signal?: AbortSignal;
     }): AsyncGenerator<AgentResponseStreamChunk<TData>> {
-        const { selectedRoute, batchSteps, context, historyEvents, batchStoppedReason, signal } = params;
+        const { selectedRoute, batchSteps, history, context, historyEvents, batchStoppedReason, signal } = params;
         let session = params.session;
 
         // Create hook executor function
@@ -1250,7 +1248,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         const agentOptions = this.agent.getAgentOptions();
         const stream = agentOptions.provider.generateMessageStream({
             prompt: batchPromptResult.prompt,
-            history: historyEvents,
+            history, // Use HistoryItem[] for AI provider
             context,
             tools: availableTools,
             signal,
@@ -1379,17 +1377,16 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         selectedStep?: Step<TContext, TData>;
         responseDirectives?: string[];
         session: SessionState<TData>;
-        history: HistoryItem[]; // Keep as HistoryItem[] for AI provider compatibility
+        history: HistoryItem[];
         context: TContext;
-        lastMessageText: string; // String version for buildResponsePrompt
-        historyEvents: Event[]; // Event[] version for buildResponsePrompt
+        historyEvents: Event[];
         signal?: AbortSignal;
     }): Promise<{
         message: string;
         toolCalls?: Array<{ toolName: string; arguments: Record<string, unknown> }>;
         session: SessionState<TData>;
     }> {
-        const { selectedRoute, selectedStep, responseDirectives, history, context, lastMessageText, historyEvents, signal } = params;
+        const { selectedRoute, selectedStep, responseDirectives, history, context, historyEvents, signal } = params;
         let session = params.session;
 
         // Determine next step
@@ -1465,8 +1462,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
             rules: selectedRoute.getRules(),
             prohibitions: selectedRoute.getProhibitions(),
             directives: responseDirectives,
-            history: historyEvents, // Use Event[] for buildResponsePrompt
-            lastMessage: lastMessageText, // Use string for buildResponsePrompt
+            history: historyEvents,
             agentOptions: this.agent.getAgentOptions(),
             combinedGuidelines: [...this.agent.getGuidelines(), ...selectedRoute.getGuidelines()],
             combinedTerms: this.mergeTerms(this.agent.getTerms(), selectedRoute.getTerms()),
@@ -1482,7 +1478,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         const agentOptions = this.agent.getAgentOptions();
         const result = await agentOptions.provider.generateMessage({
             prompt: responsePrompt,
-            history: historyEvents, // Use Event[] for AI provider
+            history, // Use HistoryItem[] for AI provider
             context,
             tools: availableTools,
             signal,
@@ -1537,11 +1533,10 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         session: SessionState<TData>;
         history: HistoryItem[];
         context: TContext;
-        lastMessageText: string; // String version for buildResponsePrompt
-        historyEvents: Event[]; // Event[] version for buildResponsePrompt
+        historyEvents: Event[];
         signal?: AbortSignal;
     }): AsyncGenerator<AgentResponseStreamChunk<TData>> {
-        const { selectedRoute, selectedStep, responseDirectives, history, context, lastMessageText, historyEvents, signal } = params;
+        const { selectedRoute, selectedStep, responseDirectives, history, context, historyEvents, signal } = params;
         let session = params.session;
 
         // Determine next step (same logic as non-streaming)
@@ -1608,8 +1603,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
             rules: selectedRoute.getRules(),
             prohibitions: selectedRoute.getProhibitions(),
             directives: responseDirectives,
-            history: historyEvents, // Use Event[] for buildResponsePrompt
-            lastMessage: lastMessageText, // Use string for buildResponsePrompt
+            history: historyEvents,
             agentOptions: this.agent.getAgentOptions(),
             combinedGuidelines: [...this.agent.getGuidelines(), ...selectedRoute.getGuidelines()],
             combinedTerms: this.mergeTerms(this.agent.getTerms(), selectedRoute.getTerms()),
@@ -1625,7 +1619,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         const agentOptions = this.agent.getAgentOptions();
         const stream = agentOptions.provider.generateMessageStream({
             prompt: responsePrompt,
-            history: historyEvents, // Use Event[] for AI provider
+            history, // Use HistoryItem[] for AI provider
             context,
             tools: availableTools,
             signal,
@@ -1640,21 +1634,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
@@ -1802,34 +1856,34 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
                 toolLoopCount++;
                 logger.debug(`[ResponseModal] Starting tool loop ${toolLoopCount}/${MAX_TOOL_LOOPS} with ${toolCalls?.length || 0} tool calls`);
 
-                // Create tool result events with proper Event format structure
-                const toolResultEvents: Event<ToolEventData>[] = [];
+                // Create tool result history items
+                const toolResultHistoryItems: HistoryItem[] = [];
                 for (const toolCall of toolCalls || []) {
                     const tool = this.findAvailableTool(toolCall.toolName, selectedRoute);
                     if (tool) {
-                        // Create proper Event format for tool results
-                        const toolResultEvent: Event<ToolEventData> = {
-                            kind: EventKind.TOOL,
-                            source: MessageRole.AGENT,
-                            timestamp: new Date().toISOString(),
-                            data: {
-                                tool_calls: [
-                                    {
-                                        tool_id: toolCall.toolName,
-                                        arguments: toolCall.arguments,
-                                        result: {
-                                            data: "Tool executed successfully",
-                                        },
-                                    },
-                                ],
-                            },
-                        };
-                        toolResultEvents.push(toolResultEvent);
+                        // Create HistoryItem format for tool results
+                        // Add assistant message with tool_calls
+                        toolResultHistoryItems.push({
+                            role: "assistant" as const,
+                            content: null,
+                            tool_calls: [{
+                                id: toolCall.toolName,
+                                name: toolCall.toolName,
+                                arguments: toolCall.arguments,
+                            }],
+                        });
+                        // Add tool result
+                        toolResultHistoryItems.push({
+                            role: "tool" as const,
+                            tool_call_id: toolCall.toolName,
+                            name: toolCall.toolName,
+                            content: "Tool executed successfully",
+                        });
                     }
                 }
 
-                // Create updated history with tool results (combine Event arrays)
-                const updatedHistoryEvents = [...historyEvents, ...toolResultEvents];
+                // Create updated history with tool results
+                const updatedHistory = [...history, ...toolResultHistoryItems];
 
                 // Make follow-up AI call to see if more tools are needed
                 // After first iteration, don't provide tools to force a text response
@@ -1844,7 +1898,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
 
                 const followUpResult = await agentOptions.provider.generateMessage({
                     prompt: responsePrompt + (toolLoopCount > 1 ? "\n\nProvide a text response to the user based on the tool results." : ""),
-                    history: updatedHistoryEvents, // Use Event[] for AI provider
+                    history: updatedHistory, // Use HistoryItem[] for AI provider
                     context,
                     tools: shouldProvideTools ? availableTools : [], // Only provide tools on first iteration
                     parameters: responseSchema ? {
@@ -1888,7 +1942,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
                                     context,
                                     updateContext: this.agent.updateContext.bind(this.agent),
                                     updateData: this.agent.updateCollectedData.bind(this.agent),
-                                    history: updatedHistoryEvents, // Use Event[] for tool execution
+                                    history: historyToEvents(updatedHistory), // Convert to Event[] for tool execution
                                     data: session.data,
                                     toolArguments: toolCall.arguments,
                                 });
@@ -2060,11 +2114,11 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         selectedRoute: Route<TContext, TData>;
         session: SessionState<TData>;
         context: TContext;
-        lastMessageText: string; // String version for buildResponsePrompt
-        historyEvents: Event[]; // Event[] version for buildResponsePrompt
+        history: HistoryItem[];
+        historyEvents: Event[];
         signal?: AbortSignal;
     }): Promise<string> {
-        const { selectedRoute, session, context, lastMessageText, historyEvents, signal } = params;
+        const { selectedRoute, session, context, history, historyEvents, signal } = params;
 
         // Get endStep spec from route
         const endStepSpec = selectedRoute.endStepSpec;
@@ -2120,7 +2174,6 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
                 completitionPrompt,
             ],
             history: historyEvents,
-            lastMessage: lastMessageText,
             agentOptions: this.agent.getAgentOptions(),
             combinedGuidelines: alwaysActiveGuidelines, // Only non-conditional guidelines
             combinedTerms: this.mergeTerms(this.agent.getTerms(), selectedRoute.getTerms()),
@@ -2135,7 +2188,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
 
         const completionResult = await agentOptions.provider.generateMessage({
             prompt: completionPrompt,
-            history: historyEvents,
+            history, // Use HistoryItem[] for AI provider
             context,
             signal,
             parameters: { jsonSchema: completionSchema, schemaName: "completion_message" },
@@ -2179,11 +2232,11 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         selectedRoute: Route<TContext, TData>;
         session: SessionState<TData>;
         context: TContext;
-        lastMessageText: string; // String version for buildResponsePrompt
-        historyEvents: Event[]; // Event[] version for buildResponsePrompt
+        history: HistoryItem[];
+        historyEvents: Event[];
         signal?: AbortSignal;
     }): AsyncGenerator<AgentResponseStreamChunk<TData>> {
-        const { selectedRoute, context, lastMessageText, historyEvents, signal } = params;
+        const { selectedRoute, context, history, historyEvents, signal } = params;
         let session = params.session;
 
         // Get endStep spec from route
@@ -2209,8 +2262,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
             rules: selectedRoute.getRules(),
             prohibitions: selectedRoute.getProhibitions(),
             directives: undefined, // No directives for completion
-            history: historyEvents, // Use Event[] for buildResponsePrompt
-            lastMessage: lastMessageText, // Use string for buildResponsePrompt
+            history: historyEvents,
             agentOptions: this.agent.getAgentOptions(),
             combinedGuidelines: [...this.agent.getGuidelines(), ...selectedRoute.getGuidelines()],
             combinedTerms: this.mergeTerms(this.agent.getTerms(), selectedRoute.getTerms()),
@@ -2223,7 +2275,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         const agentOptions = this.agent.getAgentOptions();
         const stream = agentOptions.provider.generateMessageStream({
             prompt: completionPrompt,
-            history: historyEvents, // Use Event[] for AI provider
+            history, // Use HistoryItem[] for AI provider
             context,
             signal,
             parameters: { jsonSchema: responseSchema, schemaName: "completion_message_stream" },
@@ -2292,7 +2344,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
      * @private
      */
     private async generateFallbackResponse(params: {
-        history: Event[]; // Use Event[] for buildFallbackPrompt
+        history: HistoryItem[];
         context: TContext;
         session: SessionState<TData>;
         signal?: AbortSignal;
@@ -2303,7 +2355,6 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
 
         // Build basic response prompt without route context
         const fallbackPrompt = await this.responseEngine.buildFallbackPrompt({
-            history,
             agentOptions: this.agent.getAgentOptions(),
             terms: this.agent.getTerms(),
             guidelines: this.agent.getGuidelines(),
@@ -2336,7 +2387,7 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
      * @private
      */
     private async *streamFallbackResponse(params: {
-        history: Event[]; // Use Event[] for buildFallbackPrompt
+        history: HistoryItem[];
         context: TContext;
         session: SessionState<TData>;
         signal?: AbortSignal;
@@ -2344,7 +2395,6 @@ export class ResponseModal<TContext = unknown, TData = unknown> {
         const { history, context, session, signal } = params;
 
         const fallbackPrompt = await this.responseEngine.buildFallbackPrompt({
-            history,
             agentOptions: this.agent.getAgentOptions(),
             terms: this.agent.getTerms(),
             guidelines: this.agent.getGuidelines(),

package/src/core/ResponsePipeline.ts

@@ -10,7 +10,7 @@ import type {
   Tool,
   RouteTransitionConfig,
 } from "../types";
-import { EventKind, MessageRole } from "../types/history";
+import type { HistoryItem } from "../types/history";
 import {
   createSession,
   enterRoute,
@@ -18,6 +18,7 @@ import {
   mergeCollected,
   logger,
   render,
+  historyToEvents,
 } from "../utils";
 import { createTemplateContext } from "../utils/template";
 import { Route } from "../core/Route";
@@ -171,7 +172,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
         };
       }
     }
-    
+
     // If no pending transition or transition handled, do normal routing
     if (routes.length > 0 && !selectedRoute) {
       const orchestration = await this.routingEngine.decideRouteAndStep({
@@ -242,7 +243,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
         currentStep, // Pass current step instead of undefined to maintain progression
         createTemplateContext({ data: session.data, session, context: contextToUse })
       );
-      
+
       if (candidates.length > 0) {
         nextStep = candidates[0].step;
         logger.debug(
@@ -368,7 +369,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
     selectedRoute?: Route<TContext, TData>;
     nextStep: Step<TContext, TData>;
     responsePrompt: string;
-    history: Event[];
+    history: HistoryItem[];
     context: TContext;
     session: SessionState<TData>;
     responseSchema: Record<string, unknown>;
@@ -400,31 +401,30 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
       );
 
       // Add tool execution results to history so AI knows what happened
-      const toolResultsEvents: Event[] = [];
+      const toolResultItems: HistoryItem[] = [];
       for (const toolCall of currentToolCalls || []) {
         const tool = this.findAvailableTool(toolCall.toolName, selectedRoute);
         if (tool) {
-          toolResultsEvents.push({
-            kind: EventKind.TOOL,
-            source: MessageRole.AGENT,
-            timestamp: new Date().toISOString(),
-            data: {
-              tool_calls: [
-                {
-                  tool_id: toolCall.toolName,
-                  arguments: toolCall.arguments,
-                  result: {
-                    data: "Tool executed successfully",
-                  },
-                },
-              ],
-            },
+          toolResultItems.push({
+            role: "assistant" as const,
+            content: null,
+            tool_calls: [{
+              id: toolCall.toolName,
+              name: toolCall.toolName,
+              arguments: toolCall.arguments,
+            }],
+          });
+          toolResultItems.push({
+            role: "tool" as const,
+            tool_call_id: toolCall.toolName,
+            name: toolCall.toolName,
+            content: "Tool executed successfully",
           });
         }
       }
 
       // Create updated history with tool results
-      const updatedHistory = [...history, ...toolResultsEvents];
+      const updatedHistory = [...history, ...toolResultItems];
 
       // Make follow-up AI call to see if more tools are needed
       const followUpResult = await this.options.provider.generateMessage({
@@ -454,7 +454,7 @@ export class ResponsePipeline<TContext = unknown, TData = unknown> {
           selectedRoute,
           context,
           session: currentSession,
-          history: updatedHistory,
+          history: historyToEvents(updatedHistory),
           isStreaming,
         });