@kognitivedev/vercel-ai-provider 0.1.8 → 0.2.0

package/dist/index.js

@@ -11,14 +11,31 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTemplate = void 0;
 exports.createCognitiveLayer = createCognitiveLayer;
 const ai_1 = require("ai");
+const crypto_1 = require("crypto");
+var template_1 = require("./template");
+Object.defineProperty(exports, "renderTemplate", { enumerable: true, get: function () { return template_1.renderTemplate; } });
+const template_2 = require("./template");
 function isValidId(value) {
     if (value == null || typeof value !== "string")
         return false;
     const trimmed = value.trim();
     return trimmed !== "" && trimmed !== "null" && trimmed !== "undefined";
 }
+function maskSecret(secret) {
+    if (!secret)
+        return "missing";
+    if (secret.length <= 8)
+        return `${secret.slice(0, 2)}***`;
+    return `${secret.slice(0, 4)}...${secret.slice(-4)}`;
+}
+function previewText(value, maxLength = 240) {
+    if (value.length <= maxLength)
+        return value;
+    return `${value.slice(0, maxLength)}...`;
+}
 const LOG_LEVEL_PRIORITY = {
     none: 0,
     error: 1,
@@ -55,12 +72,91 @@ function createLogger(logLevel) {
     };
 }
 const PROMPT_CACHE_TTL_MS = 60000; // 1 minute
+function getContentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.map((part) => {
+        if (!part || typeof part !== "object")
+            return "";
+        if (typeof part.text === "string")
+            return part.text;
+        if (part.type === "tool-call" && typeof part.toolName === "string")
+            return `Called ${part.toolName}`;
+        if (part.type === "tool-result")
+            return "Received tool result";
+        return "";
+    }).filter(Boolean).join(" ");
+}
 /**
- * Interpolate {{variable}} placeholders in a template string.
- * Unmatched variables are left as-is.
+ * Unwraps V2/V3 ToolResultOutput discriminated union to a displayable value.
+ * Stream ToolResult uses plain `result` (passthrough), while prompt ToolResultPart
+ * uses `output` with a discriminated union: text, json, error-text, error-json, content, execution-denied.
  */
-function interpolateTemplate(content, variables) {
-    return content.replace(/\{\{(\w+)\}\}/g, (_, key) => { var _a; return (_a = variables[key]) !== null && _a !== void 0 ? _a : `{{${key}}}`; });
+function extractOutputValue(raw) {
+    var _a;
+    if (raw == null)
+        return raw;
+    if (typeof raw !== 'object')
+        return raw;
+    const obj = raw;
+    if (typeof obj.type !== 'string')
+        return raw;
+    switch (obj.type) {
+        case 'text':
+        case 'json':
+        case 'error-text':
+        case 'error-json':
+        case 'content':
+            return obj.value;
+        case 'execution-denied':
+            return `Execution denied: ${(_a = obj.reason) !== null && _a !== void 0 ? _a : 'unknown'}`;
+        default:
+            return raw;
+    }
+}
+function buildTracePreviews(messages) {
+    const request = [...messages].reverse().find((message) => (message === null || message === void 0 ? void 0 : message.role) === "user");
+    const response = [...messages].reverse().find((message) => (message === null || message === void 0 ? void 0 : message.role) === "assistant");
+    return {
+        requestPreview: request ? getContentText(request.content).slice(0, 220) : "No request captured",
+        responsePreview: response ? getContentText(response.content).slice(0, 240) : "No response captured",
+    };
+}
+function buildTraceSpansFromMessages(messages) {
+    var _a, _b;
+    const resultMap = new Map();
+    for (const message of messages) {
+        if (!Array.isArray(message === null || message === void 0 ? void 0 : message.content))
+            continue;
+        for (const part of message.content) {
+            if ((part === null || part === void 0 ? void 0 : part.type) === "tool-result" && typeof part.toolCallId === "string") {
+                resultMap.set(part.toolCallId, (_a = part.result) !== null && _a !== void 0 ? _a : part.output);
+            }
+        }
+    }
+    const spans = [];
+    for (const message of messages) {
+        if (!Array.isArray(message === null || message === void 0 ? void 0 : message.content))
+            continue;
+        for (const part of message.content) {
+            if ((part === null || part === void 0 ? void 0 : part.type) === "tool-call" && typeof part.toolCallId === "string") {
+                const result = resultMap.get(part.toolCallId);
+                spans.push({
+                    spanKey: part.toolCallId,
+                    parentSpanKey: "root",
+                    name: typeof part.toolName === "string" ? part.toolName : "tool",
+                    spanType: "tool",
+                    status: "completed",
+                    inputPreview: JSON.stringify((_b = part.input) !== null && _b !== void 0 ? _b : {}).slice(0, 220),
+                    outputPreview: result != null ? JSON.stringify(extractOutputValue(result)).slice(0, 220) : "No tool result captured",
+                    toolName: typeof part.toolName === "string" ? part.toolName : undefined,
+                });
+            }
+        }
+    }
+    return spans;
 }
 // Session-scoped snapshot cache: sessionKey → formatted memory block
 const sessionSnapshots = new Map();
@@ -101,6 +197,7 @@ function createCognitiveLayer(config) {
     // Prompt cache: slug → CachedPrompt
     const promptCache = new Map();
     const resolvePrompt = async (slug, userId) => {
+        var _a;
         const cacheKey = userId ? `${slug}:${userId}` : slug;
         const cached = promptCache.get(cacheKey);
         if (cached && Date.now() - cached.fetchedAt < PROMPT_CACHE_TTL_MS) {
@@ -111,11 +208,31 @@ function createCognitiveLayer(config) {
         url.searchParams.set("slug", slug);
         if (userId)
             url.searchParams.set("userId", userId);
+        logger.debug("Resolving prompt from backend", {
+            slug,
+            userId,
+            url: url.toString(),
+            baseUrl,
+            apiKeyHint: maskSecret(clConfig.apiKey),
+        });
         const res = await fetch(url.toString(), {
             headers: { "Authorization": `Bearer ${clConfig.apiKey}` },
         });
+        logger.debug("Prompt resolve response received", {
+            slug,
+            userId,
+            status: res.status,
+            ok: res.ok,
+            contentType: res.headers.get("content-type"),
+        });
         if (!res.ok) {
             const body = await res.text();
+            logger.debug("Prompt resolve response body preview", {
+                slug,
+                userId,
+                status: res.status,
+                bodyPreview: previewText(body),
+            });
             throw new Error(`Failed to resolve prompt "${slug}": ${res.status} ${body}`);
         }
         const data = await res.json();
@@ -128,6 +245,14 @@ function createCognitiveLayer(config) {
             gatewaySlug: data.gatewaySlug,
         };
         promptCache.set(cacheKey, entry);
+        logger.debug("Prompt resolved payload", {
+            slug,
+            resolvedSlug: entry.slug,
+            version: entry.version,
+            promptId: entry.promptId,
+            contentLength: entry.content.length,
+            gatewaySlug: (_a = entry.gatewaySlug) !== null && _a !== void 0 ? _a : null,
+        });
         logger.info("Prompt resolved", { slug, version: entry.version });
         return entry;
     };
@@ -194,9 +319,25 @@ function createCognitiveLayer(config) {
             if (systemPromptToAdd === undefined) {
                 try {
                     const url = `${baseUrl}/api/cognitive/snapshot?userId=${userId}`;
+                    logger.debug("Fetching snapshot from backend", {
+                        userId,
+                        projectId,
+                        sessionId,
+                        url,
+                        baseUrl,
+                        apiKeyHint: maskSecret(clConfig.apiKey),
+                    });
                     const res = await fetch(url, {
                         headers: { "Authorization": `Bearer ${clConfig.apiKey}` },
                     });
+                    logger.debug("Snapshot response received", {
+                        userId,
+                        projectId,
+                        sessionId,
+                        status: res.status,
+                        ok: res.ok,
+                        contentType: res.headers.get("content-type"),
+                    });
                     if (res.ok) {
                         const data = await res.json();
                         const systemBlock = data.systemBlock || "";
@@ -229,7 +370,15 @@ ${userContextBlock || "None"}
                         });
                     }
                     else {
+                        const body = await res.text();
                         logger.warn("Snapshot fetch failed", { status: res.status });
+                        logger.debug("Snapshot response body preview", {
+                            userId,
+                            projectId,
+                            sessionId,
+                            status: res.status,
+                            bodyPreview: previewText(body),
+                        });
                         systemPromptToAdd = "";
                         sessionSnapshots.set(sessionKey, systemPromptToAdd);
                     }
@@ -255,7 +404,8 @@ ${userContextBlock || "None"}
             return Object.assign(Object.assign({}, nextParams), { prompt: messagesWithMemory });
         },
         async wrapGenerate({ doGenerate, params }) {
-            var _a, _b;
+            var _a;
+            const startedAt = new Date();
             let result;
             try {
                 result = await doGenerate();
@@ -266,28 +416,57 @@ ${userContextBlock || "None"}
                 throw err;
             }
             if (isValidId(userId) && isValidId(sessionId)) {
+                const endedAt = new Date();
                 const sessionKey = `${userId}:${projectId}:${sessionId}`;
                 const promptMeta = sessionPromptMetadata.get(sessionKey);
-                const messagesInput = params.messages || params.prompt || [];
-                const resultMessages = (_b = result === null || result === void 0 ? void 0 : result.response) === null || _b === void 0 ? void 0 : _b.messages;
-                const assistantMessage = (result === null || result === void 0 ? void 0 : result.text)
-                    ? [{ role: "assistant", content: [{ type: "text", text: result.text }] }]
+                const messagesInput = params.prompt || params.messages || [];
+                // Build assistant message from result.content (V2/V3 GenerateResult)
+                const resultContent = Array.isArray(result === null || result === void 0 ? void 0 : result.content) ? result.content : [];
+                const assistantParts = [];
+                for (const part of resultContent) {
+                    if ((part === null || part === void 0 ? void 0 : part.type) === 'text') {
+                        assistantParts.push({ type: 'text', text: part.text });
+                    }
+                    else if ((part === null || part === void 0 ? void 0 : part.type) === 'tool-call') {
+                        assistantParts.push({
+                            type: 'tool-call',
+                            toolCallId: part.toolCallId,
+                            toolName: part.toolName,
+                            input: part.input,
+                        });
+                    }
+                    else if ((part === null || part === void 0 ? void 0 : part.type) === 'tool-result') {
+                        assistantParts.push({
+                            type: 'tool-result',
+                            toolCallId: part.toolCallId,
+                            toolName: part.toolName,
+                            result: part.result,
+                        });
+                    }
+                }
+                const assistantMessage = assistantParts.length > 0
+                    ? [{ role: "assistant", content: assistantParts }]
                     : [];
-                const finalMessages = Array.isArray(resultMessages) && resultMessages.length > 0
-                    ? resultMessages
-                    : [...messagesInput, ...assistantMessage];
-                logConversation(Object.assign({ userId,
+                const finalMessages = [...messagesInput, ...assistantMessage];
+                const { requestPreview, responsePreview } = buildTracePreviews(finalMessages);
+                const spans = buildTraceSpansFromMessages(finalMessages);
+                logConversation(Object.assign(Object.assign({ userId,
                     projectId,
                     sessionId, messages: finalMessages, modelId, usage: result.usage }, (promptMeta && {
                     promptSlug: promptMeta.promptSlug,
                     promptVersion: promptMeta.promptVersion,
                     promptId: promptMeta.promptId,
-                }))).then(() => triggerProcessing(userId, projectId, sessionId));
+                })), { traceId: (0, crypto_1.randomUUID)(), requestPreview,
+                    responsePreview, state: "completed", startedAt: startedAt.toISOString(), endedAt: endedAt.toISOString(), durationMs: endedAt.getTime() - startedAt.getTime(), metadata: {
+                        appId: clConfig.appId,
+                    }, spans })).then(() => triggerProcessing(userId, projectId, sessionId));
             }
             return result;
         },
         async wrapStream({ doStream, params }) {
             var _a;
+            const startedAt = new Date();
+            const traceId = (0, crypto_1.randomUUID)();
             let result;
             try {
                 logger.debug("Starting doStream with params", JSON.stringify(params, null, 2));
@@ -302,13 +481,16 @@ ${userContextBlock || "None"}
             if (isValidId(userId) && isValidId(sessionId)) {
                 const sessionKey = `${userId}:${projectId}:${sessionId}`;
                 const promptMeta = sessionPromptMetadata.get(sessionKey);
-                const messagesInput = params.messages || params.prompt || [];
+                const messagesInput = params.prompt || params.messages || [];
                 const resultMessages = (_a = result === null || result === void 0 ? void 0 : result.response) === null || _a === void 0 ? void 0 : _a.messages;
                 const finalMessages = Array.isArray(resultMessages) && resultMessages.length > 0
                     ? resultMessages
                     : messagesInput;
                 let streamUsage;
                 let accumulatedText = '';
+                const toolCallInputs = new Map();
+                const completedToolCalls = [];
+                const completedToolResults = [];
                 const originalStream = result.stream;
                 const transformStream = new TransformStream({
                     transform(chunk, controller) {
@@ -318,19 +500,72 @@ ${userContextBlock || "None"}
                         if (chunk.type === 'finish' && chunk.usage) {
                             streamUsage = chunk.usage;
                         }
+                        // Capture tool-call stream chunks (V2/V3 shared types)
+                        if (chunk.type === 'tool-input-start') {
+                            toolCallInputs.set(chunk.id, { toolName: chunk.toolName, chunks: [] });
+                        }
+                        if (chunk.type === 'tool-input-delta') {
+                            const entry = toolCallInputs.get(chunk.id);
+                            if (entry)
+                                entry.chunks.push(chunk.delta);
+                        }
+                        if (chunk.type === 'tool-call') {
+                            completedToolCalls.push({
+                                type: 'tool-call',
+                                toolCallId: chunk.toolCallId,
+                                toolName: chunk.toolName,
+                                input: chunk.input,
+                            });
+                        }
+                        if (chunk.type === 'tool-result') {
+                            completedToolResults.push({
+                                type: 'tool-result',
+                                toolCallId: chunk.toolCallId,
+                                toolName: chunk.toolName,
+                                result: chunk.result,
+                            });
+                        }
                         controller.enqueue(chunk);
                     },
-                    flush() {
-                        const allMessages = accumulatedText
-                            ? [...finalMessages, { role: "assistant", content: [{ type: "text", text: accumulatedText }] }]
+                    async flush() {
+                        const endedAt = new Date();
+                        // Finalize any tool calls from incremental input chunks
+                        for (const [id, entry] of toolCallInputs) {
+                            // Only add if not already captured via a tool-call chunk
+                            if (!completedToolCalls.some((tc) => tc.toolCallId === id)) {
+                                completedToolCalls.push({
+                                    type: 'tool-call',
+                                    toolCallId: id,
+                                    toolName: entry.toolName,
+                                    input: entry.chunks.join(''),
+                                });
+                            }
+                        }
+                        const assistantParts = [];
+                        if (accumulatedText)
+                            assistantParts.push({ type: "text", text: accumulatedText });
+                        for (const tc of completedToolCalls)
+                            assistantParts.push(tc);
+                        const allMessages = assistantParts.length > 0
+                            ? [...finalMessages, { role: "assistant", content: assistantParts }]
                             : finalMessages;
-                        logConversation(Object.assign({ userId,
+                        if (completedToolResults.length > 0) {
+                            allMessages.push({ role: "tool", content: completedToolResults });
+                        }
+                        const { requestPreview, responsePreview } = buildTracePreviews(allMessages);
+                        const spans = buildTraceSpansFromMessages(allMessages);
+                        await logConversation(Object.assign(Object.assign({ userId,
                             projectId,
                             sessionId, messages: allMessages, modelId, usage: streamUsage }, (promptMeta && {
                             promptSlug: promptMeta.promptSlug,
                             promptVersion: promptMeta.promptVersion,
                             promptId: promptMeta.promptId,
-                        }))).then(() => triggerProcessing(userId, projectId, sessionId));
+                        })), { traceId,
+                            requestPreview,
+                            responsePreview, state: "completed", startedAt: startedAt.toISOString(), endedAt: endedAt.toISOString(), durationMs: endedAt.getTime() - startedAt.getTime(), metadata: {
+                                appId: clConfig.appId,
+                            }, spans }));
+                        triggerProcessing(userId, projectId, sessionId);
                     }
                 });
                 result.stream = originalStream.pipeThrough(transformStream);
@@ -402,7 +637,7 @@ ${userContextBlock || "None"}
         let system;
         if (resolved) {
             system = promptConfig.variables
-                ? interpolateTemplate(resolved.content, promptConfig.variables)
+                ? (0, template_2.renderTemplate)(resolved.content, promptConfig.variables)
                 : resolved.content;
             // Store prompt metadata for the session (read by middleware during logging)
             if (session === null || session === void 0 ? void 0 : session.sessionId) {
@@ -441,7 +676,7 @@ ${userContextBlock || "None"}
         let system;
         if (resolved) {
             system = promptConfig.variables
-                ? interpolateTemplate(resolved.content, promptConfig.variables)
+                ? (0, template_2.renderTemplate)(resolved.content, promptConfig.variables)
                 : resolved.content;
             // Store prompt metadata for the session (read by middleware during logging)
             if (session === null || session === void 0 ? void 0 : session.sessionId) {

package/dist/template.d.ts

@@ -0,0 +1,2 @@
+export type TemplateVariables = Record<string, string | boolean>;
+export declare function renderTemplate(template: string, variables: TemplateVariables): string;

package/dist/template.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTemplate = renderTemplate;
+// Use the pre-built dist to avoid `require.extensions` warning in webpack/Next.js
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const handlebars_1 = __importDefault(require("handlebars/dist/cjs/handlebars"));
+function renderTemplate(template, variables) {
+    const compiled = handlebars_1.default.compile(template, { noEscape: true });
+    return compiled(variables);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kognitivedev/vercel-ai-provider",
-    "version": "0.1.8",
+    "version": "0.2.0",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "publishConfig": {
@@ -12,6 +12,9 @@
         "test": "vitest run",
         "prepublishOnly": "npm run build"
     },
+    "dependencies": {
+        "handlebars": "^4.7.8"
+    },
     "peerDependencies": {
         "ai": "^5.0.0 || ^6.0.0"
     },

package/src/__tests__/template.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect } from "vitest";
+import { renderTemplate } from "../template";
+
+describe("renderTemplate", () => {
+    describe("variable interpolation", () => {
+        it("replaces a single variable", () => {
+            expect(renderTemplate("Hello {{name}}", { name: "Alice" })).toBe("Hello Alice");
+        });
+
+        it("replaces multiple variables", () => {
+            expect(
+                renderTemplate("{{greeting}}, {{name}}!", { greeting: "Hi", name: "Bob" })
+            ).toBe("Hi, Bob!");
+        });
+
+        it("renders undefined variables as empty string", () => {
+            expect(renderTemplate("Hello {{name}}", {})).toBe("Hello ");
+        });
+
+        it("does not HTML-escape content", () => {
+            expect(renderTemplate("{{content}}", { content: "<b>bold</b> & \"quoted\"" })).toBe(
+                "<b>bold</b> & \"quoted\""
+            );
+        });
+    });
+
+    describe("{{#if}} / {{/if}}", () => {
+        it("includes block when variable is truthy string", () => {
+            expect(
+                renderTemplate("start{{#if show}} visible{{/if}} end", { show: "yes" })
+            ).toBe("start visible end");
+        });
+
+        it("includes block when variable is true", () => {
+            expect(
+                renderTemplate("start{{#if show}} visible{{/if}} end", { show: true })
+            ).toBe("start visible end");
+        });
+
+        it("excludes block when variable is false", () => {
+            expect(
+                renderTemplate("start{{#if show}} visible{{/if}} end", { show: false })
+            ).toBe("start end");
+        });
+
+        it("excludes block when variable is undefined", () => {
+            expect(
+                renderTemplate("start{{#if show}} visible{{/if}} end", {})
+            ).toBe("start end");
+        });
+
+        it("excludes block when variable is empty string", () => {
+            expect(
+                renderTemplate("start{{#if show}} visible{{/if}} end", { show: "" })
+            ).toBe("start end");
+        });
+    });
+
+    describe("{{#unless}} / {{/unless}}", () => {
+        it("includes block when variable is falsy", () => {
+            expect(
+                renderTemplate("{{#unless premium}}Free tier{{/unless}}", { premium: false })
+            ).toBe("Free tier");
+        });
+
+        it("excludes block when variable is truthy", () => {
+            expect(
+                renderTemplate("{{#unless premium}}Free tier{{/unless}}", { premium: true })
+            ).toBe("");
+        });
+    });
+
+    describe("{{else}} branches", () => {
+        it("renders else branch when if condition is false", () => {
+            expect(
+                renderTemplate(
+                    "{{#if vip}}VIP access{{else}}Standard access{{/if}}",
+                    { vip: false }
+                )
+            ).toBe("Standard access");
+        });
+
+        it("renders if branch when condition is true", () => {
+            expect(
+                renderTemplate(
+                    "{{#if vip}}VIP access{{else}}Standard access{{/if}}",
+                    { vip: true }
+                )
+            ).toBe("VIP access");
+        });
+    });
+
+    describe("nested conditionals", () => {
+        it("handles nested if blocks", () => {
+            const template = "{{#if a}}A{{#if b}}-B{{/if}}{{/if}}";
+            expect(renderTemplate(template, { a: true, b: true })).toBe("A-B");
+            expect(renderTemplate(template, { a: true, b: false })).toBe("A");
+            expect(renderTemplate(template, { a: false, b: true })).toBe("");
+        });
+    });
+
+    describe("variables inside conditionals", () => {
+        it("interpolates variables within conditional blocks", () => {
+            expect(
+                renderTemplate(
+                    "{{#if hasName}}Name: {{name}}{{/if}}",
+                    { hasName: true, name: "Alice" }
+                )
+            ).toBe("Name: Alice");
+        });
+    });
+
+    describe("real-world fitness app template", () => {
+        const template = `You are a fitness coach AI assistant.
+
+User: {{userName}}
+Goal: {{fitnessGoal}}
+
+{{#if hasImages}}
+The user has attached images for form analysis. Please review them carefully.
+{{/if}}
+{{#if hasAttachments}}
+Additional documents have been provided for context.
+{{/if}}
+{{#unless hasHistory}}
+This is a new user with no prior conversation history. Introduce yourself.
+{{/unless}}
+
+Please provide personalized advice.`;
+
+        it("renders with all flags true", () => {
+            const result = renderTemplate(template, {
+                userName: "Sarah",
+                fitnessGoal: "Build muscle",
+                hasImages: true,
+                hasAttachments: true,
+                hasHistory: true,
+            });
+            expect(result).toContain("User: Sarah");
+            expect(result).toContain("Goal: Build muscle");
+            expect(result).toContain("attached images for form analysis");
+            expect(result).toContain("Additional documents");
+            expect(result).not.toContain("new user with no prior");
+        });
+
+        it("renders with all flags false", () => {
+            const result = renderTemplate(template, {
+                userName: "Tom",
+                fitnessGoal: "Lose weight",
+                hasImages: false,
+                hasAttachments: false,
+                hasHistory: false,
+            });
+            expect(result).toContain("User: Tom");
+            expect(result).toContain("Goal: Lose weight");
+            expect(result).not.toContain("attached images");
+            expect(result).not.toContain("Additional documents");
+            expect(result).toContain("new user with no prior");
+        });
+    });
+});