comisai 1.0.41 → 1.0.44

package/node_modules/@comis/orchestrator/dist/inbound/inbound-route.js

@@ -1,248 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Inbound Pipeline — Message Routing stage.
- *
- * Handles debounce buffering, group history injection, steer+followup
- * routing (SDK-native), command queue routing, and direct execution
- * fallback.
- *
- * @module
- */
-import { formatSessionKey, systemNowMs } from "@comis/core";
-import { isGroupMessage } from "@comis/channels";
-import { executeAndDeliver } from "../execution/execution-pipeline.js";
-import { isBotMentioned } from "@comis/channels";
-/**
- * Determine which priority lane a message should be assigned to.
- *
- * Priority order: follow-up messages -> heartbeat/scheduled -> DMs -> mentioned in group -> default.
- */
-function assignPriorityLane(msg, laneConfig) {
-    // Follow-up messages
-    if (msg.metadata?.isFollowup) {
-        return { lane: laneConfig.followupLane, reason: "followup" };
-    }
-    // Heartbeat / scheduled
-    if (msg.metadata?.isHeartbeat) {
-        return { lane: laneConfig.scheduledLane, reason: "heartbeat" };
-    }
-    // DMs
-    if (!isGroupMessage(msg)) {
-        return { lane: laneConfig.dmLane, reason: "dm" };
-    }
-    // Group mention
-    if (isBotMentioned(msg)) {
-        return { lane: laneConfig.mentionLane, reason: "mention" };
-    }
-    // Default
-    return { lane: laneConfig.defaultLane, reason: "default" };
-}
-// ---------------------------------------------------------------------------
-// Stage function
-// ---------------------------------------------------------------------------
-/**
- * Route an inbound message through debounce, group history, steer+followup,
- * or command queue. Falls back to direct execution when no queue is present.
- *
- * This function handles the final routing decision and may call
- * `executeAndDeliver` directly or enqueue for later execution.
- */
-export async function routeInboundMessage(deps, adapter, processedMsg, originalMsg, sessionKey, agentId, executor, streamCfg, activePacers, sendOverrides, typingLifecycle, directives) {
-    let msg = processedMsg;
-    // -------------------------------------------------------------------
-    // DEBOUNCE BUFFER GATE
-    // -------------------------------------------------------------------
-    const isDebounced = msg.metadata?.isDebounced === true;
-    if (!isDebounced && deps.debounceBuffer) {
-        deps.logger.debug({
-            step: "debounce-buffered",
-            channelType: adapter.channelType,
-            chatId: msg.channelId,
-        }, "Message buffered for debounce");
-        deps.debounceBuffer.push(sessionKey, msg, adapter.channelType);
-        return; // Message is buffered; execution deferred to flush callback
-    }
-    // -------------------------------------------------------------------
-    // GROUP HISTORY INJECTION
-    // -------------------------------------------------------------------
-    if (deps.groupHistoryBuffer) {
-        const skFormatted = formatSessionKey(sessionKey);
-        let effectiveText = msg.text ?? "";
-        const sessionLabel = deps.sessionLabelStore?.getLabel(sessionKey);
-        const history = deps.groupHistoryBuffer.getFormatted(skFormatted, sessionLabel);
-        if (history) {
-            effectiveText = `${history}\n---\n${effectiveText}`;
-            deps.eventBus.emit("grouphistory:injected", {
-                sessionKey: skFormatted,
-                channelType: adapter.channelType,
-                messageCount: deps.groupHistoryBuffer.depth(skFormatted),
-                charCount: history.length,
-                timestamp: systemNowMs(),
-            });
-            deps.logger.debug({
-                step: "group-history-inject",
-                itemCount: deps.groupHistoryBuffer.depth(skFormatted),
-                inputLen: history.length,
-            }, "Group history injected");
-        }
-        // Also push the current activating message to the buffer (for next activation's context)
-        if (isGroupMessage(msg)) {
-            deps.groupHistoryBuffer.push(skFormatted, msg);
-        }
-        // Create the effective message with injected history
-        if (effectiveText !== (msg.text ?? "")) {
-            msg = { ...msg, text: effectiveText };
-        }
-    }
-    // Build narrow execution pipeline deps from the inbound pipeline deps
-    const execDeps = {
-        eventBus: deps.eventBus,
-        logger: deps.logger,
-        streamingConfig: deps.streamingConfig,
-        sendPolicyConfig: deps.sendPolicyConfig,
-        getElevatedReplyConfig: deps.getElevatedReplyConfig,
-        channelRegistry: deps.channelRegistry,
-        retryEngine: deps.retryEngine,
-        deliveryQueue: deps.deliveryQueue,
-        deliveryService: deps.deliveryService,
-        inFlightSends: deps.inFlightSends,
-        followupTrigger: deps.followupTrigger,
-        followupConfig: deps.followupConfig,
-        commandQueue: deps.commandQueue,
-        assembleToolsForAgent: deps.assembleToolsForAgent,
-        voiceResponsePipeline: deps.voiceResponsePipeline,
-        parseOutboundMedia: deps.parseOutboundMedia,
-        outboundMediaFetch: deps.outboundMediaFetch,
-        onTaskExtraction: deps.onTaskExtraction,
-        responsePrefixConfig: deps.responsePrefixConfig,
-        buildTemplateContext: deps.buildTemplateContext,
-        enforceFinalTag: deps.getEnforceFinalTag?.(agentId),
-    };
-    // -------------------------------------------------------------------
-    // STEER+FOLLOWUP ROUTING
-    // -------------------------------------------------------------------
-    // Active-session lookup goes through BackgroundSessionResolver:
-    // composite (agentId, channelType, channelId) supersedes the single-arg
-    // formatted-key lookup so multi-agent / multi-channel sessions are
-    // distinguishable. The original
-    // `formattedKey = formatSessionKey(sessionKey)` is retained ONLY for
-    // diagnostic log fields (the SessionKey may itself be richer than the
-    // resolver's composite triple).
-    if (deps.sessionResolver && deps.queueConfig) {
-        const channelQueueConfig = deps.queueConfig.perChannel[adapter.channelType];
-        const effectiveMode = channelQueueConfig?.mode ?? deps.queueConfig.defaultMode;
-        if (effectiveMode === "steer+followup") {
-            const formattedKey = formatSessionKey(sessionKey);
-            const runHandle = deps.sessionResolver.resolveActiveSession({
-                agentId,
-                channelType: adapter.channelType,
-                channelId: msg.channelId,
-            });
-            if (runHandle) {
-                const messageText = msg.text ?? "";
-                if (runHandle.isStreaming() && !runHandle.isCompacting()) {
-                    // Session is streaming -- inject via SDK steer
-                    try {
-                        await runHandle.steer(messageText);
-                        deps.eventBus.emit("steer:injected", {
-                            sessionKey,
-                            channelType: adapter.channelType,
-                            agentId,
-                            timestamp: systemNowMs(),
-                        });
-                        deps.logger.debug({ agentId, channelType: adapter.channelType, sessionKey: formattedKey }, "Steer message injected into active session");
-                        return; // Message handled via steer -- do not enqueue
-                    }
-                    catch (steerErr) {
-                        deps.logger.warn({
-                            agentId,
-                            err: steerErr instanceof Error ? steerErr : new Error(String(steerErr)),
-                            hint: "SDK session.steer() failed; message will be queued as follow-up",
-                            errorKind: "internal",
-                        }, "Steer injection failed");
-                        // Fall through to follow-up below
-                    }
-                }
-                if (runHandle.isCompacting()) {
-                    deps.eventBus.emit("steer:rejected", {
-                        sessionKey,
-                        channelType: adapter.channelType,
-                        agentId,
-                        reason: "compacting",
-                        timestamp: systemNowMs(),
-                    });
-                    deps.logger.debug({ agentId, channelType: adapter.channelType, sessionKey: formattedKey }, "Steer rejected: session compacting");
-                }
-                else {
-                    deps.eventBus.emit("steer:rejected", {
-                        sessionKey,
-                        channelType: adapter.channelType,
-                        agentId,
-                        reason: "not_streaming",
-                        timestamp: systemNowMs(),
-                    });
-                    deps.logger.debug({ agentId, channelType: adapter.channelType, sessionKey: formattedKey }, "Steer rejected: session not streaming");
-                }
-                // Queue as follow-up (session exists but steer not possible)
-                try {
-                    await runHandle.followUp(messageText);
-                    deps.eventBus.emit("steer:followup_queued", {
-                        sessionKey,
-                        channelType: adapter.channelType,
-                        agentId,
-                        reason: runHandle.isCompacting() ? "compacting" : "not_streaming",
-                        timestamp: systemNowMs(),
-                    });
-                    deps.logger.debug({ agentId, channelType: adapter.channelType, sessionKey: formattedKey }, "Message queued as follow-up via SDK");
-                    return; // Message handled via follow-up -- do not enqueue
-                }
-                catch (followUpErr) {
-                    deps.logger.warn({
-                        agentId,
-                        err: followUpErr instanceof Error ? followUpErr : new Error(String(followUpErr)),
-                        hint: "SDK session.followUp() failed; falling through to CommandQueue",
-                        errorKind: "internal",
-                    }, "Follow-up queue failed");
-                    // Fall through to normal CommandQueue routing
-                }
-            }
-            // No active run -- fall through to CommandQueue (first message for session)
-        }
-    }
-    // -----------------------------------------------------------------------
-    // Queue-mediated path: route through CommandQueue for serialization
-    // -----------------------------------------------------------------------
-    if (deps.commandQueue) {
-        // Determine priority lane
-        let laneName;
-        if (deps.priorityScheduler && deps.queueConfig?.priorityEnabled) {
-            const laneConfig = deps.queueConfig.laneAssignment;
-            const assignment = assignPriorityLane(msg, laneConfig);
-            laneName = assignment.lane;
-            deps.eventBus.emit("priority:lane_assigned", {
-                sessionKey,
-                channelType: adapter.channelType,
-                lane: assignment.lane,
-                reason: assignment.reason,
-                timestamp: systemNowMs(),
-            });
-        }
-        const enqueueResult = await deps.commandQueue.enqueue(sessionKey, msg, adapter.channelType, async (messages) => {
-            const effectiveMsg = messages[0];
-            await executeAndDeliver(execDeps, adapter, effectiveMsg, originalMsg, executor, sessionKey, agentId, streamCfg, activePacers, sendOverrides, typingLifecycle, directives);
-        }, laneName);
-        if (!enqueueResult.ok) {
-            deps.logger.warn({
-                err: enqueueResult.error.message,
-                hint: "Check if command queue is shut down or overflow policy rejected the message",
-                errorKind: "resource",
-                channelType: adapter.channelType,
-            }, "Message enqueue failed");
-        }
-        return;
-    }
-    // -----------------------------------------------------------------------
-    // Direct execution path (fallback when commandQueue is not provided)
-    // -----------------------------------------------------------------------
-    await executeAndDeliver(execDeps, adapter, msg, originalMsg, executor, sessionKey, agentId, streamCfg, activePacers, sendOverrides, typingLifecycle, directives);
-}

package/node_modules/@comis/orchestrator/dist/inbound/inbound-setup.d.ts

@@ -1,32 +0,0 @@
-/**
- * Inbound Pipeline Phase 5: Pre-Execution Setup.
- *
- * Handles ack reaction delivery, typing controller creation, and
- * priority lane assignment before message routing/execution.
- *
- * @module
- */
-import type { ChannelPort, NormalizedMessage, SessionKey, PerChannelStreamingConfig } from "@comis/core";
-import type { InboundPipelineDeps } from "./inbound-pipeline.js";
-import type { TypingLifecycleController } from "@comis/channels";
-/**
- * Optimal typing indicator refresh intervals per platform.
- * Each value is set with margin before the platform's natural expiry.
- * IRC and Echo are intentionally omitted -- they default to typingMode "never".
- */
-export declare const PLATFORM_TYPING_DEFAULTS: Record<string, number>;
-/** Minimal deps needed for the pre-execution setup phase. */
-export type SetupDeps = Pick<InboundPipelineDeps, "logger" | "eventBus" | "channelRegistry" | "ackReactionConfig" | "lifecycleReactionsEnabled" | "streamingConfig">;
-/** Result of pre-execution setup. */
-export interface SetupResult {
-    /** Typing lifecycle controller (undefined if typing disabled). */
-    typingLifecycle: TypingLifecycleController | undefined;
-    /** Resolved per-channel streaming config. */
-    streamCfg: PerChannelStreamingConfig;
-}
-/**
- * Send ack reaction and create typing controller for the inbound message.
- *
- * Returns the typing lifecycle controller and resolved streaming config.
- */
-export declare function setupInboundExecution(deps: SetupDeps, adapter: ChannelPort, processedMsg: NormalizedMessage, originalMsg: NormalizedMessage, _sessionKey: SessionKey): SetupResult;

package/node_modules/@comis/orchestrator/dist/inbound/inbound-setup.js

@@ -1,147 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Inbound Pipeline Phase 5: Pre-Execution Setup.
- *
- * Handles ack reaction delivery, typing controller creation, and
- * priority lane assignment before message routing/execution.
- *
- * @module
- */
-import { createTypingController, createTypingLifecycleController, isGroupMessage, isBotMentioned, } from "@comis/channels";
-import { REPLY_TO_META_KEY } from "../execution/execution-pipeline.js";
-// ---------------------------------------------------------------------------
-// Per-platform typing refresh defaults
-// ---------------------------------------------------------------------------
-/**
- * Optimal typing indicator refresh intervals per platform.
- * Each value is set with margin before the platform's natural expiry.
- * IRC and Echo are intentionally omitted -- they default to typingMode "never".
- */
-export const PLATFORM_TYPING_DEFAULTS = {
-    telegram: 4000, // 1s margin before 5s expiry
-    discord: 8000, // 2s margin before 10s expiry
-    whatsapp: 8000, // ~10s expiry
-    signal: 4000, // ~5s expiry
-    line: 15000, // 20s expiry (showLoadingAnimation)
-    imessage: 4000, // ~5s process-based expiry
-};
-// ---------------------------------------------------------------------------
-// Helper functions
-// ---------------------------------------------------------------------------
-/**
- * Determine if typing indicators should be shown in the current context.
- *
- * In DMs, always show typing. In group chats, only show typing when the
- * bot was mentioned or replied to (prevents unnecessary typing noise).
- */
-function shouldShowTypingInGroup(msg) {
-    if (!isGroupMessage(msg))
-        return true; // Not a group -- show typing
-    return isBotMentioned(msg); // In group -- only if mentioned
-}
-/** Check if this execution was triggered by a heartbeat (suppress typing). */
-function isHeartbeatExecution(msg) {
-    return msg.metadata?.isHeartbeat === true;
-}
-// ---------------------------------------------------------------------------
-// Phase function
-// ---------------------------------------------------------------------------
-import { resolveStreamingConfig } from "../execution/execution-pipeline.js";
-import { systemNowMs } from "@comis/core";
-/**
- * Send ack reaction and create typing controller for the inbound message.
- *
- * Returns the typing lifecycle controller and resolved streaming config.
- */
-export function setupInboundExecution(deps, adapter, processedMsg, originalMsg, _sessionKey) {
-    // -------------------------------------------------------------------
-    // ACK REACTION -- fire-and-forget after activation
-    // -------------------------------------------------------------------
-    if (deps.ackReactionConfig?.enabled && !deps.lifecycleReactionsEnabled) {
-        const caps = deps.channelRegistry?.getCapabilities(adapter.channelType);
-        const supportsReactions = caps?.features?.reactions ?? false;
-        if (supportsReactions) {
-            const metaKey = caps?.replyToMetaKey ?? REPLY_TO_META_KEY[adapter.channelType];
-            const platformMsgId = metaKey ? String(processedMsg.metadata?.[metaKey] ?? "") : "";
-            if (platformMsgId) {
-                adapter.reactToMessage(processedMsg.channelId, platformMsgId, deps.ackReactionConfig.emoji)
-                    .then((result) => {
-                    if (result.ok) {
-                        deps.eventBus.emit("ack:reaction_sent", {
-                            channelId: processedMsg.channelId,
-                            channelType: adapter.channelType,
-                            messageId: platformMsgId,
-                            emoji: deps.ackReactionConfig.emoji,
-                            timestamp: systemNowMs(),
-                        });
-                    }
-                    else {
-                        deps.logger.warn({
-                            channelType: adapter.channelType,
-                            chatId: processedMsg.channelId,
-                            err: result.error,
-                            hint: "Platform may not support reactions or message may be too old",
-                            errorKind: "platform",
-                        }, "Ack reaction failed");
-                    }
-                })
-                    .catch((error) => {
-                    deps.logger.warn({
-                        channelType: adapter.channelType,
-                        chatId: processedMsg.channelId,
-                        err: error instanceof Error ? error : new Error(String(error)),
-                        hint: "Unexpected error in ack reaction handler",
-                        errorKind: "platform",
-                    }, "Ack reaction error");
-                });
-            }
-        }
-    }
-    // -------------------------------------------------------------------
-    // Resolve streaming config and typing controller
-    // -------------------------------------------------------------------
-    const streamCfg = resolveStreamingConfig(adapter.channelType, deps.streamingConfig);
-    // IRC and Echo default to typingMode "never" (no typing API) unless explicitly overridden
-    const effectiveTypingMode = (adapter.channelType === "irc" || adapter.channelType === "echo") && streamCfg.typingMode === "thinking"
-        ? "never"
-        : streamCfg.typingMode;
-    // Determine if typing indicators should activate
-    let typingCtrl;
-    const shouldType = effectiveTypingMode !== "never" &&
-        !isHeartbeatExecution(processedMsg) &&
-        shouldShowTypingInGroup(originalMsg);
-    if (shouldType) {
-        const threadIdForTyping = processedMsg.metadata?.telegramThreadId != null
-            ? String(processedMsg.metadata.telegramThreadId)
-            : undefined;
-        // Resolve per-platform refresh interval, falling back to per-channel config
-        const refreshMs = PLATFORM_TYPING_DEFAULTS[adapter.channelType] ?? streamCfg.typingRefreshMs;
-        typingCtrl = createTypingController({
-            mode: effectiveTypingMode,
-            refreshMs,
-            circuitBreakerThreshold: streamCfg.typingCircuitBreakerThreshold,
-            ttlMs: streamCfg.typingTtlMs,
-        }, async (chatId) => {
-            await adapter.platformAction("sendTyping", { chatId, threadId: threadIdForTyping });
-        }, { warn: (obj, message) => deps.logger.warn(obj, message) });
-    }
-    // Wrap the raw TypingController in a lifecycle controller
-    let typingLifecycle;
-    if (typingCtrl) {
-        typingLifecycle = createTypingLifecycleController(typingCtrl, {
-            graceMs: 10_000,
-            logger: { warn: (obj, message) => deps.logger.warn(obj, message) },
-        });
-        // 'instant' mode: start typing immediately before queue/execution
-        if (streamCfg.typingMode === "instant") {
-            typingLifecycle.controller.start(processedMsg.channelId);
-            deps.eventBus.emit("typing:started", {
-                channelId: adapter.channelId,
-                chatId: processedMsg.channelId,
-                mode: streamCfg.typingMode,
-                timestamp: systemNowMs(),
-            });
-        }
-    }
-    return { typingLifecycle, streamCfg };
-}

package/node_modules/@comis/orchestrator/dist/queue/priority-scheduler.d.ts

@@ -1,59 +0,0 @@
-/**
- * Priority Scheduler: Multi-lane queue scheduling with per-lane concurrency.
- *
- * Replaces the single global PQueue gate with named priority lanes, each
- * backed by its own PQueue with independent concurrency limits. This allows
- * DMs, group mentions, and background tasks to have different scheduling
- * priorities without starving any lane.
- *
- * Since each lane has its own PQueue running independently, starvation is
- * prevented by design -- as long as each lane has concurrency > 0, its tasks
- * will execute. The aging promotion mechanism is observability-only: it emits
- * events when tasks wait longer than the configured threshold, but does not
- * actually move tasks between lanes (PQueue does not support mid-flight
- * task migration).
- *
- * @module
- */
-import type { TypedEventBus, PriorityLaneConfig } from "@comis/core";
-export interface PrioritySchedulerDeps {
-    readonly lanes: PriorityLaneConfig[];
-    readonly eventBus: TypedEventBus;
-}
-export interface LaneStats {
-    pending: number;
-    executing: number;
-    concurrency: number;
-    priority: number;
-}
-export interface PriorityScheduler {
-    /** Enqueue a task to a named priority lane */
-    enqueue(lane: string, task: () => Promise<void>): Promise<void>;
-    /** Get stats for all lanes */
-    getStats(): Record<string, LaneStats>;
-    /** Get total concurrency across all lanes */
-    getTotalConcurrency(): number;
-    /** Pause all lanes */
-    pause(): void;
-    /** Resume all lanes */
-    resume(): void;
-    /** Drain all lanes (wait for all tasks to complete) */
-    drainAll(): Promise<void>;
-    /** Shutdown: pause, drain active, clear */
-    shutdown(): Promise<void>;
-}
-/**
- * Create a multi-lane priority scheduler.
- *
- * Each configured lane gets its own PQueue with independent concurrency.
- * Tasks are routed to lanes by name; unknown lane names fall back to the
- * lowest-priority lane.
- *
- * An aging sweep timer runs periodically and emits `priority:aged_promotion`
- * events for monitoring when tasks have waited longer than the configured
- * agingPromotionMs threshold.
- *
- * @param deps - Lane configuration and event bus
- * @returns PriorityScheduler instance
- */
-export declare function createPriorityScheduler(deps: PrioritySchedulerDeps): PriorityScheduler;