@harmonyos-arkts/opencode-acp 0.0.3 → 0.0.4

package/dist/index.cjs

@@ -19631,9 +19631,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 +19644,7 @@ var SessionManager = class {
       model
     };
     this.sessions.set(sessionId, state);
-    return state;
+    return { state, session };
   }
   /**
    * Auto-register a session discovered via SSE events.
@@ -20401,7 +20403,7 @@ function sysLog(action, data) {
   write("system", action, data);
 }
 function sanitize(obj, depth = 0) {
-  if (!obj || depth > 2) return obj;
+  if (!obj || depth > 5) return obj;
   const result = {};
   for (const [key, val] of Object.entries(obj)) {
     if (typeof val === "string" && val.length > 2e3) {
@@ -20414,33 +20416,6 @@ function sanitize(obj, depth = 0) {
   }
   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 {
-  }
-}
-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;
-    }
-  }
-  return result;
-}
 
 // src/event-handler.ts
 var QUESTION_TIMEOUT_MS = 6e4;
@@ -20459,130 +20434,31 @@ 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();
+  /** Cumulative code change stats per session, aggregated from session.diff SSE events. */
+  diffStats = /* @__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.
+   * Wrapper around connection.sessionUpdate that logs ALL outgoing traffic to the ACP client.
+   * Every call here corresponds to a real message sent over the wire.
    */
   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
-        } : {}
-      });
-    }
+    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 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;
+  getDiffStats(sessionId) {
+    return this.diffStats.get(sessionId);
   }
-  /**
-   * 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;
-      }
-    }
+  setDiffStats(sessionId, stats) {
+    if (this.diffStats.has(sessionId)) return;
+    this.diffStats.set(sessionId, stats);
   }
   constructor(deps) {
     this.connection = deps.connection;
@@ -20598,7 +20474,6 @@ var EventHandler = class {
     });
   }
   stop() {
-    this.flushAllBuffers();
     this.abort.abort();
   }
   async runSubscription() {
@@ -20630,9 +20505,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 +20521,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 +20532,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;
@@ -20782,27 +20661,39 @@ 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 this.sendToClient({
+            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({
             sessionId,
             update: {
@@ -20815,7 +20706,6 @@ var EventHandler = class {
           return;
         }
         if (partMeta.type === "reasoning" && props.field === "text") {
-          this.accumulateDelta(props.messageID, sessionId, "thought", props.delta);
           await this.sendToClient({
             sessionId,
             update: {
@@ -20828,6 +20718,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.diffStats.set(resolved.sessionId, { additions, deletions, files: diff.length });
+        return;
+      }
+      default: {
+        return;
+      }
     }
   }
   // ─── Child Session Announcement ──────────────────────────────────
@@ -21034,6 +20943,7 @@ var EventHandler = class {
     const agentMatch = title.match(/@(\w+)\s+subagent/);
     const agentType = agentMatch?.[1];
     const description = title.replace(/\s*\(@\w+\s+subagent\)\s*$/, "");
+    const childDiffStats = this.diffStats.get(childSessionId);
     await this.sendToClient({
       sessionId: childSessionId,
       update: {
@@ -21046,7 +20956,8 @@ var EventHandler = class {
           toolCallCount,
           durationMs,
           ...agentType && { agentType },
-          ...description && { description }
+          ...description && { description },
+          ...childDiffStats && { codeChange: childDiffStats }
         }
       }
     });
@@ -21068,6 +20979,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,22 +21071,30 @@ var Agent = class {
   sessionManager;
   eventHandler;
   authProvider;
+  mcpManager;
   /**
    * 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
-        } : {}
-      });
-    }
+    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 === "usage_update" ? {
+        used: update.used,
+        size: update.size,
+        cost: update.cost,
+        _meta: update._meta
+      } : {}
+    });
     return this.connection.sessionUpdate(params);
   }
   constructor(config2) {
@@ -21140,6 +21102,7 @@ var Agent = class {
     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 +21152,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);
+    }
+    if (method.startsWith("mcp/")) {
+      return this.handleMcpMethod(method, params);
     }
-    return this.handleProviderMethod(method, params);
+    throw new Error(`Unknown extMethod: ${method}`);
   }
   async handleProviderMethod(method, params) {
     const sessionId = params.sessionId;
@@ -21248,6 +21214,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);
@@ -21294,7 +21321,14 @@ var Agent = class {
       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.setDiffStats(sessionId, {
+          additions: session.summary.additions,
+          deletions: session.summary.deletions,
+          files: session.summary.files
+        });
+      }
       const result = await this.loadSessionMode({
         cwd: directory,
         mcpServers: params.mcpServers,
@@ -21379,7 +21413,14 @@ var Agent = class {
       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.setDiffStats(sessionId, {
+          additions: session.summary.additions,
+          deletions: session.summary.deletions,
+          files: session.summary.files
+        });
+      }
       const result = await this.loadSessionMode({
         cwd: directory,
         mcpServers,
@@ -21716,7 +21757,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(() => {
         });
       })
     );
@@ -21961,10 +22002,35 @@ var Agent = class {
         childCost += childMessages.filter((m) => m.info.role === "assistant").reduce((sum, m) => sum + (m.info.cost ?? 0), 0);
       }
     }
+    const stats = this.eventHandler.getDiffStats(sessionId);
+    let childStats;
+    for (const childId of children) {
+      const cs = this.eventHandler.getDiffStats(childId);
+      if (cs) {
+        childStats = childStats ? {
+          additions: childStats.additions + cs.additions,
+          deletions: childStats.deletions + cs.deletions,
+          files: childStats.files + cs.files
+        } : { ...cs };
+      }
+    }
+    const totalStats = stats ?? childStats;
     const providers = await this.sdk.config.providers({ directory }).then((x) => x.data?.providers ?? []).catch(() => []);
     const provider = providers.find((p) => p.id === msg.providerID);
     const model = provider?.models[msg.modelID];
     const size = model?.limit?.context ?? 0;
+    const _meta = {};
+    if (childCost > 0) {
+      _meta.parentCost = totalCost;
+      _meta.childCost = childCost;
+      _meta.childSessionCount = children.length;
+    }
+    if (totalStats) {
+      _meta.codeChange = totalStats;
+    }
+    if (childStats) {
+      _meta.childCodeChange = childStats;
+    }
     await this.sendToClient({
       sessionId,
       update: {
@@ -21972,13 +22038,7 @@ var Agent = class {
         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(() => {
     });
@@ -22045,33 +22105,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),