@harmonyos-arkts/opencode-acp 0.0.6 → 0.0.7

package/dist/index.cjs

@@ -19704,6 +19704,14 @@ var SessionManager = class {
   getChildren(parentId) {
     return [...this.children.get(parentId) ?? []];
   }
+  /** All registered session IDs (parent + discovered children). */
+  listSessionIds() {
+    return [...this.sessions.keys()];
+  }
+  /** Top-level sessions only (no parentID) — used for global error broadcast. */
+  listTopLevelSessionIds() {
+    return [...this.sessions.values()].filter((s) => !s.parentID).map((s) => s.id);
+  }
   // Model and mode management
   getModel(sessionId) {
     return this.get(sessionId).model;
@@ -20433,12 +20441,105 @@ async function sendToClient(connection, params) {
   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 } : {}
+    ...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,
+      error: update._meta?.error?.message
+    } : update._meta?.error ? { error: update._meta.error?.message ?? update._meta.error } : {}
   });
   return connection.sessionUpdate(params);
 }
 
+// src/acp-error.ts
+function inferCode(err) {
+  const name = typeof err.name === "string" ? err.name : "";
+  if (name === "AI_LoadAPIKeyError" || /auth/i.test(name)) return "auth_required";
+  if (/provider|api|model/i.test(name)) return "provider_error";
+  return "turn_error";
+}
+function extractTurnError(raw) {
+  return normalizeError(raw.responseError) ?? normalizeError(raw.messageError);
+}
+function normalizeError(err) {
+  if (err == null || err === false) return void 0;
+  if (typeof err === "string" && err.trim()) {
+    return { code: "turn_error", message: err.trim(), display: "inline" };
+  }
+  if (err instanceof Error && err.message.trim()) {
+    return {
+      code: inferCode({ name: err.name }),
+      message: err.message.trim(),
+      name: err.name,
+      cause: err.cause instanceof Error ? err.cause.message : void 0,
+      display: "inline"
+    };
+  }
+  if (typeof err === "object") {
+    const o = err;
+    const message = typeof o.message === "string" && o.message.trim() ? o.message.trim() : typeof o.error === "string" && o.error.trim() ? o.error.trim() : void 0;
+    if (!message) return void 0;
+    const cause = o.cause instanceof Error ? o.cause.message : typeof o.cause === "object" && o.cause !== null && typeof o.cause.message === "string" ? o.cause.message : void 0;
+    return {
+      code: inferCode(o),
+      message,
+      name: typeof o.name === "string" ? o.name : void 0,
+      cause,
+      display: "inline",
+      details: o
+    };
+  }
+  return void 0;
+}
+function subscriptionErrorFrom(err) {
+  const normalized = normalizeError(err);
+  if (normalized) {
+    return { ...normalized, code: "subscription_error", display: "banner" };
+  }
+  const message = err instanceof Error ? err.message : "OpenCode event stream disconnected";
+  return {
+    code: "subscription_error",
+    message: message.trim() || "OpenCode event stream disconnected",
+    display: "banner"
+  };
+}
+function stopReasonForTurn(error48, finish) {
+  if (!error48) return "end_turn";
+  if (finish === "refusal" || finish === "content_filter") return "refusal";
+  if (/refus/i.test(error48.message) || error48.code === "auth_required") return "refusal";
+  return "end_turn";
+}
+async function emitSessionError(connection, sessionId, payload, options) {
+  const display = payload.display ?? "inline";
+  const messageId = options?.messageId ?? payload.messageId ?? `err-${Date.now()}`;
+  if (display !== "silent") {
+    await sendToClient(connection, {
+      sessionId,
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        messageId,
+        content: { type: "text", text: payload.message },
+        _meta: { error: payload }
+      }
+    }).catch(() => {
+    });
+  }
+  if (display === "banner" || display === "inline") {
+    await sendToClient(connection, {
+      sessionId,
+      update: {
+        sessionUpdate: "session_info_update",
+        _meta: { error: payload }
+      }
+    }).catch(() => {
+    });
+  }
+}
+
 // src/event-handler.ts
+var SUBSCRIPTION_RETRY_MS = 3e3;
+var SUBSCRIPTION_ERROR_BROADCAST_MS = 3e4;
 var QUESTION_TIMEOUT_MS = 3e5;
 var permissionOptions = [
   { optionId: "once", kind: "allow_once", name: "Allow once" },
@@ -20463,38 +20564,65 @@ var EventHandler = class {
   fileDiffStats = /* @__PURE__ */ new Map();
   /** AI code change stats per session, keyed by sessionId → filePath → { additions, deletions }. */
   aiCodeChangeStats = /* @__PURE__ */ new Map();
+  lastSubscriptionErrorBroadcastAt = 0;
+  turnTimeoutTracker;
   constructor(deps) {
     this.connection = deps.connection;
     this.sdk = deps.sdk;
     this.sessionManager = deps.sessionManager;
+    this.turnTimeoutTracker = deps.turnTimeoutTracker;
   }
   start() {
     if (this.started) return;
     this.started = true;
-    this.runSubscription().catch((err) => {
-      if (this.abort.signal.aborted) return;
-      console.error("[event-handler] subscription failed:", err);
-    });
+    this.turnTimeoutTracker?.start();
+    void this.runSubscription();
   }
   stop() {
     this.abort.abort();
+    this.turnTimeoutTracker?.stop();
   }
   async runSubscription() {
     while (true) {
       if (this.abort.signal.aborted) return;
-      const events = await this.sdk.global.event({
-        signal: this.abort.signal
-      });
-      for await (const event of events.stream) {
-        if (this.abort.signal.aborted) return;
-        const payload = event?.payload;
-        if (!payload) continue;
-        await this.handleEvent(payload).catch((err) => {
-          console.error("[event-handler] failed to handle event:", err);
+      try {
+        const events = await this.sdk.global.event({
+          signal: this.abort.signal
         });
+        for await (const event of events.stream) {
+          if (this.abort.signal.aborted) return;
+          const payload = event?.payload;
+          if (!payload) continue;
+          await this.handleEvent(payload).catch((err) => {
+            console.error("[event-handler] failed to handle event:", err);
+          });
+        }
+      } catch (err) {
+        if (this.abort.signal.aborted) return;
+        console.error("[event-handler] subscription failed:", err);
+        await this.broadcastSubscriptionError(err);
+        await new Promise((r) => setTimeout(r, SUBSCRIPTION_RETRY_MS));
       }
     }
   }
+  /** Notify all top-level sessions that the OpenCode SSE stream dropped. */
+  async broadcastSubscriptionError(err) {
+    const now = Date.now();
+    if (now - this.lastSubscriptionErrorBroadcastAt < SUBSCRIPTION_ERROR_BROADCAST_MS) {
+      return;
+    }
+    this.lastSubscriptionErrorBroadcastAt = now;
+    const payload = subscriptionErrorFrom(err);
+    sysLog("subscription.error", { message: payload.message });
+    const sessionIds = this.sessionManager.listTopLevelSessionIds();
+    if (sessionIds.length === 0) {
+      return;
+    }
+    for (const sessionId of sessionIds) {
+      await emitSessionError(this.connection, sessionId, payload).catch(() => {
+      });
+    }
+  }
   // ─── Resolve session for routing ────────────────────────────────
   /**
    * Resolve the sessionId to use for ACP routing.
@@ -20511,6 +20639,7 @@ var EventHandler = class {
     if (event.type === "server.heartbeat") {
       return;
     }
+    this.turnTimeoutTracker?.noteEvent(event);
     switch (event.type) {
       case "session.created":
       case "session.updated": {
@@ -20781,6 +20910,7 @@ var EventHandler = class {
   async handleToolPart(sessionId, part) {
     if (!this.toolStarts.has(part.callID)) {
       this.toolStarts.add(part.callID);
+      this.turnTimeoutTracker?.onToolCallStart(sessionId);
       const session = this.sessionManager.tryGet(sessionId);
       if (session?.parentID) {
         const tracker = this.childToolCounts.get(sessionId);
@@ -20843,15 +20973,18 @@ var EventHandler = class {
         return;
       }
       case "completed": {
-        this.toolStarts.delete(part.callID);
+        if (this.toolStarts.delete(part.callID)) {
+          this.turnTimeoutTracker?.onToolCallEnd(sessionId);
+        }
         this.bashSnapshots.delete(part.callID);
         if (part.tool === "task" && part.state.metadata) {
           const childSessionId = typeof part.state.metadata["sessionId"] === "string" ? part.state.metadata["sessionId"] : void 0;
           if (childSessionId && this.sessionManager.tryGet(childSessionId)) {
             const tracker = this.childToolCounts.get(childSessionId);
-            await this.sendChildSessionCompleted(
+            await this.sendChildSessionFinished(
               childSessionId,
               sessionId,
+              "completed",
               tracker?.completed ?? 0,
               tracker ? Date.now() - tracker.startTime : 0
             ).catch(() => {
@@ -20921,8 +21054,32 @@ var EventHandler = class {
         return;
       }
       case "error": {
-        this.toolStarts.delete(part.callID);
+        if (this.toolStarts.delete(part.callID)) {
+          this.turnTimeoutTracker?.onToolCallEnd(sessionId);
+        }
         this.bashSnapshots.delete(part.callID);
+        if (part.tool === "task" && part.state.metadata) {
+          const childSessionId = typeof part.state.metadata["sessionId"] === "string" ? part.state.metadata["sessionId"] : void 0;
+          if (childSessionId && this.sessionManager.tryGet(childSessionId)) {
+            const tracker = this.childToolCounts.get(childSessionId);
+            const errText = typeof part.state.error === "string" && part.state.error.trim() ? part.state.error.trim() : "Sub-agent task failed";
+            const payload = {
+              code: "session_error",
+              message: errText,
+              display: "inline"
+            };
+            await this.sendChildSessionFinished(
+              childSessionId,
+              sessionId,
+              "failed",
+              tracker?.completed ?? 0,
+              tracker ? Date.now() - tracker.startTime : 0,
+              payload
+            ).catch(() => {
+            });
+            this.childToolCounts.delete(childSessionId);
+          }
+        }
         await sendToClient(this.connection, {
           sessionId,
           update: {
@@ -20950,9 +21107,9 @@ var EventHandler = class {
     }
   }
   /**
-   * Notify the ACP client that a child session has completed.
+   * Notify the ACP client that a child session finished (success or failure).
    */
-  async sendChildSessionCompleted(childSessionId, parentSessionId, toolCallCount, durationMs) {
+  async sendChildSessionFinished(childSessionId, parentSessionId, status, toolCallCount, durationMs, error48) {
     const child = this.sessionManager.tryGet(childSessionId);
     const title = child?.title ?? "Subagent";
     const agentMatch = title.match(/@(\w+)\s+subagent/);
@@ -20963,14 +21120,15 @@ var EventHandler = class {
       update: {
         sessionUpdate: "session_info_update",
         title,
-        status: "completed",
+        status,
         _meta: {
           parentSessionId,
           isSubagent: true,
           toolCallCount,
           durationMs,
           ...agentType && { agentType },
-          ...description && { description }
+          ...description && { description },
+          ...error48 && { error: error48 }
         }
       }
     });
@@ -21111,6 +21269,140 @@ var AuthProviderManager = class {
   }
 };
 
+// src/turn-timeout-tracker.ts
+var TURN_IDLE_LOG_MS = 9e4;
+var TURN_IDLE_LOG_MS_WITH_TOOL = 10 * 6e4;
+var TURN_IDLE_CHECK_INTERVAL_MS = 3e4;
+function parsePositiveIntEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function turnIdleLogThresholdMs(hasActiveTool) {
+  const base = parsePositiveIntEnv("HARMONY_ACP_TURN_IDLE_LOG_MS", TURN_IDLE_LOG_MS);
+  const withTool = parsePositiveIntEnv("HARMONY_ACP_TURN_IDLE_LOG_MS_WITH_TOOL", TURN_IDLE_LOG_MS_WITH_TOOL);
+  return hasActiveTool ? withTool : base;
+}
+function sessionIdFromEvent(event) {
+  const props = event.properties;
+  if (!props) return void 0;
+  switch (event.type) {
+    case "message.part.updated": {
+      const part = props.part;
+      return typeof part?.sessionID === "string" ? part.sessionID : void 0;
+    }
+    case "message.part.delta":
+      return typeof props.sessionID === "string" ? props.sessionID : void 0;
+    case "session.diff":
+    case "session.updated":
+    case "session.created":
+      return typeof props.sessionID === "string" ? props.sessionID : typeof props.info?.id === "string" ? props.info.id : void 0;
+    case "permission.asked": {
+      const permission = props;
+      return typeof permission.sessionID === "string" ? permission.sessionID : void 0;
+    }
+  }
+  return void 0;
+}
+var TurnTimeoutTracker = class {
+  constructor(sessionManager) {
+    this.sessionManager = sessionManager;
+  }
+  turns = /* @__PURE__ */ new Map();
+  timer;
+  start() {
+    if (this.timer) return;
+    const interval = parsePositiveIntEnv(
+      "HARMONY_ACP_TURN_IDLE_CHECK_MS",
+      TURN_IDLE_CHECK_INTERVAL_MS
+    );
+    this.timer = setInterval(() => this.checkIdleTurns(), interval);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  rootSessionId(sessionId) {
+    return this.sessionManager.findRootSession(sessionId)?.id ?? sessionId;
+  }
+  onPromptStart(sessionId, meta3) {
+    const root = this.rootSessionId(sessionId);
+    const now = Date.now();
+    this.turns.set(root, {
+      rootSessionId: root,
+      promptStartedAt: now,
+      lastActivityAt: now,
+      activeToolCalls: 0,
+      idleLogged: false,
+      model: meta3?.model
+    });
+    sysLog("turn.prompt_start", { sessionId: root, model: meta3?.model });
+  }
+  onPromptEnd(sessionId) {
+    const root = this.rootSessionId(sessionId);
+    const state = this.turns.get(root);
+    if (state) {
+      sysLog("turn.prompt_end", {
+        sessionId: root,
+        durationMs: Date.now() - state.promptStartedAt
+      });
+    }
+    this.turns.delete(root);
+  }
+  /** SSE / OpenCode activity for a session (child events bump the root turn). */
+  noteActivity(sessionId) {
+    const root = this.rootSessionId(sessionId);
+    const state = this.turns.get(root);
+    if (!state) return;
+    state.lastActivityAt = Date.now();
+    state.idleLogged = false;
+  }
+  onToolCallStart(sessionId) {
+    const root = this.rootSessionId(sessionId);
+    const state = this.turns.get(root);
+    if (!state) return;
+    state.activeToolCalls++;
+    state.lastActivityAt = Date.now();
+    state.idleLogged = false;
+  }
+  onToolCallEnd(sessionId) {
+    const root = this.rootSessionId(sessionId);
+    const state = this.turns.get(root);
+    if (!state) return;
+    state.activeToolCalls = Math.max(0, state.activeToolCalls - 1);
+    state.lastActivityAt = Date.now();
+    state.idleLogged = false;
+  }
+  noteEvent(event) {
+    const sid = sessionIdFromEvent(event);
+    if (sid) {
+      this.noteActivity(sid);
+    }
+  }
+  checkIdleTurns() {
+    const now = Date.now();
+    for (const state of this.turns.values()) {
+      const idleMs = now - state.lastActivityAt;
+      const thresholdMs = turnIdleLogThresholdMs(state.activeToolCalls > 0);
+      if (idleMs < thresholdMs || state.idleLogged) {
+        continue;
+      }
+      state.idleLogged = true;
+      sysLog("turn.idle_timeout", {
+        sessionId: state.rootSessionId,
+        idleMs,
+        thresholdMs,
+        promptAgeMs: now - state.promptStartedAt,
+        activeToolCalls: state.activeToolCalls,
+        model: state.model
+      });
+    }
+  }
+};
+
 // src/agent.ts
 function isApiKeyError(err) {
   return err instanceof Error && err.name === "AI_LoadAPIKeyError";
@@ -21123,19 +21415,22 @@ var Agent = class {
   eventHandler;
   authProvider;
   mcpManager;
+  turnTimeoutTracker;
   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);
+    this.turnTimeoutTracker = new TurnTimeoutTracker(this.sessionManager);
   }
   init(connection) {
     this.connection = connection;
     this.eventHandler = new EventHandler({
       connection,
       sdk: this.sdk,
-      sessionManager: this.sessionManager
+      sessionManager: this.sessionManager,
+      turnTimeoutTracker: this.turnTimeoutTracker
     });
     this.eventHandler.start();
   }
@@ -21478,102 +21773,114 @@ var Agent = class {
     const agent = session.modeId ?? await this.defaultAgent(directory);
     const parts = this.convertPromptParts(params.prompt);
     const cmd = this.parseCommand(parts);
-    ocCall("session.prompt", { sessionID, agent, model: `${model.providerID}/${model.modelID}` });
-    if (!cmd) {
-      const response2 = await this.sdk.session.prompt({
+    const modelLabel = `${model.providerID}/${model.modelID}`;
+    ocCall("session.prompt", { sessionID, agent, model: modelLabel });
+    this.turnTimeoutTracker.onPromptStart(sessionID, { model: modelLabel });
+    try {
+      if (!cmd) {
+        const response2 = await this.sdk.session.prompt({
+          sessionID,
+          model: {
+            providerID: model.providerID,
+            modelID: model.modelID
+          },
+          variant: this.sessionManager.getVariant(sessionID),
+          parts,
+          agent,
+          directory
+        });
+        const rawErr2 = response2.error;
+        ocCall("session.prompt.raw", {
+          hasData: !!response2.data,
+          hasError: !!rawErr2,
+          errorName: rawErr2?.name,
+          errorMessage: rawErr2?.message,
+          errorCode: rawErr2?.code ?? rawErr2?.cause?.code,
+          errorCauseName: rawErr2?.cause?.name,
+          errorCauseMessage: rawErr2?.cause?.message
+        });
+        const msg2 = response2.data?.info;
+        return await this.finishPromptTurn(sessionID, directory, { rawErr: rawErr2, msg: msg2 });
+      }
+      const command = await this.sdk.command.list({ directory }).then((x) => x.data?.find((c) => c.name === cmd.name));
+      if (command) {
+        const response2 = await this.sdk.session.command({
+          sessionID,
+          command: command.name,
+          arguments: cmd.args,
+          model: modelLabel,
+          agent,
+          directory
+        });
+        const rawErr2 = response2.error;
+        const msg2 = response2.data?.info;
+        return await this.finishPromptTurn(sessionID, directory, { rawErr: rawErr2, msg: msg2 });
+      }
+      if (cmd.name === "compact") {
+        await this.sdk.session.summarize(
+          {
+            sessionID,
+            directory,
+            providerID: model.providerID,
+            modelID: model.modelID
+          },
+          { throwOnError: true }
+        ).catch(() => {
+        });
+        await this.sendUsageUpdate(sessionID, directory);
+        return {
+          stopReason: "end_turn",
+          _meta: {}
+        };
+      }
+      const response = await this.sdk.session.prompt({
         sessionID,
-        model: {
-          providerID: model.providerID,
-          modelID: model.modelID
-        },
+        model: { providerID: model.providerID, modelID: model.modelID },
         variant: this.sessionManager.getVariant(sessionID),
         parts,
         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,
-        role: msg2?.role,
-        model: msg2 ? `${msg2.providerID}/${msg2.modelID}` : void 0,
-        tokens: msg2?.tokens,
-        cost: msg2?.cost,
-        finish: msg2?.finish,
-        error: msg2?.error
-      });
-      await this.logMessageContent(sessionID, msg2?.id, directory);
-      await this.sendUsageUpdate(sessionID, directory);
-      acpOut("prompt.response", {
-        stopReason: "end_turn",
-        usage: msg2 ? this.buildUsage(msg2) : void 0
-      });
-      return {
-        stopReason: "end_turn",
-        usage: msg2 ? this.buildUsage(msg2) : void 0,
-        _meta: {}
-      };
-    }
-    const command = await this.sdk.command.list({ directory }).then((x) => x.data?.find((c) => c.name === cmd.name));
-    if (command) {
-      const response2 = await this.sdk.session.command({
-        sessionID,
-        command: command.name,
-        arguments: cmd.args,
-        model: model.providerID + "/" + model.modelID,
-        agent,
-        directory
-      });
-      const msg2 = response2.data?.info;
-      await this.logMessageContent(sessionID, msg2?.id, directory);
-      await this.sendUsageUpdate(sessionID, directory);
-      return {
-        stopReason: "end_turn",
-        usage: msg2 ? this.buildUsage(msg2) : void 0,
-        _meta: {}
-      };
-    }
-    if (cmd.name === "compact") {
-      await this.sdk.session.summarize(
-        {
-          sessionID,
-          directory,
-          providerID: model.providerID,
-          modelID: model.modelID
-        },
-        { throwOnError: true }
-      ).catch(() => {
-      });
-      await this.sendUsageUpdate(sessionID, directory);
-      return {
-        stopReason: "end_turn",
-        _meta: {}
-      };
+      const rawErr = response.error;
+      const msg = response.data?.info;
+      return await this.finishPromptTurn(sessionID, directory, { rawErr, msg });
+    } finally {
+      this.turnTimeoutTracker.onPromptEnd(sessionID);
     }
-    const response = await this.sdk.session.prompt({
-      sessionID,
-      model: { providerID: model.providerID, modelID: model.modelID },
-      variant: this.sessionManager.getVariant(sessionID),
-      parts,
-      agent,
-      directory
+  }
+  /**
+   * Complete a prompt turn: emit streaming errors, usage, and PromptResponse._meta.error.
+   */
+  async finishPromptTurn(sessionID, directory, opts) {
+    const turnError = extractTurnError({
+      responseError: opts.rawErr,
+      messageError: opts.msg?.error
+    });
+    ocCall("session.prompt.response", {
+      messageId: opts.msg?.id,
+      role: opts.msg?.role,
+      model: opts.msg ? `${opts.msg.providerID}/${opts.msg.modelID}` : void 0,
+      tokens: opts.msg?.tokens,
+      cost: opts.msg?.cost,
+      finish: opts.msg?.finish,
+      error: turnError?.message
+    });
+    if (turnError) {
+      await emitSessionError(this.connection, sessionID, turnError, { messageId: opts.msg?.id });
+    }
+    await this.logMessageContent(sessionID, opts.msg?.id, directory);
+    await this.sendUsageUpdate(sessionID, directory, turnError);
+    const stopReason = stopReasonForTurn(turnError, opts.msg?.finish);
+    const usage = opts.msg ? this.buildUsage(opts.msg) : void 0;
+    acpOut("prompt.response", {
+      stopReason,
+      usage,
+      error: turnError?.message
     });
-    const msg = response.data?.info;
-    await this.logMessageContent(sessionID, msg?.id, directory);
-    await this.sendUsageUpdate(sessionID, directory);
     return {
-      stopReason: "end_turn",
-      usage: msg ? this.buildUsage(msg) : void 0,
-      _meta: {}
+      stopReason,
+      usage,
+      _meta: turnError ? { error: turnError } : {}
     };
   }
   async cancel(params) {
@@ -21584,6 +21891,7 @@ var Agent = class {
       sessionID: params.sessionId,
       directory: session.cwd
     });
+    this.turnTimeoutTracker.onPromptEnd(params.sessionId);
   }
   // ─── Configuration ────────────────────────────────────────────────
   async setSessionMode(params) {
@@ -22028,7 +22336,7 @@ var Agent = class {
         break;
     }
   }
-  async sendUsageUpdate(sessionId, directory) {
+  async sendUsageUpdate(sessionId, directory, turnError) {
     const messages = await this.sdk.session.messages({ sessionID: sessionId, directory }).then((x) => x.data).catch(() => void 0);
     if (!messages) return;
     const assistantMessages = messages.filter(
@@ -22059,6 +22367,9 @@ var Agent = class {
     }
     this.aggregateFileDiffStats(sessionId, children, _meta);
     this.aggregateAICodeChangeStats(sessionId, children, _meta);
+    if (turnError) {
+      _meta.error = turnError;
+    }
     await sendToClient(this.connection, {
       sessionId,
       update: {
@@ -22202,13 +22513,15 @@ var Agent = class {
     }
   }
   buildUsage(msg) {
+    const tokens = msg.tokens;
+    if (!tokens) return void 0;
     return {
-      totalTokens: msg.tokens.input + msg.tokens.output + msg.tokens.reasoning + (msg.tokens.cache?.read ?? 0) + (msg.tokens.cache?.write ?? 0),
-      inputTokens: msg.tokens.input,
-      outputTokens: msg.tokens.output,
-      thoughtTokens: msg.tokens.reasoning || void 0,
-      cachedReadTokens: msg.tokens.cache?.read || void 0,
-      cachedWriteTokens: msg.tokens.cache?.write || void 0
+      totalTokens: tokens.input + tokens.output + tokens.reasoning + (tokens.cache?.read ?? 0) + (tokens.cache?.write ?? 0),
+      inputTokens: tokens.input,
+      outputTokens: tokens.output,
+      thoughtTokens: tokens.reasoning || void 0,
+      cachedReadTokens: tokens.cache?.read || void 0,
+      cachedWriteTokens: tokens.cache?.write || void 0
     };
   }
 };