@coda-console/claude 1.7.1 → 1.7.6

package/agent/permissions.mjs

@@ -3,6 +3,7 @@
 // can change Claude's permissions.
 import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
+import { toolCallFields } from './tools.mjs';
 
 const deny = { behavior: 'deny', message: '用户未批准此操作' };
 
@@ -12,8 +13,8 @@ export function permissionRequest({ sessionId, toolName, input, context = {} })
   const options = [{ optionId: 'allow-once', name: '仅允许本次', kind: 'allow_once' },
     ...suggestions.map((change, i) => ({ optionId: `suggestion-${i}`, name: describeChange(change, input), kind: 'allow_always' })),
     { optionId: 'deny', name: '拒绝', kind: 'reject_once' }];
-  const params = { sessionId, options, toolCall: { toolCallId: context.toolUseID ?? randomUUID(), title: toolName, rawInput: input, status: 'pending',
-    ...(context.decisionReason ? { content: [{ type: 'content', content: { type: 'text', text: context.decisionReason } }] } : {}) } };
+  const params = { sessionId, options, toolCall: { toolCallId: context.toolUseID ?? randomUUID(), status: 'pending',
+    ...toolCallFields(toolName, input, context.decisionReason ? [{ type: 'content', content: { type: 'text', text: context.decisionReason } }] : []) } };
   const answer = response => {
     const { outcome, optionId } = response?.outcome ?? {};
     if (outcome !== 'selected') return deny;

package/agent/session.mjs

@@ -17,6 +17,7 @@ import { chosenServices, 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';
+import { toolCallFields, ToolCallCache } from './tools.mjs';
 import { elicitationForm, questionForm } from './questions.mjs';
 import { ClaudeWaits } from './waits.mjs';
 import { CacheUse } from './compaction.mjs';
@@ -81,7 +82,7 @@ export class ClaudeSession {
     this.services = chosenServices(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;
+    this.streams = new Map(); this.streamed = new Map(); this.tools = new ToolCallCache(); this.children = new Set(); this.early = new Map(); this.compaction = null;
     this.waits = new ClaudeWaits({ say: (params, sessionId = this.sessionId) => this.notify('_coda/wait', { sessionId, ...params }),
       going: () => this.prompts.size > 0 || this.waits.handling, registered: sessionId => this.registered(sessionId) });
     // What is told of the main thread's cache (compaction.mjs); while a compaction Coda asked for goes, its input and answer; and
@@ -547,8 +548,9 @@ export class ClaudeSession {
     }
     for (const block of m.message?.content ?? []) {
       if (block.type === 'tool_use') {
-        this.tools.add(block.id);
-        this.update(sessionId, { sessionUpdate: 'tool_call', toolCallId: block.id, title: block.name, rawInput: block.input, status: 'in_progress' });
+        const fields = toolCallFields(block.name, block.input);
+        this.tools.start(block.id, block.name, fields.content ?? []);
+        this.update(sessionId, { sessionUpdate: 'tool_call', toolCallId: block.id, ...fields, status: 'in_progress' });
       } else if (['text', 'thinking'].includes(block.type)) {
         const said = block.text ?? block.thinking ?? '';
         // One complete packet carries one block of the message: the first streamed one of its kind not yet confirmed.
@@ -561,17 +563,20 @@ export class ClaudeSession {
   }
   toolResults(m, parent) {
     for (const block of Array.isArray(m.message?.content) ? m.message.content : []) {
-      if (block.type !== 'tool_result' || !this.tools.has(block.tool_use_id)) continue;
+      if (block.type !== 'tool_result') continue;
+      const content = this.tools.finish(block.tool_use_id, m.tool_use_result, block.is_error);
+      if (!content) continue;
       const said = text(block.content);
       this.update(parent ?? this.sessionId, { sessionUpdate: 'tool_call_update', toolCallId: block.tool_use_id, status: block.is_error ? 'failed' : 'completed',
-        rawOutput: m.tool_use_result ?? block.content, content: [{ type: 'content', content: { type: 'text', text: said } }] });
+        // ACP content updates replace the list: keep the latest diffs alongside the result text.
+        rawOutput: m.tool_use_result ?? block.content, content: [...content, { type: 'content', content: { type: 'text', text: said } }] });
       // Claude Code says where a command it put in the background writes in the launch's result.
       const path = said.match(/Output is being written to: (\S+?\.output)\b/)?.[1];
       if (path) this.waits.outputFile(block.tool_use_id, path);
     }
   }
   result(m) {
-    const usage = m.usage ?? {}, windows = Object.values(m.modelUsage ?? {});
+    const windows = Object.values(m.modelUsage ?? {});
     const ids = takenIn(m);
     // The compaction Coda asked for (compact) is the turn that names its input. Any other is the session's own, whose cache runs
     // from its last request. Coda is told what is known of that cache (compaction.mjs).
@@ -581,8 +586,10 @@ export class ClaudeSession {
     this.turnCompaction = {};
     if (!compaction) { this.cacheUse.ended(); for (const output of turn.outputs ?? []) this.commandOutput(output); }
     const told = this.cacheUse.told();
-    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' },
+    // The result's usage sums every request in the turn. The window holds only the last main-thread request, or what
+    // compaction left. With no measurement, report no usable window; lifecycle metadata is still told.
+    this.update(this.sessionId, { sessionUpdate: 'usage_update', used: this.cacheUse.context ?? 0,
+      size: this.cacheUse.context === null ? 0 : Math.max(0, ...windows.map(w => w.contextWindow ?? 0)), cost: { amount: m.total_cost_usd ?? 0, currency: 'USD' },
       ...(Object.keys(told).length ? { _meta: { coda: told } } : {}) });
     this.turning = false;
     // The compaction's: Coda is answered, and nothing is taken up.

package/agent/tools.mjs

@@ -0,0 +1,102 @@
+// Claude Agent SDK 0.3.296's sdk-tools.d.ts, plus names used by older Claude Code sessions.
+// Only native tool names carry these meanings; MCP tools and unknown tools stay `other`.
+const kinds = new Map(Object.entries({
+  execute: ['Bash', 'BashOutput', 'KillBash', 'KillShell', 'TaskOutput', 'TaskStop', 'Monitor'],
+  read: ['Read', 'NotebookRead'],
+  edit: ['Edit', 'MultiEdit', 'Write', 'NotebookEdit'],
+  search: ['Grep', 'Glob', 'LS'],
+  fetch: ['WebFetch', 'WebSearch'],
+  think: ['TodoWrite', 'EnterPlanMode', 'ExitPlanMode', 'TaskCreate', 'TaskGet', 'TaskUpdate', 'TaskList', 'ReportFindings', 'ProposeGoal'],
+}).flatMap(([kind, names]) => names.map(name => [name, kind])));
+
+const string = value => typeof value === 'string';
+const firstLine = value => string(value) ? value.split(/\r\n|\r|\n/, 1)[0].trim() : '';
+const short = value => { const chars = Array.from(firstLine(value)); return chars.length > 200 ? `${chars.slice(0, 199).join('')}…` : chars.join(''); };
+
+// Pure presentation shared by calls and permission requests. rawInput is the SDK's original object.
+// Existing content (e.g. why permission is needed) accompanies the diffs, never replaces them.
+export function toolCallFields(name, rawInput, content = []) {
+  const input = rawInput ?? {}, kind = kinds.get(name) ?? 'other';
+  const path = ['read', 'edit'].includes(kind) ? (input.file_path ?? input.notebook_path) : undefined;
+  const hasPath = string(path) && path.length > 0;
+  let title = name;
+  if (kind === 'execute') title = short(input.command) || name;
+  if (kind === 'search') title = short(input.pattern ?? input.query ?? input.path) || name;
+  if (kind === 'fetch') title = short(input.url ?? input.query) || name;
+  if (hasPath) title = short(`${kind === 'read' ? '读取' : '编辑'} ${path}`);
+
+  const diffs = [];
+  if (hasPath) {
+    if (name === 'Write' && string(input.content)) diffs.push({ type: 'diff', path, oldText: null, newText: input.content });
+    const edits = name === 'Edit' ? [input] : name === 'MultiEdit' && Array.isArray(input.edits) ? input.edits : [];
+    for (const edit of edits) {
+      if (string(edit?.old_string) && string(edit?.new_string)) diffs.push({ type: 'diff', path, oldText: edit.old_string, newText: edit.new_string });
+    }
+  }
+  const combined = [...diffs, ...content];
+  return { title, kind, rawInput,
+    ...(hasPath ? { locations: [{ path, ...(name === 'Read' && Number.isInteger(input.offset) && input.offset >= 0 ? { line: Math.max(1, input.offset) } : {}) }] } : {}),
+    ...(combined.length ? { content: combined } : {}),
+  };
+}
+
+// A patch line includes its newline unless the immediately following marker says otherwise.
+// Context belongs to both sides; a marker after '-' or '+' only applies to that side.
+function patchText(lines, side) {
+  return lines.map((line, i) => line.startsWith(side) || line.startsWith(' ')
+    ? line.slice(1) + (lines[i + 1] === '\' ? '' : '\n') : '').join('');
+}
+
+// A successful SDK result is authoritative: a Write may overwrite a file, and an Edit may replace
+// many occurrences or be changed by the user. Keep previews only when no structured result is given.
+export function toolResultContent(name, content, result, failed = false) {
+  if (failed || !['Edit', 'MultiEdit', 'Write'].includes(name) || !string(result?.filePath)) return content;
+  let diffs;
+  if (result.staged === true) diffs = []; // SDK: held for review, the file is unchanged.
+  else if (name === 'Write' && string(result.content)
+    && (string(result.originalFile) || (result.type === 'create' && result.originalFile === null))) {
+    diffs = [{ type: 'diff', path: result.filePath, oldText: result.originalFile, newText: result.content }];
+  } else if (Array.isArray(result.structuredPatch)
+    && result.structuredPatch.every(hunk => Array.isArray(hunk?.lines) && hunk.lines.every(string))) {
+    // Each hunk carries both sides, including context. Do not merge distant hunks: that would
+    // invent adjacent lines and can undercount independent replacements.
+    diffs = result.structuredPatch.map(hunk => ({ type: 'diff', path: result.filePath,
+      oldText: patchText(hunk.lines, '-'), newText: patchText(hunk.lines, '+'),
+    }));
+  }
+  // An update whose original text was too large and whose patch is empty has no measurable diff;
+  // in particular, do not keep the input preview that would report it as a newly created file.
+  return diffs === undefined ? content : [...diffs, ...content.filter(block => block.type !== 'diff')];
+}
+
+// Pending calls must survive other tools finishing. Completed calls only serve repeated SDK results:
+// keep the most recently completed 128 calls, with at most 4 MiB of estimated string storage.
+// Evicted results are ignored, so they cannot overwrite the diff already sent to the client.
+export class ToolCallCache {
+  #pending = new Map(); #completed = new Map(); #bytes = 0;
+  constructor({ maxCompleted = 128, maxBytes = 4 * 1024 * 1024 } = {}) {
+    this.maxCompleted = maxCompleted; this.maxBytes = maxBytes;
+  }
+  #forget(id) {
+    const entry = this.#completed.get(id);
+    if (entry) { this.#bytes -= entry.bytes; this.#completed.delete(id); }
+  }
+  start(id, name, content) {
+    this.#forget(id);
+    this.#pending.set(id, { name, content });
+  }
+  finish(id, result, failed = false) {
+    const previous = this.#pending.get(id) ?? this.#completed.get(id)?.tool;
+    if (!previous) return undefined;
+    const tool = { name: previous.name, content: toolResultContent(previous.name, previous.content, result, failed) };
+    this.#pending.delete(id); this.#forget(id);
+    // Two bytes per UTF-16 code unit, including ID and serialized field names; the count limit also
+    // bounds object overhead. An oversized result is delivered once without evicting smaller entries.
+    const bytes = 2 * (id.length + JSON.stringify(tool).length);
+    if (bytes <= this.maxBytes) {
+      this.#completed.set(id, { tool, bytes }); this.#bytes += bytes;
+      while (this.#completed.size > this.maxCompleted || this.#bytes > this.maxBytes) this.#forget(this.#completed.keys().next().value);
+    }
+    return tool.content;
+  }
+}

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