@luanpoppe/ai 1.1.5 → 1.1.6

package/tests/e2e/ai-audio-multiprovider.test.ts

@@ -0,0 +1,118 @@
+import * as fs from "fs";
+import * as path from "path";
+import { AIAudio } from "../../src/index";
+import "dotenv/config";
+
+const AUDIO_FIXTURE_PATH = path.join(
+  process.cwd(),
+  "tests",
+  "e2e",
+  "@fixtures",
+  "audio-teste-saudacao.mp3",
+);
+
+describe("AIAudio multiprovider E2E", () => {
+  const openAIApiKey = process.env.OPENAI_API_KEY;
+  const openRouterApiKey = process.env.OPENROUTER_API_KEY;
+  const timeout = 120_000;
+
+  it(
+    "OpenAI STT + TTS round-trip curto",
+    { timeout },
+    async () => {
+      if (!openAIApiKey) {
+        console.log("OPENAI_API_KEY não configurada — pulando");
+        return;
+      }
+
+      const audioBuffer = fs.readFileSync(AUDIO_FIXTURE_PATH);
+      const { text } = await AIAudio.transcribeDetailedOpenAI(
+        audioBuffer,
+        { languageIn2Digits: "pt", responseFormat: "json" },
+        openAIApiKey,
+      );
+
+      expect(text.length).toBeGreaterThan(0);
+
+      const speech = await AIAudio.speakOpenAI(
+        "OK",
+        { voice: "nova", model: "gpt-4o-mini-tts", responseFormat: "mp3" },
+        openAIApiKey,
+      );
+
+      expect(speech.audio.length).toBeGreaterThan(100);
+    },
+  );
+
+  it(
+    "OpenRouter STT",
+    { timeout },
+    async () => {
+      if (!openRouterApiKey) {
+        console.log("OPENROUTER_API_KEY não configurada — pulando");
+        return;
+      }
+
+      const audioBuffer = fs.readFileSync(AUDIO_FIXTURE_PATH);
+      const result = await AIAudio.transcribeOpenRouter(
+        audioBuffer,
+        {
+          model: "openai/gpt-4o-mini-transcribe",
+          format: "mp3",
+          language: "pt",
+        },
+        openRouterApiKey,
+      );
+
+      expect(result.text.length).toBeGreaterThan(0);
+    },
+  );
+
+  it(
+    "OpenRouter TTS (Gemini — catálogo output_modalities=speech)",
+    { timeout },
+    async () => {
+      if (!openRouterApiKey) {
+        console.log("OPENROUTER_API_KEY não configurada — pulando");
+        return;
+      }
+
+      // Descoberto via GET /api/v1/models?output_modalities=speech
+      const speech = await AIAudio.speakOpenRouter(
+        "Teste de síntese.",
+        {
+          model: "google/gemini-3.1-flash-tts-preview",
+          voice: "Kore",
+        },
+        openRouterApiKey,
+      );
+
+      expect(speech.audio.length).toBeGreaterThan(100);
+      expect(speech.contentType).toBe("audio/pcm");
+    },
+  );
+
+  it(
+    "OpenRouter TTS (Mistral — mp3, requer providers liberados na conta)",
+    { timeout },
+    async () => {
+      if (!openRouterApiKey) {
+        console.log("OPENROUTER_API_KEY não configurada — pulando");
+        return;
+      }
+
+      const speech = await AIAudio.speakOpenRouter(
+        "Hello, this is a synthesis test.",
+        {
+          model: "mistralai/voxtral-mini-tts-2603",
+          voice: "en_paul_neutral",
+          responseFormat: "mp3",
+        },
+        openRouterApiKey,
+      );
+
+      expect(speech.audio.length).toBeGreaterThan(100);
+      expect(speech.contentType).toBe("audio/mpeg");
+    },
+  );
+});

package/tests/e2e/ai-deepseek-structured-output.test.ts

@@ -0,0 +1,133 @@
+import { AI } from "../../src/index";
+import { AIMessages } from "../../src/langchain/messages";
+import z from "zod";
+import "dotenv/config";
+
+describe("AI E2E - DeepSeek Structured Output", () => {
+  const openRouterApiKey = process.env.OPENROUTER_API_KEY;
+  const timeout = 180 * 1000;
+
+  const requireOpenRouter = () => {
+    if (!openRouterApiKey) {
+      console.log("OPENROUTER_API_KEY não está configurada");
+      return false;
+    }
+    return true;
+  };
+
+  it(
+    "deve retornar schema numérico com deepseek-v4-flash",
+    { timeout },
+    async () => {
+      if (!requireOpenRouter()) return;
+
+      const ai = new AI({ openRouterApiKey: openRouterApiKey! });
+      const outputSchema = z.object({
+        sum: z.number(),
+        product: z.number(),
+      });
+
+      const result = await ai.callStructuredOutput({
+        aiModel: "openrouter/deepseek/deepseek-v4-flash",
+        messages: [
+          AIMessages.human(
+            "Calcule a soma e o produto de 7 e 4. Responda em json.",
+          ),
+        ],
+        outputSchema,
+      });
+
+      expect(result.response.sum).toBe(11);
+      expect(result.response.product).toBe(28);
+    },
+  );
+
+  it(
+    "deve extrair nome e idade com deepseek-v4-pro",
+    { timeout },
+    async () => {
+      if (!requireOpenRouter()) return;
+
+      const ai = new AI({ openRouterApiKey: openRouterApiKey! });
+      const outputSchema = z.object({
+        nome: z.string(),
+        idade: z.number(),
+      });
+
+      const result = await ai.callStructuredOutput({
+        aiModel: "openrouter/deepseek/deepseek-v4-pro",
+        messages: [
+          AIMessages.human(
+            "Extraia nome e idade do texto: João tem 30 anos. Responda em json.",
+          ),
+        ],
+        outputSchema,
+      });
+
+      expect(result.response.nome.toLowerCase()).toContain("joão");
+      expect(result.response.idade).toBe(30);
+    },
+  );
+
+  it(
+    "deve suportar campos opcional/nullable com deepseek-v4-flash",
+    { timeout },
+    async () => {
+      if (!requireOpenRouter()) return;
+
+      const ai = new AI({ openRouterApiKey: openRouterApiKey! });
+      const outputSchema = z.object({
+        prontuarioFormal: z
+          .string()
+          .describe("Texto do prontuário")
+          .nullable(),
+        dataConsulta: z
+          .string()
+          .optional()
+          .describe("Data DD/MM/AAAA"),
+      });
+
+      const result = await ai.callStructuredOutput({
+        aiModel: "openrouter/deepseek/deepseek-v4-flash",
+        messages: [
+          AIMessages.human(
+            "Crie um prontuário breve para João, 30 anos, consulta 25/01/2026. Responda em json.",
+          ),
+        ],
+        outputSchema,
+      });
+
+      expect(result.response.prontuarioFormal).toBeDefined();
+      expect(typeof result.response.prontuarioFormal).toBe("string");
+      if (result.response.dataConsulta) {
+        expect(typeof result.response.dataConsulta).toBe("string");
+      }
+    },
+  );
+
+  it(
+    "deve suportar aiModelsFallback deepseek -> openai",
+    { timeout },
+    async () => {
+      if (!requireOpenRouter()) return;
+
+      const ai = new AI({ openRouterApiKey: openRouterApiKey! });
+      const outputSchema = z.object({
+        answer: z.string(),
+      });
+
+      const result = await ai.callStructuredOutput({
+        aiModel: "openrouter/deepseek/deepseek-v4-flash",
+        messages: [
+          AIMessages.human(
+            'Responda em json: { "answer": "fallback deepseek ok" }',
+          ),
+        ],
+        outputSchema,
+        aiModelsFallback: ["openrouter/openai/gpt-5-nano"],
+      });
+
+      expect(result.response.answer.toLowerCase()).toContain("fallback");
+    },
+  );
+});

package/tests/e2e/ai-embeddings.test.ts

@@ -0,0 +1,87 @@
+import { AIEmbeddings } from "../../src/index";
+import "dotenv/config";
+
+describe("AIEmbeddings E2E", () => {
+  const openAIApiKey = process.env.OPENAI_API_KEY;
+  const googleGeminiToken = process.env.GOOGLE_GEMINI_TOKEN;
+  const openRouterApiKey = process.env.OPENROUTER_API_KEY;
+  const timeout = 60_000;
+
+  it(
+    "OpenAI text-embedding-3-small",
+    { timeout },
+    async () => {
+      if (!openAIApiKey) {
+        console.log("OPENAI_API_KEY não configurada — pulando");
+        return;
+      }
+
+      const result = await AIEmbeddings.embedOpenAI(
+        "The quick brown fox jumps over the lazy dog.",
+        { model: "text-embedding-3-small" },
+        openAIApiKey,
+      );
+
+      expect(result.embeddings).toHaveLength(1);
+      expect(result.embeddings[0]!.length).toBeGreaterThan(100);
+    },
+  );
+
+  it(
+    "Gemini gemini-embedding-001",
+    { timeout },
+    async () => {
+      if (!googleGeminiToken) {
+        console.log("GOOGLE_GEMINI_TOKEN não configurada — pulando");
+        return;
+      }
+
+      const vector = await AIEmbeddings.embedQuery(
+        "Semantic search test.",
+        { model: "gemini-embedding-001" },
+        { googleGeminiToken },
+      );
+
+      expect(vector.length).toBeGreaterThan(100);
+    },
+  );
+
+  it(
+    "OpenRouter openai/text-embedding-3-small",
+    { timeout },
+    async () => {
+      if (!openRouterApiKey) {
+        console.log("OPENROUTER_API_KEY não configurada — pulando");
+        return;
+      }
+
+      const result = await AIEmbeddings.embedOpenRouter(
+        ["First document.", "Second document."],
+        { model: "openrouter/openai/text-embedding-3-small" },
+        openRouterApiKey,
+      );
+
+      expect(result.embeddings).toHaveLength(2);
+      expect(result.embeddings[0]!.length).toBeGreaterThan(100);
+    },
+  );
+
+  it(
+    "embedDocuments em lote via roteamento OpenAI",
+    { timeout },
+    async () => {
+      if (!openAIApiKey) {
+        console.log("OPENAI_API_KEY não configurada — pulando");
+        return;
+      }
+
+      const vectors = await AIEmbeddings.embedDocuments(
+        ["doc a", "doc b"],
+        { model: "text-embedding-3-small" },
+        { openAIApiKey },
+      );
+
+      expect(vectors).toHaveLength(2);
+    },
+  );
+});

package/tests/e2e/ai-local-models.test.ts

@@ -0,0 +1,65 @@
+import { AI } from "../../src/index";
+import { AIMessages } from "../../src/langchain/messages";
+import "dotenv/config";
+
+const ollamaBaseUrl = process.env.OLLAMA_BASE_URL ?? "http://127.0.0.1:11434";
+const ollamaModel = process.env.OLLAMA_MODEL_NAME ?? "llama3.2";
+const localBaseUrl = process.env.LOCAL_BASE_URL;
+const localModel = process.env.LOCAL_MODEL_NAME ?? "local-model";
+
+const timeout = 180 * 1000;
+
+describe("AI E2E — modelos locais", () => {
+  describe.skipIf(!process.env.OLLAMA_E2E)(
+    "Ollama (API nativa, prefixo ollama/)",
+    () => {
+      it(
+        "deve responder via ChatOllama",
+        { timeout },
+        async () => {
+          const ai = new AI({ ollamaBaseUrl });
+
+          const result = await ai.call({
+            aiModel: `ollama/${ollamaModel}`,
+            messages: [
+              AIMessages.human(
+                "Responda apenas com: teste ollama ok",
+              ),
+            ],
+          });
+
+          expect(result.text).toBeDefined();
+          expect(result.text.length).toBeGreaterThan(0);
+        },
+      );
+    },
+  );
+
+  describe.skipIf(!localBaseUrl)(
+    "OpenAI-compatible (prefixo local/)",
+    () => {
+      it(
+        "deve responder via servidor local (LM Studio, Ollama /v1, etc.)",
+        { timeout },
+        async () => {
+          const ai = new AI({
+            localBaseUrl,
+            localApiKey: process.env.LOCAL_API_KEY,
+          });
+
+          const result = await ai.call({
+            aiModel: `local/${localModel}`,
+            messages: [
+              AIMessages.human(
+                "Responda apenas com: teste local ok",
+              ),
+            ],
+          });
+
+          expect(result.text).toBeDefined();
+          expect(result.text.length).toBeGreaterThan(0);
+        },
+      );
+    },
+  );
+});

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

@@ -0,0 +1,17 @@
+import { describe, it, expect } from "vitest";
+import { AIAudio, ANTHROPIC_NO_NATIVE_AUDIO } from "../../../src/index.js";
+
+describe("AIAudio facade", () => {
+  it("expõe métodos estáticos principais", () => {
+    expect(typeof AIAudio.transcribeWithWhisper).toBe("function");
+    expect(typeof AIAudio.transcribeDetailedOpenAI).toBe("function");
+    expect(typeof AIAudio.transcribeOpenRouter).toBe("function");
+    expect(typeof AIAudio.speakOpenAI).toBe("function");
+    expect(typeof AIAudio.speakOpenRouter).toBe("function");
+    expect(typeof AIAudio.transcribeWithGeminiPrompt).toBe("function");
+  });
+
+  it("exporta constante Anthropic", () => {
+    expect(ANTHROPIC_NO_NATIVE_AUDIO).toContain("Anthropic");
+  });
+});

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

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { speakOpenAI } from "../../../src/audio/speech-openai.js";
+
+const mockSpeechCreate = vi.fn();
+
+vi.mock("openai", () => ({
+  default: class MockOpenAI {
+    audio = {
+      speech: {
+        create: mockSpeechCreate,
+      },
+    };
+  },
+}));
+
+describe("speech-openai", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSpeechCreate.mockResolvedValue({
+      arrayBuffer: async () => new Uint8Array([1, 2, 3]).buffer,
+    });
+  });
+
+  it("cria speech com voice e model padrão", async () => {
+    const result = await speakOpenAI(
+      "Olá",
+      { voice: "nova" },
+      "sk-test",
+    );
+
+    expect(result.audio).toEqual(Buffer.from([1, 2, 3]));
+    expect(result.contentType).toBe("audio/mpeg");
+    expect(mockSpeechCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        model: "gpt-4o-mini-tts",
+        voice: "nova",
+        input: "Olá",
+        response_format: "mp3",
+      }),
+    );
+  });
+
+  it("repassa instructions para gpt-4o-mini-tts", async () => {
+    await speakOpenAI(
+      "Oi",
+      {
+        voice: "alloy",
+        model: "gpt-4o-mini-tts",
+        instructions: "Fale devagar.",
+      },
+      "sk-test",
+    );
+
+    expect(mockSpeechCreate).toHaveBeenCalledWith(
+      expect.objectContaining({ instructions: "Fale devagar." }),
+    );
+  });
+
+  it("rejeita instructions em tts-1", async () => {
+    await expect(
+      speakOpenAI(
+        "Oi",
+        { voice: "alloy", model: "tts-1", instructions: "x" },
+        "sk-test",
+      ),
+    ).rejects.toThrow("instructions");
+  });
+
+  it("exige API key", async () => {
+    await expect(speakOpenAI("Oi", { voice: "nova" })).rejects.toThrow(
+      "OpenAI API key",
+    );
+  });
+});

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

@@ -0,0 +1,88 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { speakOpenRouter } from "../../../src/audio/speech-openrouter.js";
+
+const mockSpeechCreate = vi.fn();
+let capturedBaseURL: string | undefined;
+
+vi.mock("../../../src/audio/openrouter-client.js", () => ({
+  createOpenRouterOpenAIClient: (apiKey: string) => {
+    capturedBaseURL = "https://openrouter.ai/api/v1";
+    return {
+      apiKey,
+      audio: {
+        speech: { create: mockSpeechCreate },
+      },
+    };
+  },
+}));
+
+describe("speech-openrouter", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    capturedBaseURL = undefined;
+    mockSpeechCreate.mockResolvedValue({
+      arrayBuffer: async () => new Uint8Array([9, 8]).buffer,
+    });
+  });
+
+  it("cria speech com model slug e voice", async () => {
+    const result = await speakOpenRouter(
+      "Resumo",
+      {
+        model: "google/gemini-2.5-flash-preview-tts",
+        voice: "Kore",
+        responseFormat: "mp3",
+      },
+      "or-key",
+    );
+
+    expect(result.audio).toEqual(Buffer.from([9, 8]));
+    expect(mockSpeechCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        model: "google/gemini-2.5-flash-preview-tts",
+        voice: "Kore",
+        input: "Resumo",
+      }),
+    );
+  });
+
+  it("mescla instructions em provider.options sem apagar only", async () => {
+    await speakOpenRouter(
+      "Oi",
+      {
+        model: "deepseek/some-tts",
+        voice: "alloy",
+        instructions: "Tom formal.",
+      },
+      "or-key",
+    );
+
+    const body = mockSpeechCreate.mock.calls[0][0] as Record<string, unknown>;
+    const provider = body.provider as Record<string, unknown>;
+    expect(provider.only).toEqual(["deepseek"]);
+    expect(provider.options).toEqual({
+      openai: { instructions: "Tom formal." },
+    });
+  });
+
+  it("usa pcm por padrão para modelos Gemini TTS", async () => {
+    await speakOpenRouter(
+      "Oi",
+      {
+        model: "google/gemini-3.1-flash-tts-preview",
+        voice: "Kore",
+      },
+      "or-key",
+    );
+
+    expect(mockSpeechCreate).toHaveBeenCalledWith(
+      expect.objectContaining({ response_format: "pcm" }),
+    );
+  });
+
+  it("exige model e voice", async () => {
+    await expect(
+      speakOpenRouter("x", { model: "", voice: "a" }, "k"),
+    ).rejects.toThrow("model é obrigatório");
+  });
+});