@ynhcj/xiaoyi-channel 0.0.1 → 0.0.2-beta

package/dist/src/bot.js

@@ -1,10 +1,11 @@
 import { getXYRuntime } from "./runtime.js";
 import { createXYReplyDispatcher } from "./reply-dispatcher.js";
-import { parseA2AMessage, extractTextFromParts, extractFileParts } from "./parser.js";
+import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId } from "./parser.js";
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse } from "./formatter.js";
 import { registerSession, unregisterSession } from "./tools/session-manager.js";
+import { configManager } from "./utils/config-manager.js";
 /**
  * Handle an incoming A2A message.
  * This is the main entry point for message processing.
@@ -19,7 +20,8 @@ export async function handleXYMessage(params) {
     try {
         // Check for special messages BEFORE parsing (these have different param structures)
         const messageMethod = message.method;
-        log(`[DEBUG] Received message with method: ${messageMethod}, id: ${message.id}`);
+        log(`[BOT-ENTRY] <<<<<<< Received message with method: ${messageMethod}, id: ${message.id} >>>>>>>`);
+        log(`[BOT-ENTRY] Stack trace for debugging:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
         // Handle clearContext messages (params only has sessionId)
         if (messageMethod === "clearContext" || messageMethod === "clear_context") {
             const sessionId = message.params?.sessionId;
@@ -54,6 +56,18 @@ export async function handleXYMessage(params) {
         }
         // Parse the A2A message (for regular messages)
         const parsed = parseA2AMessage(message);
+        // Extract and update push_id if present
+        const pushId = extractPushId(parsed.parts);
+        if (pushId) {
+            log(`[BOT] 📌 Extracted push_id from user message`);
+            log(`[BOT]   - Session ID: ${parsed.sessionId}`);
+            log(`[BOT]   - Push ID preview: ${pushId.substring(0, 20)}...`);
+            log(`[BOT]   - Full push_id: ${pushId}`);
+            configManager.updatePushId(parsed.sessionId, pushId);
+        }
+        else {
+            log(`[BOT] ℹ️  No push_id found in message, will use config default`);
+        }
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
         // ✅ Resolve agent route (following feishu pattern)
@@ -61,7 +75,7 @@ export async function handleXYMessage(params) {
         // Use sessionId as peer.id to ensure all messages in the same session share context
         let route = core.channel.routing.resolveAgentRoute({
             cfg,
-            channel: "xy",
+            channel: "xiaoyi-channel",
             accountId, // "default"
             peer: {
                 kind: "direct",
@@ -70,6 +84,10 @@ export async function handleXYMessage(params) {
         });
         log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
         // Register session context for tools
+        log(`[BOT] 📝 About to register session for tools...`);
+        log(`[BOT]   - sessionKey: ${route.sessionKey}`);
+        log(`[BOT]   - sessionId: ${parsed.sessionId}`);
+        log(`[BOT]   - taskId: ${parsed.taskId}`);
         registerSession(route.sessionKey, {
             config,
             sessionId: parsed.sessionId,
@@ -77,6 +95,7 @@ export async function handleXYMessage(params) {
             messageId: parsed.messageId,
             agentId: route.accountId,
         });
+        log(`[BOT] ✅ Session registered for tools`);
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
         const fileParts = extractFileParts(parsed.parts);
@@ -93,7 +112,7 @@ export async function handleXYMessage(params) {
         messageBody = `${speaker}: ${messageBody}`;
         // Format agent envelope (following feishu pattern)
         const body = core.channel.reply.formatAgentEnvelope({
-            channel: "XY",
+            channel: "xiaoyi-channel",
             from: speaker,
             timestamp: new Date(),
             envelope: envelopeOptions,
@@ -113,13 +132,13 @@ export async function handleXYMessage(params) {
             GroupSubject: undefined,
             SenderName: parsed.sessionId,
             SenderId: parsed.sessionId,
-            Provider: "xy",
-            Surface: "xy",
+            Provider: "xiaoyi-channel",
+            Surface: "xiaoyi-channel",
             MessageSid: parsed.messageId,
             Timestamp: Date.now(),
             WasMentioned: false,
             CommandAuthorized: true,
-            OriginatingChannel: "xy",
+            OriginatingChannel: "xiaoyi-channel",
             OriginatingTo: parsed.sessionId, // Original message target
             ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
             ...mediaPayload,
@@ -137,6 +156,7 @@ export async function handleXYMessage(params) {
             error(`Failed to send initial status update:`, err);
         });
         // Create reply dispatcher (following feishu pattern)
+        log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher for session=${parsed.sessionId}, taskId=${parsed.taskId}, messageId=${parsed.messageId}`);
         const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = createXYReplyDispatcher({
             cfg,
             runtime,
@@ -145,17 +165,22 @@ export async function handleXYMessage(params) {
             messageId: parsed.messageId,
             accountId: route.accountId, // ✅ Use route.accountId
         });
+        log(`[BOT-DISPATCHER] ✅ Reply dispatcher created successfully`);
         // Start status update interval (will send updates every 60 seconds)
         // Interval will be automatically stopped when onIdle/onCleanup is triggered
         startStatusInterval();
         log(`xy: dispatching to agent (session=${parsed.sessionId})`);
         // Dispatch to OpenClaw core using correct API (following feishu pattern)
+        log(`[BOT] 🚀 Starting dispatcher with session: ${route.sessionKey}`);
         await core.channel.reply.withReplyDispatcher({
             dispatcher,
             onSettled: () => {
+                log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
+                log(`[BOT]   - About to unregister session...`);
                 markDispatchIdle();
                 // Unregister session context when done
                 unregisterSession(route.sessionKey);
+                log(`[BOT] ✅ Session unregistered in onSettled`);
             },
             run: () => core.channel.reply.dispatchReplyFromConfig({
                 ctx: ctxPayload,
@@ -164,33 +189,40 @@ export async function handleXYMessage(params) {
                 replyOptions,
             }),
         });
+        log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
         log(`xy: dispatch complete (session=${parsed.sessionId})`);
     }
     catch (err) {
+        // ✅ Only log error, don't re-throw to prevent gateway restart
         error("Failed to handle XY message:", err);
         runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
+        log(`[BOT] ❌ Error occurred, attempting cleanup...`);
         // Try to unregister session on error (if route was established)
         try {
             const core = getXYRuntime();
             const params = message.params;
             const sessionId = params?.sessionId;
             if (sessionId) {
+                log(`[BOT] 🧹 Cleaning up session after error: ${sessionId}`);
                 const route = core.channel.routing.resolveAgentRoute({
                     cfg,
-                    channel: "xy",
+                    channel: "xiaoyi-channel",
                     accountId,
                     peer: {
                         kind: "direct",
                         id: sessionId, // ✅ Use sessionId for cleanup consistency
                     },
                 });
+                log(`[BOT]   - Unregistering session: ${route.sessionKey}`);
                 unregisterSession(route.sessionKey);
+                log(`[BOT] ✅ Session unregistered after error`);
             }
         }
-        catch {
+        catch (cleanupErr) {
+            log(`[BOT] ⚠️  Cleanup failed:`, cleanupErr);
             // Ignore cleanup errors
         }
-        throw err;
+        // ❌ Don't re-throw: message processing error should not affect gateway stability
     }
 }
 /**

package/dist/src/channel.js

@@ -3,6 +3,9 @@ import { xyConfigSchema } from "./config-schema.js";
 import { xyOutbound } from "./outbound.js";
 import { xyOnboardingAdapter } from "./onboarding.js";
 import { locationTool } from "./tools/location-tool.js";
+import { noteTool } from "./tools/note-tool.js";
+import { searchNoteTool } from "./tools/search-note-tool.js";
+import { calendarTool } from "./tools/calendar-tool.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -20,6 +23,7 @@ export const xyPlugin = {
     agentPrompt: {
         messageToolHints: () => [
             "- xiaoyi targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `default`",
+            "- sendMedia requires a text reply"
         ],
     },
     capabilities: {
@@ -41,7 +45,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool],
+    agentTools: [locationTool, noteTool, searchNoteTool, calendarTool],
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();
@@ -77,6 +81,7 @@ export const xyPlugin = {
                 runtime: context.runtime,
                 abortSignal: context.abortSignal,
                 accountId: context.accountId,
+                setStatus: context.setStatus,
             });
         },
     },

package/dist/src/client.d.ts

@@ -10,6 +10,11 @@ export declare function setClientRuntime(rt: RuntimeEnv | undefined): void;
  * Reuses existing managers if config matches.
  */
 export declare function getXYWebSocketManager(config: XYChannelConfig): XYWebSocketManager;
+/**
+ * Remove a specific WebSocket manager from cache.
+ * Disconnects the manager and removes it from the cache.
+ */
+export declare function removeXYWebSocketManager(config: XYChannelConfig): void;
 /**
  * Clear all cached WebSocket managers.
  */
@@ -18,3 +23,13 @@ export declare function clearXYWebSocketManagers(): void;
  * Get the number of cached managers.
  */
 export declare function getCachedManagerCount(): number;
+/**
+ * Diagnose all cached WebSocket managers.
+ * Helps identify connection issues and orphan connections.
+ */
+export declare function diagnoseAllManagers(): void;
+/**
+ * Clean up orphan connections across all managers.
+ * Returns the number of managers that had orphan connections.
+ */
+export declare function cleanupOrphanConnections(): number;

package/dist/src/client.js

@@ -23,16 +23,34 @@ export function getXYWebSocketManager(config) {
     let cached = wsManagerCache.get(cacheKey);
     if (cached && cached.isConfigMatch(config)) {
         const log = runtime?.log ?? console.log;
-        log(`[DEBUG] Reusing cached WebSocket manager: ${cacheKey}`);
+        log(`[WS-MANAGER-CACHE] ✅ Reusing cached WebSocket manager: ${cacheKey}, total managers: ${wsManagerCache.size}`);
         return cached;
     }
     // Create new manager
     const log = runtime?.log ?? console.log;
-    log(`Creating new WebSocket manager: ${cacheKey}`);
+    log(`[WS-MANAGER-CACHE] 🆕 Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
     cached = new XYWebSocketManager(config, runtime);
     wsManagerCache.set(cacheKey, cached);
+    log(`[WS-MANAGER-CACHE] 📊 Total managers after creation: ${wsManagerCache.size}`);
     return cached;
 }
+/**
+ * Remove a specific WebSocket manager from cache.
+ * Disconnects the manager and removes it from the cache.
+ */
+export function removeXYWebSocketManager(config) {
+    const cacheKey = `${config.apiKey}-${config.agentId}`;
+    const manager = wsManagerCache.get(cacheKey);
+    if (manager) {
+        console.log(`🗑️  [WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
+        manager.disconnect();
+        wsManagerCache.delete(cacheKey);
+        console.log(`🗑️  [WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
+    }
+    else {
+        console.log(`⚠️  [WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
+    }
+}
 /**
  * Clear all cached WebSocket managers.
  */
@@ -50,3 +68,80 @@ export function clearXYWebSocketManagers() {
 export function getCachedManagerCount() {
     return wsManagerCache.size;
 }
+/**
+ * Diagnose all cached WebSocket managers.
+ * Helps identify connection issues and orphan connections.
+ */
+export function diagnoseAllManagers() {
+    console.log("========================================");
+    console.log("📊 WebSocket Manager Global Diagnostics");
+    console.log("========================================");
+    console.log(`Total cached managers: ${wsManagerCache.size}`);
+    console.log("");
+    if (wsManagerCache.size === 0) {
+        console.log("ℹ️  No managers in cache");
+        console.log("========================================");
+        return;
+    }
+    let orphanCount = 0;
+    wsManagerCache.forEach((manager, key) => {
+        const diag = manager.getConnectionDiagnostics();
+        console.log(`📌 Manager: ${key}`);
+        console.log(`   Shutting down: ${diag.isShuttingDown}`);
+        console.log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
+        // Server 1
+        console.log(`   🔌 Server1:`);
+        console.log(`      - Exists: ${diag.server1.exists}`);
+        console.log(`      - ReadyState: ${diag.server1.readyState}`);
+        console.log(`      - State connected/ready: ${diag.server1.stateConnected}/${diag.server1.stateReady}`);
+        console.log(`      - Reconnect attempts: ${diag.server1.reconnectAttempts}`);
+        console.log(`      - Listeners on WebSocket: ${diag.server1.listenerCount}`);
+        console.log(`      - Heartbeat active: ${diag.server1.heartbeatActive}`);
+        console.log(`      - Has reconnect timer: ${diag.server1.hasReconnectTimer}`);
+        if (diag.server1.isOrphan) {
+            console.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
+            orphanCount++;
+        }
+        // Server 2
+        console.log(`   🔌 Server2:`);
+        console.log(`      - Exists: ${diag.server2.exists}`);
+        console.log(`      - ReadyState: ${diag.server2.readyState}`);
+        console.log(`      - State connected/ready: ${diag.server2.stateConnected}/${diag.server2.stateReady}`);
+        console.log(`      - Reconnect attempts: ${diag.server2.reconnectAttempts}`);
+        console.log(`      - Listeners on WebSocket: ${diag.server2.listenerCount}`);
+        console.log(`      - Heartbeat active: ${diag.server2.heartbeatActive}`);
+        console.log(`      - Has reconnect timer: ${diag.server2.hasReconnectTimer}`);
+        if (diag.server2.isOrphan) {
+            console.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
+            orphanCount++;
+        }
+        console.log("");
+    });
+    if (orphanCount > 0) {
+        console.log(`⚠️  Total orphan connections found: ${orphanCount}`);
+        console.log(`💡 Suggestion: These connections should be cleaned up`);
+    }
+    else {
+        console.log(`✅ No orphan connections found`);
+    }
+    console.log("========================================");
+}
+/**
+ * Clean up orphan connections across all managers.
+ * Returns the number of managers that had orphan connections.
+ */
+export function cleanupOrphanConnections() {
+    let cleanedCount = 0;
+    wsManagerCache.forEach((manager, key) => {
+        const diag = manager.getConnectionDiagnostics();
+        if (diag.server1.isOrphan || diag.server2.isOrphan) {
+            console.log(`🧹 Cleaning up orphan connections in manager: ${key}`);
+            manager.disconnect();
+            cleanedCount++;
+        }
+    });
+    if (cleanedCount > 0) {
+        console.log(`🧹 Cleaned up ${cleanedCount} manager(s) with orphan connections`);
+    }
+    return cleanedCount;
+}

package/dist/src/file-upload.js

@@ -48,7 +48,7 @@ export class XYFileUploadService {
                         uid: this.uid,
                         teamId: this.uid,
                     },
-                    useEdge: true,
+                    useEdge: false,
                 }),
             });
             if (!prepareResp.ok) {

package/dist/src/formatter.js

@@ -51,8 +51,21 @@ export async function sendA2AResponse(params) {
         taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
+    // 📋 Log complete response body
+    log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response:`);
+    log(`[A2A_RESPONSE]   - sessionId: ${sessionId}`);
+    log(`[A2A_RESPONSE]   - taskId: ${taskId}`);
+    log(`[A2A_RESPONSE]   - messageId: ${messageId}`);
+    log(`[A2A_RESPONSE]   - append: ${append}`);
+    log(`[A2A_RESPONSE]   - final: ${final}`);
+    log(`[A2A_RESPONSE]   - text length: ${text?.length ?? 0}`);
+    log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
+    log(`[A2A_RESPONSE] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_RESPONSE] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`Sent A2A response: sessionId=${sessionId}, taskId=${taskId}, final=${final}`);
+    log(`[A2A_RESPONSE] ✅ Message sent successfully`);
 }
 /**
  * Send an A2A task status update.
@@ -96,8 +109,19 @@ export async function sendStatusUpdate(params) {
         taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
+    // 📋 Log complete response body
+    log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
+    log(`[A2A_STATUS]   - sessionId: ${sessionId}`);
+    log(`[A2A_STATUS]   - taskId: ${taskId}`);
+    log(`[A2A_STATUS]   - messageId: ${messageId}`);
+    log(`[A2A_STATUS]   - state: ${state}`);
+    log(`[A2A_STATUS]   - text: "${text}"`);
+    log(`[A2A_STATUS] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_STATUS] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`Sent status update: sessionId=${sessionId}, state=${state}, text="${text}"`);
+    log(`[A2A_STATUS] ✅ Status update sent successfully`);
 }
 /**
  * Send a command as an artifact update (final=false).
@@ -107,7 +131,8 @@ export async function sendCommand(params) {
     const runtime = getXYRuntime();
     const log = runtime?.log ?? console.log;
     const error = runtime?.error ?? console.error;
-    // Build artifact update with command
+    // Build artifact update with command as data
+    // Wrap command in commands array as per protocol requirement
     const artifact = {
         taskId,
         kind: "artifact-update",
@@ -118,8 +143,10 @@ export async function sendCommand(params) {
             artifactId: uuidv4(),
             parts: [
                 {
-                    kind: "command",
-                    command,
+                    kind: "data",
+                    data: {
+                        commands: [command],
+                    },
                 },
             ],
         },
@@ -139,8 +166,18 @@ export async function sendCommand(params) {
         taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
+    // 📋 Log complete response body
+    log(`[A2A_COMMAND] 📤 Sending A2A command:`);
+    log(`[A2A_COMMAND]   - sessionId: ${sessionId}`);
+    log(`[A2A_COMMAND]   - taskId: ${taskId}`);
+    log(`[A2A_COMMAND]   - messageId: ${messageId}`);
+    log(`[A2A_COMMAND]   - command: ${command.header.namespace}::${command.header.name}`);
+    log(`[A2A_COMMAND] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_COMMAND] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`Sent command: sessionId=${sessionId}, command=${command.header.name}`);
+    log(`[A2A_COMMAND] ✅ Command sent successfully`);
 }
 /**
  * Send a clearContext response.

package/dist/src/heartbeat.d.ts

@@ -13,12 +13,13 @@ export declare class HeartbeatManager {
     private config;
     private onTimeout;
     private serverName;
+    private onHeartbeatSuccess?;
     private intervalTimer;
     private timeoutTimer;
     private lastPongTime;
     private log;
     private error;
-    constructor(ws: WebSocket, config: HeartbeatConfig, onTimeout: () => void, serverName?: string, logFn?: (msg: string, ...args: any[]) => void, errorFn?: (msg: string, ...args: any[]) => void);
+    constructor(ws: WebSocket, config: HeartbeatConfig, onTimeout: () => void, serverName?: string, logFn?: (msg: string, ...args: any[]) => void, errorFn?: (msg: string, ...args: any[]) => void, onHeartbeatSuccess?: () => void);
     /**
      * Start heartbeat monitoring.
      */

package/dist/src/heartbeat.js

@@ -9,17 +9,20 @@ export class HeartbeatManager {
     config;
     onTimeout;
     serverName;
+    onHeartbeatSuccess;
     intervalTimer = null;
     timeoutTimer = null;
     lastPongTime = 0;
     // Logging functions following feishu pattern
     log;
     error;
-    constructor(ws, config, onTimeout, serverName = "unknown", logFn, errorFn) {
+    constructor(ws, config, onTimeout, serverName = "unknown", logFn, errorFn, onHeartbeatSuccess // ✅ 新增：心跳成功回调
+    ) {
         this.ws = ws;
         this.config = config;
         this.onTimeout = onTimeout;
         this.serverName = serverName;
+        this.onHeartbeatSuccess = onHeartbeatSuccess;
         this.log = logFn ?? console.log;
         this.error = errorFn ?? console.error;
     }
@@ -36,6 +39,8 @@ export class HeartbeatManager {
                 clearTimeout(this.timeoutTimer);
                 this.timeoutTimer = null;
             }
+            // ✅ Report health: heartbeat successful
+            this.onHeartbeatSuccess?.();
         });
         // Start interval timer
         this.intervalTimer = setInterval(() => {
@@ -67,9 +72,12 @@ export class HeartbeatManager {
         }
         try {
             // Send application-level heartbeat message
+            console.log(`[WS-${this.serverName}-SEND] Sending heartbeat frame:`, this.config.message);
             this.ws.send(this.config.message);
+            console.log(`[WS-${this.serverName}-SEND] Heartbeat message sent, size: ${this.config.message.length} bytes`);
             // Send protocol-level ping
             this.ws.ping();
+            console.log(`[WS-${this.serverName}-SEND] Protocol-level ping sent`);
             // Setup timeout timer
             this.timeoutTimer = setTimeout(() => {
                 this.error(`Heartbeat timeout for ${this.serverName}`);

package/dist/src/monitor.d.ts

@@ -4,6 +4,11 @@ export type MonitorXYOpts = {
     runtime?: RuntimeEnv;
     abortSignal?: AbortSignal;
     accountId?: string;
+    setStatus?: (status: {
+        lastEventAt?: number;
+        lastInboundAt?: number;
+        connected?: boolean;
+    }) => void;
 };
 /**
  * Monitor XY channel WebSocket connections.