adp-openclaw 0.0.71 → 0.0.73

package/index.ts

@@ -1,84 +1,93 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+
+// ============================================================================
+// PERFORMANCE NOTE: This file is the plugin entry point loaded by openclaw at
+// startup.  Everything imported at the top level is evaluated **synchronously**
+// during plugin discovery, blocking the entire startup sequence.
+//
+// Heavy modules (session-history, adp-upload-tool, tool-result-message-blocks)
+// are therefore NOT imported at the top level.  Instead they are:
+//   1. Lazily re-exported via getter helpers (for external consumers).
+//   2. Dynamically imported inside register() / tool-execute callbacks.
+//
+// This keeps register() fast (< 50 ms) and avoids blocking the scan phase.
+// ============================================================================
+
+// ---- Lightweight imports (tiny modules, no heavy deps) ----
 import { adpOpenclawPlugin, type AdpOpenclawChannelConfig } from "./src/channel.js";
 import { setAdpOpenclawRuntime } from "./src/runtime.js";
-import {
-  ADP_UPLOAD_TOOL_NAME,
-  ADP_UPLOAD_TOOL_SCHEMA,
-  parseAdpUploadToolParams,
-  uploadFilesToAdpEndpoint,
-  uploadResultEmitter,
-  UPLOAD_RESULT_EVENT,
-  type AdpUploadToolResult,
-  type UploadedFileInfo,
-} from "./src/adp-upload-tool.js";
+// Type-only imports are erased at runtime — zero overhead
+import type { AdpUploadToolResult, UploadedFileInfo } from "./src/adp-upload-tool.js";
+
+// ---- Tool name / schema constants (inlined to avoid loading full upload module) ----
+const ADP_UPLOAD_TOOL_NAME = "adp_upload_file";
+const ADP_UPLOAD_TOOL_SCHEMA = {
+  type: "object" as const,
+  properties: {
+    paths: {
+      type: "array" as const,
+      items: { type: "string" as const },
+      description: "Array of 1-10 local file paths to upload",
+      minItems: 1,
+      maxItems: 10,
+    },
+    fileType: {
+      type: "string" as const,
+      description: "Optional MIME type hint for uploaded files",
+    },
+  },
+  required: ["paths"] as const,
+};
+
+// Track whether register() has been called at least once (for log dedup)
+let _registerCallCount = 0;
+
+// ============================================================================
+// Lazy re-exports for external consumers
+// These are loaded on first access, not at plugin startup.
+// ============================================================================
 
-// Export session history functions for external use
-export {
-  getOpenClawChatHistory,
-  listOpenClawSessions,
-  getSessionPreviews,
-  getChatHistoryByConversationId,
-  resolveSessionKey,
-  configureSessionFileReader,
-  getSessionFileConfig,
-  // CLI-based functions
-  getOpenClawChatHistoryViaCli,
-  listOpenClawSessionsViaCli,
-  // Auto-selecting functions
-  getChatHistory,
-  listSessions,
-  type OpenClawSession,
-  type OpenClawMessage,
-  type ChatHistoryResponse,
-  type SessionsListResponse,
-  type SessionFileConfig,
+// Session history (heavy: node:child_process, node:fs, 1100+ lines)
+export async function getSessionHistoryModule() {
+  return import("./src/session-history.js");
+}
+
+// Re-export types (type-only imports are free at runtime)
+export type {
+  OpenClawSession,
+  OpenClawMessage,
+  ChatHistoryResponse,
+  SessionsListResponse,
+  SessionFileConfig,
 } from "./src/session-history.js";
 
-// Export ADP upload tool functions and types
-export {
-  // Tool name and schema
-  ADP_UPLOAD_TOOL_NAME,
-  ADP_UPLOAD_TOOL_SCHEMA,
-  ADP_UPLOAD_TOOL_MAX_PATHS,
-  ADP_UPLOAD_TOOL_MIN_PATHS,
-  ADP_UPLOAD_TOOL_MAX_CONCURRENCY,
-  ADP_UPLOAD_VALIDATION_MESSAGE,
-  // Main functions
-  adpUploadFile,
-  adpUploadFiles,
-  adpUploadFileWithConfig,
-  adpUploadFilesWithConfig,
-  getStorageCredential,
-  uploadFileToCos,
-  resolveClientToken,
-  // Class
-  AdpUploader,
-  // Tool execution functions
-  parseAdpUploadToolParams,
-  uploadFilesToAdpEndpoint,
-  executeAdpUploadTool,
-  // Types
-  type UploadResult,
-  type AdpUploadToolParams,
-  type AdpUploadToolResult,
-  type UploadedFileInfo,
-  type AdpUploadOptions,
-  type DescribeRemoteBotStorageCredentialReq,
-  type DescribeRemoteBotStorageCredentialRsp,
-  type Credentials,
+// ADP upload tool
+export async function getAdpUploadToolModule() {
+  return import("./src/adp-upload-tool.js");
+}
+
+export type {
+  UploadResult,
+  AdpUploadToolParams,
+  AdpUploadToolResult,
+  UploadedFileInfo,
+  AdpUploadOptions,
+  DescribeRemoteBotStorageCredentialReq,
+  DescribeRemoteBotStorageCredentialRsp,
+  Credentials,
 } from "./src/adp-upload-tool.js";
 
-// Export tool result message blocks functions
-export {
-  dispatchToolResultToMessageBlocks,
-  buildToolResultSessionContentBlocks,
-  formatUploadResultForUser,
-  formatUploadResultAsMarkdown,
-  type ResourceLinkBlock,
-  type TextBlock,
-  type ContentBlock,
-  type MessageBlock,
+// Tool result message blocks
+export async function getToolResultMessageBlocksModule() {
+  return import("./src/tool-result-message-blocks.js");
+}
+
+export type {
+  ResourceLinkBlock,
+  TextBlock,
+  ContentBlock,
+  MessageBlock,
 } from "./src/tool-result-message-blocks.js";
 
 // Helper to format tool result as JSON string
@@ -91,23 +100,19 @@ const plugin = {
   description: "ADP channel plugin backed by a Go WebSocket server",
   configSchema: emptyPluginConfigSchema(),
   register(api: OpenClawPluginApi) {
-    // Log registration for debugging
-    console.log("[adp-openclaw] register() called - starting plugin registration");
-    api.logger.info?.("[adp-openclaw] Plugin register() called");
+    _registerCallCount++;
     
-    setAdpOpenclawRuntime(api.runtime);
+    // Only log on first registration to avoid flooding logs
+    if (_registerCallCount === 1) {
+      api.logger.info?.("[adp-openclaw] Plugin register() called");
+    }
     
-    // Register the ADP file upload tool as a factory function
-    // Using a factory so the tool is only available when the message originates from the ADP channel.
-    // This prevents other channels (e.g. DingTalk) with multimodal models from picking up this tool.
-    console.log(`[adp-openclaw] Registering tool factory: ${ADP_UPLOAD_TOOL_NAME}`);
-    api.logger.info?.(`[adp-openclaw] Registering tool factory: ${ADP_UPLOAD_TOOL_NAME}`);
+    setAdpOpenclawRuntime(api.runtime);
     
     api.registerTool((ctx: { messageChannel?: string; [key: string]: unknown }) => {
       // Only expose this tool when the message comes from the adp-openclaw channel
       const channel = ctx.messageChannel ?? "";
       if (channel && channel !== "adp-openclaw") {
-        api.logger.debug?.(`[adp-openclaw] Skipping ${ADP_UPLOAD_TOOL_NAME} for channel: ${channel}`);
         return null;
       }
 
@@ -122,6 +127,14 @@ const plugin = {
         "Parameters must be local filesystem paths only.",
       parameters: ADP_UPLOAD_TOOL_SCHEMA,
       async execute(toolCallId: string, params: unknown) {
+        // Lazy-load the heavy upload module only when the tool is actually invoked
+        const {
+          parseAdpUploadToolParams,
+          uploadFilesToAdpEndpoint,
+          uploadResultEmitter,
+          UPLOAD_RESULT_EVENT,
+        } = await import("./src/adp-upload-tool.js");
+
         // Get bot token from channel config
         const getClientToken = (): string | undefined => {
           try {
@@ -157,7 +170,6 @@ const plugin = {
             ok: false,
             error: "missing bot token for file upload - please configure clientToken in adp-openclaw channel settings",
           };
-          api.logger.debug?.(`[${ADP_UPLOAD_TOOL_NAME}] token missing toolCallId=${toolCallId} paths=${JSON.stringify(parsed.value.paths)}`);
           return {
             output: errorResult,
             result: errorResult,
@@ -178,7 +190,7 @@ const plugin = {
             ok: false,
             error: formatToolResultJson(uploadResult.error),
           };
-          api.logger.debug?.(`[${ADP_UPLOAD_TOOL_NAME}] upload failed toolCallId=${toolCallId} paths=${JSON.stringify(parsed.value.paths)} error=${errorResult.error}`);
+          api.logger.debug?.(`[${ADP_UPLOAD_TOOL_NAME}] upload failed toolCallId=${toolCallId} error=${errorResult.error}`);
           return {
             output: errorResult,
             result: errorResult,
@@ -194,14 +206,8 @@ const plugin = {
           files: uploadResult.files,
         };
 
-        api.logger.debug?.(`[${ADP_UPLOAD_TOOL_NAME}] upload success toolCallId=${toolCallId} count=${successResult.files?.length ?? 0} paths=${JSON.stringify(parsed.value.paths)}`);
+        api.logger.debug?.(`[${ADP_UPLOAD_TOOL_NAME}] upload success toolCallId=${toolCallId} count=${successResult.files?.length ?? 0}`);
 
-        // Debug: print full downloadUrl for each file
-        for (const file of (successResult.files || [])) {
-          api.logger.info?.(`[${ADP_UPLOAD_TOOL_NAME}] file.downloadUrl: ${file.downloadUrl}`);
-          api.logger.info?.(`[${ADP_UPLOAD_TOOL_NAME}] file.uri: ${file.uri}`);
-        }
-        
         // 发射上传结果事件，让 monitor.ts 能够直接获取完整的下载链接
         uploadResultEmitter.emit(UPLOAD_RESULT_EVENT, {
           toolCallId,
@@ -215,25 +221,21 @@ const plugin = {
         for (const file of (successResult.files || [])) {
           content.push({
             type: "resource_link",
-            uri: file.downloadUrl || file.uri,  // 使用带签名的下载链接
+            uri: file.downloadUrl || file.uri,
             name: file.name,
             mimeType: file.mimeType,
-            downloadUrl: file.downloadUrl,  // 也包含 downloadUrl 字段
+            downloadUrl: file.downloadUrl,
           });
         }
 
         // Add a text summary with download URLs for AI to include in response
-        // 注意：URL 包含签名参数，必须完整保留，不能截断或修改
         const urlSummary = (successResult.files || [])
           .map((f: UploadedFileInfo) => {
             const url = f.downloadUrl || f.uri;
-            // 把完整 URL 作为代码块，防止 AI 截断或修改
             return `- **${f.name}**: \`${url}\``;
           })
           .join("\n");
         
-        api.logger.info?.(`[${ADP_UPLOAD_TOOL_NAME}] urlSummary: ${urlSummary}`);
-        
         content.push({
           type: "text",
           text: `Files uploaded successfully:\n${urlSummary}\n\n⚠️ IMPORTANT: The URLs above contain authentication signatures. You MUST copy the ENTIRE URL exactly as shown (including all query parameters after the "?"). Do NOT truncate or modify the URLs in any way. The links are valid for 24 hours.`,
@@ -249,16 +251,13 @@ const plugin = {
       },
     }; // end of tool object
     }); // end of factory function passed to registerTool
-    
-    // Log tool registration success
-    console.log(`[adp-openclaw] Tool ${ADP_UPLOAD_TOOL_NAME} registered successfully`);
-    api.logger.info?.(`[adp-openclaw] Tool ${ADP_UPLOAD_TOOL_NAME} registered successfully`);
 
-    // Register the channel plugin
+    // Register the channel plugin (channel.ts + onboarding.ts are lightweight config-only modules)
     api.registerChannel({ plugin: adpOpenclawPlugin });
     
-    console.log("[adp-openclaw] Plugin registration complete");
-    api.logger.info?.("[adp-openclaw] Plugin registration complete");
+    if (_registerCallCount === 1) {
+      api.logger.info?.("[adp-openclaw] Plugin registration complete");
+    }
   },
 };
 

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "adp-openclaw",
-  "version": "0.0.71",
+  "version": "0.0.73",
   "description": "ADP-OpenClaw demo channel plugin (Go WebSocket backend)",
   "type": "module",
+  "main": "index.ts",
   "dependencies": {
     "ws": "^8.16.0",
     "zod": "^3.22.4"
   },
+  "peerDependencies": {
+    "openclaw": "*"
+  },
   "devDependencies": {
     "@types/node": "^20.11.0",
     "@types/ws": "^8.5.10",
+    "openclaw": ">=2026.3.0",
     "typescript": "^5.9.3"
   },
   "openclaw": {

package/src/monitor.ts

@@ -25,11 +25,19 @@ import {
 } from "./tool-result-message-blocks.js";
 import crypto from "crypto";
 import fs from "fs";
-// @ts-ignore - import JSON file
-import packageJson from "../package.json" with { type: "json" };
-
-// Plugin version from package.json
-const PLUGIN_VERSION = packageJson.version;
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+// Read plugin version from package.json (lazy, at module load time — not at register() time)
+let PLUGIN_VERSION = "unknown";
+try {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const pkg = JSON.parse(fs.readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+  PLUGIN_VERSION = pkg.version || "unknown";
+} catch {
+  // Fallback — version string is cosmetic only
+}
 
 // WebSocket reconnect delay (fixed at 1 second)
 const RECONNECT_DELAY_MS = 1000;
@@ -153,14 +161,14 @@ async function markSessionAborted(params: {
     }
 
     if (!matchedKey) {
-      log?.info?.(`[adp-openclaw] Session key not found in store for abort marking: ${sessionKey}`);
+      log?.debug?.(`[adp-openclaw] Session key not found in store for abort marking: ${sessionKey}`);
       return;
     }
 
     store[matchedKey].abortedLastRun = true;
     store[matchedKey].updatedAt = Date.now();
     fs.writeFileSync(storePath, JSON.stringify(store, null, 2), "utf-8");
-    log?.info?.(`[adp-openclaw] Marked session ${matchedKey} as abortedLastRun=true`);
+    log?.debug?.(`[adp-openclaw] Marked session ${matchedKey} as abortedLastRun=true`);
   } catch (err) {
     log?.error?.(`[adp-openclaw] Failed to mark session aborted: ${err}`);
   }
@@ -238,7 +246,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
       const socket = (ws as any)._socket;
       if (socket && typeof socket.setKeepAlive === 'function') {
         socket.setKeepAlive(true, 30000);  // 30秒
-        log?.info(`[adp-openclaw] TCP keepalive enabled`);
+        log?.debug?.(`[adp-openclaw] TCP keepalive enabled`);
       }
       
       // Save active WebSocket for outbound messaging
@@ -310,10 +318,10 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
             setStatus?.({ lastEventAt: inboundAt, lastInboundAt: inboundAt });
 
             // Debug: log raw payload to verify recordId is received
-            log?.info(`[adp-openclaw] Raw payload: ${JSON.stringify(msg.payload)}`);
+            log?.debug?.(`[adp-openclaw] Raw payload: ${JSON.stringify(msg.payload)}`);
             
             const inMsg = msg.payload as InboundMessage;
-            log?.info(`[adp-openclaw] Received: ${inMsg.from}: ${inMsg.text} (conv=${inMsg.conversationId}, rec=${inMsg.recordId || 'none'}, user=${JSON.stringify(inMsg.user || {})})`);
+            log?.info(`[adp-openclaw] Received: ${inMsg.from}: ${inMsg.text.slice(0, 80)} (conv=${inMsg.conversationId})`);
 
             // Process the message with full user identity
             const convIdForCleanup = inMsg.conversationId || `fallback-${Date.now()}`;
@@ -458,12 +466,12 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
               
               // 监听上传结果事件
               const uploadResultHandler = (event: { toolCallId: string; result: AdpUploadToolResult }) => {
-                log?.info(`[adp-openclaw] Received upload result event for toolCallId=${event.toolCallId}`);
+                log?.debug?.(`[adp-openclaw] Received upload result event for toolCallId=${event.toolCallId}`);
                 if (event.result.ok && event.result.files && event.result.files.length > 0) {
                   pendingUploadResults.push(event.result);
                   // 打印完整的下载链接
                   for (const file of event.result.files) {
-                    log?.info(`[adp-openclaw] Upload result - file.downloadUrl: ${file.downloadUrl}`);
+                    log?.debug?.(`[adp-openclaw] Upload result - file.downloadUrl: ${file.downloadUrl}`);
                   }
                 }
               };
@@ -507,7 +515,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                       const before = finalText;
                       finalText = finalText.replace(pattern, correctUrl);
                       if (finalText !== before) {
-                        log?.info(`[adp-openclaw] Fixed LLM-corrupted URL for: ${basePath.substring(basePath.lastIndexOf("/") + 1)}`);
+                        log?.debug?.(`[adp-openclaw] Fixed LLM-corrupted URL for: ${basePath.substring(basePath.lastIndexOf("/") + 1)}`);
                       }
                     }
                   }
@@ -518,18 +526,18 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                       if (file.downloadUrl) {
                         // 使用完整的下载链接，包括签名参数
                         uploadLinks.push(`📎 [${file.name}](${file.downloadUrl})`);
-                        log?.info(`[adp-openclaw] Appending download link: ${file.downloadUrl.substring(0, 100)}...`);
+                        log?.debug?.(`[adp-openclaw] Appending download link: ${file.downloadUrl.substring(0, 100)}...`);
                       }
                     }
                   }
                   if (uploadLinks.length > 0) {
                     finalText += `\n\n**文件下载链接（24小时有效）：**\n${uploadLinks.join("\n")}`;
-                    log?.info(`[adp-openclaw] Added ${uploadLinks.length} download links to final response`);
+                    log?.debug?.(`[adp-openclaw] Added ${uploadLinks.length} download links to final response`);
                   }
                 }
                 
                 if (chunkIndex > 0) {
-                  log?.info(`[adp-openclaw] Sending outbound_end to ${displayName}: ${finalText.slice(0, 50)}... (chunks=${chunkIndex})`);
+                  log?.debug?.(`[adp-openclaw] Sending outbound_end to ${displayName}: ${finalText.slice(0, 50)}... (chunks=${chunkIndex})`);
                   const endMsg: WSMessage = {
                     type: MsgType.OutboundEnd,
                     requestId: generateRequestId(),
@@ -547,7 +555,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                   ws.send(JSON.stringify(endMsg));
                 } else {
                   // No streaming chunks were sent, send as regular outbound message
-                  log?.info(`[adp-openclaw] Sending outbound to ${displayName}: ${finalText.slice(0, 50)}...`);
+                  log?.debug?.(`[adp-openclaw] Sending outbound to ${displayName}: ${finalText.slice(0, 50)}...`);
                   const outMsg: WSMessage = {
                     type: MsgType.Outbound,
                     requestId: generateRequestId(),
@@ -564,7 +572,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 }
               };
 
-              log?.info(`[adp-openclaw] Starting dispatchReplyWithBufferedBlockDispatcher for ${displayName}`);
+              log?.debug?.(`[adp-openclaw] Starting dispatchReplyWithBufferedBlockDispatcher for ${displayName}`);
               await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                 ctx,
                 cfg: cfg ?? {},
@@ -625,8 +633,8 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                     const text = payload.text || "";
                     const kind = info?.kind;
                     
-                    // Debug log for all deliver calls - log the actual info object
-                    log?.info(`[adp-openclaw] deliver called: kind=${kind}, text.length=${text.length}, toolName=${payload.toolName || 'none'}, info=${JSON.stringify(info)}`);
+                    // Debug log for all deliver calls
+                    log?.debug?.(`[adp-openclaw] deliver called: kind=${kind}, text.length=${text.length}, toolName=${payload.toolName || 'none'}`);
                     
                     // Handle streaming block - IGNORE because handlePartial already sent deltas
                     // The "block" callback contains cumulative text (same as final), not incremental delta
@@ -641,7 +649,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                       const toolName = payload.toolName;
                       const toolResult = payload.toolResult;
                       
-                      log?.info(`[adp-openclaw] Tool result received: toolName=${toolName}, result=${JSON.stringify(toolResult)?.slice(0, 200)}`);
+                      log?.debug?.(`[adp-openclaw] Tool result received: toolName=${toolName}, result=${JSON.stringify(toolResult)?.slice(0, 200)}`);
                       
                       // If it's our upload tool and it succeeded, send file links to user
                       if (toolName === ADP_UPLOAD_TOOL_NAME && toolResult && typeof toolResult === "object") {
@@ -649,13 +657,13 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                         if (result.ok && result.files && result.files.length > 0) {
                           // Debug: print full downloadUrl before formatting
                           for (const file of result.files) {
-                            log?.info(`[adp-openclaw] File downloadUrl (full): ${file.downloadUrl}`);
+                            log?.debug?.(`[adp-openclaw] File downloadUrl (full): ${file.downloadUrl}`);
                           }
                           
                           // Format upload result as user-readable message
                           const uploadMessage = formatUploadResultAsMarkdown(result);
                           
-                          log?.info(`[adp-openclaw] Sending upload result to user: ${uploadMessage.slice(0, 100)}...`);
+                          log?.debug?.(`[adp-openclaw] Sending upload result to user: ${uploadMessage.slice(0, 100)}...`);
                           
                           // Send the file links as a message chunk
                           const chunkMsg: WSMessage = {
@@ -688,8 +696,8 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                     // Handle final reply or undefined kind - send outbound_end
                     // SDK may call deliver without kind when streaming ends
                     if (kind === "final" || kind === undefined) {
-                      log?.info(`[adp-openclaw] deliver triggering sendOutboundEnd (kind=${kind})`);
-                      log?.info(`[adp-openclaw] Final text content: ${text}`);
+                      log?.debug?.(`[adp-openclaw] deliver triggering sendOutboundEnd (kind=${kind})`);
+                      log?.debug?.(`[adp-openclaw] Final text content: ${text?.slice(0, 100)}`);
                       sendOutboundEnd(text || lastPartialText);
                     }
                   },
@@ -699,7 +707,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 },
               });
               
-              log?.info(`[adp-openclaw] dispatchReplyWithBufferedBlockDispatcher returned (finalSent=${finalSent}, chunkIndex=${chunkIndex})`);
+              log?.debug?.(`[adp-openclaw] dispatchReplyWithBufferedBlockDispatcher returned (finalSent=${finalSent}, chunkIndex=${chunkIndex})`);
               
               // Clean up active generation tracking
               activeGenerations.delete(convId);
@@ -707,7 +715,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
               // If generation was cancelled (aborted), send outbound_end with partial text
               if (generationController.signal.aborted && !finalSent) {
                 const cancelText = lastPartialText ? `${lastPartialText}\n\n[已停止生成]` : "[已停止生成]";
-                log?.info(`[adp-openclaw] Generation cancelled, sending outbound_end with partial text`);
+                log?.debug?.(`[adp-openclaw] Generation cancelled, sending outbound_end with partial text`);
                 sendOutboundEnd(cancelText);
 
                 // Mark the session as aborted so the SDK injects an "abort hint"
@@ -728,7 +736,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
               if (!finalSent && chunkIndex > 0) {
                 // Use the last accumulated partial text as the final text
                 const finalText = lastPartialText || "";
-                log?.info(`[adp-openclaw] dispatchReply completed without final, sending outbound_end (chunks=${chunkIndex})`);
+                log?.debug?.(`[adp-openclaw] dispatchReply completed without final, sending outbound_end (chunks=${chunkIndex})`);
                 sendOutboundEnd(finalText);
               }
             } catch (err) {
@@ -755,17 +763,17 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
             if (!authenticated) break;
             const cancelPayload = msg.payload as { conversationId?: string; streamId?: string };
             const cancelConvId = cancelPayload.conversationId || cancelPayload.streamId;
-            log?.info(`[adp-openclaw] Received cancel request for conv=${cancelConvId}`);
+            log?.debug?.(`[adp-openclaw] Received cancel request for conv=${cancelConvId}`);
             
             if (cancelConvId && activeGenerations.has(cancelConvId)) {
               activeGenerations.get(cancelConvId)!.abort();
-              log?.info(`[adp-openclaw] Generation cancelled for conv=${cancelConvId}`);
+              log?.debug?.(`[adp-openclaw] Generation cancelled for conv=${cancelConvId}`);
             } else {
               // If no specific convId, cancel all active generations
               if (!cancelConvId && activeGenerations.size > 0) {
                 for (const [id, controller] of activeGenerations) {
                   controller.abort();
-                  log?.info(`[adp-openclaw] Generation cancelled for conv=${id} (cancel-all)`);
+                  log?.debug?.(`[adp-openclaw] Generation cancelled for conv=${id} (cancel-all)`);
                 }
               } else {
                 log?.warn(`[adp-openclaw] No active generation found for conv=${cancelConvId}`);
@@ -784,7 +792,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
               limit?: number;
             };
 
-            log?.info(`[adp-openclaw] Received conv_history request: sessionKey=${historyPayload.sessionKey}, conversationId=${historyPayload.conversationId}`);
+            log?.debug?.(`[adp-openclaw] Received conv_history request: sessionKey=${historyPayload.sessionKey}, conversationId=${historyPayload.conversationId}`);
 
             try {
               const limit = historyPayload.limit ?? 200;
@@ -800,15 +808,15 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 // Old: agent:main:direct:{conversationId}
                 // New: agent:main:adp-openclaw:direct:{conversationId}
                 const extractedId = oldFormatMatch[1];
-                log?.info(`[adp-openclaw] Old format sessionKey detected, extracting id: ${extractedId}`);
-                log?.info(`[adp-openclaw] Merging old and new session histories for id: ${extractedId}`);
+                log?.debug?.(`[adp-openclaw] Old format sessionKey detected, extracting id: ${extractedId}`);
+                log?.debug?.(`[adp-openclaw] Merging old and new session histories for id: ${extractedId}`);
                 result = await getMergedChatHistory(extractedId, {
                   limit,
                   log,
                 });
               } else if (historyPayload.sessionKey) {
                 // Non-old-format sessionKey, use directly
-                log?.info(`[adp-openclaw] Using provided sessionKey: ${historyPayload.sessionKey}`);
+                log?.debug?.(`[adp-openclaw] Using provided sessionKey: ${historyPayload.sessionKey}`);
                 result = await getChatHistory(historyPayload.sessionKey, {
                   limit,
                   log,
@@ -817,21 +825,21 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 // If conversationId is provided, merge old and new session histories
                 // Old format: agent:main:direct:{conversationId}
                 // New format: agent:main:adp-openclaw:direct:{conversationId}
-                log?.info(`[adp-openclaw] Merging old and new session histories for conversationId: ${historyPayload.conversationId}`);
+                log?.debug?.(`[adp-openclaw] Merging old and new session histories for conversationId: ${historyPayload.conversationId}`);
                 result = await getMergedChatHistory(historyPayload.conversationId, {
                   limit,
                   log,
                 });
               } else {
                 // Default to "main" session
-                log?.info(`[adp-openclaw] Using default session: main`);
+                log?.debug?.(`[adp-openclaw] Using default session: main`);
                 result = await getChatHistory("main", {
                   limit,
                   log,
                 });
               }
 
-              log?.info(`[adp-openclaw] Sending conv_response: ${result.messages.length} messages (backend=cli)`);
+              log?.debug?.(`[adp-openclaw] Sending conv_response: ${result.messages.length} messages (backend=cli)`);
 
               // Send response back to GoServer
               const responseMsg: WSMessage = {
@@ -871,7 +879,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
 
             const backend = sessionsPayload.backend || "auto";
 
-            log?.info(`[adp-openclaw] Received fetch_openclaw_sessions request: limit=${sessionsPayload.limit}, backend=${backend}`);
+            log?.debug?.(`[adp-openclaw] Received fetch_openclaw_sessions request: limit=${sessionsPayload.limit}, backend=${backend}`);
 
             try {
               // Use unified listSessions with backend selection
@@ -882,7 +890,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 backend,
               });
 
-              log?.info(`[adp-openclaw] Sending openclaw_sessions_response: ${result.sessions.length} sessions (backend=${backend})`);
+              log?.debug?.(`[adp-openclaw] Sending openclaw_sessions_response: ${result.sessions.length} sessions (backend=${backend})`);
 
               // Send response back to GoServer
               const responseMsg: WSMessage = {

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "noEmit": true,
+    "strict": false,
+    "noImplicitAny": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": [
+    "index.ts",
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.test.ts"
+  ]
+}