botinabox 1.8.2 → 1.8.3

package/dist/core/chat/chat-pipeline.js

@@ -0,0 +1,282 @@
+/**
+ * ChatPipeline — configurable 6-layer chat orchestration.
+ * Story 7.4
+ *
+ * Replaces duplicated handler code across apps with a single configurable
+ * pipeline. Apps provide: system prompt, routing rules, LLM call function,
+ * and optional message filter. Everything else is framework-level.
+ *
+ * Layers:
+ *   1. Dedup + Storage (MessageStore)
+ *   2. Fast Response (ChatResponder)
+ *   3. Interpretation (MessageInterpreter)
+ *   4. Post-Interpretation Response
+ *   5. Task Dispatch (TriageRouter)
+ *   6. Task Execution Response
+ */
+import { createHash, randomUUID } from 'node:crypto';
+import { MessageStore } from './message-store.js';
+import { ChatResponder } from './chat-responder.js';
+import { MessageInterpreter } from './message-interpreter.js';
+import { TriageRouter } from './triage-router.js';
+const DEFAULT_DEDUP_WINDOW_MS = 5 * 60 * 1000;
+export class ChatPipeline {
+    db;
+    hooks;
+    messageStore;
+    responder;
+    interpreter;
+    router;
+    channel;
+    messageFilter;
+    capabilities;
+    dedupWindowMs;
+    tasks;
+    wakeups;
+    // In-memory thread → channel mapping for response routing
+    // (before thread_task_map exists)
+    threadChannelMap = new Map();
+    constructor(db, hooks, config) {
+        this.db = db;
+        this.hooks = hooks;
+        this.channel = config.channel ?? 'slack';
+        this.messageFilter = config.messageFilter;
+        this.capabilities = config.capabilities;
+        this.dedupWindowMs = config.dedupWindowMs ?? DEFAULT_DEDUP_WINDOW_MS;
+        this.tasks = config.tasks;
+        this.wakeups = config.wakeups;
+        this.messageStore = new MessageStore(db, hooks);
+        this.responder = new ChatResponder(db, hooks, this.messageStore, {
+            llmCall: config.llmCall,
+            model: config.model ?? 'fast',
+            systemPrompt: config.systemPrompt,
+        });
+        this.interpreter = new MessageInterpreter(db, hooks, {
+            llmCall: config.llmCall,
+            model: config.model ?? 'fast',
+            extractors: config.extractors,
+        });
+        this.router = new TriageRouter(db, hooks, {
+            rules: config.routingRules,
+            fallbackAgent: config.fallbackAgent,
+            llmFallback: config.llmRouting ?? false,
+            persist: true,
+        });
+        this.registerHandlers();
+    }
+    /**
+     * Resolve the Slack channel ID for a thread (for response delivery).
+     */
+    resolveChannel(threadId, taskId) {
+        return this.resolveChannelId(threadId, taskId);
+    }
+    /**
+     * Register the 6-layer pipeline on the HookBus.
+     */
+    registerHandlers() {
+        // Layer 1-5: Inbound message handler
+        this.hooks.register('message.inbound', async (ctx) => {
+            const msg = ctx;
+            if (msg.channel !== this.channel)
+                return;
+            // Optional message filter
+            if (this.messageFilter && !this.messageFilter(msg))
+                return;
+            // Dedup check
+            if (await this.isDuplicate(msg))
+                return;
+            // Resolve thread ID (prefer threadId, fall back to raw ts)
+            const rawTs = msg.raw?.ts;
+            const threadTs = msg.threadId ?? rawTs ?? msg.id;
+            const channelId = msg.account ?? '';
+            // Track thread → channel for response routing
+            if (threadTs && channelId) {
+                this.threadChannelMap.set(threadTs, channelId);
+            }
+            // ── Layer 1: Storage ───────────────────────────────────────
+            const { messageId } = await this.messageStore.storeInbound(msg);
+            // ── Layer 2: Fast Response ─────────────────────────────────
+            // Include recent user message history for channel-wide context
+            const userHistory = await this.messageStore.getUserHistory(msg.from, this.channel, 50);
+            const historyContext = userHistory
+                .map(m => {
+                const dir = m.direction === 'inbound' ? 'User' : 'Bot';
+                return `${dir}: ${m.body?.slice(0, 200) ?? ''}`;
+            })
+                .join('\n');
+            const ackResponse = await this.responder.respond({
+                messageBody: msg.body,
+                threadId: threadTs,
+                channel: this.channel,
+                capabilities: this.capabilities,
+                additionalContext: historyContext ? `\n\nRecent conversation history:\n${historyContext}` : undefined,
+            });
+            await this.responder.sendResponse({
+                text: ackResponse,
+                channel: this.channel,
+                threadId: threadTs,
+                source: 'responder',
+                skipFilter: true,
+                skipRedundancyCheck: true,
+            });
+            // ── Layer 3-5: Async interpretation + dispatch ─────────────
+            void this.interpretAndDispatch(messageId, msg, threadTs, channelId);
+        });
+        // Layer 6: Task execution response
+        this.hooks.register('run.completed', async (ctx) => {
+            const taskId = ctx.taskId;
+            if (!taskId)
+                return;
+            const task = await this.db.get('tasks', { id: taskId });
+            const output = task?.result;
+            if (!output)
+                return;
+            const mappings = await this.db.query('thread_task_map', {
+                where: { task_id: taskId },
+            });
+            if (mappings.length === 0)
+                return;
+            const mapping = mappings[0];
+            await this.responder.sendResponse({
+                text: output,
+                channel: this.channel,
+                threadId: mapping.thread_ts,
+                agentId: ctx.agentId,
+                taskId,
+                source: 'agent',
+            });
+        }, { priority: 90 });
+    }
+    /**
+     * Check and record message dedup (SHA256 hash, configurable window).
+     */
+    async isDuplicate(msg) {
+        const hash = createHash('sha256')
+            .update(`${msg.from}:${msg.body}`)
+            .digest('hex');
+        const cutoff = new Date(Date.now() - this.dedupWindowMs).toISOString();
+        const recent = await this.db.query('message_dedup', {
+            where: { content_hash: hash },
+        });
+        if (recent.some(r => r.created_at > cutoff)) {
+            return true;
+        }
+        await this.db.insert('message_dedup', {
+            content_hash: hash,
+            channel_id: msg.account ?? '',
+        });
+        return false;
+    }
+    /**
+     * Async interpretation + task dispatch (Layers 3-5).
+     */
+    async interpretAndDispatch(messageId, msg, threadTs, channelId) {
+        try {
+            const result = await this.interpreter.interpret(messageId);
+            // Layer 4: Post-Interpretation Response
+            if (result.tasks.length > 0 || result.memories.length > 0) {
+                const summary = this.buildSummary(result);
+                await this.responder.sendResponse({
+                    text: summary,
+                    channel: this.channel,
+                    threadId: threadTs,
+                    source: 'interpretation',
+                });
+            }
+            // Layer 5: Task Dispatch — always dispatch, execution layer decides if action needed
+            if (result.tasks.length > 0) {
+                await this.dispatchTasks(result, msg, threadTs, channelId);
+            }
+        }
+        catch (err) {
+            // Interpretation failure is non-fatal — ack was already sent
+            await this.hooks.emit('interpretation.error', {
+                messageId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    /**
+     * Route and dispatch extracted tasks.
+     */
+    async dispatchTasks(result, msg, threadTs, channelId) {
+        for (const extractedTask of result.tasks) {
+            const { agentSlug: targetSlug } = await this.router.route(msg);
+            if (!targetSlug)
+                continue;
+            const agents = await this.db.query('agents', { where: { slug: targetSlug } });
+            const targetAgent = agents[0];
+            if (!targetAgent)
+                continue;
+            const handlerAgentId = targetAgent.id;
+            // Follow-up in existing thread
+            if (threadTs) {
+                const existing = await this.db.query('thread_task_map', {
+                    where: { thread_ts: threadTs, channel_id: channelId },
+                });
+                if (existing.length > 0) {
+                    const taskId = existing[0].task_id;
+                    const task = await this.tasks.get(taskId);
+                    if (task && task.status !== 'done' && task.status !== 'cancelled') {
+                        const updatedDesc = `${task.description ?? ''}\n\n---\n**Follow-up (${new Date().toISOString()}):**\n${msg.body}`;
+                        await this.tasks.update(taskId, { description: updatedDesc });
+                        await this.wakeups.enqueue(handlerAgentId, 'chat_followup', { taskId });
+                        return;
+                    }
+                }
+            }
+            // New task
+            const description = `## Chat Message\n\n**Channel:** ${channelId}\n**Thread:** ${threadTs}\n**From:** ${msg.from}\n**Time:** ${msg.receivedAt}\n\n---\n\n${extractedTask.description ?? msg.body}`;
+            const taskId = randomUUID();
+            if (threadTs) {
+                await this.db.insert('thread_task_map', {
+                    thread_ts: threadTs,
+                    channel_id: channelId,
+                    task_id: taskId,
+                });
+            }
+            await this.tasks.create({
+                id: taskId,
+                title: extractedTask.title.slice(0, 120),
+                description,
+                assignee_id: handlerAgentId,
+                priority: extractedTask.priority ?? 5,
+            });
+            await this.wakeups.enqueue(handlerAgentId, 'chat_dispatch', { taskId });
+        }
+    }
+    /**
+     * Resolve Slack channel ID from thread_task_map or in-memory fallback.
+     */
+    async resolveChannelId(threadId, taskId) {
+        if (taskId) {
+            const mappings = await this.db.query('thread_task_map', {
+                where: { task_id: taskId },
+            });
+            if (mappings.length > 0)
+                return mappings[0].channel_id;
+        }
+        if (threadId) {
+            const mappings = await this.db.query('thread_task_map', {
+                where: { thread_ts: threadId },
+            });
+            if (mappings.length > 0)
+                return mappings[0].channel_id;
+        }
+        return this.threadChannelMap.get(threadId);
+    }
+    /**
+     * Build human-readable interpretation summary.
+     */
+    buildSummary(result) {
+        const parts = [];
+        if (result.tasks.length > 0) {
+            const names = result.tasks.map((t) => t.title).join(', ');
+            parts.push(`I've identified ${result.tasks.length} task${result.tasks.length > 1 ? 's' : ''}: ${names}. Working on ${result.tasks.length > 1 ? 'them' : 'it'} now.`);
+        }
+        if (result.memories.length > 0) {
+            parts.push(`Noted ${result.memories.length} thing${result.memories.length > 1 ? 's' : ''} to remember.`);
+        }
+        return parts.join(' ');
+    }
+}

package/dist/core/chat/chat-responder.d.ts

@@ -0,0 +1,90 @@
+/**
+ * ChatResponder — fast conversational layer with LLM-filtered responses.
+ * Story 7.2
+ *
+ * Provides rapid (<2s) conversational responses using a cheap LLM (Haiku).
+ * The responder has awareness of tools and capabilities but does NOT execute
+ * anything — it keeps the conversation going while work happens async.
+ *
+ * All outbound messages (direct, post-interpretation, task execution) are
+ * filtered through this layer for human readability and redundancy checking.
+ */
+import type { DataStore } from '../data/data-store.js';
+import type { HookBus } from '../hooks/hook-bus.js';
+import type { ChatMessage } from '../../shared/index.js';
+import type { MessageStore } from './message-store.js';
+export interface ChatResponderConfig {
+    /** System prompt for the conversational responder */
+    systemPrompt?: string;
+    /** Max tokens for context window. Default: 4000 */
+    contextWindowTokens?: number;
+    /** Max recent outbound messages to check for redundancy. Default: 10 */
+    redundancyWindow?: number;
+    /** Model to use for responses. Default: 'fast' (resolved via ModelRouter) */
+    model?: string;
+    /** Caller-provided LLM call function */
+    llmCall: (params: {
+        model: string;
+        messages: ChatMessage[];
+        system?: string;
+        maxTokens?: number;
+    }) => Promise<{
+        content: string;
+    }>;
+}
+export declare class ChatResponder {
+    private db;
+    private hooks;
+    private messageStore;
+    private readonly systemPrompt;
+    private readonly contextWindowTokens;
+    private readonly redundancyWindow;
+    private readonly model;
+    private readonly llmCall;
+    constructor(db: DataStore, hooks: HookBus, messageStore: MessageStore, config: ChatResponderConfig);
+    /**
+     * Generate a fast conversational response to an inbound message.
+     * Uses rolling context window from thread history.
+     */
+    respond(opts: {
+        messageBody: string;
+        threadId: string;
+        channel: string;
+        userName?: string;
+        capabilities?: string;
+        additionalContext?: string;
+    }): Promise<string>;
+    /**
+     * Filter any outbound message through the LLM for human readability.
+     * This is the single funnel ALL responses pass through.
+     */
+    filterResponse(text: string, context?: {
+        channel?: string;
+        threadId?: string;
+        source?: string;
+    }): Promise<string>;
+    /**
+     * Check if a candidate outbound message is redundant with recent messages.
+     * Returns true if the message should be suppressed.
+     */
+    isRedundant(text: string, threadId: string): Promise<boolean>;
+    /**
+     * Full send pipeline: check redundancy → filter → store → deliver.
+     * Returns the message ID, or undefined if suppressed as redundant.
+     */
+    sendResponse(opts: {
+        text: string;
+        channel: string;
+        threadId: string;
+        agentId?: string;
+        agentSlug?: string;
+        taskId?: string;
+        source?: string;
+        skipRedundancyCheck?: boolean;
+        skipFilter?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Build a context window from thread history, trimmed to token limit.
+     */
+    private buildContextWindow;
+}

package/dist/core/chat/chat-responder.js

@@ -0,0 +1,185 @@
+/**
+ * ChatResponder — fast conversational layer with LLM-filtered responses.
+ * Story 7.2
+ *
+ * Provides rapid (<2s) conversational responses using a cheap LLM (Haiku).
+ * The responder has awareness of tools and capabilities but does NOT execute
+ * anything — it keeps the conversation going while work happens async.
+ *
+ * All outbound messages (direct, post-interpretation, task execution) are
+ * filtered through this layer for human readability and redundancy checking.
+ */
+const DEFAULT_SYSTEM_PROMPT = `You are a helpful, enthusiastic AI digital assistant. Your job is to:
+- Acknowledge the user's message and relay what you understand
+- Let them know what will happen next (if a task is being worked on)
+- Answer conversational questions directly
+- Be honest when you need to look something up — say "let me find out"
+- Keep responses concise and friendly
+
+You are aware of tools and capabilities in the system but you do NOT execute anything.
+You cannot run code, search databases, or take actions. You are purely conversational.
+If the user asks you to DO something, acknowledge it and say it will be handled.`;
+const DEFAULT_CONTEXT_TOKENS = 4000;
+const DEFAULT_REDUNDANCY_WINDOW = 10;
+const APPROX_CHARS_PER_TOKEN = 4;
+export class ChatResponder {
+    db;
+    hooks;
+    messageStore;
+    systemPrompt;
+    contextWindowTokens;
+    redundancyWindow;
+    model;
+    llmCall;
+    constructor(db, hooks, messageStore, config) {
+        this.db = db;
+        this.hooks = hooks;
+        this.messageStore = messageStore;
+        this.systemPrompt = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+        this.contextWindowTokens = config.contextWindowTokens ?? DEFAULT_CONTEXT_TOKENS;
+        this.redundancyWindow = config.redundancyWindow ?? DEFAULT_REDUNDANCY_WINDOW;
+        this.model = config.model ?? 'fast';
+        this.llmCall = config.llmCall;
+    }
+    /**
+     * Generate a fast conversational response to an inbound message.
+     * Uses rolling context window from thread history.
+     */
+    async respond(opts) {
+        // Build context window from thread history
+        const history = await this.messageStore.getThreadHistory(opts.threadId, 50);
+        const messages = this.buildContextWindow(history, opts.messageBody);
+        // Build system prompt with optional capabilities awareness
+        let system = this.systemPrompt;
+        if (opts.capabilities) {
+            system += `\n\nSystem capabilities you are aware of:\n${opts.capabilities}`;
+        }
+        if (opts.userName) {
+            system += `\n\nYou are talking to: ${opts.userName}`;
+        }
+        if (opts.additionalContext) {
+            system += opts.additionalContext;
+        }
+        const result = await this.llmCall({
+            model: this.model,
+            messages,
+            system,
+            maxTokens: 500,
+        });
+        return result.content;
+    }
+    /**
+     * Filter any outbound message through the LLM for human readability.
+     * This is the single funnel ALL responses pass through.
+     */
+    async filterResponse(text, context) {
+        // Short messages don't need filtering
+        if (text.length < 100)
+            return text;
+        const result = await this.llmCall({
+            model: this.model,
+            messages: [
+                {
+                    role: 'user',
+                    content: `Rewrite this agent/system message to be human-friendly and conversational. Keep the substance, remove jargon, make it feel like a helpful assistant talking to a person. If it's already readable, return it as-is. Do not add preamble like "Here's the rewritten version". Just output the rewritten text.\n\n---\n${text}`,
+                },
+            ],
+            maxTokens: 1000,
+        });
+        return result.content;
+    }
+    /**
+     * Check if a candidate outbound message is redundant with recent messages.
+     * Returns true if the message should be suppressed.
+     */
+    async isRedundant(text, threadId) {
+        const recent = await this.messageStore.getRecentOutbound(threadId, this.redundancyWindow);
+        if (recent.length === 0)
+            return false;
+        const recentTexts = recent
+            .map(m => m['body'] ?? '')
+            .filter(t => t.length > 0)
+            .slice(-5) // last 5 outbound messages
+            .join('\n---\n');
+        const result = await this.llmCall({
+            model: this.model,
+            messages: [
+                {
+                    role: 'user',
+                    content: `Does this NEW message duplicate or substantially overlap the RECENT messages already sent? Answer with just "redundant" or "not redundant". If the new message has meaningful new information or updates, it is NOT redundant.\n\nRECENT MESSAGES:\n${recentTexts}\n\nNEW MESSAGE:\n${text}`,
+                },
+            ],
+            maxTokens: 10,
+        });
+        return result.content.toLowerCase().includes('redundant') &&
+            !result.content.toLowerCase().includes('not redundant');
+    }
+    /**
+     * Full send pipeline: check redundancy → filter → store → deliver.
+     * Returns the message ID, or undefined if suppressed as redundant.
+     */
+    async sendResponse(opts) {
+        // 1. Redundancy check
+        if (!opts.skipRedundancyCheck) {
+            const redundant = await this.isRedundant(opts.text, opts.threadId);
+            if (redundant) {
+                await this.hooks.emit('response.suppressed', {
+                    channel: opts.channel,
+                    threadId: opts.threadId,
+                    reason: 'redundant',
+                });
+                return undefined;
+            }
+        }
+        // 2. Filter for readability
+        const filtered = opts.skipFilter
+            ? opts.text
+            : await this.filterResponse(opts.text, {
+                channel: opts.channel,
+                threadId: opts.threadId,
+                source: opts.source,
+            });
+        // 3. Store outbound message
+        const messageId = await this.messageStore.storeOutbound({
+            channel: opts.channel,
+            text: filtered,
+            threadId: opts.threadId,
+            agentId: opts.agentId,
+            agentSlug: opts.agentSlug,
+            taskId: opts.taskId,
+        });
+        // 4. Emit for delivery (NotificationQueue listens)
+        await this.hooks.emit('response.ready', {
+            messageId,
+            channel: opts.channel,
+            threadId: opts.threadId,
+            text: filtered,
+            taskId: opts.taskId,
+        });
+        return messageId;
+    }
+    /**
+     * Build a context window from thread history, trimmed to token limit.
+     */
+    buildContextWindow(history, currentMessage) {
+        const maxChars = this.contextWindowTokens * APPROX_CHARS_PER_TOKEN;
+        let charCount = currentMessage.length;
+        const messages = [];
+        // Walk backwards through history, adding messages until we hit the limit
+        for (let i = history.length - 1; i >= 0; i--) {
+            const msg = history[i];
+            const body = msg['body'] ?? '';
+            const direction = msg['direction'];
+            if (charCount + body.length > maxChars)
+                break;
+            messages.unshift({
+                role: direction === 'inbound' ? 'user' : 'assistant',
+                content: body,
+            });
+            charCount += body.length;
+        }
+        // Add current message
+        messages.push({ role: 'user', content: currentMessage });
+        return messages;
+    }
+}

package/dist/core/chat/formatter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Text formatter — converts markdown to channel-specific formats.
+ * Story 4.4
+ */
+/**
+ * Format text for the given mode:
+ * - 'mrkdwn': Slack's mrkdwn format (**bold** → *bold*, _italic_ preserved, `code` preserved)
+ * - 'html': basic markdown → HTML (strong, em, code, pre)
+ * - 'plain': strip markdown markers
+ */
+export declare function formatText(text: string, mode: "mrkdwn" | "html" | "plain"): string;

package/dist/core/chat/formatter.js

@@ -0,0 +1,60 @@
+/**
+ * Text formatter — converts markdown to channel-specific formats.
+ * Story 4.4
+ */
+/**
+ * Format text for the given mode:
+ * - 'mrkdwn': Slack's mrkdwn format (**bold** → *bold*, _italic_ preserved, `code` preserved)
+ * - 'html': basic markdown → HTML (strong, em, code, pre)
+ * - 'plain': strip markdown markers
+ */
+export function formatText(text, mode) {
+    switch (mode) {
+        case "mrkdwn":
+            return toMrkdwn(text);
+        case "html":
+            return toHtml(text);
+        case "plain":
+            return toPlain(text);
+    }
+}
+function toMrkdwn(text) {
+    // **bold** → *bold* (Slack uses single asterisk for bold)
+    let result = text.replace(/\*\*(.+?)\*\*/g, "*$1*");
+    // __bold__ → *bold*
+    result = result.replace(/__(.+?)__/g, "*$1*");
+    // _italic_ remains as _italic_ (already valid mrkdwn)
+    // `code` remains as `code`
+    // ```code block``` remains
+    return result;
+}
+function toHtml(text) {
+    // Code blocks first (before inline)
+    let result = text.replace(/```([\s\S]*?)```/g, "<pre><code>$1</code></pre>");
+    // Inline code
+    result = result.replace(/`(.+?)`/g, "<code>$1</code>");
+    // **bold**
+    result = result.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+    // __bold__
+    result = result.replace(/__(.+?)__/g, "<strong>$1</strong>");
+    // *italic*
+    result = result.replace(/\*(.+?)\*/g, "<em>$1</em>");
+    // _italic_
+    result = result.replace(/_(.+?)_/g, "<em>$1</em>");
+    return result;
+}
+function toPlain(text) {
+    // Remove code blocks
+    let result = text.replace(/```[\s\S]*?```/g, (m) => m.replace(/```/g, "").trim());
+    // Remove inline code markers
+    result = result.replace(/`(.+?)`/g, "$1");
+    // Remove **bold**
+    result = result.replace(/\*\*(.+?)\*\*/g, "$1");
+    // Remove __bold__
+    result = result.replace(/__(.+?)__/g, "$1");
+    // Remove *italic*
+    result = result.replace(/\*(.+?)\*/g, "$1");
+    // Remove _italic_
+    result = result.replace(/_(.+?)_/g, "$1");
+    return result;
+}

package/dist/core/chat/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Chat layer exports — Stories 4.1–4.4
+ */
+export { ChannelRegistry, ChannelRegistryError } from "./channel-registry.js";
+export { discoverChannels } from "./auto-discovery.js";
+export { MessagePipeline } from "./pipeline.js";
+export { buildAgentBindings } from "./routing.js";
+export { TriageRouter } from "./triage-router.js";
+export type { RoutingRule, RoutingDecision, TriageRouterConfig } from "./triage-router.js";
+export { checkAllowlist, checkMentionGate } from "./policies.js";
+export { SessionKey } from "./session-key.js";
+export { ChatSessionManager } from "./session-manager.js";
+export { NotificationQueue } from "./notification-queue.js";
+export { MessageStore } from "./message-store.js";
+export type { StoredAttachment, StoreResult } from "./message-store.js";
+export { ChatResponder } from "./chat-responder.js";
+export type { ChatResponderConfig } from "./chat-responder.js";
+export { MessageInterpreter } from "./message-interpreter.js";
+export type { Extractor, ExtractedTask, ExtractedMemory, ExtractedFile, ExtractedUserContext, InterpretationResult, MessageInterpreterConfig, LLMCallFn, } from "./message-interpreter.js";
+export { ChatPipeline } from "./chat-pipeline.js";
+export type { ChatPipelineConfig } from "./chat-pipeline.js";
+export { chunkText } from "./text-chunker.js";
+export { formatText } from "./formatter.js";
+export type { ChatType, FormattingMode, ChannelCapabilities, ChannelMeta, InboundMessage, Attachment, OutboundPayload, SendResult, HealthStatus, ChannelConfig, ChannelAdapter, } from "./types.js";

package/dist/core/chat/index.js

@@ -0,0 +1,18 @@
+/**
+ * Chat layer exports — Stories 4.1–4.4
+ */
+export { ChannelRegistry, ChannelRegistryError } from "./channel-registry.js";
+export { discoverChannels } from "./auto-discovery.js";
+export { MessagePipeline } from "./pipeline.js";
+export { buildAgentBindings } from "./routing.js";
+export { TriageRouter } from "./triage-router.js";
+export { checkAllowlist, checkMentionGate } from "./policies.js";
+export { SessionKey } from "./session-key.js";
+export { ChatSessionManager } from "./session-manager.js";
+export { NotificationQueue } from "./notification-queue.js";
+export { MessageStore } from "./message-store.js";
+export { ChatResponder } from "./chat-responder.js";
+export { MessageInterpreter } from "./message-interpreter.js";
+export { ChatPipeline } from "./chat-pipeline.js";
+export { chunkText } from "./text-chunker.js";
+export { formatText } from "./formatter.js";