@kognitivedev/vercel-ai-provider 0.1.6 → 0.1.8

package/README.md

@@ -55,7 +55,7 @@ const { text } = await generateText({
 | `apiKey` | `string` | - | - | API key for authentication (if required) |
 | `processDelayMs` | `number` | - | `500` | Delay before triggering memory processing (set to 0 to disable) |
 | `logLevel` | `LogLevel` | - | `'info'` | Controls console logging verbosity |
-| `providerFactory` | `(baseURL: string) => (modelId: string) => LanguageModel` | - | - | Factory for creating a provider that routes through a gateway URL |
+| `providerFactory` | `(baseURL: string, apiKey: string) => (modelId: string) => LanguageModel` | - | - | Factory for creating a provider that routes through a gateway URL |
 
 ### `LogLevel`
 
@@ -317,8 +317,8 @@ const cl = createCognitiveLayer({
     clConfig: {
         appId: "my-app",
         baseUrl: "https://api.kognitive.dev",
-        providerFactory: (baseURL) => {
-            const gatewayProvider = createOpenAI({ baseURL });
+        providerFactory: (baseURL, apiKey) => {
+            const gatewayProvider = createOpenAI({ baseURL, apiKey });
             return (modelId) => gatewayProvider(modelId);
         }
     }

package/dist/index.d.ts

@@ -27,7 +27,7 @@ export interface CognitiveLayerConfig {
     /**
      * Factory for creating a provider that routes through a gateway URL.
      */
-    providerFactory?: (baseURL: string) => (modelId: string) => LanguageModel;
+    providerFactory?: (baseURL: string, apiKey: string) => (modelId: string) => LanguageModel;
 }
 export type CLModelWrapper = (modelId: string, settings?: {
     userId?: string;
@@ -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

@@ -13,6 +13,12 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCognitiveLayer = createCognitiveLayer;
 const ai_1 = require("ai");
+function isValidId(value) {
+    if (value == null || typeof value !== "string")
+        return false;
+    const trimmed = value.trim();
+    return trimmed !== "" && trimmed !== "null" && trimmed !== "undefined";
+}
 const LOG_LEVEL_PRIORITY = {
     none: 0,
     error: 1,
@@ -94,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) {
@@ -116,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;
     };
@@ -166,7 +177,7 @@ function createCognitiveLayer(config) {
     const buildMiddleware = (userId, projectId, sessionId, modelId) => ({
         specificationVersion: 'v3',
         async transformParams({ params }) {
-            if (!userId)
+            if (!isValidId(userId))
                 return params;
             const incomingMessages = Array.isArray(params.prompt)
                 ? params.prompt
@@ -254,7 +265,7 @@ ${userContextBlock || "None"}
                 logger.error("doGenerate params.prompt", JSON.stringify((_a = params.prompt) === null || _a === void 0 ? void 0 : _a.map((m) => ({ role: m.role, contentType: typeof m.content, contentLength: Array.isArray(m.content) ? m.content.length : undefined })), null, 2));
                 throw err;
             }
-            if (userId && sessionId) {
+            if (isValidId(userId) && isValidId(sessionId)) {
                 const sessionKey = `${userId}:${projectId}:${sessionId}`;
                 const promptMeta = sessionPromptMetadata.get(sessionKey);
                 const messagesInput = params.messages || params.prompt || [];
@@ -288,7 +299,7 @@ ${userContextBlock || "None"}
                 logger.error("doStream failed", err);
                 throw err;
             }
-            if (userId && sessionId) {
+            if (isValidId(userId) && isValidId(sessionId)) {
                 const sessionKey = `${userId}:${projectId}:${sessionId}`;
                 const promptMeta = sessionPromptMetadata.get(sessionKey);
                 const messagesInput = params.messages || params.prompt || [];
@@ -337,7 +348,7 @@ ${userContextBlock || "None"}
         try {
             const gatewayURL = `${baseUrl}/api/cognitive/gateway/${gatewaySlug}`;
             const modelId = originalModel.modelId || 'default';
-            const rawModel = clConfig.providerFactory(gatewayURL)(modelId);
+            const rawModel = clConfig.providerFactory(gatewayURL, clConfig.apiKey)(modelId);
             const session = originalModel[SESSION_KEY];
             if (!session)
                 return rawModel;
@@ -361,7 +372,7 @@ ${userContextBlock || "None"}
         const userId = settings === null || settings === void 0 ? void 0 : settings.userId;
         const projectId = (settings === null || settings === void 0 ? void 0 : settings.projectId) || clConfig.projectId || "default";
         const sessionId = settings === null || settings === void 0 ? void 0 : settings.sessionId;
-        const sessionMissing = !!userId && !sessionId;
+        const sessionMissing = isValidId(userId) && !isValidId(sessionId);
         if (sessionMissing) {
             logger.warn("sessionId is required to log and process memories; skipping logging until provided.");
         }
@@ -370,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 (userId && 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.6",
+    "version": "0.1.8",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "publishConfig": {

package/src/index.ts

@@ -15,6 +15,12 @@ import {
  */
 export type LogLevel = 'none' | 'error' | 'warn' | 'info' | 'debug';
 
+function isValidId(value: string | undefined | null): value is string {
+    if (value == null || typeof value !== "string") return false;
+    const trimmed = value.trim();
+    return trimmed !== "" && trimmed !== "null" && trimmed !== "undefined";
+}
+
 const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
     none: 0,
     error: 1,
@@ -72,7 +78,7 @@ export interface CognitiveLayerConfig {
     /**
      * Factory for creating a provider that routes through a gateway URL.
      */
-    providerFactory?: (baseURL: string) => (modelId: string) => LanguageModel;
+    providerFactory?: (baseURL: string, apiKey: string) => (modelId: string) => LanguageModel;
 }
 
 export type CLModelWrapper = (
@@ -110,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;
@@ -188,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) {
@@ -212,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;
     };
@@ -275,7 +286,7 @@ export function createCognitiveLayer(config: {
     const buildMiddleware = (userId: string | undefined, projectId: string, sessionId: string | undefined, modelId: string) => ({
         specificationVersion: 'v3' as const,
         async transformParams({ params }: { params: any }) {
-            if (!userId) return params;
+            if (!isValidId(userId)) return params;
 
             const incomingMessages = Array.isArray((params as any).prompt)
                 ? (params as any).prompt
@@ -373,7 +384,7 @@ ${userContextBlock || "None"}
                 throw err;
             }
 
-            if (userId && sessionId) {
+            if (isValidId(userId) && isValidId(sessionId)) {
                 const sessionKey = `${userId}:${projectId}:${sessionId}`;
                 const promptMeta = sessionPromptMetadata.get(sessionKey);
 
@@ -416,7 +427,7 @@ ${userContextBlock || "None"}
                 throw err;
             }
 
-            if (userId && sessionId) {
+            if (isValidId(userId) && isValidId(sessionId)) {
                 const sessionKey = `${userId}:${projectId}:${sessionId}`;
                 const promptMeta = sessionPromptMetadata.get(sessionKey);
 
@@ -479,7 +490,7 @@ ${userContextBlock || "None"}
         try {
             const gatewayURL = `${baseUrl}/api/cognitive/gateway/${gatewaySlug}`;
             const modelId = (originalModel as any).modelId || 'default';
-            const rawModel = clConfig.providerFactory(gatewayURL)(modelId);
+            const rawModel = clConfig.providerFactory(gatewayURL, clConfig.apiKey)(modelId);
 
             const session = (originalModel as any)[SESSION_KEY];
             if (!session) return rawModel as LanguageModel;
@@ -510,7 +521,7 @@ ${userContextBlock || "None"}
         const userId = settings?.userId;
         const projectId = settings?.projectId || clConfig.projectId || "default";
         const sessionId = settings?.sessionId;
-        const sessionMissing = !!userId && !sessionId;
+        const sessionMissing = isValidId(userId) && !isValidId(sessionId);
 
         if (sessionMissing) {
             logger.warn("sessionId is required to log and process memories; skipping logging until provided.");
@@ -522,8 +533,10 @@ ${userContextBlock || "None"}
         }) as LanguageModel;
 
         // Track session settings on the model for use in cl.streamText/cl.generateText
-        if (userId && 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;
@@ -532,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,
+                });
+            }
 
-        const model = resolveModel(options.model, resolved.gatewaySlug);
-        return aiStreamText({ ...rest, model, system } as any);
+            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 && { 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