@xenterprises/fastify-x-ai 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xenterprises/fastify-x-ai",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Fastify plugin for Vercel AI SDK - unified AI provider access with text generation, streaming, embeddings, and structured output",
   "type": "module",
   "main": "src/xAI.js",

package/test/xAI.test.js

@@ -1,280 +0,0 @@
-/**
- * xAI Tests
- *
- * Tests for the xAI Fastify plugin (Vercel AI SDK integration)
- * Note: These are unit tests that don't require actual API calls
- */
-
-import { describe, test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert";
-import Fastify from "fastify";
-import xAI, { DEFAULT_MODELS } from "../src/xAI.js";
-
-describe("xAI Plugin", () => {
-  let fastify;
-
-  beforeEach(() => {
-    fastify = Fastify({ logger: { level: "silent" } });
-  });
-
-  afterEach(async () => {
-    await fastify.close();
-  });
-
-  describe("Plugin Registration", () => {
-    test("should skip registration when active is false", async () => {
-      await fastify.register(xAI, { active: false });
-      await fastify.ready();
-
-      assert.ok(!fastify.xai, "xai should not exist");
-    });
-
-    test("should register with OpenAI provider from env", async () => {
-      // Set env var temporarily
-      const originalKey = process.env.OPENAI_API_KEY;
-      process.env.OPENAI_API_KEY = "test-key-12345";
-
-      try {
-        await fastify.register(xAI, {});
-        await fastify.ready();
-
-        assert.ok(fastify.xai, "xai should exist");
-        assert.ok(fastify.xai.config, "xai.config should exist");
-        assert.ok(fastify.xai.generate, "xai.generate should exist");
-        assert.ok(fastify.xai.stream, "xai.stream should exist");
-        assert.ok(fastify.xai.chat, "xai.chat should exist");
-        assert.ok(fastify.xai.complete, "xai.complete should exist");
-        assert.ok(fastify.xai.createEmbedding, "xai.createEmbedding should exist");
-        assert.ok(fastify.xai.similarity, "xai.similarity should exist");
-        assert.ok(fastify.xai.generateStructured, "xai.generateStructured should exist");
-        assert.ok(fastify.xai.getModel, "xai.getModel should exist");
-        assert.ok(fastify.xai.raw, "xai.raw should exist");
-      } finally {
-        if (originalKey) {
-          process.env.OPENAI_API_KEY = originalKey;
-        } else {
-          delete process.env.OPENAI_API_KEY;
-        }
-      }
-    });
-
-    test("should register with explicit provider config", async () => {
-      await fastify.register(xAI, {
-        providers: {
-          openai: { apiKey: "test-api-key" },
-        },
-      });
-      await fastify.ready();
-
-      assert.ok(fastify.xai, "xai should exist");
-      assert.ok(fastify.xai.config.providers.includes("openai"), "openai should be in providers");
-    });
-
-    test("should store default configuration", async () => {
-      await fastify.register(xAI, {
-        defaultProvider: "openai",
-        defaultMaxTokens: 2048,
-        defaultTemperature: 0.5,
-        providers: {
-          openai: { apiKey: "test-key" },
-        },
-      });
-      await fastify.ready();
-
-      assert.strictEqual(fastify.xai.config.defaultProvider, "openai");
-      assert.strictEqual(fastify.xai.config.defaultMaxTokens, 2048);
-      assert.strictEqual(fastify.xai.config.defaultTemperature, 0.5);
-    });
-
-    test("should use default values when not specified", async () => {
-      await fastify.register(xAI, {
-        providers: {
-          openai: { apiKey: "test-key" },
-        },
-      });
-      await fastify.ready();
-
-      assert.strictEqual(fastify.xai.config.defaultProvider, "openai");
-      assert.strictEqual(fastify.xai.config.defaultMaxTokens, 4096);
-      assert.strictEqual(fastify.xai.config.defaultTemperature, 0.7);
-    });
-  });
-
-  describe("Model Selection", () => {
-    test("should get model for configured provider", async () => {
-      await fastify.register(xAI, {
-        providers: {
-          openai: { apiKey: "test-key" },
-        },
-      });
-      await fastify.ready();
-
-      const model = fastify.xai.getModel("openai", "gpt-4o");
-      assert.ok(model, "model should exist");
-    });
-
-    test("should throw for unconfigured provider", async () => {
-      await fastify.register(xAI, {
-        providers: {
-          openai: { apiKey: "test-key" },
-        },
-      });
-      await fastify.ready();
-
-      assert.throws(() => {
-        fastify.xai.getModel("anthropic", "claude-3");
-      }, /Provider 'anthropic' not configured/);
-    });
-
-    test("should use default provider when not specified", async () => {
-      await fastify.register(xAI, {
-        defaultProvider: "openai",
-        providers: {
-          openai: { apiKey: "test-key" },
-        },
-      });
-      await fastify.ready();
-
-      // Should not throw when provider not specified
-      const model = fastify.xai.getModel();
-      assert.ok(model, "model should exist");
-    });
-  });
-
-  describe("Raw SDK Access", () => {
-    test("should expose raw AI SDK functions", async () => {
-      await fastify.register(xAI, {
-        providers: {
-          openai: { apiKey: "test-key" },
-        },
-      });
-      await fastify.ready();
-
-      assert.ok(fastify.xai.raw, "raw should exist");
-      assert.ok(fastify.xai.raw.generateText, "generateText should exist");
-      assert.ok(fastify.xai.raw.streamText, "streamText should exist");
-      assert.ok(fastify.xai.raw.embed, "embed should exist");
-      assert.ok(fastify.xai.raw.embedMany, "embedMany should exist");
-      assert.ok(fastify.xai.raw.cosineSimilarity, "cosineSimilarity should exist");
-    });
-  });
-
-  describe("Similarity Function", () => {
-    test("should calculate cosine similarity", async () => {
-      await fastify.register(xAI, {
-        providers: {
-          openai: { apiKey: "test-key" },
-        },
-      });
-      await fastify.ready();
-
-      // Test with identical vectors - should be 1
-      const sim1 = fastify.xai.similarity([1, 0, 0], [1, 0, 0]);
-      assert.ok(Math.abs(sim1 - 1) < 0.001, "identical vectors should have similarity ~1");
-
-      // Test with orthogonal vectors - should be 0
-      const sim2 = fastify.xai.similarity([1, 0], [0, 1]);
-      assert.ok(Math.abs(sim2) < 0.001, "orthogonal vectors should have similarity ~0");
-
-      // Test with opposite vectors - should be -1
-      const sim3 = fastify.xai.similarity([1, 0], [-1, 0]);
-      assert.ok(Math.abs(sim3 + 1) < 0.001, "opposite vectors should have similarity ~-1");
-    });
-  });
-
-  describe("Provider Configuration", () => {
-    test("should list enabled providers", async () => {
-      await fastify.register(xAI, {
-        providers: {
-          openai: { apiKey: "test-key" },
-        },
-      });
-      await fastify.ready();
-
-      assert.ok(Array.isArray(fastify.xai.config.providers));
-      assert.ok(fastify.xai.config.providers.includes("openai"));
-    });
-
-    test("should have empty providers when none configured", async () => {
-      // Clear any env vars
-      const originalOpenAI = process.env.OPENAI_API_KEY;
-      const originalAnthropic = process.env.ANTHROPIC_API_KEY;
-      const originalGoogle = process.env.GOOGLE_API_KEY;
-
-      delete process.env.OPENAI_API_KEY;
-      delete process.env.ANTHROPIC_API_KEY;
-      delete process.env.GOOGLE_API_KEY;
-
-      try {
-        await fastify.register(xAI, {});
-        await fastify.ready();
-
-        assert.ok(Array.isArray(fastify.xai.config.providers));
-        assert.strictEqual(fastify.xai.config.providers.length, 0);
-      } finally {
-        if (originalOpenAI) process.env.OPENAI_API_KEY = originalOpenAI;
-        if (originalAnthropic) process.env.ANTHROPIC_API_KEY = originalAnthropic;
-        if (originalGoogle) process.env.GOOGLE_API_KEY = originalGoogle;
-      }
-    });
-  });
-});
-
-describe("Exports", () => {
-  test("should export DEFAULT_MODELS", () => {
-    assert.ok(DEFAULT_MODELS, "DEFAULT_MODELS should exist");
-    assert.strictEqual(DEFAULT_MODELS.openai, "gpt-4o");
-    assert.strictEqual(DEFAULT_MODELS.anthropic, "claude-sonnet-4-20250514");
-    assert.strictEqual(DEFAULT_MODELS.google, "gemini-2.0-flash");
-  });
-});
-
-describe("Method Signatures", () => {
-  let fastify;
-
-  beforeEach(async () => {
-    fastify = Fastify({ logger: { level: "silent" } });
-    await fastify.register(xAI, {
-      providers: {
-        openai: { apiKey: "test-key" },
-      },
-    });
-    await fastify.ready();
-  });
-
-  afterEach(async () => {
-    await fastify.close();
-  });
-
-  test("generate should be a function", () => {
-    assert.strictEqual(typeof fastify.xai.generate, "function");
-  });
-
-  test("stream should be a function", () => {
-    assert.strictEqual(typeof fastify.xai.stream, "function");
-  });
-
-  test("chat should be a function", () => {
-    assert.strictEqual(typeof fastify.xai.chat, "function");
-  });
-
-  test("complete should be a function", () => {
-    assert.strictEqual(typeof fastify.xai.complete, "function");
-  });
-
-  test("createEmbedding should be a function", () => {
-    assert.strictEqual(typeof fastify.xai.createEmbedding, "function");
-  });
-
-  test("similarity should be a function", () => {
-    assert.strictEqual(typeof fastify.xai.similarity, "function");
-  });
-
-  test("generateStructured should be a function", () => {
-    assert.strictEqual(typeof fastify.xai.generateStructured, "function");
-  });
-
-  test("getModel should be a function", () => {
-    assert.strictEqual(typeof fastify.xai.getModel, "function");
-  });
-});