@coda-console/claude 1.6.0 → 1.6.2

package/agent/errors.mjs

@@ -0,0 +1,11 @@
+import { RequestError } from '@agentclientprotocol/sdk';
+
+// Only failed turns come here. Claude Code's synthetic assistant error and the subscription's rejected window are
+// evidence, ordinary assistant text and a bare HTTP 429 are not. Keep the provider's reset time/recovery advice intact.
+const exhausted = message => /^(?:You've (?:hit|reached) your (?:session|weekly|5-hour|7-day|usage) limit\b|(?:Your )?[Cc]redit balance is too low\b|You're out of (?:usage credits|extra usage)\b|Your org is out of usage\b)/.test(message);
+
+export function claudeFailure(message, { error, limits } = {}) {
+  const quota = (!error || ['rate_limit', 'billing_error'].includes(error)) &&
+    (exhausted(message) || (error === 'rate_limit' && limits?.status === 'rejected'));
+  return new RequestError(-32603, message, quota ? { _meta: { coda: { failure: { kind: 'quota_exhausted' } } } } : undefined);
+}

package/agent/session.mjs

@@ -10,6 +10,7 @@ import { realpath, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { agent, PROTOCOL_VERSION, RequestError } from '@agentclientprotocol/sdk';
 import { ClaudeSessionLimits, accountHash } from './limits.mjs';
+import { claudeFailure } from './errors.mjs';
 import { sdkEnvironment } from './auth.mjs';
 import { chosenServices, listedModels, serviceSettings } from './providers.mjs';
 import { SessionTitle } from './titles.mjs';
@@ -41,6 +42,8 @@ const denied = { behavior: 'deny', message: 'Coda 没有在请求结束前给出
 // A child session's output that comes before its task, kept until the task names that session: all of it, since what streamed
 // counts as said, a message's streamed pieces as one.
 const CHUNKS = new Set(['agent_message_chunk', 'agent_thought_chunk']);
+// What a turn says or does, as against what the session is (its settings, commands, title, usage).
+const SAYING = new Set([...CHUNKS, 'tool_call', 'tool_call_update', 'plan']);
 // How many messages sent into a prompt (steer) may be waiting to be taken at once.
 const STEERING_LIMIT = 32;
 
@@ -108,6 +111,8 @@ export class ClaudeSession {
       else early.push(update);
       return;
     }
+    // What a turn of Claude's own says comes after what it handles (`claim`).
+    if (sessionId === this.sessionId && SAYING.has(update.sessionUpdate)) this.waits.claim();
     this.notify('session/update', { sessionId, update });
   }
   registered(sessionId) {
@@ -286,7 +291,7 @@ export class ClaudeSession {
     if (!prompt) return;
     // What ended before this turn ended was taken in by it.
     this.waits.settled();
-    if (error) prompt.reject(failure(error)); else prompt.resolve({ stopReason });
+    if (error) prompt.reject(error); else prompt.resolve({ stopReason });
   }
   // What is said to the session goes into what its title is made of.
   heard(content) {
@@ -305,13 +310,14 @@ export class ClaudeSession {
     this.begin();
     // A subagent's request is in its session.
     const sessionId = this.waits.childSession(context.agentID) ?? this.sessionId;
+    if (sessionId === this.sessionId) this.waits.claim();
     return toolName === 'AskUserQuestion'
       ? this.ask('elicitation/create', questionForm({ sessionId, toolCallId: context.toolUseID, input }), signal, { behavior: 'deny', message: '问答已失效' })
       : this.ask('session/request_permission', permissionRequest({ sessionId, toolName, input, context }), signal, denied);
   }
   elicitation(request, { signal }) {
     if (!['starting', 'running'].includes(this.phase)) return Promise.resolve({ action: 'cancel' });
-    this.begin();
+    this.begin(); this.waits.claim();
     return this.ask('elicitation/create', elicitationForm({ sessionId: this.sessionId, request }), signal, { action: 'cancel' });
   }
   // Asked of Coda until it answers; withdrawn (`$/cancel_request`) once the SDK no longer waits for the answer.
@@ -358,7 +364,9 @@ export class ClaudeSession {
       case 'assistant': return this.assistant(m, parent);
       case 'user': return this.toolResults(m, parent);
       case 'result': return this.result(m);
-      case 'rate_limit_event': if (this.env.CODA_PLUGIN_STATE) new ClaudeSessionLimits({ path: join(this.env.CODA_PLUGIN_STATE, 'limits.json') }).observe(m.rate_limit_info, this.account ?? null);
+      case 'rate_limit_event':
+        this.turnLimits = m.rate_limit_info;
+        if (this.env.CODA_PLUGIN_STATE) new ClaudeSessionLimits({ path: join(this.env.CODA_PLUGIN_STATE, 'limits.json') }).observe(m.rate_limit_info, this.account ?? null);
     }
   }
   system(m) {
@@ -366,6 +374,7 @@ export class ClaudeSession {
       case 'init': {
         if (m.session_id !== this.sessionId) return;
         this.turning = true;
+        this.turnError = null; this.turnLimits = null;
         this.terminal = m.terminal_slash_commands ?? [];
         // Its effort is the one applied, the model's own included: what was chosen stays what it was. A query on the
         // service's model reports it by that service's name for it.
@@ -462,6 +471,13 @@ export class ClaudeSession {
   assistant(m, parent) {
     const sessionId = parent ?? this.sessionId, apiId = m.message?.id, blocks = this.streamed.get(apiId);
     if (parent) this.waits.model(parent, m.message?.model);
+    // API failures are synthetic assistant messages, followed by a result (even subtype "success" can be is_error).
+    // The result ends the turn and reports its failure; sending the synthetic message as prose would look like an answer.
+    // A child's error belongs to that child, never to the parent's prompt.
+    if (!parent) {
+      this.turnError = m.error ? { error: m.error, message: text(m.message?.content) } : null;
+      if (m.error) return;
+    }
     for (const block of m.message?.content ?? []) {
       if (block.type === 'tool_use') {
         this.tools.add(block.id);
@@ -499,17 +515,20 @@ export class ClaudeSession {
     const steered = ids.filter(id => this.steering.delete(id)).length > 0;
     const id = ids.find(id => this.prompts.has(id)) ?? (steered ? this.held : undefined);
     const cancelled = interrupted(m), failed = !cancelled && (m.is_error || m.subtype !== 'success');
+    const error = failed ? claudeFailure(m.errors?.length || m.result ? errorText(m) : this.turnError?.message || errorText(m),
+      { error: this.turnError?.error, limits: this.turnLimits }) : null;
+    this.turnError = null; this.turnLimits = null;
     if (id) {
-      const outcome = this.ending ?? (failed ? { failure: errorText(m) } : { stopReason: cancelled ? 'cancelled' : 'end_turn' });
+      const outcome = this.ending ?? (failed ? { failure: error } : { stopReason: cancelled ? 'cancelled' : 'end_turn' });
       if (this.ending || !this.steering.size) this.settle(id, outcome);
       else { this.held = id; if (cancelled || failed) this.dropRest(outcome); }
-    } else if (this.waits.handling) {
-      // A turn of Claude's own has no reply to fail: what went wrong is said in it.
-      if (failed) this.chunk(this.sessionId, 'text', m.uuid, errorText(m));
-      this.waits.finished();
+    } else if (this.waits.handling || this.waits.unclaimed) {
+      // A turn of Claude's own has no RPC reply to fail. End its own activity as failed with the reason, rather than
+      // saying the error as an answer and marking the work complete. The task that woke it retains its own outcome.
+      this.waits.finished(error ? { error: error.message, title: error.data?._meta?.coda?.failure?.kind === 'quota_exhausted' ? '额度不足' : undefined } : {});
     } else if (failed && this.prompts.size) {
       // A failure of the session itself names no input: none of those given can be said to have run.
-      for (const prompt of this.prompts.values()) prompt.reject(failure(errorText(m)));
+      for (const prompt of this.prompts.values()) prompt.reject(error);
       this.prompts.clear();
     }
     void this.title?.refresh(!failed && !cancelled);

package/agent/waits.mjs

@@ -4,7 +4,8 @@
 // What a subagent launches (`parent_task_id`) is told in that subagent's session, once a wait has told Coda that session.
 // A task that ends while no turn goes will wake Claude for its result: until a turn takes it up, or the session says idle,
 // it is still waited on. A turn Claude begins on its own handles what woke it (`takeUp`): what its opening message names,
-// else the tasks that ended, else the one wakeup due, else a wait of the turn's own; what it handles ends with that turn.
+// else the tasks that ended, else the one wakeup due, else a wait of the turn's own, told only once the turn says or asks
+// something (`claim`); what it handles ends with that turn.
 const FINAL = { completed: 'done', failed: 'failed', killed: 'cancelled', stopped: 'cancelled', ended: 'done' };
 const open = state => state === 'waiting' || state === 'handling';
 const cut = (value, limit) => typeof value === 'string' && value ? value.slice(0, limit) : undefined;
@@ -146,6 +147,12 @@ export class ClaudeWaits {
     let handled = [];
     if (origin?.kind === 'task-notification') handled = origin.subkind === 'scheduled-trigger' ? crons.filter(cron => cron.prompt && cron.prompt === text)
       : [...this.tasks.values()].filter(task => origin.runId && task.runId === origin.runId && open(task.state));
+    // A message a subagent sent (SendMessage: its report handed back, or word of how it goes) is that subagent's. Taken up for
+    // what it said, not for its end (`messaged`): the subagent ends as its end is told, not with this turn.
+    if (origin?.kind === 'peer') {
+      handled = [...this.tasks.values()].filter(task => origin.senderTaskId && task.taskId === origin.senderTaskId && open(task.state));
+      for (const task of handled) task.messaged = true;
+    }
     if (!handled.length) handled = pending.sort((a, b) => a.endedAt - b.endedAt);
     if (!handled.length) {
       // Which came due is not told: the one due, or else the only one there is.
@@ -153,23 +160,35 @@ export class ClaudeWaits {
       if ((due.length || crons.length) === 1) handled = due.length ? due : crons;
     }
     if (handled.length) for (const wait of handled) this.report(wait, 'handling');
-    else this.hold();
+    // Nothing it names: told as a wait of its own once it says or asks something. One that says nothing is not told at all,
+    // as Claude Code's turn for the notice of a subagent whose report an earlier turn took in, which reaches no model.
+    else this.unclaimed = true;
   }
+  claim() { if (this.unclaimed) { this.unclaimed = false; this.hold(); } }
   hold() {
     const own = { waitId: `turn-${++this.turns}` };
     this.own.add(own);
     this.report(own, 'handling', { kind: 'task', title: 'Claude 自主继续', stoppable: false });
   }
   // That turn's end: what it handled ended with it, a recurring wakeup waits for its next time.
-  finished() {
-    for (const task of this.tasks.values()) if (task.state === 'handling') { this.report(task, task.final ?? 'done'); task.final = undefined; }
+  finished({ error, title } = {}) {
+    // Processing a successful task's result can fail. Give that failure its own activity instead of changing the task's
+    // outcome, and leave recurring wakeups scheduled. There may already be a turn-owned activity (hold).
+    this.unclaimed = false;
+    if (error && !this.own.size) this.hold();
+    for (const task of this.tasks.values()) {
+      if (task.state !== 'handling') continue;
+      const messaged = task.messaged; task.messaged = false;
+      if (messaged && task.final === undefined) { this.report(task, 'waiting'); continue; }
+      this.report(task, task.final ?? 'done'); task.final = undefined;
+    }
     for (const cron of this.crons.values()) {
       if (cron.state !== 'handling') continue;
       if (cron.final !== undefined || !cron.recurring) { this.report(cron, 'done'); continue; }
       cron.at = nextRun(cron.schedule, this.now());
       this.report(cron, 'waiting', { at: cron.at === null ? undefined : new Date(cron.at).toISOString() });
     }
-    for (const own of this.own) this.report(own, 'done');
+    for (const own of this.own) this.report(own, error ? 'failed' : 'done', error ? { title, detail: cut(error, 4000) } : {});
     this.own.clear();
   }
   // A stop Coda asks of a wait: the task to stop when it still goes (null: none). One that ended and is yet to be taken in is

package/package.json

@@ -3,7 +3,7 @@
   "id": "claude",
   "displayName": "Claude",
   "description": "Claude SDK Agent：Coda 基于 Claude Agent SDK 写的 ACP 入口，一个进程一个 SDK 会话；资源页的「Claude」面板显示会话报告的额度，可从 Coda 登录。",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "categories": ["Agent"],
   "dependencies": {
     "@agentclientprotocol/sdk": "1.4.0",