weacpx 0.4.0-beta.2 → 0.4.0

package/dist/cli.js

@@ -9898,6 +9898,22 @@ var init_registry = __esm(() => {
   cliProviders = new Map;
 });
 
+// src/weixin/storage/ensure-dir.ts
+import fs2 from "node:fs";
+function ensureDirSync(dir) {
+  try {
+    fs2.mkdirSync(dir, { recursive: true });
+    return;
+  } catch (err) {
+    try {
+      if (fs2.statSync(dir).isDirectory())
+        return;
+    } catch {}
+    throw err;
+  }
+}
+var init_ensure_dir = () => {};
+
 // src/weixin/storage/state-dir.ts
 import os from "node:os";
 import path3 from "node:path";
@@ -9907,7 +9923,7 @@ function resolveStateDir() {
 var init_state_dir = () => {};
 
 // src/weixin/auth/accounts.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import path4 from "node:path";
 function normalizeAccountId(raw) {
   return raw.trim().toLowerCase().replace(/[@.]/g, "-");
@@ -9930,9 +9946,9 @@ function resolveAccountIndexPath() {
 function listIndexedWeixinAccountIds() {
   const filePath = resolveAccountIndexPath();
   try {
-    if (!fs2.existsSync(filePath))
+    if (!fs3.existsSync(filePath))
       return [];
-    const raw = fs2.readFileSync(filePath, "utf-8");
+    const raw = fs3.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed))
       return [];
@@ -9943,8 +9959,8 @@ function listIndexedWeixinAccountIds() {
 }
 function registerWeixinAccountId(accountId) {
   const dir = resolveWeixinStateDir();
-  fs2.mkdirSync(dir, { recursive: true });
-  fs2.writeFileSync(resolveAccountIndexPath(), JSON.stringify([accountId], null, 2), "utf-8");
+  ensureDirSync(dir);
+  fs3.writeFileSync(resolveAccountIndexPath(), JSON.stringify([accountId], null, 2), "utf-8");
 }
 function resolveAccountsDir() {
   return path4.join(resolveWeixinStateDir(), "accounts");
@@ -9955,9 +9971,9 @@ function resolveAccountPath(accountId) {
 function loadLegacyToken() {
   const legacyPath = path4.join(resolveStateDir(), "credentials", "openclaw-weixin", "credentials.json");
   try {
-    if (!fs2.existsSync(legacyPath))
+    if (!fs3.existsSync(legacyPath))
       return;
-    const raw = fs2.readFileSync(legacyPath, "utf-8");
+    const raw = fs3.readFileSync(legacyPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.token === "string" ? parsed.token : undefined;
   } catch {
@@ -9966,8 +9982,8 @@ function loadLegacyToken() {
 }
 function readAccountFile(filePath) {
   try {
-    if (fs2.existsSync(filePath)) {
-      return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    if (fs3.existsSync(filePath)) {
+      return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
     }
   } catch {}
   return null;
@@ -9989,7 +10005,7 @@ function loadWeixinAccount(accountId) {
 }
 function saveWeixinAccount(accountId, update) {
   const dir = resolveAccountsDir();
-  fs2.mkdirSync(dir, { recursive: true });
+  ensureDirSync(dir);
   const existing = loadWeixinAccount(accountId) ?? {};
   const token = update.token?.trim() || existing.token;
   const baseUrl = update.baseUrl?.trim() || existing.baseUrl;
@@ -10000,14 +10016,14 @@ function saveWeixinAccount(accountId, update) {
     ...userId ? { userId } : {}
   };
   const filePath = resolveAccountPath(accountId);
-  fs2.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+  fs3.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
   try {
-    fs2.chmodSync(filePath, 384);
+    fs3.chmodSync(filePath, 384);
   } catch {}
 }
 function clearWeixinAccount(accountId) {
   try {
-    fs2.unlinkSync(resolveAccountPath(accountId));
+    fs3.unlinkSync(resolveAccountPath(accountId));
   } catch {}
 }
 function clearAllWeixinAccounts() {
@@ -10016,7 +10032,7 @@ function clearAllWeixinAccounts() {
     clearWeixinAccount(id);
   }
   try {
-    fs2.writeFileSync(resolveAccountIndexPath(), "[]", "utf-8");
+    fs3.writeFileSync(resolveAccountIndexPath(), "[]", "utf-8");
   } catch {}
 }
 function resolveConfigPath() {
@@ -10028,9 +10044,9 @@ function resolveConfigPath() {
 function loadConfigRouteTag(accountId) {
   try {
     const configPath = resolveConfigPath();
-    if (!fs2.existsSync(configPath))
+    if (!fs3.existsSync(configPath))
       return;
-    const raw = fs2.readFileSync(configPath, "utf-8");
+    const raw = fs3.readFileSync(configPath, "utf-8");
     const cfg = JSON.parse(raw);
     const channels = cfg.channels;
     const section = channels?.["openclaw-weixin"];
@@ -10074,11 +10090,12 @@ function resolveWeixinAccount(accountId) {
 }
 var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com", CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
 var init_accounts = __esm(() => {
+  init_ensure_dir();
   init_state_dir();
 });
 
 // src/weixin/util/logger.ts
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import os2 from "node:os";
 import path5 from "node:path";
 function resolveMinLevel() {
@@ -10128,10 +10145,10 @@ function writeLog(level, message, accountId) {
   });
   try {
     if (!logDirEnsured) {
-      fs3.mkdirSync(MAIN_LOG_DIR, { recursive: true });
+      fs4.mkdirSync(MAIN_LOG_DIR, { recursive: true });
       logDirEnsured = true;
     }
-    fs3.appendFileSync(resolveMainLogPath(), `${entry}
+    fs4.appendFileSync(resolveMainLogPath(), `${entry}
 `, "utf-8");
   } catch {}
 }
@@ -12103,7 +12120,7 @@ var init_media_store = __esm(() => {
 });
 
 // src/channels/outbound-media-safety.ts
-import fs4 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import path7 from "node:path";
 async function resolveSafeOutboundMediaPath(mediaPath, allowedRoots) {
   if (mediaPath.startsWith("http://") || mediaPath.startsWith("https://")) {
@@ -12114,7 +12131,7 @@ async function resolveSafeOutboundMediaPath(mediaPath, allowedRoots) {
   if (!realCandidate) {
     return null;
   }
-  const stat2 = await fs4.stat(realCandidate).catch(() => null);
+  const stat2 = await fs5.stat(realCandidate).catch(() => null);
   if (!stat2?.isFile()) {
     return null;
   }
@@ -12128,7 +12145,7 @@ async function resolveSafeOutboundMediaPath(mediaPath, allowedRoots) {
 }
 async function realpathOrNull(filePath) {
   try {
-    return await fs4.realpath(filePath);
+    return await fs5.realpath(filePath);
   } catch {
     return null;
   }
@@ -12824,10 +12841,10 @@ var init_cdn_upload = __esm(() => {
 
 // src/weixin/cdn/upload.ts
 import crypto3 from "node:crypto";
-import fs5 from "node:fs/promises";
+import fs6 from "node:fs/promises";
 async function uploadMediaToCdn(params) {
   const { filePath, toUserId, opts, cdnBaseUrl, mediaType, label } = params;
-  const plaintext = await fs5.readFile(filePath);
+  const plaintext = await fs6.readFile(filePath);
   const rawsize = plaintext.length;
   const rawfilemd5 = crypto3.createHash("md5").update(plaintext).digest("hex");
   const filesize = aesEcbPaddedSize(rawsize);
@@ -12947,14 +12964,14 @@ var init_send_media = __esm(() => {
 });
 
 // src/weixin/messaging/debug-mode.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import path10 from "node:path";
 function resolveDebugModePath() {
   return path10.join(resolveStateDir(), "openclaw-weixin", "debug-mode.json");
 }
 function loadState() {
   try {
-    const raw = fs6.readFileSync(resolveDebugModePath(), "utf-8");
+    const raw = fs7.readFileSync(resolveDebugModePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.accounts === "object")
       return parsed;
@@ -12963,8 +12980,8 @@ function loadState() {
 }
 function saveState(state) {
   const filePath = resolveDebugModePath();
-  fs6.mkdirSync(path10.dirname(filePath), { recursive: true });
-  fs6.writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
+  ensureDirSync(path10.dirname(filePath));
+  fs7.writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
 }
 function toggleDebugMode(accountId) {
   const state = loadState();
@@ -12978,6 +12995,7 @@ function toggleDebugMode(accountId) {
   return next;
 }
 var init_debug_mode = __esm(() => {
+  init_ensure_dir();
   init_state_dir();
   init_logger();
 });
@@ -13130,7 +13148,7 @@ function normalizeMediaArray(media) {
 
 // src/weixin/messaging/handle-weixin-message-turn.ts
 import crypto4 from "node:crypto";
-import fs7 from "node:fs/promises";
+import fs8 from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path11 from "node:path";
 function utf8ByteLength(s) {
@@ -13230,7 +13248,7 @@ function createSaveMediaBuffer(mediaTempDir) {
       throw new Error(`media exceeds ${maxBytes} bytes`);
     }
     const dir = path11.join(resolveMediaTempDir(mediaTempDir), subdir ?? "");
-    await fs7.mkdir(dir, { recursive: true });
+    await fs8.mkdir(dir, { recursive: true });
     let ext = ".bin";
     if (originalFilename) {
       ext = path11.extname(originalFilename) || ".bin";
@@ -13239,7 +13257,7 @@ function createSaveMediaBuffer(mediaTempDir) {
     }
     const name = `${Date.now()}-${crypto4.randomBytes(4).toString("hex")}${ext}`;
     const filePath = path11.join(dir, name);
-    await fs7.writeFile(filePath, buffer);
+    await fs8.writeFile(filePath, buffer);
     return { path: filePath };
   };
 }
@@ -13379,7 +13397,7 @@ async function handleWeixinMessageTurn(full, deps) {
         continue;
       }
       try {
-        const buffer = await fs7.readFile(filePath);
+        const buffer = await fs8.readFile(filePath);
         const mimeType = downloaded.fileMediaType ?? downloaded.voiceMediaType ?? defaultWeixinMime(descriptor.kind);
         media.push(await mediaStore.saveMediaBuffer({
           channelId: "weixin",
@@ -13393,7 +13411,7 @@ async function handleWeixinMessageTurn(full, deps) {
           maxBytes: descriptor.kind === "image" ? DEFAULT_IMAGE_MAX_BYTES : DEFAULT_ATTACHMENT_MAX_BYTES
         }));
       } finally {
-        await fs7.rm(filePath, { force: true }).catch(() => {});
+        await fs8.rm(filePath, { force: true }).catch(() => {});
       }
     } catch (err) {
       deps.errLog(`media download failed: ${String(err)}`);
@@ -13565,7 +13583,7 @@ var init_handle_weixin_message_turn = __esm(() => {
 });
 
 // src/weixin/storage/sync-buf.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import path12 from "node:path";
 function resolveAccountsDir2() {
   return path12.join(resolveStateDir(), "openclaw-weixin", "accounts");
@@ -13578,7 +13596,7 @@ function getLegacySyncBufDefaultJsonPath() {
 }
 function readSyncBufFile(filePath) {
   try {
-    const raw = fs8.readFileSync(filePath, "utf-8");
+    const raw = fs9.readFileSync(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.get_updates_buf === "string") {
       return data.get_updates_buf;
@@ -13602,11 +13620,12 @@ function loadGetUpdatesBuf(filePath) {
 }
 function saveGetUpdatesBuf(filePath, getUpdatesBuf) {
   const dir = path12.dirname(filePath);
-  fs8.mkdirSync(dir, { recursive: true });
-  fs8.writeFileSync(filePath, JSON.stringify({ get_updates_buf: getUpdatesBuf }, null, 0), "utf-8");
+  ensureDirSync(dir);
+  fs9.writeFileSync(filePath, JSON.stringify({ get_updates_buf: getUpdatesBuf }, null, 0), "utf-8");
 }
 var init_sync_buf = __esm(() => {
   init_accounts();
+  init_ensure_dir();
   init_state_dir();
 });
 
@@ -14153,7 +14172,7 @@ import { dirname as dirname6, join as join3 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function createWeixinConsumerLock(options = {}) {
   const lockFilePath = options.lockFilePath ?? join3(homedir3(), ".weacpx", "runtime", "weixin-consumer.lock.json");
-  const isProcessRunning = options.isProcessRunning ?? defaultIsProcessRunning3;
+  const isProcessRunning = options.isProcessRunning ?? defaultIsProcessRunning4;
   const onDiagnostic = options.onDiagnostic;
   return {
     async acquire(meta2) {
@@ -14240,7 +14259,7 @@ async function loadLockMetadata(path13) {
     return null;
   }
 }
-function defaultIsProcessRunning3(pid) {
+function defaultIsProcessRunning4(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -16569,7 +16588,7 @@ async function handleSessionRemove(context, chatKey, alias) {
   return { text: lines.join(`
 `) };
 }
-async function promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal) {
+async function promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent) {
   const effectiveReplyMode = session.replyMode ?? context.config?.channel.replyMode ?? "verbose";
   if (!session.replyMode)
     session.replyMode = effectiveReplyMode;
@@ -16594,7 +16613,7 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
   const { promptText, taskIds, groupIds, claimHumanReply } = await preparePromptWithFallback(context, session, chatKey, text, replyContextToken, accountId);
   try {
     const replyContext = transportReply && context.quota && getChannelIdFromChatKey(chatKey) === "weixin" ? { chatKey, quota: context.quota } : undefined;
-    const result = await context.interaction.promptTransportSession(session, promptText, transportReply, replyContext, media, abortSignal);
+    const result = await context.interaction.promptTransportSession(session, promptText, transportReply, replyContext, media, abortSignal, onToolEvent);
     if (claimHumanReply) {
       try {
         await context.orchestration?.claimActiveHumanReply?.(claimHumanReply);
@@ -16614,17 +16633,17 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
     throw error2;
   }
 }
-async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal) {
+async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent) {
   const session = await context.sessions.getCurrentSession(chatKey);
   if (!session) {
     return { text: NO_CURRENT_SESSION_TEXT };
   }
   try {
-    return await promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal);
+    return await promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent);
   } catch (error2) {
     const recovered = await context.recovery.tryRecoverMissingSession(session, error2);
     if (recovered) {
-      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media, abortSignal);
+      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent);
     }
     return context.recovery.renderTransportError(session, error2);
   }
@@ -18150,7 +18169,7 @@ class CommandRouter {
     this.quota = quota;
     this.logger = logger2 ?? createNoopAppLogger();
   }
-  async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal) {
+  async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent) {
     const startedAt = Date.now();
     const command = parseCommand(input);
     await this.logger.debug("command.parsed", "parsed inbound command", {
@@ -18264,7 +18283,7 @@ class CommandRouter {
         case "task.cancel":
           return await handleTaskCancel(this.createHandlerContext(), chatKey, command.taskId);
         case "prompt":
-          return await handlePrompt(this.createSessionHandlerContext(), chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal);
+          return await handlePrompt(this.createSessionHandlerContext(), chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent);
       }
     });
   }
@@ -18316,7 +18335,7 @@ class CommandRouter {
     return {
       setModeTransportSession: (session, modeId) => this.setModeTransportSession(session, modeId),
       cancelTransportSession: (session) => this.cancelTransportSession(session),
-      promptTransportSession: (session, text, reply, replyContext, media, abortSignal) => this.promptTransportSession(session, text, reply, replyContext, media, abortSignal)
+      promptTransportSession: (session, text, reply, replyContext, media, abortSignal, onToolEvent) => this.promptTransportSession(session, text, reply, replyContext, media, abortSignal, onToolEvent)
     };
   }
   createSessionRenderRecoveryOps() {
@@ -18479,7 +18498,7 @@ class CommandRouter {
   async checkTransportSession(session) {
     return await this.measureTransportCall("has_session", session, () => this.transport.hasSession(session));
   }
-  async promptTransportSession(session, text, reply, replyContext, media, abortSignal) {
+  async promptTransportSession(session, text, reply, replyContext, media, abortSignal, onToolEvent) {
     session.mcpCoordinatorSession ??= session.transportSession;
     let done = false;
     let cancelOnAbort;
@@ -18516,7 +18535,10 @@ class CommandRouter {
       abortSignal.addEventListener("abort", cancelOnAbort, { once: true });
     }
     try {
-      return await this.measureTransportCall("prompt", session, () => this.transport.prompt(session, text, reply, replyContext, media ? { media } : undefined));
+      return await this.measureTransportCall("prompt", session, () => this.transport.prompt(session, text, reply, replyContext, {
+        ...media ? { media } : {},
+        ...onToolEvent ? { onToolEvent } : {}
+      }));
     } finally {
       done = true;
       if (cancelOnAbort && abortSignal) {
@@ -18667,7 +18689,7 @@ class ConsoleAgent {
       mimeType: m.mimeType,
       ...m.fileName ? { fileName: m.fileName } : {}
     })) : undefined;
-    return await this.router.handle(request.conversationId, request.text, request.reply, request.replyContextToken, request.accountId, promptMedia, request.metadata, request.abortSignal);
+    return await this.router.handle(request.conversationId, request.text, request.reply, request.replyContextToken, request.accountId, promptMedia, request.metadata, request.abortSignal, request.onToolEvent);
   }
   isKnownCommand(text) {
     return isKnownWeacpxCommandText(text);
@@ -22767,6 +22789,10 @@ function encodeBridgePromptSegmentEvent(event) {
   return `${JSON.stringify(event)}
 `;
 }
+function encodeBridgePromptToolEvent(event) {
+  return `${JSON.stringify(event)}
+`;
+}
 function encodeBridgeSessionProgressEvent(event) {
   return `${JSON.stringify(event)}
 `;
@@ -22834,6 +22860,11 @@ class AcpxBridgeClient {
           type: "prompt.segment",
           text: message.text
         });
+      } else if (message.event === "prompt.tool_event") {
+        pending.onEvent?.({
+          type: "prompt.tool_event",
+          event: message.toolEvent
+        });
       } else if (message.event === "session.progress") {
         pending.onEvent?.({
           type: "session.progress",
@@ -23157,6 +23188,17 @@ var init_quota_gated_reply_sink = __esm(() => {
   ADAPTIVE_WINDOW_SCHEDULE_MS = [3000, 6000, 12000, 24000, 48000, 60000];
 });
 
+// src/transport/tool-event-mode.ts
+function resolveToolEventMode(input) {
+  if (input?.toolEventMode !== undefined) {
+    return input.toolEventMode;
+  }
+  if (input?.onToolEvent !== undefined) {
+    return "structured";
+  }
+  return "text";
+}
+
 // src/transport/acpx-bridge/acpx-bridge-transport.ts
 class AcpxBridgeTransport {
   client;
@@ -23179,10 +23221,18 @@ class AcpxBridgeTransport {
     }) : null;
     let segmentError;
     let segmentChain = Promise.resolve();
+    let toolEventError;
+    let toolEventChain = Promise.resolve();
+    let toolEventMode = resolveToolEventMode(options);
+    if ((toolEventMode === "structured" || toolEventMode === "both") && !options?.onToolEvent) {
+      toolEventMode = "text";
+    }
     const result = await this.client.request("prompt", {
       ...this.toParams(session),
       text,
-      ...options?.media ? { media: options.media } : {}
+      ...options?.media ? { media: options.media } : {},
+      ...toolEventMode === "structured" || toolEventMode === "both" ? { toolEvents: true } : {},
+      toolEventMode
     }, (event) => {
       if (event.type === "prompt.segment") {
         const onSegment = options?.onSegment;
@@ -23193,9 +23243,21 @@ class AcpxBridgeTransport {
           });
         }
         sink?.feedSegment(event.text);
+        return;
+      }
+      if (event.type === "prompt.tool_event") {
+        const onToolEvent = options?.onToolEvent;
+        if (onToolEvent) {
+          const toolEvent = event.event;
+          toolEventChain = toolEventChain.then(() => onToolEvent(toolEvent)).catch((error2) => {
+            toolEventError ??= error2;
+          });
+        }
+        return;
       }
     });
     await segmentChain;
+    await toolEventChain;
     if (sink) {
       const { overflowCount } = sink.finalize();
       await sink.drain({ timeoutMs: 30000 });
@@ -23207,6 +23269,9 @@ class AcpxBridgeTransport {
       if (segmentError) {
         throw segmentError;
       }
+      if (toolEventError) {
+        throw toolEventError;
+      }
       return { text: summary ? `${summary}
 
 ${result.text}` : "" };
@@ -23214,6 +23279,9 @@ ${result.text}` : "" };
     if (segmentError) {
       throw segmentError;
     }
+    if (toolEventError) {
+      throw toolEventError;
+    }
     return result;
   }
   async setMode(session, modeId) {
@@ -23400,8 +23468,37 @@ var init_prompt_media = __esm(() => {
   };
 });
 
+// src/transport/tool-kind-emoji.ts
+var TOOL_KIND_EMOJI, DEFAULT_TOOL_EMOJI;
+var init_tool_kind_emoji = __esm(() => {
+  TOOL_KIND_EMOJI = {
+    read: "\uD83D\uDCD6",
+    search: "\uD83D\uDD0D",
+    execute: "\uD83D\uDCBB",
+    edit: "✏️",
+    think: "\uD83E\uDDE0",
+    other: "\uD83D\uDD27"
+  };
+  DEFAULT_TOOL_EMOJI = TOOL_KIND_EMOJI.other;
+});
+
 // src/transport/streaming-prompt.ts
-function createStreamingPromptState(formatToolCalls = false) {
+function createStreamingPromptState(formatToolCalls = false, options) {
+  let toolEventMode;
+  let onToolEvent;
+  if (options === undefined) {
+    toolEventMode = "text";
+    onToolEvent = undefined;
+  } else if (typeof options === "function") {
+    onToolEvent = options;
+    toolEventMode = "structured";
+  } else {
+    onToolEvent = options.onToolEvent;
+    toolEventMode = resolveToolEventMode({
+      toolEventMode: options.mode,
+      onToolEvent
+    });
+  }
   return {
     buffer: "",
     segments: [],
@@ -23409,6 +23506,8 @@ function createStreamingPromptState(formatToolCalls = false) {
     pendingLine: "",
     formatToolCalls,
     emittedToolCallIds: new Set,
+    toolEventMode,
+    onToolEvent,
     finalize() {
       if (this.pendingLine.trim().length > 0) {
         parseStreamingChunks(this, this.pendingLine);
@@ -23446,15 +23545,24 @@ function parseStreamingChunks(state, line) {
   if (!update)
     return;
   if (state.formatToolCalls && (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update")) {
-    const formatted = formatToolCallEvent(update, update.sessionUpdate);
-    if (formatted) {
-      const toolCallId = update.toolCallId;
-      if (toolCallId) {
-        if (state.emittedToolCallIds.has(toolCallId))
-          return;
-        state.emittedToolCallIds.add(toolCallId);
+    const wantsStructured = state.toolEventMode === "structured" || state.toolEventMode === "both";
+    const wantsText = state.toolEventMode === "text" || state.toolEventMode === "both";
+    if (wantsStructured && state.onToolEvent) {
+      const toolEvent = buildToolUseEvent(update);
+      if (toolEvent)
+        state.onToolEvent(toolEvent);
+    }
+    if (wantsText) {
+      const formatted = formatToolCallEvent(update, update.sessionUpdate);
+      if (formatted) {
+        const toolCallId = update.toolCallId;
+        if (toolCallId) {
+          if (state.emittedToolCallIds.has(toolCallId))
+            return;
+          state.emittedToolCallIds.add(toolCallId);
+        }
+        state.segments.push(formatted);
       }
-      state.segments.push(formatted);
     }
     return;
   }
@@ -23484,16 +23592,51 @@ function formatToolCallEvent(update, sessionUpdate) {
   const title = update.title ?? "";
   if (title.length === 0)
     return null;
-  const emoji2 = KIND_EMOJI[kind] ?? "\uD83D\uDD27";
-  const inputSummary = summarizeToolInput(update.rawInput);
+  const emoji2 = TOOL_KIND_EMOJI[kind] ?? DEFAULT_TOOL_EMOJI;
+  const inputSummary = summarizeToolInput(update.rawInput, title);
   const status = readString(update, "status");
+  if (!inputSummary && status === "pending")
+    return null;
   if (!inputSummary && isGenericToolTitle(kind, title))
     return null;
-  const summaryText = inputSummary ? `: ${truncateToolDisplay(inputSummary)}` : "";
+  const summaryText = inputSummary && inputSummary !== title ? `: ${truncateToolDisplay(inputSummary)}` : "";
   const statusText = status ? ` (${status})` : "";
   return `${emoji2} ${title}${statusText}${summaryText}`;
 }
-function summarizeToolInput(rawInput) {
+function buildToolUseEvent(update) {
+  if (!update)
+    return null;
+  const toolCallId = update.toolCallId;
+  if (!toolCallId)
+    return null;
+  const kindRaw = update.kind ?? "";
+  const kind = (() => {
+    switch (kindRaw) {
+      case "read":
+      case "search":
+      case "execute":
+      case "edit":
+      case "think":
+        return kindRaw;
+      default:
+        return "other";
+    }
+  })();
+  const title = (update.title ?? "").trim();
+  const toolName = title || "Tool";
+  const summaryRaw = summarizeToolInput(update.rawInput, title);
+  const summary = summaryRaw && summaryRaw !== title ? summaryRaw : undefined;
+  const statusRaw = readString(update, "status");
+  const status = statusRaw === "completed" || statusRaw === "success" ? "success" : statusRaw === "failed" || statusRaw === "error" ? "error" : "running";
+  return {
+    toolCallId,
+    toolName,
+    kind,
+    ...summary ? { summary } : {},
+    status
+  };
+}
+function summarizeToolInput(rawInput, title = "") {
   if (rawInput == null)
     return;
   if (typeof rawInput === "string" || typeof rawInput === "number" || typeof rawInput === "boolean") {
@@ -23501,6 +23644,9 @@ function summarizeToolInput(rawInput) {
   }
   if (!isRecord3(rawInput))
     return;
+  const taskSummary = summarizeTaskInput(rawInput, title);
+  if (taskSummary)
+    return taskSummary;
   const command = readFirstString(rawInput, ["command", "cmd", "program"]);
   const args = readFirstStringArray(rawInput, ["args", "arguments"]);
   if (command) {
@@ -23523,6 +23669,7 @@ function summarizeToolInput(rawInput) {
     "file",
     "filePath",
     "filepath",
+    "file_path",
     "target",
     "uri",
     "url",
@@ -23534,6 +23681,16 @@ function summarizeToolInput(rawInput) {
     "description"
   ]);
 }
+function summarizeTaskInput(rawInput, title) {
+  const subagentType = readFirstString(rawInput, ["subagent_type", "subagentType", "agent", "agentType"]);
+  const description = readFirstString(rawInput, ["description", "task", "summary"]);
+  if (subagentType && description) {
+    return description === title ? subagentType : `${subagentType}: ${description}`;
+  }
+  if (subagentType)
+    return subagentType;
+  return;
+}
 function readFirstString(record3, keys) {
   for (const key of keys) {
     const value = record3[key];
@@ -23580,14 +23737,8 @@ function isGenericToolTitle(kind, title) {
   }
   return false;
 }
-var KIND_EMOJI;
 var init_streaming_prompt = __esm(() => {
-  KIND_EMOJI = {
-    read: "\uD83D\uDCD6",
-    search: "\uD83D\uDD0D",
-    execute: "\uD83D\uDCBB",
-    edit: "✏️"
-  };
+  init_tool_kind_emoji();
 });
 
 // src/transport/acpx-cli/node-pty-helper.ts
@@ -23897,7 +24048,8 @@ class AcpxCliTransport {
   runCommand;
   runPtyCommand;
   queueOwnerLauncher;
-  constructor(options, runCommand = defaultRunner, runPtyCommand = defaultPtyRunner, queueOwnerLauncher) {
+  streamingHooks;
+  constructor(options, runCommand = defaultRunner, runPtyCommand = defaultPtyRunner, queueOwnerLauncher, streamingHooks = {}) {
     this.command = options.command ?? "acpx";
     this.sessionInitTimeoutMs = options.sessionInitTimeoutMs ?? 120000;
     this.permissionMode = options.permissionMode ?? "approve-all";
@@ -23907,6 +24059,7 @@ class AcpxCliTransport {
     this.queueOwnerLauncher = queueOwnerLauncher ?? new AcpxQueueOwnerLauncher({
       acpxCommand: this.command
     });
+    this.streamingHooks = streamingHooks;
   }
   async ensureSession(session, _onProgress) {
     const args = this.buildArgs(session, [
@@ -23925,9 +24078,13 @@ class AcpxCliTransport {
     const structuredPrompt = await createStructuredPromptFile(text, options?.media);
     const args = this.buildPromptArgs(session, text, structuredPrompt?.filePath);
     try {
-      if (reply || options?.onSegment) {
+      if (reply || options?.onSegment || options?.onToolEvent) {
         const formatToolCalls = (session.replyMode ?? "verbose") === "verbose";
-        const { result: result2, overflowCount } = await this.runStreamingPrompt(this.command, args, reply, 30000, formatToolCalls, replyContext, options?.onSegment);
+        let toolEventMode = resolveToolEventMode(options);
+        if ((toolEventMode === "structured" || toolEventMode === "both") && !options?.onToolEvent) {
+          toolEventMode = "text";
+        }
+        const { result: result2, overflowCount } = await this.runStreamingPrompt(this.command, args, reply, formatToolCalls, toolEventMode, replyContext, options?.onSegment, options?.onToolEvent);
         const baseText = getPromptText(result2);
         if (!reply) {
           return { text: baseText };
@@ -24064,16 +24221,35 @@ ${baseText}` : "" };
       })
     ]);
   }
-  async runStreamingPrompt(command, args, reply, maxSegmentWaitMs = 30000, formatToolCalls = false, replyContext, onSegment) {
+  async runStreamingPrompt(command, args, reply, formatToolCalls = false, toolEventMode = "text", replyContext, onSegment, onToolEvent) {
+    const hooks = this.streamingHooks;
+    const doSpawn = hooks.spawnPrompt ?? ((cmd, spawnArgs) => spawn8(cmd, spawnArgs, { stdio: ["ignore", "pipe", "pipe"] }));
+    const setIntervalFn = hooks.setIntervalFn ?? ((fn, delay) => setInterval(fn, delay));
+    const clearIntervalFn = hooks.clearIntervalFn ?? ((timer) => clearInterval(timer));
+    const maxSegmentWaitMs = hooks.maxSegmentWaitMs ?? 30000;
+    const flushCheckIntervalMs = hooks.flushCheckIntervalMs ?? 5000;
+    const now = hooks.now ?? (() => Date.now());
     return await new Promise((resolve3, reject) => {
       const spawnSpec = resolveSpawnCommand(command, args);
-      const child = spawn8(spawnSpec.command, spawnSpec.args, { stdio: ["ignore", "pipe", "pipe"] });
+      const child = doSpawn(spawnSpec.command, spawnSpec.args);
       let stdout2 = "";
       let stderr = "";
-      const state = createStreamingPromptState(formatToolCalls);
-      let lastReplyAt = Date.now();
+      let lastReplyAt = now();
       let segmentChain = Promise.resolve();
       let segmentError;
+      let toolEventChain = Promise.resolve();
+      let toolEventError;
+      const userOnToolEvent = onToolEvent;
+      const state = createStreamingPromptState(formatToolCalls, {
+        mode: toolEventMode,
+        ...userOnToolEvent ? {
+          onToolEvent: (event) => {
+            toolEventChain = toolEventChain.then(() => userOnToolEvent(event)).catch((error2) => {
+              toolEventError ??= error2;
+            });
+          }
+        } : {}
+      });
       const sink = reply ? createQuotaGatedReplySink({
         reply,
         ...replyContext ? { replyContext } : {}
@@ -24085,7 +24261,7 @@ ${baseText}` : "" };
           });
         }
         sink?.feedSegment(segment);
-        lastReplyAt = Date.now();
+        lastReplyAt = now();
       };
       const flushBuffer = () => {
         const remaining = state.buffer.trim();
@@ -24094,11 +24270,11 @@ ${baseText}` : "" };
           feedSegment(remaining);
         }
       };
-      const timer = setInterval(() => {
-        if (state.buffer.trim().length > 0 && Date.now() - lastReplyAt >= maxSegmentWaitMs) {
+      const timer = setIntervalFn(() => {
+        if (state.buffer.trim().length > 0 && now() - lastReplyAt >= maxSegmentWaitMs) {
           flushBuffer();
         }
-      }, 5000);
+      }, flushCheckIntervalMs);
       child.stdout.setEncoding("utf8");
       child.stdout.on("data", (chunk) => {
         stdout2 += String(chunk);
@@ -24111,11 +24287,11 @@ ${baseText}` : "" };
         stderr += String(chunk);
       });
       child.on("error", (err) => {
-        clearInterval(timer);
+        clearIntervalFn(timer);
         reject(err);
       });
       child.on("close", (code) => {
-        clearInterval(timer);
+        clearIntervalFn(timer);
         const remaining = state.finalize();
         if (remaining.length > 0) {
           feedSegment(remaining);
@@ -24123,7 +24299,8 @@ ${baseText}` : "" };
         const { overflowCount } = sink?.finalize() ?? { overflowCount: 0 };
         Promise.all([
           sink?.drain({ timeoutMs: 30000 }) ?? Promise.resolve(),
-          segmentChain
+          segmentChain,
+          toolEventChain
         ]).then(() => {
           const deferred = sink?.getPendingError();
           if (deferred) {
@@ -24134,6 +24311,10 @@ ${baseText}` : "" };
             reject(segmentError);
             return;
           }
+          if (toolEventError) {
+            reject(toolEventError);
+            return;
+          }
           resolve3({
             result: { code: code ?? 1, stdout: stdout2, stderr },
             overflowCount
@@ -25120,7 +25301,7 @@ async function checkDaemon(options = {}) {
     cliEntryPath: options.cliEntryPath ?? resolveCliEntryPath(),
     cwd: options.cwd ?? process.cwd(),
     env: options.env ?? process.env,
-    isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning4
+    isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning5
   });
   try {
     const status = await controller.getStatus();
@@ -25191,7 +25372,7 @@ async function checkDaemon(options = {}) {
     };
   }
 }
-function defaultIsProcessRunning4(pid) {
+function defaultIsProcessRunning5(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -38712,7 +38893,7 @@ async function asToolResult(action) {
             text: "Outbound budget exhausted; the action has been recorded as pending and will retry automatically after the next user inbound resets the quota window. No further action required."
           }
         ],
-        structuredContent: { status: "deferred_quota", chatKey: error2.chatKey },
+        structuredContent: { status: "deferred_quota" },
         isError: false
       };
     }
@@ -38923,7 +39104,9 @@ function renderCoordinatorReviewContestedResultSuccess(task, decision) {
 }
 function formatToolError(error2) {
   const message = error2 instanceof Error ? error2.message : String(error2);
-  if (/ECONNREFUSED|ENOENT|server closed without a response|socket hang up|connect /i.test(message)) {
+  const code = typeof error2 === "object" && error2 !== null && "code" in error2 ? error2.code : undefined;
+  const isConnectionError = code === "ECONNREFUSED" || code === "ENOENT" || code === "ECONNRESET" || code === "EPIPE" || /server closed without a response|socket hang up/i.test(message);
+  if (isConnectionError) {
     return `Failed to connect to the orchestration daemon: ${message}`;
   }
   return message;
@@ -39084,9 +39267,9 @@ function createOrchestrationTransport(endpoint, deps = {}) {
       sourceHandle: input.sourceHandle ?? input.coordinatorSession,
       targetAgent: input.targetAgent,
       task: input.task,
-      ...input.workingDirectory ? { cwd: input.workingDirectory } : {},
-      ...input.role ? { role: input.role } : {},
-      ...input.groupId ? { groupId: input.groupId } : {}
+      ...input.workingDirectory !== undefined ? { cwd: input.workingDirectory } : {},
+      ...input.role !== undefined ? { role: input.role } : {},
+      ...input.groupId !== undefined ? { groupId: input.groupId } : {}
     }),
     createGroup: async (input) => await client.createGroup(input),
     getGroup: async (input) => await client.getGroup(input),
@@ -39095,10 +39278,10 @@ function createOrchestrationTransport(endpoint, deps = {}) {
     getTask: async (input) => await client.getTaskForCoordinator(input),
     listTasks: async (input) => await client.listTasks({
       coordinatorSession: input.coordinatorSession,
-      ...input.status ? { status: input.status } : {},
+      ...input.status !== undefined ? { status: input.status } : {},
       ...input.stuck !== undefined ? { stuck: input.stuck } : {},
-      ...input.sort ? { sort: input.sort } : {},
-      ...input.order ? { order: input.order } : {}
+      ...input.sort !== undefined ? { sort: input.sort } : {},
+      ...input.order !== undefined ? { order: input.order } : {}
     }),
     approveTask: async (input) => await client.approveTask(input),
     rejectTask: async (input) => await client.rejectTask(input),
@@ -39205,6 +39388,84 @@ async function resolveMcpIdentity(server, options) {
   }
   throw new McpError(ErrorCode.InvalidRequest, "weacpx MCP identity is not configured; run through `weacpx mcp-stdio` or provide --coordinator-session");
 }
+function installMcpStdioShutdownHooks(options) {
+  const platform = options.platform ?? process.platform;
+  const signalSource = options.signalSource ?? process;
+  const isProcessRunning = options.isProcessRunning ?? defaultIsProcessRunning3;
+  const setIntervalFn = options.setIntervalFn ?? ((callback, ms) => setInterval(callback, ms));
+  const clearIntervalFn = options.clearIntervalFn ?? ((handle) => clearInterval(handle));
+  const parentPid = options.parentPid ?? process.ppid;
+  const parentCheckIntervalMs = options.parentCheckIntervalMs ?? parseParentCheckIntervalMs(process.env.WEACPX_MCP_PARENT_CHECK_INTERVAL_MS);
+  let disposed = false;
+  let triggered = false;
+  const triggerShutdown = (reason, context) => {
+    if (disposed || triggered)
+      return;
+    triggered = true;
+    options.onDiagnostic?.("mcp.stdio.shutdown", { reason, ...context ?? {} });
+    options.shutdown();
+  };
+  const onStreamEnd = () => triggerShutdown("stdin.end");
+  const onStreamClose = () => triggerShutdown("stdin.close");
+  const onStdinError = (error2) => triggerShutdown("stdin.error", errorContext(error2));
+  const onStdoutError = (error2) => triggerShutdown("stdout.error", errorContext(error2));
+  const onSignal = (signal) => triggerShutdown("signal", { signal });
+  options.stdin.on("end", onStreamEnd);
+  options.stdin.on("close", onStreamClose);
+  options.stdin.on("error", onStdinError);
+  options.stdout.on("error", onStdoutError);
+  const signals = platform === "win32" ? ["SIGINT", "SIGTERM", "SIGBREAK"] : ["SIGINT", "SIGTERM", "SIGHUP"];
+  const signalListeners = signals.map((signal) => ({ signal, listener: () => onSignal(signal) }));
+  for (const { signal, listener } of signalListeners) {
+    signalSource.on(signal, listener);
+  }
+  let parentTimer;
+  if (parentPid > 1 && parentCheckIntervalMs > 0) {
+    parentTimer = setIntervalFn(() => {
+      if (!isProcessRunning(parentPid)) {
+        triggerShutdown("parent_dead", { parentPid });
+      }
+    }, parentCheckIntervalMs);
+    parentTimer.unref?.();
+  }
+  return () => {
+    if (disposed)
+      return;
+    disposed = true;
+    options.stdin.off("end", onStreamEnd);
+    options.stdin.off("close", onStreamClose);
+    options.stdin.off("error", onStdinError);
+    options.stdout.off("error", onStdoutError);
+    for (const { signal, listener } of signalListeners) {
+      signalSource.off(signal, listener);
+    }
+    if (parentTimer) {
+      clearIntervalFn(parentTimer);
+    }
+  };
+}
+function parseParentCheckIntervalMs(raw) {
+  if (raw === undefined || raw.trim().length === 0)
+    return 5000;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 5000;
+}
+function errorContext(error2) {
+  const record3 = error2;
+  return {
+    ...typeof record3?.code === "string" ? { code: record3.code } : {},
+    ...typeof record3?.message === "string" ? { message: record3.message } : {}
+  };
+}
+function defaultIsProcessRunning3(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error2) {
+    const code = error2?.code;
+    return code !== "ESRCH";
+  }
+}
 async function runWeacpxMcpServer(options) {
   const transport = options.transport ?? createOrchestrationTransport(options.endpoint ?? resolveDefaultOrchestrationEndpoint(process.env, process.platform));
   const server = createWeacpxMcpServer({
@@ -39215,11 +39476,14 @@ async function runWeacpxMcpServer(options) {
     ...options.availableAgents ? { availableAgents: options.availableAgents } : {}
   });
   const stdio = new StdioServerTransport(stdin, stdout);
+  let cleanupShutdownHooks;
   let shuttingDown = false;
   const shutdown = async () => {
     if (shuttingDown)
       return;
     shuttingDown = true;
+    cleanupShutdownHooks?.();
+    options.onDiagnostic?.("mcp.stdio.stopping");
     const forceExit = setTimeout(() => process.exit(0), 3000);
     forceExit.unref();
     try {
@@ -39227,11 +39491,16 @@ async function runWeacpxMcpServer(options) {
       await stdio.close();
     } catch {}
     clearTimeout(forceExit);
+    options.onDiagnostic?.("mcp.stdio.stopped");
     process.exit(0);
   };
-  stdin.on("end", () => void shutdown());
-  process.on("SIGTERM", () => void shutdown());
-  process.on("SIGINT", () => void shutdown());
+  options.onDiagnostic?.("mcp.stdio.start", { parentPid: process.ppid, platform: process.platform });
+  cleanupShutdownHooks = installMcpStdioShutdownHooks({
+    stdin,
+    stdout,
+    shutdown,
+    onDiagnostic: options.onDiagnostic
+  });
   await server.connect(stdio);
 }
 function normalizeInputSchemaJson(schema) {
@@ -39257,18 +39526,18 @@ function sanitizeMcpClientName(input) {
   return normalized.length > 0 ? normalized : "mcp-host";
 }
 
-// src/mcp/parse-coordinator-workspace.ts
-function parseCoordinatorWorkspace(args, env = process.env) {
+// src/mcp/parse-string-flag.ts
+function parseStringFlag(args, env, options) {
   let fromFlag = null;
   for (let index = 0;index < args.length; index += 1) {
-    if (args[index] === "--workspace") {
+    if (args[index] === options.flag) {
       const value = args[index + 1];
       if (value === undefined) {
-        throw new Error("--workspace requires a non-empty value");
+        throw new Error(`${options.flag} requires a non-empty value`);
       }
       const trimmedValue = value.trim();
       if (trimmedValue.length === 0 || trimmedValue.startsWith("-")) {
-        throw new Error("--workspace requires a non-empty value");
+        throw new Error(`${options.flag} requires a non-empty value`);
       }
       fromFlag = value;
     }
@@ -39277,56 +39546,32 @@ function parseCoordinatorWorkspace(args, env = process.env) {
   if (trimmedFlag && trimmedFlag.length > 0) {
     return trimmedFlag;
   }
-  const trimmedEnv = env.WEACPX_COORDINATOR_WORKSPACE?.trim();
+  const trimmedEnv = env[options.envKey]?.trim();
   return trimmedEnv && trimmedEnv.length > 0 ? trimmedEnv : null;
 }
 
+// src/mcp/parse-coordinator-workspace.ts
+function parseCoordinatorWorkspace(args, env = process.env) {
+  return parseStringFlag(args, env, {
+    flag: "--workspace",
+    envKey: "WEACPX_COORDINATOR_WORKSPACE"
+  });
+}
+
 // src/mcp/parse-coordinator-session.ts
 function parseCoordinatorSession(args, env = process.env) {
-  let fromFlag = null;
-  for (let index = 0;index < args.length; index += 1) {
-    if (args[index] === "--coordinator-session") {
-      const value = args[index + 1];
-      if (value === undefined) {
-        throw new Error("--coordinator-session requires a non-empty value");
-      }
-      const trimmedValue = value.trim();
-      if (trimmedValue.length === 0 || trimmedValue.startsWith("-")) {
-        throw new Error("--coordinator-session requires a non-empty value");
-      }
-      fromFlag = value;
-    }
-  }
-  const trimmedFlag = fromFlag?.trim();
-  if (trimmedFlag && trimmedFlag.length > 0) {
-    return trimmedFlag;
-  }
-  const trimmedEnv = env.WEACPX_COORDINATOR_SESSION?.trim();
-  return trimmedEnv && trimmedEnv.length > 0 ? trimmedEnv : null;
+  return parseStringFlag(args, env, {
+    flag: "--coordinator-session",
+    envKey: "WEACPX_COORDINATOR_SESSION"
+  });
 }
 
 // src/mcp/parse-source-handle.ts
 function parseSourceHandle(args, env = process.env) {
-  let fromFlag = null;
-  for (let index = 0;index < args.length; index += 1) {
-    if (args[index] === "--source-handle") {
-      const value = args[index + 1];
-      if (value === undefined) {
-        throw new Error("--source-handle requires a non-empty value");
-      }
-      const trimmedValue = value.trim();
-      if (trimmedValue.length === 0 || trimmedValue.startsWith("-")) {
-        throw new Error("--source-handle requires a non-empty value");
-      }
-      fromFlag = value;
-    }
-  }
-  const trimmedFlag = fromFlag?.trim();
-  if (trimmedFlag && trimmedFlag.length > 0) {
-    return trimmedFlag;
-  }
-  const trimmedEnv = env.WEACPX_SOURCE_HANDLE?.trim();
-  return trimmedEnv && trimmedEnv.length > 0 ? trimmedEnv : null;
+  return parseStringFlag(args, env, {
+    flag: "--source-handle",
+    envKey: "WEACPX_SOURCE_HANDLE"
+  });
 }
 
 // src/cli.ts
@@ -41023,7 +41268,12 @@ async function defaultMcpStdio(args, deps = {}) {
     ...coordinatorSession ? { coordinatorSession } : {},
     ...sourceHandle ? { sourceHandle } : {},
     ...identityResolver ? { resolveIdentity: identityResolver } : {},
-    ...availableAgents ? { availableAgents } : {}
+    ...availableAgents ? { availableAgents } : {},
+    onDiagnostic: (event, context) => {
+      const suffix = context && Object.keys(context).length > 0 ? ` ${JSON.stringify(context)}` : "";
+      (deps.stderr ?? ((text) => process.stderr.write(text)))(`[weacpx:mcp] ${event}${suffix}
+`);
+    }
   });
   return 0;
 }