@harmonyos-arkts/opencode-acp 0.0.3 → 0.0.6

package/dist/index.cjs

@@ -19586,6 +19586,11 @@ function createOpencodeClient(config2) {
 // node_modules/@opencode-ai/sdk/dist/v2/server.js
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 
+// src/index.ts
+var http = __toESM(require("node:http"), 1);
+var https = __toESM(require("node:https"), 1);
+var import_node_stream = require("node:stream");
+
 // src/agent.ts
 var import_url2 = require("url");
 
@@ -19631,9 +19636,11 @@ var SessionManager = class {
   /**
    * Load an existing session into the manager.
    * Called by agent.loadSession() / agent.unstable_resumeSession().
+   * Returns the session state plus the raw Session object from OpenCode.
    */
   async load(sessionId, cwd, mcpServers, model) {
-    await this.sdk.session.get({ sessionID: sessionId, directory: cwd }, { throwOnError: true });
+    const response = await this.sdk.session.get({ sessionID: sessionId, directory: cwd }, { throwOnError: true });
+    const session = response.data;
     const state = {
       id: sessionId,
       cwd,
@@ -19642,7 +19649,7 @@ var SessionManager = class {
       model
     };
     this.sessions.set(sessionId, state);
-    return state;
+    return { state, session };
   }
   /**
    * Auto-register a session discovered via SSE events.
@@ -20277,65 +20284,6 @@ function applyStructuredPatch(source, patch, options = {}) {
 
 // src/utils.ts
 var import_url = require("url");
-function toToolKind(toolName) {
-  const tool = toolName.toLowerCase();
-  switch (tool) {
-    case "bash":
-      return "execute";
-    case "webfetch":
-      return "fetch";
-    case "edit":
-    case "patch":
-    case "write":
-      return "edit";
-    case "grep":
-    case "glob":
-    case "context7_resolve_library_id":
-    case "context7_get_library_docs":
-      return "search";
-    case "list":
-    case "read":
-      return "read";
-    default:
-      return "other";
-  }
-}
-function toLocations(toolName, input) {
-  const tool = toolName.toLowerCase();
-  switch (tool) {
-    case "read":
-    case "edit":
-    case "write":
-      return input["filePath"] ? [{ path: input["filePath"] }] : [];
-    case "glob":
-    case "grep":
-      return input["path"] ? [{ path: input["path"] }] : [];
-    case "list":
-      return input["path"] ? [{ path: input["path"] }] : [];
-    default:
-      return [];
-  }
-}
-function parseUri(uri) {
-  try {
-    if (uri.startsWith("file://")) {
-      const path = uri.slice(7);
-      const name = path.split("/").pop() || path;
-      return { type: "file", url: uri, filename: name, mime: "text/plain" };
-    }
-    if (uri.startsWith("zed://")) {
-      const url2 = new URL(uri);
-      const path = url2.searchParams.get("path");
-      if (path) {
-        const name = path.split("/").pop() || path;
-        return { type: "file", url: (0, import_url.pathToFileURL)(path).href, filename: name, mime: "text/plain" };
-      }
-    }
-    return { type: "text", text: uri };
-  } catch {
-    return { type: "text", text: uri };
-  }
-}
 
 // src/logger.ts
 var import_fs = require("fs");
@@ -20401,49 +20349,97 @@ function sysLog(action, data) {
   write("system", action, data);
 }
 function sanitize(obj, depth = 0) {
-  if (!obj || depth > 2) return obj;
+  if (!obj) return obj;
+  if (depth > 5) return { __truncated__: true, __depth__: depth };
   const result = {};
   for (const [key, val] of Object.entries(obj)) {
     if (typeof val === "string" && val.length > 2e3) {
       result[key] = val.slice(0, 2e3) + `... [${val.length} chars total]`;
     } else if (val && typeof val === "object" && !Array.isArray(val)) {
       result[key] = sanitize(val, depth + 1);
+    } else if (val && Array.isArray(val)) {
+      result[key] = val.map(
+        (item) => typeof item === "string" && item.length > 2e3 ? item.slice(0, 2e3) + `... [${item.length} chars total]` : item && typeof item === "object" ? sanitize(item, depth + 1) : item
+      );
     } else {
       result[key] = val;
     }
   }
   return result;
 }
-function acpAssembled(action, data) {
-  if (!enabled) return;
-  const entry = {
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    cat: "acp.out",
-    action,
-    ...data && { data: sanitizeAssembled(data) }
-  };
-  try {
-    (0, import_fs.appendFileSync)(logFile, JSON.stringify(entry) + "\n");
-  } catch {
+
+// src/utils.ts
+function toToolKind(toolName) {
+  const tool = toolName.toLowerCase();
+  switch (tool) {
+    case "bash":
+      return "execute";
+    case "webfetch":
+      return "fetch";
+    case "edit":
+    case "patch":
+    case "write":
+      return "edit";
+    case "grep":
+    case "glob":
+    case "context7_resolve_library_id":
+    case "context7_get_library_docs":
+      return "search";
+    case "list":
+    case "read":
+      return "read";
+    default:
+      return "other";
   }
 }
-function sanitizeAssembled(obj, depth = 0) {
-  if (!obj || depth > 2) return obj;
-  const result = {};
-  for (const [key, val] of Object.entries(obj)) {
-    if (typeof val === "string" && val.length > 1e4) {
-      result[key] = val.slice(0, 1e4) + `... [${val.length} chars total]`;
-    } else if (val && typeof val === "object" && !Array.isArray(val)) {
-      result[key] = sanitizeAssembled(val, depth + 1);
-    } else {
-      result[key] = val;
+function toLocations(toolName, input) {
+  const tool = toolName.toLowerCase();
+  switch (tool) {
+    case "read":
+    case "edit":
+    case "write":
+      return input["filePath"] ? [{ path: input["filePath"] }] : [];
+    case "glob":
+    case "grep":
+      return input["path"] ? [{ path: input["path"] }] : [];
+    case "list":
+      return input["path"] ? [{ path: input["path"] }] : [];
+    default:
+      return [];
+  }
+}
+function parseUri(uri) {
+  try {
+    if (uri.startsWith("file://")) {
+      const path = uri.slice(7);
+      const name = path.split("/").pop() || path;
+      return { type: "file", url: uri, filename: name, mime: "text/plain" };
     }
+    if (uri.startsWith("zed://")) {
+      const url2 = new URL(uri);
+      const path = url2.searchParams.get("path");
+      if (path) {
+        const name = path.split("/").pop() || path;
+        return { type: "file", url: (0, import_url.pathToFileURL)(path).href, filename: name, mime: "text/plain" };
+      }
+    }
+    return { type: "text", text: uri };
+  } catch {
+    return { type: "text", text: uri };
   }
-  return result;
+}
+async function sendToClient(connection, params) {
+  const updateType = params.update.sessionUpdate;
+  const update = params.update;
+  acpOut(`sessionUpdate.${updateType}`, {
+    sessionId: params.sessionId.slice(0, 12),
+    ...updateType === "agent_message_chunk" || updateType === "agent_thought_chunk" ? { messageId: update.messageId?.slice(0, 12), delta: update.content?.text?.slice(0, 200) } : updateType === "tool_call" || updateType === "tool_call_update" ? { toolCallId: update.toolCallId, tool: update.title, kind: update.kind, status: update.status } : updateType === "session_info_update" ? { title: update.title, _meta: update._meta } : updateType === "usage_update" ? { used: update.used, size: update.size, cost: update.cost, _meta: update._meta } : {}
+  });
+  return connection.sessionUpdate(params);
 }
 
 // src/event-handler.ts
-var QUESTION_TIMEOUT_MS = 6e4;
+var QUESTION_TIMEOUT_MS = 3e5;
 var permissionOptions = [
   { optionId: "once", kind: "allow_once", name: "Allow once" },
   { optionId: "always", kind: "allow_always", name: "Always allow" },
@@ -20459,131 +20455,14 @@ var EventHandler = class {
   permissionQueues = /* @__PURE__ */ new Map();
   questionQueues = /* @__PURE__ */ new Map();
   started = false;
-  messageBuffers = /* @__PURE__ */ new Map();
-  /** Index: sessionId → Set<messageId> for O(1) flush lookup. */
-  sessionBufferIndex = /* @__PURE__ */ new Map();
-  messageMetaCache = /* @__PURE__ */ new Map();
+  /** partID → { type, ignored }, built from message.part.updated SSE events. */
+  partMetaIndex = /* @__PURE__ */ new Map();
   /** Track tool call counts per child session to detect completion. */
   childToolCounts = /* @__PURE__ */ new Map();
-  /**
-   * Wrapper around connection.sessionUpdate that logs what's sent to the ACP client.
-   * This is the single point where we record all outgoing traffic.
-   */
-  async sendToClient(params) {
-    const updateType = params.update.sessionUpdate;
-    if (updateType !== "agent_message_chunk" && updateType !== "agent_thought_chunk") {
-      this.flushMessageBuffer(params.sessionId, `boundary:${updateType}`);
-      acpOut(`sessionUpdate.${updateType}`, {
-        sessionId: params.sessionId.slice(0, 12),
-        ...updateType === "tool_call" || updateType === "tool_call_update" ? {
-          toolCallId: params.update.toolCallId,
-          tool: params.update.title,
-          kind: params.update.kind,
-          status: params.update.status
-        } : updateType === "session_info_update" ? {
-          title: params.update.title,
-          _meta: params.update._meta
-        } : {}
-      });
-    }
-    return this.connection.sessionUpdate(params);
-  }
-  /**
-   * Accumulate a text/thought delta into the message buffer.
-   * The buffer is flushed as a single log entry when a boundary event occurs
-   * (e.g. tool_call starts, new message, session change).
-   */
-  accumulateDelta(messageId, sessionId, kind, delta) {
-    let buf = this.messageBuffers.get(messageId);
-    if (!buf) {
-      buf = { sessionId, text: "", thought: "" };
-      this.messageBuffers.set(messageId, buf);
-      const msgSet = this.sessionBufferIndex.get(sessionId);
-      if (msgSet) {
-        msgSet.add(messageId);
-      } else {
-        this.sessionBufferIndex.set(sessionId, /* @__PURE__ */ new Set([messageId]));
-      }
-    }
-    buf[kind] += delta;
-  }
-  /**
-   * Flush accumulated message content for a given session as assembled log entries.
-   * Called when a boundary event (tool_call, session change, etc.) signals the
-   * text/thought phase is complete.
-   */
-  flushMessageBuffer(sessionId, reason) {
-    const msgIds = this.sessionBufferIndex.get(sessionId);
-    if (!msgIds) return;
-    for (const messageId of msgIds) {
-      const buf = this.messageBuffers.get(messageId);
-      if (!buf) continue;
-      if (!buf.text && !buf.thought) {
-        this.messageBuffers.delete(messageId);
-        continue;
-      }
-      if (buf.text) {
-        acpAssembled("sessionUpdate.agent_message_complete", {
-          sessionId: sessionId.slice(0, 12),
-          messageId: messageId.slice(0, 12),
-          length: buf.text.length,
-          text: buf.text,
-          flushReason: reason
-        });
-      }
-      if (buf.thought) {
-        acpAssembled("sessionUpdate.agent_thought_complete", {
-          sessionId: sessionId.slice(0, 12),
-          messageId: messageId.slice(0, 12),
-          length: buf.thought.length,
-          text: buf.thought,
-          flushReason: reason
-        });
-      }
-      this.messageBuffers.delete(messageId);
-    }
-    this.sessionBufferIndex.delete(sessionId);
-  }
-  /** Flush all remaining buffers (e.g. on stop) */
-  flushAllBuffers() {
-    for (const sessionId of this.sessionBufferIndex.keys()) {
-      this.flushMessageBuffer(sessionId, "stop");
-    }
-  }
-  /**
-   * Get or cache message metadata (role + parts) for a message.
-   * Fetches from SDK only on first delta for a message, then serves from cache.
-   */
-  async getOrCacheMessageMeta(sessionID, messageID, cwd) {
-    const cached2 = this.messageMetaCache.get(messageID);
-    if (cached2) return cached2;
-    const message = await this.sdk.session.message({ sessionID, messageID, directory: cwd }, { throwOnError: true }).then((x) => x.data).catch(() => void 0);
-    if (!message) return void 0;
-    const parts = /* @__PURE__ */ new Map();
-    for (const p of message.parts) {
-      parts.set(p.id, { type: p.type, ignored: p.ignored });
-    }
-    const meta3 = { role: message.info.role, parts };
-    this.messageMetaCache.set(messageID, meta3);
-    if (this.messageMetaCache.size > 50) {
-      const oldest = this.messageMetaCache.keys().next().value;
-      if (oldest) this.messageMetaCache.delete(oldest);
-    }
-    return meta3;
-  }
-  /**
-   * Flush previous message buffer for a session when messageId changes.
-   */
-  flushPreviousBuffer(sessionId, currentMessageId) {
-    const msgIds = this.sessionBufferIndex.get(sessionId);
-    if (!msgIds) return;
-    for (const messageId of msgIds) {
-      if (messageId !== currentMessageId) {
-        this.flushMessageBuffer(sessionId, "new_message");
-        return;
-      }
-    }
-  }
+  /** Cumulative file diff stats per session, aggregated from session.diff SSE events. */
+  fileDiffStats = /* @__PURE__ */ new Map();
+  /** AI code change stats per session, keyed by sessionId → filePath → { additions, deletions }. */
+  aiCodeChangeStats = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.connection = deps.connection;
     this.sdk = deps.sdk;
@@ -20598,7 +20477,6 @@ var EventHandler = class {
     });
   }
   stop() {
-    this.flushAllBuffers();
     this.abort.abort();
   }
   async runSubscription() {
@@ -20630,9 +20508,13 @@ var EventHandler = class {
   }
   // ─── Event Handling ──────────────────────────────────────────────
   async handleEvent(event) {
+    if (event.type === "server.heartbeat") {
+      return;
+    }
     switch (event.type) {
       case "session.created":
       case "session.updated": {
+        ocEvent(event.type, event);
         const props = event.properties;
         const info = props.info ?? props;
         const parentID = info.parentID;
@@ -20642,7 +20524,6 @@ var EventHandler = class {
         const isNew = !this.sessionManager.tryGet(id);
         this.sessionManager.registerDiscovered(id, parentID, title);
         if (isNew) {
-          ocEvent("session.created.child", { id, parentID, title });
           const agentMatch = title?.match(/@(\w+)\s+subagent/);
           const agentType = agentMatch?.[1];
           const description = title?.replace(/\s*\(@\w+\s+subagent\)\s*$/, "") ?? title;
@@ -20654,6 +20535,7 @@ var EventHandler = class {
         return;
       }
       case "permission.asked": {
+        ocEvent("permission.asked", event);
         const permission = event.properties;
         const resolved = this.resolveSession(permission.sessionID);
         if (!resolved) return;
@@ -20723,15 +20605,26 @@ var EventHandler = class {
       }
       case "question.asked": {
         const q = event.properties;
-        const resolved = this.resolveSession(q.sessionID);
-        if (!resolved) return;
+        ocEvent("question.asked", event);
+        let resolved = this.resolveSession(q.sessionID);
+        if (!resolved) {
+          console.warn(`[event-handler] question.asked: session ${q.sessionID} not in manager, attempting auto-register`);
+          try {
+            const sessionResp = await this.sdk.session.get({ sessionID: q.sessionID, directory: "" });
+            const fetchedSession = sessionResp.data;
+            if (fetchedSession?.parentID) {
+              this.sessionManager.registerDiscovered(fetchedSession.id, fetchedSession.parentID, fetchedSession.title);
+              resolved = this.resolveSession(q.sessionID);
+            } else if (fetchedSession) {
+              console.warn(`[event-handler] question.asked: top-level session ${q.sessionID} not registered; was agent.newSession called?`);
+            }
+          } catch (err) {
+            console.error(`[event-handler] question.asked: failed to fetch session ${q.sessionID}:`, err);
+          }
+          if (!resolved) return;
+        }
         const directory = resolved.cwd;
         const sessionId = resolved.sessionId;
-        ocEvent("question.asked", {
-          id: q.id,
-          sessionID: q.sessionID,
-          questions: q.questions.length
-        });
         const prev = this.questionQueues.get(q.sessionID) ?? Promise.resolve();
         const next = prev.then(async () => {
           const extResult = await Promise.race([
@@ -20751,7 +20644,7 @@ var EventHandler = class {
           if (!extResult || !extResult.answers) {
             await this.sdk.question.reject({ requestID: q.id, directory }).catch(() => {
             });
-            ocEvent("question.rejected", { requestID: q.id });
+            sysLog("question.rejected", { requestID: q.id });
             return;
           }
           const answers = extResult.answers;
@@ -20759,7 +20652,7 @@ var EventHandler = class {
             console.error("[event-handler] invalid answers shape from client:", JSON.stringify(answers));
             await this.sdk.question.reject({ requestID: q.id, directory }).catch(() => {
             });
-            ocEvent("question.rejected", {
+            sysLog("question.rejected", {
               requestID: q.id,
               reason: "invalid_answers"
             });
@@ -20770,7 +20663,7 @@ var EventHandler = class {
             directory,
             answers
           });
-          ocEvent("question.reply", { requestID: q.id, answers });
+          sysLog("question.reply", { requestID: q.id, answers });
         }).catch((err) => {
           console.error("[event-handler] question handling error:", err);
         }).finally(() => {
@@ -20782,28 +20675,40 @@ var EventHandler = class {
         return;
       }
       case "message.part.updated": {
+        ocEvent("message.part.updated", event);
         const props = event.properties;
         const part = props.part;
+        if (part.id) {
+          this.partMetaIndex.set(part.id, { type: part.type, ignored: part.ignored });
+        }
         const resolved = this.resolveSession(part.sessionID);
         if (!resolved) return;
         if (part.type === "tool") {
           await this.handleToolPart(resolved.sessionId, part);
         }
+        if (part.type === "text" && typeof part.text === "string" && part.ignored === true) {
+          await sendToClient(this.connection, {
+            sessionId: resolved.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              messageId: part.messageID,
+              content: { type: "text", text: part.text }
+            }
+          }).catch(() => {
+          });
+        }
         return;
       }
       case "message.part.delta": {
+        ocEvent("message.part.delta", event);
         const props = event.properties;
         const resolved = this.resolveSession(props.sessionID);
         if (!resolved) return;
         const sessionId = resolved.sessionId;
-        this.flushPreviousBuffer(sessionId, props.messageID);
-        const meta3 = await this.getOrCacheMessageMeta(props.sessionID, props.messageID, resolved.cwd);
-        if (!meta3 || meta3.role !== "assistant") return;
-        const partMeta = meta3.parts.get(props.partID);
+        const partMeta = this.partMetaIndex.get(props.partID);
         if (!partMeta) return;
         if (partMeta.type === "text" && props.field === "text" && partMeta.ignored !== true) {
-          this.accumulateDelta(props.messageID, sessionId, "text", props.delta);
-          await this.sendToClient({
+          await sendToClient(this.connection, {
             sessionId,
             update: {
               sessionUpdate: "agent_message_chunk",
@@ -20815,8 +20720,7 @@ var EventHandler = class {
           return;
         }
         if (partMeta.type === "reasoning" && props.field === "text") {
-          this.accumulateDelta(props.messageID, sessionId, "thought", props.delta);
-          await this.sendToClient({
+          await sendToClient(this.connection, {
             sessionId,
             update: {
               sessionUpdate: "agent_thought_chunk",
@@ -20828,6 +20732,25 @@ var EventHandler = class {
         }
         return;
       }
+      case "session.diff": {
+        ocEvent("session.diff", event);
+        const { sessionID, diff } = event.properties;
+        const resolved = this.resolveSession(sessionID);
+        if (!resolved) {
+          return;
+        }
+        let additions = 0;
+        let deletions = 0;
+        for (const d of diff) {
+          additions += d.additions;
+          deletions += d.deletions;
+        }
+        this.fileDiffStats.set(resolved.sessionId, { additions, deletions, files: diff.length });
+        return;
+      }
+      default: {
+        return;
+      }
     }
   }
   // ─── Child Session Announcement ──────────────────────────────────
@@ -20838,7 +20761,7 @@ var EventHandler = class {
    * and _meta containing structured metadata about the subagent.
    */
   async announceChildSession(childSessionId, parentSessionId, title, meta3) {
-    await this.sendToClient({
+    await sendToClient(this.connection, {
       sessionId: childSessionId,
       update: {
         sessionUpdate: "session_info_update",
@@ -20871,7 +20794,7 @@ var EventHandler = class {
           });
         }
       }
-      await this.sendToClient({
+      await sendToClient(this.connection, {
         sessionId,
         update: {
           sessionUpdate: "tool_call",
@@ -20903,7 +20826,7 @@ var EventHandler = class {
             content: { type: "text", text: output }
           });
         }
-        await this.sendToClient({
+        await sendToClient(this.connection, {
           sessionId,
           update: {
             sessionUpdate: "tool_call_update",
@@ -20956,12 +20879,13 @@ var EventHandler = class {
           const oldText = typeof input["oldString"] === "string" ? input["oldString"] : "";
           const newText = typeof input["newString"] === "string" ? input["newString"] : typeof input["content"] === "string" ? input["content"] : "";
           content.push({ type: "diff", path: filePath, oldText, newText });
+          this.accumulateAICodeChangeStats(sessionId, part);
         }
         if (part.tool === "todowrite") {
           try {
             const todos = JSON.parse(part.state.output);
             if (Array.isArray(todos)) {
-              await this.sendToClient({
+              await sendToClient(this.connection, {
                 sessionId,
                 update: {
                   sessionUpdate: "plan",
@@ -20977,7 +20901,7 @@ var EventHandler = class {
           } catch {
           }
         }
-        await this.sendToClient({
+        await sendToClient(this.connection, {
           sessionId,
           update: {
             sessionUpdate: "tool_call_update",
@@ -20999,7 +20923,7 @@ var EventHandler = class {
       case "error": {
         this.toolStarts.delete(part.callID);
         this.bashSnapshots.delete(part.callID);
-        await this.sendToClient({
+        await sendToClient(this.connection, {
           sessionId,
           update: {
             sessionUpdate: "tool_call_update",
@@ -21034,7 +20958,7 @@ var EventHandler = class {
     const agentMatch = title.match(/@(\w+)\s+subagent/);
     const agentType = agentMatch?.[1];
     const description = title.replace(/\s*\(@\w+\s+subagent\)\s*$/, "");
-    await this.sendToClient({
+    await sendToClient(this.connection, {
       sessionId: childSessionId,
       update: {
         sessionUpdate: "session_info_update",
@@ -21058,6 +20982,44 @@ var EventHandler = class {
     if (typeof output !== "string") return;
     return output;
   }
+  // ─── Statistics Accessors ────────────────────────────────────────
+  getFileDiffStats(sessionId) {
+    return this.fileDiffStats.get(sessionId);
+  }
+  setFileDiffStats(sessionId, stats) {
+    if (this.fileDiffStats.has(sessionId)) return;
+    this.fileDiffStats.set(sessionId, stats);
+  }
+  /**
+   * Accumulate AI code change stats from a completed tool part's metadata.
+   * The harmony-code plugin injects `metadata.aiCodeChange` for edit/write tools.
+   */
+  accumulateAICodeChangeStats(sessionId, part) {
+    if (part.state.status !== "completed") return;
+    const meta3 = part.state.metadata ?? {};
+    const aiCodeChange = meta3["aiCodeChange"];
+    if (!aiCodeChange || aiCodeChange.additions === 0 && aiCodeChange.deletions === 0) return;
+    const fileMap = this.aiCodeChangeStats.get(sessionId) ?? /* @__PURE__ */ new Map();
+    const existing = fileMap.get(aiCodeChange.file) ?? { additions: 0, deletions: 0 };
+    fileMap.set(aiCodeChange.file, {
+      additions: existing.additions + aiCodeChange.additions,
+      deletions: existing.deletions + aiCodeChange.deletions
+    });
+    if (!this.aiCodeChangeStats.has(sessionId)) {
+      this.aiCodeChangeStats.set(sessionId, fileMap);
+    }
+  }
+  getAICodeChangeStats(sessionId) {
+    const fileMap = this.aiCodeChangeStats.get(sessionId);
+    if (!fileMap || fileMap.size === 0) return void 0;
+    let additions = 0;
+    let deletions = 0;
+    for (const stats of fileMap.values()) {
+      additions += stats.additions;
+      deletions += stats.deletions;
+    }
+    return { additions, deletions, files: fileMap.size };
+  }
 };
 function simpleHash(str) {
   let hash2 = 0;
@@ -21068,6 +21030,49 @@ function simpleHash(str) {
   return hash2.toString(36);
 }
 
+// src/mcp-manager.ts
+var THROW = { throwOnError: true };
+var McpManager = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  async status(directory) {
+    ocCall("mcp.status", { directory });
+    const result = await this.sdk.mcp.status({ directory });
+    return result.data ?? {};
+  }
+  async add(directory, name, config2) {
+    ocCall("mcp.add", { directory, name });
+    const result = await this.sdk.mcp.add({ directory, name, config: config2 }, THROW);
+    return result.data ?? {};
+  }
+  async connect(directory, name) {
+    ocCall("mcp.connect", { directory, name });
+    await this.sdk.mcp.connect({ name, directory }, THROW);
+    return { success: true };
+  }
+  async disconnect(directory, name) {
+    ocCall("mcp.disconnect", { directory, name });
+    await this.sdk.mcp.disconnect({ name, directory }, THROW);
+    return { success: true };
+  }
+  async startAuth(directory, name) {
+    ocCall("mcp.auth.start", { directory, name });
+    const result = await this.sdk.mcp.auth.start({ name, directory }, THROW);
+    return result.data ?? {};
+  }
+  async callbackAuth(directory, name, code) {
+    ocCall("mcp.auth.callback", { directory, name });
+    const result = await this.sdk.mcp.auth.callback({ name, directory, code }, THROW);
+    return result.data ?? {};
+  }
+  async removeAuth(directory, name) {
+    ocCall("mcp.auth.remove", { directory, name });
+    await this.sdk.mcp.auth.remove({ name, directory }, THROW);
+    return { success: true };
+  }
+};
+
 // src/auth-provider.ts
 var AuthProviderManager = class {
   sdk;
@@ -21117,29 +21122,13 @@ var Agent = class {
   sessionManager;
   eventHandler;
   authProvider;
-  /**
-   * Wrapper around connection.sessionUpdate that logs what's sent to the ACP client.
-   */
-  async sendToClient(params) {
-    const updateType = params.update.sessionUpdate;
-    if (updateType !== "agent_message_chunk" && updateType !== "agent_thought_chunk") {
-      acpOut(`sessionUpdate.${updateType}`, {
-        sessionId: params.sessionId.slice(0, 12),
-        ...updateType === "tool_call" || updateType === "tool_call_update" ? {
-          toolCallId: params.update.toolCallId,
-          tool: params.update.title,
-          kind: params.update.kind,
-          status: params.update.status
-        } : {}
-      });
-    }
-    return this.connection.sessionUpdate(params);
-  }
+  mcpManager;
   constructor(config2) {
     this.config = config2;
     this.sdk = config2.sdk;
     this.sessionManager = new SessionManager(config2.sdk);
     this.authProvider = new AuthProviderManager(config2.sdk);
+    this.mcpManager = new McpManager(config2.sdk);
   }
   init(connection) {
     this.connection = connection;
@@ -21189,10 +21178,13 @@ var Agent = class {
   // ─── Extension Methods ────────────────────────────────────────────
   async extMethod(method, params) {
     acpIn("extMethod", { method });
-    if (!method.startsWith("provider/")) {
-      throw new Error(`Unknown extMethod: ${method}`);
+    if (method.startsWith("provider/")) {
+      return this.handleProviderMethod(method, params);
     }
-    return this.handleProviderMethod(method, params);
+    if (method.startsWith("mcp/")) {
+      return this.handleMcpMethod(method, params);
+    }
+    throw new Error(`Unknown extMethod: ${method}`);
   }
   async handleProviderMethod(method, params) {
     const sessionId = params.sessionId;
@@ -21248,6 +21240,67 @@ var Agent = class {
         throw new Error(`Unknown provider extMethod: ${method}`);
     }
   }
+  async handleMcpMethod(method, params) {
+    const sessionId = params.sessionId;
+    if (!sessionId) throw new Error("sessionId required");
+    const directory = this.sessionManager.get(sessionId)?.cwd;
+    if (!directory) throw new Error("Session not found");
+    switch (method) {
+      case "mcp/status": {
+        const data = await this.mcpManager.status(directory);
+        acpOut("extMethod.response", { method: "mcp/status" });
+        return data;
+      }
+      case "mcp/add": {
+        const name = params.name;
+        const config2 = params.config;
+        if (!name) throw new Error("Missing required parameter: name");
+        if (!config2) throw new Error("Missing required parameter: config");
+        const data = await this.mcpManager.add(directory, name, config2);
+        acpOut("extMethod.response", { method: "mcp/add", name });
+        return data;
+      }
+      case "mcp/connect": {
+        const name = params.name;
+        if (!name) throw new Error("Missing required parameter: name");
+        const data = await this.mcpManager.connect(directory, name);
+        acpOut("extMethod.response", { method: "mcp/connect", name });
+        return data;
+      }
+      case "mcp/disconnect": {
+        const name = params.name;
+        if (!name) throw new Error("Missing required parameter: name");
+        const data = await this.mcpManager.disconnect(directory, name);
+        acpOut("extMethod.response", { method: "mcp/disconnect", name });
+        return data;
+      }
+      case "mcp/auth/start": {
+        const name = params.name;
+        if (!name) throw new Error("Missing required parameter: name");
+        const data = await this.mcpManager.startAuth(directory, name);
+        acpOut("extMethod.response", { method: "mcp/auth/start", name });
+        return data;
+      }
+      case "mcp/auth/callback": {
+        const name = params.name;
+        const code = params.code;
+        if (!name) throw new Error("Missing required parameter: name");
+        if (!code) throw new Error("Missing required parameter: code");
+        const data = await this.mcpManager.callbackAuth(directory, name, code);
+        acpOut("extMethod.response", { method: "mcp/auth/callback", name });
+        return data;
+      }
+      case "mcp/auth/remove": {
+        const name = params.name;
+        if (!name) throw new Error("Missing required parameter: name");
+        const data = await this.mcpManager.removeAuth(directory, name);
+        acpOut("extMethod.response", { method: "mcp/auth/remove", name });
+        return data;
+      }
+      default:
+        throw new Error(`Unknown MCP method: ${method}`);
+    }
+  }
   async buildProviderMeta() {
     try {
       const data = await this.authProvider.listProviders(this.config.cwd);
@@ -21290,11 +21343,19 @@ var Agent = class {
     }
   }
   async loadSession(params) {
+    acpIn("loadSession", { sessionId: params.sessionId, cwd: params.cwd });
     try {
       const directory = params.cwd;
       const sessionId = params.sessionId;
       const model = await this.defaultModel(directory);
-      await this.sessionManager.load(sessionId, params.cwd, params.mcpServers, model);
+      const { session } = await this.sessionManager.load(sessionId, params.cwd, params.mcpServers, model);
+      if (session.summary) {
+        this.eventHandler.setFileDiffStats(sessionId, {
+          additions: session.summary.additions,
+          deletions: session.summary.deletions,
+          files: session.summary.files
+        });
+      }
       const result = await this.loadSessionMode({
         cwd: directory,
         mcpServers: params.mcpServers,
@@ -21330,6 +21391,7 @@ var Agent = class {
     }
   }
   async listSessions(params) {
+    acpIn("listSessions", { cwd: params.cwd, cursor: params.cursor });
     const limit = 100;
     const cursor = params.cursor ? Number(params.cursor) : void 0;
     const sessions = await this.sdk.session.list({ directory: params.cwd ?? void 0, roots: true }).then((x) => x.data ?? []);
@@ -21346,9 +21408,11 @@ var Agent = class {
     const next = filtered.length > limit && last ? String(last.time.updated) : void 0;
     const response = { sessions: entries };
     if (next) response.nextCursor = next;
+    acpOut("listSessions.response", { count: entries.length, hasNext: !!next });
     return response;
   }
   async unstable_forkSession(params) {
+    acpIn("forkSession", { sessionId: params.sessionId, cwd: params.cwd });
     try {
       const directory = params.cwd;
       const mcpServers = params.mcpServers ?? [];
@@ -21374,12 +21438,20 @@ var Agent = class {
     }
   }
   async unstable_resumeSession(params) {
+    acpIn("resumeSession", { sessionId: params.sessionId, cwd: params.cwd });
     try {
       const directory = params.cwd;
       const sessionId = params.sessionId;
       const mcpServers = params.mcpServers ?? [];
       const model = await this.defaultModel(directory);
-      await this.sessionManager.load(sessionId, directory, mcpServers, model);
+      const { session } = await this.sessionManager.load(sessionId, directory, mcpServers, model);
+      if (session.summary) {
+        this.eventHandler.setFileDiffStats(sessionId, {
+          additions: session.summary.additions,
+          deletions: session.summary.deletions,
+          files: session.summary.files
+        });
+      }
       const result = await this.loadSessionMode({
         cwd: directory,
         mcpServers,
@@ -21419,6 +21491,16 @@ var Agent = class {
         agent,
         directory
       });
+      const rawErr = response2.error;
+      ocCall("session.prompt.raw", {
+        hasData: !!response2.data,
+        hasError: !!rawErr,
+        errorName: rawErr?.name,
+        errorMessage: rawErr?.message,
+        errorCode: rawErr?.code ?? rawErr?.cause?.code,
+        errorCauseName: rawErr?.cause?.name,
+        errorCauseMessage: rawErr?.cause?.message
+      });
       const msg2 = response2.data?.info;
       ocCall("session.prompt.response", {
         messageId: msg2?.id,
@@ -21505,6 +21587,7 @@ var Agent = class {
   }
   // ─── Configuration ────────────────────────────────────────────────
   async setSessionMode(params) {
+    acpIn("setSessionMode", { sessionId: params.sessionId, modeId: params.modeId });
     const session = this.sessionManager.get(params.sessionId);
     const agents = await this.sdk.app.agents({ directory: session.cwd }).then((x) => x.data ?? []).catch(() => []);
     const availableModes = agents.filter((a) => a.mode !== "subagent" && !a.hidden);
@@ -21514,6 +21597,7 @@ var Agent = class {
     this.sessionManager.setMode(params.sessionId, params.modeId);
   }
   async unstable_setSessionModel(params) {
+    acpIn("setSessionModel", { sessionId: params.sessionId, modelId: params.modelId });
     const session = this.sessionManager.get(params.sessionId);
     const providers = await this.sdk.config.providers({ directory: session.cwd }).then((x) => x.data?.providers ?? []).catch(() => []);
     const selection = parseModelSelection(params.modelId, providers);
@@ -21527,6 +21611,7 @@ var Agent = class {
     };
   }
   async setSessionConfigOption(params) {
+    acpIn("setSessionConfigOption", { sessionId: params.sessionId, configId: params.configId, value: params.value });
     const session = this.sessionManager.get(params.sessionId);
     const providers = await this.sdk.config.providers({ directory: session.cwd }).then((x) => x.data?.providers ?? []).catch(() => []);
     const sortedProviders = [...providers].sort(
@@ -21612,7 +21697,7 @@ var Agent = class {
     if (!childMessages?.length) return;
     const title = `Subagent (${childSessionId.slice(0, 8)})`;
     this.sessionManager.registerDiscovered(childSessionId, parentSessionId, title);
-    await this.sendToClient({
+    await sendToClient(this.connection, {
       sessionId: childSessionId,
       update: {
         sessionUpdate: "session_info_update",
@@ -21716,7 +21801,7 @@ var Agent = class {
             {}
           )
         };
-        await this.sdk.mcp.add({ directory: params.cwd, name: server.name, config: config2 }).catch(() => {
+        await this.mcpManager.add(params.cwd, server.name, config2).catch(() => {
         });
       })
     );
@@ -21729,7 +21814,7 @@ var Agent = class {
       availableCommands.push({ name: "compact", description: "compact the session" });
     }
     setTimeout(() => {
-      this.sendToClient({
+      sendToClient(this.connection, {
         sessionId: params.sessionId,
         update: {
           sessionUpdate: "available_commands_update",
@@ -21782,7 +21867,7 @@ var Agent = class {
         await this.replayToolPart(sessionId, part);
       } else if (part.type === "text" && part.text) {
         const audience = part.synthetic ? ["assistant"] : part.ignored ? ["user"] : void 0;
-        await this.sendToClient({
+        await sendToClient(this.connection, {
           sessionId,
           update: {
             sessionUpdate: messageChunk,
@@ -21800,7 +21885,7 @@ var Agent = class {
         const filename = part.filename ?? "file";
         const mime = part.mime || "application/octet-stream";
         if (url2.startsWith("file://")) {
-          await this.sendToClient({
+          await sendToClient(this.connection, {
             sessionId,
             update: {
               sessionUpdate: messageChunk,
@@ -21815,7 +21900,7 @@ var Agent = class {
           const base64Data = base64Match?.[2] ?? "";
           const effectiveMime = dataMime || mime;
           if (effectiveMime.startsWith("image/")) {
-            await this.sendToClient({
+            await sendToClient(this.connection, {
               sessionId,
               update: {
                 sessionUpdate: messageChunk,
@@ -21837,7 +21922,7 @@ var Agent = class {
               mimeType: effectiveMime,
               text: Buffer.from(base64Data, "base64").toString("utf-8")
             } : { uri: fileUri, mimeType: effectiveMime, blob: base64Data };
-            await this.sendToClient({
+            await sendToClient(this.connection, {
               sessionId,
               update: {
                 sessionUpdate: messageChunk,
@@ -21849,7 +21934,7 @@ var Agent = class {
           }
         }
       } else if (part.type === "reasoning" && part.text) {
-        await this.sendToClient({
+        await sendToClient(this.connection, {
           sessionId,
           update: {
             sessionUpdate: "agent_thought_chunk",
@@ -21862,7 +21947,7 @@ var Agent = class {
     }
   }
   async replayToolPart(sessionId, part) {
-    await this.sendToClient({
+    await sendToClient(this.connection, {
       sessionId,
       update: {
         sessionUpdate: "tool_call",
@@ -21887,12 +21972,13 @@ var Agent = class {
             oldText: typeof input["oldString"] === "string" ? input["oldString"] : "",
             newText: typeof input["newString"] === "string" ? input["newString"] : typeof input["content"] === "string" ? input["content"] : ""
           });
+          this.eventHandler.accumulateAICodeChangeStats(sessionId, part);
         }
         if (part.tool === "todowrite") {
           try {
             const todos = JSON.parse(part.state.output);
             if (Array.isArray(todos)) {
-              await this.sendToClient({
+              await sendToClient(this.connection, {
                 sessionId,
                 update: {
                   sessionUpdate: "plan",
@@ -21908,7 +21994,7 @@ var Agent = class {
           } catch {
           }
         }
-        await this.sendToClient({
+        await sendToClient(this.connection, {
           sessionId,
           update: {
             sessionUpdate: "tool_call_update",
@@ -21925,7 +22011,7 @@ var Agent = class {
         break;
       }
       case "error":
-        await this.sendToClient({
+        await sendToClient(this.connection, {
           sessionId,
           update: {
             sessionUpdate: "tool_call_update",
@@ -21965,24 +22051,76 @@ var Agent = class {
     const provider = providers.find((p) => p.id === msg.providerID);
     const model = provider?.models[msg.modelID];
     const size = model?.limit?.context ?? 0;
-    await this.sendToClient({
+    const _meta = {};
+    if (childCost > 0) {
+      _meta.parentCost = totalCost;
+      _meta.childCost = childCost;
+      _meta.childSessionCount = children.length;
+    }
+    this.aggregateFileDiffStats(sessionId, children, _meta);
+    this.aggregateAICodeChangeStats(sessionId, children, _meta);
+    await sendToClient(this.connection, {
       sessionId,
       update: {
         sessionUpdate: "usage_update",
         used: msg.tokens.input + (msg.tokens.cache?.read ?? 0),
         size,
         cost: { amount: totalCost + childCost, currency: "USD" },
-        ...childCost > 0 && {
-          _meta: {
-            parentCost: totalCost,
-            childCost,
-            childSessionCount: children.length
-          }
-        }
+        ...Object.keys(_meta).length > 0 && { _meta }
       }
     }).catch(() => {
     });
   }
+  /**
+   * Aggregate file diff stats (git-based) for parent + child sessions into _meta.
+   * 主 session 的 session.diff 已包含子任务的变更数据，直接使用，不累加子 session。
+   */
+  aggregateFileDiffStats(sessionId, children, _meta) {
+    const stats = this.eventHandler.getFileDiffStats(sessionId);
+    let childFileDiffStats;
+    for (const childId of children) {
+      const cs = this.eventHandler.getFileDiffStats(childId);
+      if (cs) {
+        childFileDiffStats = childFileDiffStats ? {
+          additions: childFileDiffStats.additions + cs.additions,
+          deletions: childFileDiffStats.deletions + cs.deletions,
+          files: childFileDiffStats.files + cs.files
+        } : { ...cs };
+      }
+    }
+    const totalFileDiffStats = stats ?? childFileDiffStats;
+    if (totalFileDiffStats) {
+      _meta.fileDiffStats = totalFileDiffStats;
+    }
+    if (childFileDiffStats) {
+      _meta.childFileDiffStats = childFileDiffStats;
+    }
+  }
+  /**
+   * Aggregate AI code change stats (tool-based) for parent + child sessions into _meta.
+   */
+  aggregateAICodeChangeStats(sessionId, children, _meta) {
+    const parentStats = this.eventHandler.getAICodeChangeStats(sessionId);
+    let childAICodeChangeStats;
+    for (const childId of children) {
+      const cs = this.eventHandler.getAICodeChangeStats(childId);
+      if (cs) {
+        childAICodeChangeStats = childAICodeChangeStats ? {
+          additions: childAICodeChangeStats.additions + cs.additions,
+          deletions: childAICodeChangeStats.deletions + cs.deletions,
+          files: childAICodeChangeStats.files + cs.files
+        } : { ...cs };
+      }
+    }
+    const totalAICodeChangeStats = parentStats ? childAICodeChangeStats ? {
+      additions: parentStats.additions + childAICodeChangeStats.additions,
+      deletions: parentStats.deletions + childAICodeChangeStats.deletions,
+      files: parentStats.files + childAICodeChangeStats.files
+    } : parentStats : childAICodeChangeStats;
+    if (totalAICodeChangeStats) {
+      _meta.aiCodeChange = totalAICodeChangeStats;
+    }
+  }
   convertPromptParts(parts) {
     const result = [];
     for (const part of parts) {
@@ -22045,33 +22183,13 @@ var Agent = class {
     return { name, args: rest.join(" ").trim() };
   }
   /**
-   * Fetch the complete message content after prompt returns and log it.
-   * This ensures the response text is always captured in logs, even if
-   * SSE delta events arrive out of sync or are missed.
+   * Fetch the complete message content after prompt returns and log tool usage.
    */
   async logMessageContent(sessionId, messageId, directory) {
     if (!messageId) return;
     const message = await this.sdk.session.message({ sessionID: sessionId, messageID: messageId, directory }).then((x) => x.data).catch(() => void 0);
     if (!message) return;
     for (const part of message.parts) {
-      if (part.type === "text" && part.text) {
-        acpAssembled("sessionUpdate.agent_message_complete", {
-          sessionId: sessionId.slice(0, 12),
-          messageId: messageId.slice(0, 12),
-          length: part.text.length,
-          text: part.text,
-          flushReason: "prompt_complete"
-        });
-      }
-      if (part.type === "reasoning" && part.text) {
-        acpAssembled("sessionUpdate.agent_thought_complete", {
-          sessionId: sessionId.slice(0, 12),
-          messageId: messageId.slice(0, 12),
-          length: part.text.length,
-          text: part.text,
-          flushReason: "prompt_complete"
-        });
-      }
       if (part.type === "tool") {
         ocCall("session.prompt.tool", {
           sessionId: sessionId.slice(0, 12),
@@ -22128,6 +22246,91 @@ function parseModelSelection(modelId, providers) {
 }
 
 // src/index.ts
+var nativeFetch = (input, init) => {
+  return new Promise((resolve, reject) => {
+    let url2;
+    let requestMethod;
+    let requestHeaders;
+    let requestBody = null;
+    if (typeof input === "string") {
+      url2 = new URL(input);
+    } else if (input instanceof URL) {
+      url2 = input;
+    } else {
+      url2 = new URL(input.url);
+      requestMethod = input.method;
+      requestHeaders = input.headers;
+      requestBody = input.body;
+    }
+    const method = (init?.method ?? requestMethod ?? "GET").toUpperCase();
+    const mergedHeaders = new Headers(init?.headers ?? requestHeaders ?? void 0);
+    const headerObj = {};
+    mergedHeaders.forEach((value, key) => {
+      headerObj[key] = value;
+    });
+    const body = init?.body !== void 0 ? init.body : requestBody;
+    const signal = init?.signal;
+    if (signal?.aborted) {
+      return reject(
+        signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted.", "AbortError")
+      );
+    }
+    const mod = url2.protocol === "https:" ? https : http;
+    const req = mod.request(
+      url2,
+      {
+        method,
+        headers: headerObj
+        // Note: do NOT set `timeout` here. Leaving it unset means
+        // node:http will not apply any inactivity-based abort.
+      },
+      (res) => {
+        const respHeaders = new Headers();
+        for (const [k, v] of Object.entries(res.headers)) {
+          if (v == null) continue;
+          if (Array.isArray(v)) {
+            for (const item of v) respHeaders.append(k, item);
+          } else {
+            respHeaders.set(k, String(v));
+          }
+        }
+        const webStream = import_node_stream.Readable.toWeb(res);
+        resolve(
+          new Response(webStream, {
+            status: res.statusCode ?? 200,
+            statusText: res.statusMessage ?? "",
+            headers: respHeaders
+          })
+        );
+      }
+    );
+    req.on("error", reject);
+    if (signal) {
+      signal.addEventListener(
+        "abort",
+        () => {
+          req.destroy(
+            signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted.", "AbortError")
+          );
+        },
+        { once: true }
+      );
+    }
+    if (body == null) {
+      req.end();
+    } else if (typeof body === "string") {
+      req.end(body);
+    } else if (body instanceof Uint8Array || Buffer.isBuffer(body)) {
+      req.end(body);
+    } else if (body instanceof URLSearchParams) {
+      req.end(body.toString());
+    } else if (typeof body.pipeTo === "function") {
+      import_node_stream.Readable.fromWeb(body).pipe(req);
+    } else {
+      req.end(String(body));
+    }
+  });
+};
 function parseArgs(args) {
   let server = "http://localhost:4096";
   let cwd = process.cwd();
@@ -22167,7 +22370,10 @@ async function main() {
   initLogger();
   if (log) setLogEnabled(true);
   sysLog("starting", { server, cwd });
-  const sdk = createOpencodeClient({ baseUrl: server });
+  const sdk = createOpencodeClient({
+    baseUrl: server,
+    fetch: nativeFetch
+  });
   try {
     await sdk.global.health();
     sysLog("server_connected");