comisai 1.0.37 → 1.0.41

package/node_modules/@comis/channels/dist/shared/inbound-gate.js

@@ -1,386 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Inbound Pipeline Phase 3: Message Gate.
- *
- * Evaluates auto-reply rules, handles slash commands (/send, /approve,
- * /deny, /config, /stop, general commands), reset triggers, and prompt
- * skill detection. Returns a gate decision indicating whether the message
- * should be processed, skipped, or was handled inline (command response sent).
- *
- * @module
- */
-import { formatSessionKey } from "@comis/core";
-import { parseSlashCommand, matchPromptSkillCommand } from "@comis/agent";
-import { evaluateAutoReply, isGroupMessage } from "./auto-reply-engine.js";
-import { matchesResetTrigger } from "./inbound-pipeline.js";
-import { deliverToChannel } from "./deliver-to-channel.js";
-// ---------------------------------------------------------------------------
-// Phase function
-// ---------------------------------------------------------------------------
-/**
- * Evaluate all message gates: auto-reply engine, slash commands, reset
- * triggers, and prompt skill detection.
- *
- * Returns a `GateDecision`:
- * - `"process"`: message should continue to routing/execution (may have modified msg/directives)
- * - `"handled"`: a command was intercepted and a response already delivered
- * - `"skip"`: message was suppressed (auto-reply gate, inject-history)
- */
-export async function evaluateInboundGate(deps, adapter, processedMsg, sessionKey, agentId, sendOverrides) {
-    let msg = processedMsg;
-    // -------------------------------------------------------------------
-    // AUTO-REPLY ENGINE GATE
-    // -------------------------------------------------------------------
-    // Follow-up messages always activate -- bypass auto-reply evaluation
-    if (msg.metadata?.isFollowup === true) {
-        // Skip auto-reply evaluation -- follow-ups are system-generated
-        // Fall through to execution
-    }
-    else if (deps.autoReplyEngineConfig?.enabled !== false) {
-        const arConfig = deps.autoReplyEngineConfig ?? {
-            enabled: true,
-            groupActivation: "mention-gated",
-            customPatterns: [],
-            historyInjection: true,
-            maxHistoryInjections: 50,
-            maxGroupHistoryMessages: 20,
-        };
-        const isGroup = isGroupMessage(msg);
-        const decision = evaluateAutoReply(msg, arConfig, isGroup);
-        if (decision.action === "activate") {
-            deps.eventBus.emit("autoreply:activated", {
-                channelId: msg.channelId,
-                senderId: msg.senderId,
-                activationMode: arConfig.groupActivation,
-                reason: decision.reason,
-                timestamp: Date.now(),
-            });
-            // Continue to routing + execution below
-        }
-        else if (decision.action === "inject-history") {
-            deps.eventBus.emit("autoreply:suppressed", {
-                channelId: msg.channelId,
-                senderId: msg.senderId,
-                reason: decision.reason,
-                injectedAsHistory: true,
-                timestamp: Date.now(),
-            });
-            deps.logger.info({
-                channelType: adapter.channelType,
-                chatId: msg.channelId,
-                senderId: msg.senderId,
-                reason: decision.reason,
-                activationMode: arConfig.groupActivation,
-                isBotMentioned: msg.metadata?.isBotMentioned === true,
-                replyToBot: msg.metadata?.replyToBot === true,
-                action: "inject-history",
-                hint: "Group activation policy did not match — message saved as history context only. Set autoReplyEngine.groupActivation=always to respond to all group messages, or @-mention/reply to the bot to activate it.",
-                errorKind: "config",
-            }, "Group message did not activate agent");
-            // Push to group history ring buffer for context injection
-            if (deps.groupHistoryBuffer) {
-                deps.groupHistoryBuffer.push(formatSessionKey(sessionKey), msg);
-            }
-            // Route history injection through command queue for serialization
-            if (deps.commandQueue) {
-                const historyEnqueueResult = await deps.commandQueue.enqueue(sessionKey, msg, adapter.channelType, async () => {
-                    // No-op execution: serialized with concurrent executions via queue.
-                    // Lightweight save to append message as history context.
-                    const existing = deps.sessionManager.loadOrCreate(sessionKey);
-                    deps.sessionManager.save(sessionKey, [
-                        ...existing.slice(-(arConfig.maxHistoryInjections - 1)),
-                        { role: "user", content: `[${msg.senderId}]: ${msg.text ?? ""}` },
-                    ]);
-                });
-                if (!historyEnqueueResult.ok) {
-                    deps.logger.warn({
-                        err: historyEnqueueResult.error.message,
-                        hint: "Check if command queue is shut down or overflow policy rejected the message",
-                        errorKind: "resource",
-                        channelType: adapter.channelType,
-                    }, "History injection enqueue failed");
-                }
-            }
-            return { action: "skip" }; // Do not route to agent
-        }
-        else {
-            // "ignore" -- emit suppressed event and return
-            deps.eventBus.emit("autoreply:suppressed", {
-                channelId: msg.channelId,
-                senderId: msg.senderId,
-                reason: decision.reason,
-                injectedAsHistory: false,
-                timestamp: Date.now(),
-            });
-            deps.logger.info({
-                channelType: adapter.channelType,
-                chatId: msg.channelId,
-                senderId: msg.senderId,
-                reason: decision.reason,
-                activationMode: arConfig.groupActivation,
-                isBotMentioned: msg.metadata?.isBotMentioned === true,
-                replyToBot: msg.metadata?.replyToBot === true,
-                action: "ignore",
-                hint: "Group activation policy did not match and history injection is disabled. Set autoReplyEngine.groupActivation=always or autoReplyEngine.historyInjection=true to change.",
-                errorKind: "config",
-            }, "Group message ignored");
-            return { action: "skip" };
-        }
-    }
-    // -------------------------------------------------------------------
-    // /send command handler (runtime send policy override)
-    // -------------------------------------------------------------------
-    if (msg.text && /^\/send\s/i.test(msg.text)) {
-        const arg = msg.text.replace(/^\/send\s+/i, "").trim().toLowerCase();
-        if (arg === "on" || arg === "off" || arg === "inherit") {
-            // Verify sender is session owner
-            if (msg.senderId === sessionKey.userId) {
-                const overrideKey = formatSessionKey(sessionKey);
-                sendOverrides.set(overrideKey, arg);
-                deps.eventBus.emit("sendpolicy:override_changed", {
-                    sessionKey,
-                    override: arg,
-                    changedBy: msg.senderId,
-                    timestamp: Date.now(),
-                });
-                await deliverToChannel(adapter, msg.channelId, `Send policy override set to: ${arg}`, { skipChunking: true });
-            }
-            else {
-                await deliverToChannel(adapter, msg.channelId, "Only the session owner can change send policy overrides.", { skipChunking: true });
-            }
-            return { action: "handled" }; // Do not route to agent
-        }
-    }
-    // -------------------------------------------------------------------
-    // /approve and /deny COMMAND INTERCEPTION
-    // -------------------------------------------------------------------
-    if (msg.text && deps.approvalGate) {
-        const result = await handleApprovalCommand(deps, adapter, msg, sessionKey);
-        if (result)
-            return { action: "handled" };
-    }
-    // -------------------------------------------------------------------
-    // CONFIG COMMAND INTERCEPTION
-    // -------------------------------------------------------------------
-    if (msg.text && deps.handleConfigCommand) {
-        const configParsed = parseSlashCommand(msg.text);
-        if (configParsed.found && configParsed.command === "config") {
-            const response = await deps.handleConfigCommand(configParsed.args, adapter.channelType);
-            if (response) {
-                await deliverToChannel(adapter, msg.channelId, response);
-                return { action: "handled" }; // Do not route to agent
-            }
-        }
-    }
-    // -------------------------------------------------------------------
-    // /stop COMMAND INTERCEPTION
-    // -------------------------------------------------------------------
-    if (msg.text) {
-        const stopParsed = parseSlashCommand(msg.text);
-        if (stopParsed.found && stopParsed.command === "stop") {
-            // Active-session lookup goes through the composite-key resolver.
-            // `formattedKey` is retained as a diagnostic log field so
-            // operators can correlate /stop-aborts with session traces.
-            const formattedKey = formatSessionKey(sessionKey);
-            const runHandle = deps.sessionResolver?.resolveActiveSession({
-                agentId,
-                channelType: adapter.channelType,
-                channelId: msg.channelId,
-            });
-            if (runHandle) {
-                try {
-                    await runHandle.abort();
-                    deps.eventBus.emit("execution:aborted", {
-                        sessionKey,
-                        reason: "user_stop",
-                        agentId,
-                        timestamp: Date.now(),
-                    });
-                    deps.logger.info({ agentId, sessionKey: formattedKey }, "Execution aborted by /stop command");
-                    await deliverToChannel(adapter, msg.channelId, "Execution stopped.", { skipChunking: true });
-                }
-                catch (abortError) {
-                    deps.logger.warn({
-                        err: abortError,
-                        agentId,
-                        hint: "Abort call failed; execution may have already completed",
-                        errorKind: "internal",
-                    }, "Stop command abort failed");
-                    await deliverToChannel(adapter, msg.channelId, "Could not stop execution (may have already completed).", { skipChunking: true });
-                }
-            }
-            else {
-                await deliverToChannel(adapter, msg.channelId, "No active execution to stop.", { skipChunking: true });
-            }
-            return { action: "handled" }; // Do not route to agent
-        }
-    }
-    // -------------------------------------------------------------------
-    // GENERAL SLASH COMMAND INTERCEPTION
-    // -------------------------------------------------------------------
-    if (msg.text && deps.handleSlashCommand) {
-        const cmdResult = await deps.handleSlashCommand(msg.text, sessionKey, agentId);
-        if (cmdResult) {
-            if (cmdResult.handled) {
-                // Fully handled commands: send response and return (skip executor)
-                if (cmdResult.response) {
-                    await deliverToChannel(adapter, msg.channelId, cmdResult.response, { skipChunking: true });
-                }
-                return { action: "handled" };
-            }
-            // Directive commands (handled=false): pass directives and cleaned text to executor
-            if (cmdResult.directives && Object.keys(cmdResult.directives).length > 0) {
-                msg = {
-                    ...msg,
-                    text: cmdResult.cleanedText ?? msg.text,
-                    metadata: {
-                        ...msg.metadata,
-                        _commandDirectives: cmdResult.directives,
-                    },
-                };
-            }
-        }
-    }
-    // -------------------------------------------------------------------
-    // RESET TRIGGER PHRASE GATE
-    // -------------------------------------------------------------------
-    const resetTriggers = deps.getResetTriggers?.(agentId) ?? [];
-    if (resetTriggers.length > 0 && msg.text && matchesResetTrigger(msg.text, resetTriggers)) {
-        deps.logger.debug({
-            step: "reset-trigger",
-            agentId,
-            channelType: adapter.channelType,
-        }, "Reset trigger matched");
-        deps.sessionManager.expire(sessionKey);
-        deps.eventBus.emit("session:expired", {
-            sessionKey,
-            reason: "auto-reset:trigger-phrase",
-        });
-        let resetMessage = "Session reset.";
-        if (deps.greetingGenerator) {
-            const greetingResult = await deps.greetingGenerator.generate(agentId);
-            if (greetingResult.ok) {
-                resetMessage = greetingResult.value;
-            }
-        }
-        await deliverToChannel(adapter, msg.channelId, resetMessage, { skipChunking: true });
-        return { action: "handled" }; // Do not route to agent
-    }
-    // -------------------------------------------------------------------
-    // PROMPT SKILL DETECTION
-    // -------------------------------------------------------------------
-    if (msg.text && deps.loadPromptSkill && deps.getUserInvocableSkillNames) {
-        const systemCmd = parseSlashCommand(msg.text);
-        if (!systemCmd.found) {
-            const skillNames = deps.getUserInvocableSkillNames();
-            const skillMatch = matchPromptSkillCommand(msg.text, skillNames);
-            if (skillMatch) {
-                const loadResult = await deps.loadPromptSkill(skillMatch.name, skillMatch.args || undefined);
-                if (loadResult.ok) {
-                    const skill = loadResult.value;
-                    msg = {
-                        ...msg,
-                        text: skillMatch.args || "",
-                        metadata: {
-                            ...msg.metadata,
-                            promptSkillContent: skill.content,
-                            promptSkillAllowedTools: skill.allowedTools.length > 0 ? skill.allowedTools : undefined,
-                            promptSkillName: skill.skillName,
-                        },
-                    };
-                    deps.eventBus.emit("skill:prompt_invoked", {
-                        skillName: skill.skillName,
-                        invokedBy: "user",
-                        args: skillMatch.args,
-                        timestamp: Date.now(),
-                    });
-                }
-                else {
-                    deps.logger.warn({ skillName: skillMatch.name, err: loadResult.error, hint: "Check skill manifest and file accessibility", errorKind: "config" }, "Failed to load prompt skill");
-                }
-            }
-        }
-    }
-    // Extract command directives from metadata (set by general slash command interception above)
-    const directives = msg.metadata?._commandDirectives;
-    return { action: "process", processedMsg: msg, directives };
-}
-// ---------------------------------------------------------------------------
-// Approval command helper (keeps gate function readable)
-// ---------------------------------------------------------------------------
-/** Handle /approve and /deny commands. Returns true if command was handled. */
-async function handleApprovalCommand(deps, adapter, msg, sessionKey) {
-    const text = msg.text.trim();
-    const gate = deps.approvalGate;
-    // Bare command (no arguments) -- auto-resolve if unambiguous
-    const bareApproveMatch = /^\/approve\s*$/i.test(text);
-    const bareDenyMatch = !bareApproveMatch && /^\/deny\s*$/i.test(text);
-    if (bareApproveMatch || bareDenyMatch) {
-        const isApprove = !!bareApproveMatch;
-        const formattedKey = formatSessionKey(sessionKey);
-        const pending = gate.pending();
-        const matches = pending.filter((r) => r.sessionKey === formattedKey);
-        if (matches.length === 0) {
-            await deliverToChannel(adapter, msg.channelId, "No pending approvals.", { skipChunking: true });
-        }
-        else if (matches.length === 1) {
-            const approvedBy = `chat:${msg.senderId}`;
-            gate.resolveApproval(matches[0].requestId, isApprove, approvedBy);
-            const verb = isApprove ? "Approved" : "Denied";
-            await deliverToChannel(adapter, msg.channelId, `${verb}: ${matches[0].toolName ?? matches[0].action} (${matches[0].requestId.slice(0, 8)})`, { skipChunking: true });
-        }
-        else {
-            const lines = matches.map((r) => `  ${r.requestId.slice(0, 8)} - ${r.toolName ?? r.action}`);
-            const cmd = isApprove ? "/approve" : "/deny";
-            await deliverToChannel(adapter, msg.channelId, `Multiple pending approvals. Specify an ID or use "${cmd} all":\n${lines.join("\n")}`, { skipChunking: true });
-        }
-        return true;
-    }
-    // Command with arguments
-    const approveMatch = /^\/approve\s+(.+)/i.exec(text);
-    const denyMatch = !approveMatch ? /^\/deny\s+(.+)/i.exec(text) : null;
-    if (approveMatch || denyMatch) {
-        const isApprove = !!approveMatch;
-        const arg = (approveMatch?.[1] ?? denyMatch?.[1] ?? "").trim().toLowerCase();
-        const approvedBy = `chat:${msg.senderId}`;
-        if (arg === "all") {
-            // Batch: resolve all pending approvals matching this session
-            const formattedKey = formatSessionKey(sessionKey);
-            const pending = gate.pending();
-            const matches = pending.filter((r) => r.sessionKey === formattedKey);
-            if (matches.length === 0) {
-                await deliverToChannel(adapter, msg.channelId, "No pending approvals to resolve.", { skipChunking: true });
-            }
-            else {
-                for (const req of matches) {
-                    gate.resolveApproval(req.requestId, isApprove, approvedBy);
-                }
-                const verb = isApprove ? "Approved" : "Denied";
-                await deliverToChannel(adapter, msg.channelId, `${verb} ${matches.length} pending approval(s).`, { skipChunking: true });
-            }
-        }
-        else {
-            // Single: resolve by request ID prefix match.
-            // Use filter+length check instead of first-match lookup — when the
-            // prefix is short and two pending requests share it, the operator
-            // must NOT silently get the first match. Warn and bail; the
-            // operator can re-issue with a longer prefix.
-            const pending = gate.pending();
-            const matches = pending.filter((r) => r.requestId.startsWith(arg));
-            if (matches.length === 0) {
-                await deliverToChannel(adapter, msg.channelId, `No pending approval found for ID: ${arg} (may have already been resolved or timed out).`, { skipChunking: true });
-            }
-            else if (matches.length > 1) {
-                await deliverToChannel(adapter, msg.channelId, `Ambiguous prefix "${arg}" matches ${matches.length} pending approvals. Use a longer prefix.`, { skipChunking: true });
-            }
-            else {
-                const match = matches[0];
-                gate.resolveApproval(match.requestId, isApprove, approvedBy);
-                const verb = isApprove ? "Approved" : "Denied";
-                await deliverToChannel(adapter, msg.channelId, `${verb}: ${match.toolName ?? match.action} (${match.requestId.slice(0, 8)})`, { skipChunking: true });
-            }
-        }
-        return true;
-    }
-    return false;
-}

package/node_modules/@comis/channels/dist/shared/inbound-pipeline.d.ts

@@ -1,159 +0,0 @@
-/**
- * Inbound Pipeline: Thin orchestrator for message reception and routing.
- *
- * Delegates to 5 focused phase modules:
- *   1. inbound-resolve  — agent resolution, identity, session key
- *   2. inbound-preprocess — audio preflight, media preprocessing, compression
- *   3. inbound-gate     — auto-reply, slash commands, reset triggers, skills
- *   4. inbound-setup    — ack reaction, typing controller
- *   5. inbound-route    — debounce, group history, queue routing, execution
- *
- * @module
- */
-import type { AgentExecutor } from "@comis/agent";
-import type { MessageRouter } from "@comis/agent";
-import type { SessionManager } from "@comis/agent";
-import type { CommandQueue } from "@comis/agent";
-import type { DebounceBuffer } from "@comis/agent";
-import type { FollowupTrigger } from "@comis/agent";
-import type { PriorityScheduler } from "@comis/agent";
-import type { SessionLabelStore } from "@comis/agent";
-import type { ActiveRunRegistry, BackgroundSessionResolver } from "@comis/agent";
-import type { ChannelPort, DeliveryQueuePort, NormalizedMessage, SessionKey, TypedEventBus } from "@comis/core";
-import type { StreamingConfig } from "@comis/core";
-import type { AutoReplyEngineConfig, SendPolicyConfig, QueueConfig, ElevatedReplyConfig, AckReactionConfig } from "@comis/core";
-import type { ComisLogger } from "@comis/infra";
-import type { Result } from "@comis/shared";
-import type { BlockPacer } from "./block-pacer.js";
-import type { ChannelRegistry } from "./channel-registry.js";
-import type { SendOverrideStore } from "./send-policy.js";
-import type { PreflightResult } from "./audio-preflight.js";
-import type { RetryEngine } from "./retry-engine.js";
-import type { GroupHistoryBuffer } from "./group-history-buffer.js";
-import type { VoiceResponsePipelineDeps } from "./voice-response-pipeline.js";
-/** Narrow deps interface for the inbound pipeline. */
-export interface InboundPipelineDeps {
-    eventBus: TypedEventBus;
-    logger: ComisLogger;
-    messageRouter: MessageRouter;
-    sessionManager: SessionManager;
-    createExecutor: (agentId: string) => AgentExecutor | undefined;
-    channelRegistry?: ChannelRegistry;
-    preprocessMessage?: (msg: NormalizedMessage) => Promise<NormalizedMessage>;
-    commandQueue?: CommandQueue;
-    autoReplyEngineConfig?: AutoReplyEngineConfig;
-    sendPolicyConfig?: SendPolicyConfig;
-    getResetTriggers?: (agentId: string) => string[];
-    identityResolver?: {
-        resolve(provider: string, providerUserId: string): string | undefined;
-    };
-    getDmScopeConfig?: (agentId: string) => {
-        mode?: string;
-        agentPrefix?: boolean;
-        threadIsolation?: boolean;
-    } | undefined;
-    debounceBuffer?: DebounceBuffer;
-    groupHistoryBuffer?: GroupHistoryBuffer;
-    followupTrigger?: FollowupTrigger;
-    followupConfig?: {
-        maxFollowupRuns: number;
-    };
-    priorityScheduler?: PriorityScheduler;
-    queueConfig?: QueueConfig;
-    getElevatedReplyConfig?: (agentId: string) => ElevatedReplyConfig | undefined;
-    sessionLabelStore?: SessionLabelStore;
-    ackReactionConfig?: AckReactionConfig;
-    loadPromptSkill?: (name: string, args?: string) => Promise<Result<{
-        content: string;
-        allowedTools: string[];
-        skillName: string;
-    }, Error>>;
-    getUserInvocableSkillNames?: () => Set<string>;
-    assembleToolsForAgent?: (agentId: string, options?: {
-        sessionKey?: SessionKey;
-    }) => Promise<any[]>;
-    greetingGenerator?: {
-        generate(agentName: string): Promise<Result<string, Error>>;
-    };
-    audioPreflight?: (msg: NormalizedMessage) => Promise<PreflightResult>;
-    voiceResponsePipeline?: VoiceResponsePipelineDeps;
-    parseOutboundMedia?: (text: string) => {
-        text: string;
-        mediaUrls: string[];
-    };
-    outboundMediaFetch?: (url: string) => Promise<Result<{
-        buffer: Buffer;
-        mimeType?: string;
-    }, Error>>;
-    streamingConfig?: StreamingConfig;
-    retryEngine?: RetryEngine;
-    /** Delivery queue for crash-safe message persistence. When present, agent responses are enqueued before send. */
-    deliveryQueue?: DeliveryQueuePort;
-    /**
-     * Per-instance set of in-flight outbound sendMessage promises. Threaded
-     * through ExecutionPipelineDeps -> DeliverToChannelDeps so deliver-to-channel
-     * can register active sends. Drained in stopAll() with a 5s deadline so
-     * SIGUSR2 cannot tear down adapters mid-send. Created by the channel-manager
-     * factory; do not pass externally.
-     */
-    inFlightSends?: Set<Promise<unknown>>;
-    /** Optional active run registry for SDK-native steer+followup. */
-    activeRunRegistry?: ActiveRunRegistry;
-    /**
-     * Optional composite-key resolver for active-session lookup. When
-     * present, supersedes `activeRunRegistry.has/.get` for production
-     * lookups. Wired by the daemon as
-     * `createBackgroundSessionResolver({ activeRunRegistry })`.
-     */
-    sessionResolver?: BackgroundSessionResolver;
-    /** Handle /config command. Returns response text or undefined if not a config command. */
-    handleConfigCommand?: (args: string[], channelType: string) => Promise<string | undefined>;
-    /** Optional callback for task extraction after successful agent execution. */
-    onTaskExtraction?: (conversationText: string, sessionKey: string, agentId: string) => Promise<void>;
-    /** When true, lifecycle reactor handles queued/thinking reactions -- skip ack reaction. */
-    lifecycleReactionsEnabled?: boolean;
-    /** Response prefix config for template-based prefix/suffix on agent responses. */
-    responsePrefixConfig?: {
-        template: string;
-        position: "prepend" | "append";
-    };
-    /** Template context builder for response prefix variables. */
-    buildTemplateContext?: (agentId: string, channelType: string, msg: NormalizedMessage) => Record<string, string>;
-    /** Optional approval gate for resolving /approve and /deny chat commands. When absent, approval commands pass through as plain text. */
-    approvalGate?: {
-        resolveApproval(requestId: string, approved: boolean, approvedBy: string, reason?: string): void;
-        pending(): Array<{
-            requestId: string;
-            sessionKey: string;
-            action: string;
-            toolName: string;
-        }>;
-        getRequest(requestId: string): {
-            requestId: string;
-            sessionKey: string;
-        } | undefined;
-    };
-    /** Handle general slash commands via command handler. Returns CommandResult or undefined if not a command. */
-    handleSlashCommand?: (text: string, sessionKey: SessionKey, agentId: string) => Promise<{
-        handled: boolean;
-        response?: string;
-        directives?: Record<string, unknown>;
-        cleanedText?: string;
-    } | undefined>;
-    /** Per-agent enforceFinalTag config lookup. Returns boolean or undefined if agent not found. */
-    getEnforceFinalTag?: (agentId: string) => boolean | undefined;
-    /** Optional allowFrom sender filter lookup. Returns allowed sender IDs for a channel type. Empty array = allow all. */
-    getAllowFrom?: (channelType: string) => string[];
-}
-/**
- * Test message text against configured reset trigger phrases.
- * Supports literal string matching (case-insensitive) and /regex/ patterns.
- * Each pattern is wrapped in try/catch to prevent ReDoS from user-configured patterns.
- */
-export declare function matchesResetTrigger(text: string, triggers: string[]): boolean;
-/**
- * Process an inbound message through the full pipeline.
- *
- * Orchestrates 5 phases: resolve -> preprocess -> gate -> setup -> route.
- */
-export declare function processInboundMessage(deps: InboundPipelineDeps, adapter: ChannelPort, msg: NormalizedMessage, activePacers: Set<BlockPacer>, sendOverrides: SendOverrideStore): Promise<void>;

package/node_modules/@comis/channels/dist/shared/inbound-pipeline.js

@@ -1,89 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Inbound Pipeline: Thin orchestrator for message reception and routing.
- *
- * Delegates to 5 focused phase modules:
- *   1. inbound-resolve  — agent resolution, identity, session key
- *   2. inbound-preprocess — audio preflight, media preprocessing, compression
- *   3. inbound-gate     — auto-reply, slash commands, reset triggers, skills
- *   4. inbound-setup    — ack reaction, typing controller
- *   5. inbound-route    — debounce, group history, queue routing, execution
- *
- * @module
- */
-import { isRegexSafe } from "./regex-guard.js";
-// Phase module imports
-import { resolveInboundAgent } from "./inbound-resolve.js";
-import { preprocessInboundMessage } from "./inbound-preprocess.js";
-import { evaluateInboundGate } from "./inbound-gate.js";
-import { setupInboundExecution } from "./inbound-setup.js";
-import { routeInboundMessage } from "./inbound-route.js";
-// ---------------------------------------------------------------------------
-// Trigger phrase matching
-// ---------------------------------------------------------------------------
-/**
- * Test message text against configured reset trigger phrases.
- * Supports literal string matching (case-insensitive) and /regex/ patterns.
- * Each pattern is wrapped in try/catch to prevent ReDoS from user-configured patterns.
- */
-export function matchesResetTrigger(text, triggers) {
-    const lowerText = text.toLowerCase().trim();
-    for (const trigger of triggers) {
-        try {
-            if (trigger.startsWith("/") && trigger.endsWith("/") && trigger.length > 2) {
-                const body = trigger.slice(1, -1);
-                const check = isRegexSafe(body);
-                if (!check.safe)
-                    continue; // Skip overly complex patterns
-                const re = new RegExp(body, "i");
-                if (re.test(lowerText))
-                    return true;
-            }
-            else {
-                if (lowerText === trigger.toLowerCase())
-                    return true;
-            }
-        }
-        catch {
-            // Invalid regex -- skip silently (ReDoS prevention)
-        }
-    }
-    return false;
-}
-// ---------------------------------------------------------------------------
-// Main inbound pipeline (thin orchestrator)
-// ---------------------------------------------------------------------------
-/**
- * Process an inbound message through the full pipeline.
- *
- * Orchestrates 5 phases: resolve -> preprocess -> gate -> setup -> route.
- */
-export async function processInboundMessage(deps, adapter, msg, activePacers, sendOverrides) {
-    // Phase 0: Sender allowFrom filtering
-    const allowFrom = deps.getAllowFrom?.(adapter.channelType) ?? [];
-    if (allowFrom.length > 0 && !allowFrom.includes(msg.senderId)) {
-        deps.logger.info({ channelType: adapter.channelType, senderId: msg.senderId, hint: "Sender not in allowFrom list", errorKind: "auth" }, "Sender blocked by allowFrom filter");
-        deps.eventBus.emit("sender:blocked", {
-            channelType: adapter.channelType,
-            senderId: msg.senderId,
-            channelId: msg.channelId,
-            timestamp: Date.now(),
-        });
-        return;
-    }
-    // Phase 1: Resolve agent, identity, session key
-    const resolved = resolveInboundAgent(deps, adapter, msg);
-    if (!resolved)
-        return; // No executor -- early exit
-    const { agentId, executor, sessionKey } = resolved;
-    // Phase 2: Audio preflight, media preprocessing, compression
-    const processedMsg = await preprocessInboundMessage(deps, msg, adapter.channelType);
-    // Phase 3: Auto-reply gate, slash commands, reset triggers, prompt skills
-    const gate = await evaluateInboundGate(deps, adapter, processedMsg, sessionKey, agentId, sendOverrides);
-    if (gate.action === "handled" || gate.action === "skip")
-        return;
-    // Phase 4: Ack reaction, typing controller, streaming config
-    const { typingLifecycle, streamCfg } = setupInboundExecution(deps, adapter, gate.processedMsg, msg, sessionKey);
-    // Phase 5: Debounce, group history, steer+followup, queue routing, execution
-    await routeInboundMessage(deps, adapter, gate.processedMsg, msg, sessionKey, agentId, executor, streamCfg, activePacers, sendOverrides, typingLifecycle, gate.directives);
-}