@kognitivedev/vercel-ai-provider 0.2.13 → 0.2.16

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @kognitivedev/vercel-ai-provider
 
+## 0.2.16
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/prompthub@0.1.14
+  - @kognitivedev/shared@0.2.16
+
+## 0.2.15
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/prompthub@0.1.13
+  - @kognitivedev/shared@0.2.15
+
+## 0.2.14
+
+### Patch Changes
+
+- release
+
+- release
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/prompthub@0.1.12
+  - @kognitivedev/shared@0.2.14
+
 ## 0.2.13
 
 ### Patch Changes

package/dist/__tests__/cognitive-layer-extra.test.js

@@ -1,42 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
-const aiMocks = vitest_1.vi.hoisted(() => ({
-    wrapLanguageModel: vitest_1.vi.fn(({ model }) => model),
-    streamText: vitest_1.vi.fn(async (options) => ({ options })),
-    generateText: vitest_1.vi.fn(async (options) => ({ options })),
-}));
+const test_1 = require("ai/test");
 const promptHubMocks = vitest_1.vi.hoisted(() => ({
     resolvePrompt: vitest_1.vi.fn(),
 }));
-vitest_1.vi.mock("ai", () => ({
-    wrapLanguageModel: aiMocks.wrapLanguageModel,
-    streamText: aiMocks.streamText,
-    generateText: aiMocks.generateText,
-}));
 vitest_1.vi.mock("@kognitivedev/prompthub", () => ({
     createPromptHubClient: vitest_1.vi.fn(() => ({
         resolvePrompt: promptHubMocks.resolvePrompt,
     })),
 }));
+vitest_1.vi.mock("ai", async (importOriginal) => {
+    const mod = await importOriginal();
+    return Object.assign(Object.assign({}, mod), { streamText: vitest_1.vi.fn((...args) => mod.streamText(...args)), generateText: vitest_1.vi.fn((...args) => mod.generateText(...args)) });
+});
+const ai_1 = require("ai");
 const index_1 = require("../index");
+function minimalFinishUsage() {
+    return {
+        inputTokens: { total: 1, noCache: undefined, cacheRead: undefined, cacheWrite: undefined },
+        outputTokens: { total: 1, text: undefined, reasoning: undefined },
+    };
+}
+function createDualMockModel(modelId = "mock-model") {
+    return new test_1.MockLanguageModelV3({
+        modelId,
+        doGenerate: async () => ({
+            content: [{ type: "text", text: "ok" }],
+            finishReason: { unified: "stop", raw: undefined },
+            usage: minimalFinishUsage(),
+            warnings: [],
+        }),
+        doStream: async () => ({
+            stream: (0, test_1.convertArrayToReadableStream)([
+                { type: "text-start", id: "t1" },
+                { type: "text-delta", id: "t1", delta: "x" },
+                { type: "text-end", id: "t1" },
+                {
+                    type: "finish",
+                    finishReason: { unified: "stop", raw: undefined },
+                    usage: minimalFinishUsage(),
+                },
+            ]),
+        }),
+    });
+}
+/** Default provider for tests — real LanguageModel so `wrapLanguageModel` middleware runs. */
+function defaultProvider(modelId) {
+    const m = createDualMockModel(modelId);
+    return m;
+}
+function setupSnapshotAndLogFetch() {
+    const fetchSpy = vitest_1.vi.fn(async (url, init) => {
+        const urlStr = typeof url === "string" ? url : url.toString();
+        if (urlStr.includes("/api/cognitive/snapshot")) {
+            return new Response(JSON.stringify({ systemBlock: "", userContextBlock: "" }), { status: 200, headers: { "Content-Type": "application/json" } });
+        }
+        if (urlStr.includes("/api/cognitive/log")) {
+            return new Response(JSON.stringify({ ok: true }), { status: 201 });
+        }
+        if (urlStr.includes("/api/cognitive/process")) {
+            return new Response(JSON.stringify({ ok: true }), { status: 200 });
+        }
+        return new Response("not found", { status: 404 });
+    });
+    vitest_1.vi.stubGlobal("fetch", fetchSpy);
+    return fetchSpy;
+}
 function makeLayer(overrides) {
+    var _a;
     return (0, index_1.createCognitiveLayer)({
-        provider: (modelId) => ({ modelId }),
+        provider: (_a = overrides === null || overrides === void 0 ? void 0 : overrides.provider) !== null && _a !== void 0 ? _a : defaultProvider,
         clConfig: Object.assign({ apiKey: "test-api-key", baseUrl: "https://backend.example", projectId: "project-1", processDelayMs: 0, logLevel: "debug" }, overrides),
     });
 }
 (0, vitest_1.describe)("createCognitiveLayer extras", () => {
     (0, vitest_1.beforeEach)(() => {
-        aiMocks.wrapLanguageModel.mockClear();
-        aiMocks.streamText.mockClear();
-        aiMocks.generateText.mockClear();
+        vitest_1.vi.mocked(ai_1.streamText).mockClear();
+        vitest_1.vi.mocked(ai_1.generateText).mockClear();
         promptHubMocks.resolvePrompt.mockReset();
     });
     (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.unstubAllGlobals();
         vitest_1.vi.restoreAllMocks();
     });
     (0, vitest_1.it)("resolves prompts and renders variables", async () => {
+        setupSnapshotAndLogFetch();
         promptHubMocks.resolvePrompt.mockResolvedValue({
             promptId: "prompt-1",
             slug: "welcome",
@@ -63,7 +112,7 @@ function makeLayer(overrides) {
             userId: "user-1",
             tag: undefined,
         });
-        (0, vitest_1.expect)(aiMocks.streamText).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+        (0, vitest_1.expect)(ai_1.streamText).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
             system: "Hello Ada",
             model: vitest_1.expect.objectContaining({ modelId: "mock-model" }),
         }));
@@ -73,6 +122,7 @@ function makeLayer(overrides) {
         cl.clearSessionCache();
     });
     (0, vitest_1.it)("uses a gateway model when providerFactory is available", async () => {
+        setupSnapshotAndLogFetch();
         promptHubMocks.resolvePrompt.mockResolvedValue({
             promptId: "prompt-2",
             slug: "gateway",
@@ -81,7 +131,7 @@ function makeLayer(overrides) {
             fetchedAt: Date.now(),
             gatewaySlug: "gateway-a",
         });
-        const providerFactory = vitest_1.vi.fn(() => vitest_1.vi.fn((modelId) => ({ modelId })));
+        const providerFactory = vitest_1.vi.fn(() => vitest_1.vi.fn((mid) => createDualMockModel(mid)));
         const cl = makeLayer({ providerFactory });
         const model = cl("mock-model", {
             userId: "user-1",
@@ -94,13 +144,15 @@ function makeLayer(overrides) {
             prompt: { slug: "gateway" },
         });
         (0, vitest_1.expect)(providerFactory).toHaveBeenCalledWith("https://backend.example/api/cognitive/gateway/gateway-a", "test-api-key");
-        (0, vitest_1.expect)(aiMocks.generateText).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
-            model: vitest_1.expect.objectContaining({ modelId: "gateway-model" }),
+        // Gateway path reuses the base model's modelId when calling the factory (routing is via gateway base URL).
+        (0, vitest_1.expect)(ai_1.generateText).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            model: vitest_1.expect.objectContaining({ modelId: "mock-model" }),
             system: "Prompt body",
         }));
     });
     (0, vitest_1.it)("passes prompt tag and stores tag/ab metadata in logging payload", async () => {
         var _a, _b, _c, _d;
+        const fetchSpy = setupSnapshotAndLogFetch();
         const backendResponse = {
             promptId: "prompt-4",
             slug: "tagged-welcome",
@@ -113,9 +165,6 @@ function makeLayer(overrides) {
             variant: "variant",
         };
         promptHubMocks.resolvePrompt.mockResolvedValue(backendResponse);
-        const fetchSpy = vitest_1.vi
-            .spyOn(globalThis, "fetch")
-            .mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 201 }));
         const cl = makeLayer();
         const model = cl("mock-model", {
             userId: "user-2",
@@ -154,9 +203,9 @@ function makeLayer(overrides) {
         (0, vitest_1.expect)((_b = calledWithBody.metadata) === null || _b === void 0 ? void 0 : _b.promptTag).toBe("production");
         (0, vitest_1.expect)((_c = calledWithBody.metadata) === null || _c === void 0 ? void 0 : _c.abTestId).toBe("ab-test-1");
         (0, vitest_1.expect)((_d = calledWithBody.metadata) === null || _d === void 0 ? void 0 : _d.variant).toBe("variant");
-        fetchSpy.mockRestore();
     });
     (0, vitest_1.it)("falls back to the original model when gateway model creation fails", async () => {
+        setupSnapshotAndLogFetch();
         promptHubMocks.resolvePrompt.mockResolvedValue({
             promptId: "prompt-3",
             slug: "gateway",
@@ -182,13 +231,14 @@ function makeLayer(overrides) {
             prompt: { slug: "gateway" },
         });
         (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("Failed to create gateway model, falling back to original"), vitest_1.expect.any(Error));
-        (0, vitest_1.expect)(aiMocks.streamText).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+        (0, vitest_1.expect)(ai_1.streamText).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
             model: vitest_1.expect.objectContaining({ modelId: "mock-model" }),
         }));
     });
     (0, vitest_1.it)("falls back cleanly when prompt resolution fails", async () => {
-        promptHubMocks.resolvePrompt.mockRejectedValue(new Error("not found"));
+        setupSnapshotAndLogFetch();
         const warnSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+        promptHubMocks.resolvePrompt.mockRejectedValue(new Error("not found"));
         const cl = makeLayer();
         const model = cl("mock-model", {
             userId: "user-1",
@@ -201,9 +251,9 @@ function makeLayer(overrides) {
             prompt: { slug: "missing" },
         });
         (0, vitest_1.expect)(warnSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('Failed to resolve prompt "missing", generating without system prompt.'), vitest_1.expect.any(Error));
-        (0, vitest_1.expect)(aiMocks.generateText).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+        (0, vitest_1.expect)(ai_1.generateText).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
             model: vitest_1.expect.objectContaining({ modelId: "mock-model" }),
         }));
-        (0, vitest_1.expect)(aiMocks.generateText.mock.calls[0][0]).not.toHaveProperty("system");
+        (0, vitest_1.expect)(vitest_1.vi.mocked(ai_1.generateText).mock.calls[0][0]).not.toHaveProperty("system");
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kognitivedev/vercel-ai-provider",
-  "version": "0.2.13",
+  "version": "0.2.16",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {
@@ -13,8 +13,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@kognitivedev/prompthub": "^0.1.11",
-    "@kognitivedev/shared": "^0.2.13"
+    "@kognitivedev/prompthub": "^0.1.14",
+    "@kognitivedev/shared": "^0.2.16"
   },
   "peerDependencies": {
     "ai": "^5.0.0 || ^6.0.0"

package/src/__tests__/cognitive-layer-extra.test.ts

@@ -1,35 +1,93 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import type { LanguageModel } from "ai";
-
-const aiMocks = vi.hoisted(() => ({
-    wrapLanguageModel: vi.fn(({ model }: { model: unknown }) => model),
-    streamText: vi.fn(async (options: Record<string, unknown>) => ({ options })),
-    generateText: vi.fn(async (options: Record<string, unknown>) => ({ options })),
-}));
+import { MockLanguageModelV3, convertArrayToReadableStream } from "ai/test";
 
 const promptHubMocks = vi.hoisted(() => ({
     resolvePrompt: vi.fn(),
 }));
 
-vi.mock("ai", () => ({
-    wrapLanguageModel: aiMocks.wrapLanguageModel,
-    streamText: aiMocks.streamText,
-    generateText: aiMocks.generateText,
-}));
-
 vi.mock("@kognitivedev/prompthub", () => ({
     createPromptHubClient: vi.fn(() => ({
         resolvePrompt: promptHubMocks.resolvePrompt,
     })),
 }));
 
+vi.mock("ai", async (importOriginal) => {
+    const mod = await importOriginal<typeof import("ai")>();
+    return {
+        ...mod,
+        streamText: vi.fn((...args: Parameters<typeof mod.streamText>) => mod.streamText(...args)),
+        generateText: vi.fn((...args: Parameters<typeof mod.generateText>) => mod.generateText(...args)),
+    };
+});
+
+import { streamText as aiStreamText, generateText as aiGenerateText } from "ai";
 import { createCognitiveLayer } from "../index";
 
+function minimalFinishUsage() {
+    return {
+        inputTokens: { total: 1, noCache: undefined, cacheRead: undefined, cacheWrite: undefined },
+        outputTokens: { total: 1, text: undefined, reasoning: undefined },
+    } as const;
+}
+
+function createDualMockModel(modelId = "mock-model") {
+    return new MockLanguageModelV3({
+        modelId,
+        doGenerate: async () => ({
+            content: [{ type: "text" as const, text: "ok" }],
+            finishReason: { unified: "stop" as const, raw: undefined },
+            usage: minimalFinishUsage(),
+            warnings: [],
+        }),
+        doStream: async () => ({
+            stream: convertArrayToReadableStream([
+                { type: "text-start" as const, id: "t1" },
+                { type: "text-delta" as const, id: "t1", delta: "x" },
+                { type: "text-end" as const, id: "t1" },
+                {
+                    type: "finish" as const,
+                    finishReason: { unified: "stop" as const, raw: undefined },
+                    usage: minimalFinishUsage(),
+                },
+            ]),
+        }),
+    });
+}
+
+/** Default provider for tests — real LanguageModel so `wrapLanguageModel` middleware runs. */
+function defaultProvider(modelId: string): LanguageModel {
+    const m = createDualMockModel(modelId);
+    return m as unknown as LanguageModel;
+}
+
+function setupSnapshotAndLogFetch() {
+    const fetchSpy = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
+        const urlStr = typeof url === "string" ? url : url.toString();
+        if (urlStr.includes("/api/cognitive/snapshot")) {
+            return new Response(
+                JSON.stringify({ systemBlock: "", userContextBlock: "" }),
+                { status: 200, headers: { "Content-Type": "application/json" } },
+            );
+        }
+        if (urlStr.includes("/api/cognitive/log")) {
+            return new Response(JSON.stringify({ ok: true }), { status: 201 });
+        }
+        if (urlStr.includes("/api/cognitive/process")) {
+            return new Response(JSON.stringify({ ok: true }), { status: 200 });
+        }
+        return new Response("not found", { status: 404 });
+    });
+    vi.stubGlobal("fetch", fetchSpy);
+    return fetchSpy;
+}
+
 function makeLayer(overrides?: {
     providerFactory?: (baseURL: string, apiKey: string) => (modelId: string) => LanguageModel;
+    provider?: (modelId: string) => LanguageModel;
 }) {
     return createCognitiveLayer({
-        provider: (modelId: string) => ({ modelId }),
+        provider: overrides?.provider ?? defaultProvider,
         clConfig: {
             apiKey: "test-api-key",
             baseUrl: "https://backend.example",
@@ -43,17 +101,18 @@ function makeLayer(overrides?: {
 
 describe("createCognitiveLayer extras", () => {
     beforeEach(() => {
-        aiMocks.wrapLanguageModel.mockClear();
-        aiMocks.streamText.mockClear();
-        aiMocks.generateText.mockClear();
+        vi.mocked(aiStreamText).mockClear();
+        vi.mocked(aiGenerateText).mockClear();
         promptHubMocks.resolvePrompt.mockReset();
     });
 
     afterEach(() => {
+        vi.unstubAllGlobals();
         vi.restoreAllMocks();
     });
 
     it("resolves prompts and renders variables", async () => {
+        setupSnapshotAndLogFetch();
         promptHubMocks.resolvePrompt.mockResolvedValue({
             promptId: "prompt-1",
             slug: "welcome",
@@ -83,14 +142,14 @@ describe("createCognitiveLayer extras", () => {
             userId: "user-1",
             tag: undefined,
         });
-        expect(aiMocks.streamText).toHaveBeenCalledWith(
+        expect(aiStreamText).toHaveBeenCalledWith(
             expect.objectContaining({
                 system: "Hello Ada",
                 model: expect.objectContaining({ modelId: "mock-model" }),
-            })
+            }),
         );
         expect(warnSpy).toHaveBeenCalledWith(
-            expect.stringContaining("Gateway config found but no providerFactory provided")
+            expect.stringContaining("Gateway config found but no providerFactory provided"),
         );
         expect(logSpy).toHaveBeenCalled();
         cl.clearSessionCache("user-1:project-1:session-1");
@@ -98,6 +157,7 @@ describe("createCognitiveLayer extras", () => {
     });
 
     it("uses a gateway model when providerFactory is available", async () => {
+        setupSnapshotAndLogFetch();
         promptHubMocks.resolvePrompt.mockResolvedValue({
             promptId: "prompt-2",
             slug: "gateway",
@@ -107,7 +167,7 @@ describe("createCognitiveLayer extras", () => {
             gatewaySlug: "gateway-a",
         });
 
-        const providerFactory = vi.fn(() => vi.fn((modelId: string) => ({ modelId } as unknown as LanguageModel)));
+        const providerFactory = vi.fn(() => vi.fn((mid: string) => createDualMockModel(mid) as unknown as LanguageModel));
         const cl = makeLayer({ providerFactory });
         const model = cl("mock-model", {
             userId: "user-1",
@@ -123,17 +183,20 @@ describe("createCognitiveLayer extras", () => {
 
         expect(providerFactory).toHaveBeenCalledWith(
             "https://backend.example/api/cognitive/gateway/gateway-a",
-            "test-api-key"
+            "test-api-key",
         );
-        expect(aiMocks.generateText).toHaveBeenCalledWith(
+        // Gateway path reuses the base model's modelId when calling the factory (routing is via gateway base URL).
+        expect(aiGenerateText).toHaveBeenCalledWith(
             expect.objectContaining({
-                model: expect.objectContaining({ modelId: "gateway-model" }),
+                model: expect.objectContaining({ modelId: "mock-model" }),
                 system: "Prompt body",
-            })
+            }),
         );
     });
 
     it("passes prompt tag and stores tag/ab metadata in logging payload", async () => {
+        const fetchSpy = setupSnapshotAndLogFetch();
+
         const backendResponse = {
             promptId: "prompt-4",
             slug: "tagged-welcome",
@@ -147,10 +210,6 @@ describe("createCognitiveLayer extras", () => {
         };
         promptHubMocks.resolvePrompt.mockResolvedValue(backendResponse);
 
-        const fetchSpy = vi
-            .spyOn(globalThis, "fetch")
-            .mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 201 }));
-
         const cl = makeLayer();
         const model = cl("mock-model", {
             userId: "user-2",
@@ -179,12 +238,10 @@ describe("createCognitiveLayer extras", () => {
                     Authorization: "Bearer test-api-key",
                 }),
                 body: expect.stringContaining('"promptSlug":"tagged-welcome"'),
-            })
+            }),
         );
 
-        const logCall = fetchSpy.mock.calls.find(
-            ([url]) => String(url).includes("api/cognitive/log"),
-        );
+        const logCall = fetchSpy.mock.calls.find(([url]) => String(url).includes("api/cognitive/log"));
         expect(logCall).toBeDefined();
         const calledWithBody = JSON.parse(logCall![1]!.body as string);
         expect(calledWithBody.promptSlug).toBe("tagged-welcome");
@@ -197,11 +254,10 @@ describe("createCognitiveLayer extras", () => {
         expect(calledWithBody.metadata?.promptTag).toBe("production");
         expect(calledWithBody.metadata?.abTestId).toBe("ab-test-1");
         expect(calledWithBody.metadata?.variant).toBe("variant");
-
-        fetchSpy.mockRestore();
     });
 
     it("falls back to the original model when gateway model creation fails", async () => {
+        setupSnapshotAndLogFetch();
         promptHubMocks.resolvePrompt.mockResolvedValue({
             promptId: "prompt-3",
             slug: "gateway",
@@ -231,18 +287,19 @@ describe("createCognitiveLayer extras", () => {
 
         expect(errorSpy).toHaveBeenCalledWith(
             expect.stringContaining("Failed to create gateway model, falling back to original"),
-            expect.any(Error)
+            expect.any(Error),
         );
-        expect(aiMocks.streamText).toHaveBeenCalledWith(
+        expect(aiStreamText).toHaveBeenCalledWith(
             expect.objectContaining({
                 model: expect.objectContaining({ modelId: "mock-model" }),
-            })
+            }),
         );
     });
 
     it("falls back cleanly when prompt resolution fails", async () => {
-        promptHubMocks.resolvePrompt.mockRejectedValue(new Error("not found"));
+        setupSnapshotAndLogFetch();
         const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+        promptHubMocks.resolvePrompt.mockRejectedValue(new Error("not found"));
         const cl = makeLayer();
         const model = cl("mock-model", {
             userId: "user-1",
@@ -258,13 +315,13 @@ describe("createCognitiveLayer extras", () => {
 
         expect(warnSpy).toHaveBeenCalledWith(
             expect.stringContaining('Failed to resolve prompt "missing", generating without system prompt.'),
-            expect.any(Error)
+            expect.any(Error),
         );
-        expect(aiMocks.generateText).toHaveBeenCalledWith(
+        expect(aiGenerateText).toHaveBeenCalledWith(
             expect.objectContaining({
                 model: expect.objectContaining({ modelId: "mock-model" }),
-            })
+            }),
         );
-        expect(aiMocks.generateText.mock.calls[0][0]).not.toHaveProperty("system");
+        expect(vi.mocked(aiGenerateText).mock.calls[0][0]).not.toHaveProperty("system");
     });
 });