@intent-systems/nexus 2026.1.5-3

package/dist/auto-reply/reply/session.js

@@ -0,0 +1,169 @@
+import crypto from "node:crypto";
+import { buildGroupDisplayName, DEFAULT_IDLE_MINUTES, DEFAULT_RESET_TRIGGERS, loadSessionStore, resolveAgentIdFromSessionKey, resolveGroupSessionKey, resolveSessionKey, resolveStorePath, saveSessionStore, } from "../../config/sessions.js";
+import { resolveCommandAuthorization } from "../command-auth.js";
+import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
+export async function initSessionState(params) {
+    const { ctx, cfg, commandAuthorized } = params;
+    const sessionCfg = cfg.session;
+    const mainKey = sessionCfg?.mainKey ?? "main";
+    const agentId = resolveAgentIdFromSessionKey(ctx.SessionKey);
+    const resetTriggers = sessionCfg?.resetTriggers?.length
+        ? sessionCfg.resetTriggers
+        : DEFAULT_RESET_TRIGGERS;
+    const idleMinutes = Math.max(sessionCfg?.idleMinutes ?? DEFAULT_IDLE_MINUTES, 1);
+    const sessionScope = sessionCfg?.scope ?? "per-sender";
+    const storePath = resolveStorePath(sessionCfg?.store, { agentId });
+    const sessionStore = loadSessionStore(storePath);
+    let sessionKey;
+    let sessionEntry;
+    let sessionId;
+    let isNewSession = false;
+    let bodyStripped;
+    let systemSent = false;
+    let abortedLastRun = false;
+    let persistedThinking;
+    let persistedVerbose;
+    let persistedModelOverride;
+    let persistedProviderOverride;
+    const groupResolution = resolveGroupSessionKey(ctx) ?? undefined;
+    const isGroup = ctx.ChatType?.trim().toLowerCase() === "group" || Boolean(groupResolution);
+    const triggerBodyNormalized = stripStructuralPrefixes(ctx.Body ?? "")
+        .trim()
+        .toLowerCase();
+    const rawBody = ctx.Body ?? "";
+    const trimmedBody = rawBody.trim();
+    const resetAuthorized = resolveCommandAuthorization({
+        ctx,
+        cfg,
+        commandAuthorized,
+    }).isAuthorizedSender;
+    // Timestamp/message prefixes (e.g. "[Dec 4 17:35] ") are added by the
+    // web inbox before we get here. They prevented reset triggers like "/new"
+    // from matching, so strip structural wrappers when checking for resets.
+    const strippedForReset = isGroup
+        ? stripMentions(triggerBodyNormalized, ctx, cfg)
+        : triggerBodyNormalized;
+    for (const trigger of resetTriggers) {
+        if (!trigger)
+            continue;
+        if (!resetAuthorized)
+            break;
+        if (trimmedBody === trigger || strippedForReset === trigger) {
+            isNewSession = true;
+            bodyStripped = "";
+            break;
+        }
+        const triggerPrefix = `${trigger} `;
+        if (trimmedBody.startsWith(triggerPrefix) ||
+            strippedForReset.startsWith(triggerPrefix)) {
+            isNewSession = true;
+            bodyStripped = strippedForReset.slice(trigger.length).trimStart();
+            break;
+        }
+    }
+    sessionKey = resolveSessionKey(sessionScope, ctx, mainKey);
+    if (groupResolution?.legacyKey && groupResolution.legacyKey !== sessionKey) {
+        const legacyEntry = sessionStore[groupResolution.legacyKey];
+        if (legacyEntry && !sessionStore[sessionKey]) {
+            sessionStore[sessionKey] = legacyEntry;
+            delete sessionStore[groupResolution.legacyKey];
+        }
+    }
+    const entry = sessionStore[sessionKey];
+    const idleMs = idleMinutes * 60_000;
+    const freshEntry = entry && Date.now() - entry.updatedAt <= idleMs;
+    if (!isNewSession && freshEntry) {
+        sessionId = entry.sessionId;
+        systemSent = entry.systemSent ?? false;
+        abortedLastRun = entry.abortedLastRun ?? false;
+        persistedThinking = entry.thinkingLevel;
+        persistedVerbose = entry.verboseLevel;
+        persistedModelOverride = entry.modelOverride;
+        persistedProviderOverride = entry.providerOverride;
+    }
+    else {
+        sessionId = crypto.randomUUID();
+        isNewSession = true;
+        systemSent = false;
+        abortedLastRun = false;
+    }
+    const baseEntry = !isNewSession && freshEntry ? entry : undefined;
+    sessionEntry = {
+        ...baseEntry,
+        sessionId,
+        updatedAt: Date.now(),
+        systemSent,
+        abortedLastRun,
+        // Persist previously stored thinking/verbose levels when present.
+        thinkingLevel: persistedThinking ?? baseEntry?.thinkingLevel,
+        verboseLevel: persistedVerbose ?? baseEntry?.verboseLevel,
+        modelOverride: persistedModelOverride ?? baseEntry?.modelOverride,
+        providerOverride: persistedProviderOverride ?? baseEntry?.providerOverride,
+        sendPolicy: baseEntry?.sendPolicy,
+        queueMode: baseEntry?.queueMode,
+        queueDebounceMs: baseEntry?.queueDebounceMs,
+        queueCap: baseEntry?.queueCap,
+        queueDrop: baseEntry?.queueDrop,
+        displayName: baseEntry?.displayName,
+        chatType: baseEntry?.chatType,
+        provider: baseEntry?.provider,
+        subject: baseEntry?.subject,
+        room: baseEntry?.room,
+        space: baseEntry?.space,
+    };
+    if (groupResolution?.provider) {
+        const provider = groupResolution.provider;
+        const subject = ctx.GroupSubject?.trim();
+        const space = ctx.GroupSpace?.trim();
+        const explicitRoom = ctx.GroupRoom?.trim();
+        const isRoomProvider = provider === "discord" || provider === "slack";
+        const nextRoom = explicitRoom ??
+            (isRoomProvider && subject && subject.startsWith("#")
+                ? subject
+                : undefined);
+        const nextSubject = nextRoom ? undefined : subject;
+        sessionEntry.chatType = groupResolution.chatType ?? "group";
+        sessionEntry.provider = provider;
+        if (nextSubject)
+            sessionEntry.subject = nextSubject;
+        if (nextRoom)
+            sessionEntry.room = nextRoom;
+        if (space)
+            sessionEntry.space = space;
+        sessionEntry.displayName = buildGroupDisplayName({
+            provider: sessionEntry.provider,
+            subject: sessionEntry.subject,
+            room: sessionEntry.room,
+            space: sessionEntry.space,
+            id: groupResolution.id,
+            key: sessionKey,
+        });
+    }
+    else if (!sessionEntry.chatType) {
+        sessionEntry.chatType = "direct";
+    }
+    sessionStore[sessionKey] = sessionEntry;
+    await saveSessionStore(storePath, sessionStore);
+    const sessionCtx = {
+        ...ctx,
+        BodyStripped: bodyStripped ?? ctx.Body,
+        SessionId: sessionId,
+        IsNewSession: isNewSession ? "true" : "false",
+    };
+    return {
+        sessionCtx,
+        sessionEntry,
+        sessionStore,
+        sessionKey,
+        sessionId: sessionId ?? crypto.randomUUID(),
+        isNewSession,
+        systemSent,
+        abortedLastRun,
+        storePath,
+        sessionScope,
+        groupResolution,
+        isGroup,
+        bodyStripped,
+        triggerBodyNormalized,
+    };
+}

package/dist/auto-reply/reply/typing.js

@@ -0,0 +1,125 @@
+export function createTypingController(params) {
+    const { onReplyStart, typingIntervalSeconds = 6, typingTtlMs = 2 * 60_000, silentToken, log, } = params;
+    let started = false;
+    let active = false;
+    let runComplete = false;
+    let dispatchIdle = false;
+    // Important: callbacks (tool/block streaming) can fire late (after the run completed),
+    // especially when upstream event emitters don't await async listeners.
+    // Once we stop typing, we "seal" the controller so late events can't restart typing forever.
+    let sealed = false;
+    let typingTimer;
+    let typingTtlTimer;
+    const typingIntervalMs = typingIntervalSeconds * 1000;
+    const formatTypingTtl = (ms) => {
+        if (ms % 60_000 === 0)
+            return `${ms / 60_000}m`;
+        return `${Math.round(ms / 1000)}s`;
+    };
+    const resetCycle = () => {
+        started = false;
+        active = false;
+        runComplete = false;
+        dispatchIdle = false;
+    };
+    const cleanup = () => {
+        if (sealed)
+            return;
+        if (typingTtlTimer) {
+            clearTimeout(typingTtlTimer);
+            typingTtlTimer = undefined;
+        }
+        if (typingTimer) {
+            clearInterval(typingTimer);
+            typingTimer = undefined;
+        }
+        resetCycle();
+        sealed = true;
+    };
+    const refreshTypingTtl = () => {
+        if (sealed)
+            return;
+        if (!typingIntervalMs || typingIntervalMs <= 0)
+            return;
+        if (typingTtlMs <= 0)
+            return;
+        if (typingTtlTimer) {
+            clearTimeout(typingTtlTimer);
+        }
+        typingTtlTimer = setTimeout(() => {
+            if (!typingTimer)
+                return;
+            log?.(`typing TTL reached (${formatTypingTtl(typingTtlMs)}); stopping typing indicator`);
+            cleanup();
+        }, typingTtlMs);
+    };
+    const triggerTyping = async () => {
+        if (sealed)
+            return;
+        await onReplyStart?.();
+    };
+    const ensureStart = async () => {
+        if (sealed)
+            return;
+        // Late callbacks after a run completed should never restart typing.
+        if (runComplete)
+            return;
+        if (!active) {
+            active = true;
+        }
+        if (started)
+            return;
+        started = true;
+        await triggerTyping();
+    };
+    const maybeStopOnIdle = () => {
+        if (!active)
+            return;
+        // Stop only when the model run is done and the dispatcher queue is empty.
+        if (runComplete && dispatchIdle)
+            cleanup();
+    };
+    const startTypingLoop = async () => {
+        if (sealed)
+            return;
+        if (!onReplyStart)
+            return;
+        if (typingIntervalMs <= 0)
+            return;
+        if (typingTimer)
+            return;
+        await ensureStart();
+        refreshTypingTtl();
+        typingTimer = setInterval(() => {
+            void triggerTyping();
+        }, typingIntervalMs);
+    };
+    const startTypingOnText = async (text) => {
+        if (sealed)
+            return;
+        const trimmed = text?.trim();
+        if (!trimmed)
+            return;
+        if (silentToken && trimmed === silentToken)
+            return;
+        refreshTypingTtl();
+        await startTypingLoop();
+    };
+    const markRunComplete = () => {
+        runComplete = true;
+        maybeStopOnIdle();
+    };
+    const markDispatchIdle = () => {
+        dispatchIdle = true;
+        maybeStopOnIdle();
+    };
+    return {
+        onReplyStart: ensureStart,
+        startTypingLoop,
+        startTypingOnText,
+        refreshTypingTtl,
+        markRunComplete,
+        markDispatchIdle,
+        cleanup,
+    };
+}