@coda-console/claude 1.3.1 → 1.4.1

package/agent/auth.mjs

@@ -3,7 +3,7 @@ import { open } from 'node:fs/promises';
 import { isAbsolute } from 'node:path';
 
 // Variables that make the Claude CLI use something other than the user's normal login.
-const authOverrides = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'ANTHROPIC_CUSTOM_HEADERS',
+export const authOverrides = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'ANTHROPIC_CUSTOM_HEADERS',
   'CLAUDE_CODE_OAUTH_TOKEN', 'CLAUDE_CODE_OAUTH_REFRESH_TOKEN', 'CLAUDE_CODE_OAUTH_SCOPES',
   'CLAUDE_CODE_USE_BEDROCK', 'CLAUDE_CODE_USE_VERTEX', 'CLAUDE_CODE_USE_FOUNDRY'];
 

package/agent/providers.mjs

@@ -0,0 +1,53 @@
+// The model service chosen in Coda (`claude.modelProvider`, Coda's docs/plugins.md「模型服务」): another plugin's service that
+// speaks Anthropic Messages, from CODA_MODEL_PROVIDERS. The models its address lists (`<地址>/models`) join Claude's own, each
+// named by the service and the model; a session on one runs Claude Code with the service as its API (`serviceSettings`), set
+// for that session's process only.
+import { readFileSync } from 'node:fs';
+import { authOverrides } from './auth.mjs';
+
+export const SETTING = 'claude.modelProvider';
+const log = text => process.stderr.write(`[claude-agent] ${text}\n`);
+const parse = text => { try { return JSON.parse(text || '{}'); } catch { return {}; } };
+const LIST_TIMEOUT = 8000;
+
+// The chosen service: its address, title and key (read from the file Coda keeps it in). Null when none is chosen, or the
+// one chosen is not on this machine or speaks another API.
+export function chosenService(env = process.env) {
+  const ref = parse(env.CODA_PLUGIN_SETTINGS)[SETTING];
+  if (!ref) return null;
+  const provided = parse(env.CODA_MODEL_PROVIDERS)[ref];
+  if (!provided?.url) { log(`模型服务 ${ref} 在这台机器上没有`); return null; }
+  if (provided.api !== 'anthropic-messages') { log(`模型服务 ${ref} 讲 ${provided.api}，Claude 只接 anthropic-messages 的`); return null; }
+  let key;
+  try { key = provided.keyFile ? readFileSync(provided.keyFile, 'utf8').trim() || undefined : undefined; }
+  catch (e) { log(`读不到模型服务 ${ref} 的 Key：${e.message}`); }
+  return { ref, title: provided.title || ref, url: provided.url, key };
+}
+
+// The models the service lists, asked as an Anthropic client asks (Coda's「检查可用模型」): `<服务>/<模型>`, named by the
+// model and the service. 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} (${title})`, efforts: [], model: model.id }));
+}
+
+// The flag settings Claude Code runs a service's model with (above the machine's and the project's settings, its environment
+// beneath them): the service as its API, a token of the service's own (`none` without one), and the model for every role,
+// subagents' and background work's included. None of the machine's own ways to the API goes with it: an API key, a key
+// helper, an OAuth token or custom headers would be sent to the service, a cloud provider's would take the requests away.
+export function serviceSettings({ url, key }, model) {
+  return { apiKeyHelper: '', env: { ...Object.fromEntries(authOverrides.map(name => [name, ''])), ANTHROPIC_BASE_URL: url, ANTHROPIC_AUTH_TOKEN: key ?? 'none',
+    ANTHROPIC_MODEL: model, ANTHROPIC_DEFAULT_OPUS_MODEL: model, ANTHROPIC_DEFAULT_SONNET_MODEL: model, ANTHROPIC_DEFAULT_HAIKU_MODEL: model,
+    CLAUDE_CODE_SUBAGENT_MODEL: model } };
+}
+
+// The service's models, listed with Claude's own: none when it cannot list them now.
+export async function listedModels(service) {
+  if (!service) return [];
+  try { return await serviceModels(service); }
+  catch (e) { log(`模型服务 ${service.ref} 列不出模型：${e.message}`); return []; }
+}

package/agent/session.mjs

@@ -11,6 +11,7 @@ import { join } from 'node:path';
 import { agent, PROTOCOL_VERSION, RequestError } from '@agentclientprotocol/sdk';
 import { ClaudeSessionLimits, accountHash } from './limits.mjs';
 import { sdkEnvironment } from './auth.mjs';
+import { chosenService, listedModels, serviceSettings } from './providers.mjs';
 import { SessionTitle } from './titles.mjs';
 import { MODEL_EFFORT, MODES, claudeModels, configOptions, reportedModel } from './models.mjs';
 import { permissionRequest } from './permissions.mjs';
@@ -58,6 +59,8 @@ 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 model service chosen in Coda (providers.mjs), and the model of it the query runs on: null on Claude's own.
+    this.service = chosenService(env); this.serviceModel = null;
     this.models = []; this.commands = []; this.terminal = null; this.current = { mode: 'default', model: undefined, effort: null };
     // Streamed text by API message, so that the complete message adds only what was not streamed; tool calls said.
     this.streams = new Map(); this.streamed = new Map(); this.tools = new Set(); this.children = new Set(); this.early = new Map(); this.compaction = null;
@@ -74,7 +77,12 @@ export class ClaudeSession {
       .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))
-      .onNotification('session/cancel', ({ params }) => { if (params.sessionId === this.sessionId) void this.query?.interrupt().catch(() => {}); })
+      .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(() => {});
+      })
       .onRequest('_coda/wait/stop', params => params, ({ params }) => this.stopWait(params))
       .connect(stream);
     this.client = this.connection.client;
@@ -114,7 +122,8 @@ export class ClaudeSession {
       // Coda's servers are stdio ones; the SDK keys them by name.
       const servers = Object.fromEntries(mcpServers.filter(server => typeof server.command === 'string').map(({ name, command, args = [], env = [] }) =>
         [name, { command, args, ...(env.length ? { env: Object.fromEntries(env.map(variable => [variable.name, variable.value])) } : {}) }]));
-      this.query = this.sdk.query({ prompt: this.input, options: {
+      // What every query of the session starts with; a model of the chosen service runs in a query of its own (`reroute`).
+      this.launch = {
         // Skipping every approval is a mode the user may switch to later; the SDK refuses it unless allowed at start.
         permissionMode: 'default', allowDangerouslySkipPermissions: true, settingSources: ['user', 'project', 'local'],
         // Coda's session instructions (what its clients render, what the project's plugins say) follow Claude Code's own.
@@ -124,7 +133,6 @@ export class ClaudeSession {
         settings: { crossSessionInbound: 'refuse' },
         includePartialMessages: true, forwardSubagentText: true, cwd: dir,
         ...(Object.keys(servers).length ? { mcpServers: servers } : {}), ...(additionalDirectories.length ? { additionalDirectories } : {}),
-        ...(resume ? { resume } : { sessionId: this.sessionId }),
         // Claude Code reports running and idle only when asked: idle is what ends a task's wait.
         env: { ...environment, CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS: '1' },
         // Stop supplies the complete list of scheduled wakeups. A CronCreate result alone cannot tell whether one was later
@@ -137,15 +145,12 @@ export class ClaudeSession {
         canUseTool: (toolName, input, context) => this.permission(toolName, input, context),
         onElicitation: (request, context) => this.elicitation(request, context),
         stderr: data => process.stderr.write(data),
-      } });
-      this.pump = this.consume();
-      let timer;
-      const initialization = await Promise.race([this.query.initializationResult(),
-        this.pump.then(() => { throw failure('Claude 会话在初始化时结束', -32001); }),
-        new Promise((_, reject) => { timer = setTimeout(() => reject(failure('Claude 初始化超时', -32001)), this.initializationTimeoutMs); })])
-        .finally(() => clearTimeout(timer));
+      };
+      const listed = listedModels(this.service);
+      this.start(resume ? { resume } : { sessionId: this.sessionId });
+      const initialization = await this.initialized(), served = await listed;
       if (this.phase !== 'starting') throw failure('Claude 会话在初始化时结束', -32001);
-      this.models = claudeModels(initialization.models); this.commands = initialization.commands ?? [];
+      this.models = [...claudeModels(initialization.models), ...served]; this.commands = initialization.commands ?? [];
       // Who the session runs as, for the「Claude」panel (limits.mjs): the windows it reports are that account's, and
       // only while the panel is of that account.
       const email = initialization.account?.email;
@@ -159,6 +164,49 @@ export class ClaudeSession {
       throw error instanceof RequestError ? error : failure(error?.message || 'Claude 会话启动失败');
     }
   }
+  // A query of the session, reading a prompt stream of its own: on Claude's own models, or on `model` of the chosen
+  // service, which it runs with that service as its API and that model for every role. One started after the session
+  // opened goes on with the model, mode and effort chosen.
+  start(at, model) {
+    this.input = new InputStream();
+    const entry = this.served(model);
+    const settings = { ...this.launch.settings, ...(this.current.effort ? { effortLevel: this.current.effort } : {}),
+      ...(entry ? serviceSettings(this.service, entry.model) : {}) };
+    this.serviceModel = entry ? model : null;
+    this.query = this.sdk.query({ prompt: this.input, options: { ...this.launch, ...at, settings,
+      ...(this.phase === 'running' ? { permissionMode: this.current.mode, model: entry ? entry.model : this.current.model } : {}) } });
+    this.pump = this.consume(this.query);
+  }
+  async initialized() {
+    let timer;
+    return Promise.race([this.query.initializationResult(),
+      this.pump.then(() => { throw failure('Claude 会话在初始化时结束', -32001); }),
+      new Promise((_, reject) => { timer = setTimeout(() => reject(failure('Claude 初始化超时', -32001)), this.initializationTimeoutMs); })])
+      .finally(() => clearTimeout(timer));
+  }
+  // The model chosen is of another service than the query's (Claude's own, or the chosen service's): the session goes on in a
+  // query started for it, resuming what the last one said. Before a turn, as Coda sets a session's model before each.
+  async reroute() {
+    const previous = this.query;
+    this.query = null; this.input.close();
+    try { previous.close(); } catch {}
+    await this.pump;
+    if (this.phase !== 'running') throw failure('Claude 会话未在运行', -32001);
+    // One that cannot be started, or does not start, ends the session, as one that ends of itself does: no later turn waits on it.
+    try {
+      const said = await this.sdk.getSessionInfo(this.sessionId, { dir: this.cwd });
+      this.start(said ? { resume: this.sessionId } : { sessionId: this.sessionId }, this.current.model);
+      if (this.title) this.title.query = this.query;
+      await this.initialized();
+    } catch (error) {
+      this.end(this.query, error);
+      throw error instanceof RequestError ? error : failure(error?.message || 'Claude 会话启动失败');
+    }
+  }
+  // The chosen service's model that `model` is; null for one of Claude's own.
+  served(model) { return this.models.find(m => m.id === model && m.model) ?? null; }
+  // Whether the next turn runs in another query than this one: on the service's models, or back on Claude's own.
+  rerouted() { return (this.served(this.current.model)?.id ?? null) !== this.serviceModel; }
   async configure(configId, value) {
     if (this.phase !== 'running') throw failure('Claude 会话未在运行', -32001);
     if (configId === 'mode') {
@@ -166,7 +214,12 @@ export class ClaudeSession {
       await this.query.setPermissionMode(value); this.current.mode = value;
     } else if (configId === 'model') {
       if (!this.models.some(model => model.id === value)) throw failure('模型不可用', -32602);
-      await this.query.setModel(value); this.current.model = value;
+      // Between Claude's own models the query switches; to or from the service's, the next turn runs in another one, and
+      // what this one still runs would end with it.
+      const switching = (this.served(value)?.id ?? null) !== this.serviceModel;
+      if (switching && (this.prompts.size || this.waits.pending)) throw failure('后台任务、子 Agent 或定时唤醒还没结束，结束后才能换到这个模型', -32602);
+      if (!switching && !this.serviceModel) await this.query.setModel(value);
+      this.current.model = value;
       // An effort chosen for the last model that this one does not have is no choice of it: the model's own goes on.
       if (this.current.effort !== null && !this.models.find(model => model.id === value).efforts.includes(this.current.effort)) {
         await this.query.applyFlagSettings({ effortLevel: null }); this.current.effort = null;
@@ -179,8 +232,14 @@ export class ClaudeSession {
     return { configOptions: this.options() };
   }
   // Answered when the native result that names this input arrives; accepting it into the input says nothing yet.
-  prompt({ prompt }) {
+  async prompt({ prompt }) {
     if (this.phase !== 'running') throw failure('Claude 会话未在运行', -32001);
+    if (this.rerouted()) {
+      if (!this.rerouting) { this.cancelling = false; this.rerouting = this.reroute().finally(() => { this.rerouting = null; }); }
+      await this.rerouting;
+      // Stopped while it moved: the input is not given to the new query.
+      if (this.cancelling) { this.cancelling = false; return { stopReason: 'cancelled' }; }
+    }
     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 } });
@@ -222,23 +281,27 @@ export class ClaudeSession {
     } catch { return fallback; } finally { signal?.removeEventListener('abort', withdraw); this.withdrawals.delete(withdrawn); }
   }
 
-  async consume() {
+  async consume(query) {
     let error;
     try {
-      for await (const message of this.query) {
+      for await (const message of query) {
         try { this.receive(message); }
         catch (failed) { process.stderr.write(`Claude 消息处理失败：${failed.message}\n`); }
       }
     } catch (value) { if (this.phase !== 'closing') error = value; }
-    finally {
-      const intended = this.phase === 'closing';
-      this.phase = 'ended'; this.input.close();
-      for (const withdrawn of this.withdrawals) withdrawn.abort();
-      for (const { reject } of this.prompts.values()) reject(failure(error?.message ?? 'Claude 会话已结束'));
-      this.prompts.clear();
-      try { this.query.close(); } catch {}
-      if (!intended) this.onEnded(error);
-    }
+    // The session ends with its query; one it moved off, for another model's, ends with nothing to say.
+    if (query === this.query) this.end(query, error);
+  }
+  // The session ends with its query: what waits on it is let go, and the entry told unless it was closing.
+  end(query, error) {
+    if (this.phase === 'ended') return;
+    const intended = this.phase === 'closing';
+    this.phase = 'ended'; this.input.close();
+    for (const withdrawn of this.withdrawals) withdrawn.abort();
+    for (const { reject } of this.prompts.values()) reject(failure(error?.message ?? 'Claude 会话已结束'));
+    this.prompts.clear();
+    try { query?.close(); } catch {}
+    if (!intended) this.onEnded(error);
   }
   receive(m) {
     const parent = m.parent_tool_use_id ?? null;
@@ -257,8 +320,9 @@ export class ClaudeSession {
       case 'init': {
         if (m.session_id !== this.sessionId) return;
         this.terminal = m.terminal_slash_commands ?? [];
-        // Its effort is the one applied, the model's own included: what was chosen stays what it was.
-        this.current = { ...this.current, model: reportedModel(this.models, this.current.model, m.model), mode: m.permissionMode ?? this.current.mode };
+        // 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 the service's name for it.
+        this.current = { ...this.current, model: this.serviceModel ?? reportedModel(this.models, this.current.model, m.model), mode: m.permissionMode ?? this.current.mode };
         if (!this.title) {
           const sessionId = this.sessionId;
           this.title = new SessionTitle({ sdk: this.sdk, query: this.query, cwd: this.cwd, sessionId, alive: () => ['starting', 'running'].includes(this.phase),

package/agent/waits.mjs

@@ -21,6 +21,8 @@ export class ClaudeWaits {
     this.models = new Map(); this.outputs = new Map();
   }
   get handling() { return this.own.size > 0 || [...this.tasks.values(), ...this.crons.values()].some(w => w.state === 'handling'); }
+  // Whether anything is still waited on: what ends with the Claude process that runs it.
+  get pending() { return this.own.size > 0 || [...this.tasks.values(), ...this.crons.values()].some(w => open(w.state)); }
   report(wait, state, fields = {}) {
     wait.state = state;
     const params = { waitId: wait.waitId, state, ...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined)) };

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.3.1",
+  "version": "1.4.1",
   "dependencies": {
     "@agentclientprotocol/sdk": "1.4.0",
     "@anthropic-ai/claude-agent-sdk": "0.3.296"
@@ -32,6 +32,18 @@
         "setupHint": "请在运行机配置 Claude SDK 认证；若指定了 token 文件，请检查路径和权限。"
       }
     ],
+    "configuration": {
+      "title": "Claude",
+      "properties": {
+        "claude.modelProvider": {
+          "type": "string",
+          "format": "coda-model-provider",
+          "title": "模型服务",
+          "order": 1,
+          "description": "选一个插件提供的模型服务（如 Magpie），它列出的模型和 Claude 自己的模型一起出现在会话的模型里；选中它的模型，那个会话就走这个服务，Claude 自己的模型照旧。只接 Anthropic 接口（anthropic-messages）的服务。"
+        }
+      }
+    },
     "panels": [
       {
         "id": "limits",