@ynhcj/xiaoyi 2.5.6 → 2.5.7

package/dist/xy-parser.d.ts

@@ -0,0 +1,49 @@
+import type { A2AJsonRpcRequest, A2AMessagePart, A2ADataEvent } from "./types.js";
+/**
+ * Parsed message information extracted from A2A request.
+ * Note: agentId is not extracted from message - it should come from config.
+ */
+export interface ParsedA2AMessage {
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    parts: A2AMessagePart[];
+    method: string;
+}
+/**
+ * Parse an A2A JSON-RPC request into structured message data.
+ */
+export declare function parseA2AMessage(request: A2AJsonRpcRequest): ParsedA2AMessage;
+/**
+ * Extract text content from message parts.
+ */
+export declare function extractTextFromParts(parts: A2AMessagePart[]): string;
+/**
+ * Extract file parts from message parts.
+ */
+export declare function extractFileParts(parts: A2AMessagePart[]): Array<{
+    name: string;
+    mimeType: string;
+    uri: string;
+}>;
+/**
+ * Extract data events from message parts (for tool responses).
+ */
+export declare function extractDataEvents(parts: A2AMessagePart[]): A2ADataEvent[];
+/**
+ * Check if message is a clearContext request.
+ */
+export declare function isClearContextMessage(method: string): boolean;
+/**
+ * Check if message is a tasks/cancel request.
+ */
+export declare function isTasksCancelMessage(method: string): boolean;
+/**
+ * Extract push_id from message parts.
+ * Looks for push_id in data parts under variables.systemVariables.push_id
+ */
+export declare function extractPushId(parts: A2AMessagePart[]): string | null;
+/**
+ * Validate A2A request structure.
+ */
+export declare function validateA2ARequest(request: any): request is A2AJsonRpcRequest;

package/dist/xy-parser.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseA2AMessage = parseA2AMessage;
+exports.extractTextFromParts = extractTextFromParts;
+exports.extractFileParts = extractFileParts;
+exports.extractDataEvents = extractDataEvents;
+exports.isClearContextMessage = isClearContextMessage;
+exports.isTasksCancelMessage = isTasksCancelMessage;
+exports.extractPushId = extractPushId;
+exports.validateA2ARequest = validateA2ARequest;
+const logger_js_1 = require("./xy-utils/logger.js");
+/**
+ * Parse an A2A JSON-RPC request into structured message data.
+ */
+function parseA2AMessage(request) {
+    const { method, params, id } = request;
+    if (!params) {
+        throw new Error("A2A request missing params");
+    }
+    const { sessionId, message, id: paramsId } = params;
+    if (!sessionId || !message) {
+        throw new Error("A2A request params missing required fields");
+    }
+    return {
+        sessionId,
+        taskId: paramsId, // Task ID from params (对话唯一标识)
+        messageId: id, // Global unique message sequence ID from top-level request
+        parts: message.parts || [],
+        method,
+    };
+}
+/**
+ * Extract text content from message parts.
+ */
+function extractTextFromParts(parts) {
+    const textParts = parts
+        .filter((part) => part.kind === "text")
+        .map((part) => part.text);
+    return textParts.join("\n").trim();
+}
+/**
+ * Extract file parts from message parts.
+ */
+function extractFileParts(parts) {
+    return parts
+        .filter((part) => part.kind === "file")
+        .map((part) => part.file);
+}
+/**
+ * Extract data events from message parts (for tool responses).
+ */
+function extractDataEvents(parts) {
+    return parts
+        .filter((part) => part.kind === "data")
+        .map((part) => part.data.event)
+        .filter((event) => event !== undefined);
+}
+/**
+ * Check if message is a clearContext request.
+ */
+function isClearContextMessage(method) {
+    return method === "clearContext" || method === "clear_context";
+}
+/**
+ * Check if message is a tasks/cancel request.
+ */
+function isTasksCancelMessage(method) {
+    return method === "tasks/cancel" || method === "tasks_cancel";
+}
+/**
+ * Extract push_id from message parts.
+ * Looks for push_id in data parts under variables.systemVariables.push_id
+ */
+function extractPushId(parts) {
+    for (const part of parts) {
+        if (part.kind === "data" && part.data) {
+            const pushId = part.data.variables?.systemVariables?.push_id;
+            if (pushId && typeof pushId === "string") {
+                return pushId;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Validate A2A request structure.
+ */
+function validateA2ARequest(request) {
+    if (!request || typeof request !== "object") {
+        return false;
+    }
+    if (request.jsonrpc !== "2.0") {
+        logger_js_1.logger.warn("Invalid JSON-RPC version:", request.jsonrpc);
+        return false;
+    }
+    if (!request.method || typeof request.method !== "string") {
+        logger_js_1.logger.warn("Missing or invalid method");
+        return false;
+    }
+    if (!request.id) {
+        logger_js_1.logger.warn("Missing request id");
+        return false;
+    }
+    if (!request.params || typeof request.params !== "object") {
+        logger_js_1.logger.warn("Missing or invalid params");
+        return false;
+    }
+    return true;
+}

package/dist/xy-reply-dispatcher.d.ts

@@ -0,0 +1,17 @@
+import type { OpenClawConfig, RuntimeEnv } from "openclaw/dist/plugin-sdk/index.js";
+type ClawdbotConfig = OpenClawConfig;
+export interface CreateXYReplyDispatcherParams {
+    cfg: ClawdbotConfig;
+    runtime: RuntimeEnv;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    accountId: string;
+}
+/**
+ * Create a reply dispatcher for XY channel messages.
+ * Follows feishu pattern with status updates and streaming support.
+ * Runtime is expected to be validated before calling this function.
+ */
+export declare function createXYReplyDispatcher(params: CreateXYReplyDispatcherParams): any;
+export {};

package/dist/xy-reply-dispatcher.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createXYReplyDispatcher = createXYReplyDispatcher;
+const runtime_js_1 = require("./runtime.js");
+const xy_formatter_js_1 = require("./xy-formatter.js");
+const xy_config_js_1 = require("./xy-config.js");
+/**
+ * Create a reply dispatcher for XY channel messages.
+ * Follows feishu pattern with status updates and streaming support.
+ * Runtime is expected to be validated before calling this function.
+ */
+function createXYReplyDispatcher(params) {
+    const { cfg, runtime, sessionId, taskId, messageId, accountId } = params;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    log(`[DISPATCHER-CREATE] ******* Creating dispatcher for session=${sessionId}, taskId=${taskId}, messageId=${messageId} *******`);
+    log(`[DISPATCHER-CREATE] Stack trace:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
+    log(`[DISPATCHER-CREATE] ======== Creating reply dispatcher ========`);
+    log(`[DISPATCHER-CREATE] sessionId: ${sessionId}, taskId: ${taskId}, messageId: ${messageId}`);
+    log(`[DISPATCHER-CREATE] Stack trace:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
+    // Get OpenClaw PluginRuntime (not XiaoYiRuntime)
+    const xiaoYiRuntime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const core = xiaoYiRuntime.getPluginRuntime();
+    // Resolve configuration
+    const config = (0, xy_config_js_1.resolveXYConfig)(cfg);
+    // Reply prefix context: not imported at runtime to avoid openclaw/plugin-sdk
+    // module resolution issues in the CJS require chain. For a bot-to-bot A2A
+    // channel the response prefix (model name badge) is not needed.
+    const prefixContext = { responsePrefix: undefined, responsePrefixContextProvider: undefined, onModelSelected: undefined };
+    // Status update interval (every 60 seconds)
+    let statusUpdateInterval = null;
+    // Track if we've sent any response
+    let hasSentResponse = false;
+    // Track if we've sent the final empty message
+    let finalSent = false;
+    // Accumulate all text from deliver calls
+    let accumulatedText = "";
+    /**
+     * Start the status update interval
+     * Call this immediately after creating the dispatcher
+     */
+    const startStatusInterval = () => {
+        log(`[STATUS INTERVAL] Starting interval for session ${sessionId}, taskId=${taskId}`);
+        statusUpdateInterval = setInterval(() => {
+            log(`[STATUS INTERVAL] Triggering status update for session ${sessionId}, taskId=${taskId}`);
+            void (0, xy_formatter_js_1.sendStatusUpdate)({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                text: "任务正在处理中，请稍后~",
+                state: "working",
+            }).catch((err) => {
+                error(`Failed to send status update:`, err);
+            });
+        }, 30000); // 30 seconds
+    };
+    /**
+     * Stop the status update interval
+     */
+    const stopStatusInterval = () => {
+        if (statusUpdateInterval) {
+            log(`[STATUS INTERVAL] Stopping interval for session ${sessionId}, taskId=${taskId}`);
+            clearInterval(statusUpdateInterval);
+            statusUpdateInterval = null;
+            log(`[STATUS INTERVAL] Stopped interval for session ${sessionId}, taskId=${taskId}`);
+        }
+    };
+    const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+        responsePrefix: prefixContext.responsePrefix,
+        responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+        humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, accountId),
+        onReplyStart: () => {
+            log(`[REPLY START] Reply started for session ${sessionId}, taskId=${taskId}`);
+            // Status update interval is now managed externally
+        },
+        deliver: async (payload, info) => {
+            const text = payload.text ?? "";
+            // 🔍 Debug logging
+            log(`[DELIVER] sessionId=${sessionId}, info.kind=${info?.kind}, text.length=${text.length}, text="${text.slice(0, 200)}"`);
+            log(`[DELIVER] payload keys: ${Object.keys(payload).join(", ")}`);
+            if (payload.mediaUrls) {
+                log(`[DELIVER] mediaUrls: ${payload.mediaUrls.length} files`);
+            }
+            try {
+                // Skip empty messages
+                if (!text.trim()) {
+                    log(`[DELIVER SKIP] Empty text, skipping`);
+                    return;
+                }
+                // Accumulate text instead of sending immediately
+                accumulatedText += text;
+                hasSentResponse = true;
+                log(`[DELIVER ACCUMULATE] Accumulated text, current length=${accumulatedText.length}`);
+                // Also stream text as reasoningText for real-time display
+                await (0, xy_formatter_js_1.sendReasoningTextUpdate)({
+                    config,
+                    sessionId,
+                    taskId,
+                    messageId,
+                    text,
+                });
+                log(`[DELIVER] ✅ Sent deliver text as reasoningText update`);
+            }
+            catch (deliverError) {
+                error(`Failed to deliver message:`, deliverError);
+            }
+        },
+        onError: async (err, info) => {
+            runtime.error?.(`xy: ${info.kind} reply failed: ${String(err)}`);
+            // Stop status updates
+            stopStatusInterval();
+            // Send error status if we haven't sent any response yet
+            if (!hasSentResponse) {
+                try {
+                    await (0, xy_formatter_js_1.sendStatusUpdate)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "处理失败，请稍后重试",
+                        state: "failed",
+                    });
+                }
+                catch (statusError) {
+                    error(`Failed to send error status:`, statusError);
+                }
+            }
+        },
+        onIdle: async () => {
+            log(`[ON_IDLE] Reply idle for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+            // Send accumulated text with append=false and final=true
+            if (hasSentResponse && !finalSent) {
+                log(`[ON_IDLE] Sending accumulated text, length=${accumulatedText.length}`);
+                try {
+                    // Send status update before final message
+                    await (0, xy_formatter_js_1.sendStatusUpdate)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务处理已完成~",
+                        state: "completed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent completion status update`);
+                    await (0, xy_formatter_js_1.sendA2AResponse)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: accumulatedText,
+                        append: false,
+                        final: true,
+                    });
+                    finalSent = true;
+                    log(`[ON_IDLE] Sent accumulated text`);
+                }
+                catch (err) {
+                    error(`[ON_IDLE] Failed to send accumulated text:`, err);
+                }
+            }
+            else {
+                log(`[ON_IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+                // Task was interrupted - send failure status and error response
+                try {
+                    await (0, xy_formatter_js_1.sendStatusUpdate)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务处理中断了~",
+                        state: "failed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent failure status update`);
+                    await (0, xy_formatter_js_1.sendA2AResponse)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务执行异常，请重试~",
+                        append: false,
+                        final: true,
+                    });
+                    finalSent = true;
+                    log(`[ON_IDLE] ✅ Sent error response`);
+                }
+                catch (err) {
+                    error(`[ON_IDLE] Failed to send failure status and error response:`, err);
+                }
+            }
+            // Stop status updates
+            stopStatusInterval();
+        },
+        onCleanup: () => {
+            log(`[ON_CLEANUP] Reply cleanup for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+        },
+    });
+    return {
+        dispatcher,
+        replyOptions: {
+            ...replyOptions,
+            onModelSelected: prefixContext.onModelSelected,
+            // 🔧 Tool execution start callback
+            onToolStart: async ({ name, phase }) => {
+                log(`[TOOL START] 🔧 Tool execution started/updated: name=${name}, phase=${phase}, session=${sessionId}, taskId=${taskId}`);
+                if (phase === "start") {
+                    const toolName = name || "unknown";
+                    try {
+                        await (0, xy_formatter_js_1.sendStatusUpdate)({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text: `正在使用工具: ${toolName}...`,
+                            state: "working",
+                        });
+                        log(`[TOOL START] ✅ Sent status update for tool start: ${toolName}`);
+                    }
+                    catch (err) {
+                        error(`[TOOL START] ❌ Failed to send tool start status:`, err);
+                    }
+                }
+            },
+            // 🔧 Tool execution result callback
+            onToolResult: async (payload) => {
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[TOOL RESULT] 🔧 Tool execution result received: session=${sessionId}, taskId=${taskId}`);
+                log(`[TOOL RESULT]   - text.length=${text.length}`);
+                log(`[TOOL RESULT]   - hasMedia=${hasMedia}`);
+                log(`[TOOL RESULT]   - isError=${payload.isError}`);
+                if (text.length > 0) {
+                    log(`[TOOL RESULT]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                try {
+                    if (text.length > 0 || hasMedia) {
+                        const resultText = text.length > 0 ? text : "工具执行完成";
+                        await (0, xy_formatter_js_1.sendStatusUpdate)({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text: resultText,
+                            state: "working",
+                        });
+                        log(`[TOOL RESULT] ✅ Sent tool result as status update`);
+                    }
+                }
+                catch (err) {
+                    error(`[TOOL RESULT] ❌ Failed to send tool result status:`, err);
+                }
+            },
+            // 🧠 Reasoning/thinking process streaming callback
+            onReasoningStream: async (payload) => {
+                const text = payload.text ?? "";
+                log(`[REASONING STREAM] 🧠 Reasoning/thinking chunk received: session=${sessionId}, taskId=${taskId}`);
+                log(`[REASONING STREAM]   - text.length=${text.length}`);
+                if (text.length > 0) {
+                    log(`[REASONING STREAM]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                // try {
+                //   if (text.length > 0) {
+                //     await sendReasoningTextUpdate({
+                //       config,
+                //       sessionId,
+                //       taskId,
+                //       messageId,
+                //       text,
+                //     });
+                //     log(`[REASONING STREAM] ✅ Sent reasoning chunk as reasoningText update`);
+                //   }
+                // } catch (err) {
+                //   error(`[REASONING STREAM] ❌ Failed to send reasoning chunk reasoningText:`, err);
+                // }
+            },
+            // 📝 Partial reply streaming callback (real-time preview)
+            onPartialReply: async (payload) => {
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[PARTIAL REPLY] 📝 Partial reply chunk received: session=${sessionId}, taskId=${taskId}`);
+                log(`[PARTIAL REPLY]   - text.length=${text.length}`);
+                log(`[PARTIAL REPLY]   - hasMedia=${hasMedia}`);
+                if (text.length > 0) {
+                    log(`[PARTIAL REPLY]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                try {
+                    if (text.length > 0) {
+                        await (0, xy_formatter_js_1.sendReasoningTextUpdate)({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text,
+                            append: false,
+                        });
+                        log(`[PARTIAL REPLY] ✅ Sent partial reply as reasoningText update (append=false)`);
+                    }
+                }
+                catch (err) {
+                    error(`[PARTIAL REPLY] ❌ Failed to send partial reply reasoningText:`, err);
+                }
+            },
+        },
+        markDispatchIdle,
+        startStatusInterval, // Expose this to be called immediately
+        stopStatusInterval, // Expose this for manual control if needed
+    };
+}

package/dist/xy-tools/session-manager.d.ts

@@ -0,0 +1,29 @@
+import type { XiaoYiChannelConfig } from "../types.js";
+export interface SessionContext {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    agentId: string;
+}
+/**
+ * Register a session context for tool access.
+ * Should be called when starting to process a message.
+ */
+export declare function registerSession(sessionKey: string, context: SessionContext): void;
+/**
+ * Unregister a session context.
+ * Should be called when message processing is complete.
+ */
+export declare function unregisterSession(sessionKey: string): void;
+/**
+ * Get session context by sessionKey.
+ * Returns null if session not found.
+ */
+export declare function getSessionContext(sessionKey: string): SessionContext | null;
+/**
+ * Get the most recent session context.
+ * This is a fallback for tools that don't have access to sessionKey.
+ * Returns null if no sessions are active.
+ */
+export declare function getLatestSessionContext(): SessionContext | null;

package/dist/xy-tools/session-manager.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSession = registerSession;
+exports.unregisterSession = unregisterSession;
+exports.getSessionContext = getSessionContext;
+exports.getLatestSessionContext = getLatestSessionContext;
+const logger_js_1 = require("../xy-utils/logger.js");
+const config_manager_js_1 = require("../xy-utils/config-manager.js");
+// Map of sessionKey -> SessionContext
+const activeSessions = new Map();
+/**
+ * Register a session context for tool access.
+ * Should be called when starting to process a message.
+ */
+function registerSession(sessionKey, context) {
+    logger_js_1.logger.log(`[SESSION_MANAGER] 📝 Registering session: ${sessionKey}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - taskId: ${context.taskId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - messageId: ${context.messageId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - agentId: ${context.agentId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
+    activeSessions.set(sessionKey, context);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - All session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
+}
+/**
+ * Unregister a session context.
+ * Should be called when message processing is complete.
+ */
+function unregisterSession(sessionKey) {
+    logger_js_1.logger.log(`[SESSION_MANAGER] 🗑️  Unregistering session: ${sessionKey}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Session existed: ${activeSessions.has(sessionKey)}`);
+    // Get session context before deleting to clear associated pushId
+    const context = activeSessions.get(sessionKey);
+    const existed = activeSessions.delete(sessionKey);
+    // Clear cached pushId for this session
+    if (context) {
+        config_manager_js_1.configManager.clearSession(context.sessionId);
+    }
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Deleted: ${existed}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Remaining session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
+}
+/**
+ * Get session context by sessionKey.
+ * Returns null if session not found.
+ */
+function getSessionContext(sessionKey) {
+    logger_js_1.logger.log(`[SESSION_MANAGER] 🔍 Getting session by key: ${sessionKey}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions: ${activeSessions.size}`);
+    const context = activeSessions.get(sessionKey) ?? null;
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Found: ${context !== null}`);
+    if (context) {
+        logger_js_1.logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
+    }
+    return context;
+}
+/**
+ * Get the most recent session context.
+ * This is a fallback for tools that don't have access to sessionKey.
+ * Returns null if no sessions are active.
+ */
+function getLatestSessionContext() {
+    logger_js_1.logger.log(`[SESSION_MANAGER] 🔍 Getting latest session context`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions count: ${activeSessions.size}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
+    if (activeSessions.size === 0) {
+        logger_js_1.logger.error(`[SESSION_MANAGER]   - ❌ No active sessions found!`);
+        return null;
+    }
+    // Return the last added session
+    const sessions = Array.from(activeSessions.values());
+    const latestSession = sessions[sessions.length - 1];
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - ✅ Found latest session:`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]     - sessionId: ${latestSession.sessionId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]     - taskId: ${latestSession.taskId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]     - messageId: ${latestSession.messageId}`);
+    return latestSession;
+}

package/dist/xy-utils/config-manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Manages dynamic configuration updates that can change at runtime.
+ * Specifically handles pushId which can be updated per-session.
+ */
+declare class ConfigManager {
+    private sessionPushIds;
+    private globalPushId;
+    /**
+     * Update push ID for a specific session.
+     */
+    updatePushId(sessionId: string, pushId: string): void;
+    /**
+     * Get push ID for a session (falls back to global if not found).
+     */
+    getPushId(sessionId?: string): string | null;
+    /**
+     * Clear push ID for a session.
+     */
+    clearSession(sessionId: string): void;
+    /**
+     * Clear all cached push IDs.
+     */
+    clear(): void;
+}
+export declare const configManager: ConfigManager;
+export {};

package/dist/xy-utils/config-manager.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = void 0;
+// Dynamic configuration manager for runtime updates
+const logger_js_1 = require("./logger.js");
+/**
+ * Manages dynamic configuration updates that can change at runtime.
+ * Specifically handles pushId which can be updated per-session.
+ */
+class ConfigManager {
+    constructor() {
+        this.sessionPushIds = new Map();
+        this.globalPushId = null;
+    }
+    /**
+     * Update push ID for a specific session.
+     */
+    updatePushId(sessionId, pushId) {
+        if (!pushId) {
+            logger_js_1.logger.warn(`[ConfigManager] Attempted to set empty pushId for session ${sessionId}`);
+            return;
+        }
+        const previous = this.sessionPushIds.get(sessionId);
+        if (previous !== pushId) {
+            logger_js_1.logger.log(`[ConfigManager] ✨ Updated pushId for session ${sessionId}`);
+            logger_js_1.logger.log(`[ConfigManager]   - Previous: ${previous ? previous.substring(0, 20) + '...' : 'none'}`);
+            logger_js_1.logger.log(`[ConfigManager]   - New:      ${pushId.substring(0, 20)}...`);
+            logger_js_1.logger.log(`[ConfigManager]   - Full new pushId: ${pushId}`);
+            this.sessionPushIds.set(sessionId, pushId);
+            this.globalPushId = pushId; // Also update global for backward compatibility
+        }
+    }
+    /**
+     * Get push ID for a session (falls back to global if not found).
+     */
+    getPushId(sessionId) {
+        if (sessionId) {
+            const sessionPushId = this.sessionPushIds.get(sessionId);
+            if (sessionPushId) {
+                return sessionPushId;
+            }
+        }
+        return this.globalPushId;
+    }
+    /**
+     * Clear push ID for a session.
+     */
+    clearSession(sessionId) {
+        this.sessionPushIds.delete(sessionId);
+        logger_js_1.logger.debug(`[ConfigManager] Cleared pushId for session ${sessionId}`);
+    }
+    /**
+     * Clear all cached push IDs.
+     */
+    clear() {
+        this.sessionPushIds.clear();
+        this.globalPushId = null;
+        logger_js_1.logger.debug(`[ConfigManager] Cleared all cached pushIds`);
+    }
+}
+exports.configManager = new ConfigManager();