nexus-channel 1.6.5

package/dist/src/hub/agents.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAgentMap = loadAgentMap;
+const schema_1 = require("../config/schema");
+const api_client_1 = require("./api-client");
+async function loadAgentMap(hub2dUrl, config) {
+    const result = new Map();
+    try {
+        const apiBase = (0, api_client_1.normalizeHub2dHttpBase)(hub2dUrl, config.apiPort ?? schema_1.DEFAULT_API_PORT);
+        const headers = (0, api_client_1.buildAuthHeaders)(config);
+        const resp = await fetch(`${apiBase}/api/agents`, { headers, signal: AbortSignal.timeout(5000) });
+        if (!resp.ok) {
+            return result;
+        }
+        const agents = await resp.json();
+        for (const agent of agents) {
+            result.set(agent.username.toLowerCase(), agent.user_id);
+        }
+    }
+    catch (error) {
+        console.error(`[nexus] failed to load agent map: ${error.message}`);
+    }
+    return result;
+}

package/dist/src/hub/api-client.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHub2dHttpBase = normalizeHub2dHttpBase;
+exports.buildAuthHeaders = buildAuthHeaders;
+function normalizeHub2dHttpBase(hub2dUrl, apiPort) {
+    const wsUrl = hub2dUrl.startsWith('ws') ? hub2dUrl : hub2dUrl.replace(/^http/, 'ws');
+    const parsed = new URL(wsUrl);
+    return `http://${parsed.hostname}:${apiPort}`;
+}
+function buildAuthHeaders(config) {
+    const headers = {};
+    const apiKey = config.nexusApiKey ?? process.env.NEXUS_API_KEY ?? '';
+    if (apiKey) {
+        headers['x-api-key'] = apiKey;
+    }
+    return headers;
+}

package/dist/src/hub/context.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchNexusContext = fetchNexusContext;
+const schema_1 = require("../config/schema");
+const api_client_1 = require("./api-client");
+const CONTEXT_INJECTION_TTL_MS = 60000;
+const CONTEXT_MAX_CHARS = 2000;
+const contextCache = new Map();
+async function fetchNexusContext(roomId, hub2dUrl, config) {
+    const mode = config.contextInjection ?? 'P0';
+    if (mode === 'OFF')
+        return '';
+    const agentName = config.agentName || 'unknown';
+    const cacheKey = `${roomId}:${agentName}`;
+    const cached = contextCache.get(cacheKey);
+    if (cached && Date.now() - cached.fetchedAt < CONTEXT_INJECTION_TTL_MS) {
+        return cached.content;
+    }
+    try {
+        const apiBase = (0, api_client_1.normalizeHub2dHttpBase)(hub2dUrl, config.apiPort ?? schema_1.DEFAULT_API_PORT);
+        const headers = (0, api_client_1.buildAuthHeaders)(config);
+        const url = `${apiBase}/api/context/inject?room_id=${encodeURIComponent(roomId)}&level=P0&node=${encodeURIComponent(agentName)}`;
+        const resp = await fetch(url, { headers, signal: AbortSignal.timeout(5000) });
+        if (!resp.ok) {
+            console.error(`[nexus] context API error: ${resp.status}`);
+            return '';
+        }
+        const data = await resp.json();
+        if (!data?.enabled || !Array.isArray(data.items) || data.items.length === 0) {
+            return '';
+        }
+        const lines = data.items.map((item) => {
+            const sender = item.from || item.human_id || item.sender || 'unknown';
+            return `[${sender}] ${item.content}`;
+        });
+        let contentBody = lines.join('\n');
+        if (contentBody.length > CONTEXT_MAX_CHARS) {
+            contentBody = `${contentBody.slice(0, CONTEXT_MAX_CHARS)}\n[TRUNCATED context_too_long]`;
+        }
+        const content = `[Room Context: latest ${data.items.length} msgs]\n${contentBody}\n[End Context]\n\n`;
+        contextCache.set(cacheKey, { content, fetchedAt: Date.now() });
+        return content;
+    }
+    catch (error) {
+        console.error(`[nexus] context fetch failed: ${error.message}`);
+        return '';
+    }
+}

package/dist/src/runtime/directory.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messagingAdapter = exports.directoryAdapter = exports.KNOWN_AGENTS = exports.KNOWN_ROOMS = void 0;
+exports.KNOWN_ROOMS = [
+    { kind: 'group', id: 'general', name: 'General' },
+    { kind: 'group', id: 'boss', name: 'Boss' },
+    { kind: 'group', id: 'alpha', name: 'Alpha' },
+];
+exports.KNOWN_AGENTS = [
+    { kind: 'user', id: 'serina', name: 'Serina 💠' },
+    { kind: 'user', id: 'cortana', name: 'Cortana 🤍' },
+    { kind: 'user', id: 'roland', name: 'Roland 🟠' },
+    { kind: 'user', id: 'oracle', name: 'Oracle 🔮' },
+];
+exports.directoryAdapter = {
+    listGroups: async () => {
+        return [...exports.KNOWN_ROOMS, ...exports.KNOWN_AGENTS.map((agent) => ({ ...agent, kind: 'group' }))];
+    },
+    listPeers: async () => {
+        return exports.KNOWN_AGENTS;
+    },
+};
+exports.messagingAdapter = {
+    targetResolver: {
+        hint: 'Use room name (general, boss) or agent name (serina, cortana, roland, oracle). Prefix with @ for agents.',
+        looksLikeId: (raw) => {
+            const lower = raw.toLowerCase().trim();
+            return exports.KNOWN_ROOMS.some((room) => room.id === lower) || exports.KNOWN_AGENTS.some((agent) => agent.id === lower);
+        },
+    },
+};

package/dist/src/runtime/event-handler.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventTimestamp = getEventTimestamp;
+exports.getEventDecision = getEventDecision;
+exports.buildEventPrompt = buildEventPrompt;
+exports.processEvent = processEvent;
+const schema_1 = require("../config/schema");
+const chat_client_1 = require("../gateway/chat-client");
+const context_1 = require("../hub/context");
+const STALE_MESSAGE_TTL_MS = 20 * 60 * 1000;
+function getEventTimestamp(eventId) {
+    const ts = parseInt(eventId.split('-')[0], 10);
+    return Number.isNaN(ts) ? 0 : ts;
+}
+function getEventDecision(params) {
+    const { event, config, selfUserId, isRecent } = params;
+    const agentName = config.agentName || schema_1.DEFAULT_AGENT_NAME;
+    if (event.from === agentName)
+        return 'skip-own';
+    const eventTs = getEventTimestamp(event.event_id);
+    const ageMs = Date.now() - eventTs;
+    if (eventTs > 0 && ageMs > STALE_MESSAGE_TTL_MS)
+        return 'skip-stale';
+    const toActorIds = event.to_actor_ids || [];
+    if (toActorIds.length > 0 && (selfUserId === undefined || !toActorIds.includes(selfUserId))) {
+        return 'skip-actor-gate';
+    }
+    const mentions = event.mentions || [];
+    if (toActorIds.length === 0 && mentions.length > 0 && !mentions.includes(agentName)) {
+        return 'skip-mention-gate';
+    }
+    if (isRecent(event.event_id))
+        return 'skip-duplicate';
+    return 'process';
+}
+function buildEventPrompt(event, config) {
+    const threshold = config.longTextThreshold || schema_1.DEFAULT_LONG_TEXT;
+    const from = event.from || 'unknown';
+    let content = event.text || '';
+    if (content.length > threshold) {
+        content = `${content.slice(0, threshold)} [TRUNCATED orig_len=${event.text.length} kept=${threshold}]`;
+    }
+    if (Array.isArray(event.attachments) && event.attachments.length > 0) {
+        const attLines = event.attachments.map((att) => {
+            const parts = [`[附件:${att.type || 'file'}] ${att.name || 'unknown'}`];
+            if (att.size)
+                parts.push(`${Math.round(att.size / 1024)}KB`);
+            if (att.width && att.height)
+                parts.push(`${att.width}×${att.height}`);
+            return parts.join(' ');
+        });
+        content += `\n${attLines.join('\n')}`;
+    }
+    return `[from: ${from}] ${content}`;
+}
+async function processEvent(params) {
+    const { event, config, selfUserId, isRecent, markRecent, gatewayConfig, sendReply, sendAck, updateResumeToken } = params;
+    const decision = getEventDecision({ event, config, selfUserId, isRecent });
+    const roomId = event.room_id || schema_1.DEFAULT_ROOM_ID;
+    if (decision !== 'process') {
+        if (decision !== 'skip-own' && decision !== 'skip-duplicate') {
+            sendAck(roomId, event.event_id);
+            updateResumeToken(roomId, event.event_id);
+        }
+        return decision;
+    }
+    markRecent(event.event_id);
+    try {
+        let prompt = buildEventPrompt(event, config);
+        const hub2dUrl = config.hub2dUrl || 'ws://127.0.0.1:3001';
+        const context = await (0, context_1.fetchNexusContext)(roomId, hub2dUrl, config);
+        if (context) {
+            prompt = `${context}${prompt}`;
+        }
+        const sessionKey = `nexus:${roomId}`;
+        const response = await (0, chat_client_1.callGatewayWithRetry)([{ role: 'user', content: prompt }], sessionKey, gatewayConfig);
+        sendReply(event.event_id, roomId, event.from || 'unknown', response.content, 'done');
+        sendAck(roomId, event.event_id);
+        updateResumeToken(roomId, event.event_id);
+        return 'process';
+    }
+    catch (error) {
+        sendReply(event.event_id, roomId, event.from || 'unknown', `[ERROR] ${error.code || 'unknown_error'}: ${String(error.message || '').slice(0, 200)}`, 'error');
+        sendAck(roomId, event.event_id);
+        updateResumeToken(roomId, event.event_id);
+        return 'process';
+    }
+}

package/dist/src/runtime/outbound.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_AGENTS = exports.KNOWN_ROOMS = void 0;
+exports.resolveOutboundTarget = resolveOutboundTarget;
+exports.isResolvedOutboundTargetError = isResolvedOutboundTargetError;
+exports.createOutboundClient = createOutboundClient;
+const schema_1 = require("../config/schema");
+exports.KNOWN_ROOMS = [
+    { kind: 'group', id: 'general', name: 'General' },
+    { kind: 'group', id: 'boss', name: 'Boss' },
+    { kind: 'group', id: 'alpha', name: 'Alpha' },
+];
+exports.KNOWN_AGENTS = [
+    { kind: 'user', id: 'serina', name: 'Serina 💠' },
+    { kind: 'user', id: 'cortana', name: 'Cortana 🤍' },
+    { kind: 'user', id: 'roland', name: 'Roland 🟠' },
+    { kind: 'user', id: 'oracle', name: 'Oracle 🔮' },
+];
+const SILENT_PATTERNS = ['NO_REPLY', 'HEARTBEAT_OK', '(no reply)'];
+function resolveOutboundTarget(to) {
+    const room = exports.KNOWN_ROOMS.find((item) => item.id === to || item.name.toLowerCase() === to.toLowerCase());
+    if (room)
+        return { ok: true, to: room.id };
+    const agent = exports.KNOWN_AGENTS.find((item) => item.id === to || item.name.toLowerCase().startsWith(to.toLowerCase()));
+    if (agent)
+        return { ok: true, to: agent.id };
+    if (!to || !to.trim()) {
+        return { ok: false, error: new Error('target required') };
+    }
+    return { ok: true, to };
+}
+function isResolvedOutboundTargetError(value) {
+    return value.ok === false;
+}
+function createOutboundClient(config, sendMessage) {
+    const agentName = config.agentName || schema_1.DEFAULT_AGENT_NAME;
+    const defaultRoom = (config.roomId || schema_1.DEFAULT_ROOM_ID).split(',')[0].trim();
+    return {
+        async sendText(params) {
+            if (!params.text.trim() || SILENT_PATTERNS.some((pattern) => params.text.trim().startsWith(pattern))) {
+                return { channel: 'nexus-channel', messageId: `suppressed-${Date.now()}` };
+            }
+            const resolved = resolveOutboundTarget(params.to);
+            if (isResolvedOutboundTargetError(resolved)) {
+                throw resolved.error;
+            }
+            const isAgent = exports.KNOWN_AGENTS.some((agent) => agent.id === resolved.to);
+            const targetRoom = exports.KNOWN_ROOMS.some((room) => room.id === resolved.to) ? resolved.to : defaultRoom;
+            const mentions = isAgent && resolved.to !== agentName ? [resolved.to] : undefined;
+            sendMessage(targetRoom, params.text, mentions, `out-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+            return { channel: 'nexus-channel', messageId: `out-${Date.now()}` };
+        },
+        async sendMedia(params) {
+            const resolved = resolveOutboundTarget(params.to);
+            if (isResolvedOutboundTargetError(resolved)) {
+                throw resolved.error;
+            }
+            const targetRoom = exports.KNOWN_ROOMS.some((room) => room.id === resolved.to) ? resolved.to : defaultRoom;
+            const fallbackText = params.text || `[Media: ${params.mediaUrl || 'unsupported'}]`;
+            sendMessage(targetRoom, fallbackText, undefined, `media-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+            return { channel: 'nexus-channel', messageId: `media-${Date.now()}` };
+        },
+    };
+}

package/dist/src/runtime/status.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusAdapter = exports.defaultStatusSnapshot = void 0;
+exports.defaultStatusSnapshot = {
+    accountId: 'default',
+    enabled: true,
+    configured: false,
+    running: false,
+    connected: false,
+    lastConnectedAt: null,
+    lastInboundAt: null,
+    lastEventAt: null,
+    lastError: null,
+};
+exports.statusAdapter = {
+    defaultRuntime: { ...exports.defaultStatusSnapshot },
+    buildChannelSummary: ({ snapshot }) => ({
+        configured: Boolean(snapshot?.configured),
+        linked: Boolean(snapshot?.connected),
+        connected: Boolean(snapshot?.connected),
+        running: Boolean(snapshot?.running),
+        lastError: snapshot?.lastError ?? null,
+        authAgeMs: typeof snapshot?.lastConnectedAt === 'number' ? Math.max(0, Date.now() - snapshot.lastConnectedAt) : null,
+    }),
+    buildAccountSnapshot: ({ account, runtime }) => {
+        const meta = account?.__nexusMeta || { configured: false };
+        return {
+            accountId: account?.accountId || 'default',
+            name: account?.agentName || account?.accountId || 'Nexus',
+            enabled: account?.enabled ?? true,
+            configured: Boolean(meta.configured),
+            running: runtime?.running ?? false,
+            connected: runtime?.connected ?? false,
+            lastConnectedAt: runtime?.lastConnectedAt ?? null,
+            lastInboundAt: runtime?.lastInboundAt ?? null,
+            lastEventAt: runtime?.lastEventAt ?? null,
+            lastError: runtime?.lastError ?? null,
+            meta,
+            extra: {
+                hub2dUrl: account?.hub2dUrl ?? null,
+                roomId: account?.roomId ?? null,
+                agentName: account?.agentName ?? null,
+            },
+        };
+    },
+};

package/dist/src/runtime/tools.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentTools = createAgentTools;
+const schema_1 = require("../config/schema");
+const context_1 = require("../hub/context");
+const DispatchMessageSchema = {
+    type: 'object',
+    properties: {
+        target: { type: 'string', description: 'Agent name or room id to send to.' },
+        room_id: { type: 'string', description: 'Room ID to dispatch from.' },
+        text: { type: 'string', description: 'Message content.' },
+    },
+    required: ['text'],
+};
+const GetRoomSummarySchema = {
+    type: 'object',
+    properties: {
+        room_id: { type: 'string', description: 'Room ID to query.' },
+        max_chars: { type: 'number', minimum: 100, maximum: 5000 },
+    },
+};
+function createAgentTools(deps) {
+    return [
+        {
+            name: 'nexus_dispatch_message',
+            description: 'Dispatch a message to another agent or room in Nexus Hub.',
+            schema: DispatchMessageSchema,
+            ownerOnly: false,
+            handler: async (args) => {
+                const text = String(args?.text || '').trim();
+                if (!text)
+                    return { content: '[ERROR] nexus_dispatch_message: text is required.' };
+                const cfg = deps.getConfig();
+                const roomId = args?.room_id || (cfg.roomId || schema_1.DEFAULT_ROOM_ID).split(',')[0].trim();
+                const target = args?.target ? String(args.target) : undefined;
+                const result = await deps.dispatchMessage(roomId, text, target);
+                return { content: `[OK] Message dispatched. event_id=${result.event_id}` };
+            },
+        },
+        {
+            name: 'nexus_get_room_summary',
+            description: 'Fetch recent room summary from Nexus Hub context API.',
+            schema: GetRoomSummarySchema,
+            ownerOnly: false,
+            handler: async (args) => {
+                const cfg = deps.getConfig();
+                const roomId = args?.room_id || (cfg.roomId || schema_1.DEFAULT_ROOM_ID).split(',')[0].trim();
+                const maxChars = Number(args?.max_chars || 2000);
+                const hub2dUrl = cfg.hub2dUrl || 'ws://127.0.0.1:3001';
+                const context = await (0, context_1.fetchNexusContext)(roomId, hub2dUrl, cfg);
+                if (!context) {
+                    return { content: `[INFO] No recent context available for room '${roomId}'.` };
+                }
+                const truncated = context.length > maxChars ? `${context.slice(0, maxChars)}\n[...truncated ${context.length - maxChars} chars]` : context;
+                return { content: `## Room Summary: ${roomId}\n\n${truncated}` };
+            },
+        },
+    ];
+}

package/dist/src/transport/frames.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConnectFrame = buildConnectFrame;
+exports.buildAckFrame = buildAckFrame;
+exports.buildReplyFrame = buildReplyFrame;
+exports.buildSendFrame = buildSendFrame;
+function buildConnectFrame(params) {
+    const frame = {
+        type: 'connect',
+        node: params.node,
+        rooms: params.rooms,
+        resume_token: params.resumeToken || {},
+        clientInfo: {
+            openclawVersion: params.openclawVersion || 'unknown',
+            pluginVersion: params.pluginVersion || 'unknown',
+        },
+    };
+    if (params.token) {
+        frame.token = params.token;
+    }
+    return frame;
+}
+function buildAckFrame(roomId, eventId) {
+    return {
+        type: 'ack',
+        room_id: roomId,
+        event_id: eventId,
+    };
+}
+function buildReplyFrame(params) {
+    return {
+        type: 'reply',
+        event_id: params.eventId,
+        room_id: params.roomId,
+        from: params.from,
+        to: params.to,
+        text: params.text,
+        content: params.text,
+        status: params.status,
+        blocks: [],
+    };
+}
+function buildSendFrame(params) {
+    return {
+        type: 'send',
+        room_id: params.roomId,
+        text: params.text,
+        client_msg_id: params.clientMsgId,
+        mentions: params.mentions,
+    };
+}

package/dist/src/transport/reconnect.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReconnectState = createReconnectState;
+exports.scheduleReconnect = scheduleReconnect;
+exports.resetReconnectDelay = resetReconnectDelay;
+exports.incrementConnId = incrementConnId;
+exports.isStaleConnection = isStaleConnection;
+const MAX_RECONNECT_DELAY = 30000;
+const BASE_RECONNECT_DELAY = 1000;
+function createReconnectState() {
+    return {
+        currentDelay: BASE_RECONNECT_DELAY,
+        connId: 0
+    };
+}
+function scheduleReconnect(state, callback) {
+    const jitter = Math.floor(Math.random() * 250);
+    const delay = state.currentDelay + jitter;
+    const timer = setTimeout(() => {
+        callback();
+    }, delay);
+    state.currentDelay = Math.min(state.currentDelay * 2, MAX_RECONNECT_DELAY);
+    return { delay, timer };
+}
+function resetReconnectDelay(state) {
+    state.currentDelay = BASE_RECONNECT_DELAY;
+}
+function incrementConnId(state) {
+    return ++state.connId;
+}
+function isStaleConnection(state, connId) {
+    return connId !== state.connId;
+}

package/dist/src/transport/resume-store.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadResumeTokens = loadResumeTokens;
+exports.saveResumeTokens = saveResumeTokens;
+exports.initResumeTokenStore = initResumeTokenStore;
+exports.updateResumeToken = updateResumeToken;
+exports.getResumeTokens = getResumeTokens;
+exports.flushResumeTokens = flushResumeTokens;
+exports.resetResumeTokenStore = resetResumeTokenStore;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const RESUME_TOKEN_PATH = path.join(process.env.HOME || '~', '.openclaw', 'state', 'nexus-resume.json');
+function loadResumeTokens() {
+    try {
+        if (fs.existsSync(RESUME_TOKEN_PATH)) {
+            const data = JSON.parse(fs.readFileSync(RESUME_TOKEN_PATH, 'utf-8'));
+            return data || {};
+        }
+    }
+    catch (e) {
+        console.error(`[nexus] Failed to load resume_tokens: ${e.message}`);
+    }
+    return {};
+}
+function saveResumeTokens(tokens) {
+    try {
+        const dir = path.dirname(RESUME_TOKEN_PATH);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(RESUME_TOKEN_PATH, JSON.stringify(tokens, null, 2));
+    }
+    catch (e) {
+        console.error(`[nexus] Failed to save resume_tokens: ${e.message}`);
+    }
+}
+let flushTimer = null;
+let tokensDirty = false;
+let currentTokens = {};
+function initResumeTokenStore(initialTokens) {
+    currentTokens = initialTokens || loadResumeTokens();
+    tokensDirty = false;
+}
+function updateResumeToken(room, eventId) {
+    currentTokens[room] = eventId;
+    tokensDirty = true;
+    // Debounce flush: write at most every 2s
+    if (!flushTimer) {
+        flushTimer = setTimeout(() => {
+            flushTimer = null;
+            if (tokensDirty) {
+                saveResumeTokens(currentTokens);
+                tokensDirty = false;
+            }
+        }, 2000);
+    }
+}
+function getResumeTokens() {
+    return { ...currentTokens };
+}
+function flushResumeTokens() {
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+    if (tokensDirty) {
+        saveResumeTokens(currentTokens);
+        tokensDirty = false;
+    }
+}
+function resetResumeTokenStore() {
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+    currentTokens = {};
+    tokensDirty = false;
+}