@falai/agent 1.1.3 → 1.2.1

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
@@ -199,8 +261,7 @@ export class AnthropicProvider implements AiProvider {
       for (let i = 0; i < this.backupModels.length; i++) {
         const backupModel = this.backupModels[i];
         logger.debug(
-          `[ANTHROPIC] Trying backup model ${i + 1}/${
-            this.backupModels.length
+          `[ANTHROPIC] Trying backup model ${i + 1}/${this.backupModels.length
           }: ${backupModel}`
         );
 
@@ -249,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) => ({
@@ -299,10 +378,6 @@ export class AnthropicProvider implements AiProvider {
       );
       const message = textContent?.type === "text" ? textContent.text : "";
 
-      if (!message) {
-        throw new Error("No response from Anthropic");
-      }
-
       // Extract tool calls from response
       const toolCalls: Array<{
         toolName: string;
@@ -319,6 +394,11 @@ export class AnthropicProvider implements AiProvider {
         }
       }
 
+      // Only throw error if we have no text AND no function calls
+      if (!message && toolCalls.length === 0) {
+        throw new Error("No response from Anthropic");
+      }
+
       // Parse JSON response if schema was provided
       let structured: AgentStructuredResponse | undefined;
       if (input.parameters?.jsonSchema) {
@@ -333,9 +413,9 @@ export class AnthropicProvider implements AiProvider {
       // If tools were used, include them in structured response
       if (toolCalls.length > 0) {
         structured = {
-          message,
+          ...(structured || {}),
+          message: structured?.message || message,
           toolCalls,
-          ...structured,
         } as AgentStructuredResponse;
       }
 
@@ -390,8 +470,7 @@ export class AnthropicProvider implements AiProvider {
       for (let i = 0; i < this.backupModels.length; i++) {
         const backupModel = this.backupModels[i];
         logger.debug(
-          `[ANTHROPIC] Trying backup model ${i + 1}/${
-            this.backupModels.length
+          `[ANTHROPIC] Trying backup model ${i + 1}/${this.backupModels.length
           }: ${backupModel}`
         );
 
@@ -439,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) => ({
@@ -536,9 +633,9 @@ export class AnthropicProvider implements AiProvider {
     // If tools were used, include them in structured response
     if (toolCalls.length > 0) {
       structured = {
-        message: accumulated,
+        ...(structured || {}),
+        message: structured?.message || accumulated,
         toolCalls,
-        ...structured,
       } as AgentStructuredResponse;
     }
 

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,122 @@ 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,
+   * not raw JSON Schema. This method handles the conversion, including
+   * edge cases like empty objects that Gemini rejects.
+   *
+   * @private
+   */
+  private convertToolParameters(parameters: unknown): Schema | undefined {
+    if (!parameters || typeof parameters !== "object") {
+      return undefined;
+    }
+    try {
+      return this.adaptSchemaForGemini(parameters as StructuredSchema);
+    } catch (error) {
+      logger.warn(`[GeminiProvider] Failed to convert tool parameters, passing as-is:`, error);
+      return parameters as Schema;
+    }
+  }
+
+  /**
+   * Safely extract text from a Gemini response or chunk.
+   * The `.text` getter can throw when the response contains only function calls
+   * (observed in some SDK versions). This method falls back to manually
+   * extracting text parts from candidates.
+   *
+   * @private
+   */
+  private safeExtractText(responseOrChunk: { text?: string; candidates?: Array<{ content?: { parts?: Array<{ text?: string; functionCall?: unknown }> } }> }): string {
+    try {
+      return responseOrChunk.text || "";
+    } catch {
+      // .text getter threw — extract text parts manually
+      const parts = responseOrChunk.candidates?.[0]?.content?.parts;
+      if (parts) {
+        return parts
+          .filter((p) => p.text != null)
+          .map((p) => p.text)
+          .join("");
+      }
+      return "";
+    }
+  }
+
+  /**
+   * Build Gemini function declarations from framework tool definitions.
+   * Converts JSON Schema parameters to Gemini's Schema format.
+   *
+   * @private
+   */
+  private buildFunctionDeclarations(
+    tools: Array<{ id: string; name?: string; description?: string; parameters?: unknown }>
+  ): FunctionDeclaration[] {
+    return tools.map((tool) => ({
+      name: tool.name || tool.id,
+      description: tool.description || "",
+      parameters: this.convertToolParameters(tool.parameters),
+    }));
+  }
+
   /**
    * Adapt common schema format to Gemini's specific requirements.
    * Gemini has strict validation:
@@ -356,15 +473,8 @@ export class GeminiProvider implements AiProvider {
       if (hasTools) {
         const toolNames = input.tools?.map((tool) => tool.name || tool.id) || [];
         logger.debug(`[GeminiProvider] Configuring ${toolNames.length} tools for model ${model}:`, toolNames);
-        configOverride.tools = [
-          {
-            functionDeclarations: input.tools?.map((tool) => ({
-              name: tool.name || tool.id,
-              description: tool.description || "",
-              parameters: tool.parameters as FunctionDeclaration["parameters"], // JSON schema
-            })),
-          },
-        ];
+        const functionDeclarations = this.buildFunctionDeclarations(input.tools!);
+        configOverride.tools = [{ functionDeclarations }];
 
       } else if (hasJsonSchema) {
         // Only set JSON schema if no tools are present
@@ -377,10 +487,29 @@ 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,
-          config: configOverride,
+          contents: historyContents,
+          config: {
+            ...configOverride,
+            ...(input.signal ? { abortSignal: input.signal } : {}),
+          },
         });
       } catch (error: unknown) {
         logger.error(`[GeminiProvider] API call failed:`, error);
@@ -399,7 +528,7 @@ export class GeminiProvider implements AiProvider {
           if (part.functionCall) {
             toolCalls.push({
               toolName: part.functionCall.name || "",
-              arguments: part.functionCall.args as Record<string, unknown>,
+              arguments: (part.functionCall.args as Record<string, unknown>) || {},
             });
           }
         }
@@ -408,30 +537,13 @@ export class GeminiProvider implements AiProvider {
       // Debug logging for response structure
       if (!response.text && toolCalls.length === 0) {
         logger.debug(`[GeminiProvider] Debug - Response structure:`, {
-          hasText: !!response.text,
           candidatesCount: response.candidates?.length || 0,
-          firstCandidateContent: response.candidates?.[0]?.content,
           firstCandidateParts: response.candidates?.[0]?.content?.parts?.length || 0,
         });
       }
-      // Try to get text from response, handling function calls properly
-      let message = "";
-      try {
-        message = response.text || "";
-      } catch (textError) {
-        // Sometimes response.text throws when there are function calls
-        logger.debug(`[GeminiProvider] Could not get response.text (likely due to function calls):`, textError);
-
-        // Try to extract text parts manually
-        if (response.candidates && response.candidates[0]?.content?.parts) {
-          const textParts = response.candidates[0].content.parts
-            .filter(part => part.text)
-            .map(part => part.text)
-            .join('');
-          message = textParts;
-          logger.debug(`[GeminiProvider] Extracted text from parts:`, message);
-        }
-      }
+
+      // Safely extract text — .text getter can throw when response has only function calls
+      const message = this.safeExtractText(response);
 
       // Only throw error if we have no text AND no function calls
       if (!message && toolCalls.length === 0) {
@@ -443,15 +555,8 @@ export class GeminiProvider implements AiProvider {
       // Log when we have function calls but no text (this is normal)
       if (toolCalls.length > 0 && !message) {
         logger.debug(`[GeminiProvider] Function calls detected without text message:`, toolCalls.map(tc => tc.toolName));
-      } else if (toolCalls.length > 0 && message) {
-        logger.debug(`[GeminiProvider] Response has both text and function calls:`, {
-          messageLength: message.length,
-          toolCalls: toolCalls.map(tc => tc.toolName),
-        });
       }
 
-
-
       // Parse JSON response if schema was provided
       let structured: AgentStructuredResponse | undefined;
       if (input.parameters?.jsonSchema) {
@@ -574,15 +679,8 @@ export class GeminiProvider implements AiProvider {
     if (hasTools) {
       const toolNames = input.tools?.map((tool) => tool.name || tool.id) || [];
       logger.debug(`[GeminiProvider] Configuring ${toolNames.length} tools for streaming:`, toolNames);
-      configOverride.tools = [
-        {
-          functionDeclarations: input.tools?.map((tool) => ({
-            name: tool.name || tool.id,
-            description: tool.description || "",
-            parameters: tool.parameters as FunctionDeclaration["parameters"],
-          })),
-        },
-      ];
+      const functionDeclarations = this.buildFunctionDeclarations(input.tools!);
+      configOverride.tools = [{ functionDeclarations }];
 
     } else if (hasJsonSchema) {
       // Only set JSON schema if no tools are present
@@ -595,10 +693,29 @@ 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,
-        config: configOverride,
+        contents: historyContents,
+        config: {
+          ...configOverride,
+          ...(input.signal ? { abortSignal: input.signal } : {}),
+        },
       });
     } catch (error: unknown) {
       logger.error(`[GeminiProvider] Streaming API call failed:`, error);
@@ -615,7 +732,10 @@ export class GeminiProvider implements AiProvider {
     }> = [];
 
     for await (const chunk of stream) {
-      const delta = chunk.text || "";
+      if (input.signal?.aborted) break;
+
+      // Safely extract text — chunk.text can throw when chunk has only function calls
+      const delta = this.safeExtractText(chunk);
 
       // Extract tool calls from chunk
       if (chunk.candidates && chunk.candidates[0]?.content?.parts) {
@@ -623,7 +743,7 @@ export class GeminiProvider implements AiProvider {
           if (part.functionCall) {
             toolCalls.push({
               toolName: part.functionCall.name || "",
-              arguments: part.functionCall.args as Record<string, unknown>,
+              arguments: (part.functionCall.args as Record<string, unknown>) || {},
             });
           }
         }
@@ -657,12 +777,12 @@ export class GeminiProvider implements AiProvider {
       }
     }
 
-    // If tools were used, include them in structured response
+    // Include tool calls in structured response (even without JSON schema)
     if (toolCalls.length > 0) {
       structured = {
         message: structured?.message || accumulated,
-        toolCalls,
         ...structured,
+        toolCalls,
       } as AgentStructuredResponse;
     }