@kognitivedev/vercel-ai-provider 0.1.7 → 0.1.8

package/dist/index.d.ts

@@ -59,7 +59,7 @@ export interface LogConversationPayload {
 export type CognitiveLayer = CLModelWrapper & {
     streamText: (options: CLStreamTextOptions) => Promise<ReturnType<typeof aiStreamText>>;
     generateText: (options: CLGenerateTextOptions) => ReturnType<typeof aiGenerateText>;
-    resolvePrompt: (slug: string) => Promise<CachedPrompt>;
+    resolvePrompt: (slug: string, userId?: string) => Promise<CachedPrompt>;
     logConversation: (payload: LogConversationPayload) => Promise<void>;
     triggerProcessing: (userId: string, projectId: string, sessionId: string) => void;
     clearPromptCache: () => void;

package/dist/index.js

@@ -100,13 +100,18 @@ function createCognitiveLayer(config) {
     };
     // Prompt cache: slug → CachedPrompt
     const promptCache = new Map();
-    const resolvePrompt = async (slug) => {
-        const cached = promptCache.get(slug);
+    const resolvePrompt = async (slug, userId) => {
+        const cacheKey = userId ? `${slug}:${userId}` : slug;
+        const cached = promptCache.get(cacheKey);
         if (cached && Date.now() - cached.fetchedAt < PROMPT_CACHE_TTL_MS) {
             logger.debug("Using cached prompt", { slug, version: cached.version });
             return cached;
         }
-        const res = await fetch(`${baseUrl}/api/cognitive/prompt?slug=${encodeURIComponent(slug)}`, {
+        const url = new URL(`${baseUrl}/api/cognitive/prompt`);
+        url.searchParams.set("slug", slug);
+        if (userId)
+            url.searchParams.set("userId", userId);
+        const res = await fetch(url.toString(), {
             headers: { "Authorization": `Bearer ${clConfig.apiKey}` },
         });
         if (!res.ok) {
@@ -122,7 +127,7 @@ function createCognitiveLayer(config) {
             fetchedAt: Date.now(),
             gatewaySlug: data.gatewaySlug,
         };
-        promptCache.set(slug, entry);
+        promptCache.set(cacheKey, entry);
         logger.info("Prompt resolved", { slug, version: entry.version });
         return entry;
     };
@@ -376,60 +381,90 @@ ${userContextBlock || "None"}
             middleware: buildMiddleware(userId, projectId, sessionId, modelId),
         });
         // Track session settings on the model for use in cl.streamText/cl.generateText
-        if (isValidId(userId) && isValidId(sessionId)) {
-            wrappedModel[SESSION_KEY] = { userId, projectId, sessionId };
+        // Always store if userId is valid — sessionId may be missing but userId is still
+        // needed for prompt resolution (e.g. A/B test assignment)
+        if (isValidId(userId)) {
+            wrappedModel[SESSION_KEY] = { userId, projectId, sessionId: isValidId(sessionId) ? sessionId : undefined };
         }
         return wrappedModel;
     };
     const clStreamText = async (options) => {
         const { prompt: promptConfig } = options, rest = __rest(options, ["prompt"]);
-        // Resolve and interpolate prompt
-        const resolved = await resolvePrompt(promptConfig.slug);
-        const system = promptConfig.variables
-            ? interpolateTemplate(resolved.content, promptConfig.variables)
-            : resolved.content;
-        // Store prompt metadata for the session (read by middleware during logging)
         const session = options.model[SESSION_KEY];
-        if (session) {
-            const sessionKey = `${session.userId}:${session.projectId}:${session.sessionId}`;
-            sessionPromptMetadata.set(sessionKey, {
-                promptSlug: resolved.slug,
-                promptVersion: resolved.version,
-                promptId: resolved.promptId,
+        // Resolve and interpolate prompt (graceful fallback on failure)
+        let resolved = null;
+        try {
+            resolved = await resolvePrompt(promptConfig.slug, session === null || session === void 0 ? void 0 : session.userId);
+        }
+        catch (err) {
+            logger.warn(`Failed to resolve prompt "${promptConfig.slug}", streaming without system prompt.`, err);
+        }
+        let system;
+        if (resolved) {
+            system = promptConfig.variables
+                ? interpolateTemplate(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) {
+                const sessionKey = `${session.userId}:${session.projectId}:${session.sessionId}`;
+                sessionPromptMetadata.set(sessionKey, {
+                    promptSlug: resolved.slug,
+                    promptVersion: resolved.version,
+                    promptId: resolved.promptId,
+                });
+            }
+            logger.info("cl.streamText called", {
+                slug: promptConfig.slug,
+                version: resolved.version,
+                systemLength: system.length,
             });
         }
-        logger.info("cl.streamText called", {
-            slug: promptConfig.slug,
-            version: resolved.version,
-            systemLength: system.length,
-        });
-        const model = resolveModel(options.model, resolved.gatewaySlug);
-        return (0, ai_1.streamText)(Object.assign(Object.assign({}, rest), { model, system }));
+        else {
+            logger.info("cl.streamText called without resolved prompt", {
+                slug: promptConfig.slug,
+            });
+        }
+        const model = resolveModel(options.model, resolved === null || resolved === void 0 ? void 0 : resolved.gatewaySlug);
+        return (0, ai_1.streamText)(Object.assign(Object.assign(Object.assign({}, rest), { model }), (system && { system })));
     };
     const clGenerateText = async (options) => {
         const { prompt: promptConfig } = options, rest = __rest(options, ["prompt"]);
-        // Resolve and interpolate prompt
-        const resolved = await resolvePrompt(promptConfig.slug);
-        const system = promptConfig.variables
-            ? interpolateTemplate(resolved.content, promptConfig.variables)
-            : resolved.content;
-        // Store prompt metadata for the session (read by middleware during logging)
         const session = options.model[SESSION_KEY];
-        if (session) {
-            const sessionKey = `${session.userId}:${session.projectId}:${session.sessionId}`;
-            sessionPromptMetadata.set(sessionKey, {
-                promptSlug: resolved.slug,
-                promptVersion: resolved.version,
-                promptId: resolved.promptId,
+        // Resolve and interpolate prompt (graceful fallback on failure)
+        let resolved = null;
+        try {
+            resolved = await resolvePrompt(promptConfig.slug, session === null || session === void 0 ? void 0 : session.userId);
+        }
+        catch (err) {
+            logger.warn(`Failed to resolve prompt "${promptConfig.slug}", generating without system prompt.`, err);
+        }
+        let system;
+        if (resolved) {
+            system = promptConfig.variables
+                ? interpolateTemplate(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) {
+                const sessionKey = `${session.userId}:${session.projectId}:${session.sessionId}`;
+                sessionPromptMetadata.set(sessionKey, {
+                    promptSlug: resolved.slug,
+                    promptVersion: resolved.version,
+                    promptId: resolved.promptId,
+                });
+            }
+            logger.info("cl.generateText called", {
+                slug: promptConfig.slug,
+                version: resolved.version,
+                systemLength: system.length,
             });
         }
-        logger.info("cl.generateText called", {
-            slug: promptConfig.slug,
-            version: resolved.version,
-            systemLength: system.length,
-        });
-        const model = resolveModel(options.model, resolved.gatewaySlug);
-        return (0, ai_1.generateText)(Object.assign(Object.assign({}, rest), { model, system }));
+        else {
+            logger.info("cl.generateText called without resolved prompt", {
+                slug: promptConfig.slug,
+            });
+        }
+        const model = resolveModel(options.model, resolved === null || resolved === void 0 ? void 0 : resolved.gatewaySlug);
+        return (0, ai_1.generateText)(Object.assign(Object.assign(Object.assign({}, rest), { model }), (system && { system })));
     };
     // Return the model wrapper function with streamText/generateText attached
     return Object.assign(clWrapper, {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kognitivedev/vercel-ai-provider",
-    "version": "0.1.7",
+    "version": "0.1.8",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "publishConfig": {

package/src/index.ts

@@ -116,7 +116,7 @@ export interface LogConversationPayload {
 export type CognitiveLayer = CLModelWrapper & {
     streamText: (options: CLStreamTextOptions) => Promise<ReturnType<typeof aiStreamText>>;
     generateText: (options: CLGenerateTextOptions) => ReturnType<typeof aiGenerateText>;
-    resolvePrompt: (slug: string) => Promise<CachedPrompt>;
+    resolvePrompt: (slug: string, userId?: string) => Promise<CachedPrompt>;
     logConversation: (payload: LogConversationPayload) => Promise<void>;
     triggerProcessing: (userId: string, projectId: string, sessionId: string) => void;
     clearPromptCache: () => void;
@@ -194,14 +194,19 @@ export function createCognitiveLayer(config: {
     // Prompt cache: slug → CachedPrompt
     const promptCache = new Map<string, CachedPrompt>();
 
-    const resolvePrompt = async (slug: string): Promise<CachedPrompt> => {
-        const cached = promptCache.get(slug);
+    const resolvePrompt = async (slug: string, userId?: string): Promise<CachedPrompt> => {
+        const cacheKey = userId ? `${slug}:${userId}` : slug;
+        const cached = promptCache.get(cacheKey);
         if (cached && Date.now() - cached.fetchedAt < PROMPT_CACHE_TTL_MS) {
             logger.debug("Using cached prompt", { slug, version: cached.version });
             return cached;
         }
 
-        const res = await fetch(`${baseUrl}/api/cognitive/prompt?slug=${encodeURIComponent(slug)}`, {
+        const url = new URL(`${baseUrl}/api/cognitive/prompt`);
+        url.searchParams.set("slug", slug);
+        if (userId) url.searchParams.set("userId", userId);
+
+        const res = await fetch(url.toString(), {
             headers: { "Authorization": `Bearer ${clConfig.apiKey}` },
         });
         if (!res.ok) {
@@ -218,7 +223,7 @@ export function createCognitiveLayer(config: {
             fetchedAt: Date.now(),
             gatewaySlug: data.gatewaySlug,
         };
-        promptCache.set(slug, entry);
+        promptCache.set(cacheKey, entry);
         logger.info("Prompt resolved", { slug, version: entry.version });
         return entry;
     };
@@ -528,8 +533,10 @@ ${userContextBlock || "None"}
         }) as LanguageModel;
 
         // Track session settings on the model for use in cl.streamText/cl.generateText
-        if (isValidId(userId) && isValidId(sessionId)) {
-            (wrappedModel as any)[SESSION_KEY] = { userId, projectId, sessionId };
+        // Always store if userId is valid — sessionId may be missing but userId is still
+        // needed for prompt resolution (e.g. A/B test assignment)
+        if (isValidId(userId)) {
+            (wrappedModel as any)[SESSION_KEY] = { userId, projectId, sessionId: isValidId(sessionId) ? sessionId : undefined };
         }
 
         return wrappedModel;
@@ -538,61 +545,89 @@ ${userContextBlock || "None"}
     const clStreamText = async (options: CLStreamTextOptions) => {
         const { prompt: promptConfig, ...rest } = options;
 
-        // Resolve and interpolate prompt
-        const resolved = await resolvePrompt(promptConfig.slug);
-        const system = promptConfig.variables
-            ? interpolateTemplate(resolved.content, promptConfig.variables)
-            : resolved.content;
-
-        // Store prompt metadata for the session (read by middleware during logging)
-        const session = (options.model as any)[SESSION_KEY] as { userId: string; projectId: string; sessionId: string } | undefined;
-        if (session) {
-            const sessionKey = `${session.userId}:${session.projectId}:${session.sessionId}`;
-            sessionPromptMetadata.set(sessionKey, {
-                promptSlug: resolved.slug,
-                promptVersion: resolved.version,
-                promptId: resolved.promptId,
-            });
+        const session = (options.model as any)[SESSION_KEY] as { userId: string; projectId: string; sessionId?: string } | undefined;
+
+        // Resolve and interpolate prompt (graceful fallback on failure)
+        let resolved: CachedPrompt | null = null;
+        try {
+            resolved = await resolvePrompt(promptConfig.slug, session?.userId);
+        } catch (err) {
+            logger.warn(`Failed to resolve prompt "${promptConfig.slug}", streaming without system prompt.`, err);
         }
 
-        logger.info("cl.streamText called", {
-            slug: promptConfig.slug,
-            version: resolved.version,
-            systemLength: system.length,
-        });
+        let system: string | undefined;
+        if (resolved) {
+            system = promptConfig.variables
+                ? interpolateTemplate(resolved.content, promptConfig.variables)
+                : resolved.content;
+
+            // Store prompt metadata for the session (read by middleware during logging)
+            if (session?.sessionId) {
+                const sessionKey = `${session.userId}:${session.projectId}:${session.sessionId}`;
+                sessionPromptMetadata.set(sessionKey, {
+                    promptSlug: resolved.slug,
+                    promptVersion: resolved.version,
+                    promptId: resolved.promptId,
+                });
+            }
+
+            logger.info("cl.streamText called", {
+                slug: promptConfig.slug,
+                version: resolved.version,
+                systemLength: system.length,
+            });
+        } else {
+            logger.info("cl.streamText called without resolved prompt", {
+                slug: promptConfig.slug,
+            });
+        }
 
-        const model = resolveModel(options.model, resolved.gatewaySlug);
-        return aiStreamText({ ...rest, model, system } as any);
+        const model = resolveModel(options.model, resolved?.gatewaySlug);
+        return aiStreamText({ ...rest, model, ...(system && { system }) } as any);
     };
 
     const clGenerateText = async (options: CLGenerateTextOptions) => {
         const { prompt: promptConfig, ...rest } = options;
 
-        // Resolve and interpolate prompt
-        const resolved = await resolvePrompt(promptConfig.slug);
-        const system = promptConfig.variables
-            ? interpolateTemplate(resolved.content, promptConfig.variables)
-            : resolved.content;
-
-        // Store prompt metadata for the session (read by middleware during logging)
-        const session = (options.model as any)[SESSION_KEY] as { userId: string; projectId: string; sessionId: string } | undefined;
-        if (session) {
-            const sessionKey = `${session.userId}:${session.projectId}:${session.sessionId}`;
-            sessionPromptMetadata.set(sessionKey, {
-                promptSlug: resolved.slug,
-                promptVersion: resolved.version,
-                promptId: resolved.promptId,
-            });
+        const session = (options.model as any)[SESSION_KEY] as { userId: string; projectId: string; sessionId?: string } | undefined;
+
+        // Resolve and interpolate prompt (graceful fallback on failure)
+        let resolved: CachedPrompt | null = null;
+        try {
+            resolved = await resolvePrompt(promptConfig.slug, session?.userId);
+        } catch (err) {
+            logger.warn(`Failed to resolve prompt "${promptConfig.slug}", generating without system prompt.`, err);
         }
 
-        logger.info("cl.generateText called", {
-            slug: promptConfig.slug,
-            version: resolved.version,
-            systemLength: system.length,
-        });
+        let system: string | undefined;
+        if (resolved) {
+            system = promptConfig.variables
+                ? interpolateTemplate(resolved.content, promptConfig.variables)
+                : resolved.content;
+
+            // Store prompt metadata for the session (read by middleware during logging)
+            if (session?.sessionId) {
+                const sessionKey = `${session.userId}:${session.projectId}:${session.sessionId}`;
+                sessionPromptMetadata.set(sessionKey, {
+                    promptSlug: resolved.slug,
+                    promptVersion: resolved.version,
+                    promptId: resolved.promptId,
+                });
+            }
+
+            logger.info("cl.generateText called", {
+                slug: promptConfig.slug,
+                version: resolved.version,
+                systemLength: system.length,
+            });
+        } else {
+            logger.info("cl.generateText called without resolved prompt", {
+                slug: promptConfig.slug,
+            });
+        }
 
-        const model = resolveModel(options.model, resolved.gatewaySlug);
-        return aiGenerateText({ ...rest, model, system } as any);
+        const model = resolveModel(options.model, resolved?.gatewaySlug);
+        return aiGenerateText({ ...rest, model, ...(system && { system }) } as any);
     };
 
     // Return the model wrapper function with streamText/generateText attached