@kognitivedev/vercel-ai-provider 0.2.22 → 0.2.26

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @kognitivedev/vercel-ai-provider
 
+## 0.2.26
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/memory@0.2.26
+  - @kognitivedev/prompthub@0.2.26
+  - @kognitivedev/shared@0.2.26
+  - @kognitivedev/tools@0.2.26
+
+## 0.2.25
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/memory@0.2.25
+  - @kognitivedev/prompthub@0.2.25
+  - @kognitivedev/shared@0.2.25
+  - @kognitivedev/tools@0.2.25
+
+## 0.2.24
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/memory@0.2.24
+  - @kognitivedev/prompthub@0.2.24
+  - @kognitivedev/shared@0.2.24
+  - @kognitivedev/tools@0.2.24
+
+## 0.2.23
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/memory@0.2.23
+  - @kognitivedev/prompthub@0.2.23
+  - @kognitivedev/shared@0.2.23
+  - @kognitivedev/tools@0.2.23
+
 ## 0.2.22
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,8 @@
 # @kognitivedev/vercel-ai-provider
 
-Vercel AI SDK provider wrapper that integrates the Kognitive memory layer into your AI applications. Automatically injects memory context and logs conversations for memory processing.
+Vercel AI SDK provider wrapper that integrates the Kognitive memory layer into your AI applications. It injects memory context, emits live turn traces, and logs finalized conversation snapshots back to the backend.
+
+For new runs, the provider can also emit incremental live trace milestones to the backend while a generation or stream is still in progress.
 
 ## Installation
 
@@ -28,8 +30,9 @@ const cl = createCognitiveLayer({
     provider: openai,
     clConfig: {
         appId: "my-app",
-        defaultAgentId: "assistant",
-        baseUrl: "http://localhost:3001"
+        projectId: "project-123",
+        baseUrl: "http://localhost:3001",
+        apiKey: process.env.COGNITIVE_API_KEY!,
     }
 });
 
@@ -37,12 +40,18 @@ const cl = createCognitiveLayer({
 const { text } = await generateText({
     model: cl("gpt-4o", {
         userId: "user-123",
-        sessionId: "session-abc"
+        sessionId: "session-abc",
     }),
     prompt: "What's my favorite color?"
 });
 ```
 
+For tracing, treat `projectId` and `sessionId` as required. Regular chat integrations now follow:
+
+- `1 session -> 1 agent_run -> many turn traces`
+- each completed turn writes its own `conversation_snapshot`
+- each turn emits its own live `trace-events`
+
 ## Configuration
 
 ### `CognitiveLayerConfig`
@@ -156,6 +165,22 @@ interface PromptConfig {
 
 ## Usage Examples
 
+## Live Trace Events
+
+When `userId`, `projectId`, and `sessionId` are available, the provider now uses three complementary backend paths:
+
+- `POST /api/cognitive/agent-run` to ensure or update the logical run
+- `POST /api/cognitive/trace-events` for append-only live milestones such as trace start, assistant progress, and tool completion
+- `POST /api/cognitive/log` for the finalized conversation snapshot after the turn completes
+
+For chat apps, the provider reuses one session-scoped run for the lifetime of the session and emits one new trace per turn.
+
+This is additive:
+
+- existing memory logging behavior stays the same
+- old traces without live events remain valid
+- dashboards normalize both legacy traces and event-backed traces into one read model
+
 ### With OpenAI
 
 ```typescript

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

@@ -1,7 +1,21 @@
 "use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
 const test_1 = require("ai/test");
+const shared_1 = require("@kognitivedev/shared");
 const promptHubMocks = vitest_1.vi.hoisted(() => ({
     resolvePrompt: vitest_1.vi.fn(),
 }));
@@ -59,6 +73,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 });
         }
@@ -121,6 +141,51 @@ function makeLayer(overrides) {
         cl.clearSessionCache("user-1:project-1:session-1");
         cl.clearSessionCache();
     });
+    (0, vitest_1.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" }],
+        });
+        (0, vitest_1.expect)(ai_1.streamText).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            system: "Direct system prompt",
+        }));
+        (0, vitest_1.expect)(promptHubMocks.resolvePrompt).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.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 },
+        });
+        (0, vitest_1.expect)(ai_1.streamText).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            tools: vitest_1.expect.objectContaining({
+                weather: vitest_1.expect.any(Object),
+                "get-topic-memory": vitest_1.expect.objectContaining({
+                    description: vitest_1.expect.stringContaining("Retrieve topic-scoped historical memory"),
+                    execute: vitest_1.expect.any(Function),
+                }),
+            }),
+        }));
+    });
     (0, vitest_1.it)("uses a gateway model when providerFactory is available", async () => {
         setupSnapshotAndLogFetch();
         promptHubMocks.resolvePrompt.mockResolvedValue({
@@ -150,6 +215,68 @@ function makeLayer(overrides) {
             system: "Prompt body",
         }));
     });
+    (0, vitest_1.it)("converts streamText fullStream into message events", async () => {
+        const stream = (0, index_1.toMessageEventStream)({
+            fullStream: (function () {
+                return __asyncGenerator(this, arguments, function* () {
+                    yield yield __await({ type: "tool-call", toolCallId: "tool-1", toolName: "get-topic-memory", input: { entity: "Evital" } });
+                    yield yield __await({ type: "tool-result", toolCallId: "tool-1", toolName: "get-topic-memory", result: { summary: "Known details" } });
+                    yield yield __await({ type: "text-delta", delta: "Known details" });
+                });
+            })(),
+        });
+        const reader = stream.getReader();
+        const chunks = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+        }
+        (0, vitest_1.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" },
+            },
+        ]);
+    });
+    (0, vitest_1.it)("converts generateText results into message events", async () => {
+        const stream = (0, index_1.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 = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+        }
+        (0, vitest_1.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" },
+            },
+        ]);
+    });
     (0, vitest_1.it)("passes prompt tag and stores tag/ab metadata in logging payload", async () => {
         var _a, _b, _c, _d;
         const fetchSpy = setupSnapshotAndLogFetch();
@@ -256,4 +383,28 @@ function makeLayer(overrides) {
         }));
         (0, vitest_1.expect)(vitest_1.vi.mocked(ai_1.generateText).mock.calls[0][0]).not.toHaveProperty("system");
     });
+    (0, vitest_1.it)("rethrows moderation errors from prompt resolution", async () => {
+        setupSnapshotAndLogFetch();
+        promptHubMocks.resolvePrompt.mockRejectedValue(new shared_1.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 (0, vitest_1.expect)(cl.generateText({
+            model,
+            messages: [{ role: "user", content: "Hi" }],
+            prompt: { slug: "blocked" },
+        })).rejects.toBeInstanceOf(shared_1.ModerationError);
+    });
 });

package/dist/__tests__/wrap-stream-logging.test.js

@@ -6,8 +6,12 @@ const ai_1 = require("ai");
 const test_1 = require("ai/test");
 (0, vitest_1.describe)("wrapStream logging", () => {
     let fetchCalls;
+    let traceEventCalls;
+    let agentRunCalls;
     (0, vitest_1.beforeEach)(() => {
         fetchCalls = [];
+        traceEventCalls = [];
+        agentRunCalls = [];
         vitest_1.vi.stubGlobal("fetch", vitest_1.vi.fn(async (url, init) => {
             const urlStr = typeof url === "string" ? url : url.toString();
             if (urlStr.includes("/api/cognitive/snapshot")) {
@@ -18,6 +22,16 @@ const test_1 = require("ai/test");
                 fetchCalls.push({ url: urlStr, body });
                 return new Response(JSON.stringify({ ok: true }), { status: 200 });
             }
+            if (urlStr.includes("/api/cognitive/agent-run")) {
+                const body = JSON.parse(init === null || init === void 0 ? void 0 : init.body);
+                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 === null || init === void 0 ? void 0 : init.body);
+                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 });
             }
@@ -85,7 +99,7 @@ const test_1 = require("ai/test");
         const logCall = fetchCalls.find((c) => c.url.includes("/api/cognitive/log"));
         (0, vitest_1.expect)(logCall).toBeDefined();
         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) => m.role === "assistant");
         (0, vitest_1.expect)(assistantMsg).toBeDefined();
         (0, vitest_1.expect)(assistantMsg.content).toEqual([
@@ -96,11 +110,6 @@ const test_1 = require("ai/test");
                 toolName: "get_weather",
                 input: '{"city":"London"}',
             },
-        ]);
-        // Tool results should be in a separate tool message
-        const toolMsg = messages.find((m) => m.role === "tool");
-        (0, vitest_1.expect)(toolMsg).toBeDefined();
-        (0, vitest_1.expect)(toolMsg.content).toEqual([
             {
                 type: "tool-result",
                 toolCallId: "call-1",
@@ -108,6 +117,7 @@ const test_1 = require("ai/test");
                 result: { temperature: 15, unit: "celsius" },
             },
         ]);
+        (0, vitest_1.expect)(messages.some((m) => m.role === "tool")).toBe(false);
         // Spans should include the tool call with populated previews
         const spans = logCall.body.spans;
         const toolSpan = spans === null || spans === void 0 ? void 0 : spans.find((s) => s.spanType === "tool");
@@ -115,6 +125,15 @@ const test_1 = require("ai/test");
         (0, vitest_1.expect)(toolSpan.toolName).toBe("get_weather");
         (0, vitest_1.expect)(toolSpan.inputPreview).toContain("London");
         (0, vitest_1.expect)(toolSpan.outputPreview).toContain("15");
+        (0, vitest_1.expect)(traceEventCalls.some((call) => call.body.start)).toBe(true);
+        (0, vitest_1.expect)(traceEventCalls.some((call) => Array.isArray(call.body.events) &&
+            call.body.events.some((event) => event.eventType === "tool.started"))).toBe(true);
+        (0, vitest_1.expect)(traceEventCalls.some((call) => Array.isArray(call.body.events) &&
+            call.body.events.some((event) => event.eventType === "tool.completed"))).toBe(true);
+        (0, vitest_1.expect)(agentRunCalls).toHaveLength(2);
+        (0, vitest_1.expect)(agentRunCalls[0].body.status).toBe("running");
+        (0, vitest_1.expect)(agentRunCalls[1].body.status).toBe("running");
+        (0, vitest_1.expect)(agentRunCalls[0].body.runId).toBe(agentRunCalls[1].body.runId);
     });
     (0, vitest_1.it)("should include tool definitions in logged conversation when tools are present", async () => {
         const mockModel = new test_1.MockLanguageModelV3({
@@ -231,8 +250,111 @@ const test_1 = require("ai/test");
         const messages = logCall.body.messages;
         const assistantMsg = messages.find((m) => m.role === "assistant");
         (0, vitest_1.expect)(assistantMsg).toBeDefined();
-        (0, vitest_1.expect)(assistantMsg.content).toEqual([
-            { type: "text", text: "Hello world" },
-        ]);
+        (0, vitest_1.expect)(assistantMsg.content).toBe("Hello world");
+        (0, vitest_1.expect)(traceEventCalls.some((call) => Array.isArray(call.body.events) &&
+            call.body.events.some((event) => event.eventType === "assistant.progress"))).toBe(true);
+        (0, vitest_1.expect)(traceEventCalls.some((call) => { var _a; return ((_a = call.body.finish) === null || _a === void 0 ? void 0 : _a.state) === "completed"; })).toBe(true);
+        (0, vitest_1.expect)(agentRunCalls).toHaveLength(2);
+        (0, vitest_1.expect)(agentRunCalls[0].body.runId).toBe(agentRunCalls[1].body.runId);
+        (0, vitest_1.expect)(logCall.body.turnIndex).toBe(0);
+        (0, vitest_1.expect)(typeof logCall.body.turnId).toBe("string");
+    });
+    (0, vitest_1.it)("reuses one session run but increments turn metadata per turn", async () => {
+        const makeModel = () => new test_1.MockLanguageModelV3({
+            doStream: async () => ({
+                stream: (0, test_1.convertArrayToReadableStream)([
+                    { type: "text-start", id: "t1" },
+                    { type: "text-delta", id: "t1", delta: "Hello" },
+                    { type: "text-end", id: "t1" },
+                    {
+                        type: "finish",
+                        finishReason: { unified: "stop", raw: undefined },
+                        usage: {
+                            inputTokens: { total: 10, noCache: undefined, cacheRead: undefined, cacheWrite: undefined },
+                            outputTokens: { total: 5, text: undefined, reasoning: undefined },
+                        },
+                    },
+                ]),
+            }),
+        });
+        const cl = (0, index_1.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 (0, ai_1.streamText)({ model, messages: [{ role: "user", content: "first" }] }).text;
+        await (0, ai_1.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"));
+        (0, vitest_1.expect)(logCalls).toHaveLength(2);
+        (0, vitest_1.expect)(logCalls.map((call) => call.body.turnIndex)).toEqual([0, 1]);
+        (0, vitest_1.expect)(new Set(logCalls.map((call) => call.body.turnId)).size).toBe(2);
+        (0, vitest_1.expect)(new Set(runCalls.map((call) => call.body.runId)).size).toBe(1);
+    });
+    (0, vitest_1.it)("forwards automatic thread title config from providerOptions to the log payload", async () => {
+        const mockModel = new test_1.MockLanguageModelV3({
+            doStream: async () => ({
+                stream: (0, test_1.convertArrayToReadableStream)([
+                    { type: "text-start", id: "t1" },
+                    { type: "text-delta", id: "t1", delta: "Knowledge base ready" },
+                    { type: "text-end", id: "t1" },
+                    {
+                        type: "finish",
+                        finishReason: { unified: "stop", raw: undefined },
+                        usage: {
+                            inputTokens: { total: 12, noCache: undefined, cacheRead: undefined, cacheWrite: undefined },
+                            outputTokens: { total: 4, text: undefined, reasoning: undefined },
+                        },
+                    },
+                ]),
+            }),
+        });
+        const cl = (0, index_1.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 (0, ai_1.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"));
+        (0, vitest_1.expect)(logCall).toBeDefined();
+        (0, vitest_1.expect)(logCall.body.automaticTitle).toEqual({
+            trigger: "first-message",
+            strategy: "first-message",
+            maxLength: 60,
+        });
     });
 });

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { streamText as aiStreamText, generateText as aiGenerateText, type LanguageModel } from "ai";
+import { type AutomaticThreadTitleConfig } from "@kognitivedev/shared";
 export { renderTemplate, type TemplateVariables } from "./template";
 /**
  * Log levels for controlling verbosity of CognitiveLayer logging.
@@ -40,11 +41,16 @@ export interface PromptConfig {
     variables?: Record<string, string | boolean>;
     tag?: string;
 }
-export type CLStreamTextOptions = Omit<Parameters<typeof aiStreamText>[0], 'system' | 'prompt'> & {
-    prompt: PromptConfig;
+export interface CognitiveToolOptions {
+    autoTopicMemoryTool?: boolean;
+}
+export type CLStreamTextOptions = Omit<Parameters<typeof aiStreamText>[0], 'prompt'> & {
+    prompt?: PromptConfig;
+    kognitive?: CognitiveToolOptions;
 };
-export type CLGenerateTextOptions = Omit<Parameters<typeof aiGenerateText>[0], 'system' | 'prompt'> & {
-    prompt: PromptConfig;
+export type CLGenerateTextOptions = Omit<Parameters<typeof aiGenerateText>[0], 'prompt'> & {
+    prompt?: PromptConfig;
+    kognitive?: CognitiveToolOptions;
 };
 export interface LogConversationPayload {
     userId: string;
@@ -74,6 +80,8 @@ export interface LogConversationPayload {
         parameters?: Record<string, unknown>;
     }>;
     agentRunId?: string;
+    turnId?: string;
+    turnIndex?: number;
     metadata?: Record<string, unknown>;
     spans?: Array<{
         spanKey: string;
@@ -87,6 +95,10 @@ export interface LogConversationPayload {
         errorMessage?: string;
         metadata?: Record<string, unknown>;
     }>;
+    automaticTitle?: AutomaticThreadTitleConfig;
+}
+interface LogConversationResult {
+    generatedTitle: string | null;
 }
 export type CognitiveLayer = CLModelWrapper & {
     streamText: (options: CLStreamTextOptions) => Promise<ReturnType<typeof aiStreamText>>;
@@ -95,7 +107,7 @@ export type CognitiveLayer = CLModelWrapper & {
         userId?: string;
         tag?: string;
     }) => Promise<CachedPrompt>;
-    logConversation: (payload: LogConversationPayload) => Promise<void>;
+    logConversation: (payload: LogConversationPayload) => Promise<LogConversationResult | null>;
     triggerProcessing: (userId: string, sessionId: string) => void;
     clearSessionCache: (sessionKey?: string) => void;
 };
@@ -110,6 +122,44 @@ export interface CachedPrompt {
     abTestId?: string;
     variant?: "control" | "variant";
 }
+export declare function toMessageEventStream(result: {
+    fullStream: AsyncIterable<any>;
+}): ReadableStream<{
+    event: string;
+    data: unknown;
+}>;
+export declare function toGeneratedMessageEventStream(result: {
+    text?: string;
+    toolCalls?: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        input?: unknown;
+    }>;
+    toolResults?: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        output?: unknown;
+        result?: unknown;
+        isError?: boolean;
+    }>;
+    steps?: Array<{
+        toolCalls?: Array<{
+            toolCallId?: string;
+            toolName?: string;
+            input?: unknown;
+        }>;
+        toolResults?: Array<{
+            toolCallId?: string;
+            toolName?: string;
+            output?: unknown;
+            result?: unknown;
+            isError?: boolean;
+        }>;
+    }>;
+}): ReadableStream<{
+    event: string;
+    data: unknown;
+}>;
 export declare function createCognitiveLayer(config: {
     provider: any;
     clConfig: CognitiveLayerConfig;