@luanpoppe/ai 1.1.2 → 1.1.4

package/tests/unit/index.test.ts

@@ -2,7 +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 { AIMemory } from "../../src/langchain/memory";
 import z from "zod";
 
 // Mock das dependências
@@ -23,8 +23,8 @@ vi.mock("../../src/langchain/models", () => ({
   },
 }));
 
-vi.mock("../../src/langchain/checkpointers", async () => {
-  const actual = await vi.importActual("../../src/langchain/checkpointers");
+vi.mock("../../src/langchain/memory", async () => {
+  const actual = await vi.importActual("../../src/langchain/memory");
   return {
     ...actual,
     AIMemory: vi.fn().mockImplementation(function () {
@@ -293,6 +293,101 @@ describe("AI", () => {
       });
     });
 
+    it("deve passar reasoningEffort no modelConfig", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const mockResponse = {
+        messages: [{ content: "Resposta" } as any],
+      };
+
+      vi.mocked(AIModels.gpt).mockReturnValue(mockModel);
+      vi.mocked(createAgent).mockReturnValue({
+        invoke: vi.fn().mockResolvedValue(mockResponse),
+      } as any);
+
+      await ai.call({
+        aiModel: "gpt-5-nano",
+        messages: mockMessages,
+        modelConfig: {
+          reasoningEffort: "medium",
+        },
+      });
+
+      expect(AIModels.gpt).toHaveBeenCalledWith({
+        model: "gpt-5-nano",
+        apiKey: mockTokens.openAIApiKey,
+        reasoningEffort: "medium",
+      });
+    });
+
+    it("deve exibir warning quando reasoningEffort é passado com modelo Gemini", async () => {
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const mockResponse = {
+        messages: [{ content: "Resposta" } as any],
+      };
+
+      vi.mocked(AIModels.gemini).mockReturnValue(mockModel);
+      vi.mocked(createAgent).mockReturnValue({
+        invoke: vi.fn().mockResolvedValue(mockResponse),
+      } as any);
+
+      const aiWithGemini = new AI({
+        openAIApiKey: "test-key",
+        googleGeminiToken: "test-gemini-token",
+      });
+
+      await aiWithGemini.call({
+        aiModel: "gemini-2.5-flash",
+        messages: mockMessages,
+        modelConfig: {
+          reasoningEffort: "high",
+        },
+      });
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('O modelo "gemini-2.5-flash" não suporta reasoningEffort'),
+      );
+      expect(AIModels.gemini).toHaveBeenCalledWith(
+        expect.not.objectContaining({ reasoningEffort: expect.anything() }),
+      );
+      warnSpy.mockRestore();
+    });
+
+    it("deve exibir warning quando reasoningEffort é passado com OpenRouter não-OpenAI", async () => {
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const mockResponse = {
+        messages: [{ content: "Resposta" } as any],
+      };
+
+      vi.mocked(AIModels.openrouter).mockReturnValue(mockModel);
+      vi.mocked(createAgent).mockReturnValue({
+        invoke: vi.fn().mockResolvedValue(mockResponse),
+      } as any);
+
+      const aiWithOpenRouter = new AI({
+        openRouterApiKey: "test-openrouter-key",
+      });
+
+      await aiWithOpenRouter.call({
+        aiModel: "openrouter/google/gemini-2.5-flash",
+        messages: mockMessages,
+        modelConfig: {
+          reasoningEffort: "high",
+        },
+      });
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          'O modelo "openrouter/google/gemini-2.5-flash" não suporta reasoningEffort',
+        ),
+      );
+      warnSpy.mockRestore();
+    });
+
     it("deve lançar erro quando memory está ativo e threadId não é fornecido", async () => {
       const aiWithMemory = new AI({
         openAIApiKey: "test-key",

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

@@ -1,4 +1,4 @@
-import { AIMemory } from "../../../src/langchain/checkpointers";
+import { AIMemory } from "../../../src/langchain/memory";
 import { MemorySaver } from "@langchain/langgraph";
 import { describe, it, expect, vi } from "vitest";
 
@@ -97,11 +97,54 @@ describe("AIMemory", () => {
       });
     });
 
-    it("deve lançar erro quando graph não é passado e agent não foi definido", async () => {
+    it("deve usar checkpointer.list quando graph e agent não estão disponíveis", async () => {
       const memory = new AIMemory({ type: "memory" });
-      await expect(memory.getHistory("1")).rejects.toThrow(
-        "É necessário passar graph em getHistory ou definir o agent"
-      );
+      const mockTuple1 = {
+        checkpoint: {
+          channel_values: { messages: [{ role: "user", content: "oi" }] },
+          ts: "2024-01-01T10:00:00Z",
+        },
+        config: { configurable: { thread_id: "1" } },
+        metadata: {},
+      };
+      const mockTuple2 = {
+        checkpoint: {
+          channel_values: {
+            messages: [
+              { role: "user", content: "oi" },
+              { role: "assistant", content: "olá" },
+            ],
+          },
+          ts: "2024-01-01T10:01:00Z",
+        },
+        config: { configurable: { thread_id: "1" } },
+        metadata: {},
+      };
+      const mockList = vi.fn(async function* () {
+        yield mockTuple2;
+        yield mockTuple1;
+      });
+      vi.spyOn(memory, "getCheckpointer").mockResolvedValue({
+        list: mockList,
+      } as any);
+
+      const result = await memory.getHistory("1");
+
+      expect(result.fullHistory).toHaveLength(2);
+      expect(result.fullHistory[0].values).toEqual(mockTuple2.checkpoint.channel_values);
+      expect(result.fullHistory[1].values).toEqual(mockTuple1.checkpoint.channel_values);
+      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(mockList).toHaveBeenCalledWith({ configurable: { thread_id: "1" } });
     });
   });
 
@@ -143,5 +186,29 @@ describe("AIMemory", () => {
       const state = await memory.getState("1", mockGraph as any);
       expect(state).toEqual(mockState);
     });
+
+    it("deve usar checkpointer quando graph não está disponível", async () => {
+      const memory = new AIMemory({ type: "memory" });
+      const mockTuple = {
+        checkpoint: {
+          channel_values: { messages: [{ role: "user", content: "oi" }] },
+          ts: "2024-01-01T10:00:00Z",
+        },
+        config: { configurable: { thread_id: "1" } },
+        metadata: {},
+      };
+      const mockList = vi.fn(async function* () {
+        yield mockTuple;
+      });
+      vi.spyOn(memory, "getCheckpointer").mockResolvedValue({
+        list: mockList,
+      } as any);
+
+      const state = await memory.getState("1");
+
+      expect(state).not.toBeNull();
+      expect(state?.values).toEqual({ messages: [{ role: "user", content: "oi" }] });
+      expect(mockList).toHaveBeenCalledWith({ configurable: { thread_id: "1" } });
+    });
   });
 });

package/tests/unit/langchain/image-utils.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect } from "vitest";
+import { ImageUtils } from "../../../src/utils/image-utils";
+
+describe("ImageUtils", () => {
+  describe("bufferToBase64", () => {
+    it("deve converter Buffer para base64", () => {
+      const buffer = Buffer.from("test data");
+      const result = ImageUtils.bufferToBase64(buffer);
+      expect(result).toBe("dGVzdCBkYXRh");
+    });
+
+    it("deve converter ArrayBuffer para base64", () => {
+      const arrayBuffer = new TextEncoder().encode("test data").buffer;
+      const result = ImageUtils.bufferToBase64(arrayBuffer);
+      expect(result).toBe("dGVzdCBkYXRh");
+    });
+
+    it("deve converter Uint8Array para base64", () => {
+      const uint8Array = new TextEncoder().encode("test data");
+      const result = ImageUtils.bufferToBase64(uint8Array);
+      expect(result).toBe("dGVzdCBkYXRh");
+    });
+
+    it("deve lançar erro para tipo não suportado", () => {
+      expect(() => {
+        ImageUtils.bufferToBase64("invalid" as any);
+      }).toThrow("Tipo de buffer não suportado");
+    });
+  });
+
+  describe("detectMimeTypeFromExtension", () => {
+    it("deve detectar JPEG pela extensão", () => {
+      expect(ImageUtils.detectMimeTypeFromExtension("imagem.jpg")).toBe(
+        "image/jpeg"
+      );
+      expect(ImageUtils.detectMimeTypeFromExtension("foto.jpeg")).toBe(
+        "image/jpeg"
+      );
+      expect(ImageUtils.detectMimeTypeFromExtension("foto.JPG")).toBe(
+        "image/jpeg"
+      );
+    });
+
+    it("deve detectar PNG pela extensão", () => {
+      expect(ImageUtils.detectMimeTypeFromExtension("imagem.png")).toBe(
+        "image/png"
+      );
+    });
+
+    it("deve detectar GIF pela extensão", () => {
+      expect(ImageUtils.detectMimeTypeFromExtension("animacao.gif")).toBe(
+        "image/gif"
+      );
+    });
+
+    it("deve detectar WebP pela extensão", () => {
+      expect(ImageUtils.detectMimeTypeFromExtension("foto.webp")).toBe(
+        "image/webp"
+      );
+    });
+
+    it("deve retornar null para extensão desconhecida", () => {
+      expect(
+        ImageUtils.detectMimeTypeFromExtension("arquivo.unknown")
+      ).toBeNull();
+    });
+
+    it("deve retornar null quando filename não é fornecido", () => {
+      expect(ImageUtils.detectMimeTypeFromExtension(undefined)).toBeNull();
+    });
+  });
+
+  describe("detectMimeTypeFromBuffer", () => {
+    it("deve detectar JPEG pelos magic bytes", () => {
+      const buffer = Buffer.from([0xff, 0xd8, 0xff, 0x00, 0x00]);
+      expect(ImageUtils.detectMimeTypeFromBuffer(buffer)).toBe("image/jpeg");
+    });
+
+    it("deve detectar PNG pelos magic bytes", () => {
+      const buffer = Buffer.from([
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00,
+      ]);
+      expect(ImageUtils.detectMimeTypeFromBuffer(buffer)).toBe("image/png");
+    });
+
+    it("deve detectar GIF pelos magic bytes", () => {
+      const buffer = Buffer.from([0x47, 0x49, 0x46, 0x38, 0x00, 0x00]);
+      expect(ImageUtils.detectMimeTypeFromBuffer(buffer)).toBe("image/gif");
+    });
+
+    it("deve detectar WebP pelos magic bytes", () => {
+      const buffer = Buffer.from([
+        0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00, 0x57, 0x45, 0x42, 0x50,
+      ]);
+      expect(ImageUtils.detectMimeTypeFromBuffer(buffer)).toBe("image/webp");
+    });
+
+    it("deve retornar null para buffer desconhecido", () => {
+      const buffer = Buffer.from([0x00, 0x00, 0x00, 0x00]);
+      expect(ImageUtils.detectMimeTypeFromBuffer(buffer)).toBeNull();
+    });
+  });
+
+  describe("detectImageMimeType", () => {
+    it("deve priorizar extensão sobre magic bytes", () => {
+      const buffer = Buffer.from([0xff, 0xd8, 0xff]); // Magic bytes de JPEG
+      const result = ImageUtils.detectImageMimeType(buffer, "imagem.png");
+      expect(result).toBe("image/png");
+    });
+
+    it("deve usar magic bytes quando extensão não está disponível", () => {
+      const buffer = Buffer.from([
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00,
+      ]);
+      const result = ImageUtils.detectImageMimeType(buffer);
+      expect(result).toBe("image/png");
+    });
+
+    it("deve usar fallback para JPEG quando não consegue detectar", () => {
+      const buffer = Buffer.from([0x00, 0x00, 0x00, 0x00]);
+      const result = ImageUtils.detectImageMimeType(buffer);
+      expect(result).toBe("image/jpeg");
+    });
+  });
+});

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

@@ -175,4 +175,82 @@ describe("AIMessages", () => {
       expect(callArgs.content[0].mime_type).toBe("audio/mp4");
     });
   });
+
+  describe("humanImage", () => {
+    it("deve criar uma HumanMessage com conteúdo de imagem e texto", () => {
+      const imageBuffer = Buffer.from("fake image data");
+      const text = "Descreva esta imagem";
+
+      const result = AIMessages.humanImage({
+        image: {
+          buffer: imageBuffer,
+          filename: "imagem.jpg",
+        },
+        text,
+      });
+
+      expect(result).toBeDefined();
+      expect(HumanMessage).toHaveBeenCalled();
+      const callArgs = (HumanMessage as any).mock.calls[0][0];
+      expect(callArgs.content).toBeInstanceOf(Array);
+      expect(callArgs.content.length).toBe(2);
+      expect(callArgs.content[0].type).toBe("text");
+      expect(callArgs.content[0].text).toBe(text);
+      expect(callArgs.content[1].type).toBe("image");
+      expect(callArgs.content[1].source_type).toBe("base64");
+      expect(callArgs.content[1].mime_type).toBe("image/jpeg");
+      expect(callArgs.content[1].data).toBeDefined();
+    });
+
+    it("deve criar uma HumanMessage apenas com imagem (sem texto)", () => {
+      const imageBuffer = Buffer.from("fake image data");
+
+      const result = AIMessages.humanImage({
+        image: {
+          buffer: imageBuffer,
+          filename: "imagem.png",
+        },
+      });
+
+      expect(result).toBeDefined();
+      expect(HumanMessage).toHaveBeenCalled();
+      const callArgs = (HumanMessage as any).mock.calls[0][0];
+      expect(callArgs.content).toBeInstanceOf(Array);
+      expect(callArgs.content.length).toBe(1);
+      expect(callArgs.content[0].type).toBe("image");
+      expect(callArgs.content[0].source_type).toBe("base64");
+      expect(callArgs.content[0].mime_type).toBe("image/png");
+    });
+
+    it("deve detectar MIME type automaticamente pela extensão", () => {
+      const imageBuffer = Buffer.from("fake image data");
+
+      const result = AIMessages.humanImage({
+        image: {
+          buffer: imageBuffer,
+          filename: "foto.webp",
+        },
+      });
+
+      expect(result).toBeDefined();
+      const callArgs = (HumanMessage as any).mock.calls[0][0];
+      expect(callArgs.content[0].mime_type).toBe("image/webp");
+    });
+
+    it("deve usar MIME type fornecido mesmo com extensão", () => {
+      const imageBuffer = Buffer.from("fake image data");
+
+      const result = AIMessages.humanImage({
+        image: {
+          buffer: imageBuffer,
+          mimeType: "image/png",
+          filename: "imagem.jpg",
+        },
+      });
+
+      expect(result).toBeDefined();
+      const callArgs = (HumanMessage as any).mock.calls[0][0];
+      expect(callArgs.content[0].mime_type).toBe("image/png");
+    });
+  });
 });

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

@@ -101,6 +101,22 @@ describe("AIModels", () => {
         "OpenAI API key is not passed in the model parameters"
       );
     });
+
+    it("deve criar uma instância do ChatOpenAI com reasoningEffort", () => {
+      const config: LLMModelConfig = {
+        model: "gpt-5-nano",
+        apiKey: "test-api-key",
+        reasoningEffort: "high",
+      };
+
+      AIModels.gpt(config);
+
+      expect(ChatOpenAI).toHaveBeenCalledWith({
+        model: "gpt-5-nano",
+        apiKey: "test-api-key",
+        modelKwargs: { reasoning_effort: "high" },
+      });
+    });
   });
 
   describe("gemini", () => {