@luanpoppe/ai 1.1.4 → 1.1.6

package/tests/unit/index.test.ts

@@ -20,7 +20,10 @@ vi.mock("../../src/langchain/models", () => ({
     gpt: vi.fn(),
     gemini: vi.fn(),
     openrouter: vi.fn(),
+    ollama: vi.fn(),
+    openaiCompatible: vi.fn(),
   },
+  DEFAULT_OLLAMA_BASE_URL: "http://127.0.0.1:11434",
 }));
 
 vi.mock("../../src/langchain/memory", async () => {
@@ -264,6 +267,77 @@ describe("AI", () => {
       ).rejects.toThrow("Model not supported");
     });
 
+    it("deve usar modelo Ollama quando aiModel começa com 'ollama/'", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const mockResponse = {
+        messages: [{ content: "Resposta local" } as any],
+      };
+
+      vi.mocked(AIModels.ollama).mockReturnValue(mockModel);
+      vi.mocked(createAgent).mockReturnValue({
+        invoke: vi.fn().mockResolvedValue(mockResponse),
+      } as any);
+
+      const localAi = new AI({ ollamaBaseUrl: "http://ollama:11434" });
+
+      await localAi.call({
+        aiModel: "ollama/llama3.2",
+        messages: mockMessages,
+      });
+
+      expect(AIModels.ollama).toHaveBeenCalledWith({
+        model: "llama3.2",
+        baseUrl: "http://ollama:11434",
+        maxTokens: undefined,
+        temperature: undefined,
+        numCtx: undefined,
+      });
+    });
+
+    it("deve usar modelo local OpenAI-compatible quando aiModel começa com 'local/'", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const mockResponse = {
+        messages: [{ content: "LM Studio" } as any],
+      };
+
+      vi.mocked(AIModels.openaiCompatible).mockReturnValue(mockModel);
+      vi.mocked(createAgent).mockReturnValue({
+        invoke: vi.fn().mockResolvedValue(mockResponse),
+      } as any);
+
+      const localAi = new AI({
+        localBaseUrl: "http://localhost:1234/v1",
+        localApiKey: "test-local-key",
+      });
+
+      await localAi.call({
+        aiModel: "local/qwen2.5-7b-instruct",
+        messages: mockMessages,
+        modelConfig: { temperature: 0.3 },
+      });
+
+      expect(AIModels.openaiCompatible).toHaveBeenCalledWith({
+        model: "qwen2.5-7b-instruct",
+        baseURL: "http://localhost:1234/v1",
+        apiKey: "test-local-key",
+        maxTokens: undefined,
+        temperature: 0.3,
+      });
+    });
+
+    it("deve lançar erro para local/* sem localBaseUrl", async () => {
+      const mockMessages = [AIMessages.human("Teste")];
+
+      await expect(
+        ai.call({
+          aiModel: "local/my-model",
+          messages: mockMessages,
+        }),
+      ).rejects.toThrow("localBaseUrl é obrigatório");
+    });
+
     it("deve passar modelConfig quando fornecido", async () => {
       const mockModel = {} as any;
       const mockMessages = [AIMessages.human("Teste")];
@@ -388,6 +462,106 @@ describe("AI", () => {
       warnSpy.mockRestore();
     });
 
+    it("deve aplicar provider only deepseek por padrão em openrouter/deepseek/*", async () => {
+      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/deepseek/deepseek-v3.2",
+        messages: mockMessages,
+      });
+
+      expect(AIModels.openrouter).toHaveBeenCalledWith(
+        expect.objectContaining({
+          model: "deepseek/deepseek-v3.2",
+          apiKey: "test-openrouter-key",
+          openRouterProvider: undefined,
+          openRouterAllowAllProviders: undefined,
+        }),
+      );
+    });
+
+    it("deve repassar openRouterProvider e openRouterAllowAllProviders no modelConfig", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const mockResponse = {
+        messages: [{ content: "Resposta" } as any],
+      };
+      const openRouterProvider = {
+        only: ["deepinfra"],
+        max_price: { prompt: 1, completion: 2 },
+      };
+
+      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/deepseek/deepseek-r1",
+        messages: mockMessages,
+        modelConfig: {
+          openRouterProvider,
+          openRouterAllowAllProviders: false,
+        },
+      });
+
+      expect(AIModels.openrouter).toHaveBeenCalledWith(
+        expect.objectContaining({
+          model: "deepseek/deepseek-r1",
+          openRouterProvider,
+          openRouterAllowAllProviders: false,
+        }),
+      );
+    });
+
+    it("deve repassar openRouterAllowAllProviders true para liberar todos os providers", async () => {
+      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/deepseek/deepseek-v3.2",
+        messages: mockMessages,
+        modelConfig: {
+          openRouterAllowAllProviders: true,
+        },
+      });
+
+      expect(AIModels.openrouter).toHaveBeenCalledWith(
+        expect.objectContaining({
+          openRouterAllowAllProviders: true,
+        }),
+      );
+    });
+
     it("deve lançar erro quando memory está ativo e threadId não é fornecido", async () => {
       const aiWithMemory = new AI({
         openAIApiKey: "test-key",
@@ -676,6 +850,41 @@ describe("AI", () => {
       expect(result.response).toEqual(mockStructuredResponse);
     });
 
+    it("deve usar json_object para DeepSeek sem responseFormat no agente", async () => {
+      const mockModel = {} as any;
+      const mockMessages = [AIMessages.human("Teste")];
+      const outputSchema = z.object({ sum: z.number(), product: z.number() });
+
+      vi.mocked(AIModels.openrouter).mockReturnValue(mockModel);
+      vi.mocked(createAgent).mockReturnValue({
+        invoke: vi.fn().mockResolvedValue({
+          messages: [{ content: '{"sum":11,"product":28}' }],
+        }),
+      } as any);
+
+      const aiWithOpenRouter = new AI({
+        openRouterApiKey: "test-openrouter-key",
+      });
+
+      const result = await aiWithOpenRouter.callStructuredOutput({
+        aiModel: "openrouter/deepseek/deepseek-v4-flash",
+        messages: mockMessages,
+        outputSchema,
+      });
+
+      expect(AIModels.openrouter).toHaveBeenCalledWith(
+        expect.objectContaining({
+          openRouterForceJsonObject: true,
+        }),
+      );
+      expect(createAgent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          responseFormat: undefined,
+        }),
+      );
+      expect(result.response).toEqual({ sum: 11, product: 28 });
+    });
+
     it("deve validar o schema e lançar erro se inválido", async () => {
       const mockModel = {} as any;
       const mockMessages = [AIMessages.human("Teste")];

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 });
+    });
+  });
+});