@luanpoppe/ai 1.1.5 → 1.1.6

package/tests/unit/audio/transcription-openai.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  transcribeDetailedOpenAI,
+  transcribeToSrtOpenAI,
+  transcribeToVttOpenAI,
+  transcribeDiarizedOpenAI,
+  translateOpenAI,
+  transcribeWithWhisperOpenAI,
+} from "../../../src/audio/transcription-openai.js";
+
+const mockTranscriptionsCreate = vi.fn();
+const mockTranslationsCreate = vi.fn();
+
+vi.mock("openai", () => ({
+  default: class MockOpenAI {
+    audio = {
+      transcriptions: { create: mockTranscriptionsCreate },
+      translations: { create: mockTranslationsCreate },
+    };
+  },
+  toFile: async (buffer: Buffer, filename: string) =>
+    new File([new Uint8Array(buffer)], filename, { type: "audio/mpeg" }),
+}));
+
+describe("transcription-openai", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("transcribeDetailedOpenAI mapeia verbose_json com words", async () => {
+    mockTranscriptionsCreate.mockResolvedValue({
+      text: "olá",
+      language: "pt",
+      duration: 1.2,
+      words: [{ word: "olá", start: 0, end: 0.5 }],
+      segments: [{ id: 0, start: 0, end: 0.5, text: "olá" }],
+    });
+
+    const result = await transcribeDetailedOpenAI(
+      Buffer.from("audio"),
+      {
+        model: "whisper-1",
+        responseFormat: "verbose_json",
+        timestampGranularities: ["word"],
+      },
+      "sk-test",
+    );
+
+    expect(result.text).toBe("olá");
+    expect(result.words).toHaveLength(1);
+    expect(result.segments).toHaveLength(1);
+  });
+
+  it("transcribeToSrtOpenAI usa response_format srt", async () => {
+    mockTranscriptionsCreate.mockResolvedValue("1\n00:00:00,000 --> 00:00:01,000\nolá");
+
+    const srt = await transcribeToSrtOpenAI(
+      Buffer.from("audio"),
+      { languageIn2Digits: "pt" },
+      "sk-test",
+    );
+
+    expect(srt).toContain("olá");
+    expect(mockTranscriptionsCreate).toHaveBeenCalledWith(
+      expect.objectContaining({ response_format: "srt", model: "whisper-1" }),
+    );
+  });
+
+  it("transcribeToVttOpenAI usa response_format vtt", async () => {
+    mockTranscriptionsCreate.mockResolvedValue("WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nolá");
+
+    const vtt = await transcribeToVttOpenAI(Buffer.from("audio"), {}, "sk-test");
+
+    expect(vtt).toContain("WEBVTT");
+    expect(mockTranscriptionsCreate).toHaveBeenCalledWith(
+      expect.objectContaining({ response_format: "vtt" }),
+    );
+  });
+
+  it("transcribeDiarizedOpenAI mapeia speakers", async () => {
+    mockTranscriptionsCreate.mockResolvedValue({
+      text: "fala a fala b",
+      segments: [
+        { speaker: "A", start: 0, end: 1, text: "fala a" },
+        { speaker: "B", start: 1, end: 2, text: "fala b" },
+      ],
+    });
+
+    const result = await transcribeDiarizedOpenAI(Buffer.from("audio"), {}, "sk-test");
+
+    expect(result.speakers).toHaveLength(2);
+    expect(result.speakers?.[0].speaker).toBe("A");
+    expect(mockTranscriptionsCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        model: "gpt-4o-transcribe-diarize",
+        response_format: "diarized_json",
+      }),
+    );
+  });
+
+  it("translateOpenAI chama translations.create", async () => {
+    mockTranslationsCreate.mockResolvedValue({ text: "hello" });
+
+    const text = await translateOpenAI(Buffer.from("audio"), {}, "sk-test");
+
+    expect(text).toBe("hello");
+    expect(mockTranslationsCreate).toHaveBeenCalled();
+  });
+
+  it("rejeita timestampGranularities fora de whisper-1 verbose_json", async () => {
+    await expect(
+      transcribeDetailedOpenAI(Buffer.from("x"), {
+        model: "gpt-4o-transcribe",
+        responseFormat: "json",
+        timestampGranularities: ["word"],
+      }),
+    ).rejects.toThrow("timestampGranularities");
+  });
+
+  it("transcribeWithWhisperOpenAI retorna string", async () => {
+    mockTranscriptionsCreate.mockResolvedValue("texto simples");
+
+    const text = await transcribeWithWhisperOpenAI(Buffer.from("audio"), {}, "sk-test");
+
+    expect(text).toBe("texto simples");
+    expect(mockTranscriptionsCreate).toHaveBeenCalledWith(
+      expect.objectContaining({ response_format: "text" }),
+    );
+  });
+});

package/tests/unit/audio/transcription-openrouter.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { transcribeOpenRouter } from "../../../src/audio/transcription-openrouter.js";
+
+const mockFetch = vi.fn();
+
+vi.stubGlobal("fetch", mockFetch);
+
+describe("transcription-openrouter", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        text: "transcrito via OR",
+        usage: { seconds: 2, cost: 0.001 },
+      }),
+    });
+  });
+
+  it("envia input_audio base64 e model", async () => {
+    const buf = Buffer.from("fake-audio");
+    const result = await transcribeOpenRouter(
+      buf,
+      { model: "openai/whisper-1", format: "mp3", language: "pt" },
+      "or-key",
+    );
+
+    expect(result.text).toBe("transcrito via OR");
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://openrouter.ai/api/v1/audio/transcriptions",
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          Authorization: "Bearer or-key",
+        }),
+      }),
+    );
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0][1] as RequestInit).body as string,
+    );
+    expect(body.model).toBe("openai/whisper-1");
+    expect(body.input_audio.format).toBe("mp3");
+    expect(body.input_audio.data).toBe(buf.toString("base64"));
+    expect(body.language).toBe("pt");
+  });
+
+  it("aplica provider default deepseek para modelos deepseek", async () => {
+    await transcribeOpenRouter(
+      Buffer.from("x"),
+      { model: "deepseek/some-stt" },
+      "or-key",
+    );
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0][1] as RequestInit).body as string,
+    );
+    expect(body.provider).toEqual({ only: ["deepseek"] });
+  });
+
+  it("exige openRouterApiKey", async () => {
+    await expect(
+      transcribeOpenRouter(Buffer.from("x"), { model: "openai/whisper-1" }),
+    ).rejects.toThrow("OpenRouter API key");
+  });
+
+  it("propaga erro HTTP", async () => {
+    mockFetch.mockResolvedValue({
+      ok: false,
+      status: 400,
+      text: async () => "bad request",
+    });
+
+    await expect(
+      transcribeOpenRouter(
+        Buffer.from("x"),
+        { model: "openai/whisper-1" },
+        "or-key",
+      ),
+    ).rejects.toThrow("OpenRouter STT falhou");
+  });
+});

package/tests/unit/embeddings/embed-gemini.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { embedGemini } from "../../../src/embeddings/embed-gemini.js";
+
+const mockEmbedQuery = vi.fn();
+const mockEmbedDocuments = vi.fn();
+
+vi.mock("@langchain/google-genai", () => ({
+  GoogleGenerativeAIEmbeddings: class MockGoogleGenerativeAIEmbeddings {
+    constructor(public params: Record<string, unknown>) {}
+    embedQuery = mockEmbedQuery;
+    embedDocuments = mockEmbedDocuments;
+  },
+}));
+
+describe("embed-gemini", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEmbedQuery.mockResolvedValue([0.5, 0.6]);
+    mockEmbedDocuments.mockResolvedValue([
+      [0.1, 0.2],
+      [0.3, 0.4],
+    ]);
+  });
+
+  it("embedQuery para input único", async () => {
+    const result = await embedGemini(
+      "hello",
+      { model: "gemini-embedding-001" },
+      "gemini-key",
+    );
+
+    expect(result.embeddings).toEqual([[0.5, 0.6]]);
+    expect(mockEmbedQuery).toHaveBeenCalledWith("hello");
+  });
+
+  it("embedDocuments para lote", async () => {
+    const result = await embedGemini(
+      ["a", "b"],
+      { model: "gemini-embedding-001", taskType: "RETRIEVAL_DOCUMENT" },
+      "gemini-key",
+    );
+
+    expect(result.embeddings).toHaveLength(2);
+    expect(mockEmbedDocuments).toHaveBeenCalledWith(["a", "b"]);
+  });
+
+  it("exige googleGeminiToken", async () => {
+    await expect(
+      embedGemini("x", { model: "gemini-embedding-001" }),
+    ).rejects.toThrow("googleGeminiToken");
+  });
+});

package/tests/unit/embeddings/embed-openai.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { embedOpenAI } from "../../../src/embeddings/embed-openai.js";
+
+const mockEmbeddingsCreate = vi.fn();
+
+vi.mock("openai", () => ({
+  default: class MockOpenAI {
+    embeddings = { create: mockEmbeddingsCreate };
+  },
+}));
+
+describe("embed-openai", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEmbeddingsCreate.mockResolvedValue({
+      model: "text-embedding-3-small",
+      data: [
+        { index: 0, embedding: [0.1, 0.2] },
+        { index: 1, embedding: [0.3, 0.4] },
+      ],
+      usage: { prompt_tokens: 10, total_tokens: 10 },
+    });
+  });
+
+  it("cria embeddings para string única", async () => {
+    mockEmbeddingsCreate.mockResolvedValueOnce({
+      model: "text-embedding-3-small",
+      data: [{ index: 0, embedding: [0.1, 0.2] }],
+      usage: { prompt_tokens: 5, total_tokens: 5 },
+    });
+
+    const result = await embedOpenAI(
+      "hello",
+      { model: "text-embedding-3-small" },
+      "sk-test",
+    );
+
+    expect(result.embeddings).toEqual([[0.1, 0.2]]);
+    expect(mockEmbeddingsCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        model: "text-embedding-3-small",
+        input: "hello",
+      }),
+    );
+  });
+
+  it("cria embeddings em lote", async () => {
+    const result = await embedOpenAI(
+      ["a", "b"],
+      { model: "text-embedding-3-large", dimensions: 256 },
+      "sk-test",
+    );
+
+    expect(result.embeddings).toHaveLength(2);
+    expect(mockEmbeddingsCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        input: ["a", "b"],
+        dimensions: 256,
+      }),
+    );
+  });
+
+  it("exige API key", async () => {
+    await expect(
+      embedOpenAI("x", { model: "text-embedding-3-small" }),
+    ).rejects.toThrow("OpenAI API key");
+  });
+});

package/tests/unit/embeddings/embed-openrouter.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { embedOpenRouter } from "../../../src/embeddings/embed-openrouter.js";
+
+const mockEmbeddingsCreate = vi.fn();
+
+vi.mock("../../../src/utils/openrouter-client.js", () => ({
+  createOpenRouterOpenAIClient: () => ({
+    embeddings: { create: mockEmbeddingsCreate },
+  }),
+}));
+
+describe("embed-openrouter", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEmbeddingsCreate.mockResolvedValue({
+      model: "openai/text-embedding-3-small",
+      data: [{ index: 0, embedding: [1, 2, 3] }],
+      usage: { prompt_tokens: 5, total_tokens: 5 },
+    });
+  });
+
+  it("remove prefixo openrouter/ do model", async () => {
+    const result = await embedOpenRouter(
+      "test",
+      { model: "openrouter/openai/text-embedding-3-small" },
+      "or-key",
+    );
+
+    expect(result.embeddings[0]).toEqual([1, 2, 3]);
+    expect(mockEmbeddingsCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        model: "openai/text-embedding-3-small",
+        input: "test",
+      }),
+    );
+  });
+
+  it("repassa provider quando informado", async () => {
+    await embedOpenRouter(
+      "test",
+      {
+        model: "openrouter/openai/text-embedding-3-small",
+        openRouterProvider: { sort: "price" },
+      },
+      "or-key",
+    );
+
+    expect(mockEmbeddingsCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        provider: { sort: "price" },
+      }),
+    );
+  });
+
+  it("exige openRouterApiKey", async () => {
+    await expect(
+      embedOpenRouter("x", {
+        model: "openrouter/openai/text-embedding-3-small",
+      }),
+    ).rejects.toThrow("OpenRouter API key");
+  });
+});

package/tests/unit/embeddings/index.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  AIEmbeddings,
+  ANTHROPIC_NO_NATIVE_EMBEDDINGS,
+} from "../../../src/index.js";
+
+vi.mock("../../../src/embeddings/embed-openai.js", () => ({
+  embedOpenAI: vi.fn().mockResolvedValue({
+    embeddings: [[1]],
+    model: "text-embedding-3-small",
+  }),
+}));
+
+vi.mock("../../../src/embeddings/embed-openrouter.js", () => ({
+  embedOpenRouter: vi.fn().mockResolvedValue({
+    embeddings: [[2]],
+    model: "openai/text-embedding-3-small",
+  }),
+}));
+
+vi.mock("../../../src/embeddings/embed-gemini.js", () => ({
+  embedGemini: vi.fn().mockResolvedValue({
+    embeddings: [[3]],
+    model: "gemini-embedding-001",
+  }),
+}));
+
+describe("AIEmbeddings facade", () => {
+  it("expõe métodos estáticos", () => {
+    expect(typeof AIEmbeddings.embedOpenAI).toBe("function");
+    expect(typeof AIEmbeddings.embedOpenRouter).toBe("function");
+    expect(typeof AIEmbeddings.embedGemini).toBe("function");
+    expect(typeof AIEmbeddings.embedDocuments).toBe("function");
+    expect(typeof AIEmbeddings.embedQuery).toBe("function");
+  });
+
+  it("exporta constante Anthropic", () => {
+    expect(ANTHROPIC_NO_NATIVE_EMBEDDINGS).toContain("Anthropic");
+  });
+
+  it("embedQuery roteia por prefixo openrouter/", async () => {
+    const { embedOpenRouter } = await import(
+      "../../../src/embeddings/embed-openrouter.js"
+    );
+
+    const vec = await AIEmbeddings.embedQuery(
+      "q",
+      { model: "openrouter/openai/text-embedding-3-small" },
+      { openRouterApiKey: "k" },
+    );
+
+    expect(vec).toEqual([2]);
+    expect(embedOpenRouter).toHaveBeenCalled();
+  });
+});

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")];