@ynhcj/xiaoyi-channel 0.0.129-beta → 0.0.129-next

package/dist/src/client.js

@@ -1,14 +1,7 @@
 // WebSocket client cache management
 // Follows feishu/client.ts pattern for caching client instances
 import { XYWebSocketManager } from "./websocket.js";
-// Runtime reference for logging
-let runtime;
-/**
- * Set the runtime for logging in client module.
- */
-export function setClientRuntime(rt) {
-    runtime = rt;
-}
+import { logger } from "./utils/logger.js";
 /**
  * Global cache for WebSocket managers.
  * Key format: `${apiKey}-${agentId}`
@@ -24,19 +17,17 @@ const wsManagerCache = _g.__xyWsManagerCache;
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.
  */
-export function getXYWebSocketManager(config) {
+export function getXYWebSocketManager(config, runtime) {
     const cacheKey = `${config.apiKey}-${config.agentId}`;
     let cached = wsManagerCache.get(cacheKey);
     if (cached && cached.isConfigMatch(config)) {
-        const log = runtime?.log ?? console.log;
         return cached;
     }
     // Create new manager
-    const log = runtime?.log ?? console.log;
-    log(`[WS-MANAGER-CACHE] 🆕 Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
+    logger.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}`);
+    logger.log(`[WS-MANAGER-CACHE] 📊 Total managers after creation: ${wsManagerCache.size}`);
     return cached;
 }
 /**
@@ -44,25 +35,23 @@ export function getXYWebSocketManager(config) {
  * Disconnects the manager and removes it from the cache.
  */
 export function removeXYWebSocketManager(config) {
-    const log = runtime?.log ?? console.log;
     const cacheKey = `${config.apiKey}-${config.agentId}`;
     const manager = wsManagerCache.get(cacheKey);
     if (manager) {
-        log(`🗑️  [WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
+        logger.log(`🗑️  [WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
         manager.disconnect();
         wsManagerCache.delete(cacheKey);
-        log(`🗑️  [WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
+        logger.log(`🗑️  [WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
     }
     else {
-        log(`⚠️  [WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
+        logger.log(`⚠️  [WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
     }
 }
 /**
  * Clear all cached WebSocket managers.
  */
 export function clearXYWebSocketManagers() {
-    const log = runtime?.log ?? console.log;
-    log("Clearing all WebSocket manager caches");
+    logger.log("Clearing all WebSocket manager caches");
     for (const manager of wsManagerCache.values()) {
         manager.disconnect();
     }
@@ -79,37 +68,35 @@ export function getCachedManagerCount() {
  * Helps identify connection issues and orphan connections.
  */
 export function diagnoseAllManagers() {
-    const log = runtime?.log ?? console.log;
-    log(`Total cached managers: ${wsManagerCache.size}`);
+    logger.log(`Total cached managers: ${wsManagerCache.size}`);
     if (wsManagerCache.size === 0) {
-        log("ℹ️  No managers in cache");
+        logger.log("ℹ️  No managers in cache");
         return;
     }
     let orphanCount = 0;
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
-        log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
+        logger.log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
         // Connection
-        log(`   🔌 Connection:`);
-        log(`      - Exists: ${diag.connection.exists}`);
-        log(`      - ReadyState: ${diag.connection.readyState}`);
-        log(`      - State connected/ready: ${diag.connection.stateConnected}/${diag.connection.stateReady}`);
-        log(`      - Reconnect attempts: ${diag.connection.reconnectAttempts}`);
-        log(`      - Listeners on WebSocket: ${diag.connection.listenerCount}`);
-        log(`      - Heartbeat active: ${diag.connection.heartbeatActive}`);
-        log(`      - Has reconnect timer: ${diag.connection.hasReconnectTimer}`);
+        logger.log(`   🔌 Connection:`);
+        logger.log(`      - Exists: ${diag.connection.exists}`);
+        logger.log(`      - ReadyState: ${diag.connection.readyState}`);
+        logger.log(`      - State connected/ready: ${diag.connection.stateConnected}/${diag.connection.stateReady}`);
+        logger.log(`      - Reconnect attempts: ${diag.connection.reconnectAttempts}`);
+        logger.log(`      - Listeners on WebSocket: ${diag.connection.listenerCount}`);
+        logger.log(`      - Heartbeat active: ${diag.connection.heartbeatActive}`);
+        logger.log(`      - Has reconnect timer: ${diag.connection.hasReconnectTimer}`);
         if (diag.connection.isOrphan) {
-            log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
+            logger.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
             orphanCount++;
         }
-        log("");
     });
     if (orphanCount > 0) {
-        log(`⚠️  Total orphan connections found: ${orphanCount}`);
-        log(`💡 Suggestion: These connections should be cleaned up`);
+        logger.log(`⚠️  Total orphan connections found: ${orphanCount}`);
+        logger.log(`💡 Suggestion: These connections should be cleaned up`);
     }
     else {
-        log(`✅ No orphan connections found`);
+        logger.log(`✅ No orphan connections found`);
     }
 }
 /**
@@ -117,18 +104,17 @@ export function diagnoseAllManagers() {
  * Returns the number of managers that had orphan connections.
  */
 export function cleanupOrphanConnections() {
-    const log = runtime?.log ?? console.log;
     let cleanedCount = 0;
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
         if (diag.connection.isOrphan) {
-            log(`🧹 Cleaning up orphan connections in manager: ${key}`);
+            logger.log(`🧹 Cleaning up orphan connections in manager: ${key}`);
             manager.disconnect();
             cleanedCount++;
         }
     });
     if (cleanedCount > 0) {
-        log(`🧹 Cleaned up ${cleanedCount} manager(s) with orphan connections`);
+        logger.log(`🧹 Cleaned up ${cleanedCount} manager(s) with orphan connections`);
     }
     return cleanedCount;
 }

package/dist/src/cspl/call-api.d.ts

@@ -1,3 +1,9 @@
 import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import { type CsplConfig } from "./config.js";
 import type { ApiResponse } from "./constants.js";
 export declare function callCsplApi(questionText: string, cfg: ClawdbotConfig): Promise<ApiResponse>;
+/**
+ * Call CSPL API with a pre-resolved CsplConfig.
+ * Used by after_tool_call hook which has session context but not ClawdbotConfig.
+ */
+export declare function callCsplApiWithConfig(questionText: string, config: CsplConfig): Promise<ApiResponse>;

package/dist/src/cspl/call-api.js

@@ -1,4 +1,5 @@
 // SENTINEL HOOK API 请求模块
+import http from "node:http";
 import https from "node:https";
 import { URL } from "node:url";
 import { randomBytes } from "node:crypto";
@@ -43,18 +44,12 @@ function parseResponse(data) {
     }
     return json;
 }
-export async function callCsplApi(questionText, cfg) {
-    const config = getCsplConfig(cfg);
-    const headers = buildHeaders(config);
-    const payload = {
-        questionText,
-        textSource: config.textSource,
-        action: config.action,
-        extra: JSON.stringify({ userId: config.uid }),
-    };
+function doApiRequest(url, headers, payload, timeout) {
+    const isHttp = url.startsWith("http://");
+    const module = isHttp ? http : https;
+    const options = buildRequestOptions(url, headers, timeout);
     return new Promise((resolve, reject) => {
-        const options = buildRequestOptions(config.api.url, headers, config.api.timeout);
-        const req = https.request(options, (res) => {
+        const req = module.request(options, (res) => {
             if (res.statusCode && res.statusCode >= HTTP_STATUS_BAD_REQUEST) {
                 reject(new Error(`[SENTINEL HOOK] HTTP error: ${res.statusCode}`));
                 return;
@@ -66,7 +61,7 @@ export async function callCsplApi(questionText, cfg) {
             res.on("end", () => {
                 try {
                     const result = parseResponse(data);
-                    logger.log(`[SENTINEL HOOK] ✅ 请求成功`);
+                    logger.log(`[SENTINEL HOOK] ✅ 请求成功, securityResult=${result?.data?.securityResult ?? "N/A"}`);
                     resolve(result);
                 }
                 catch (e) {
@@ -80,7 +75,7 @@ export async function callCsplApi(questionText, cfg) {
             reject(error);
         });
         req.on("timeout", () => {
-            logger.error(`[SENTINEL HOOK] ⏰ 请求超时 (${config.api.timeout}ms)`);
+            logger.error(`[SENTINEL HOOK] ⏰ 请求超时 (${timeout}ms)`);
             req.destroy();
             reject(new Error("[SENTINEL HOOK] Request timeout"));
         });
@@ -88,3 +83,28 @@ export async function callCsplApi(questionText, cfg) {
         req.end();
     });
 }
+export async function callCsplApi(questionText, cfg) {
+    const config = getCsplConfig(cfg);
+    const headers = buildHeaders(config);
+    const payload = {
+        questionText,
+        textSource: config.textSource,
+        action: config.action,
+        extra: JSON.stringify({ userId: config.uid }),
+    };
+    return doApiRequest(config.api.url, headers, payload, config.api.timeout);
+}
+/**
+ * Call CSPL API with a pre-resolved CsplConfig.
+ * Used by after_tool_call hook which has session context but not ClawdbotConfig.
+ */
+export async function callCsplApiWithConfig(questionText, config) {
+    const headers = buildHeaders(config);
+    const payload = {
+        questionText,
+        textSource: config.textSource,
+        action: config.action,
+        extra: JSON.stringify({ userId: config.uid }),
+    };
+    return doApiRequest(config.api.url, headers, payload, config.api.timeout);
+}

package/dist/src/cspl/config.d.ts

@@ -1,4 +1,5 @@
 import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { XYChannelConfig } from "../types.js";
 export interface ApiConfig {
     url: string;
     timeout: number;
@@ -15,5 +16,14 @@ export interface CsplConfig {
 /**
  * 构建 CSPL 配置。uid 和 apiKey 复用 XYChannelConfig，避免重复配置。
  * serviceUrl 从 .xiaoyienv 文件读取，skillId 写死在常量中。
+ *
+ * Accepts either ClawdbotConfig (legacy after_tool_call path) or
+ * XYChannelConfig (AgentToolResultMiddleware path).  Config is cached
+ * after the first successful call so subsequent calls can omit the arg.
  */
-export declare function getCsplConfig(cfg: ClawdbotConfig): CsplConfig;
+export declare function getCsplConfig(cfg?: ClawdbotConfig): CsplConfig;
+/**
+ * Initialize CSPL config from an already-resolved XYChannelConfig.
+ * Used by AgentToolResultMiddleware which has session context but not ClawdbotConfig.
+ */
+export declare function initCsplConfigFromXYConfig(xyConfig: XYChannelConfig): CsplConfig;

package/dist/src/cspl/config.js

@@ -27,10 +27,17 @@ function readServiceUrl() {
 /**
  * 构建 CSPL 配置。uid 和 apiKey 复用 XYChannelConfig，避免重复配置。
  * serviceUrl 从 .xiaoyienv 文件读取，skillId 写死在常量中。
+ *
+ * Accepts either ClawdbotConfig (legacy after_tool_call path) or
+ * XYChannelConfig (AgentToolResultMiddleware path).  Config is cached
+ * after the first successful call so subsequent calls can omit the arg.
  */
 export function getCsplConfig(cfg) {
     if (cachedConfig)
         return cachedConfig;
+    if (!cfg) {
+        throw new Error("[SENTINEL HOOK] CSPL config not initialized: pass ClawdbotConfig on first call");
+    }
     const xyConfig = resolveXYConfig(cfg);
     const serviceUrl = readServiceUrl();
     cachedConfig = {
@@ -48,3 +55,26 @@ export function getCsplConfig(cfg) {
     logger.log("[SENTINEL HOOK] Config loaded (uid/apiKey from XYChannelConfig)");
     return cachedConfig;
 }
+/**
+ * Initialize CSPL config from an already-resolved XYChannelConfig.
+ * Used by AgentToolResultMiddleware which has session context but not ClawdbotConfig.
+ */
+export function initCsplConfigFromXYConfig(xyConfig) {
+    if (cachedConfig)
+        return cachedConfig;
+    const serviceUrl = readServiceUrl();
+    cachedConfig = {
+        api: {
+            url: `${serviceUrl}${API_URL_SUFFIX}`,
+            timeout: CSPL_STATIC_CONFIG.api.timeout,
+        },
+        uid: xyConfig.uid,
+        apiKey: xyConfig.apiKey,
+        skillId: CSPL_STATIC_CONFIG.skillId,
+        requestFrom: CSPL_STATIC_CONFIG.requestFrom,
+        textSource: CSPL_STATIC_CONFIG.textSource,
+        action: CSPL_STATIC_CONFIG.action,
+    };
+    logger.log("[SENTINEL HOOK] Config loaded via XYChannelConfig");
+    return cachedConfig;
+}

package/dist/src/cspl/middleware.d.ts

@@ -0,0 +1,8 @@
+import type { AgentToolResultMiddleware } from "openclaw/plugin-sdk/agent-harness-runtime";
+/**
+ * Create the CSPL AgentToolResultMiddleware.
+ *
+ * Gets XYChannelConfig from session context (via sessionKey) to initialize
+ * the CSPL API config on first call, then caches it for subsequent calls.
+ */
+export declare function createCsplMiddleware(): AgentToolResultMiddleware;

package/dist/src/cspl/middleware.js

@@ -0,0 +1,90 @@
+// CSPL AgentToolResultMiddleware
+// Replaces the after_tool_call hook with a middleware that intercepts tool results
+// BEFORE they reach the LLM, enabling true security interruption.
+import { callCsplApiWithConfig } from "./call-api.js";
+import { getCsplConfig, initCsplConfigFromXYConfig } from "./config.js";
+import { ALLOWED_TOOLS, MAX_TEXT_LENGTH, MAX_TOTAL_LENGTH, MIN_TEXT_LENGTH, STEER_ABORT_MESSAGE, } from "./constants.js";
+import { parseSecurityResult, processText, validateAndTruncateText, } from "./utils.js";
+import { getSessionContext } from "../tools/session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Extract text content from an OpenClawAgentToolResult.
+ */
+function extractMiddlewareResultText(event) {
+    const result = event.result;
+    if (!result?.content || !Array.isArray(result.content)) {
+        return "";
+    }
+    const texts = [];
+    // Special handling for web_fetch: text is in details.text
+    if (event.toolName === "web_fetch" && result.details?.text) {
+        texts.push(String(result.details.text));
+    }
+    else {
+        for (const item of result.content) {
+            if (item?.type === "text" && typeof item.text === "string") {
+                texts.push(item.text);
+            }
+        }
+    }
+    return texts.length > 0 ? texts.join("; ") : "";
+}
+/**
+ * Create the CSPL AgentToolResultMiddleware.
+ *
+ * Gets XYChannelConfig from session context (via sessionKey) to initialize
+ * the CSPL API config on first call, then caches it for subsequent calls.
+ */
+export function createCsplMiddleware() {
+    return async (event, ctx) => {
+        if (!ALLOWED_TOOLS.includes(event.toolName)) {
+            return;
+        }
+        try {
+            const resultText = extractMiddlewareResultText(event);
+            const resultLength = resultText.length;
+            if (resultLength <= MIN_TEXT_LENGTH || resultLength > MAX_TOTAL_LENGTH) {
+                return;
+            }
+            logger.log(`[CSPL MIDDLEWARE] Scanning tool result: toolName=${event.toolName}, textLength=${resultLength}`);
+            // Build CSPL request payload
+            const questionText = {
+                subSceneID: "TOOL_OUTPUT",
+                tool: event.toolName,
+                output: [{ content: "" }],
+            };
+            const originText = processText(resultText);
+            questionText.output[0].content = originText;
+            let finalJson = JSON.stringify(questionText);
+            if (finalJson.length > MAX_TEXT_LENGTH) {
+                const diff = finalJson.length - MAX_TEXT_LENGTH;
+                const { text: trimmed } = validateAndTruncateText(originText, MAX_TEXT_LENGTH - diff);
+                questionText.output[0].content = trimmed;
+                finalJson = JSON.stringify(questionText);
+            }
+            // Get CSPL config (cached after first call)
+            // Try session context first (XYChannelConfig), then fall back to cached config
+            const sessionCtx = getSessionContext(ctx.sessionKey ?? "");
+            const csplConfig = sessionCtx
+                ? initCsplConfigFromXYConfig(sessionCtx.config)
+                : getCsplConfig();
+            const csplStartTime = Date.now();
+            const response = await callCsplApiWithConfig(finalJson, csplConfig);
+            const csplElapsed = Date.now() - csplStartTime;
+            const result = parseSecurityResult(response);
+            logger.log(`[CSPL MIDDLEWARE] Security result: status=${result.status}, toolName=${event.toolName}, elapsed=${csplElapsed}ms`);
+            if (result.status === "REJECT") {
+                logger.log(`[CSPL MIDDLEWARE] REJECT - replacing tool result with security message`);
+                return {
+                    result: {
+                        content: [{ type: "text", text: STEER_ABORT_MESSAGE }],
+                        details: {},
+                    },
+                };
+            }
+        }
+        catch (err) {
+            logger.error(`[CSPL MIDDLEWARE] Error: ${err}`);
+        }
+    };
+}

package/dist/src/cspl/steer-context.d.ts

@@ -0,0 +1,21 @@
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+/** Called from handleXYMessage on every inbound A2A message to keep cfg/runtime fresh. */
+export declare function setCsplSteerContext(cfg: ClawdbotConfig, runtime: RuntimeEnv): void;
+/** Parameters for steer message injection. */
+export interface SteerInjectionParams {
+    sessionId: string;
+    taskId: string;
+    message: string;
+    /** Human-readable source label for logging (e.g. "cspl", "self-evolution"). */
+    source: string;
+}
+/**
+ * Inject a steer message into an active session by constructing a synthetic
+ * A2A tasks/send message and dispatching it through handleXYMessage.
+ *
+ * Uses skipRegistration so the steer message doesn't register a new taskId,
+ * increment session refCount, or send extra status updates.
+ *
+ * Returns true if the injection was dispatched successfully.
+ */
+export declare function tryInjectSteer(params: SteerInjectionParams): Promise<boolean>;

package/dist/src/cspl/steer-context.js

@@ -0,0 +1,78 @@
+import { handleXYMessage } from "../bot.js";
+import { logger } from "../utils/logger.js";
+import { randomUUID } from "node:crypto";
+// Use globalThis to ensure a single cache across all module copies.
+// The xy_channel plugin may be loaded by openclaw from different module
+// resolution paths, causing steer-context.ts to be instantiated multiple
+// times. globalThis guarantees all copies share the same cfg/runtime.
+const _g = globalThis;
+if (!_g.__xySteerCachedCfg) {
+    _g.__xySteerCachedCfg = null;
+}
+if (!_g.__xySteerCachedRuntime) {
+    _g.__xySteerCachedRuntime = null;
+}
+function getCachedCfg() {
+    return _g.__xySteerCachedCfg;
+}
+function setCachedCfg(cfg) {
+    _g.__xySteerCachedCfg = cfg;
+}
+function getCachedRuntime() {
+    return _g.__xySteerCachedRuntime;
+}
+function setCachedRuntime(runtime) {
+    _g.__xySteerCachedRuntime = runtime;
+}
+/** Called from handleXYMessage on every inbound A2A message to keep cfg/runtime fresh. */
+export function setCsplSteerContext(cfg, runtime) {
+    setCachedCfg(cfg);
+    setCachedRuntime(runtime);
+}
+/**
+ * Inject a steer message into an active session by constructing a synthetic
+ * A2A tasks/send message and dispatching it through handleXYMessage.
+ *
+ * Uses skipRegistration so the steer message doesn't register a new taskId,
+ * increment session refCount, or send extra status updates.
+ *
+ * Returns true if the injection was dispatched successfully.
+ */
+export async function tryInjectSteer(params) {
+    const { sessionId, taskId, message, source } = params;
+    const cfg = getCachedCfg();
+    const runtime = getCachedRuntime();
+    if (!cfg || !runtime) {
+        logger.error(`[STEER:${source}] No cached cfg/runtime, cannot inject steer`);
+        return false;
+    }
+    const syntheticMessage = {
+        jsonrpc: "2.0",
+        method: "tasks/send",
+        id: `steer-${source}-${randomUUID()}`,
+        params: {
+            sessionId,
+            id: taskId,
+            agentLoginSessionId: "",
+            message: {
+                role: "user",
+                parts: [{ kind: "text", text: message }],
+            },
+        },
+    };
+    logger.log(`[STEER:${source}] Injecting steer for sessionId=${sessionId}, taskId=${taskId}`);
+    try {
+        await handleXYMessage({
+            cfg,
+            runtime,
+            message: syntheticMessage,
+            accountId: "default",
+            skipRegistration: true,
+        });
+        return true;
+    }
+    catch (err) {
+        logger.error(`[STEER:${source}] Failed to inject steer: ${err}`);
+        return false;
+    }
+}

package/dist/src/file-download.js

@@ -20,10 +20,10 @@ export async function downloadFile(url, destPath) {
     }
     catch (error) {
         if (error.name === 'AbortError') {
-            logger.log(`Download timeout (30s) for ${url}`);
+            logger.error(`Download timeout (30s) for ${url}`);
             throw new Error(`Download timeout after 30 seconds`);
         }
-        logger.log(`Failed to download file from ${url}:`);
+        logger.error(`Failed to download file from ${url}:`);
         throw error;
     }
     finally {
@@ -52,7 +52,7 @@ export async function downloadFilesFromParts(fileParts, tempDir = "/tmp/xy_chann
             });
         }
         catch (error) {
-            logger.log(`Failed to download file ${name}:`);
+            logger.error(`Failed to download file ${name}:`);
             // Continue with other files
         }
     }

package/dist/src/formatter.d.ts

@@ -17,7 +17,6 @@ export interface SendA2AResponseParams {
     }>;
     errorCode?: number | string;
     errorMessage?: string;
-    runtime?: any;
 }
 /**
  * Send an A2A artifact update response.
@@ -50,7 +49,6 @@ export interface SendStatusUpdateParams {
     messageId: string;
     text: string;
     state: "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "unknown";
-    runtime?: any;
 }
 /**
  * Send an A2A task status update.

package/dist/src/formatter.js

@@ -7,8 +7,7 @@ import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
  * Send an A2A artifact update response.
  */
 export async function sendA2AResponse(params) {
-    const { config, sessionId, taskId, messageId, text, append, final, files, errorCode, errorMessage, runtime } = params;
-    const log = runtime?.log ?? console.log;
+    const { config, sessionId, taskId, messageId, text, append, final, files, errorCode, errorMessage } = params;
     // Build artifact update event
     const artifact = {
         taskId,
@@ -47,7 +46,7 @@ export async function sendA2AResponse(params) {
             code: errorCode,
             message: errorMessage ?? "任务执行异常，请重试",
         };
-        log(`[A2A_RESPONSE] ⚠️ Including error code: ${errorCode}`);
+        logger.log(`[A2A_RESPONSE] ⚠️ Including error code: ${errorCode}`);
     }
     // Send via WebSocket
     const wsManager = getXYWebSocketManager(config);
@@ -59,13 +58,13 @@ export async function sendA2AResponse(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
-    log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response: taskId: ${taskId}`);
-    log(`[A2A_RESPONSE]   - append: ${append}`);
-    log(`[A2A_RESPONSE]   - final: ${final}`);
-    log(`[A2A_RESPONSE]   - text: ${text.length <= 10 ? text : text.slice(0, 5) + '***' + text.slice(-5)}`);
-    log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
+    logger.log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response: taskId: ${taskId}`);
+    logger.log(`[A2A_RESPONSE]   - append: ${append}`);
+    logger.log(`[A2A_RESPONSE]   - final: ${final}`);
+    logger.log(`[A2A_RESPONSE]   - text: ${text.length <= 10 ? text : text.slice(0, 5) + '***' + text.slice(-5)}`);
+    logger.log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`[A2A_RESPONSE] ✅ Message sent successfully`);
+    logger.log(`[A2A_RESPONSE] ✅ Message sent successfully`);
 }
 /**
  * Send an A2A artifact-update with reasoningText part.
@@ -110,8 +109,7 @@ export async function sendReasoningTextUpdate(params) {
  * Follows A2A protocol standard format with nested status object.
  */
 export async function sendStatusUpdate(params) {
-    const { config, sessionId, taskId, messageId, text, state, runtime } = params;
-    const log = runtime?.log ?? console.log;
+    const { config, sessionId, taskId, messageId, text, state } = params;
     // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
     // fall back to closure-captured values
     const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
@@ -150,9 +148,9 @@ export async function sendStatusUpdate(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     // 📋 Log complete response body
-    log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
-    log(`[A2A_STATUS]   - taskId: ${currentTaskId}`);
-    log(`[A2A_STATUS]   - text: "${text}"`);
+    logger.log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
+    logger.log(`[A2A_STATUS]   - taskId: ${currentTaskId}`);
+    logger.log(`[A2A_STATUS]   - text: "${text}"`);
     await wsManager.sendMessage(sessionId, outboundMessage);
 }
 /**

package/dist/src/heartbeat.js

@@ -1,5 +1,6 @@
 // Heartbeat management for WebSocket connections
 import WebSocket from "ws";
+import { logger } from "./utils/logger.js";
 /**
  * Manages heartbeat for a WebSocket connection.
  * Supports both application-level (30s) and protocol-level (20s) heartbeats.
@@ -23,8 +24,8 @@ export class HeartbeatManager {
         this.onTimeout = onTimeout;
         this.serverName = serverName;
         this.onHeartbeatSuccess = onHeartbeatSuccess;
-        this.log = logFn ?? console.log;
-        this.error = errorFn ?? console.error;
+        this.log = logFn ?? ((msg, ...args) => logger.log(msg, ...args));
+        this.error = errorFn ?? ((msg, ...args) => logger.error(msg, ...args));
     }
     /**
      * Start heartbeat monitoring.