@cogitator-ai/channels 0.2.5 → 0.4.0

package/dist/gateway.js

@@ -1,3 +1,4 @@
+import { parseModel } from '@cogitator-ai/core';
 import { SessionManager, CompactionService } from '@cogitator-ai/memory';
 import { StreamBuffer } from './stream-buffer.js';
 import { adaptMarkdown, chunkMessage, getPlatformLimit } from './formatters/markdown.js';
@@ -5,46 +6,56 @@ import { StatusReactionTracker } from './status-reactions.js';
 import { InboundDebouncer } from './inbound-debounce.js';
 import { formatEnvelope } from './envelope.js';
 import { MessageQueue } from './message-queue.js';
+const DEFAULT_SUMMARY_PROMPT = 'Summarize the following conversation between a user and an assistant. ' +
+    'Preserve facts, decisions, user preferences, open tasks and any commitments. ' +
+    'Write a concise summary in the language of the conversation.';
+const TYPING_INTERVAL_MS = 4000;
+function messageText(message) {
+    if (typeof message.content === 'string')
+        return message.content;
+    return message.content
+        .map((part) => (part.type === 'text' ? part.text : `[${part.type}]`))
+        .join(' ');
+}
+function isScheduled(msg) {
+    const raw = msg.raw;
+    return typeof raw === 'object' && raw !== null && 'scheduled' in raw && raw.scheduled === true;
+}
+function dayKey(timestamp) {
+    const date = new Date(timestamp);
+    return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;
+}
 export class Gateway {
     config;
     channels;
     sessionManager;
-    compactionService;
     middlewares;
     streamConfig;
     debouncer;
     messageQueue;
     hooks;
     lastMessageTime = new Map();
+    threads = new Map();
+    inFlight = new Map();
     running = false;
     startedAt = null;
     messageCount = 0;
+    messageCountDay = dayKey(Date.now());
     constructor(config) {
         this.config = config;
         this.channels = config.channels;
         this.middlewares = config.middleware ?? [];
         this.streamConfig = config.stream ?? { flushInterval: 500, minChunkSize: 20 };
-        if (config.memory) {
-            this.sessionManager = config.sessionManager ? null : new SessionManager(config.memory);
-            this.compactionService = config.session?.compaction
-                ? new CompactionService({
-                    adapter: config.memory,
-                    summarize: this.createSummarizeFn(),
-                })
-                : null;
-        }
-        else {
-            this.sessionManager = null;
-            this.compactionService = null;
-        }
         this.hooks = config.hooks ?? null;
-        this.debouncer = config.debounce?.enabled
-            ? new InboundDebouncer(config.debounce, (merged) => this.processMessage(merged))
-            : null;
+        this.sessionManager =
+            config.sessionManager ?? (config.memory ? new SessionManager(config.memory) : null);
         this.messageQueue =
             config.queueMode && config.queueMode !== 'parallel'
-                ? new MessageQueue(config.queueMode, (msg) => this.processMessage(msg))
+                ? new MessageQueue(config.queueMode, (msg, signal) => this.processMessage(msg, signal))
                 : null;
+        this.debouncer = config.debounce?.enabled
+            ? new InboundDebouncer(config.debounce, (merged) => this.dispatch(merged))
+            : null;
         for (const channel of this.channels) {
             channel.onMessage((msg) => this.handleIncoming(msg));
         }
@@ -54,7 +65,14 @@ export class Gateway {
             return;
         this.running = true;
         this.startedAt = Date.now();
-        await Promise.all(this.channels.map((ch) => ch.start()));
+        const results = await Promise.allSettled(this.channels.map((ch) => ch.start()));
+        const failure = results.find((r) => r.status === 'rejected');
+        if (failure) {
+            this.running = false;
+            this.startedAt = null;
+            await Promise.allSettled(this.channels.map((ch) => ch.stop()));
+            throw failure.reason instanceof Error ? failure.reason : new Error(String(failure.reason));
+        }
     }
     async stop() {
         if (!this.running)
@@ -64,130 +82,201 @@ export class Gateway {
             await this.debouncer.flushAll();
         this.messageQueue?.dispose();
         await Promise.all(this.channels.map((ch) => ch.stop()));
+        this.startedAt = null;
     }
     get stats() {
+        this.rollMessageCounter();
         return {
             uptime: this.startedAt ? Date.now() - this.startedAt : 0,
-            activeSessions: 0,
-            totalSessions: 0,
+            activeSessions: this.inFlight.size,
+            totalSessions: this.threads.size,
             messagesToday: this.messageCount,
             connectedChannels: this.channels.map((ch) => ch.type),
         };
     }
+    getSessions() {
+        return [...this.threads.entries()]
+            .map(([threadId, info]) => ({ threadId, ...info, active: this.inFlight.has(threadId) }))
+            .sort((a, b) => b.lastActiveAt - a.lastActiveAt);
+    }
     async injectMessage(msg) {
         return this.handleIncoming(msg);
     }
+    /**
+     * Summarize older messages of a conversation thread, keeping `keepRecent` messages intact.
+     * Runs regardless of the configured message threshold.
+     */
+    async compactThread(threadId, agent) {
+        const compaction = this.config.session?.compaction;
+        if (!this.config.memory || !compaction) {
+            return 'Compaction is not configured';
+        }
+        const targetAgent = agent ?? (await this.resolveAgent({ id: 'system', channelType: 'system' }));
+        const service = new CompactionService({
+            adapter: this.config.memory,
+            summarize: this.createSummarizeFn(targetAgent, compaction),
+        });
+        const result = await service.compact(threadId, { ...compaction, threshold: 0 });
+        if (result.compactedMessages < result.originalMessages) {
+            await this.hooks?.emit('session:compacted', { threadId, result });
+            return `Compacted ${result.originalMessages} messages into ${result.compactedMessages}`;
+        }
+        return `Nothing to compact (${result.originalMessages} messages)`;
+    }
+    async compactIfNeeded(threadId, agent) {
+        const memory = this.config.memory;
+        const compaction = this.config.session?.compaction;
+        if (!memory || !compaction)
+            return;
+        const entries = await memory.getEntries({ threadId });
+        if (!entries.success || entries.data.length < compaction.threshold)
+            return;
+        await this.compactThread(threadId, agent);
+    }
     async handleIncoming(msg) {
         if (this.debouncer) {
             this.debouncer.enqueue(msg);
+            return;
         }
-        else if (this.messageQueue) {
-            const threadId = this.getThreadId(msg);
-            this.messageQueue.push(msg, threadId);
+        await this.dispatch(msg);
+    }
+    async dispatch(msg) {
+        if (this.messageQueue) {
+            this.messageQueue.push(msg, this.getThreadId(msg));
+            return;
         }
-        else {
-            await this.processMessage(msg);
+        await this.processMessage(msg);
+    }
+    rollMessageCounter() {
+        const today = dayKey(Date.now());
+        if (today !== this.messageCountDay) {
+            this.messageCountDay = today;
+            this.messageCount = 0;
         }
     }
-    async processMessage(msg) {
-        try {
-            const channel = this.channels.find((ch) => ch.type === msg.channelType);
-            if (!channel)
+    async runMiddleware(msg, ctx) {
+        let reachedEnd = false;
+        const runAll = async (index) => {
+            if (index >= this.middlewares.length) {
+                reachedEnd = true;
                 return;
-            const user = {
-                id: msg.userId,
-                channelType: msg.channelType,
-                name: msg.userName,
-            };
-            const threadId = this.getThreadId(msg);
-            const ctx = this.createMiddlewareContext(threadId, user, channel);
-            let middlewarePassed = true;
-            if (this.middlewares.length > 0) {
-                let nextCalled = false;
-                const runAll = async (index) => {
-                    if (index >= this.middlewares.length) {
-                        nextCalled = true;
-                        return;
-                    }
-                    await this.middlewares[index].handle(msg, ctx, () => runAll(index + 1));
-                };
-                await runAll(0);
-                middlewarePassed = nextCalled;
             }
-            if (!middlewarePassed)
+            await this.middlewares[index].handle(msg, ctx, () => runAll(index + 1));
+        };
+        await runAll(0);
+        return reachedEnd;
+    }
+    async processMessage(msg, signal) {
+        const channel = this.channels.find((ch) => ch.type === msg.channelType);
+        if (!channel)
+            return;
+        const threadId = this.getThreadId(msg);
+        this.inFlight.set(threadId, (this.inFlight.get(threadId) ?? 0) + 1);
+        try {
+            await this.processWithChannel(msg, channel, threadId, signal);
+        }
+        catch (error) {
+            if (signal?.aborted)
                 return;
-            await this.hooks?.emit('message:received', { msg, threadId, user });
-            this.messageCount++;
-            if (this.config.envelope?.enabled) {
-                const prevTime = this.lastMessageTime.get(threadId);
-                msg = { ...msg, text: formatEnvelope(msg, this.config.envelope, prevTime) };
-                this.lastMessageTime.set(threadId, Date.now());
-            }
-            if (this.sessionManager) {
-                const session = await this.sessionManager.getOrCreate({
-                    userId: msg.userId,
-                    channelType: msg.channelType,
-                    channelId: msg.channelId,
-                    agentId: this.getAgentName(),
-                });
-                await this.sessionManager.incrementMessageCount(session.id);
-                if (this.compactionService && this.config.session?.compaction) {
-                    const compaction = this.config.session.compaction;
-                    if (session.messageCount >= compaction.threshold) {
-                        await this.compactionService.compact(session.id, compaction);
-                    }
-                }
-            }
-            const agent = await this.resolveAgent(user);
-            const reactionsEnabled = this.config.reactions?.enabled && channel.setReaction;
-            let tracker;
-            if (reactionsEnabled) {
-                tracker = new StatusReactionTracker(channel, msg.channelId, msg.id, this.config.reactions);
-                tracker.setPhase('queued');
+            this.config.onError?.(error instanceof Error ? error : new Error(String(error)), msg);
+        }
+        finally {
+            const remaining = (this.inFlight.get(threadId) ?? 1) - 1;
+            if (remaining <= 0)
+                this.inFlight.delete(threadId);
+            else
+                this.inFlight.set(threadId, remaining);
+        }
+    }
+    async processWithChannel(msg, channel, threadId, signal) {
+        const user = {
+            id: msg.userId,
+            channelType: msg.channelType,
+            name: msg.userName,
+        };
+        const ctx = this.createMiddlewareContext(threadId, user, channel);
+        if (!(await this.runMiddleware(msg, ctx)))
+            return;
+        await this.handleAccepted(msg, channel, threadId, user, signal);
+    }
+    async handleAccepted(originalMsg, channel, threadId, user, signal) {
+        let msg = originalMsg;
+        await this.hooks?.emit('message:received', { msg, threadId, user });
+        this.rollMessageCounter();
+        this.messageCount++;
+        const known = this.threads.get(threadId);
+        this.threads.set(threadId, {
+            channelType: msg.channelType,
+            userId: msg.userId,
+            ...(msg.userName || known?.userName ? { userName: msg.userName ?? known?.userName } : {}),
+            messageCount: (known?.messageCount ?? 0) + 1,
+            lastActiveAt: Date.now(),
+        });
+        if (this.config.envelope?.enabled) {
+            const prevTime = this.lastMessageTime.get(threadId);
+            msg = { ...msg, text: formatEnvelope(msg, this.config.envelope, prevTime) };
+            this.lastMessageTime.set(threadId, Date.now());
+        }
+        const agent = await this.resolveAgent(user);
+        if (this.sessionManager) {
+            const session = await this.sessionManager.getOrCreate({
+                userId: msg.userId,
+                channelType: msg.channelType,
+                channelId: msg.channelId,
+                agentId: agent.name,
+            });
+            if (session.messageCount === 0) {
+                await this.hooks?.emit('session:created', { session, threadId });
             }
-            await channel.sendTyping(msg.channelId);
-            const typingInterval = setInterval(() => {
-                channel.sendTyping(msg.channelId).catch(() => { });
-            }, 4000);
+            await this.sessionManager.incrementMessageCount?.(session.id);
+        }
+        if (this.config.memory && this.config.session?.compaction) {
             try {
-                tracker?.setPhase('thinking');
-                if (this.config.stream) {
-                    await this.runStreaming(agent, msg, channel, threadId);
-                }
-                else {
-                    await this.runDirect(agent, msg, channel, threadId);
-                }
-                tracker?.setPhase('done');
+                await this.compactIfNeeded(threadId, agent);
             }
             catch (error) {
-                tracker?.setPhase('error');
-                throw error;
+                this.config.onError?.(error instanceof Error ? error : new Error(String(error)), originalMsg);
+            }
+        }
+        const tracker = this.config.reactions?.enabled && channel.setReaction
+            ? new StatusReactionTracker(channel, msg.channelId, msg.id, this.config.reactions)
+            : undefined;
+        tracker?.setPhase('queued');
+        const typingInterval = setInterval(() => {
+            channel.sendTyping(msg.channelId).catch(() => { });
+        }, TYPING_INTERVAL_MS);
+        try {
+            await channel.sendTyping(msg.channelId).catch(() => { });
+            tracker?.setPhase('thinking');
+            if (this.config.stream) {
+                await this.runStreaming(agent, msg, channel, threadId, tracker, signal);
             }
-            finally {
-                clearInterval(typingInterval);
-                tracker?.dispose();
+            else {
+                await this.runDirect(agent, msg, channel, threadId, tracker, signal);
             }
+            tracker?.setPhase('done');
         }
         catch (error) {
-            if (this.config.onError) {
-                this.config.onError(error instanceof Error ? error : new Error(String(error)), msg);
-            }
+            tracker?.setPhase('error');
+            throw error;
+        }
+        finally {
+            clearInterval(typingInterval);
+            tracker?.dispose();
         }
     }
     async extractMedia(msg, agent) {
         let input = msg.text;
         let images;
         if (this.config.mediaProcessor && msg.attachments?.length) {
-            console.log(`[gateway] Processing ${msg.attachments.length} attachment(s), types: ${msg.attachments.map((a) => a.type).join(', ')}`);
             const result = await this.config.mediaProcessor.process(msg.attachments, agent.model);
-            console.log(`[gateway] Media result: images=${result.images.length}, text=${!!result.transcribedText}, notes=${result.systemNotes.length}`);
             if (result.images.length > 0)
                 images = result.images;
             if (result.transcribedText) {
                 input = result.transcribedText + (input ? `\n${input}` : '');
             }
             if (result.systemNotes.length > 0) {
-                input = (input || '') + '\n' + result.systemNotes.join('\n');
+                input = (input ? `${input}\n` : '') + result.systemNotes.join('\n');
             }
         }
         if (!input && !images?.length) {
@@ -195,43 +284,63 @@ export class Gateway {
         }
         return { input, images };
     }
-    async runDirect(agent, msg, channel, threadId) {
+    buildRunOptions(msg, threadId, input, images, tracker, signal) {
+        return {
+            input,
+            threadId,
+            useMemory: !!this.config.memory,
+            userId: msg.userId,
+            channelType: msg.channelType,
+            channelId: msg.channelId,
+            ...(images ? { images } : {}),
+            ...(signal ? { signal } : {}),
+            ...(this.config.runTimeout !== undefined ? { timeout: this.config.runTimeout } : {}),
+            ...(tracker
+                ? {
+                    onToolCall: () => tracker.setPhase('tool'),
+                    onToolResult: () => tracker.setPhase('thinking'),
+                }
+                : {}),
+        };
+    }
+    async sendChunked(channel, msg, output, replyTo) {
+        const chunks = chunkMessage(output, getPlatformLimit(msg.channelType));
+        let sentId = '';
+        for (let i = 0; i < chunks.length; i++) {
+            const id = await channel.sendText(msg.channelId, chunks[i], {
+                ...(i === 0 && replyTo ? { replyTo } : {}),
+                format: 'markdown',
+            });
+            if (i === 0)
+                sentId = id;
+        }
+        return sentId;
+    }
+    async runDirect(agent, msg, channel, threadId, tracker, signal) {
         const { input, images } = await this.extractMedia(msg, agent);
-        const replyTo = msg.raw?.scheduled ? undefined : msg.id;
+        const replyTo = isScheduled(msg) ? undefined : msg.id;
         await this.hooks?.emit('agent:before_run', { msg, threadId, agent: agent.name });
         let result;
         try {
-            result = await this.config.cogitator.run(agent, {
-                input,
-                threadId,
-                useMemory: !!this.config.memory,
-                userId: msg.userId,
-                channelType: msg.channelType,
-                channelId: msg.channelId,
-                ...(images ? { images } : {}),
-            });
+            result = await this.config.cogitator.run(agent, this.buildRunOptions(msg, threadId, input, images, tracker, signal));
         }
         catch (error) {
             await this.hooks?.emit('agent:error', { msg, threadId, error });
             throw error;
         }
         await this.hooks?.emit('agent:after_run', { msg, threadId, output: result.output });
+        if (signal?.aborted)
+            return;
         const output = adaptMarkdown(result.output, msg.channelType);
+        if (!output)
+            return;
         await this.hooks?.emit('message:sending', {
             msg,
             threadId,
             text: output,
             channelId: msg.channelId,
         });
-        const limit = getPlatformLimit(msg.channelType);
-        const chunks = chunkMessage(output, limit);
-        let sentId = '';
-        for (let i = 0; i < chunks.length; i++) {
-            sentId = await channel.sendText(msg.channelId, chunks[i], {
-                ...(i === 0 && replyTo ? { replyTo } : {}),
-                format: 'markdown',
-            });
-        }
+        const sentId = await this.sendChunked(channel, msg, output, replyTo);
         await this.hooks?.emit('message:sent', {
             msg,
             threadId,
@@ -239,67 +348,53 @@ export class Gateway {
             messageId: sentId,
         });
     }
-    async runStreaming(agent, msg, channel, threadId) {
+    async runStreaming(agent, msg, channel, threadId, tracker, signal) {
         const { input, images } = await this.extractMedia(msg, agent);
-        console.log(`[gateway] Running LLM, input: "${input.slice(0, 200)}", images: ${images?.length ?? 0}`);
-        const replyTo = msg.raw?.scheduled ? undefined : msg.id;
-        const useDraft = !!channel.sendDraft;
+        const replyTo = isScheduled(msg) ? undefined : msg.id;
         const streamCfg = {
             ...this.streamConfig,
             maxMessageChars: this.streamConfig.maxMessageChars ?? getPlatformLimit(msg.channelType),
         };
-        const stream = new StreamBuffer(channel, msg.channelId, streamCfg, replyTo, useDraft);
+        const stream = new StreamBuffer(channel, msg.channelId, streamCfg, replyTo, !!channel.sendDraft, (text) => adaptMarkdown(text, msg.channelType));
         stream.start();
         await this.hooks?.emit('agent:before_run', { msg, threadId, agent: agent.name });
         await this.hooks?.emit('stream:started', { msg, threadId });
+        let tokenCount = 0;
+        let result;
         try {
-            let tokenCount = 0;
-            const runPromise = this.config.cogitator.run(agent, {
-                input,
-                threadId,
-                useMemory: !!this.config.memory,
-                userId: msg.userId,
-                channelType: msg.channelType,
-                channelId: msg.channelId,
+            result = await this.config.cogitator.run(agent, {
+                ...this.buildRunOptions(msg, threadId, input, images, tracker, signal),
                 stream: true,
                 onToken: (token) => {
                     tokenCount++;
                     stream.append(token);
                 },
-                ...(images ? { images } : {}),
-            });
-            const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error('LLM response timeout (90s)')), 90_000));
-            const result = await Promise.race([runPromise, timeout]);
-            if (tokenCount > 0) {
-                await stream.finish();
-            }
-            else {
-                await stream.abort();
-                if (result.output) {
-                    const output = adaptMarkdown(result.output, msg.channelType);
-                    const limit = getPlatformLimit(msg.channelType);
-                    const chunks = chunkMessage(output, limit);
-                    for (let i = 0; i < chunks.length; i++) {
-                        await channel.sendText(msg.channelId, chunks[i], {
-                            ...(i === 0 && replyTo ? { replyTo } : {}),
-                            format: 'markdown',
-                        });
-                    }
-                }
-            }
-            await this.hooks?.emit('agent:after_run', { msg, threadId, output: result.output });
-            await this.hooks?.emit('stream:finished', {
-                msg,
-                threadId,
-                messageIds: stream.getMessageIds(),
             });
         }
         catch (error) {
-            console.error('[gateway] LLM run error:', error.message);
             await stream.abort();
             await this.hooks?.emit('agent:error', { msg, threadId, error });
             throw error;
         }
+        if (signal?.aborted) {
+            await stream.abort();
+            return;
+        }
+        if (tokenCount > 0) {
+            await stream.finish();
+        }
+        else {
+            await stream.abort();
+            const output = adaptMarkdown(result.output, msg.channelType);
+            if (output)
+                await this.sendChunked(channel, msg, output, replyTo);
+        }
+        await this.hooks?.emit('agent:after_run', { msg, threadId, output: result.output });
+        await this.hooks?.emit('stream:finished', {
+            msg,
+            threadId,
+            messageIds: stream.getMessageIds(),
+        });
     }
     getThreadId(msg) {
         if (this.config.session?.threadKey) {
@@ -310,17 +405,10 @@ export class Gateway {
     async resolveAgent(user) {
         const agentOrFactory = this.config.agent;
         if (typeof agentOrFactory === 'function') {
-            return agentOrFactory(user);
+            return (await agentOrFactory(user));
         }
         return agentOrFactory;
     }
-    getAgentName() {
-        const agentOrFactory = this.config.agent;
-        if (typeof agentOrFactory === 'function') {
-            return 'dynamic';
-        }
-        return agentOrFactory.name;
-    }
     createMiddlewareContext(threadId, user, channel) {
         const store = new Map();
         return {
@@ -335,12 +423,25 @@ export class Gateway {
             },
         };
     }
-    createSummarizeFn() {
+    createSummarizeFn(agent, compaction) {
+        const modelId = compaction.summaryModel ?? agent.model;
+        const explicitProvider = compaction.summaryModel ? undefined : agent.config?.provider;
+        const prompt = compaction.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT;
         return async (messages) => {
-            const text = messages
-                .map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
-                .join('\n');
-            return `[Summary of ${messages.length} messages]: ${text.slice(0, 500)}`;
+            const backend = this.config.cogitator.getLLMBackend(modelId, explicitProvider);
+            const model = explicitProvider ? modelId : parseModel(modelId).model;
+            const transcript = messages.map((m) => `${m.role}: ${messageText(m)}`).join('\n');
+            const response = await backend.chat({
+                model,
+                messages: [
+                    { role: 'system', content: prompt },
+                    { role: 'user', content: transcript },
+                ],
+            });
+            const summary = response.content.trim();
+            if (!summary)
+                throw new Error('Summarization model returned an empty summary');
+            return summary;
         };
     }
 }