alexa-ai 2.5.0 → 2.6.0

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to `alexa-ai` are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
 [Semantic Versioning](https://semver.org/).
 
+## [2.6.0] — 2026-09-07
+
+### Added
+- **Time-aware conversations.** Previously the replayed history had no
+  timestamps, so a thread from a week ago read like it happened today and the
+  model answered accordingly. Now:
+  - the system prompt carries a live "Today is <weekday, date, time, zone>"
+    line (`timeZone` option, defaults to the server zone);
+  - history turns further apart than `timeGapMinutes` (default 60) carry a
+    bracketed gap marker, e.g. "[about 1 week passed since the previous
+    message]";
+  - the live message carries the same marker when the thread itself was
+    resumed after a long pause.
+  Disable with `historyTimeMarkers: false`. `getHistory()` now returns
+  `createdAt` alongside `role`/`content`.
+
 ## [2.5.0] — 2026-09-07
 
 ### Added

package/README.md

@@ -931,6 +931,23 @@ refusal asks the vision model for a score instead (`via: 'chat'` — works when
 the key can see images), (c) otherwise returns `error: 'DEEPAI_PRO_REQUIRED'`
 with a clear message. A Pro key makes the real model work.
 
+**The bot thinks last week's chat happened today.** Fixed in 2.6.0. Two
+mechanisms now keep the model time-aware:
+
+1. The system prompt carries a live date line — *"Today is Tuesday, 22
+   September 2026 at 14:05 (Asia/Colombo time)."* — so it can answer
+   date questions and judge how old memories are.
+2. Replayed history carries time-gap markers. When two turns are more than
+   `timeGapMinutes` apart (default 60), the later turn is prefixed with a
+   bracketed note like `[about 1 week passed since the previous message]`,
+   and the same marker is attached to the live message when a thread is
+   resumed after a long pause. The model explicitly knows the old messages
+   are from last week.
+
+Options: `timeGapMinutes` (default 60), `historyTimeMarkers: false` to
+disable markers, `timeZone` (e.g. `'Asia/Colombo'`; defaults to the server's
+zone).
+
 **Always check `result.ok` before sending media.** On failure every helper
 returns `url: null` — passing that straight to Baileys'
 `prepareWAMessageMedia` crashes the bot with

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alexa-ai",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "AI engine for the Alexa WhatsApp bot: DeepAI-powered chat with PostgreSQL-backed long-term memory, cross-chat identity (@lid <-> phone), vision/OCR, image generation and web search.",
   "main": "index.js",
   "scripts": {

package/src/core/Config.js

@@ -184,6 +184,13 @@ class Config {
 
         // ---- Conversation / memory tuning -----------------------------------
         this.historyLimit = Config._int(opts.historyLimit, 14, 2, 60);
+        // Time awareness: the prompt carries a "Today is ..." line, and a
+        // gap marker is inserted between history turns that are further
+        // apart than timeGapMinutes, so the model knows how much time has
+        // passed instead of treating a week-old chat as happening today.
+        this.historyTimeMarkers = opts.historyTimeMarkers !== false;
+        this.timeGapMinutes = Config._int(opts.timeGapMinutes, 60, 1, 60 * 24 * 365);
+        this.timeZone = opts.timeZone || process.env.DEEPAI_TIME_ZONE || null; // null = server local
         this.maxMemories = Config._int(opts.maxMemories, 25, 0, 200);
         this.maxMessageLength = Config._int(opts.maxMessageLength, 8000, 100, 100000);
         this.sharedGroupThread = Boolean(opts.sharedGroupThread);

package/src/repositories/ConversationRepository.js

@@ -119,7 +119,13 @@ class ConversationRepository {
               ORDER BY created_at ASC, id ASC`,
             [conversationId, limit]
         );
-        return rows.map((r) => ({ role: r.role, content: r.content }));
+        // createdAt rides along so the prompt can carry time-gap markers;
+        // without them a week-old thread reads like it happened just now.
+        return rows.map((r) => ({
+            role: r.role,
+            content: r.content,
+            createdAt: r.created_at ? new Date(r.created_at).toISOString() : null,
+        }));
     }
 
     async findByContextKey(contextKey) {

package/src/services/PromptBuilder.js

@@ -84,13 +84,29 @@ class PromptBuilder {
         // 2) Assistant acknowledgement locks the role in.
         messages.push({ role: 'assistant', content: this._acknowledgement() });
 
-        // 3) Prior turns of this thread.
-        for (const turn of PromptBuilder._sanitiseHistory(history, this.config.historyLimit)) {
+        // 3) Prior turns of this thread, with time-gap markers so the model
+        // knows a thread resumed days later instead of assuming "today".
+        const annotatedHistory = PromptBuilder._timeAnnotatedHistory(history, this.config);
+        for (const turn of annotatedHistory) {
             messages.push(turn);
         }
 
         // 4) The live message, with its reinforcement notes.
         let current = String(message ?? '').trim();
+
+        // 4a) The common case: the thread itself is old. When the last
+        // replayed turn is further back than the gap threshold, the live
+        // message carries the marker so the model knows how much time passed
+        // since the previous conversation.
+        if (this.config.historyTimeMarkers) {
+            const lastStamped = [...annotatedHistory].reverse().find((t) => t.createdAt);
+            if (lastStamped) {
+                const gap = Date.now() - Date.parse(lastStamped.createdAt);
+                if (gap >= this.config.timeGapMinutes * 60 * 1000) {
+                    current = `[${PromptBuilder._gapLabel(gap)} passed since the previous message]\n\n${current}`;
+                }
+            }
+        }
         if (imageContext) {
             current = current
                 ? `[Image attached — visual description: ${imageContext}]\n\n${current}`
@@ -126,6 +142,7 @@ class PromptBuilder {
         const { assistantName, creator } = this.config;
         return [
             `You are ${assistantName}, a warm, friendly female WhatsApp assistant created by ${creator}.`,
+            PromptBuilder._todayLine(this.config.timeZone),
             `Your name is exactly "${assistantName}" — never a variant such as "${assistantName} Mini" or "${assistantName} AI".`,
             'Never mention DeepAI, ChatGPT, OpenAI, GPT, Llama, Gemini or any model/company name, and never call yourself a language model.',
             'You always reply in plain English only. Never answer in Chinese, Japanese, Korean or any other non-Latin script.',
@@ -205,13 +222,77 @@ class PromptBuilder {
 
         const cleaned = history
             .filter((m) => m && (m.role === 'user' || m.role === 'assistant'))
-            .map((m) => ({ role: m.role, content: String(m.content ?? '').trim() }))
+            .map((m) => {
+                const turn = { role: m.role, content: String(m.content ?? '').trim() };
+                const t = Date.parse(m.createdAt || m.created_at || m.timestamp || '');
+                if (Number.isFinite(t)) turn.createdAt = new Date(t).toISOString();
+                return turn;
+            })
             .filter((m) => m.content.length > 0);
 
         const trimmed = cleaned.slice(-limit);
         while (trimmed.length && trimmed[0].role === 'assistant') trimmed.shift();
         return trimmed;
     }
+
+    /**
+     * History plus out-of-band time-gap markers. Whenever two consecutive
+     * turns are further apart than config.timeGapMinutes, the later turn is
+     * prefixed with a bracketed note like "[About 7 days passed since the
+     * previous message]" so the model reasons correctly about old threads.
+     * @private
+     */
+    static _timeAnnotatedHistory(history, config) {
+        const turns = PromptBuilder._sanitiseHistory(history, config.historyLimit);
+        if (!config.historyTimeMarkers) return turns;
+        const thresholdMs = config.timeGapMinutes * 60 * 1000;
+
+        let previous = null;
+        return turns.map((turn) => {
+            const annotated = { ...turn };
+            if (previous && previous.createdAt && turn.createdAt) {
+                const gap = Date.parse(turn.createdAt) - Date.parse(previous.createdAt);
+                if (gap >= thresholdMs) {
+                    const label = PromptBuilder._gapLabel(gap);
+                    annotated.content = `[${label} passed since the previous message]\n\n${turn.content}`;
+                }
+            }
+            if (turn.createdAt) previous = turn;
+            return annotated;
+        });
+    }
+
+    /** @private human duration for gap markers. */
+    static _gapLabel(ms) {
+        const minutes = Math.round(ms / 60000);
+        if (minutes < 60) return `${Math.max(1, minutes)} minute${minutes === 1 ? '' : 's'}`;
+        const hours = Math.round(minutes / 60);
+        if (hours < 24) return `about ${hours} hour${hours === 1 ? '' : 's'}`;
+        const days = Math.round(hours / 24);
+        if (days < 7) return `about ${days} day${days === 1 ? '' : 's'}`;
+        if (days < 30) return `about ${Math.round(days / 7)} week${Math.round(days / 7) === 1 ? '' : 's'}`;
+        const months = Math.round(days / 30);
+        return `about ${months} month${months === 1 ? '' : 's'}`;
+    }
+
+    /**
+     * "Today is Tuesday, 22 September 2026 at 14:05 (Colombo time)." — keeps
+     * the model grounded on the current date; also used for date questions.
+     * @private
+     */
+    static _todayLine(timeZone) {
+        try {
+            const zone = timeZone || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+            const now = new Date();
+            const date = new Intl.DateTimeFormat('en-GB', {
+                weekday: 'long', day: 'numeric', month: 'long', year: 'numeric',
+                hour: '2-digit', minute: '2-digit', hour12: false, timeZone: zone,
+            }).format(now);
+            return `Today is ${date} (${zone.replace(/_/g, ' ')} time). Use this for date and time questions, and to reason about how old conversations and memories are.`;
+        } catch {
+            return `Today is ${new Date().toDateString()}. Use this for date and time questions.`;
+        }
+    }
 }
 
 module.exports = PromptBuilder;

package/test/fakes.js

@@ -79,7 +79,7 @@ function createFakeDb() {
             return { name: user?.display_name || named?.value || user?.push_name || null };
         }
         if (/^INSERT INTO wa_messages/.test(q)) {
-            const row = { id: seq++, conversation_id: p[0], user_id: p[1], role: p[2], content: p[3] };
+            const row = { id: seq++, conversation_id: p[0], user_id: p[1], role: p[2], content: p[3], created_at: new Date().toISOString() };
             state.messages.push(row);
             return row;
         }
@@ -97,7 +97,7 @@ function createFakeDb() {
         if (/FROM wa_messages/.test(q)) {
             return state.messages
                 .filter((m) => m.conversation_id === p[0])
-                .map((m) => ({ role: m.role, content: m.content }));
+                .map((m) => ({ role: m.role, content: m.content, created_at: m.created_at }));
         }
         if (/FROM wa_memories/.test(q)) {
             return state.memories.filter((m) => m.user_id === p[0]).map((m) => ({ key: m.key, value: m.value }));

package/test/run-tests.js

@@ -328,6 +328,29 @@ section('PromptBuilder — persona delivery');
     ok('group context injected', persona.content.includes('GROUP'));
     ok('group turn states it is the same person as the DM', persona.content.includes('SAME person'));
     check('third turn is the assistant ack', msgs[2].role, 'assistant');
+
+    // time awareness: current-date line + gap markers
+    ok('system digest carries a Today line', /Today is .+ time\)\. Use this for date/.test(msgs[0].content));
+    {
+        const now = Date.now();
+        const aged = pb.build({
+            message: 'hi again',
+            history: [
+                { role: 'user', content: 'old question', createdAt: new Date(now - 7 * 86400000).toISOString() },
+                { role: 'assistant', content: 'old answer', createdAt: new Date(now - 7 * 86400000 + 30000).toISOString() },
+                { role: 'user', content: 'recent question', createdAt: new Date(now - 60000).toISOString() },
+            ],
+        });
+        const turns = aged.slice(3).filter((m) => m.role === 'user' || m.role === 'assistant');
+        ok('week-long gap gets a marker', turns.some((m) => m.content.includes('[about 1 week passed since the previous message]')));
+        ok('short gap gets no marker', !turns.some((m) => /passed since/.test(m.content) && m.content.includes('old answer')));
+        const off = new PromptBuilder(new Config({ key: 'k', postgresUrl: 'postgres://u:p@localhost/db', historyTimeMarkers: false }));
+        const plain = off.build({
+            message: 'hi',
+            history: [{ role: 'user', content: 'old question', createdAt: new Date(now - 7 * 86400000).toISOString() }, { role: 'user', content: 'recent', createdAt: new Date(now).toISOString() }],
+        });
+        ok('markers can be disabled', !plain.slice(3).some((m) => /passed since/.test(m.content)));
+    }
     ok('last turn contains the live message', msgs[msgs.length - 1].content.endsWith('hello'));
     ok('recall note precedes the live message', msgs[msgs.length - 1].content.includes('Remembered facts'));
     ok('recall note lists known facts', msgs[msgs.length - 1].content.includes('name=Nimal'));
@@ -980,6 +1003,19 @@ async function endToEndTests() {
         const zh2 = await ai.chat({ message: 'hello', userId: '78151912841263@lid' });
         ok('unrecoverable reply carries no CJK', !/[\u4E00-\u9FFF]/.test(zh2.text));
         ok('unrecoverable reply is non-empty', zh2.text.trim().length > 0);
+
+        // 9. A week-old thread is replayed with a time-gap marker, so the
+        // model knows the old messages are from last week, not today.
+        deepai.push('That was a week ago! Today is a new day.');
+        for (const m of db.state.messages) {
+            if (m.conversation_id && m.created_at) m.created_at = new Date(Date.now() - 7 * 86400000).toISOString();
+        }
+        const agedReply = await ai.chat({ message: 'do you remember me?', userId: '78151912841263@lid' });
+        const lastCall = deepai.calls[deepai.calls.length - 1];
+        const sentHistory = lastCall.fields.chatHistory || '';
+        ok('aged thread sends a gap marker', /passed since the previous message/.test(sentHistory));
+        ok('gap marker says roughly a week', /about 1 week/.test(sentHistory));
+        ok('reply is not corrupted by the marker', typeof agedReply.text === 'string' && agedReply.text.length > 0);
     } finally {
         deepai.restore();
     }