@coda-console/claude 1.5.1 → 1.6.0

package/agent/last-listed.mjs

@@ -0,0 +1,34 @@
+// The same file in the Claude, Codex and OpenCode plugins: an agent plugin imports nothing of another's.
+// What a model service listed when it last answered, kept in the plugin's state directory (CODA_PLUGIN_STATE) under the
+// service's name. One that cannot be asked now (its machine restarting, the network to it down) is listed as it last said
+// rather than left out of the session's models, and of Coda's catalog of them for as long as that is kept; a request to it
+// fails then as any request to it would. One never listed here, or without a state directory, keeps its asking's error.
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const file = (state, ref) => join(state, 'service-models', `${ref.replaceAll('/', '.')}.json`);
+const readText = path => { try { return readFileSync(path, 'utf8'); } catch { return null; } };
+const kept = path => { try { const models = JSON.parse(readText(path)); return Array.isArray(models) ? models : null; } catch { return null; } };
+
+// `ask()`: the models the service lists now.
+export async function lastListed(ref, ask, state, log) {
+  let models;
+  try { models = await ask(); } catch (error) {
+    const last = state ? kept(file(state, ref)) : null;
+    if (!last) throw error;
+    log(`模型服务 ${ref} 列不出模型（${error.message}），沿用上次列出的 ${last.length} 个`);
+    return last;
+  }
+  if (state) remember(file(state, ref), JSON.stringify(models));
+  return models;
+}
+
+// Written when it is not that already, whole: another session's process may read it meanwhile.
+function remember(path, text) {
+  if (readText(path) === text) return;
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, text); renameSync(temporary, path);
+  } catch { /* Not kept: what the service listed still stands. */ }
+}

package/agent/providers.mjs

@@ -4,6 +4,7 @@
 // its API (`serviceSettings`), set for that session's process only.
 import { readFileSync } from 'node:fs';
 import { authOverrides } from './auth.mjs';
+import { lastListed } from './last-listed.mjs';
 
 export const SETTING = 'claude.modelProviders';
 const log = text => process.stderr.write(`[claude-agent] ${text}\n`);
@@ -25,15 +26,20 @@ export function chosenServices(env = process.env) {
   });
 }
 
-// The models a service lists, asked as an Anthropic client asks (Coda's「检查可用模型」): `<服务>/<模型>`, named by the
-// model, in the service's group. They have no effort to choose.
-export async function serviceModels({ ref, title, url, key }, fetcher = fetch) {
-  const at = `${url.replace(/\/+$/, '')}/models?limit=1000`;
-  const response = await fetcher(at, { headers: key ? { 'x-api-key': key, 'anthropic-version': '2023-06-01' } : {}, signal: AbortSignal.timeout(LIST_TIMEOUT) });
-  if (!response.ok) throw new Error(`${at} 回答 ${response.status}`);
-  const body = await response.json();
-  return (Array.isArray(body?.data) ? body.data : []).filter(model => typeof model?.id === 'string' && model.id)
-    .map(model => ({ id: `${ref}/${model.id}`, name: model.id, efforts: [], model: model.id, service: ref, group: title }));
+// The models a service lists, asked as an Anthropic client asks (Coda's「检查可用模型」), or as it last listed them when
+// it cannot be asked now (last-listed.mjs): `<服务>/<模型>`, named by the model, in the service's group. They have no
+// effort to choose.
+export async function serviceModels({ ref, title, url, key }, fetcher = fetch, state) {
+  const listed = await lastListed(ref, async () => {
+    const at = `${url.replace(/\/+$/, '')}/models?limit=1000`;
+    const response = await fetcher(at, { headers: key ? { 'x-api-key': key, 'anthropic-version': '2023-06-01' } : {}, signal: AbortSignal.timeout(LIST_TIMEOUT) });
+    if (!response.ok) throw new Error(`${at} 回答 ${response.status}`);
+    const body = await response.json();
+    // Only a list replaces the one kept: an answer of another shape is the service not answering.
+    if (!Array.isArray(body?.data)) throw new Error(`${at} 的回答不是模型列表`);
+    return body.data.filter(model => typeof model?.id === 'string' && model.id);
+  }, state, log);
+  return listed.map(model => ({ id: `${ref}/${model.id}`, name: model.id, efforts: [], model: model.id, service: ref, group: title }));
 }
 
 // The flag settings Claude Code runs a service's model with (above the machine's and the project's settings, its environment
@@ -46,10 +52,11 @@ export function serviceSettings({ url, key }, model) {
     CLAUDE_CODE_SUBAGENT_MODEL: model } };
 }
 
-// The services' models, listed with Claude's own in the order the services are chosen: none of one that cannot list them now.
-export async function listedModels(services) {
+// The services' models, listed with Claude's own in the order the services are chosen: none of one that cannot list them
+// now and never did (`state`: the plugin's state directory).
+export async function listedModels(services, state) {
   return (await Promise.all(services.map(async service => {
-    try { return await serviceModels(service); }
+    try { return await serviceModels(service, fetch, state); }
     catch (e) { log(`模型服务 ${service.ref} 列不出模型：${e.message}`); return []; }
   }))).flat();
 }

package/agent/session.mjs

@@ -41,6 +41,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']);
+// How many messages sent into a prompt (steer) may be waiting to be taken at once.
+const STEERING_LIMIT = 32;
 
 class InputStream {
   queue = []; wake = null; ended = false;
@@ -59,6 +61,9 @@ export class ClaudeSession {
   constructor({ sdk, env = process.env, environment = sdkEnvironment, initializationTimeoutMs = 60_000, onEnded = () => {} }) {
     Object.assign(this, { sdk, env, environment, initializationTimeoutMs, onEnded });
     this.phase = 'new'; this.input = new InputStream(); this.prompts = new Map(); this.withdrawals = new Set();
+    // The messages sent into the prompt's turn not yet taken (steer), the prompt whose own turn ended before they were, how
+    // the prompt ends once it is ending before they are taken (dropRest), and whether a native turn is going.
+    this.steering = new Set(); this.held = null; this.ending = null; this.turning = false;
     // The model services chosen in Coda (providers.mjs), and the service's model the query runs on: null on Claude's own.
     this.services = chosenServices(env); this.serviceModel = null;
     this.models = []; this.commands = []; this.terminal = null; this.current = { mode: 'default', model: undefined, effort: null };
@@ -70,18 +75,22 @@ export class ClaudeSession {
   connect(stream) {
     this.connection = agent({ name: 'coda-claude' })
       .onRequest('initialize', () => ({ protocolVersion: PROTOCOL_VERSION, agentInfo: SDK ? { name: 'claude-agent-sdk', version: SDK } : { name: 'coda-claude', version: '1' },
-        agentCapabilities: { loadSession: true, sessionCapabilities: { additionalDirectories: {}, systemPrompt: {} }, _meta: { coda: { waits: {} } } } }))
+        agentCapabilities: { loadSession: true, sessionCapabilities: { additionalDirectories: {}, systemPrompt: {} }, _meta: { coda: { waits: {} } } },
+        _meta: { steering: { supported: true } } }))
       // The SDK's own reading of these drops what its schema does not name, `systemPrompt` among them: they are read as sent.
       .onRequest('session/new', params => params ?? {}, ({ params }) => this.open(params))
       .onRequest('session/load', params => params ?? {}, ({ params }) => this.open(params, params.sessionId))
       .onRequest('session/set_config_option', ({ params }) => this.configure(params.configId, params.value))
       .onRequest('session/set_mode', async ({ params }) => { await this.configure('mode', params.modeId); return {}; })
       .onRequest('session/prompt', ({ params }) => this.prompt(params))
+      .onRequest('_session/steering', params => params ?? {}, ({ params }) => this.steer(params))
       .onNotification('session/cancel', ({ params }) => {
         if (params.sessionId !== this.sessionId) return;
         // While the session moves to another query there is none to interrupt: the turn waiting on the move is stopped there.
         if (this.rerouting) this.cancelling = true;
-        void this.query?.interrupt().catch(() => {});
+        // Messages sent into the turn and not taken yet (steer) are stopped with it: else Claude Code would run them after.
+        if (this.steering.size) this.dropRest({ stopReason: 'cancelled' });
+        else void this.query?.interrupt().catch(() => {});
       })
       .onRequest('_coda/wait/stop', params => params, ({ params }) => this.stopWait(params))
       .connect(stream);
@@ -146,7 +155,7 @@ export class ClaudeSession {
         onElicitation: (request, context) => this.elicitation(request, context),
         stderr: data => process.stderr.write(data),
       };
-      const listed = listedModels(this.services);
+      const listed = listedModels(this.services, this.env.CODA_PLUGIN_STATE);
       this.start(resume ? { resume } : { sessionId: this.sessionId });
       const initialization = await this.initialized(), served = await listed;
       if (this.phase !== 'starting') throw failure('Claude 会话在初始化时结束', -32001);
@@ -243,9 +252,46 @@ export class ClaudeSession {
     const id = randomUUID(), content = prompt.filter(block => block.type === 'text').map(block => block.text).join('\n');
     const answered = new Promise((resolve, reject) => this.prompts.set(id, { resolve, reject }));
     this.input.push({ type: 'user', uuid: id, session_id: this.sessionId, parent_tool_use_id: null, message: { role: 'user', content } });
+    this.heard(content);
+    return answered;
+  }
+  // A message into the turn going (docs/agent-protocol.md「插话」): Claude Code takes one sent with priority `next` into the
+  // turn it runs at its next tool round, and runs one the turn ended before as a turn of its own right after, which the
+  // prompt waits for too (result): either way it is that prompt's. With no prompt of Coda's going, Coda sends it as the next.
+  // A result names at most 64 of the messages it took in (the SDK's user_message_uuids): few enough go in at a time that each is
+  // named; one more is Coda's to send as the next turn, as it is with no turn going.
+  steer({ prompt }) {
+    if (this.phase !== 'running' || !this.prompts.size || this.ending) return { outcome: 'promptRequired', reason: 'noRunningTurn' };
+    if (this.steering.size >= STEERING_LIMIT) return { outcome: 'promptRequired', reason: 'tooManyPending' };
+    const id = randomUUID(), content = prompt.filter(block => block.type === 'text').map(block => block.text).join('\n');
+    this.steering.add(id);
+    this.input.push({ type: 'user', uuid: id, session_id: this.sessionId, parent_tool_use_id: null, priority: 'next', message: { role: 'user', content } });
+    this.heard(content);
+    return { outcome: 'injected' };
+  }
+  // What was said into the prompt and is not taken yet is not to run after it ends, stopped or failed: Claude Code drops it
+  // (cancelQueued), and the prompt ends as `outcome` once nothing of it goes on — at the drop's receipt when no native turn
+  // is going (one held, whose own turn ended), else as the turn going ends (result).
+  dropRest(outcome) {
+    this.ending = outcome;
+    void this.query?.interrupt({ cancelQueued: true }).then(receipt => {
+      for (const id of receipt?.cancelled ?? []) this.steering.delete(id);
+      if (this.held && !this.turning) this.settle(this.held, this.ending);
+    }, () => {});
+  }
+  // The prompt answered: as it ended, and with nothing of it left to take.
+  settle(id, { stopReason, failure: error }) {
+    const prompt = this.prompts.get(id);
+    this.prompts.delete(id); this.held = null; this.ending = null; this.steering.clear();
+    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 });
+  }
+  // What is said to the session goes into what its title is made of.
+  heard(content) {
     this.titleContext = ((this.titleContext ?? '') + '\n' + content + '\n').slice(-1000);
     if (this.title) { this.title.append(this.titleContext); this.titleContext = ''; }
-    return answered;
   }
   async stopWait({ waitId }) {
     const taskId = this.phase === 'running' ? this.waits.stop(waitId) : null;
@@ -296,7 +342,7 @@ export class ClaudeSession {
   end(query, error) {
     if (this.phase === 'ended') return;
     const intended = this.phase === 'closing';
-    this.phase = 'ended'; this.input.close();
+    this.phase = 'ended'; this.input.close(); this.steering.clear(); this.held = null; this.ending = null;
     for (const withdrawn of this.withdrawals) withdrawn.abort();
     for (const { reject } of this.prompts.values()) reject(failure(error?.message ?? 'Claude 会话已结束'));
     this.prompts.clear();
@@ -319,6 +365,7 @@ export class ClaudeSession {
     switch (m.subtype) {
       case 'init': {
         if (m.session_id !== this.sessionId) return;
+        this.turning = true;
         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.
@@ -444,13 +491,18 @@ export class ClaudeSession {
     const usage = m.usage ?? {}, windows = Object.values(m.modelUsage ?? {});
     this.update(this.sessionId, { sessionUpdate: 'usage_update', used: (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0),
       size: Math.max(0, ...windows.map(w => w.contextWindow ?? 0)), cost: { amount: m.total_cost_usd ?? 0, currency: 'USD' } });
-    const ids = m.user_message_uuids ?? (m.user_message_uuid ? [m.user_message_uuid] : []), id = ids.find(id => this.prompts.has(id));
+    this.turning = false;
+    const ids = m.user_message_uuids ?? (m.user_message_uuid ? [m.user_message_uuid] : []);
+    // A message sent into the prompt's turn (steer) is the prompt's, and so is the turn Claude Code runs it in when the prompt's
+    // own ended before taking it: the prompt is answered once none is left to take. Stopped or failed with some not taken
+    // yet, it ends once those are dropped (dropRest); one ending already ends as it was to.
+    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');
     if (id) {
-      const prompt = this.prompts.get(id); this.prompts.delete(id);
-      // What ended before this turn ended was taken in by it.
-      this.waits.settled();
-      if (failed) prompt.reject(failure(errorText(m))); else prompt.resolve({ stopReason: cancelled ? 'cancelled' : 'end_turn' });
+      const outcome = this.ending ?? (failed ? { failure: errorText(m) } : { 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));

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.5.1",
+  "version": "1.6.0",
   "categories": ["Agent"],
   "dependencies": {
     "@agentclientprotocol/sdk": "1.4.0",