@coda-console/codex 1.6.1 → 1.7.1

package/agent/entry.mjs

@@ -1,9 +1,9 @@
 // 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),
-// and a steer that finds no turn going is answered `promptRequired` (steering.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).
+// 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).
 import { createRequire, registerHooks } from 'node:module';
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
@@ -19,6 +19,7 @@ import { networkedCodexDevelopment } from './network.mjs';
 import { codexOptionsAsShown } from './options.mjs';
 import { instructedCodexThreads } from './instructions.mjs';
 import { promptRequiredCodexSteering } from './steering.mjs';
+import { servedCodexModels } from './providers.mjs';
 import { input, listen, relayedCodexStreams } from './relay.mjs';
 import { CodexWaits } from './waits.mjs';
 import { explainCodexError, reportedCodexFailures } from './errors.mjs';
@@ -62,6 +63,6 @@ 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(networkedCodexDevelopment(Buffer.from(loaded.source).toString('utf8')))))))))) };
+    promptRequiredCodexSteering(instructedCodexThreads(servedCodexModels(networkedCodexDevelopment(Buffer.from(loaded.source).toString('utf8'))))))))))) };
 } });
 await import(adapter.href);

package/agent/instructions.mjs

@@ -16,9 +16,17 @@ export function sessionInstructions(systemPrompt) {
   return content.map(block => block.text).join('\n\n');
 }
 
+// Coda's instructions for the session this process runs (Coda runs one a process), as it last opened it; codex-acp's own resume
+// of its thread as the session moves to another model provider (providers.mjs, `carriedInstructions`) carries them on.
+let opened, carrying = false;
+export async function carriedInstructions(work) {
+  carrying = true;
+  try { return await work(); } finally { carrying = false; }
+}
 // The thread's developer instructions for a session request: its own configuration's, then Coda's.
 export async function codaDeveloperInstructions(codexClient, request) {
-  const ours = request._meta?.[INSTRUCTIONS];
+  if (!carrying) opened = request._meta?.[INSTRUCTIONS];
+  const ours = opened;
   if (!ours) return void 0;
   const own = (await codexClient.configRead({ cwd: request.cwd, includeLayers: false }))?.config?.developer_instructions;
   return own ? `${own}\n\n${ours}` : ours;

package/agent/providers.mjs

@@ -0,0 +1,111 @@
+// The model service chosen in Coda (`codex.modelProvider`, Coda's docs/plugins.md「模型服务」): another plugin's service that
+// speaks the OpenAI Responses API (Codex no longer speaks Chat Completions), from CODA_MODEL_PROVIDERS. The models its address
+// lists (`<地址>/models`) join Codex's own, each named by the service and the model. Codex binds a thread to one model
+// provider, so a turn on another provider's model first moves the session there the way codex-acp moves it for ACP's
+// `providers/set` and `providers/disable`: its app-server starts again with the service as the provider of its OpenAI slot
+// (or without it), and the session's thread is resumed on it. The machine's Codex configuration is not touched.
+import { existsSync, readFileSync } from 'node:fs';
+import { carriedInstructions } from './instructions.mjs';
+
+export const SETTING = 'codex.modelProvider';
+const log = text => process.stderr.write(`[codex-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 !== 'openai-responses') { log(`模型服务 ${ref} 讲 ${provided.api}，Codex 只接 openai-responses 的`); 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, as Codex's model list has them (app-server `model/list`): `<服务>/<模型>`, named by the
+// model and the service, with no effort or speed to choose.
+export async function serviceModels({ ref, title, url, key }, fetcher = fetch) {
+  const at = `${url.replace(/\/+$/, '')}/models`;
+  const response = await fetcher(at, { headers: key ? { Authorization: `Bearer ${key}` } : {}, 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}`, model: model.id, displayName: `${model.id} (${title})`, description: '', hidden: false, isDefault: false,
+    supportedReasoningEfforts: [], defaultReasoningEffort: 'medium', inputModalities: ['text', 'image'], serviceTiers: [] }));
+}
+
+// One service a process (Coda runs one session a process), listed once, as its session opens.
+export class ServiceModels {
+  // `on`: the service's address the session runs on, null on Codex's own (where it opens), undefined when a move to one or
+  // the other failed partway: codex-acp sets its gateway before the thread is resumed on it, so that is no sign of either,
+  // and keeps its old client, closed, when the app-server it started again does not start.
+  constructor(service = chosenService(), fetcher = fetch) { Object.assign(this, { service, fetcher }); this.models = []; this.on = null; }
+  list() {
+    return this.listed ??= (!this.service ? Promise.resolve([]) : serviceModels(this.service, this.fetcher)
+      .catch(e => { log(`模型服务 ${this.service.ref} 列不出模型：${e.message}`); return []; })).then(models => (this.models = models));
+  }
+  served(model) { return this.models.find(m => m.id === model) ?? null; }
+  // What a turn names to Codex: the service's own name for one of its models.
+  wire(model) { return this.served(model)?.model ?? model; }
+  // A stop that comes while a turn waits on the move has no turn of codex-acp's to interrupt yet: it is the waiting turn's,
+  // which ends cancelled with its input not given (`route` says so).
+  cancel(sessionId) { if (this.moving === sessionId) this.stopped = true; }
+  async route(server, params) {
+    this.moving = params.sessionId; this.stopped = false;
+    try { await this.move(server, params); } finally { this.moving = null; }
+    return this.stopped;
+  }
+  // Before a turn of codex-acp's `server`: the session on the provider of its model, its thread resumed with Coda's
+  // instructions as it was opened. A thread nothing was said in yet is not written down, and would not be resumed after the
+  // restart: naming it, by what it is first told, writes it. A move that failed is made again from the restart, on which
+  // codex-acp has a client again; the thread was written down before it.
+  async move(server, { sessionId, prompt }) {
+    const state = server.sessions.get(sessionId);
+    if (!state) return;
+    const served = this.served(state.currentModelId.replace(/\[[^\]]*\]$/, '')), wanted = served ? this.service.url : null;
+    if (this.on === wanted) return;
+    if (this.on !== undefined) {
+      const client = server.codexAcpClient.appServerClient;
+      const { thread } = await client.threadRead({ threadId: sessionId });
+      if (thread.path && !existsSync(thread.path)) await client.threadSetName({ threadId: sessionId, name: firstWords(prompt) });
+    }
+    this.on = undefined;
+    await carriedInstructions(() => served ? server.setProvider({ providerId: 'openai', apiType: 'openai', baseUrl: this.service.url,
+      headers: this.service.key ? { Authorization: `Bearer ${this.service.key}` } : {} }) : server.disableProvider({ providerId: 'openai' }));
+    this.on = wanted;
+  }
+  // Codex knows nothing of the service's models: that it runs one on fallback metadata, or resumes a session last on one
+  // with another model (Coda sets the session's model before each turn), is no news to say in the session.
+  quiet({ message } = {}) {
+    const named = /^Model metadata for `(.+?)` not found|^This session was recorded with model `(.+?)` but is resuming with `(.+?)`/.exec(message ?? '');
+    return !!named && named.slice(1).some(model => model && this.models.some(m => m.model === model));
+  }
+}
+const firstWords = prompt => Array.from((prompt ?? []).filter(b => b.type === 'text').map(b => b.text).join(' ').replace(/\s+/g, ' ').trim()).slice(0, 80).join('') || 'Coda';
+
+export const services = new ServiceModels();
+const patches = [
+  // Codex's models, then the service's.
+  ['    } while (cursor);\n    return models;\n  }', '    } while (cursor);\n    return [...models, ...await codaServices.list()];\n  }', 1],
+  // A turn first moves the session to the provider of its model, and names the model as that provider does.
+  ['  async prompt(params, signal, onTurnStarted) {\n    if (this.providerUpdate !== null) {',
+    '  async prompt(params, signal, onTurnStarted) {\n    if (await codaServices.route(this, params)) return { stopReason: "cancelled" };\n    if (this.providerUpdate !== null) {', 1],
+  // A stop while the session moves is the moving turn's.
+  ['  async cancel(params) {\n    const sessionState = this.sessions.get(params.sessionId);',
+    '  async cancel(params) {\n    codaServices.cancel(params.sessionId);\n    const sessionState = this.sessions.get(params.sessionId);', 1],
+  ['      model: modelId.model,\n      serviceTier\n    }, onTurnStarted);', '      model: codaServices.wire(modelId.model),\n      serviceTier\n    }, onTurnStarted);', 1],
+  ['      case "warning":\n        return this.createWarningEvent(notification.params);',
+    '      case "warning":\n        if (codaServices.quiet(notification.params)) return null;\n        return this.createWarningEvent(notification.params);', 1],
+];
+// Fails loudly once the locked adapter changes.
+export function servedCodexModels(source) {
+  for (const [before, after, count] of patches) {
+    if (source.split(before).length !== count + 1) throw new Error('codex-acp model service patch no longer matches the locked adapter');
+    source = source.replaceAll(before, after);
+  }
+  return `import { services as codaServices } from ${JSON.stringify(import.meta.url)};\n${source.replace(/^#![^\n]*\n/, '')}`;
+}

package/package.json

@@ -3,7 +3,7 @@
   "id": "codex",
   "displayName": "Codex",
   "description": "Codex Agent：Coda 自带的入口运行 codex-acp，报告子 Agent 与后台命令。额度与登录由账号来源插件接管；未接入账号来源时使用 Codex 自己的登录面板。",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "dependencies": {
     "@agentclientprotocol/codex-acp": "1.12.0",
     "@openai/codex": "0.162.1"
@@ -37,6 +37,18 @@
         "setupHint": "请在运行机为后端所属账号完成 Codex 认证。"
       }
     ],
+    "configuration": {
+      "title": "Codex",
+      "properties": {
+        "codex.modelProvider": {
+          "type": "string",
+          "format": "coda-model-provider",
+          "title": "模型服务",
+          "order": 1,
+          "description": "选一个插件提供的模型服务（如 Magpie），它列出的模型和 Codex 自己的模型一起出现在会话的模型里；选中它的模型，那个会话就走这个服务，Codex 自己的模型照旧。只接 OpenAI Responses 接口（openai-responses）的服务：Codex 不再支持 Chat Completions。"
+        }
+      }
+    },
     "panels": [
       {
         "id": "login",