@luanpoppe/ai 1.1.0 → 1.1.2

package/tests/unit/index.test.ts

@@ -2,6 +2,7 @@ import { AI } from "../../src/index";
 import { AIModels } from "../../src/langchain/models";
 import { createAgent } from "langchain";
 import { AIMessages } from "../../src/langchain/messages";
+import { AIMemory } from "../../src/langchain/checkpointers";
 import z from "zod";
 
 // Mock das dependências
@@ -11,10 +12,6 @@ vi.mock("langchain", async () => {
     ...actual,
     createAgent: vi.fn(),
     modelRetryMiddleware: vi.fn((config) => ({ type: "retry", ...config })),
-    modelFallbackMiddleware: vi.fn((...models) => ({
-      type: "fallback",
-      models,
-    })),
   };
 });
 
@@ -22,9 +19,23 @@ vi.mock("../../src/langchain/models", () => ({
   AIModels: {
     gpt: vi.fn(),
     gemini: vi.fn(),
+    openrouter: vi.fn(),
   },
 }));
 
+vi.mock("../../src/langchain/checkpointers", async () => {
+  const actual = await vi.importActual("../../src/langchain/checkpointers");
+  return {
+    ...actual,
+    AIMemory: vi.fn().mockImplementation(function () {
+      return {
+        getCheckpointer: vi.fn().mockResolvedValue({}),
+        setAgent: vi.fn(),
+      };
+    }),
+  };
+});
+
 describe("AI", () => {
   let ai: AI;
   const mockTokens = {
@@ -52,6 +63,30 @@ describe("AI", () => {
       const instance = new AI({ googleGeminiToken: "test-token" });
       expect(instance).toBeInstanceOf(AI);
     });
+
+    it("deve criar uma instância com memory config e expor getter memory", () => {
+      const instance = new AI({
+        openAIApiKey: "test-key",
+        memory: { type: "memory" },
+      });
+      expect(instance).toBeInstanceOf(AI);
+      expect(instance.memory).toBeDefined();
+    });
+
+    it("deve criar uma instância com checkpointer", () => {
+      const mockCheckpointer = {} as any;
+      const instance = new AI({
+        openAIApiKey: "test-key",
+        checkpointer: mockCheckpointer,
+      });
+      expect(instance).toBeInstanceOf(AI);
+      expect(() => instance.memory).toThrow("memory não está configurado");
+    });
+
+    it("memory getter deve lançar erro quando memory não está configurado", () => {
+      const instance = new AI({ openAIApiKey: "test-key" });
+      expect(() => instance.memory).toThrow("memory não está configurado");
+    });
   });
 
   describe("call", () => {
@@ -159,14 +194,17 @@ describe("AI", () => {
         invoke: vi.fn().mockResolvedValue(mockResponse),
       } as any);
 
+      const { modelRetryMiddleware } = await import("langchain");
+
       await ai.call({
         aiModel: "gpt-4",
         messages: mockMessages,
         maxRetries: 5,
       });
 
-      const callArgs = vi.mocked(createAgent).mock.calls[0][0];
-      expect(callArgs.middleware).toBeDefined();
+      expect(modelRetryMiddleware).toHaveBeenCalledWith(
+        expect.objectContaining({ maxRetries: 5 }),
+      );
     });
 
     it("deve usar modelo GPT quando aiModel começa com 'gpt'", async () => {
@@ -222,7 +260,7 @@ describe("AI", () => {
         ai.call({
           aiModel: "unsupported-model" as any,
           messages: mockMessages,
-        })
+        }),
       ).rejects.toThrow("Model not supported");
     });
 
@@ -254,6 +292,231 @@ describe("AI", () => {
         temperature: 0.7,
       });
     });
+
+    it("deve lançar erro quando memory está ativo e threadId não é fornecido", async () => {
+      const aiWithMemory = new AI({
+        openAIApiKey: "test-key",
+        memory: { type: "memory" },
+      });
+
+      await expect(
+        aiWithMemory.call({
+          aiModel: "gpt-4",
+          messages: [AIMessages.human("Olá")],
+        }),
+      ).rejects.toThrow("threadId é obrigatório");
+    });
+
+    it("deve fazer fallback para o próximo modelo quando o principal falhar", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const mockResponse = {
+        messages: [{ content: "Resposta do fallback" } as any],
+      };
+      const error = new Error("Modelo principal falhou");
+
+      vi.mocked(AIModels.gpt).mockReturnValue(mockModel);
+      vi.mocked(AIModels.gemini).mockReturnValue(mockModel);
+
+      let createCount = 0;
+      vi.mocked(createAgent).mockImplementation(() => {
+        createCount++;
+        return {
+          invoke: vi.fn().mockImplementation(() => {
+            if (createCount === 1) return Promise.reject(error);
+            return Promise.resolve(mockResponse);
+          }),
+        } as any;
+      });
+
+      const result = await ai.call({
+        aiModel: "gpt-4",
+        messages: mockMessages,
+        aiModelsFallback: ["gemini-2.5-flash"],
+      });
+
+      expect(createAgent).toHaveBeenCalledTimes(2);
+      expect(AIModels.gpt).toHaveBeenCalled();
+      expect(AIModels.gemini).toHaveBeenCalled();
+      expect(result.text).toBe("Resposta do fallback");
+    });
+
+    it("deve fazer fallback com modelo OpenRouter na lista", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const mockResponse = {
+        messages: [{ content: "Resposta OpenRouter" } as any],
+      };
+      const error = new Error("GPT falhou");
+
+      const aiWithOpenRouter = new AI({
+        openAIApiKey: "test-key",
+        openRouterApiKey: "test-openrouter-key",
+      });
+
+      vi.mocked(AIModels.gpt).mockReturnValue(mockModel);
+      vi.mocked(AIModels.openrouter).mockReturnValue(mockModel);
+
+      let callCount = 0;
+      vi.mocked(createAgent).mockImplementation(() => {
+        callCount++;
+        return {
+          invoke: vi.fn().mockImplementation(() => {
+            if (callCount === 1) return Promise.reject(error);
+            return Promise.resolve(mockResponse);
+          }),
+        } as any;
+      });
+
+      const result = await aiWithOpenRouter.call({
+        aiModel: "gpt-4",
+        messages: mockMessages,
+        aiModelsFallback: ["openrouter/openai/gpt-5-nano"],
+      });
+
+      expect(AIModels.openrouter).toHaveBeenCalledWith(
+        expect.objectContaining({
+          model: "openai/gpt-5-nano",
+          apiKey: "test-openrouter-key",
+        }),
+      );
+      expect(result.text).toBe("Resposta OpenRouter");
+    });
+
+    it("deve usar aiModelsFallback do construtor quando não passado no método", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const mockResponse = {
+        messages: [{ content: "Resposta fallback default" } as any],
+      };
+      const error = new Error("Modelo principal falhou");
+
+      const aiWithDefaultFallback = new AI({
+        openAIApiKey: "test-key",
+        aiModelsFallback: ["gemini-2.5-flash"],
+      });
+
+      vi.mocked(AIModels.gpt).mockReturnValue(mockModel);
+      vi.mocked(AIModels.gemini).mockReturnValue(mockModel);
+
+      let createCount = 0;
+      vi.mocked(createAgent).mockImplementation(() => {
+        createCount++;
+        return {
+          invoke: vi.fn().mockImplementation(() => {
+            if (createCount === 1) return Promise.reject(error);
+            return Promise.resolve(mockResponse);
+          }),
+        } as any;
+      });
+
+      const result = await aiWithDefaultFallback.call({
+        aiModel: "gpt-4",
+        messages: mockMessages,
+      });
+
+      expect(createAgent).toHaveBeenCalledTimes(2);
+      expect(result.text).toBe("Resposta fallback default");
+    });
+
+    it("deve usar aiModelsFallback do método quando passado, sobrescrevendo o do construtor", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const mockResponse = {
+        messages: [{ content: "Resposta fallback do método" } as any],
+      };
+      const error = new Error("Modelo principal falhou");
+
+      const aiWithDefaultFallback = new AI({
+        openAIApiKey: "test-key",
+        openRouterApiKey: "test-openrouter-key",
+        aiModelsFallback: ["gemini-2.5-flash"],
+      });
+
+      vi.mocked(AIModels.gpt).mockReturnValue(mockModel);
+      vi.mocked(AIModels.openrouter).mockReturnValue(mockModel);
+
+      let createCount = 0;
+      vi.mocked(createAgent).mockImplementation(() => {
+        createCount++;
+        return {
+          invoke: vi.fn().mockImplementation(() => {
+            if (createCount === 1) return Promise.reject(error);
+            return Promise.resolve(mockResponse);
+          }),
+        } as any;
+      });
+
+      const result = await aiWithDefaultFallback.call({
+        aiModel: "gpt-4",
+        messages: mockMessages,
+        aiModelsFallback: ["openrouter/openai/gpt-5-nano"],
+      });
+
+      expect(AIModels.openrouter).toHaveBeenCalled();
+      expect(result.text).toBe("Resposta fallback do método");
+    });
+
+    it("deve lançar exceção quando todos os modelos falharem", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const error = new Error("Todos os modelos falharam");
+
+      vi.mocked(AIModels.gpt).mockReturnValue(mockModel);
+      vi.mocked(AIModels.gemini).mockReturnValue(mockModel);
+
+      vi.mocked(createAgent).mockReturnValue({
+        invoke: vi.fn().mockRejectedValue(error),
+      } as any);
+
+      await expect(
+        ai.call({
+          aiModel: "gpt-4",
+          messages: mockMessages,
+          aiModelsFallback: ["gemini-2.5-flash"],
+        }),
+      ).rejects.toThrow("Todos os modelos falharam");
+
+      expect(createAgent).toHaveBeenCalledTimes(2);
+    });
+
+    it("deve passar checkpointer e thread_id quando memory e threadId são fornecidos", async () => {
+      const mockCheckpointer = {};
+      vi.mocked(AIMemory).mockImplementation(function () {
+        return {
+          getCheckpointer: vi.fn().mockResolvedValue(mockCheckpointer),
+          setAgent: vi.fn(),
+        } as any;
+      });
+
+      const aiWithMemory = new AI({
+        openAIApiKey: "test-key",
+        memory: { type: "memory" },
+      });
+
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Olá")];
+      const mockResponse = {
+        messages: [mockMessages[0], { content: "Resposta" } as any],
+      };
+
+      vi.mocked(AIModels.gpt).mockReturnValue(mockModel);
+      const mockInvoke = vi.fn().mockResolvedValue(mockResponse);
+      vi.mocked(createAgent).mockReturnValue({ invoke: mockInvoke } as any);
+
+      await aiWithMemory.call({
+        aiModel: "gpt-4",
+        messages: mockMessages,
+        threadId: "thread-123",
+      });
+
+      const callArgs = vi.mocked(createAgent).mock.calls[0][0];
+      expect(callArgs.checkpointer).toBe(mockCheckpointer);
+      expect(mockInvoke).toHaveBeenCalledWith(
+        { messages: mockMessages },
+        { configurable: { thread_id: "thread-123" } },
+      );
+    });
   });
 
   describe("callStructuredOutput", () => {
@@ -284,6 +547,40 @@ describe("AI", () => {
       expect(result.response).toEqual(mockStructuredResponse);
     });
 
+    it("deve fazer fallback no callStructuredOutput quando o modelo principal falhar", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const outputSchema = z.object({ name: z.string() });
+      const mockStructuredResponse = { name: "Fallback" };
+      const error = new Error("Modelo principal falhou");
+
+      vi.mocked(AIModels.gpt).mockReturnValue(mockModel);
+      vi.mocked(AIModels.gemini).mockReturnValue(mockModel);
+
+      let createCount = 0;
+      vi.mocked(createAgent).mockImplementation(() => {
+        createCount++;
+        return {
+          invoke: vi.fn().mockImplementation(() => {
+            if (createCount === 1) return Promise.reject(error);
+            return Promise.resolve({
+              structuredResponse: mockStructuredResponse,
+            });
+          }),
+        } as any;
+      });
+
+      const result = await ai.callStructuredOutput({
+        aiModel: "gpt-4",
+        messages: mockMessages,
+        outputSchema,
+        aiModelsFallback: ["gemini-2.5-flash"],
+      });
+
+      expect(createAgent).toHaveBeenCalledTimes(2);
+      expect(result.response).toEqual(mockStructuredResponse);
+    });
+
     it("deve validar o schema e lançar erro se inválido", async () => {
       const mockModel = {} as any;
       const mockMessages = [AIMessages.human("Teste")];
@@ -305,13 +602,13 @@ describe("AI", () => {
           aiModel: "gpt-4",
           messages: mockMessages,
           outputSchema,
-        })
+        }),
       ).rejects.toThrow();
     });
   });
 
   describe("getRawAgent", () => {
-    it("deve retornar um agente sem outputSchema", () => {
+    it("deve retornar um agente sem outputSchema", async () => {
       const mockModel = {} as any;
       const mockMessages = [AIMessages.human("Teste")];
       const mockAgent = {
@@ -321,7 +618,7 @@ describe("AI", () => {
       vi.mocked(AIModels.gpt).mockReturnValue(mockModel);
       vi.mocked(createAgent).mockReturnValue(mockAgent as any);
 
-      const result = ai.getRawAgent({
+      const result = await ai.getRawAgent({
         aiModel: "gpt-4",
         messages: mockMessages,
       });
@@ -330,7 +627,7 @@ describe("AI", () => {
       expect(result.agent).toBe(mockAgent);
     });
 
-    it("deve retornar um agente com outputSchema quando fornecido", () => {
+    it("deve retornar um agente com outputSchema quando fornecido", async () => {
       const mockModel = {} as any;
       const mockMessages = [AIMessages.human("Teste")];
       const outputSchema = z.object({ result: z.string() });
@@ -341,12 +638,12 @@ describe("AI", () => {
       vi.mocked(AIModels.gpt).mockReturnValue(mockModel);
       vi.mocked(createAgent).mockReturnValue(mockAgent as any);
 
-      const result = ai.getRawAgent(
+      const result = await ai.getRawAgent(
         {
           aiModel: "gpt-4",
           messages: mockMessages,
         },
-        outputSchema
+        outputSchema,
       );
 
       expect(createAgent).toHaveBeenCalled();

package/tests/unit/langchain/checkpointers.test.ts

@@ -0,0 +1,147 @@
+import { AIMemory } from "../../../src/langchain/checkpointers";
+import { MemorySaver } from "@langchain/langgraph";
+import { describe, it, expect, vi } from "vitest";
+
+describe("AIMemory", () => {
+  describe("getCheckpointer", () => {
+    it("deve criar MemorySaver para type memory", async () => {
+      const memory = new AIMemory({ type: "memory" });
+      const checkpointer = await memory.getCheckpointer();
+      expect(checkpointer).toBeInstanceOf(MemorySaver);
+    });
+
+    it("deve retornar a mesma instância em chamadas subsequentes", async () => {
+      const memory = new AIMemory({ type: "memory" });
+      const cp1 = await memory.getCheckpointer();
+      const cp2 = await memory.getCheckpointer();
+      expect(cp1).toBe(cp2);
+    });
+
+    it("deve criar MongoDBSaver com url quando pacotes estão instalados", async () => {
+      const memory = new AIMemory({
+        type: "mongodb",
+        url: "mongodb://localhost:27017/test",
+      });
+      const checkpointer = await memory.getCheckpointer();
+      expect(checkpointer).toBeDefined();
+      expect(checkpointer).toHaveProperty("get");
+      expect(checkpointer).toHaveProperty("put");
+    });
+  });
+
+  describe("getHistory", () => {
+    it("deve retornar fullHistory e messages via graph.getStateHistory", async () => {
+      const memory = new AIMemory({ type: "memory" });
+      const mockSnapshot1 = {
+        values: { messages: [{ role: "user", content: "oi" }] },
+        config: { configurable: { thread_id: "1" } },
+        next: [],
+        tasks: [],
+        createdAt: "2024-01-01T10:00:00Z",
+      };
+      const mockSnapshot2 = {
+        values: {
+          messages: [
+            { role: "user", content: "oi" },
+            { role: "assistant", content: "olá" },
+          ],
+        },
+        config: { configurable: { thread_id: "1" } },
+        next: [],
+        tasks: [],
+        createdAt: "2024-01-01T10:01:00Z",
+      };
+      // getStateHistory retorna mais recente primeiro: snapshot2 (2 msgs) depois snapshot1 (1 msg)
+      const mockGraph = {
+        getStateHistory: vi.fn(async function* () {
+          yield mockSnapshot2;
+          yield mockSnapshot1;
+        }),
+      };
+      const result = await memory.getHistory("1", mockGraph as any);
+      expect(result.fullHistory).toHaveLength(2);
+      expect(result.fullHistory[0]).toEqual(mockSnapshot2);
+      expect(result.fullHistory[1]).toEqual(mockSnapshot1);
+      expect(result.messages).toHaveLength(2);
+      expect(result.messages[0]).toEqual({
+        role: "human",
+        createdAt: "2024-01-01T10:00:00Z",
+        content: "oi",
+      });
+      expect(result.messages[1]).toEqual({
+        role: "ai",
+        createdAt: "2024-01-01T10:01:00Z",
+        content: "olá",
+      });
+      expect(mockGraph.getStateHistory).toHaveBeenCalledWith({
+        configurable: { thread_id: "1" },
+      });
+    });
+
+    it("deve usar agent do setAgent quando graph não é passado", async () => {
+      const memory = new AIMemory({ type: "memory" });
+      const mockGraph = {
+        getStateHistory: vi.fn(async function* () {
+          yield {
+            values: { messages: [{ role: "user", content: "teste" }] },
+            createdAt: "2024-01-01T10:00:00Z",
+          };
+        }),
+      };
+      memory.setAgent(mockGraph as any);
+      const result = await memory.getHistory("1");
+      expect(result.messages).toHaveLength(1);
+      expect(result.messages[0].content).toBe("teste");
+      expect(mockGraph.getStateHistory).toHaveBeenCalledWith({
+        configurable: { thread_id: "1" },
+      });
+    });
+
+    it("deve lançar erro quando graph não é passado e agent não foi definido", async () => {
+      const memory = new AIMemory({ type: "memory" });
+      await expect(memory.getHistory("1")).rejects.toThrow(
+        "É necessário passar graph em getHistory ou definir o agent"
+      );
+    });
+  });
+
+  describe("getState", () => {
+    it("deve retornar estado atual via graph.getState quando disponível", async () => {
+      const memory = new AIMemory({ type: "memory" });
+      const mockState = {
+        values: { messages: [{ role: "user", content: "oi" }] },
+        config: { configurable: { thread_id: "1" } },
+        next: [],
+        tasks: [],
+      };
+      const mockGraph = {
+        getState: vi.fn().mockResolvedValue(mockState),
+        getStateHistory: vi.fn(async function* () {
+          yield mockState;
+        }),
+      };
+      const state = await memory.getState("1", mockGraph as any);
+      expect(state).toEqual(mockState);
+      expect(mockGraph.getState).toHaveBeenCalledWith({
+        configurable: { thread_id: "1" },
+      });
+    });
+
+    it("deve usar getStateHistory quando getState não existe", async () => {
+      const memory = new AIMemory({ type: "memory" });
+      const mockState = {
+        values: { messages: [] },
+        config: { configurable: { thread_id: "1" } },
+        next: [],
+        tasks: [],
+      };
+      const mockGraph = {
+        getStateHistory: vi.fn(async function* () {
+          yield mockState;
+        }),
+      };
+      const state = await memory.getState("1", mockGraph as any);
+      expect(state).toEqual(mockState);
+    });
+  });
+});

package/tests/unit/langchain/tools.test.ts

@@ -103,7 +103,8 @@ describe("AITools", () => {
 
     it("deve criar múltiplas ferramentas independentes", () => {
       const toolFunction1 = async (input: { x: number }) => input.x * 2;
-      const toolFunction2 = async (input: { y: string }) => y.toUpperCase();
+      const toolFunction2 = async (input: { y: string }) =>
+        input.y.toUpperCase();
 
       const params1: CreateToolParams = {
         toolFunction: toolFunction1,