@kognitivedev/vercel-ai-provider 0.2.22 → 0.2.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kognitivedev/vercel-ai-provider",
-  "version": "0.2.22",
+  "version": "0.2.26",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {
@@ -8,13 +8,15 @@
   },
   "scripts": {
     "build": "tsc",
-    "dev": "tsc -w",
+    "dev": "tsc -w --noCheck",
     "test": "vitest run",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@kognitivedev/prompthub": "^0.2.22",
-    "@kognitivedev/shared": "^0.2.22"
+    "@kognitivedev/memory": "^0.2.26",
+    "@kognitivedev/prompthub": "^0.2.26",
+    "@kognitivedev/shared": "^0.2.26",
+    "@kognitivedev/tools": "^0.2.26"
   },
   "peerDependencies": {
     "ai": "^5.0.0 || ^6.0.0"

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

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import type { LanguageModel } from "ai";
 import { MockLanguageModelV3, convertArrayToReadableStream } from "ai/test";
+import { ModerationError } from "@kognitivedev/shared";
 
 const promptHubMocks = vi.hoisted(() => ({
     resolvePrompt: vi.fn(),
@@ -22,7 +23,11 @@ vi.mock("ai", async (importOriginal) => {
 });
 
 import { streamText as aiStreamText, generateText as aiGenerateText } from "ai";
-import { createCognitiveLayer } from "../index";
+import {
+    createCognitiveLayer,
+    toGeneratedMessageEventStream,
+    toMessageEventStream,
+} from "../index";
 
 function minimalFinishUsage() {
     return {
@@ -73,6 +78,12 @@ function setupSnapshotAndLogFetch() {
         if (urlStr.includes("/api/cognitive/log")) {
             return new Response(JSON.stringify({ ok: true }), { status: 201 });
         }
+        if (urlStr.includes("/api/cognitive/agent-run")) {
+            return new Response(JSON.stringify({ ok: true, runDbId: "run-db-1" }), { status: 200 });
+        }
+        if (urlStr.includes("/api/cognitive/trace-events")) {
+            return new Response(JSON.stringify({ ok: true, traceDbId: "trace-db-1" }), { status: 200 });
+        }
         if (urlStr.includes("/api/cognitive/process")) {
             return new Response(JSON.stringify({ ok: true }), { status: 200 });
         }
@@ -156,6 +167,61 @@ describe("createCognitiveLayer extras", () => {
         cl.clearSessionCache();
     });
 
+    it("supports direct system usage without a managed prompt", async () => {
+        setupSnapshotAndLogFetch();
+
+        const cl = makeLayer();
+        const model = cl("mock-model", {
+            userId: "user-1",
+            projectId: "project-1",
+            sessionId: "session-1",
+        });
+
+        await cl.streamText({
+            model,
+            system: "Direct system prompt",
+            messages: [{ role: "user", content: "Hi" }],
+        } as any);
+
+        expect(aiStreamText).toHaveBeenCalledWith(
+            expect.objectContaining({
+                system: "Direct system prompt",
+            }),
+        );
+        expect(promptHubMocks.resolvePrompt).not.toHaveBeenCalled();
+    });
+
+    it("optionally auto-injects the topic memory tool into cl.streamText", async () => {
+        setupSnapshotAndLogFetch();
+
+        const cl = makeLayer();
+        const model = cl("mock-model", {
+            userId: "user-1",
+            projectId: "project-1",
+            sessionId: "session-1",
+        });
+
+        await cl.streamText({
+            model,
+            system: "Direct system prompt",
+            messages: [{ role: "user", content: "What do you know about Evital?" }],
+            tools: {
+                weather: { description: "Weather tool" },
+            },
+            kognitive: { autoTopicMemoryTool: true },
+        } as any);
+
+        expect(aiStreamText).toHaveBeenCalledWith(expect.objectContaining({
+            tools: expect.objectContaining({
+                weather: expect.any(Object),
+                "get-topic-memory": expect.objectContaining({
+                    description: expect.stringContaining("Retrieve topic-scoped historical memory"),
+                    execute: expect.any(Function),
+                }),
+            }),
+        }));
+    });
+
     it("uses a gateway model when providerFactory is available", async () => {
         setupSnapshotAndLogFetch();
         promptHubMocks.resolvePrompt.mockResolvedValue({
@@ -194,6 +260,70 @@ describe("createCognitiveLayer extras", () => {
         );
     });
 
+    it("converts streamText fullStream into message events", async () => {
+        const stream = toMessageEventStream({
+            fullStream: (async function* () {
+                yield { type: "tool-call", toolCallId: "tool-1", toolName: "get-topic-memory", input: { entity: "Evital" } };
+                yield { type: "tool-result", toolCallId: "tool-1", toolName: "get-topic-memory", result: { summary: "Known details" } };
+                yield { type: "text-delta", delta: "Known details" };
+            })(),
+        });
+
+        const reader = stream.getReader();
+        const chunks: Array<{ event: string; data: unknown }> = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            chunks.push(value);
+        }
+
+        expect(chunks).toEqual([
+            {
+                event: "messages",
+                data: { type: "tool-call", id: "tool-1", name: "get-topic-memory", input: { entity: "Evital" } },
+            },
+            {
+                event: "messages",
+                data: { type: "tool-result", id: "tool-1", name: "get-topic-memory", result: { summary: "Known details" } },
+            },
+            {
+                event: "messages",
+                data: { token: "Known details" },
+            },
+        ]);
+    });
+
+    it("converts generateText results into message events", async () => {
+        const stream = toGeneratedMessageEventStream({
+            text: "Known details",
+            toolCalls: [{ toolCallId: "tool-1", toolName: "get-topic-memory", input: { entity: "Evital" } }],
+            toolResults: [{ toolCallId: "tool-1", toolName: "get-topic-memory", result: { summary: "Known details" } }],
+        });
+
+        const reader = stream.getReader();
+        const chunks: Array<{ event: string; data: unknown }> = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            chunks.push(value);
+        }
+
+        expect(chunks).toEqual([
+            {
+                event: "messages",
+                data: { type: "tool-call", id: "tool-1", name: "get-topic-memory", input: { entity: "Evital" } },
+            },
+            {
+                event: "messages",
+                data: { type: "tool-result", id: "tool-1", name: "get-topic-memory", result: { summary: "Known details" } },
+            },
+            {
+                event: "messages",
+                data: { token: "Known details" },
+            },
+        ]);
+    });
+
     it("passes prompt tag and stores tag/ab metadata in logging payload", async () => {
         const fetchSpy = setupSnapshotAndLogFetch();
 
@@ -324,4 +454,31 @@ describe("createCognitiveLayer extras", () => {
         );
         expect(vi.mocked(aiGenerateText).mock.calls[0][0]).not.toHaveProperty("system");
     });
+
+    it("rethrows moderation errors from prompt resolution", async () => {
+        setupSnapshotAndLogFetch();
+        promptHubMocks.resolvePrompt.mockRejectedValue(new ModerationError({
+            error: "USER_RESTRICTED",
+            code: "user_restricted",
+            kind: "restriction",
+            surface: "prompt_hub",
+            reasonCode: "policy_violation",
+            message: "Prompt blocked.",
+            retryable: false,
+            expiresAt: null,
+        }));
+
+        const cl = makeLayer();
+        const model = cl("mock-model", {
+            userId: "user-1",
+            projectId: "project-1",
+            sessionId: "session-1",
+        });
+
+        await expect(cl.generateText({
+            model,
+            messages: [{ role: "user", content: "Hi" }],
+            prompt: { slug: "blocked" },
+        } as any)).rejects.toBeInstanceOf(ModerationError);
+    });
 });

package/src/__tests__/wrap-stream-logging.test.ts

@@ -5,9 +5,13 @@ import { MockLanguageModelV3, convertArrayToReadableStream } from "ai/test";
 
 describe("wrapStream logging", () => {
     let fetchCalls: { url: string; body: any }[];
+    let traceEventCalls: { url: string; body: any }[];
+    let agentRunCalls: { url: string; body: any }[];
 
     beforeEach(() => {
         fetchCalls = [];
+        traceEventCalls = [];
+        agentRunCalls = [];
 
         vi.stubGlobal(
             "fetch",
@@ -27,6 +31,18 @@ describe("wrapStream logging", () => {
                     return new Response(JSON.stringify({ ok: true }), { status: 200 });
                 }
 
+                if (urlStr.includes("/api/cognitive/agent-run")) {
+                    const body = JSON.parse(init?.body as string);
+                    agentRunCalls.push({ url: urlStr, body });
+                    return new Response(JSON.stringify({ ok: true, runDbId: "run-db-1" }), { status: 200 });
+                }
+
+                if (urlStr.includes("/api/cognitive/trace-events")) {
+                    const body = JSON.parse(init?.body as string);
+                    traceEventCalls.push({ url: urlStr, body });
+                    return new Response(JSON.stringify({ ok: true, traceDbId: "trace-db-1" }), { status: 200 });
+                }
+
                 if (urlStr.includes("/api/cognitive/process")) {
                     return new Response(JSON.stringify({ ok: true }), { status: 200 });
                 }
@@ -106,7 +122,7 @@ describe("wrapStream logging", () => {
 
         const messages = logCall!.body.messages;
 
-        // Assistant message should contain text + tool-call parts
+        // Assistant message should contain the full replay-safe turn.
         const assistantMsg = messages.find((m: any) => m.role === "assistant");
         expect(assistantMsg).toBeDefined();
         expect(assistantMsg.content).toEqual([
@@ -117,12 +133,6 @@ describe("wrapStream logging", () => {
                 toolName: "get_weather",
                 input: '{"city":"London"}',
             },
-        ]);
-
-        // Tool results should be in a separate tool message
-        const toolMsg = messages.find((m: any) => m.role === "tool");
-        expect(toolMsg).toBeDefined();
-        expect(toolMsg.content).toEqual([
             {
                 type: "tool-result",
                 toolCallId: "call-1",
@@ -130,6 +140,7 @@ describe("wrapStream logging", () => {
                 result: { temperature: 15, unit: "celsius" },
             },
         ]);
+        expect(messages.some((m: any) => m.role === "tool")).toBe(false);
 
         // Spans should include the tool call with populated previews
         const spans = logCall!.body.spans;
@@ -138,6 +149,19 @@ describe("wrapStream logging", () => {
         expect(toolSpan.toolName).toBe("get_weather");
         expect(toolSpan.inputPreview).toContain("London");
         expect(toolSpan.outputPreview).toContain("15");
+        expect(traceEventCalls.some((call) => call.body.start)).toBe(true);
+        expect(traceEventCalls.some((call) =>
+            Array.isArray(call.body.events) &&
+            call.body.events.some((event: any) => event.eventType === "tool.started"))
+        ).toBe(true);
+        expect(traceEventCalls.some((call) =>
+            Array.isArray(call.body.events) &&
+            call.body.events.some((event: any) => event.eventType === "tool.completed"))
+        ).toBe(true);
+        expect(agentRunCalls).toHaveLength(2);
+        expect(agentRunCalls[0].body.status).toBe("running");
+        expect(agentRunCalls[1].body.status).toBe("running");
+        expect(agentRunCalls[0].body.runId).toBe(agentRunCalls[1].body.runId);
     });
 
     it("should include tool definitions in logged conversation when tools are present", async () => {
@@ -272,8 +296,126 @@ describe("wrapStream logging", () => {
         const messages = logCall!.body.messages;
         const assistantMsg = messages.find((m: any) => m.role === "assistant");
         expect(assistantMsg).toBeDefined();
-        expect(assistantMsg.content).toEqual([
-            { type: "text", text: "Hello world" },
-        ]);
+        expect(assistantMsg.content).toBe("Hello world");
+        expect(traceEventCalls.some((call) =>
+            Array.isArray(call.body.events) &&
+            call.body.events.some((event: any) => event.eventType === "assistant.progress"))
+        ).toBe(true);
+        expect(traceEventCalls.some((call) => call.body.finish?.state === "completed")).toBe(true);
+        expect(agentRunCalls).toHaveLength(2);
+        expect(agentRunCalls[0].body.runId).toBe(agentRunCalls[1].body.runId);
+        expect(logCall!.body.turnIndex).toBe(0);
+        expect(typeof logCall!.body.turnId).toBe("string");
+    });
+
+    it("reuses one session run but increments turn metadata per turn", async () => {
+        const makeModel = () =>
+            new MockLanguageModelV3({
+                doStream: async () => ({
+                    stream: convertArrayToReadableStream([
+                        { type: "text-start" as const, id: "t1" },
+                        { type: "text-delta" as const, id: "t1", delta: "Hello" },
+                        { type: "text-end" as const, id: "t1" },
+                        {
+                            type: "finish" as const,
+                            finishReason: { unified: "stop" as const, raw: undefined },
+                            usage: {
+                                inputTokens: { total: 10, noCache: undefined, cacheRead: undefined, cacheWrite: undefined },
+                                outputTokens: { total: 5, text: undefined, reasoning: undefined },
+                            },
+                        },
+                    ] satisfies import("@ai-sdk/provider").LanguageModelV3StreamPart[]),
+                }),
+            });
+
+        const cl = createCognitiveLayer({
+            provider: () => makeModel(),
+            clConfig: {
+                apiKey: "test-api-key",
+                appId: "test-app",
+                projectId: "test-project",
+                processDelayMs: 0,
+                logLevel: "none",
+            },
+        });
+
+        const model = cl("mock-model", {
+            userId: "user-1",
+            projectId: "project-1",
+            sessionId: "session-1",
+        });
+
+        await streamText({ model, messages: [{ role: "user", content: "first" }] }).text;
+        await streamText({ model, messages: [{ role: "user", content: "second" }] }).text;
+        await new Promise((r) => setTimeout(r, 100));
+
+        const logCalls = fetchCalls.filter((call) => call.url.includes("/api/cognitive/log"));
+        const runCalls = agentRunCalls.filter((call) => call.url.includes("/api/cognitive/agent-run"));
+
+        expect(logCalls).toHaveLength(2);
+        expect(logCalls.map((call) => call.body.turnIndex)).toEqual([0, 1]);
+        expect(new Set(logCalls.map((call) => call.body.turnId)).size).toBe(2);
+        expect(new Set(runCalls.map((call) => call.body.runId)).size).toBe(1);
+    });
+
+    it("forwards automatic thread title config from providerOptions to the log payload", async () => {
+        const mockModel = new MockLanguageModelV3({
+            doStream: async () => ({
+                stream: convertArrayToReadableStream([
+                    { type: "text-start" as const, id: "t1" },
+                    { type: "text-delta" as const, id: "t1", delta: "Knowledge base ready" },
+                    { type: "text-end" as const, id: "t1" },
+                    {
+                        type: "finish" as const,
+                        finishReason: { unified: "stop" as const, raw: undefined },
+                        usage: {
+                            inputTokens: { total: 12, noCache: undefined, cacheRead: undefined, cacheWrite: undefined },
+                            outputTokens: { total: 4, text: undefined, reasoning: undefined },
+                        },
+                    },
+                ] satisfies import("@ai-sdk/provider").LanguageModelV3StreamPart[]),
+            }),
+        });
+
+        const cl = createCognitiveLayer({
+            provider: () => mockModel,
+            clConfig: {
+                apiKey: "test-api-key",
+                appId: "test-app",
+                projectId: "test-project",
+                processDelayMs: 0,
+                logLevel: "none",
+            },
+        });
+
+        const model = cl("mock-model", {
+            userId: "user-1",
+            projectId: "project-1",
+            sessionId: "session-1",
+        });
+
+        await streamText({
+            model,
+            messages: [{ role: "user", content: "Search the knowledge base for onboarding docs" }],
+            providerOptions: {
+                kognitive: {
+                    automaticTitle: {
+                        trigger: "first-message",
+                        strategy: "first-message",
+                        maxLength: 60,
+                    },
+                },
+            },
+        }).text;
+
+        await new Promise((r) => setTimeout(r, 100));
+
+        const logCall = fetchCalls.find((call) => call.url.includes("/api/cognitive/log"));
+        expect(logCall).toBeDefined();
+        expect(logCall!.body.automaticTitle).toEqual({
+            trigger: "first-message",
+            strategy: "first-message",
+            maxLength: 60,
+        });
     });
 });