@poolzin/pool-bot 2026.3.6 → 2026.3.9

package/dist/context-engine/summarizing.js

@@ -0,0 +1,293 @@
+/**
+ * Summarizing Context Engine
+ *
+ * Advanced context management with intelligent summarization.
+ * Provides better token efficiency than the legacy engine.
+ *
+ * Features:
+ * - Sliding window with summarization
+ * - Token-aware message prioritization
+ * - Configurable summarization strategy
+ */
+/**
+ * Token estimator using character-based approximation
+ * More accurate than simple division
+ */
+function estimateTokens(text) {
+    // GPT-style tokenization approximation
+    // - Average English word: ~1.3 tokens
+    // - Whitespace and punctuation: ~0.5 tokens each
+    // - Code/non-English: ~2-3 tokens per word
+    const words = text.trim().split(/\s+/).length;
+    const chars = text.length;
+    const punctuation = (text.match(/[.,!?;:()[\]{}"']/g) ?? []).length;
+    // Heuristic: code detection (high special char ratio)
+    const specialChars = (text.match(/[^\w\s]/g) ?? []).length;
+    const isCode = specialChars / chars > 0.15;
+    if (isCode) {
+        return Math.ceil(chars / 2.5); // Code: ~2.5 chars/token
+    }
+    // Regular text estimation
+    const wordTokens = words * 1.3;
+    const punctTokens = punctuation * 0.5;
+    const overhead = Math.ceil(chars / 100); // Metadata overhead
+    return Math.ceil(wordTokens + punctTokens + overhead);
+}
+/**
+ * Summarizing Context Engine
+ *
+ * Implements sliding window with intelligent summarization:
+ * 1. Keep system messages (highest priority)
+ * 2. Keep recent conversation (high priority)
+ * 3. Summarize older messages into running summary
+ */
+export class SummarizingContextEngine {
+    info = {
+        id: "summarizing",
+        name: "Summarizing Context Engine",
+        description: "Sliding window with intelligent message summarization",
+        supportsVectorSearch: false,
+        supportsFullTextSearch: false,
+        tokenLimit: undefined,
+    };
+    config;
+    sessions = new Map();
+    constructor(config) {
+        this.config = {
+            maxTokens: config?.maxTokens ?? 8000,
+            keepRecentMessages: config?.keepRecentMessages ?? 6,
+            summarizationThreshold: config?.summarizationThreshold ?? 4000,
+        };
+    }
+    async bootstrap(params) {
+        try {
+            this.sessions.set(params.sessionId, {
+                messages: [],
+                summary: undefined,
+                summaryTokens: 0,
+                lastAccessed: new Date(),
+                totalIngested: 0,
+            });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async ingest(params) {
+        try {
+            const session = this.sessions.get(params.sessionId);
+            if (!session) {
+                return {
+                    success: false,
+                    error: `Session ${params.sessionId} not found`,
+                };
+            }
+            const content = typeof params.message.content === "string"
+                ? params.message.content
+                : JSON.stringify(params.message.content);
+            const estimatedTokens = estimateTokens(content);
+            // Calculate priority
+            const priority = this.calculatePriority(params.message, session.messages.length);
+            const prioritized = {
+                ...params.message,
+                priority,
+                estimatedTokens,
+                internalTimestamp: Date.now(),
+            };
+            session.messages.push(prioritized);
+            session.totalIngested++;
+            session.lastAccessed = new Date();
+            // Check if we need to compact
+            const currentTokens = this.getTotalTokenCount(session);
+            if (currentTokens > this.config.summarizationThreshold) {
+                await this.compact({ sessionId: params.sessionId });
+            }
+            return {
+                success: true,
+                tokensConsumed: estimatedTokens,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async assemble(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            return {
+                messages: params.messages ?? [],
+                totalTokens: 0,
+                wasTruncated: false,
+            };
+        }
+        // Build context: summary + recent messages
+        const resultMessages = [];
+        let totalTokens = 0;
+        // Add summary if exists
+        if (session.summary) {
+            const summaryMsg = {
+                role: "system",
+                content: `[Previous conversation summary: ${session.summary}]`,
+                metadata: { isSummary: true },
+            };
+            resultMessages.push(summaryMsg);
+            totalTokens += session.summaryTokens;
+        }
+        // Add messages within budget
+        const budget = params.tokenBudget ?? this.config.maxTokens;
+        const sortedMessages = [...session.messages].sort((a, b) => b.priority - a.priority || a.internalTimestamp - b.internalTimestamp);
+        const included = [];
+        const excluded = [];
+        for (const msg of sortedMessages) {
+            if (totalTokens + msg.estimatedTokens <= budget) {
+                // Strip priority metadata before returning
+                const { priority: _, estimatedTokens: __, internalTimestamp: ___, ...cleanMsg } = msg;
+                included.push(cleanMsg);
+                totalTokens += msg.estimatedTokens;
+            }
+            else {
+                const { priority: _, estimatedTokens: __, internalTimestamp: ___, ...cleanMsg } = msg;
+                excluded.push(cleanMsg);
+            }
+        }
+        // Sort by internalTimestamp for final output
+        included.sort((a, b) => {
+            const ta = session.messages.find(m => m.id === a.id)?.internalTimestamp ?? 0;
+            const tb = session.messages.find(m => m.id === b.id)?.internalTimestamp ?? 0;
+            return ta - tb;
+        });
+        resultMessages.push(...included);
+        return {
+            messages: resultMessages,
+            totalTokens,
+            wasTruncated: excluded.length > 0,
+            excludedMessages: excluded.length > 0 ? excluded : undefined,
+        };
+    }
+    async compact(params) {
+        try {
+            const session = this.sessions.get(params.sessionId);
+            if (!session || session.messages.length <= this.config.keepRecentMessages) {
+                return { success: true, tokensSaved: 0 };
+            }
+            const originalTokens = this.getTotalTokenCount(session);
+            // Messages to summarize (older ones)
+            const toSummarize = session.messages.slice(0, -this.config.keepRecentMessages);
+            const toKeep = session.messages.slice(-this.config.keepRecentMessages);
+            if (toSummarize.length === 0) {
+                return { success: true, tokensSaved: 0 };
+            }
+            // Generate summary (simplified - in production, use LLM)
+            const summary = this.generateSummary(toSummarize);
+            const _summaryTokens = estimateTokens(summary);
+            // Update session
+            session.summary = session.summary
+                ? `${session.summary} ${summary}`
+                : summary;
+            session.summaryTokens = estimateTokens(session.summary);
+            session.messages = toKeep;
+            const newTokens = this.getTotalTokenCount(session);
+            const tokensSaved = originalTokens - newTokens;
+            return {
+                success: true,
+                summary: session.summary,
+                tokensSaved: Math.max(0, tokensSaved),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async cleanup(params) {
+        this.sessions.delete(params.sessionId);
+    }
+    async getStats(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            return { messageCount: 0 };
+        }
+        return {
+            messageCount: session.messages.length,
+            totalTokens: this.getTotalTokenCount(session),
+            lastAccessed: session.lastAccessed,
+        };
+    }
+    /**
+     * Calculate message priority (0-100)
+     */
+    calculatePriority(message, index) {
+        let priority = 50; // Base priority
+        // System messages are highest priority
+        if (message.role === "system") {
+            priority += 40;
+        }
+        // Recent messages get boost
+        if (index > -5) {
+            priority += 20;
+        }
+        // Messages with tool calls/results are important
+        if (message.metadata?.tool_calls ||
+            message.metadata?.tool_call_id) {
+            priority += 15;
+        }
+        return Math.min(100, priority);
+    }
+    /**
+     * Get total token count for session
+     */
+    getTotalTokenCount(session) {
+        const messageTokens = session.messages.reduce((sum, m) => sum + m.estimatedTokens, 0);
+        return messageTokens + session.summaryTokens;
+    }
+    /**
+     * Generate a simple summary of messages
+     * In production, this would use an LLM
+     */
+    generateSummary(messages) {
+        const userMsgs = messages.filter((m) => m.role === "user");
+        const assistantMsgs = messages.filter((m) => m.role === "assistant");
+        const topics = this.extractTopics(messages);
+        return (`Conversation covered ${userMsgs.length} user queries and ${assistantMsgs.length} responses. ` +
+            `Topics: ${topics.join(", ") || "general discussion"}.`);
+    }
+    /**
+     * Extract key topics from messages (simplified)
+     */
+    extractTopics(messages) {
+        const allContent = messages
+            .map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content))
+            .join(" ")
+            .toLowerCase();
+        // Simple keyword extraction
+        const keywords = [
+            "code",
+            "function",
+            "error",
+            "bug",
+            "fix",
+            "implement",
+            "create",
+            "update",
+            "delete",
+            "configure",
+            "setup",
+        ];
+        return keywords.filter((kw) => allContent.includes(kw)).slice(0, 3);
+    }
+}
+/**
+ * Create a summarizing context engine
+ */
+export function createSummarizingContextEngine(config) {
+    return new SummarizingContextEngine(config);
+}

package/dist/context-engine/types.js

@@ -0,0 +1,7 @@
+/**
+ * Context Engine - Pluggable conversation context management
+ *
+ * Provides a modular architecture for managing conversation context
+ * with support for different storage and retrieval strategies.
+ */
+export {};

package/dist/discord/monitor/message-handler.preflight.js

@@ -66,7 +66,8 @@ export async function preflightDiscordMessage(params) {
         logVerbose(`discord: drop message ${message.id} (missing channel id)`);
         return null;
     }
-    const allowBots = params.discordConfig?.allowBots ?? false;
+    const allowBotsSetting = params.discordConfig?.allowBots;
+    const allowBotsMode = allowBotsSetting === "mentions" ? "mentions" : allowBotsSetting === true ? "all" : "off";
     if (params.botUserId && author.id === params.botUserId) {
         // Always ignore own messages to prevent self-reply loops
         return null;
@@ -92,7 +93,7 @@ export async function preflightDiscordMessage(params) {
         pluralkitInfo,
     });
     if (author.bot) {
-        if (!allowBots && !sender.isPluralKit) {
+        if (allowBotsMode === "off" && !sender.isPluralKit) {
             logVerbose("discord: drop bot message (allowBots=false)");
             return null;
         }
@@ -523,6 +524,14 @@ export async function preflightDiscordMessage(params) {
         });
         return null;
     }
+    if (author.bot && !sender.isPluralKit && allowBotsMode === "mentions") {
+        const botMentioned = isDirectMessage || wasMentioned || implicitMention;
+        if (!botMentioned) {
+            logDebug(`[discord-preflight] drop: bot message missing mention (allowBots=mentions)`);
+            logVerbose("discord: drop bot message (allowBots=mentions, missing mention)");
+            return null;
+        }
+    }
     if (!messageText) {
         logDebug(`[discord-preflight] drop: empty content`);
         logVerbose(`discord: drop message ${message.id} (empty content)`);

package/dist/gateway/http-common.js

@@ -5,9 +5,14 @@ import { readJsonBody } from "./hooks.js";
  * Content-Security-Policy are intentionally omitted here because some handlers
  * (canvas host, A2UI) serve content that may be loaded inside frames.
  */
-export function setDefaultSecurityHeaders(res) {
+export function setDefaultSecurityHeaders(res, opts) {
     res.setHeader("X-Content-Type-Options", "nosniff");
     res.setHeader("Referrer-Policy", "no-referrer");
+    res.setHeader("Permissions-Policy", "camera=(), microphone=(), geolocation=()");
+    const strictTransportSecurity = opts?.strictTransportSecurity;
+    if (typeof strictTransportSecurity === "string" && strictTransportSecurity.length > 0) {
+        res.setHeader("Strict-Transport-Security", strictTransportSecurity);
+    }
 }
 export function sendJson(res, status, body) {
     res.statusCode = status;

package/dist/hooks/fire-and-forget.js

@@ -0,0 +1,6 @@
+import { logVerbose } from "../globals.js";
+export function fireAndForgetHook(task, label, logger = logVerbose) {
+    void task.catch((err) => {
+        logger(`${label}: ${String(err)}`);
+    });
+}

package/dist/hooks/internal-hooks.js

@@ -5,8 +5,18 @@
  * like command processing, session lifecycle, etc.
  */
 import { createSubsystemLogger } from "../logging/subsystem.js";
-/** Registry of hook handlers by event key */
-const handlers = new Map();
+/**
+ * Registry of hook handlers by event key.
+ *
+ * Uses a globalThis singleton so that registerInternalHook and
+ * triggerInternalHook always share the same Map even when the bundler
+ * emits multiple copies of this module into separate chunks (bundle
+ * splitting). Without the singleton, handlers registered in one chunk
+ * are invisible to triggerInternalHook in another chunk, causing hooks
+ * to silently fire with zero handlers.
+ */
+const _g = globalThis;
+const handlers = (_g.__poolbot_internal_hook_handlers__ ??= new Map());
 const log = createSubsystemLogger("internal-hooks");
 /**
  * Register a hook handler for a specific event type or event:action combination
@@ -112,45 +122,80 @@ export function createInternalHookEvent(type, action, sessionKey, context = {})
         messages: [],
     };
 }
+function isHookEventTypeAndAction(event, type, action) {
+    return event.type === type && event.action === action;
+}
+function getHookContext(event) {
+    const context = event.context;
+    if (!context || typeof context !== "object") {
+        return null;
+    }
+    return context;
+}
+function hasStringContextField(context, key) {
+    return typeof context[key] === "string";
+}
+function hasBooleanContextField(context, key) {
+    return typeof context[key] === "boolean";
+}
 export function isAgentBootstrapEvent(event) {
-    if (event.type !== "agent" || event.action !== "bootstrap") {
+    if (!isHookEventTypeAndAction(event, "agent", "bootstrap")) {
         return false;
     }
-    const context = event.context;
-    if (!context || typeof context !== "object") {
+    const context = getHookContext(event);
+    if (!context) {
         return false;
     }
-    if (typeof context.workspaceDir !== "string") {
+    if (!hasStringContextField(context, "workspaceDir")) {
         return false;
     }
     return Array.isArray(context.bootstrapFiles);
 }
 export function isGatewayStartupEvent(event) {
-    if (event.type !== "gateway" || event.action !== "startup") {
+    if (!isHookEventTypeAndAction(event, "gateway", "startup")) {
         return false;
     }
-    const context = event.context;
-    return Boolean(context && typeof context === "object");
+    return Boolean(getHookContext(event));
 }
 export function isMessageReceivedEvent(event) {
-    if (event.type !== "message" || event.action !== "received") {
+    if (!isHookEventTypeAndAction(event, "message", "received")) {
         return false;
     }
-    const context = event.context;
-    if (!context || typeof context !== "object") {
+    const context = getHookContext(event);
+    if (!context) {
         return false;
     }
-    return typeof context.from === "string" && typeof context.channelId === "string";
+    return hasStringContextField(context, "from") && hasStringContextField(context, "channelId");
 }
 export function isMessageSentEvent(event) {
-    if (event.type !== "message" || event.action !== "sent") {
+    if (!isHookEventTypeAndAction(event, "message", "sent")) {
         return false;
     }
-    const context = event.context;
-    if (!context || typeof context !== "object") {
+    const context = getHookContext(event);
+    if (!context) {
+        return false;
+    }
+    return (hasStringContextField(context, "to") &&
+        hasStringContextField(context, "channelId") &&
+        hasBooleanContextField(context, "success"));
+}
+export function isMessageTranscribedEvent(event) {
+    if (!isHookEventTypeAndAction(event, "message", "transcribed")) {
+        return false;
+    }
+    const context = getHookContext(event);
+    if (!context) {
+        return false;
+    }
+    return (hasStringContextField(context, "transcript") && hasStringContextField(context, "channelId"));
+}
+export function isMessagePreprocessedEvent(event) {
+    if (!isHookEventTypeAndAction(event, "message", "preprocessed")) {
+        return false;
+    }
+    const context = getHookContext(event);
+    if (!context) {
         return false;
     }
-    return (typeof context.to === "string" &&
-        typeof context.channelId === "string" &&
-        typeof context.success === "boolean");
+    return hasStringContextField(context, "channelId");
 }

package/dist/hooks/message-hook-mappers.js

@@ -0,0 +1,179 @@
+export function deriveInboundMessageHookContext(ctx, overrides) {
+    const content = overrides?.content ??
+        (typeof ctx.BodyForCommands === "string"
+            ? ctx.BodyForCommands
+            : typeof ctx.RawBody === "string"
+                ? ctx.RawBody
+                : typeof ctx.Body === "string"
+                    ? ctx.Body
+                    : "");
+    const channelId = (ctx.OriginatingChannel ?? ctx.Surface ?? ctx.Provider ?? "").toLowerCase();
+    const conversationId = ctx.OriginatingTo ?? ctx.To ?? ctx.From ?? undefined;
+    const isGroup = Boolean(ctx.GroupSubject || ctx.GroupChannel);
+    return {
+        from: ctx.From ?? "",
+        to: ctx.To,
+        content,
+        body: ctx.Body,
+        bodyForAgent: ctx.BodyForAgent,
+        transcript: ctx.Transcript,
+        timestamp: typeof ctx.Timestamp === "number" && Number.isFinite(ctx.Timestamp)
+            ? ctx.Timestamp
+            : undefined,
+        channelId,
+        accountId: ctx.AccountId,
+        conversationId,
+        messageId: overrides?.messageId ??
+            ctx.MessageSidFull ??
+            ctx.MessageSid ??
+            ctx.MessageSidFirst ??
+            ctx.MessageSidLast,
+        senderId: ctx.SenderId,
+        senderName: ctx.SenderName,
+        senderUsername: ctx.SenderUsername,
+        senderE164: ctx.SenderE164,
+        provider: ctx.Provider,
+        surface: ctx.Surface,
+        threadId: ctx.MessageThreadId,
+        mediaPath: ctx.MediaPath,
+        mediaType: ctx.MediaType,
+        originatingChannel: ctx.OriginatingChannel,
+        originatingTo: ctx.OriginatingTo,
+        guildId: ctx.GroupSpace,
+        channelName: ctx.GroupChannel,
+        isGroup,
+        groupId: isGroup ? conversationId : undefined,
+    };
+}
+export function buildCanonicalSentMessageHookContext(params) {
+    return {
+        to: params.to,
+        content: params.content,
+        success: params.success,
+        error: params.error,
+        channelId: params.channelId,
+        accountId: params.accountId,
+        conversationId: params.conversationId ?? params.to,
+        messageId: params.messageId,
+        isGroup: params.isGroup,
+        groupId: params.groupId,
+    };
+}
+export function toPluginMessageContext(canonical) {
+    return {
+        channelId: canonical.channelId,
+        accountId: canonical.accountId,
+        conversationId: canonical.conversationId,
+    };
+}
+export function toPluginMessageReceivedEvent(canonical) {
+    return {
+        from: canonical.from,
+        content: canonical.content,
+        timestamp: canonical.timestamp,
+        metadata: {
+            to: canonical.to,
+            provider: canonical.provider,
+            surface: canonical.surface,
+            threadId: canonical.threadId,
+            originatingChannel: canonical.originatingChannel,
+            originatingTo: canonical.originatingTo,
+            messageId: canonical.messageId,
+            senderId: canonical.senderId,
+            senderName: canonical.senderName,
+            senderUsername: canonical.senderUsername,
+            senderE164: canonical.senderE164,
+            guildId: canonical.guildId,
+            channelName: canonical.channelName,
+        },
+    };
+}
+export function toPluginMessageSentEvent(canonical) {
+    return {
+        to: canonical.to,
+        content: canonical.content,
+        success: canonical.success,
+        ...(canonical.error ? { error: canonical.error } : {}),
+    };
+}
+export function toInternalMessageReceivedContext(canonical) {
+    return {
+        from: canonical.from,
+        content: canonical.content,
+        timestamp: canonical.timestamp,
+        channelId: canonical.channelId,
+        accountId: canonical.accountId,
+        conversationId: canonical.conversationId,
+        messageId: canonical.messageId,
+        metadata: {
+            to: canonical.to,
+            provider: canonical.provider,
+            surface: canonical.surface,
+            threadId: canonical.threadId,
+            senderId: canonical.senderId,
+            senderName: canonical.senderName,
+            senderUsername: canonical.senderUsername,
+            senderE164: canonical.senderE164,
+            guildId: canonical.guildId,
+            channelName: canonical.channelName,
+        },
+    };
+}
+export function toInternalMessageTranscribedContext(canonical, cfg) {
+    return {
+        from: canonical.from,
+        to: canonical.to,
+        body: canonical.body,
+        bodyForAgent: canonical.bodyForAgent,
+        transcript: canonical.transcript ?? "",
+        timestamp: canonical.timestamp,
+        channelId: canonical.channelId,
+        conversationId: canonical.conversationId,
+        messageId: canonical.messageId,
+        senderId: canonical.senderId,
+        senderName: canonical.senderName,
+        senderUsername: canonical.senderUsername,
+        provider: canonical.provider,
+        surface: canonical.surface,
+        mediaPath: canonical.mediaPath,
+        mediaType: canonical.mediaType,
+        cfg,
+    };
+}
+export function toInternalMessagePreprocessedContext(canonical, cfg) {
+    return {
+        from: canonical.from,
+        to: canonical.to,
+        body: canonical.body,
+        bodyForAgent: canonical.bodyForAgent,
+        transcript: canonical.transcript,
+        timestamp: canonical.timestamp,
+        channelId: canonical.channelId,
+        conversationId: canonical.conversationId,
+        messageId: canonical.messageId,
+        senderId: canonical.senderId,
+        senderName: canonical.senderName,
+        senderUsername: canonical.senderUsername,
+        provider: canonical.provider,
+        surface: canonical.surface,
+        mediaPath: canonical.mediaPath,
+        mediaType: canonical.mediaType,
+        isGroup: canonical.isGroup,
+        groupId: canonical.groupId,
+        cfg,
+    };
+}
+export function toInternalMessageSentContext(canonical) {
+    return {
+        to: canonical.to,
+        content: canonical.content,
+        success: canonical.success,
+        ...(canonical.error ? { error: canonical.error } : {}),
+        channelId: canonical.channelId,
+        accountId: canonical.accountId,
+        conversationId: canonical.conversationId,
+        messageId: canonical.messageId,
+        ...(canonical.isGroup != null ? { isGroup: canonical.isGroup } : {}),
+        ...(canonical.groupId ? { groupId: canonical.groupId } : {}),
+    };
+}