@falai/agent 1.2.0 → 1.2.2

package/src/providers/AnthropicProvider.ts

@@ -15,6 +15,7 @@ import type {
   GenerateMessageStreamChunk,
   AgentStructuredResponse,
 } from "../types";
+import type { HistoryItem } from "../types/history";
 import { withTimeoutAndRetry, logger } from "../utils";
 
 const DEFAULT_RETRY_CONFIG = {
@@ -152,6 +153,67 @@ export class AnthropicProvider implements AiProvider {
     };
   }
 
+  /**
+   * Build Anthropic-formatted messages from HistoryItem[] array.
+   * System messages are extracted separately (Anthropic uses a `system` param).
+   * Tool results are mapped to Anthropic's tool_result content blocks.
+   * Assistant tool_calls are mapped to tool_use content blocks.
+   */
+  private buildAnthropicMessages(history: HistoryItem[]): {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    messages: any[];
+    systemMessages: string[];
+  } {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const messages: any[] = [];
+    const systemMessages: string[] = [];
+
+    for (const item of history) {
+      switch (item.role) {
+        case "system":
+          systemMessages.push(item.content);
+          break;
+        case "user":
+          messages.push({ role: "user", content: item.content });
+          break;
+        case "assistant":
+          if (item.tool_calls && item.tool_calls.length > 0) {
+            const content: Array<Record<string, unknown>> = [];
+            if (item.content) {
+              content.push({ type: "text", text: item.content });
+            }
+            for (const tc of item.tool_calls) {
+              content.push({
+                type: "tool_use",
+                id: tc.id,
+                name: tc.name,
+                input: tc.arguments,
+              });
+            }
+            messages.push({ role: "assistant", content });
+          } else {
+            messages.push({ role: "assistant", content: item.content || "" });
+          }
+          break;
+        case "tool":
+          // Anthropic tool results are sent as user messages with tool_result content blocks
+          messages.push({
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: item.tool_call_id,
+                content: typeof item.content === "string" ? item.content : JSON.stringify(item.content),
+              },
+            ],
+          });
+          break;
+      }
+    }
+
+    return { messages, systemMessages };
+  }
+
   async generateMessage<
     TContext = unknown,
     TStructured = AgentStructuredResponse
@@ -248,18 +310,36 @@ export class AnthropicProvider implements AiProvider {
       // Anthropic requires max_tokens to be specified
       const maxTokens = input.parameters?.maxOutputTokens || 4096;
 
+      // Build messages from history
+      const { messages: historyMessages, systemMessages } = this.buildAnthropicMessages(input.history);
+
+      // Append the current prompt as the final user message
+      historyMessages.push({
+        role: "user",
+        content: input.prompt,
+      });
+
       const params: MessageCreateParamsNonStreaming = {
         model,
         max_tokens: maxTokens,
-        messages: [
-          {
-            role: "user",
-            content: input.prompt,
-          },
-        ],
+        messages: historyMessages,
         ...this.config,
       };
 
+      // Set system messages from history if present
+      if (systemMessages.length > 0) {
+        if (typeof this.config?.system === "string") {
+          params.system = `${this.config.system}\n\n${systemMessages.join("\n\n")}`;
+        } else if (Array.isArray(this.config?.system)) {
+          params.system = [
+            ...this.config.system,
+            ...systemMessages.map(s => ({ type: "text" as const, text: s })),
+          ];
+        } else {
+          params.system = systemMessages.join("\n\n");
+        }
+      }
+
       // Add tools if provided
       if (input.tools && input.tools.length > 0) {
         params.tools = input.tools.map((tool) => ({
@@ -438,19 +518,37 @@ export class AnthropicProvider implements AiProvider {
     // Anthropic requires max_tokens to be specified
     const maxTokens = input.parameters?.maxOutputTokens || 4096;
 
+    // Build messages from history
+    const { messages: historyMessages, systemMessages } = this.buildAnthropicMessages(input.history);
+
+    // Append the current prompt as the final user message
+    historyMessages.push({
+      role: "user" as const,
+      content: input.prompt,
+    });
+
     const params = {
       model,
       max_tokens: maxTokens,
-      messages: [
-        {
-          role: "user" as const,
-          content: input.prompt,
-        },
-      ],
+      messages: historyMessages,
       stream: true,
       ...this.config,
     };
 
+    // Set system messages from history if present
+    if (systemMessages.length > 0) {
+      if (typeof this.config?.system === "string") {
+        params.system = `${this.config.system}\n\n${systemMessages.join("\n\n")}`;
+      } else if (Array.isArray(this.config?.system)) {
+        params.system = [
+          ...this.config.system,
+          ...systemMessages.map(s => ({ type: "text" as const, text: s })),
+        ];
+      } else {
+        params.system = systemMessages.join("\n\n");
+      }
+    }
+
     // Add tools if provided
     if (input.tools && input.tools.length > 0) {
       params.tools = input.tools.map((tool) => ({

package/src/providers/GeminiProvider.ts

@@ -19,6 +19,7 @@ import type {
   AgentStructuredResponse,
   StructuredSchema,
 } from "../types";
+import type { HistoryItem } from "../types/history";
 import { withTimeoutAndRetry } from "../utils/retry";
 import { tryParseJSONResponse } from "../utils/json";
 import { logger } from "../utils/logger";
@@ -152,6 +153,62 @@ export class GeminiProvider implements AiProvider {
     };
   }
 
+  /**
+   * Build Gemini-formatted contents from HistoryItem[] array.
+   * Gemini uses "user"/"model" roles (not "assistant").
+   * System messages are extracted separately for systemInstruction.
+   * Tool results map to functionResponse parts, tool calls to functionCall parts.
+   */
+  private buildGeminiContents(history: HistoryItem[]): {
+    contents: Array<{ role: string; parts: Array<Record<string, unknown>> }>;
+    systemInstructions: string[];
+  } {
+    const contents: Array<{ role: string; parts: Array<Record<string, unknown>> }> = [];
+    const systemInstructions: string[] = [];
+
+    for (const item of history) {
+      switch (item.role) {
+        case "system":
+          systemInstructions.push(item.content);
+          break;
+        case "user":
+          contents.push({ role: "user", parts: [{ text: item.content }] });
+          break;
+        case "assistant":
+          if (item.tool_calls && item.tool_calls.length > 0) {
+            const parts: Array<Record<string, unknown>> = [];
+            if (item.content) {
+              parts.push({ text: item.content });
+            }
+            for (const tc of item.tool_calls) {
+              parts.push({
+                functionCall: { name: tc.name, args: tc.arguments },
+              });
+            }
+            contents.push({ role: "model", parts });
+          } else {
+            contents.push({ role: "model", parts: [{ text: item.content || "" }] });
+          }
+          break;
+        case "tool":
+          contents.push({
+            role: "user",
+            parts: [
+              {
+                functionResponse: {
+                  name: item.name,
+                  response: typeof item.content === "object" ? item.content : { result: item.content },
+                },
+              },
+            ],
+          });
+          break;
+      }
+    }
+
+    return { contents, systemInstructions };
+  }
+
   /**
    * Convert tool parameter schemas (JSON Schema) to Gemini's Schema format.
    * Gemini's FunctionDeclaration.parameters expects its own Schema type,
@@ -430,9 +487,25 @@ export class GeminiProvider implements AiProvider {
 
       let response: GenerateContentResponse;
       try {
+        // Build contents from history
+        const { contents: historyContents, systemInstructions } = this.buildGeminiContents(input.history);
+
+        // Append the current prompt as the final user content
+        historyContents.push({ role: "user", parts: [{ text: input.prompt }] });
+
+        // Set system instruction from history if present
+        if (systemInstructions.length > 0) {
+          const existingSystem = configOverride.systemInstruction;
+          if (typeof existingSystem === "string") {
+            configOverride.systemInstruction = `${existingSystem}\n\n${systemInstructions.join("\n\n")}`;
+          } else {
+            configOverride.systemInstruction = systemInstructions.join("\n\n");
+          }
+        }
+
         response = await this.genAI.models.generateContent({
           model,
-          contents: input.prompt,
+          contents: historyContents,
           config: {
             ...configOverride,
             ...(input.signal ? { abortSignal: input.signal } : {}),
@@ -620,9 +693,25 @@ export class GeminiProvider implements AiProvider {
 
     let stream;
     try {
+      // Build contents from history
+      const { contents: historyContents, systemInstructions } = this.buildGeminiContents(input.history);
+
+      // Append the current prompt as the final user content
+      historyContents.push({ role: "user", parts: [{ text: input.prompt }] });
+
+      // Set system instruction from history if present
+      if (systemInstructions.length > 0) {
+        const existingSystem = configOverride.systemInstruction;
+        if (typeof existingSystem === "string") {
+          configOverride.systemInstruction = `${existingSystem}\n\n${systemInstructions.join("\n\n")}`;
+        } else {
+          configOverride.systemInstruction = systemInstructions.join("\n\n");
+        }
+      }
+
       stream = await this.genAI.models.generateContentStream({
         model,
-        contents: input.prompt,
+        contents: historyContents,
         config: {
           ...configOverride,
           ...(input.signal ? { abortSignal: input.signal } : {}),

package/src/providers/OpenAIProvider.ts

@@ -13,6 +13,7 @@ import type {
   AgentStructuredResponse,
   StructuredSchema,
 } from "../types";
+import type { HistoryItem } from "../types/history";
 import { withTimeoutAndRetry, logger } from "../utils";
 import { FunctionParameters } from "openai/resources/shared.mjs";
 
@@ -161,6 +162,52 @@ export class OpenAIProvider implements AiProvider {
     };
   }
 
+  /**
+   * Build OpenAI-formatted messages from HistoryItem[] array.
+   * Maps directly to ChatCompletionMessageParam format.
+   */
+  private buildOpenAIMessages(history: HistoryItem[]): Array<unknown> {
+    const messages: Array<unknown> = [];
+
+    for (const item of history) {
+      switch (item.role) {
+        case "system":
+          messages.push({ role: "system", content: item.content });
+          break;
+        case "user":
+          messages.push({ role: "user", content: item.content });
+          break;
+        case "assistant":
+          if (item.tool_calls && item.tool_calls.length > 0) {
+            messages.push({
+              role: "assistant",
+              content: item.content || null,
+              tool_calls: item.tool_calls.map(tc => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                  name: tc.name,
+                  arguments: JSON.stringify(tc.arguments),
+                },
+              })),
+            });
+          } else {
+            messages.push({ role: "assistant", content: item.content || "" });
+          }
+          break;
+        case "tool":
+          messages.push({
+            role: "tool",
+            tool_call_id: item.tool_call_id,
+            content: typeof item.content === "string" ? item.content : JSON.stringify(item.content),
+          });
+          break;
+      }
+    }
+
+    return messages;
+  }
+
   /**
    * Adapt common schema format to OpenAI's format.
    * OpenAI uses standard JSON Schema, so this is mostly a passthrough.
@@ -265,14 +312,12 @@ export class OpenAIProvider implements AiProvider {
     input: GenerateMessageInput<TContext>
   ): Promise<GenerateMessageOutput<TStructured>> {
     const operation = async (): Promise<GenerateMessageOutput> => {
+      const historyMessages = this.buildOpenAIMessages(input.history);
+      historyMessages.push({ role: "user", content: input.prompt });
+
       const params: ChatCompletionCreateParamsNonStreaming = {
         model,
-        messages: [
-          {
-            role: "user",
-            content: input.prompt,
-          },
-        ],
+        messages: historyMessages as ChatCompletionCreateParamsNonStreaming["messages"],
         ...this.config,
       };
 
@@ -468,15 +513,14 @@ export class OpenAIProvider implements AiProvider {
     model: string,
     input: GenerateMessageInput<TContext>
   ): AsyncGenerator<GenerateMessageStreamChunk<TStructured>> {
+    // Build messages from history and append prompt as final user message
+    const historyMessages = this.buildOpenAIMessages(input.history);
+    historyMessages.push({ role: "user" as const, content: input.prompt });
+
     const params = {
       ...this.config,
       model,
-      messages: [
-        {
-          role: "user" as const,
-          content: input.prompt,
-        },
-      ],
+      messages: historyMessages as ChatCompletionCreateParamsNonStreaming["messages"],
       stream: true as const,
     };
 

package/src/providers/OpenRouterProvider.ts

@@ -15,6 +15,7 @@ import type {
   GenerateMessageStreamChunk,
   StructuredSchema,
 } from "../types";
+import type { HistoryItem } from "../types/history";
 import { withTimeoutAndRetry, logger } from "../utils";
 
 const DEFAULT_RETRY_CONFIG = {
@@ -171,6 +172,52 @@ export class OpenRouterProvider implements AiProvider {
     };
   }
 
+  /**
+   * Build OpenRouter-formatted messages from HistoryItem[] array.
+   * OpenRouter uses OpenAI-compatible format.
+   */
+  private buildOpenRouterMessages(history: HistoryItem[]): Array<unknown> {
+    const messages: Array<unknown> = [];
+
+    for (const item of history) {
+      switch (item.role) {
+        case "system":
+          messages.push({ role: "system", content: item.content });
+          break;
+        case "user":
+          messages.push({ role: "user", content: item.content });
+          break;
+        case "assistant":
+          if (item.tool_calls && item.tool_calls.length > 0) {
+            messages.push({
+              role: "assistant",
+              content: item.content || null,
+              tool_calls: item.tool_calls.map(tc => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                  name: tc.name,
+                  arguments: JSON.stringify(tc.arguments),
+                },
+              })),
+            });
+          } else {
+            messages.push({ role: "assistant", content: item.content || "" });
+          }
+          break;
+        case "tool":
+          messages.push({
+            role: "tool",
+            tool_call_id: item.tool_call_id,
+            content: typeof item.content === "string" ? item.content : JSON.stringify(item.content),
+          });
+          break;
+      }
+    }
+
+    return messages;
+  }
+
   /**
    * Adapt common schema format to OpenRouter's format.
    * OpenRouter is OpenAI-compatible and uses standard JSON Schema.
@@ -272,14 +319,12 @@ export class OpenRouterProvider implements AiProvider {
     input: GenerateMessageInput<TContext>
   ): Promise<GenerateMessageOutput<TStructured>> {
     const operation = async (): Promise<GenerateMessageOutput> => {
+      const historyMessages = this.buildOpenRouterMessages(input.history);
+      historyMessages.push({ role: "user", content: input.prompt });
+
       const params: ChatCompletionCreateParamsNonStreaming = {
         model,
-        messages: [
-          {
-            role: "user",
-            content: input.prompt,
-          },
-        ],
+        messages: historyMessages as ChatCompletionCreateParamsNonStreaming["messages"],
         ...this.config,
       };
 
@@ -471,15 +516,13 @@ export class OpenRouterProvider implements AiProvider {
     model: string,
     input: GenerateMessageInput<TContext>
   ): AsyncGenerator<GenerateMessageStreamChunk<TStructured>> {
+    const historyMessages = this.buildOpenRouterMessages(input.history);
+    historyMessages.push({ role: "user" as const, content: input.prompt });
+
     const params = {
       ...this.config,
       model,
-      messages: [
-        {
-          role: "user" as const,
-          content: input.prompt,
-        },
-      ],
+      messages: historyMessages as ChatCompletionCreateParamsNonStreaming["messages"],
       stream: true as const,
     };
 

package/src/types/ai.ts

@@ -2,7 +2,7 @@
  * AI provider strategy types
  */
 
-import type { Event } from "./history";
+import type { HistoryItem } from "./history";
 
 /**
  * Reasoning/thinking configuration for AI models
@@ -36,7 +36,7 @@ export interface GenerateMessageInput<TContext = unknown> {
   /** The constructed prompt */
   prompt: string;
   /** Interaction history */
-  history: Event[];
+  history: HistoryItem[];
   /** Context data */
   context: TContext;
   /** Tools available for AI to call during this interaction */