@khalilgharbaoui/opencode-claude-code-plugin 0.26.1 → 0.26.3

package/dist/index.js

@@ -514,6 +514,9 @@ function translateStreamForHost(stream, dialect = "v1") {
   );
 }
 
+// src/account-failover.ts
+import { homedir as homedir2 } from "os";
+
 // src/accounts.ts
 import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
 import path from "path";
@@ -907,8 +910,9 @@ var QUESTION_TOOL_NAME = "question";
 var APPROVED_EXIT_PLAN_MODE_MESSAGE = "User has approved your plan. You can now start coding. Start with updating your todo list if applicable.";
 var REJECTED_EXIT_PLAN_MODE_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected. To tell you how to proceed, the user said:";
 var PLAN_MODE_APPROVAL_QUESTION = "Do you want to proceed with this plan?";
-var OPENCODE_QUESTION_RESULT_PREFIX = `User has answered your questions: "${PLAN_MODE_APPROVAL_QUESTION}"="`;
-var OPENCODE_QUESTION_RESULT_SUFFIX = `". You can now continue with the user's answers in mind.`;
+var OPENCODE_QUESTION_RESULT_PREFIX = "User has answered your questions: ";
+var OPENCODE_QUESTION_RESULT_SUFFIX = ". You can now continue with the user's answers in mind.";
+var OPENCODE_UNANSWERED = "Unanswered";
 var KEY_SEPARATOR = "\0";
 function isPlanModeQuestionActive(input) {
   if (input.compactionMode) return false;
@@ -1007,29 +1011,40 @@ function unwrapToolOutput(part) {
       return output;
   }
 }
-function unwrapOpencodeQuestionResult(value) {
-  if (value.startsWith(OPENCODE_QUESTION_RESULT_PREFIX) && value.endsWith(OPENCODE_QUESTION_RESULT_SUFFIX)) {
-    return value.slice(
-      OPENCODE_QUESTION_RESULT_PREFIX.length,
-      -OPENCODE_QUESTION_RESULT_SUFFIX.length
-    );
+function unwrapOpencodeQuestionResult(value, question) {
+  if (!value.startsWith(OPENCODE_QUESTION_RESULT_PREFIX) || !value.endsWith(OPENCODE_QUESTION_RESULT_SUFFIX)) {
+    return value;
   }
-  return value;
+  const body = value.slice(
+    OPENCODE_QUESTION_RESULT_PREFIX.length,
+    value.length - OPENCODE_QUESTION_RESULT_SUFFIX.length
+  );
+  if (!body.startsWith('"') || !body.endsWith('"')) return value;
+  let answer;
+  const head = question === void 0 ? void 0 : `"${question}"="`;
+  if (head && body.startsWith(head) && body.length > head.length) {
+    answer = body.slice(head.length, -1);
+  } else {
+    const split = body.lastIndexOf('"="');
+    if (split > 0) answer = body.slice(split + 3, -1);
+  }
+  if (answer === void 0) return value;
+  return answer === OPENCODE_UNANSWERED ? "" : answer;
 }
-function collectAnswerStrings(value) {
-  if (typeof value === "string") return [unwrapOpencodeQuestionResult(value)];
-  if (Array.isArray(value)) return value.flatMap(collectAnswerStrings);
+function collectAnswerStrings(value, question) {
+  if (typeof value === "string") return [unwrapOpencodeQuestionResult(value, question)];
+  if (Array.isArray(value)) return value.flatMap((item) => collectAnswerStrings(item, question));
   if (!value || typeof value !== "object") return [];
   const obj = value;
   if (obj.denied === true) return [String(obj.reason ?? "question rejected")];
   for (const key of ["answers", "answer", "selected", "selection", "value"]) {
-    if (key in obj) return collectAnswerStrings(obj[key]);
+    if (key in obj) return collectAnswerStrings(obj[key], question);
   }
   return [];
 }
 function classifyQuestionResult(part) {
   const output = unwrapToolOutput(part);
-  const answers = collectAnswerStrings(output).map((answer) => answer.trim()).filter(Boolean);
+  const answers = collectAnswerStrings(output, PLAN_MODE_APPROVAL_QUESTION).map((answer) => answer.trim()).filter(Boolean);
   if (answers.length === 1 && answers[0].toLowerCase() === "yes") {
     return { approved: true, feedback: "" };
   }
@@ -1070,6 +1085,35 @@ var ACCOUNT_LIMIT_PATTERNS = [
   /third-party apps now draw from your extra usage/i,
   /you[’'`]?ve hit your individual spend limit/i
 ];
+var ACCOUNT_BLOCK_MARKER = "\u258C **claude account:**";
+var ACCOUNT_BLOCKS = {
+  authentication_failed: { what: "is not logged in (its login expired or was revoked)", login: true },
+  oauth_org_not_allowed: { what: "belongs to an organization that does not allow this login", login: false },
+  account_on_hold: { what: "is on hold", login: false },
+  verification_required: { what: "needs to be verified at claude.ai", login: false },
+  billing_error: { what: "has a billing problem", login: false }
+};
+function accountBlockKind(msg) {
+  if (msg.type !== "assistant" || typeof msg.error !== "string") return null;
+  return Object.prototype.hasOwnProperty.call(ACCOUNT_BLOCKS, msg.error) ? msg.error : null;
+}
+function describeAccountBlock(kind) {
+  return ACCOUNT_BLOCKS[kind].what;
+}
+function loginCommandFor(configDir, home = homedir2()) {
+  if (!configDir) return "claude auth login";
+  const shown = configDir === home || configDir.startsWith(`${home}/`) ? `~${configDir.slice(home.length)}` : configDir;
+  return `CLAUDE_CONFIG_DIR=${shown} claude auth login`;
+}
+function formatAccountBlockNote(input) {
+  const block = ACCOUNT_BLOCKS[input.kind];
+  const account = normalizeAccountName(input.account || DEFAULT_ACCOUNT);
+  const fix = block.login ? `Log in again with \`${loginCommandFor(input.configDir)}\`, then resend your message.` : "Check the account at claude.ai, then resend your message.";
+  const then = input.offeringSwitch ? " Or pick another account below." : "";
+  return `
+${ACCOUNT_BLOCK_MARKER} the Claude account "${account}" ${block.what}. ${fix}${then}
+`;
+}
 function isAccountLimitError(input) {
   if (input.rateLimit && isRateLimitRejected(input.rateLimit)) return true;
   const text = input.resultText;
@@ -1175,17 +1219,18 @@ function createAccountFailoverQuestionCall(sessionKey2, input, toolCallId = `${A
   const candidates = input.candidates.map((c) => normalizeAccountName(c));
   const resets = describeReset(input.resetsAt);
   const until = resets ?? "opencode restarts";
-  pendingQuestions2.set(pendingKey2(sessionKey2, toolCallId), {
-    sourceAccount: source,
-    candidates: [...candidates],
-    resetsAt: input.resetsAt
-  });
-  const question = [
+  const question = input.reason ? `The Claude account "${source}" ${input.reason}. Continue this task on another configured account? Leaving this unanswered waits, at no cost.` : [
     `The Claude account "${source}" is out of usage`,
     input.window ? ` in ${input.window}` : "",
     resets ? `, which resets at ${resets}` : "",
     ". Continue this task on another configured account? Leaving this unanswered waits, at no cost."
   ].join("");
+  pendingQuestions2.set(pendingKey2(sessionKey2, toolCallId), {
+    sourceAccount: source,
+    candidates: [...candidates],
+    resetsAt: input.resetsAt,
+    question
+  });
   return {
     toolCallId,
     toolName: QUESTION_TOOL_NAME,
@@ -1223,7 +1268,11 @@ function classify(pending, part) {
       reason: String(output.reason ?? "question rejected")
     };
   }
-  const answers = collectAnswerStrings(output).map((answer) => answer.trim()).filter(Boolean);
+  const outputType = part?.output?.type;
+  if (outputType === "error-text" || outputType === "error-json") {
+    return { kind: "stop", reason: String(output ?? "the form was dismissed") };
+  }
+  const answers = collectAnswerStrings(output, pending.question).map((answer) => answer.trim()).filter(Boolean);
   if (answers.length === 0) return { kind: "stop", reason: "no answer" };
   const picked = normalizeAccountName(answers[0]);
   if (picked === STOP_ANSWER) {
@@ -1240,7 +1289,7 @@ function classify(pending, part) {
     resetsAt: pending.resetsAt
   };
 }
-function consumeAccountFailoverAnswer(sessionKey2, prompt) {
+function consumeAccountFailoverAnswer(sessionKey2, prompt, fallback) {
   for (let i = prompt.length - 1; i >= 0; i--) {
     const msg = prompt[i];
     if (!Array.isArray(msg.content)) continue;
@@ -1255,6 +1304,21 @@ function consumeAccountFailoverAnswer(sessionKey2, prompt) {
       return classify(pending, part);
     }
   }
+  const last = prompt[prompt.length - 1];
+  if (fallback && fallback.candidates.length > 0 && Array.isArray(last?.content)) {
+    const orphan = last.content.find(
+      (part) => part?.type === "tool-result" && typeof part.toolCallId === "string" && part.toolCallId.startsWith(ACCOUNT_FAILOVER_TOOL_CALL_PREFIX)
+    );
+    if (orphan) {
+      return classify(
+        {
+          sourceAccount: normalizeAccountName(fallback.sourceAccount || DEFAULT_ACCOUNT),
+          candidates: fallback.candidates.map((c) => normalizeAccountName(c))
+        },
+        orphan
+      );
+    }
+  }
   return null;
 }
 function formatFailoverNote(input) {
@@ -1515,6 +1579,53 @@ function resolveProxyClientCeilingMs(overrides) {
   }
   return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
 }
+var proxyDeadlineGuard = null;
+function setProxyDeadlineGuard(guard) {
+  proxyDeadlineGuard = guard;
+}
+var PROXY_DEADLINE_RECHECK_MS = 6e4;
+var deadlineRecheckMs = PROXY_DEADLINE_RECHECK_MS;
+function armProxyDeadline(opts) {
+  let cancelled = false;
+  let extended = false;
+  let timer = null;
+  const check = async () => {
+    timer = null;
+    if (cancelled) return;
+    let keep = false;
+    const guard = proxyDeadlineGuard;
+    if (guard) {
+      try {
+        keep = await guard({ callId: opts.callId, toolName: opts.toolName });
+      } catch {
+        keep = false;
+      }
+    }
+    if (cancelled) return;
+    if (keep) {
+      if (!extended && opts.logExtension) {
+        log.warn("proxy call past its deadline, but opencode is still serving it; waiting", {
+          callId: opts.callId,
+          toolName: opts.toolName,
+          deadlineMs: opts.deadlineMs,
+          note: "usually a permission prompt in opencode; the call ends when it is answered, you abort, or the claude process goes"
+        });
+      }
+      extended = true;
+      timer = setTimeout(() => void check(), opts.recheckMs ?? deadlineRecheckMs);
+      return;
+    }
+    opts.onExpire();
+  };
+  timer = setTimeout(() => void check(), opts.deadlineMs);
+  return {
+    cancel() {
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+      timer = null;
+    }
+  };
+}
 function buildProxyTimeoutError(toolName, ms) {
   const key = toolName.toLowerCase();
   const base = `Proxy tool '${toolName}' timed out after ${ms}ms waiting for opencode to resolve the call`;
@@ -2000,21 +2111,26 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
               timeoutOverrides
             );
             if (deadlineMs > PROXY_NO_DEADLINE_MS) {
-              timer = setTimeout(() => {
-                if (!pending.has(callId)) return;
-                pending.delete(callId);
-                log.notice("proxy-mcp tool call timed out", {
-                  callId,
-                  toolName,
-                  deadlineMs
-                });
-                reject2(buildProxyTimeoutError(toolName, deadlineMs));
-              }, deadlineMs);
+              timer = armProxyDeadline({
+                callId,
+                toolName,
+                deadlineMs,
+                onExpire: () => {
+                  if (!pending.has(callId)) return;
+                  pending.delete(callId);
+                  log.notice("proxy-mcp tool call timed out", {
+                    callId,
+                    toolName,
+                    deadlineMs
+                  });
+                  reject2(buildProxyTimeoutError(toolName, deadlineMs));
+                }
+              });
             }
             calls.emit("call", entry);
           }
         ).finally(() => {
-          if (timer) clearTimeout(timer);
+          timer?.cancel();
           pending.delete(callId);
         });
         if (channel.closed) {
@@ -2381,7 +2497,7 @@ var PROXY_STALL_WARNING_MS = 5 * 6e4;
 var PROXY_DEADLINE_WARNING_FRACTION = 0.6;
 var PROXY_DEADLINE_WARNING_MIN_MS = 6e4;
 function clearPendingTimers(pending) {
-  if (pending.timer) clearTimeout(pending.timer);
+  pending.timer?.cancel();
   if (pending.stallTimer) clearInterval(pending.stallTimer);
   if (pending.deadlineWarnTimer) clearTimeout(pending.deadlineWarnTimer);
 }
@@ -2425,20 +2541,26 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides, stallWarning
     call.input,
     timeoutOverrides
   );
-  const timer = deadlineMs > PROXY_NO_DEADLINE_MS ? setTimeout(() => {
-    const current = pendingByCallId.get(call.id);
-    if (!current) return;
-    pendingByCallId.delete(call.id);
-    indexRemove(current.sessionKey, call.id);
-    clearPendingTimers(current);
-    current.reject(buildProxyTimeoutError(call.toolName, deadlineMs));
-    log.notice("timed out pending proxy call", {
-      sessionKey: current.sessionKey,
-      toolCallId: call.id,
-      toolName: call.toolName,
-      deadlineMs
-    });
-  }, deadlineMs) : null;
+  const timer = deadlineMs > PROXY_NO_DEADLINE_MS ? armProxyDeadline({
+    callId: call.id,
+    toolName: call.toolName,
+    deadlineMs,
+    logExtension: true,
+    onExpire: () => {
+      const current = pendingByCallId.get(call.id);
+      if (!current) return;
+      pendingByCallId.delete(call.id);
+      indexRemove(current.sessionKey, call.id);
+      clearPendingTimers(current);
+      current.reject(buildProxyTimeoutError(call.toolName, deadlineMs));
+      log.notice("timed out pending proxy call", {
+        sessionKey: current.sessionKey,
+        toolCallId: call.id,
+        toolName: call.toolName,
+        deadlineMs
+      });
+    }
+  }) : null;
   const stallTimer = deadlineMs === PROXY_NO_DEADLINE_MS && stallWarningMs > 0 ? setInterval(() => {
     const current = pendingByCallId.get(call.id);
     if (!current) return;
@@ -2467,7 +2589,7 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides, stallWarning
       remainingMs: Math.max(0, deadlineMs - waitedMs),
       emitted: current.emitted === true,
       channelClosed: current.channel?.closed === true,
-      note: "it will be rejected when the deadline passes; raise this tool's proxyToolTimeoutMs if the work is legitimately this long"
+      note: "it will be rejected when the deadline passes unless opencode is still serving it (a permission prompt is waiting); raise this tool's proxyToolTimeoutMs if the work is legitimately this long"
     });
   }, warnAtMs) : null;
   deadlineWarnTimer?.unref?.();
@@ -2502,6 +2624,9 @@ function markPendingProxyCallEmitted(toolCallId) {
 function isPendingProxyCallChannelClosed(call) {
   return call.channel?.closed === true;
 }
+function findPendingProxyCall(toolCallId) {
+  return pendingByCallId.get(toolCallId);
+}
 function getPendingProxyCalls(sessionKey2) {
   const s = callIdsBySession.get(sessionKey2);
   if (!s || s.size === 0) return [];
@@ -4600,7 +4725,8 @@ var PLUGIN_NOTE_MARKERS = [
   RESULT_ERROR_MARKER,
   DOCTOR_MARKER,
   STREAM_TIMEOUT_MARKER,
-  FAILOVER_MARKER
+  FAILOVER_MARKER,
+  ACCOUNT_BLOCK_MARKER
 ];
 function isPluginNote(part) {
   if (!part || part.type !== "text" || typeof part.text !== "string") return false;
@@ -4854,6 +4980,7 @@ function getClaudeUserMessage(prompt, includeHistoryContext = false, opts = {})
   const compactionMode = opts.compactionMode === true;
   const cliToolCallIds = opts.cliToolCallIds;
   const content = [];
+  prompt = stripAccountFailoverParts(prompt);
   if (opts.stripContextReminders) {
     const stripped = stripContextReminders(prompt);
     if (stripped.removed > 0) {
@@ -6195,9 +6322,16 @@ function spawnInteractiveProcess(opts) {
 // src/claude-code-language-model.ts
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
-import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
+import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
 import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname5, join as join8 } from "path";
+async function isProxyCallStillServed(callId) {
+  const pending = findPendingProxyCall(callId);
+  if (!pending || pending.emitted !== true) return false;
+  const session = describeSessionKey(pending.sessionKey).session;
+  return await fetchSessionRunState(session) === "busy";
+}
+setProxyDeadlineGuard(({ callId }) => isProxyCallStillServed(callId));
 var DEFAULT_COMPACTION_MODEL = "claude-haiku-4-5";
 function resolveCompactionModel(configured) {
   const env = process.env.CLAUDE_CODE_COMPACTION_MODEL?.trim();
@@ -6552,7 +6686,7 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join8(homedir5(), ".config");
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join8(homedir6(), ".config");
   const globalAgents = readPromptFileIfPresent(join8(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
@@ -7855,7 +7989,10 @@ ${plan}
       deleteActiveProcess(sk);
       clearCompression(sk);
     }
-    const failoverAnswer = compactionMode || useInteractive ? null : consumeAccountFailoverAnswer(sk, options.prompt);
+    const failoverAnswer = compactionMode || useInteractive ? null : consumeAccountFailoverAnswer(sk, options.prompt, {
+      sourceAccount,
+      candidates: failoverCandidates(this.config.failoverAccounts, sourceAccount)
+    });
     if (failoverAnswer?.kind === "stop") {
       log.warn("account failover declined; ending the turn", {
         sessionKey: sk,
@@ -8487,6 +8624,7 @@ ${plan}
           let resultMeta = {};
           let resultFailure;
           let accountLimitHit = null;
+          let accountBlock = null;
           const drainBuffer = [];
           let drainTimer = null;
           const DRAIN_QUIET_MS = 100;
@@ -8648,20 +8786,21 @@ ${plan}
               });
             }
             activeProcess?.pendingProxyCompletions?.clear();
-            if (accountLimitHit && failoverAskActive && msg.is_error === true) {
+            if ((accountLimitHit || accountBlock) && failoverAskActive && msg.is_error === true) {
               const call = createAccountFailoverQuestionCall(sk, {
                 sourceAccount,
                 candidates: failoverAccounts,
-                resetsAt: accountLimitHit.resetsAt,
-                window: accountLimitHit.window
+                resetsAt: accountLimitHit?.resetsAt,
+                window: accountLimitHit?.window,
+                reason: accountLimitHit || !accountBlock ? void 0 : describeAccountBlock(accountBlock)
               });
               log.warn(
-                `Claude account "${sourceAccount}" is out of usage; asking which account to continue on.`,
+                `Claude account "${sourceAccount}" ${accountLimitHit || !accountBlock ? "is out of usage" : `cannot serve (${accountBlock})`}; asking which account to continue on.`,
                 {
                   sessionKey: sk,
                   candidates: failoverAccounts,
                   toolCallId: call.toolCallId,
-                  resetsAt: accountLimitHit.resetsAt ?? null
+                  resetsAt: accountLimitHit?.resetsAt ?? null
                 }
               );
               finishWithQuestionCall(call);
@@ -8799,6 +8938,8 @@ ${plan}
                   endTextBlock();
                 }
               }
+              const block = accountBlockKind(msg);
+              if (block) accountBlock = block;
               if (msg.type === "rate_limit_event") {
                 const info = parseRateLimitEvent(msg);
                 if (info && isRateLimitRejected(info)) {
@@ -8815,58 +8956,58 @@ ${plan}
                 return;
               }
               if (msg.type === "content_block_start" && msg.content_block && msg.index !== void 0) {
-                const block = msg.content_block;
+                const block2 = msg.content_block;
                 const idx = msg.index;
-                if (block.type === "thinking") {
+                if (block2.type === "thinking") {
                   noteReasoning();
                   const reasoningId = generateId();
                   reasoningIds.set(idx, reasoningId);
                 }
-                if (block.type === "text") {
+                if (block2.type === "text") {
                   textBlockIndices.add(idx);
                   resetLastVisibleTextBlock();
-                  if (block.text) {
+                  if (block2.text) {
                     if (!currentTextId) startTextBlock();
                     controller.enqueue({
                       type: "text-delta",
                       id: currentTextId,
-                      delta: block.text
+                      delta: block2.text
                     });
-                    noteVisibleText(block.text);
+                    noteVisibleText(block2.text);
                     hasReceivedContent = true;
                   }
                 }
-                if (block.type === "tool_use" && block.id && block.name) {
+                if (block2.type === "tool_use" && block2.id && block2.name) {
                   noteToolActivity();
                   const entry = {
-                    id: block.id,
-                    name: block.name,
+                    id: block2.id,
+                    name: block2.name,
                     inputJson: "",
                     started: false
                   };
                   toolCallMap.set(idx, entry);
-                  if (block.name !== "AskUserQuestion" && block.name !== "ask_user_question" && block.name !== "ExitPlanMode" && !block.name.startsWith(PROXY_TOOL_PREFIX)) {
+                  if (block2.name !== "AskUserQuestion" && block2.name !== "ask_user_question" && block2.name !== "ExitPlanMode" && !block2.name.startsWith(PROXY_TOOL_PREFIX)) {
                     const { name: mappedName, skip, executed } = mapTool(
-                      block.name,
+                      block2.name,
                       void 0,
                       {
                         webSearch: self.config.webSearch,
                         sessionId: getClaudeSessionId(sk),
-                        toolUseId: block.id
+                        toolUseId: block2.id
                       }
                     );
                     if (!skip) {
                       entry.started = true;
                       controller.enqueue({
                         type: "tool-input-start",
-                        id: block.id,
+                        id: block2.id,
                         toolName: mappedName,
                         providerExecuted: executed
                       });
                       log.info("tool started", {
-                        name: block.name,
+                        name: block2.name,
                         mappedName,
-                        id: block.id
+                        id: block2.id
                       });
                     }
                   }
@@ -9057,8 +9198,8 @@ ${plan}
                     hadStreamThinking: hadThinkingTextFromStream
                   });
                   if (!hadThinkingTextFromStream) {
-                    for (const block of thinkingBlocks) {
-                      if (block.thinking && block.thinking.length > 0) {
+                    for (const block2 of thinkingBlocks) {
+                      if (block2.thinking && block2.thinking.length > 0) {
                         noteReasoning();
                         hadThinkingTextFromStream = true;
                         const thinkingId = generateId();
@@ -9069,7 +9210,7 @@ ${plan}
                         controller.enqueue({
                           type: "reasoning-delta",
                           id: thinkingId,
-                          delta: block.thinking
+                          delta: block2.thinking
                         });
                         controller.enqueue({
                           type: "reasoning-end",
@@ -9096,20 +9237,20 @@ ${plan}
                 if (hasToolUse) {
                   clearFallbackTimer();
                 }
-                for (const block of msg.message.content) {
-                  if (block.type === "text" && block.text) {
+                for (const block2 of msg.message.content) {
+                  if (block2.type === "text" && block2.text) {
                     resetLastVisibleTextBlock();
                     const blockId = startTextBlock();
                     controller.enqueue({
                       type: "text-delta",
                       id: blockId,
-                      delta: block.text
+                      delta: block2.text
                     });
                     endTextBlock();
-                    noteVisibleText(block.text);
+                    noteVisibleText(block2.text);
                     hasReceivedContent = true;
                   }
-                  if (block.type === "thinking" && block.thinking) {
+                  if (block2.type === "thinking" && block2.thinking) {
                     noteReasoning();
                     const thinkingId = generateId();
                     controller.enqueue({
@@ -9119,17 +9260,17 @@ ${plan}
                     controller.enqueue({
                       type: "reasoning-delta",
                       id: thinkingId,
-                      delta: block.thinking
+                      delta: block2.thinking
                     });
                     controller.enqueue({
                       type: "reasoning-end",
                       id: thinkingId
                     });
                   }
-                  if (block.type === "tool_use" && block.id && block.name) {
+                  if (block2.type === "tool_use" && block2.id && block2.name) {
                     noteToolActivity();
-                    const parsedInput = block.input ?? {};
-                    if (isAskUserQuestionTool(block.name)) {
+                    const parsedInput = block2.input ?? {};
+                    if (isAskUserQuestionTool(block2.name)) {
                       const askId = startTextBlock();
                       controller.enqueue({
                         type: "text-delta",
@@ -9137,12 +9278,12 @@ ${plan}
                         delta: formatAskUserQuestion(parsedInput)
                       });
                       endTextBlock();
-                    } else if (block.name === "ExitPlanMode") {
+                    } else if (block2.name === "ExitPlanMode") {
                       const plan = parsedInput?.plan || "";
                       if (planModeQuestionActive) {
                         const questionCall = createExitPlanModeQuestionCall(
                           sk,
-                          block.id,
+                          block2.id,
                           plan
                         );
                         const planId2 = startTextBlock();
@@ -9167,8 +9308,8 @@ ${plan}
 `
                       });
                       endTextBlock();
-                    } else if (isWebSearchTool(block.name) && isWebSearchHandledByCli(self.config.webSearch)) {
-                      toolCallsById.delete(block.id);
+                    } else if (isWebSearchTool(block2.name) && isWebSearchHandledByCli(self.config.webSearch)) {
+                      toolCallsById.delete(block2.id);
                       const query = typeof parsedInput?.query === "string" ? parsedInput.query : JSON.stringify(parsedInput);
                       const searchId = startTextBlock();
                       controller.enqueue({
@@ -9179,11 +9320,11 @@ ${plan}
 `
                       });
                       endTextBlock();
-                    } else if (block.name.startsWith(PROXY_TOOL_PREFIX)) {
+                    } else if (block2.name.startsWith(PROXY_TOOL_PREFIX)) {
                       noteProxyActivity();
                       log.debug("ignoring proxy tool_use from assistant message", {
-                        name: block.name,
-                        id: block.id
+                        name: block2.name,
+                        id: block2.id
                       });
                     } else {
                       const {
@@ -9191,61 +9332,61 @@ ${plan}
                         input: mappedInput,
                         executed,
                         skip
-                      } = mapTool(block.name, parsedInput, {
+                      } = mapTool(block2.name, parsedInput, {
                         webSearch: self.config.webSearch,
                         sessionId: getClaudeSessionId(sk),
-                        toolUseId: block.id
+                        toolUseId: block2.id
                       });
                       if (!skip) {
-                        toolCallsById.set(block.id, {
-                          id: block.id,
-                          name: block.name,
+                        toolCallsById.set(block2.id, {
+                          id: block2.id,
+                          name: block2.name,
                           input: parsedInput
                         });
-                        if (!executed) skipResultForIds.add(block.id);
+                        if (!executed) skipResultForIds.add(block2.id);
                         controller.enqueue({
                           type: "tool-input-start",
-                          id: block.id,
+                          id: block2.id,
                           toolName: mappedName,
                           providerExecuted: executed
                         });
                         controller.enqueue({
                           type: "tool-call",
-                          toolCallId: block.id,
+                          toolCallId: block2.id,
                           toolName: mappedName,
                           input: JSON.stringify(mappedInput),
                           providerExecuted: executed
                         });
                       }
                       log.info("tool_use from assistant message", {
-                        name: block.name,
+                        name: block2.name,
                         mappedName,
-                        id: block.id,
+                        id: block2.id,
                         executed
                       });
                     }
                   }
-                  if (block.type === "tool_result") {
+                  if (block2.type === "tool_result") {
                     log.debug("tool_result", {
-                      toolUseId: block.tool_use_id
+                      toolUseId: block2.tool_use_id
                     });
                   }
                 }
               }
               if (msg.type === "user" && msg.message?.content) {
-                for (const block of msg.message.content) {
-                  if (block.type === "tool_result" && block.tool_use_id) {
-                    if (skipResultForIds.has(block.tool_use_id)) {
+                for (const block2 of msg.message.content) {
+                  if (block2.type === "tool_result" && block2.tool_use_id) {
+                    if (skipResultForIds.has(block2.tool_use_id)) {
                       log.debug("skipping tool-result (opencode runs it)", {
-                        toolUseId: block.tool_use_id
+                        toolUseId: block2.tool_use_id
                       });
                       continue;
                     }
                     let resultText = "";
-                    if (typeof block.content === "string") {
-                      resultText = block.content;
-                    } else if (Array.isArray(block.content)) {
-                      resultText = block.content.filter(
+                    if (typeof block2.content === "string") {
+                      resultText = block2.content;
+                    } else if (Array.isArray(block2.content)) {
+                      resultText = block2.content.filter(
                         (c) => c.type === "text" && typeof c.text === "string"
                       ).map((c) => c.text).join("\n");
                     }
@@ -9253,11 +9394,11 @@ ${plan}
                     if (claudeSessionId) {
                       const list2 = applyTaskCreateToolResult(
                         claudeSessionId,
-                        block.tool_use_id,
+                        block2.tool_use_id,
                         resultText
                       );
                       if (list2) {
-                        const synthId = `todowrite_${block.tool_use_id}`;
+                        const synthId = `todowrite_${block2.tool_use_id}`;
                         controller.enqueue({
                           type: "tool-input-start",
                           id: synthId,
@@ -9281,12 +9422,12 @@ ${plan}
                         noteToolActivity();
                       }
                     }
-                    const toolCall = toolCallsById.get(block.tool_use_id);
+                    const toolCall = toolCallsById.get(block2.tool_use_id);
                     if (toolCall) {
-                      const isError = block.is_error === true;
+                      const isError = block2.is_error === true;
                       controller.enqueue({
                         type: "tool-result",
-                        toolCallId: block.tool_use_id,
+                        toolCallId: block2.tool_use_id,
                         toolName: toolCall.name,
                         result: {
                           output: resultText,
@@ -9298,11 +9439,11 @@ ${plan}
                       });
                       noteToolActivity();
                       log.info("tool result emitted", {
-                        toolUseId: block.tool_use_id,
+                        toolUseId: block2.tool_use_id,
                         name: toolCall.name,
                         isError
                       });
-                      toolCallsById.delete(block.tool_use_id);
+                      toolCallsById.delete(block2.tool_use_id);
                     }
                   }
                 }
@@ -9328,6 +9469,26 @@ ${plan}
                 })) {
                   accountLimitHit = {};
                 }
+                if (accountBlock && msg.is_error) {
+                  resultFailure ??= accountBlock;
+                  const offeringSwitch = failoverAskActive;
+                  controller.enqueue({
+                    type: "text-delta",
+                    id: startTextBlock(),
+                    delta: formatAccountBlockNote({
+                      kind: accountBlock,
+                      account: sourceAccount,
+                      configDir: self.config.configDir,
+                      offeringSwitch
+                    })
+                  });
+                  endTextBlock();
+                  log.warn(`Claude account "${sourceAccount}" cannot serve requests`, {
+                    sessionKey: sk,
+                    kind: accountBlock,
+                    offeringSwitch
+                  });
+                }
                 const failure = describeResultFailure(msg);
                 if (failure) {
                   resultFailure = msg.subtype;
@@ -9773,7 +9934,7 @@ import {
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "fs";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import { join as join9, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
@@ -9783,12 +9944,12 @@ function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
     xdg ? join9(xdg, "opencode") : null,
-    join9(homedir6(), ".cache", "opencode"),
-    join9(homedir6(), "Library", "Caches", "opencode")
+    join9(homedir7(), ".cache", "opencode"),
+    join9(homedir7(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join9(homedir6(), ".config");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join9(homedir7(), ".config");
   return join9(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {