profclaw 0.0.1-beta.1

package/dist/chat/memory.js

@@ -0,0 +1,343 @@
+/**
+ * Conversation Memory Management
+ *
+ * Handles context window optimization and automatic message compaction
+ * to keep conversations within model limits while preserving context.
+ *
+ * Features:
+ * - Automatic compaction when context window is near limit
+ * - AI-powered summarization of older messages
+ * - Tool result truncation for large outputs
+ * - Priority-based message retention
+ * - Sliding window with importance scoring
+ */
+import { MODEL_CATALOG } from '../providers/core/models.js';
+export const DEFAULT_MEMORY_CONFIG = {
+    compactThreshold: 0.7,
+    preserveRecentCount: 6, // Keep last 3 exchanges (user + assistant)
+    minMessagesForCompaction: 10,
+    targetAfterCompaction: 0.5,
+    maxToolResultTokens: 2000, // ~8KB of text
+    summarizeLargeToolResults: true,
+};
+// === Token Estimation ===
+/**
+ * Rough token estimation (4 chars per token average)
+ * This is a fast approximation - actual tokenization varies by model
+ */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Estimate tokens for a message array
+ */
+export function estimateMessagesTokens(messages) {
+    return messages.reduce((total, msg) => {
+        // Content + role overhead (~10 tokens per message for structure)
+        return total + estimateTokens(msg.content) + 10;
+    }, 0);
+}
+/**
+ * Get context window for the current model
+ */
+export function getContextWindow(model) {
+    // Default to 128k if model not specified
+    if (!model)
+        return 128000;
+    const modelInfo = MODEL_CATALOG.find((m) => m.id === model || m.id.includes(model) || model.includes(m.id));
+    return modelInfo?.contextWindow || 128000;
+}
+// === Tool Result Processing ===
+/**
+ * Truncate large tool results to save context space
+ */
+export function truncateToolResult(result, maxTokens = DEFAULT_MEMORY_CONFIG.maxToolResultTokens) {
+    const resultStr = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+    const originalTokens = estimateTokens(resultStr);
+    if (originalTokens <= maxTokens) {
+        return { result, wasTruncated: false, originalTokens };
+    }
+    // Truncate to maxTokens worth of characters (rough estimate)
+    const maxChars = maxTokens * 4;
+    const truncated = resultStr.slice(0, maxChars);
+    // Try to parse back if it was JSON
+    if (typeof result !== 'string') {
+        try {
+            return {
+                result: {
+                    _truncated: true,
+                    _originalLength: resultStr.length,
+                    data: truncated + '\n\n[... truncated]',
+                },
+                wasTruncated: true,
+                originalTokens,
+            };
+        }
+        catch {
+            // Fall through to string return
+        }
+    }
+    return {
+        result: truncated + '\n\n[... truncated, ' + (originalTokens - maxTokens) + ' tokens removed]',
+        wasTruncated: true,
+        originalTokens,
+    };
+}
+/**
+ * Process tool calls in a message, truncating large results
+ */
+export function processToolCallsForCompaction(toolCalls, config = DEFAULT_MEMORY_CONFIG) {
+    if (!toolCalls || toolCalls.length === 0) {
+        return { toolCalls, tokensSaved: 0 };
+    }
+    let tokensSaved = 0;
+    const processedCalls = toolCalls.map((tc) => {
+        if (tc.result === undefined)
+            return tc;
+        const { result, wasTruncated, originalTokens } = truncateToolResult(tc.result, config.maxToolResultTokens);
+        if (wasTruncated) {
+            const newTokens = estimateTokens(typeof result === 'string' ? result : JSON.stringify(result));
+            tokensSaved += originalTokens - newTokens;
+        }
+        return { ...tc, result };
+    });
+    return { toolCalls: processedCalls, tokensSaved };
+}
+// === Priority-Based Retention ===
+/**
+ * Message importance scoring for retention decisions
+ */
+export function scoreMessageImportance(message) {
+    let score = 0;
+    // System messages are always high priority
+    if (message.role === 'system') {
+        score += 100;
+    }
+    // User messages that ask questions or give instructions
+    if (message.role === 'user') {
+        score += 20;
+        if (message.content.includes('?'))
+            score += 10;
+        if (/^(create|make|build|implement|fix|update|change)/i.test(message.content)) {
+            score += 15;
+        }
+    }
+    // Assistant messages with tool calls are important
+    if (message.role === 'assistant') {
+        score += 10;
+        if (message.toolCalls && message.toolCalls.length > 0) {
+            score += 5 * message.toolCalls.length;
+        }
+    }
+    // Messages that mention errors or important keywords
+    if (/error|fail|success|complete|done|critical|important/i.test(message.content)) {
+        score += 10;
+    }
+    // Longer messages likely contain more context
+    const tokens = estimateTokens(message.content);
+    if (tokens > 100)
+        score += 5;
+    if (tokens > 500)
+        score += 10;
+    return score;
+}
+/**
+ * Select messages to keep based on importance scoring
+ */
+export function selectMessagesForRetention(messages, targetTokens, config = DEFAULT_MEMORY_CONFIG) {
+    // Always keep the most recent messages
+    const recentMessages = messages.slice(-config.preserveRecentCount);
+    const olderMessages = messages.slice(0, -config.preserveRecentCount);
+    // Score and sort older messages by importance
+    const scoredMessages = olderMessages.map((m) => ({
+        message: m,
+        score: scoreMessageImportance(m),
+        tokens: estimateTokens(m.content),
+    }));
+    scoredMessages.sort((a, b) => b.score - a.score);
+    // Select older messages until we hit target
+    const recentTokens = estimateMessagesTokens(recentMessages);
+    let remainingBudget = targetTokens - recentTokens;
+    const selectedOlder = [];
+    for (const { message, tokens } of scoredMessages) {
+        if (remainingBudget <= 0)
+            break;
+        if (tokens <= remainingBudget) {
+            selectedOlder.push(message);
+            remainingBudget -= tokens;
+        }
+    }
+    // Sort selected older messages by timestamp to maintain order
+    selectedOlder.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    return [...selectedOlder, ...recentMessages];
+}
+/**
+ * Check if messages need compaction based on token count
+ */
+export function needsCompaction(messages, model, config = DEFAULT_MEMORY_CONFIG) {
+    if (messages.length < config.minMessagesForCompaction) {
+        return false;
+    }
+    const contextWindow = getContextWindow(model);
+    const currentTokens = estimateMessagesTokens(messages);
+    const threshold = contextWindow * config.compactThreshold;
+    return currentTokens > threshold;
+}
+/**
+ * Create a summary of messages using AI
+ */
+export async function summarizeMessages(messages, model) {
+    const content = messages
+        .map((m) => `${m.role.toUpperCase()}: ${m.content}`)
+        .join('\n\n');
+    const summaryPrompt = `Summarize this conversation concisely, preserving key information, decisions made, and context needed for continuing the discussion. Be brief but complete.
+
+CONVERSATION:
+${content}
+
+SUMMARY:`;
+    try {
+        const { aiProvider } = await import('../providers/ai-sdk.js');
+        const response = await aiProvider.chat({
+            messages: [
+                {
+                    id: 'summary-request',
+                    role: 'user',
+                    content: summaryPrompt,
+                    timestamp: new Date().toISOString(),
+                },
+            ],
+            model: model || 'local', // Prefer local/free model for summaries
+            maxTokens: 500,
+            temperature: 0.3,
+        });
+        return response.content;
+    }
+    catch (error) {
+        // Fallback to simple truncation if AI fails
+        console.warn('[Memory] AI summarization failed, using truncation:', error);
+        return `Previous conversation summary (${messages.length} messages): ${messages
+            .slice(-3)
+            .map((m) => m.content.slice(0, 100))
+            .join(' ... ')}`;
+    }
+}
+/**
+ * Compact messages by summarizing older ones and truncating large tool results
+ */
+export async function compactMessages(messages, model, config = DEFAULT_MEMORY_CONFIG) {
+    const originalCount = messages.length;
+    const originalTokens = estimateMessagesTokens(messages);
+    // Don't compact if not needed
+    if (!needsCompaction(messages, model, config)) {
+        return {
+            messages,
+            originalCount,
+            compactedCount: messages.length,
+            tokensReduced: 0,
+            wasCompacted: false,
+        };
+    }
+    // First pass: Truncate large tool results in all messages
+    let toolResultsTruncated = 0;
+    let tokensSavedFromToolResults = 0;
+    const messagesWithTruncatedTools = messages.map((m) => {
+        if (!m.toolCalls || m.toolCalls.length === 0)
+            return m;
+        const { toolCalls, tokensSaved } = processToolCallsForCompaction(m.toolCalls, config);
+        if (tokensSaved > 0) {
+            toolResultsTruncated++;
+            tokensSavedFromToolResults += tokensSaved;
+        }
+        return { ...m, toolCalls };
+    });
+    // Check if tool truncation was enough
+    const tokensAfterToolTruncation = estimateMessagesTokens(messagesWithTruncatedTools);
+    const contextWindow = getContextWindow(model);
+    const targetTokens = contextWindow * config.targetAfterCompaction;
+    if (tokensAfterToolTruncation <= contextWindow * config.compactThreshold) {
+        // Tool truncation was sufficient
+        return {
+            messages: messagesWithTruncatedTools,
+            originalCount,
+            compactedCount: messagesWithTruncatedTools.length,
+            tokensReduced: tokensSavedFromToolResults,
+            wasCompacted: tokensSavedFromToolResults > 0,
+            toolResultsTruncated: toolResultsTruncated > 0 ? toolResultsTruncated : undefined,
+        };
+    }
+    // Second pass: Use priority-based selection or summarization
+    const preserveCount = Math.min(config.preserveRecentCount, messagesWithTruncatedTools.length - 1);
+    const messagesToSummarize = messagesWithTruncatedTools.slice(0, -preserveCount);
+    const messagesToKeep = messagesWithTruncatedTools.slice(-preserveCount);
+    // Try priority-based selection first for moderate compaction needs
+    const tokensNeeded = tokensAfterToolTruncation - targetTokens;
+    const olderMessagesTokens = estimateMessagesTokens(messagesToSummarize);
+    if (tokensNeeded < olderMessagesTokens * 0.5) {
+        // We only need to remove ~50% of older messages, use priority selection
+        const selected = selectMessagesForRetention(messagesWithTruncatedTools, Math.floor(targetTokens), config);
+        const selectedTokens = estimateMessagesTokens(selected);
+        return {
+            messages: selected,
+            originalCount,
+            compactedCount: selected.length,
+            tokensReduced: originalTokens - selectedTokens,
+            wasCompacted: true,
+            toolResultsTruncated: toolResultsTruncated > 0 ? toolResultsTruncated : undefined,
+        };
+    }
+    // Full summarization needed for heavy compaction
+    const summary = await summarizeMessages(messagesToSummarize, model);
+    // Create summary message
+    const summaryMessage = {
+        id: `summary-${Date.now()}`,
+        conversationId: messages[0]?.conversationId || '',
+        role: 'system',
+        content: `[CONVERSATION SUMMARY - ${messagesToSummarize.length} messages compacted]\n\n${summary}`,
+        createdAt: new Date().toISOString(),
+    };
+    // New message array: summary + recent messages
+    const compactedMessages = [summaryMessage, ...messagesToKeep];
+    const compactedTokens = estimateMessagesTokens(compactedMessages);
+    return {
+        messages: compactedMessages,
+        summary,
+        originalCount,
+        compactedCount: compactedMessages.length,
+        tokensReduced: originalTokens - compactedTokens,
+        wasCompacted: true,
+        toolResultsTruncated: toolResultsTruncated > 0 ? toolResultsTruncated : undefined,
+    };
+}
+/**
+ * Get memory stats for a conversation
+ */
+export function getMemoryStats(messages, model, config = DEFAULT_MEMORY_CONFIG) {
+    const contextWindow = getContextWindow(model);
+    const estimatedTokens = estimateMessagesTokens(messages);
+    const summaryCount = messages.filter((m) => m.content.startsWith('[CONVERSATION SUMMARY')).length;
+    return {
+        messageCount: messages.length,
+        estimatedTokens,
+        contextWindow,
+        usagePercentage: (estimatedTokens / contextWindow) * 100,
+        needsCompaction: needsCompaction(messages, model, config),
+        summaryCount,
+    };
+}
+export default {
+    DEFAULT_MEMORY_CONFIG,
+    estimateTokens,
+    estimateMessagesTokens,
+    getContextWindow,
+    needsCompaction,
+    summarizeMessages,
+    compactMessages,
+    getMemoryStats,
+    // Advanced pruning
+    truncateToolResult,
+    processToolCallsForCompaction,
+    scoreMessageImportance,
+    selectMessagesForRetention,
+};
+//# sourceMappingURL=memory.js.map

package/dist/chat/message-handler.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Messenger-to-AI Pipeline
+ *
+ * Handles incoming messages from all 22 chat providers (Telegram, Discord,
+ * Slack, WhatsApp, etc.) by routing them through the AI and replying on
+ * the same channel.
+ *
+ * Architecture inspired by OpenClaw (text chunking, channel dock pattern)
+ * and NanoClaw (cursor rollback on error, concurrency limiting, typing
+ * indicators, GroupQueue pattern).
+ *
+ * Flow:
+ *   Provider webhook -> parseMessage() -> IncomingMessage
+ *     -> getChatRegistry().emit({ type: 'message', payload })
+ *     -> handleIncomingMessage()
+ *         1. shouldRespond() mention gating
+ *         2. checkRateLimit() sliding window
+ *         3. getOrCreateConversation() keyed by provider:accountId:chatId
+ *         4. Load history + compaction check
+ *         5. buildSystemPrompt() with channel personality
+ *         6. aiProvider.chat() call AI
+ *         7. provider.outbound.send() reply to user
+ *         8. addMessage() x2 persist user + assistant
+ */
+import type { ChatEvent, ChatContext as RegistryChatContext } from './providers/types.js';
+/** In-memory cache: "telegram:default:12345" -> conversationId */
+declare const channelConversations: Map<string, string>;
+declare function getOrCreateChannelConversation(provider: string, accountId: string, chatId: string, chatName?: string): Promise<string>;
+declare function friendlyErrorReply(error: unknown): string;
+declare function handleIncomingMessage(event: ChatEvent, _context: RegistryChatContext): Promise<void>;
+/**
+ * Register the messenger message handler.
+ * Call once at startup after conversation tables are initialized.
+ * Returns an unsubscribe function.
+ */
+export declare function registerMessageHandler(): () => void;
+export { handleIncomingMessage, getOrCreateChannelConversation, friendlyErrorReply, channelConversations };
+//# sourceMappingURL=message-handler.d.ts.map

package/dist/chat/message-handler.js

@@ -0,0 +1,274 @@
+/**
+ * Messenger-to-AI Pipeline
+ *
+ * Handles incoming messages from all 22 chat providers (Telegram, Discord,
+ * Slack, WhatsApp, etc.) by routing them through the AI and replying on
+ * the same channel.
+ *
+ * Architecture inspired by OpenClaw (text chunking, channel dock pattern)
+ * and NanoClaw (cursor rollback on error, concurrency limiting, typing
+ * indicators, GroupQueue pattern).
+ *
+ * Flow:
+ *   Provider webhook -> parseMessage() -> IncomingMessage
+ *     -> getChatRegistry().emit({ type: 'message', payload })
+ *     -> handleIncomingMessage()
+ *         1. shouldRespond() mention gating
+ *         2. checkRateLimit() sliding window
+ *         3. getOrCreateConversation() keyed by provider:accountId:chatId
+ *         4. Load history + compaction check
+ *         5. buildSystemPrompt() with channel personality
+ *         6. aiProvider.chat() call AI
+ *         7. provider.outbound.send() reply to user
+ *         8. addMessage() x2 persist user + assistant
+ */
+import { logger } from '../utils/logger.js';
+import { getChatRegistry } from './providers/registry.js';
+import { getGroupChatManager } from './group.js';
+import { buildSystemPrompt } from './system-prompts.js';
+import { createConversation, addMessage, getConversationMessages, } from './conversations.js';
+import { needsCompaction, compactMessages } from './memory.js';
+import { getSessionModel } from './execution/tools/session-status.js';
+// CONSTANTS
+/** Max concurrent AI calls to prevent overload (inspired by NanoClaw GroupQueue) */
+const MAX_CONCURRENT = parseInt(process.env['POOL_MAX_CONCURRENT'] ?? '50', 10);
+/** Currently processing count */
+let activeCount = 0;
+// CONVERSATION CACHE
+/** In-memory cache: "telegram:default:12345" -> conversationId */
+const channelConversations = new Map();
+let sendMessagePromise = null;
+async function sendProviderMessage(message) {
+    if (!sendMessagePromise) {
+        sendMessagePromise = import('./providers/index.js').then((mod) => mod.sendMessage);
+    }
+    const sendMessage = await sendMessagePromise;
+    return sendMessage(message);
+}
+function makeConversationKey(provider, accountId, chatId) {
+    return `${provider}:${accountId}:${chatId}`;
+}
+async function getOrCreateChannelConversation(provider, accountId, chatId, chatName) {
+    const key = makeConversationKey(provider, accountId, chatId);
+    // Cache hit
+    const cached = channelConversations.get(key);
+    if (cached)
+        return cached;
+    // No DB metadata column for messenger key, so create a new conversation.
+    // Title encodes the provider and chat for discoverability.
+    const title = chatName
+        ? `${provider} - ${chatName}`
+        : `${provider} #${chatId.slice(0, 12)}`;
+    const conversation = await createConversation({
+        title,
+        presetId: 'profclaw-assistant',
+    });
+    channelConversations.set(key, conversation.id);
+    return conversation.id;
+}
+// ERROR HELPERS
+function friendlyErrorReply(error) {
+    if (!(error instanceof Error)) {
+        return 'Something went wrong. Please try again.';
+    }
+    const msg = error.message.toLowerCase();
+    if (msg.includes('rate limit') || msg.includes('429') || msg.includes('too many requests')) {
+        return "I'm being rate limited by the AI provider. Please wait a moment.";
+    }
+    if (msg.includes('quota') || msg.includes('insufficient_quota') || msg.includes('billing')) {
+        return 'My API quota is used up. Please check the billing.';
+    }
+    if (msg.includes('401') || msg.includes('403') || msg.includes('unauthorized') || msg.includes('invalid.*key') || msg.includes('authentication')) {
+        return "My API key isn't working. Configuration needed.";
+    }
+    if (msg.includes('timeout') || msg.includes('timed out') || msg.includes('econnrefused')) {
+        return "The AI service isn't responding. Try again shortly.";
+    }
+    if (msg.includes('context_length') || msg.includes('too long') || msg.includes('token')) {
+        return 'The conversation is too long. Starting a fresh context may help.';
+    }
+    return 'Something went wrong. Please try again.';
+}
+// MESSAGE HANDLER
+async function handleIncomingMessage(event, _context) {
+    const message = event.payload;
+    // Skip if no text content
+    if (!message.text?.trim())
+        return;
+    // Concurrency guard (NanoClaw pattern) - send busy reply instead of silent drop
+    if (activeCount >= MAX_CONCURRENT) {
+        logger.warn('[MessageHandler] At concurrency limit', {
+            provider: message.provider,
+            chatId: message.chatId,
+            activeCount,
+        });
+        try {
+            await sendProviderMessage({
+                provider: message.provider,
+                accountId: message.accountId,
+                to: message.chatId,
+                text: "I'm handling many requests right now. Please try again in a moment.",
+                threadId: message.threadId,
+                replyToId: message.id,
+            });
+        }
+        catch {
+            // If we can't even send the busy reply, just log and move on
+        }
+        return;
+    }
+    const groupManager = getGroupChatManager();
+    // Mention gating - respects DM, reply, mention rules
+    if (!groupManager.shouldRespond(message)) {
+        return;
+    }
+    // Rate limiting (sliding window)
+    const rateCheck = groupManager.checkRateLimit(message.senderId, message.chatId);
+    if (!rateCheck.allowed) {
+        const cooldownMsg = rateCheck.message ?? "You're sending messages too fast. Please wait a moment.";
+        await sendProviderMessage({
+            provider: message.provider,
+            accountId: message.accountId,
+            to: message.chatId,
+            text: cooldownMsg,
+            threadId: message.threadId,
+            replyToId: message.id,
+        });
+        return;
+    }
+    // Track user activity
+    groupManager.trackUser(message);
+    activeCount++;
+    let responseSentToUser = false;
+    try {
+        // Get or create conversation keyed by provider:accountId:chatId
+        const conversationId = await getOrCreateChannelConversation(message.provider, message.accountId, message.chatId, message.chatName);
+        // Load history
+        const history = await getConversationMessages(conversationId);
+        // Compaction check
+        let messages = history;
+        if (needsCompaction(messages)) {
+            const result = await compactMessages(messages);
+            messages = result.messages;
+        }
+        // Resolve model - per-conversation override or system default
+        const modelOverride = getSessionModel(conversationId);
+        // Build system prompt with channel personality
+        const personality = groupManager.getPersonality(message.chatId, message.provider);
+        const promptContext = {
+            user: {
+                name: message.senderName || message.senderUsername,
+            },
+            runtime: {
+                model: modelOverride,
+                conversationId,
+            },
+        };
+        let systemPrompt = await buildSystemPrompt('profclaw-assistant', promptContext);
+        if (personality?.systemPrompt) {
+            systemPrompt += `\n\n${personality.systemPrompt}`;
+        }
+        // Convert history to ChatMessage format for the AI
+        const aiMessages = messages.map((m) => ({
+            id: m.id,
+            role: m.role,
+            content: m.content,
+            timestamp: m.createdAt,
+        }));
+        // Add the new user message
+        aiMessages.push({
+            id: message.id,
+            role: 'user',
+            content: message.text,
+            timestamp: message.timestamp.toISOString(),
+        });
+        // Call AI (lazy import to avoid loading all AI SDKs at startup)
+        const { aiProvider } = await import('../providers/ai-sdk.js');
+        const response = await aiProvider.chat({
+            messages: aiMessages,
+            model: modelOverride,
+            systemPrompt,
+            temperature: 0.7,
+        });
+        // Get reply target (thread/reply context from group manager)
+        const replyTarget = groupManager.getReplyTarget(message);
+        // Send response back to the channel
+        const sendResult = await sendProviderMessage({
+            provider: message.provider,
+            accountId: message.accountId,
+            to: message.chatId,
+            text: response.content,
+            threadId: replyTarget.threadId,
+            replyToId: replyTarget.replyToId,
+        });
+        responseSentToUser = sendResult.success;
+        // Persist both messages
+        await addMessage({
+            conversationId,
+            role: 'user',
+            content: message.text,
+        });
+        await addMessage({
+            conversationId,
+            role: 'assistant',
+            content: response.content,
+            model: response.model,
+            provider: response.provider,
+            tokenUsage: {
+                prompt: response.usage.promptTokens,
+                completion: response.usage.completionTokens,
+                total: response.usage.totalTokens,
+            },
+            cost: response.usage.cost,
+        });
+        logger.info('[MessageHandler] Processed message', {
+            provider: message.provider,
+            chatId: message.chatId,
+            conversationId,
+            model: response.model,
+            tokens: response.usage.totalTokens,
+        });
+    }
+    catch (error) {
+        logger.error('[MessageHandler] Failed to process message', {
+            provider: message.provider,
+            chatId: message.chatId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        // Send friendly error reply (NanoClaw pattern: only if we haven't sent output yet)
+        if (!responseSentToUser) {
+            try {
+                await sendProviderMessage({
+                    provider: message.provider,
+                    accountId: message.accountId,
+                    to: message.chatId,
+                    text: friendlyErrorReply(error),
+                    threadId: message.threadId,
+                    replyToId: message.id,
+                });
+            }
+            catch {
+                // If we can't even send the error, just log it
+                logger.error('[MessageHandler] Failed to send error reply');
+            }
+        }
+    }
+    finally {
+        activeCount--;
+    }
+}
+// REGISTRATION
+/**
+ * Register the messenger message handler.
+ * Call once at startup after conversation tables are initialized.
+ * Returns an unsubscribe function.
+ */
+export function registerMessageHandler() {
+    const registry = getChatRegistry();
+    const unsubscribe = registry.on('message', handleIncomingMessage);
+    logger.info('[MessageHandler] Registered messenger-to-AI pipeline');
+    return unsubscribe;
+}
+// Exported for testing
+export { handleIncomingMessage, getOrCreateChannelConversation, friendlyErrorReply, channelConversations };
+//# sourceMappingURL=message-handler.js.map