@luanpoppe/ai 1.1.5 → 1.1.6

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

@@ -1,6 +1,15 @@
 import { AIMessages } from "../../../src/langchain/messages";
 import { SystemMessage, HumanMessage, AIMessage } from "langchain";
 
+vi.mock("../../../src/audio", () => ({
+  AIAudio: {
+    transcribeWithWhisper: vi.fn().mockResolvedValue("texto whisper"),
+    transcribeOpenRouter: vi
+      .fn()
+      .mockResolvedValue({ text: "texto openrouter" }),
+  },
+}));
+
 // Mock do langchain
 vi.mock("langchain", () => {
   class MockSystemMessage {
@@ -174,6 +183,34 @@ describe("AIMessages", () => {
       const callArgs = (HumanMessage as any).mock.calls[0][0];
       expect(callArgs.content[0].mime_type).toBe("audio/mp4");
     });
+
+    it("provider openai usa STT prévio via AIAudio", async () => {
+      const { AIAudio } = await import("../../../src/audio");
+      const audioBuffer = Buffer.from("fake audio data");
+
+      const result = await AIMessages.humanAudio({
+        audio: { buffer: audioBuffer, mimeType: "audio/mp3" },
+        provider: "openai",
+        openAIApiKey: "sk-test",
+      });
+
+      expect(AIAudio.transcribeWithWhisper).toHaveBeenCalled();
+      expect(result.content).toContain("texto whisper");
+    });
+
+    it("provider openrouter usa transcribeOpenRouter", async () => {
+      const { AIAudio } = await import("../../../src/audio");
+      const audioBuffer = Buffer.from("fake audio data");
+
+      const result = await AIMessages.humanAudio({
+        audio: { buffer: audioBuffer, mimeType: "audio/mp3" },
+        provider: "openrouter",
+        openRouterApiKey: "or-test",
+      });
+
+      expect(AIAudio.transcribeOpenRouter).toHaveBeenCalled();
+      expect(result.content).toContain("texto openrouter");
+    });
   });
 
   describe("humanImage", () => {

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

@@ -1,6 +1,12 @@
-import { AIModels, LLMModelConfig } from "../../../src/langchain/models";
+import {
+  AIModels,
+  DEFAULT_OLLAMA_BASE_URL,
+  LLMModelConfig,
+  resolveOpenRouterProvider,
+} from "../../../src/langchain/models";
 import { ChatOpenAI } from "@langchain/openai";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
+import { ChatOllama } from "@langchain/ollama";
 
 // Mock das dependências
 vi.mock("@langchain/openai", () => ({
@@ -11,6 +17,10 @@ vi.mock("@langchain/google-genai", () => ({
   ChatGoogleGenerativeAI: vi.fn(),
 }));
 
+vi.mock("@langchain/ollama", () => ({
+  ChatOllama: vi.fn(),
+}));
+
 describe("AIModels", () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -205,4 +215,216 @@ describe("AIModels", () => {
       );
     });
   });
+
+  describe("resolveOpenRouterProvider", () => {
+    it("deve retornar only deepseek para modelos deepseek/ sem config", () => {
+      expect(
+        resolveOpenRouterProvider("deepseek/deepseek-v3.2", {}),
+      ).toEqual({ only: ["deepseek"] });
+    });
+
+    it("não deve aplicar default para modelos que não são deepseek/", () => {
+      expect(
+        resolveOpenRouterProvider("openai/gpt-5-nano", {}),
+      ).toBeUndefined();
+    });
+
+    it("deve retornar undefined quando openRouterAllowAllProviders é true", () => {
+      expect(
+        resolveOpenRouterProvider("deepseek/deepseek-v3.2", {
+          openRouterAllowAllProviders: true,
+        }),
+      ).toBeUndefined();
+    });
+
+    it("deve usar openRouterProvider explícito em vez do default", () => {
+      const custom = { only: ["deepinfra"] };
+      expect(
+        resolveOpenRouterProvider("deepseek/deepseek-r1", {
+          openRouterProvider: custom,
+        }),
+      ).toEqual(custom);
+    });
+  });
+
+  describe("openrouter", () => {
+    it("deve criar ChatOpenAI com configurações básicas", () => {
+      const config: LLMModelConfig = {
+        model: "openai/gpt-5-nano",
+        apiKey: "test-openrouter-key",
+      };
+
+      AIModels.openrouter(config);
+
+      expect(ChatOpenAI).toHaveBeenCalledWith({
+        model: "openai/gpt-5-nano",
+        apiKey: "test-openrouter-key",
+        configuration: {
+          baseURL: "https://openrouter.ai/api/v1",
+        },
+      });
+    });
+
+    it("deve aplicar provider only deepseek por padrão em modelos deepseek/", () => {
+      const config: LLMModelConfig = {
+        model: "deepseek/deepseek-v3.2",
+        apiKey: "test-openrouter-key",
+      };
+
+      AIModels.openrouter(config);
+
+      expect(ChatOpenAI).toHaveBeenCalledWith(
+        expect.objectContaining({
+          modelKwargs: { provider: { only: ["deepseek"] } },
+        }),
+      );
+    });
+
+    it("não deve enviar provider em modelos não-deepseek", () => {
+      const config: LLMModelConfig = {
+        model: "openai/gpt-5-nano",
+        apiKey: "test-openrouter-key",
+      };
+
+      AIModels.openrouter(config);
+
+      expect(ChatOpenAI).toHaveBeenCalledWith(
+        expect.not.objectContaining({
+          modelKwargs: expect.anything(),
+        }),
+      );
+    });
+
+    it("não deve aplicar default deepseek quando openRouterAllowAllProviders é true", () => {
+      const config: LLMModelConfig = {
+        model: "deepseek/deepseek-v3.2",
+        apiKey: "test-openrouter-key",
+        openRouterAllowAllProviders: true,
+      };
+
+      AIModels.openrouter(config);
+
+      expect(ChatOpenAI).toHaveBeenCalledWith(
+        expect.not.objectContaining({
+          modelKwargs: expect.anything(),
+        }),
+      );
+    });
+
+    it("deve enviar openRouterProvider customizado", () => {
+      const provider = {
+        only: ["deepinfra", "fireworks"],
+        max_price: { prompt: 0.5, completion: 1 },
+        sort: "price" as const,
+      };
+
+      AIModels.openrouter({
+        model: "deepseek/deepseek-r1",
+        apiKey: "test-openrouter-key",
+        openRouterProvider: provider,
+      });
+
+      expect(ChatOpenAI).toHaveBeenCalledWith(
+        expect.objectContaining({
+          modelKwargs: { provider },
+        }),
+      );
+    });
+
+    it("deve mesclar provider com reasoningEffort", () => {
+      AIModels.openrouter({
+        model: "deepseek/deepseek-r1",
+        apiKey: "test-openrouter-key",
+        reasoningEffort: "high",
+        openRouterProvider: { only: ["deepseek"] },
+      });
+
+      expect(ChatOpenAI).toHaveBeenCalledWith(
+        expect.objectContaining({
+          modelKwargs: {
+            reasoning_effort: "high",
+            provider: { only: ["deepseek"] },
+          },
+        }),
+      );
+    });
+
+    it("deve lançar erro quando apiKey não é fornecida", () => {
+      expect(() =>
+        AIModels.openrouter({ model: "openai/gpt-5-nano" }),
+      ).toThrow("OpenRouter API key is not passed in the model parameters");
+    });
+  });
+
+  describe("ollama", () => {
+    it("deve criar ChatOllama com configurações básicas e baseUrl padrão", () => {
+      AIModels.ollama({ model: "llama3.2" });
+
+      expect(ChatOllama).toHaveBeenCalledWith({
+        model: "llama3.2",
+        baseUrl: DEFAULT_OLLAMA_BASE_URL,
+      });
+    });
+
+    it("deve criar ChatOllama com baseUrl, temperature e numCtx customizados", () => {
+      AIModels.ollama({
+        model: "qwen2.5:7b",
+        baseUrl: "http://custom:11434",
+        temperature: 0.2,
+        numCtx: 8192,
+        maxTokens: 512,
+      });
+
+      expect(ChatOllama).toHaveBeenCalledWith({
+        model: "qwen2.5:7b",
+        baseUrl: "http://custom:11434",
+        temperature: 0.2,
+        numCtx: 8192,
+        numPredict: 512,
+      });
+    });
+  });
+
+  describe("openaiCompatible", () => {
+    it("deve criar ChatOpenAI com baseURL local", () => {
+      AIModels.openaiCompatible({
+        model: "meta-llama/Llama-3.2-3B-Instruct",
+        baseURL: "http://localhost:1234/v1",
+      });
+
+      expect(ChatOpenAI).toHaveBeenCalledWith({
+        model: "meta-llama/Llama-3.2-3B-Instruct",
+        apiKey: "not-needed",
+        configuration: {
+          baseURL: "http://localhost:1234/v1",
+        },
+      });
+    });
+
+    it("deve aceitar apiKey e parâmetros opcionais", () => {
+      AIModels.openaiCompatible({
+        model: "my-model",
+        baseURL: "http://127.0.0.1:11434/v1",
+        apiKey: "lm-studio",
+        maxTokens: 1000,
+        temperature: 0.5,
+      });
+
+      expect(ChatOpenAI).toHaveBeenCalledWith({
+        model: "my-model",
+        apiKey: "lm-studio",
+        maxTokens: 1000,
+        temperature: 0.5,
+        configuration: {
+          baseURL: "http://127.0.0.1:11434/v1",
+        },
+      });
+    });
+
+    it("deve lançar erro quando baseURL não é fornecida", () => {
+      expect(() =>
+        AIModels.openaiCompatible({ model: "x", baseURL: "" }),
+      ).toThrow("baseURL é obrigatório");
+    });
+  });
 });

package/tests/unit/langchain/structured-output.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import z from "zod";
+import {
+  buildJsonObjectSystemAppend,
+  isDeepSeekJsonObjectOnlyModel,
+  parseJsonFromAssistantMessages,
+} from "../../../src/langchain/structured-output";
+
+describe("structured-output", () => {
+  describe("isDeepSeekJsonObjectOnlyModel", () => {
+    it("deve detectar openrouter/deepseek/*", () => {
+      expect(
+        isDeepSeekJsonObjectOnlyModel("openrouter/deepseek/deepseek-v4-pro"),
+      ).toBe(true);
+    });
+
+    it("não deve detectar openrouter/openai/*", () => {
+      expect(
+        isDeepSeekJsonObjectOnlyModel("openrouter/openai/gpt-5-nano"),
+      ).toBe(false);
+    });
+  });
+
+  describe("buildJsonObjectSystemAppend", () => {
+    it("deve incluir a palavra json e o schema", () => {
+      const append = buildJsonObjectSystemAppend(
+        z.object({ name: z.string() }),
+      );
+      expect(append.toLowerCase()).toContain("json");
+      expect(append).toContain("name");
+    });
+  });
+
+  describe("parseJsonFromAssistantMessages", () => {
+    it("deve parsear JSON direto", () => {
+      const result = parseJsonFromAssistantMessages([
+        { content: '{"a":1}' } as any,
+      ]);
+      expect(result).toEqual({ a: 1 });
+    });
+
+    it("deve parsear JSON em fence markdown", () => {
+      const result = parseJsonFromAssistantMessages([
+        { content: '```json\n{"b":2}\n```' } as any,
+      ]);
+      expect(result).toEqual({ b: 2 });
+    });
+  });
+});