@coda-console/codex 1.8.3 → 1.8.5

package/agent/entry.mjs

@@ -1,6 +1,6 @@
 // The Codex agent as Coda starts it (the plugin's `contributes.agents`): the locked codex-acp, run in this process with Coda's
 // patches, which fail the start once the adapter changes. Between it and Coda the entry speaks Coda's protocol for it
-// (waits.mjs, docs/agent-protocol.md): its session instructions become the thread's developer instructions (instructions.mjs),
+// (waits.mjs, docs/agent-protocol.md), and of its own check of a call as that call's (reviews.mjs): its session instructions become the thread's developer instructions (instructions.mjs),
 // and a steer that finds no turn going is answered `promptRequired` (steering.mjs); the models of the model service chosen in
 // Coda join Codex's own (providers.mjs). What Coda wants of Codex beyond ACP is set here: the mode a session starts in, and
 // which Codex program runs, through the account bridge when another plugin chooses the account (accounts.mjs).
@@ -22,7 +22,9 @@ import { promptRequiredCodexSteering } from './steering.mjs';
 import { servedCodexModels } from './providers.mjs';
 import { input, listen, relayedCodexStreams } from './relay.mjs';
 import { CodexWaits } from './waits.mjs';
+import { CodexReviews } from './reviews.mjs';
 import { explainCodexError, reportedCodexFailures } from './errors.mjs';
+import { reportedCodexSleeps } from './sleep.mjs';
 
 const env = process.env;
 // A session starts read-only, unless its machine's configuration says otherwise.
@@ -47,8 +49,8 @@ if (!env.CODEX_PATH && accountSource(env) && env.CODA_PLUGIN_STATE) {
 
 const version = codexVersion();
 const waits = new CodexWaits({ agentInfo: version ? { name: 'codex', version } : null }), parse = line => { try { return JSON.parse(line); } catch { return null; } };
-const say = message => process.stdout.write(`${JSON.stringify(message)}\n`);
-listen(line => { for (const message of waits.fromAgent(parse(line))) say(explainCodexError(message)); });
+const reviews = new CodexReviews(), say = message => process.stdout.write(`${JSON.stringify(message)}\n`);
+listen(line => { for (const message of waits.fromAgent(parse(line))) for (const each of reviews.fromAgent(message)) say(explainCodexError(each)); });
 readLines(process.stdin).on('line', line => {
   const message = parse(line);
   if (!message || typeof message !== 'object') return;
@@ -62,7 +64,7 @@ const adapter = new URL(import.meta.resolve('@agentclientprotocol/codex-acp'));
 registerHooks({ load(url, context, nextLoad) {
   const loaded = nextLoad(url, context);
   if (url !== adapter.href) return loaded;
-  return { ...loaded, source: reportedCodexFailures(codexOptionsAsShown(relayedCodexStreams(orderedCodexTitles(followCodexProcessExit(continuedCodexSubagents(
-    promptRequiredCodexSteering(instructedCodexThreads(servedCodexModels(networkedCodexDevelopment(Buffer.from(loaded.source).toString('utf8'))))))))))) };
+  return { ...loaded, source: reportedCodexSleeps(reportedCodexFailures(codexOptionsAsShown(relayedCodexStreams(orderedCodexTitles(followCodexProcessExit(continuedCodexSubagents(
+    promptRequiredCodexSteering(instructedCodexThreads(servedCodexModels(networkedCodexDevelopment(Buffer.from(loaded.source).toString('utf8')))))))))))) };
 } });
 await import(adapter.href);

package/agent/reviews.mjs

@@ -0,0 +1,55 @@
+// Codex's own check of a call before running it (its automatic approval review), said to Coda as part of that call
+// (docs/agent-protocol.md「工具调用的审核」). codex-acp makes each check a call of its own, `Guardian Review`
+// (`guardian_assessment:<id>`), which names the call it checks (`targetItemId`); here it becomes `_meta.coda.review` of that
+// call. A check can begin before codex-acp tells of the call: the call is told then, pending, and codex-acp's own telling of
+// it later is an update of it.
+const record = value => value && typeof value === 'object' && !Array.isArray(value);
+const CHECK = 'guardian_assessment:';
+const STATE = { inProgress: 'reviewing', approved: 'approved', denied: 'denied', aborted: 'denied', timedOut: 'denied' };
+const RISKS = new Set(['low', 'medium', 'high', 'critical']);
+// What the call is, as far as the check says (each kind of action codex-acp 1.12.0 names), until codex-acp tells it. ACP
+// requires a call's title: one the action does not give is said plainly.
+const PLACEHOLDER = {
+  command: a => [a.command, 'execute'],
+  execve: a => [(a.argv?.length ? a.argv : [a.program]).join(' '), 'execute'],
+  writeStdin: a => [`向进程 ${a.processId} 写入输入`, 'execute'],
+  applyPatch: a => [a.files?.length === 1 ? `修改 ${a.files[0]}` : `修改 ${a.files?.length ?? 0} 个文件`, 'edit'],
+  networkAccess: a => [`访问 ${a.target || a.host}`, 'fetch'],
+  mcpToolCall: a => [`MCP ${a.toolName}（${a.connectorName ?? a.server}）`],
+  requestPermissions: a => [a.reason || '申请更多权限'],
+};
+const placeholder = action => {
+  const [title, kind] = PLACEHOLDER[action?.type]?.(action) ?? [];
+  return { title: typeof title === 'string' && title.trim() ? title : '待审核的操作', ...(kind ? { kind } : {}) };
+};
+
+export class CodexReviews {
+  constructor() {
+    // The calls told of, and those told here before codex-acp did, by session.
+    this.told = new Set(); this.early = new Set();
+  }
+  // What codex-acp says, as said to Coda: the same, but a check is said of the call it checks.
+  fromAgent(message) {
+    const u = message?.params?.update;
+    if (message?.method !== 'session/update' || !record(u) || !['tool_call', 'tool_call_update'].includes(u.sessionUpdate)
+      || typeof u.toolCallId !== 'string') return [message];
+    const { sessionId } = message.params, key = id => `${sessionId}\n${id}`;
+    const said = update => ({ ...message, params: { ...message.params, update } });
+    if (!u.toolCallId.startsWith(CHECK)) {
+      if (u.sessionUpdate !== 'tool_call') return [message];
+      if (this.early.delete(key(u.toolCallId))) return [said({ ...u, sessionUpdate: 'tool_call_update' })];
+      this.told.add(key(u.toolCallId));
+      return [message];
+    }
+    // The started event, then the completed one: the later is the last word.
+    const check = record(u.rawOutput) ? u.rawOutput : u.rawInput, target = check?.targetItemId, state = STATE[check?.review?.status];
+    if (typeof target !== 'string' || !target || !state) return [message];
+    const { rationale, riskLevel } = check.review;
+    const review = { state, ...(typeof rationale === 'string' && rationale.trim() ? { reason: rationale.slice(0, 4000) } : {}),
+      ...(RISKS.has(riskLevel) ? { risk: riskLevel } : {}) };
+    const meta = { toolCallId: target, _meta: { coda: { review } } };
+    if (this.told.has(key(target)) || this.early.has(key(target))) return [said({ sessionUpdate: 'tool_call_update', ...meta })];
+    this.early.add(key(target)); this.told.add(key(target));
+    return [said({ sessionUpdate: 'tool_call', ...meta, ...placeholder(check.action), status: 'pending' })];
+  }
+}

package/agent/sleep.mjs

@@ -0,0 +1,22 @@
+// Codex's interruptible clock.sleep is a native display item, not a shell command or an AIR async task.
+// Keep it in the adapter's normal session routing, including child sessions. waits.mjs turns this private metadata
+// into a Coda background wait; the public ACP update stays valid while crossing codex-acp's schema.
+export function codexSleepUpdate(item, state) {
+  return { sessionUpdate: 'session_info_update', _meta: { coda: { sleep: { id: item.id, durationMs: item.durationMs, state } } } };
+}
+
+export function reportedCodexSleeps(source) {
+  for (const [activity, state] of [['Started', 'waiting'], ['Completed', 'done']]) {
+    const before = `        return this.subagents.legacyActivity${activity}(event.item);\n      case "sleep":`;
+    if (source.split(before).length !== 2) throw new Error('codex-acp sleep patch no longer matches the locked adapter');
+    source = source.replace(before, `${before}\n        return codexSleepUpdate(event.item, "${state}");`);
+  }
+  return `import { codexSleepUpdate } from ${JSON.stringify(import.meta.url)};\n${source.replace(/^#![^\n]*\n/, '')}`;
+}
+
+export function sleepTitle(durationMs) {
+  for (const [unit, label] of [[3600000, '小时'], [60000, '分钟'], [1000, '秒']]) {
+    if (durationMs >= unit && durationMs % unit === 0) return `等待 ${durationMs / unit} ${label}`;
+  }
+  return `等待 ${durationMs / 1000} 秒`;
+}

package/agent/waits.mjs

@@ -4,6 +4,7 @@
 // Coda: every session it names to Coda is `X`, and each run of it a wait of its own. Coda's session instructions are checked
 // here and handed to the patched codex-acp in the request's `_meta` (instructions.mjs).
 import { INSTRUCTIONS, sessionInstructions } from './instructions.mjs';
+import { sleepTitle } from './sleep.mjs';
 
 const record = value => value && typeof value === 'object' && !Array.isArray(value);
 const string = value => typeof value === 'string' && value.length > 0;
@@ -16,7 +17,7 @@ export class CodexWaits {
   // `agentInfo`: the Codex it runs, said in place of codex-acp's own name and version.
   constructor({ agentInfo = null } = {}) {
     // The root session; Coda's requests whose answers are read here, by id; the waits said, by id.
-    this.root = null; this.asked = new Map(); this.waits = new Map(); this.agentInfo = agentInfo;
+    this.root = null; this.asked = new Map(); this.waits = new Map(); this.sleeps = new Map(); this.agentInfo = agentInfo;
   }
   // What Coda says: `agent`, what codex-acp is told; `coda`, what Coda is answered here.
   fromCoda(message) {
@@ -37,6 +38,7 @@ export class CodexWaits {
     }
     if (message.method === 'session/new') this.asked.set(message.id, 'session');
     else if (message.method === 'session/load' && string(message.params?.sessionId)) this.root = message.params.sessionId;
+    else if (message.method === 'session/prompt') this.asked.set(message.id, { prompt: message.params.sessionId });
     return { agent: [message], coda: [] };
   }
   // A command is stopped through the session that keeps it, the root; a subagent by cancelling its session.
@@ -52,12 +54,31 @@ export class CodexWaits {
   // What codex-acp says, as said to Coda.
   fromAgent(message) {
     if (!record(message)) return [];
-    if ('id' in message && !('method' in message)) return [this.answer(message)];
+    if ('id' in message && !('method' in message)) {
+      const sessionId = this.asked.get(message.id)?.prompt;
+      // Cancelling or failing a turn can skip the sleep's completed item. End its waits before ending the prompt.
+      const finished = sessionId ? this.finishSleeps(base(sessionId), message.error ? 'failed' : message.result?.stopReason === 'cancelled' ? 'cancelled' : 'done') : [];
+      return [...finished, this.answer(message)];
+    }
     if (record(message.params) && string(message.params.sessionId)) message = { ...message, params: { ...message.params, sessionId: base(message.params.sessionId) } };
     if (message.method !== 'session/update' || !record(message.params?.update)) return [message];
     const { sessionId, update: u } = message.params;
     const said = params => [{ jsonrpc: '2.0', method: '_coda/wait', params: { sessionId, ...params } }];
     switch (u.sessionUpdate) {
+      case 'session_info_update': {
+        const sleep = u._meta?.coda?.sleep;
+        if (!sleep) return [message];
+        const waitId = `sleep:${sleep.id}`;
+        if (sleep.state === 'waiting') {
+          if (!this.sleeps.has(sessionId)) this.sleeps.set(sessionId, new Set());
+          this.sleeps.get(sessionId).add(waitId);
+          return said({ waitId, kind: 'task', state: 'waiting', title: sleepTitle(sleep.durationMs),
+            detail: '等待结束后继续；发送消息并选择「立即插话」可提前继续。', stoppable: false });
+        }
+        if (!this.sleeps.get(sessionId)?.delete(waitId)) return [];
+        if (!this.sleeps.get(sessionId).size) this.sleeps.delete(sessionId);
+        return said({ waitId, state: 'done' });
+      }
       case 'subagent_spawned': {
         if (!string(u.subagentSessionId)) return [];
         const stoppable = u.capabilities?.cancel === true;
@@ -66,7 +87,10 @@ export class CodexWaits {
           childSessionId: base(u.subagentSessionId), stoppable });
       }
       case 'subagent_state_update':
-        return string(u.subagentSessionId) && SUBAGENT_END[u.state] ? said({ waitId: u.subagentSessionId, state: SUBAGENT_END[u.state] }) : [];
+        return string(u.subagentSessionId) && SUBAGENT_END[u.state] ? [
+          ...this.finishSleeps(base(u.subagentSessionId), SUBAGENT_END[u.state]),
+          ...said({ waitId: u.subagentSessionId, state: SUBAGENT_END[u.state] }),
+        ] : [];
       case 'async_task_spawned': {
         if (!string(u.asyncTaskId)) return [];
         const stoppable = u.canStop === true;
@@ -86,6 +110,11 @@ export class CodexWaits {
     }
     return [message];
   }
+  finishSleeps(sessionId, state) {
+    const pending = this.sleeps.get(sessionId) ?? [];
+    this.sleeps.delete(sessionId);
+    return [...pending].map(waitId => ({ jsonrpc: '2.0', method: '_coda/wait', params: { sessionId, waitId, state } }));
+  }
   answer(message) {
     const asked = this.asked.get(message.id);
     if (!asked) return message;

package/package.json

@@ -2,8 +2,8 @@
   "name": "@coda-console/codex",
   "id": "codex",
   "displayName": "Codex",
-  "description": "Codex Agent：Coda 自带的入口运行 codex-acp，报告子 Agent 与后台命令。额度与登录由账号来源插件接管；未接入账号来源时使用 Codex 自己的登录面板。",
-  "version": "1.8.3",
+  "description": "Codex Agent：Coda 自带的入口运行 codex-acp，报告子 Agent、后台命令与命令的自动审核。额度与登录由账号来源插件接管；未接入账号来源时使用 Codex 自己的登录面板。",
+  "version": "1.8.5",
   "categories": ["Agent"],
   "dependencies": {
     "@agentclientprotocol/codex-acp": "1.12.0",