myavana-bot-test-core 2.2.0 → 2.3.0

package/.env

@@ -14,7 +14,7 @@ REDIS_PASSWORD=OyLRjkTPuCGzQ2mNzA3Uhx5HIqWza8QC
 REDIS_USERNAME=default
 
 #GENKIT
-GENKIT_API_KEY=AIzaSyBB5ZYwktOFI3R3j_vs8U7CxwKgS3XNgM0
+GENKIT_API_KEY=AQ.Ab8RN6Irt-ueXxfkkZm2MEkvaTr5HfHicLIjyYFHkrancWvQjA
 
 #OpenAI
 OPENAI_API_KEY=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

package/index.js

@@ -53,6 +53,8 @@ const modules = {
     getAllYoutubeVideos: safeRequire('./src/utils', 'utils')?.getAllYoutubeVideos,
     getAllTestimonials: safeRequire('./src/utils', 'utils')?.getAllTestimonials,
     getAdditionalInstructions: safeRequire('./src/utils', 'utils')?.getAdditionalInstructions,
+    getTrainingData: safeRequire('./src/utils', 'utils')?.getTrainingData,
+    getChatbotWelcomeSettings: safeRequire('./src/utils', 'utils')?.getChatbotWelcomeSettings,
 };
 
 // Smart systems - Load with proper error handling and fallbacks
@@ -121,6 +123,43 @@ for (const [moduleName, modulePath] of Object.entries(smartModulePaths)) {
     }
 }
 
+// Trend-aware knowledge
+const trendModules = {
+    trendManager: safeRequire('./src/trendManager', 'trendManager'),
+    getTrendContext: safeRequire('./src/trendManager', 'trendManager')?.getTrendContext,
+    generateTrends: safeRequire('./src/trendManager', 'trendManager')?.generateTrends,
+};
+
+// Conversation-driving behavior
+const conversationDriverModules = {
+    conversationDriver: safeRequire('./src/conversationDriver', 'conversationDriver'),
+    getConversationDirective: safeRequire('./src/conversationDriver', 'conversationDriver')?.getConversationDirective,
+};
+
+// Adaptive Personality Engine
+const personalityModules = {
+    personaClassifier: safeRequire('./src/personaClassifier', 'personaClassifier'),
+    buildMessageContext: safeRequire('./src/messageContextBuilder', 'messageContextBuilder')?.buildMessageContext,
+};
+
+// Tool-enabled agents
+const agentToolModules = {
+    agentTools: safeRequire('./src/agentTools', 'agentTools'),
+    globalTools: safeRequire('./src/agentTools', 'agentTools')?.globalTools,
+    createUserTools: safeRequire('./src/agentTools', 'agentTools')?.createUserTools,
+};
+
+// D2C funnel-event tracking
+const funnelEventModules = {
+    logFunnelEvent: safeRequire('./src/funnelEvents', 'funnelEvents')?.logFunnelEvent,
+};
+
+// Local Agent Memory (self-hosted, TAM-inspired)
+const agentMemoryModules = {
+    extractAndStoreMemories: safeRequire('./src/agentMemory', 'agentMemory')?.extractAndStoreMemories,
+    retrieveRelevantMemories: safeRequire('./src/agentMemory', 'agentMemory')?.retrieveRelevantMemories,
+};
+
 // Enhanced systems
 const enhancedModules = {
     Logger: safeRequire('./src/logger', 'Logger')?.Logger,
@@ -135,7 +174,13 @@ const enhancedModules = {
 module.exports = {
     ...modules,
     ...smartModules,
-    ...enhancedModules
+    ...enhancedModules,
+    ...trendModules,
+    ...conversationDriverModules,
+    ...personalityModules,
+    ...agentToolModules,
+    ...funnelEventModules,
+    ...agentMemoryModules,
 };
 
 // Log export summary

package/migrations/004_add_partner_products.sql

@@ -0,0 +1,25 @@
+-- Migration 004: Partner products table
+-- Stores products from Myavana partner brands that the AI can recommend.
+-- The searchServices agent tool queries this table alongside Myavana's own services.
+
+CREATE TABLE IF NOT EXISTS partner_products (
+    id           SERIAL PRIMARY KEY,
+    brand_name   VARCHAR(255) NOT NULL,
+    product_name VARCHAR(255) NOT NULL,
+    description  TEXT,
+    category     VARCHAR(100),          -- e.g. 'shampoo', 'conditioner', 'styler', 'treatment'
+    hair_types   TEXT[],                -- e.g. ARRAY['4a','4b','4c']
+    hair_concerns TEXT[],               -- e.g. ARRAY['moisture','breakage','frizz']
+    price_usd    NUMERIC(8,2),
+    url          TEXT,
+    image_url    TEXT,
+    in_stock     BOOLEAN DEFAULT TRUE,
+    active       BOOLEAN DEFAULT TRUE,
+    created_at   TIMESTAMP DEFAULT NOW(),
+    updated_at   TIMESTAMP DEFAULT NOW(),
+    UNIQUE (brand_name, product_name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_partner_products_brand   ON partner_products (brand_name);
+CREATE INDEX IF NOT EXISTS idx_partner_products_category ON partner_products (category);
+CREATE INDEX IF NOT EXISTS idx_partner_products_active   ON partner_products (active) WHERE active = TRUE;

package/migrations/005_add_hair_trends.sql

@@ -0,0 +1,23 @@
+-- Migration 005: Hair trends table
+-- Stores AI-generated and admin-curated trend awareness data.
+-- Refreshed every 48h by trendManager.generateTrends().
+-- The trendManager serves relevant rows into per-message context so the AI
+-- stays current without the trends being baked into the 24h cached system prompt.
+
+CREATE TABLE IF NOT EXISTS hair_trends (
+    id              SERIAL PRIMARY KEY,
+    trend_name      VARCHAR(255) NOT NULL,
+    description     TEXT NOT NULL,                  -- one sentence: what it is and why it works
+    category        VARCHAR(50)  NOT NULL,           -- 'technique' | 'ingredient' | 'style' | 'wellness'
+    relevance_stages INT[],                          -- journey stage numbers this applies to (null = all)
+    hair_types      TEXT[],                          -- hair types this is most relevant for (null = all)
+    trend_score     FLOAT DEFAULT 0.5,               -- 0.0-1.0, how current/hot this trend is
+    source          VARCHAR(100) DEFAULT 'ai-generated', -- 'ai-generated' | 'admin-curated'
+    active          BOOLEAN DEFAULT TRUE,
+    generated_at    TIMESTAMP DEFAULT NOW(),
+    expires_at      TIMESTAMP DEFAULT (NOW() + INTERVAL '48 hours')
+);
+
+CREATE INDEX IF NOT EXISTS idx_hair_trends_active    ON hair_trends (active, expires_at);
+CREATE INDEX IF NOT EXISTS idx_hair_trends_category  ON hair_trends (category);
+CREATE INDEX IF NOT EXISTS idx_hair_trends_stages    ON hair_trends USING GIN (relevance_stages);

package/migrations/006_add_funnel_events.sql

@@ -0,0 +1,17 @@
+-- Migration 006: Chatbot funnel events
+-- Tracks D2C conversion-funnel milestones (intake, paywall, purchase, HHCP delivery,
+-- consult triage) emitted by the widget/backend, independent of the single-column
+-- conversation_metrics.conversion_event, so funnel drop-off can be queried per stage.
+
+CREATE TABLE IF NOT EXISTS chatbot_funnel_events (
+    id                  SERIAL PRIMARY KEY,
+    user_id             VARCHAR(255),
+    conversation_id     VARCHAR(255),
+    event_type          VARCHAR(100), -- intake_completed | paywall_shown | purchase_completed | hhcp_delivered | consult_triaged
+    metadata            JSONB,
+    created_at          TIMESTAMP DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_funnel_events_user         ON chatbot_funnel_events (user_id);
+CREATE INDEX IF NOT EXISTS idx_funnel_events_conversation ON chatbot_funnel_events (conversation_id);
+CREATE INDEX IF NOT EXISTS idx_funnel_events_type_created  ON chatbot_funnel_events (event_type, created_at);

package/migrations/007_add_agent_memory.sql

@@ -0,0 +1,23 @@
+-- Migration 007: Local Agent Memory (self-hosted, TAM-inspired)
+-- Durable, semantic long-term memory for the D2C widget's context, built entirely
+-- on this Postgres instance via pgvector (no external memory-service vendor).
+-- Requires the `vector` extension to be enabled on the target Postgres instance
+-- (supported on modern RDS Postgres versions) before this migration is run.
+
+CREATE EXTENSION IF NOT EXISTS vector;
+
+CREATE TABLE IF NOT EXISTS agent_memories (
+    id                      SERIAL PRIMARY KEY,
+    user_id                 VARCHAR(255) NOT NULL,
+    memory_type             VARCHAR(50),          -- fact | preference | episodic
+    content                 TEXT NOT NULL,
+    embedding               vector(768),          -- matches the Google embedding model's output dimension
+    importance_score        FLOAT DEFAULT 0.5,
+    source_conversation_id  VARCHAR(255),
+    created_at              TIMESTAMP DEFAULT NOW(),
+    last_accessed_at        TIMESTAMP DEFAULT NOW(),
+    access_count            INTEGER DEFAULT 0
+);
+
+CREATE INDEX IF NOT EXISTS idx_agent_memories_user      ON agent_memories (user_id);
+CREATE INDEX IF NOT EXISTS idx_agent_memories_embedding ON agent_memories USING hnsw (embedding vector_cosine_ops);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "myavana-bot-test-core",
-    "version": "2.2.0",
+    "version": "2.3.0",
     "description": "Shared bot functionality with enhanced features",
     "main": "index.js",
     "scripts": {
@@ -24,7 +24,8 @@
         "pg": "^8.13.1",
         "redis": "^4.7.0",
         "uuid": "^9.0.1",
-        "winston": "^3.11.0"
+        "winston": "^3.11.0",
+        "zod": "^3.25.76"
     },
     "devDependencies": {
         "@babel/preset-env": "^7.23.6",

package/src/__tests__/agentTools.test.js

@@ -0,0 +1,165 @@
+// agentTools.test.js
+// Tests tool handler logic by capturing handlers at definition time via mock.
+// jest.mock factory variables must be prefixed with `mock` to be hoisting-safe.
+
+const mockQuery = jest.fn();
+const mockCapturedHandlers = {};
+
+jest.mock('../database', () => ({
+    pgClient: { query: mockQuery },
+    redisClient: { get: jest.fn(), set: jest.fn() },
+}));
+
+jest.mock('../ai', () => ({
+    defineTool: (config, fn) => {
+        mockCapturedHandlers[config.name] = fn;
+        return { __toolName: config.name };
+    },
+    dynamicTool: (config, fn) => {
+        mockCapturedHandlers[config.name] = fn;
+        return { __toolName: config.name };
+    },
+}));
+
+// Load module after mocks — defineTool/dynamicTool calls populate mockCapturedHandlers
+const { createUserTools } = require('../agentTools');
+// Trigger dynamic tool registration for user 'u1'
+createUserTools('u1');
+
+beforeEach(() => jest.clearAllMocks());
+
+// ---------------------------------------------------------------------------
+// searchServices
+// ---------------------------------------------------------------------------
+
+describe('searchServices', () => {
+    test('returns matching rows from products table', async () => {
+        mockQuery
+            .mockResolvedValueOnce({ rows: [{ product_id: 1, product_name: 'Hair Analysis' }] })
+            .mockRejectedValueOnce(new Error('relation "partner_products" does not exist'));
+
+        const result = await mockCapturedHandlers['searchServices']({ query: 'analysis', limit: 5 });
+        expect(result).toEqual([{ product_id: 1, product_name: 'Hair Analysis' }]);
+    });
+
+    test('includes partner products when table exists', async () => {
+        mockQuery
+            .mockResolvedValueOnce({ rows: [{ product_name: 'Myavana Analysis' }] })
+            .mockResolvedValueOnce({ rows: [{ product_name: 'Partner Cream', source: 'partner' }] });
+
+        const result = await mockCapturedHandlers['searchServices']({ query: 'moisture', limit: 5 });
+        expect(result).toHaveLength(2);
+        expect(result[1].source).toBe('partner');
+    });
+
+    test('returns not-found message when no rows match', async () => {
+        mockQuery
+            .mockResolvedValueOnce({ rows: [] })
+            .mockRejectedValueOnce(new Error('table missing'));
+
+        const result = await mockCapturedHandlers['searchServices']({ query: 'xyz123' });
+        expect(result[0].message).toMatch(/No services or products found/);
+    });
+
+    test('returns error object without throwing when DB fails', async () => {
+        mockQuery.mockRejectedValue(new Error('DB down'));
+        const result = await mockCapturedHandlers['searchServices']({ query: 'anything' });
+        expect(result[0].error).toBeDefined();
+    });
+
+    test('trims combined results to limit', async () => {
+        const services = Array.from({ length: 4 }, (_, i) => ({ product_name: `Service ${i}` }));
+        const partners = Array.from({ length: 4 }, (_, i) => ({ product_name: `Partner ${i}` }));
+        mockQuery
+            .mockResolvedValueOnce({ rows: services })
+            .mockResolvedValueOnce({ rows: partners });
+
+        const result = await mockCapturedHandlers['searchServices']({ query: 'hair', limit: 5 });
+        expect(result.length).toBeLessThanOrEqual(5);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// lookupFAQ
+// ---------------------------------------------------------------------------
+
+describe('lookupFAQ', () => {
+    test('returns matching FAQ rows', async () => {
+        const faqs = [{ question: 'How do I cancel?', answer: 'Email support@myavana.com' }];
+        mockQuery.mockResolvedValueOnce({ rows: faqs });
+
+        const result = await mockCapturedHandlers['lookupFAQ']({ query: 'cancel', limit: 3 });
+        expect(result).toEqual(faqs);
+    });
+
+    test('returns fallback instruction when no rows match', async () => {
+        mockQuery.mockResolvedValueOnce({ rows: [] });
+        const result = await mockCapturedHandlers['lookupFAQ']({ query: 'unknown topic' });
+        expect(result[0].answer).toMatch(/Answer based on your knowledge/);
+    });
+
+    test('returns error object without throwing when DB fails', async () => {
+        mockQuery.mockRejectedValue(new Error('DB down'));
+        const result = await mockCapturedHandlers['lookupFAQ']({ query: 'anything' });
+        expect(result[0].error).toBeDefined();
+    });
+});
+
+// ---------------------------------------------------------------------------
+// saveHairGoal (dynamic — registered via createUserTools('u1'))
+// ---------------------------------------------------------------------------
+
+describe('saveHairGoal', () => {
+    test('upserts goal and returns saved:true', async () => {
+        mockQuery.mockResolvedValueOnce({ rows: [] });
+
+        const result = await mockCapturedHandlers['saveHairGoal']({ goal: 'grow 4 inches by December' });
+        expect(result).toEqual({ saved: true, goal: 'grow 4 inches by December' });
+        expect(mockQuery).toHaveBeenCalledWith(
+            expect.stringContaining('INSERT INTO user_preferences'),
+            expect.arrayContaining(['u1'])
+        );
+    });
+
+    test('returns saved:false without throwing when DB fails', async () => {
+        mockQuery.mockRejectedValue(new Error('DB error'));
+        const result = await mockCapturedHandlers['saveHairGoal']({ goal: 'retain moisture' });
+        expect(result).toEqual({ saved: false, goal: 'retain moisture' });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getUserHairProfile (dynamic — registered via createUserTools('u1'))
+// ---------------------------------------------------------------------------
+
+describe('getUserHairProfile', () => {
+    test('returns profile with null fields stripped', async () => {
+        mockQuery.mockResolvedValueOnce({
+            rows: [{ hair_type: '4c', hair_concerns: ['dryness'], porosity: null, elasticity: null }],
+        });
+
+        const result = await mockCapturedHandlers['getUserHairProfile']({});
+        expect(result).toEqual({ hair_type: '4c', hair_concerns: ['dryness'] });
+        expect(result.porosity).toBeUndefined();
+    });
+
+    test('returns not-found message when user has no profile row', async () => {
+        mockQuery.mockResolvedValueOnce({ rows: [] });
+        const result = await mockCapturedHandlers['getUserHairProfile']({});
+        expect(result.message).toMatch(/No hair profile/);
+    });
+
+    test('returns message when profile row has all-null fields', async () => {
+        mockQuery.mockResolvedValueOnce({
+            rows: [{ hair_type: null, hair_concerns: null, porosity: null }],
+        });
+        const result = await mockCapturedHandlers['getUserHairProfile']({});
+        expect(result.message).toMatch(/no attributes recorded/);
+    });
+
+    test('returns error object without throwing when DB fails', async () => {
+        mockQuery.mockRejectedValue(new Error('DB down'));
+        const result = await mockCapturedHandlers['getUserHairProfile']({});
+        expect(result.error).toBeDefined();
+    });
+});

package/src/__tests__/cacheManager.test.js

@@ -0,0 +1,196 @@
+const mockQuery = jest.fn();
+const mockRedisGet = jest.fn();
+const mockRedisSet = jest.fn();
+
+jest.mock('../database', () => ({
+    pgClient: { query: mockQuery },
+    redisClient: { get: mockRedisGet, set: mockRedisSet },
+}));
+
+jest.mock('../ai', () => ({}));
+jest.mock('@genkit-ai/google-genai', () => ({
+    googleAI: { model: jest.fn(() => 'mocked-model') },
+}));
+jest.mock('../config', () => ({ genkitApiKey: 'test-key' }));
+
+const mockCacheCreate = jest.fn();
+jest.mock('@google/genai', () => ({
+    GoogleGenAI: jest.fn().mockImplementation(() => ({
+        caches: { create: mockCacheCreate },
+    })),
+}));
+
+const CacheManager = require('../cacheManager');
+
+beforeEach(() => {
+    jest.clearAllMocks();
+    // Clear in-memory cache — it's a plain Map, not a Jest mock, so clearAllMocks won't reset it
+    CacheManager.memoryCache.clear();
+});
+
+const futureDate = new Date(Date.now() + 10 * 60 * 60 * 1000); // 10 hours from now
+const pastDate = new Date(Date.now() - 1000); // 1 second ago
+const nearExpiryDate = new Date(Date.now() + 30 * 60 * 1000); // 30 min from now (< 1hr threshold)
+
+describe('isCacheExpired', () => {
+    test('returns false for future expiry', () => {
+        expect(CacheManager.isCacheExpired({ expires_at: futureDate })).toBe(false);
+    });
+
+    test('returns true for past expiry', () => {
+        expect(CacheManager.isCacheExpired({ expires_at: pastDate })).toBe(true);
+    });
+});
+
+describe('checkCacheValidity', () => {
+    test('returns hasValidCache=false when no cache in any layer', async () => {
+        mockQuery.mockResolvedValue({ rows: [] });
+        mockRedisGet.mockResolvedValue(null);
+
+        const result = await CacheManager.checkCacheValidity('u1');
+
+        expect(result.hasValidCache).toBe(false);
+        expect(result.reason).toBe('no_cache');
+    });
+
+    test('returns hasValidCache=false when cache is expired', async () => {
+        mockQuery.mockResolvedValue({
+            rows: [{ cache_name: 'cn1', created_at: new Date(), expires_at: pastDate }],
+        });
+
+        const result = await CacheManager.checkCacheValidity('u1');
+
+        expect(result.hasValidCache).toBe(false);
+        expect(result.reason).toBe('expired');
+    });
+
+    test('returns hasValidCache=true for valid cache', async () => {
+        mockQuery.mockResolvedValue({
+            rows: [{ cache_name: 'cn1', created_at: new Date(), expires_at: futureDate }],
+        });
+
+        const result = await CacheManager.checkCacheValidity('u1');
+
+        expect(result.hasValidCache).toBe(true);
+        expect(result.cacheName).toBe('cn1');
+        expect(result.needsRefresh).toBe(false);
+    });
+
+    test('sets needsRefresh=true when cache is near expiry', async () => {
+        mockQuery.mockResolvedValue({
+            rows: [{ cache_name: 'cn1', created_at: new Date(), expires_at: nearExpiryDate }],
+        });
+
+        const result = await CacheManager.checkCacheValidity('u1');
+
+        expect(result.hasValidCache).toBe(true);
+        expect(result.needsRefresh).toBe(true);
+    });
+
+    test('returns hasValidCache=false when all layers empty after DB error', async () => {
+        mockQuery.mockRejectedValue(new Error('DB down'));
+
+        const result = await CacheManager.checkCacheValidity('u1');
+
+        expect(result.hasValidCache).toBe(false);
+        // getUserCache catches internally and returns null, so reason is 'no_cache' not 'error'
+        expect(result.reason).toBe('no_cache');
+    });
+});
+
+describe('saveUserCacheMultiLayer', () => {
+    test('saves to all layers when all succeed', async () => {
+        mockQuery.mockResolvedValue({ rows: [] });
+        mockRedisSet.mockResolvedValue('OK');
+
+        await CacheManager.saveUserCacheMultiLayer('u1', 'cache-name-123');
+
+        expect(mockQuery).toHaveBeenCalled();
+        expect(mockRedisSet).toHaveBeenCalledWith(
+            'gemini_cache:u1',
+            expect.any(String),
+            { EX: CacheManager.CACHE_TTL_SECONDS }
+        );
+    });
+
+    test('does NOT call setex (redis v3 API)', async () => {
+        mockQuery.mockResolvedValue({ rows: [] });
+        mockRedisSet.mockResolvedValue('OK');
+
+        await CacheManager.saveUserCacheMultiLayer('u1', 'cache-name-123');
+
+        // Ensure old redis v3 API is not used
+        expect(mockRedisSet).toHaveBeenCalled();
+        const call = mockRedisSet.mock.calls[0];
+        // redis v4 set(key, value, options) — third arg is options object, not a number
+        expect(typeof call[2]).toBe('object');
+        expect(call[2]).toHaveProperty('EX');
+    });
+
+    test('continues when Postgres fails but Redis succeeds', async () => {
+        mockQuery.mockRejectedValue(new Error('Postgres down'));
+        mockRedisSet.mockResolvedValue('OK');
+
+        // Should not throw — memory layer always succeeds
+        await expect(
+            CacheManager.saveUserCacheMultiLayer('u1', 'cache-name-123')
+        ).resolves.not.toThrow();
+    });
+
+    test('throws when all layers fail', async () => {
+        mockQuery.mockRejectedValue(new Error('Postgres down'));
+        mockRedisSet.mockRejectedValue(new Error('Redis down'));
+        // Memory always succeeds so this won't throw — the guard is for all 3 failing
+        // Simulate memory failure by spying
+        const spy = jest.spyOn(CacheManager, 'saveUserCacheToMemory').mockImplementation(() => {
+            throw new Error('Memory down');
+        });
+
+        await expect(
+            CacheManager.saveUserCacheMultiLayer('u1', 'cache-name-123')
+        ).rejects.toThrow('All cache storage layers failed');
+
+        spy.mockRestore();
+    });
+});
+
+describe('getOrCreateCache', () => {
+    test('returns existing cache when valid cache found', async () => {
+        mockQuery.mockResolvedValue({
+            rows: [{ cache_name: 'existing-cache', created_at: new Date(), expires_at: futureDate }],
+        });
+
+        const result = await CacheManager.getOrCreateCache('u1', 'system prompt text');
+
+        expect(result.cacheName).toBe('existing-cache');
+        expect(result.isNewCache).toBe(false);
+        expect(mockCacheCreate).not.toHaveBeenCalled();
+    });
+
+    test('creates new cache when none exists', async () => {
+        mockQuery.mockResolvedValue({ rows: [] });
+        mockRedisGet.mockResolvedValue(null);
+        mockCacheCreate.mockResolvedValue({ name: 'new-cache-name' });
+        mockRedisSet.mockResolvedValue('OK');
+
+        const result = await CacheManager.getOrCreateCache('u1', 'system prompt text');
+
+        expect(mockCacheCreate).toHaveBeenCalledWith(expect.objectContaining({
+            model: 'gemini-3.7-flash',
+            config: expect.objectContaining({ systemInstruction: 'system prompt text' }),
+        }));
+        expect(result.cacheName).toBe('new-cache-name');
+        expect(result.isNewCache).toBe(true);
+    });
+
+    test('returns null cacheName on creation failure', async () => {
+        mockQuery.mockResolvedValue({ rows: [] });
+        mockRedisGet.mockResolvedValue(null);
+        mockCacheCreate.mockRejectedValue(new Error('Gemini API error'));
+
+        const result = await CacheManager.getOrCreateCache('u1', 'system prompt text');
+
+        expect(result.cacheName).toBeNull();
+        expect(result.error).toBeDefined();
+    });
+});