benchgo-plugin 0.0.0-stage → 0.0.2

package/src/providers/acp.mjs

@@ -0,0 +1,138 @@
+import { randomUUID } from 'node:crypto';
+import { LineProcess } from '../line-process.mjs';
+import { commandCatalog, normalizeCommand } from '../commands.mjs';
+
+// Launch arguments verified against Paseo d57096a45 acp-provider-catalog.ts.
+// Original adapter implementation: ACP JSON-RPC, no filesystem/terminal client privileges.
+export const ACP_TOOL_DEFAULTS = Object.freeze({
+  gemini: Object.freeze({ command: 'gemini', args: Object.freeze(['--acp']) }),
+  hermes: Object.freeze({ command: 'hermes', args: Object.freeze(['acp']) }),
+  grok: Object.freeze({ command: 'grok', args: Object.freeze(['agent', 'stdio']) }),
+  mcode: Object.freeze({ command: 'mcode', args: Object.freeze(['acp']) }),
+});
+const safeModels = state => Array.isArray(state?.availableModels) ? state.availableModels.filter(item => typeof item?.modelId === 'string').map(item => ({ id: item.modelId, name: item.name || item.modelId, ...(item.description ? { description: item.description } : {}) })) : [];
+export class ACPProvider {
+  static capabilities = { stream: true, resume: true, steer: false, approvals: true, discover: true };
+  constructor(config = {}, toolId = 'gemini') { this.config = config; this.toolId = toolId; }
+  async models({ cwd = process.cwd(), nativeId } = {}) {
+    // Probe creates one short-lived native session when no resumable id is supplied.
+    const driver = await this.connect({ cwd, nativeId }, { event() {}, nativeId() {}, failure() {}, approval: async () => ({ allow: false }) });
+    try { return await driver.models(); } finally { await driver.close(); }
+  }
+  async connect(session, host) {
+    const defaults = ACP_TOOL_DEFAULTS[this.toolId];
+    if (!defaults) throw new Error('Unknown ACP tool');
+    const delegation = host.delegation;
+    if (delegation && ['command', 'script', 'url', 'token'].some(key => typeof delegation[key] !== 'string' || !delegation[key].trim() || delegation[key].includes(String.fromCharCode(0)))) throw new Error('ACP delegation requires a valid command, script, URL and token');
+    // ACP stdio MCP is baseline protocol support; HTTP/SSE flags do not gate it.
+    const mcpServers = delegation ? [{ name: 'commander', command: delegation.command, args: [delegation.script], env: [{ name: 'COMMANDER_DELEGATE_URL', value: delegation.url }, { name: 'COMMANDER_DELEGATE_TOKEN', value: delegation.token }] }] : [];
+    const wire = new LineProcess(this.config.command ?? defaults.command, [...(this.config.args ?? []), ...defaults.args], { cwd: session.cwd, env: this.config.env, timeout: this.config.timeout ?? 30_000 });
+    const life = new AbortController(), pendingPermissions = new Set();
+    let closing = false, connected = false, busy = false, caps = {}, modelsState, configOptions = [], commandList = [], commandsReady = false, commandTimer, cancelTimer, settleCommands;
+    const earlyUpdates = [];
+    const commandsGate = new Promise(resolve => { settleCommands = resolve; });
+    const driver = {
+      nativeId: session.nativeId, turnId: undefined,
+      async models() { return safeModels(modelsState); },
+      async setModel(modelId) {
+        if (!safeModels(modelsState).some(model => model.id === modelId)) throw new Error('Requested model is not advertised by ACP agent: ' + modelId);
+        const option = modelConfig();
+        if (option) await wire.request('session/set_config_option', { sessionId: driver.nativeId, configId: option.id, value: modelId });
+        else if (caps.sessionCapabilities?.setModel !== false) await wire.request('session/set_model', { sessionId: driver.nativeId, modelId });
+        else throw new Error('ACP agent does not support changing models in an existing session');
+        modelsState.currentModelId = modelId;
+        session.model = modelId;
+      },
+      async commands() { if (!commandsReady) await commandsGate; return commandCatalog(commandList); },
+      async command(value) { const cmd = normalizeCommand(value.name, value.arguments); const catalog = await driver.commands(); if (!catalog.some(item => item.name === cmd.name)) throw new Error('Unsupported native ACP command: /' + cmd.name); return driver.submit('/' + cmd.name + (cmd.arguments ? ' ' + cmd.arguments : '')); },
+      async submit(text) {
+        if (!connected || closing) throw new Error('ACP session is disconnected');
+        if (busy) throw new Error('ACP session is already running');
+        if (typeof text !== 'string' || !text.trim()) throw new Error('Prompt must not be empty');
+        busy = true; driver.turnId = randomUUID(); host.event('turn.started', {});
+        void wire.request('session/prompt', { sessionId: driver.nativeId, prompt: [{ type: 'text', text }] }, thisProvider.config.promptTimeout ?? 15 * 60_000).then(result => {
+          busy = false; clearTimeout(cancelTimer); cancelTimer = undefined;
+          if (!closing) host.event('turn.completed', { status: result?.stopReason === 'cancelled' ? 'cancelled' : 'completed', stopReason: result?.stopReason ?? null });
+        }).catch(async error => {
+          if (!closing) { host.event('turn.completed', { status: 'failed', message: error.message }); host.failure(error); await driver.close(); }
+        }).finally(() => { busy = false; });
+      },
+      async interrupt() {
+        if (busy && !closing) {
+          for (const request of pendingPermissions) request.abort(); wire.notify('session/cancel', { sessionId: driver.nativeId });
+          if (!cancelTimer) { cancelTimer = setTimeout(() => { if (busy && !closing) { const error = new Error('ACP cancellation was not acknowledged; session execution outcome may be unknown'); host.event('turn.completed', { status: 'failed', message: error.message }); host.failure(error); void driver.close(); } }, thisProvider.config.cancelTimeout ?? 8000); cancelTimer.unref(); }
+        }
+      },
+      async history() { throw new Error('ACP history is replayed by session/load; standalone history is not advertised.'); },
+      async discover() { if (!caps.sessionCapabilities?.list) throw new Error('This ACP agent does not advertise session listing'); return wire.request('session/list', { cwd: session.cwd }); },
+      async close() { if (closing) return; closing = true; connected = false; clearTimeout(commandTimer); clearTimeout(cancelTimer); settleCommands(); life.abort(); for (const request of pendingPermissions) request.abort(); await wire.close(); },
+    };
+    const thisProvider = this;
+    const modelConfig = () => configOptions.find(option => option?.category === 'model' || option?.id === 'model' || option?.id === 'model_id');
+    const optionModels = option => (option?.options ?? []).flatMap(item => item?.options ?? [item]).filter(item => typeof item?.value === 'string').map(item => ({ modelId: item.value, name: item.name ?? item.value }));
+    const update = message => {
+      if (message.method !== 'session/update' || closing) return;
+      if (!driver.nativeId) { if (earlyUpdates.length < 500) earlyUpdates.push(message); return; }
+      if (message.params?.sessionId !== driver.nativeId) return;
+      const value = message.params.update; if (!value || typeof value !== 'object') return;
+      switch (value.sessionUpdate) {
+        case 'available_commands_update': commandList = (value.availableCommands ?? []).slice(0, 500).map(cmd => ({ ...cmd, argumentHint: cmd.input?.hint ?? '' })); commandsReady = true; settleCommands(); break;
+        case 'config_option_update': configOptions = value.configOptions ?? []; if (modelConfig()) modelsState = { availableModels: optionModels(modelConfig()), currentModelId: modelConfig().currentValue }; break;
+        case 'agent_message_chunk': if (connected && busy && value.content?.type === 'text') host.event('text.delta', { text: value.content.text }); break;
+        case 'agent_thought_chunk': if (connected && busy && value.content?.type === 'text') host.event('item', { type: 'reasoning', text: value.content.text }); break;
+        case 'tool_call': case 'tool_call_update': case 'plan': if (connected && busy) host.event('item', value); break;
+        case 'usage_update': if (connected && busy) host.event('item', { type: 'acp.context_usage', ...value }); break;
+      }
+    };
+    wire.on('notification', update);
+    wire.on('failure', error => { if (!closing) { life.abort(); for (const request of pendingPermissions) request.abort(); host.failure(error); } });
+    wire.on('request', request => {
+      void (async () => {
+        if (request.method !== 'session/request_permission') { wire.reject(request.id, 'Client filesystem and terminal methods are unsupported'); return; }
+        const params = request.params ?? {}, once = params.options?.find(option => option.kind === 'allow_once' && typeof option.optionId === 'string');
+        const denied = () => ({ outcome: { outcome: 'cancelled' } });
+        if (!connected || closing || !busy || params.sessionId !== driver.nativeId || !once || !host.approval) { wire.respond(request.id, denied()); return; }
+        const controller = new AbortController(); pendingPermissions.add(controller);
+        const abort = () => controller.abort(); life.signal.addEventListener('abort', abort, { once: true });
+        const timer = setTimeout(abort, this.config.approvalTimeout ?? 120_000); timer.unref();
+        try {
+          const answer = await Promise.race([Promise.resolve().then(() => host.approval({ kind: 'permission', method: params.toolCall?.kind ?? 'tool', nativeRequestId: request.id, details: params.toolCall ?? {} }, controller.signal)), new Promise(resolve => controller.signal.addEventListener('abort', () => resolve({ allow: false }), { once: true }))]);
+          if (!closing && !wire.closed) wire.respond(request.id, answer?.allow === true && !controller.signal.aborted ? { outcome: { outcome: 'selected', optionId: once.optionId } } : denied());
+        } catch { if (!closing && !wire.closed) wire.respond(request.id, denied()); }
+        finally { clearTimeout(timer); pendingPermissions.delete(controller); life.signal.removeEventListener('abort', abort); }
+      })().catch(error => { if (!closing) host.failure(error); });
+    });
+    try {
+      const initialized = await wire.request('initialize', { protocolVersion: 1, clientInfo: { name: 'benchgo', version: '0.1.0' }, clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false } });
+      if (initialized?.protocolVersion !== 1) throw new Error('Unsupported ACP protocol version');
+      caps = initialized.agentCapabilities ?? {};
+      if (session.nativeId && !caps.loadSession) throw new Error('This ACP agent does not support session resume; refusing to create a replacement session');
+      let result;
+      try {
+        result = await wire.request(session.nativeId ? 'session/load' : 'session/new', { ...(session.nativeId ? { sessionId: session.nativeId } : {}), cwd: session.cwd, mcpServers });
+      } catch (error) {
+        if (delegation) throw new Error('ACP session with BenchGo delegation MCP failed: ' + error.message, { cause: error });
+        throw error;
+      }
+      if (!session.nativeId && (typeof result?.sessionId !== 'string' || !result.sessionId)) throw new Error('ACP agent did not return a durable session id');
+      if (session.nativeId && result?.sessionId && result.sessionId !== session.nativeId) throw new Error('ACP resume returned a different session id');
+      driver.nativeId = session.nativeId ?? result.sessionId;
+      // Persist the real native session before optional model changes can fail.
+      await host.nativeId?.(driver.nativeId);
+      modelsState = result.models; configOptions = result.configOptions ?? [];
+      for (const message of earlyUpdates) update(message); earlyUpdates.length = 0;
+      if (!modelsState && modelConfig()) modelsState = { availableModels: optionModels(modelConfig()), currentModelId: modelConfig().currentValue };
+      if (session.model && session.model !== modelsState?.currentModelId) {
+        if (!safeModels(modelsState).some(model => model.id === session.model)) throw new Error('Requested model is not advertised by ACP agent: ' + session.model);
+        const option = modelConfig();
+        if (option) await wire.request('session/set_config_option', { sessionId: driver.nativeId, configId: option.id, value: session.model });
+        else await wire.request('session/set_model', { sessionId: driver.nativeId, modelId: session.model });
+        modelsState.currentModelId = session.model;
+      }
+      connected = true;
+      commandTimer = setTimeout(settleCommands, this.config.commandsTimeout ?? 300); commandTimer.unref();
+      return driver;
+    } catch (error) { await driver.close(); throw error; }
+  }
+}
+export const acpProviderClasses = Object.fromEntries(Object.keys(ACP_TOOL_DEFAULTS).map(id => [id, class extends ACPProvider { constructor(config = {}) { super(config, id); } }]));

package/src/providers/claude.mjs

@@ -0,0 +1,115 @@
+import { commandCatalog } from '../commands.mjs';
+import { isolatedClaudeHistory } from '../isolated-launch.mjs';
+
+export class ClaudeProvider {
+  static capabilities = { stream: true, resume: true, steer: false, approvals: true, discover: true };
+  constructor(config = {}) { this.config = config; }
+
+  async connect(session, host) {
+    let sdk;
+    try { sdk = await import('@anthropic-ai/claude-agent-sdk'); }
+    catch { throw new Error('Claude Agent SDK is not installed; run npm install in plugins/commander'); }
+    const isolatedHome = this.config.managedProfile?.isolated ? this.config.env.CLAUDE_CONFIG_DIR : null;
+    const historyInfo = id => isolatedHome ? isolatedClaudeHistory(isolatedHome, 'info', id, session.cwd) : sdk.getSessionInfo(id, { dir: session.cwd });
+    if (session.nativeId && !await historyInfo(session.nativeId)) {
+      throw new Error('Claude native history is missing or unreadable; refusing to create a replacement session');
+    }
+    let query;
+    let wake;
+    let stopped = false;
+    let hasAssistantText = false;
+    const queue = [];
+    async function* input() {
+      while (!stopped) {
+        if (!queue.length) await new Promise(resolve => { wake = resolve; });
+        if (stopped) return;
+        yield queue.shift();
+      }
+    }
+    const driver = {
+      nativeId: session.nativeId,
+      async setModel(model) {
+        if (typeof query.setModel !== 'function') throw new Error('Claude Agent SDK does not support changing models in this session');
+        await query.setModel(model || undefined);
+        session.model = model || undefined;
+      },
+      async submit(text) {
+        hasAssistantText = false;
+        queue.push({ type: 'user', session_id: driver.nativeId ?? '', message: { role: 'user', content: text }, parent_tool_use_id: null });
+        wake?.(); wake = undefined;
+      },
+      async commands() { return commandCatalog(await query.supportedCommands()); },
+      async command({ name, arguments: args }) { await driver.submit(`/${name}${args ? ` ${args}` : ''}`); },
+      async interrupt() { await query.interrupt(); },
+      async close() {
+        stopped = true; wake?.();
+        query.close();
+        await pump;
+      },
+    };
+    query = sdk.query({ prompt: input(), options: {
+      cwd: session.cwd,
+      ...(session.nativeId ? { resume: session.nativeId } : {}),
+      ...(session.model ? { model: session.model } : {}),
+      pathToClaudeCodeExecutable: this.config.command ?? 'claude',
+      env: { ...process.env, ...this.config.env },
+      permissionMode: 'default',
+      includePartialMessages: true,
+      settingSources: this.config.settingSources ?? ['user', 'project', 'local'],
+      ...(this.config.settings ? { settings: this.config.settings } : {}),
+      systemPrompt: { type: 'preset', preset: 'claude_code' },
+      ...(host.delegation ? { mcpServers: { commander: { command: host.delegation.command, args: [host.delegation.script], env: { COMMANDER_DELEGATE_URL: host.delegation.url, COMMANDER_DELEGATE_TOKEN: host.delegation.token } } } } : {}),
+      canUseTool: async (toolName, toolInput, options) => {
+        const isQuestion = toolName === 'AskUserQuestion';
+        const answer = await host.approval({ kind: isQuestion ? 'question' : 'permission', method: toolName, nativeRequestId: options.toolUseID, details: isQuestion ? toolInput : { toolName, input: toolInput } }, options.signal);
+        return answer.allow === true ? { behavior: 'allow', updatedInput: isQuestion ? { ...toolInput, answers: answer.answers } : toolInput } : { behavior: 'deny', message: 'Denied by BenchGo user' };
+      },
+    } });
+    const pump = (async () => {
+      try {
+        for await (const message of query) {
+          if (message.parent_tool_use_id) {
+            host.event('subagent.event', { type: message.type, parentToolUseId: message.parent_tool_use_id, message });
+            continue;
+          }
+          if (message.session_id && message.session_id !== driver.nativeId) {
+            if (driver.nativeId) throw new Error('Claude returned a different native session');
+            driver.nativeId = message.session_id;
+            host.nativeId(message.session_id);
+          }
+          if (message.type === 'stream_event') {
+            if (message.event.type === 'message_start') host.event('turn.started', {});
+            if (message.event.type === 'content_block_delta' && message.event.delta.type === 'text_delta') { hasAssistantText = true; host.event('text.delta', { text: message.event.delta.text }); }
+            if (message.event.type === 'content_block_start' && message.event.content_block.type === 'tool_use') host.event('item', message.event.content_block);
+          } else if (message.type === 'result') {
+            if (!hasAssistantText && message.usage?.output_tokens === 0 && typeof message.result === 'string' && message.result.trim()) host.event('text.delta', { text: message.result });
+            host.event('turn.completed', { status: message.is_error ? 'failed' : 'completed', result: message.result ?? null, errors: message.errors ?? [] });
+          } else if (message.type === 'assistant' || message.type === 'user') {
+            host.event('message', { type: message.type, message: message.message });
+          } else if (message.type === 'system' && message.subtype === 'api_retry') {
+            host.event('provider.retry', { attempt: message.attempt ?? null, maxRetries: message.max_retries ?? null, delayMs: message.retry_delay_ms ?? null, status: message.error_status ?? null });
+          }
+        }
+        if (!stopped) host.failure(new Error('Claude session stream ended'));
+      } catch (error) { if (!stopped) host.failure(error); }
+    })();
+    let timer;
+    try {
+      await Promise.race([
+        query.initializationResult(),
+        new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('Claude initialization timed out')), 30_000); }),
+      ]);
+      if (this.config.managedProfile?.subscription) {
+        const account = await query.accountInfo();
+        if (!account?.subscriptionType || account.subscriptionType === 'none' || account.apiKeySource && account.apiKeySource !== 'none' || account.apiProvider && account.apiProvider !== 'firstParty') throw new Error('请先在本机 Claude Code 中完成 Claude 订阅登录，不能用 API 密钥替代订阅。');
+      }
+    } catch (error) { await driver.close(); throw error; }
+    finally { clearTimeout(timer); }
+    driver.history = async () => {
+      if (!driver.nativeId) throw new Error('Claude has not persisted a native session yet');
+      return isolatedHome ? isolatedClaudeHistory(isolatedHome, 'messages', driver.nativeId, session.cwd) : sdk.getSessionMessages(driver.nativeId, { dir: session.cwd });
+    };
+    driver.discover = () => isolatedHome ? isolatedClaudeHistory(isolatedHome, 'list', '', session.cwd) : sdk.listSessions({ dir: session.cwd, limit: 50 });
+    return driver;
+  }
+}

package/src/providers/codex.mjs

@@ -0,0 +1,134 @@
+import { LineProcess } from '../line-process.mjs';
+import { createHash } from 'node:crypto';
+import { commandCatalog, compactCommand } from '../commands.mjs';
+
+export class CodexProvider {
+  static capabilities = { stream: true, resume: true, steer: true, approvals: true, discover: true };
+  constructor(config = {}) { this.config = config; }
+
+  async connect(session, host) {
+    const wire = new LineProcess(this.config.command ?? 'codex', [...(this.config.commandArgs ?? []), 'app-server', '--listen', 'stdio://'], { cwd: session.cwd, env: this.config.env });
+    let previousUsage, previousUsageKey;
+    const driver = {
+      nativeId: session.nativeId,
+      async setModel(model) { session.model = model || undefined; },
+      turnId: undefined,
+      compacting: false,
+      async commands() {
+        const result = await wire.request('skills/list', { cwds: [session.cwd] });
+        driver.skills = (result.data ?? []).flatMap(entry => entry.skills ?? []).filter(skill => skill.enabled !== false);
+        return commandCatalog(driver.skills.map(skill => ({ ...skill, kind: 'skill' })), [compactCommand]);
+      },
+      validateCommand({ name, arguments: args }) {
+        if (name === 'compact' && args) throw new Error('Codex compact does not accept arguments');
+      },
+      async command({ name, arguments: args }) {
+        driver.validateCommand({ name, arguments: args });
+        if (name === 'compact') {
+          driver.compacting = true;
+          try { await wire.request('thread/compact/start', { threadId: driver.nativeId }); }
+          catch (error) { driver.compacting = false; throw error; }
+          return;
+        }
+        const skill = driver.skills?.find(entry => entry.name === name);
+        if (!skill?.path) throw new Error(`Unsupported native Codex command: /${name}`);
+        const response = await wire.request('turn/start', { threadId: driver.nativeId, ...(session.model ? { model: session.model } : {}), input: [{ type: 'skill', name: skill.name, path: skill.path }, { type: 'text', text: `$${name}${args ? ` ${args}` : ''}` }] });
+        driver.turnId = response.turn.id;
+      },
+      async submit(text) {
+        const response = await wire.request('turn/start', {
+          threadId: driver.nativeId, ...(session.model ? { model: session.model } : {}), input: [{ type: 'text', text }],
+        });
+        driver.turnId = response.turn.id;
+      },
+      async steer(text) {
+        if (!driver.turnId) throw new Error('No native Codex turn to steer');
+        await wire.request('turn/steer', { threadId: driver.nativeId, expectedTurnId: driver.turnId, input: [{ type: 'text', text }] });
+      },
+      async interrupt() {
+        if (!driver.turnId) throw new Error('Codex has not published an active turn');
+        await wire.request('turn/interrupt', { threadId: driver.nativeId, turnId: driver.turnId });
+      },
+      async history() { return wire.request('thread/read', { threadId: driver.nativeId, includeTurns: true }); },
+      async discover() { return wire.request('thread/list', { cwd: session.cwd, limit: 50 }); },
+      close: () => wire.close(),
+    };
+    wire.on('failure', error => host.failure(error));
+    wire.on('notification', message => {
+      const p = message.params ?? {};
+      if (p.threadId && driver.nativeId && p.threadId !== driver.nativeId) return;
+      switch (message.method) {
+        case 'thread/tokenUsage/updated': {
+          const total = p.tokenUsage?.total, last = p.tokenUsage?.last;
+          if (!last || !driver.turnId) break;
+          const key = JSON.stringify(total ?? last);
+          if (key === previousUsageKey) break;
+          const usage = previousUsage && total ? Object.fromEntries(Object.entries(total).map(([name, value]) => [name, Number.isSafeInteger(value) && Number.isSafeInteger(previousUsage[name]) && value >= previousUsage[name] ? value - previousUsage[name] : undefined])) : last;
+          const nativeTurnId = p.turnId ?? driver.turnId;
+          const signature = createHash('sha256').update(key).digest('hex').slice(0, 24);
+          host.event('usage', { id: 'request:' + nativeTurnId + ':' + signature, scope: 'request', nativeTurnId, usage: { ...usage, cacheReadTokens: usage.cachedInputTokens, contextTokens: last.inputTokens, contextWindow: p.tokenUsage.modelContextWindow }, convention: 'inclusive' });
+          previousUsage = total; previousUsageKey = key;
+          break;
+        }
+        case 'thread/compacted':
+          if (driver.compacting) { driver.compacting = false; host.event('turn.completed', { status: 'completed', command: 'compact' }); }
+          break;
+        case 'turn/started': driver.turnId = p.turn.id; host.event('turn.started', { nativeTurnId: p.turn.id, model: session.model ?? null }); break;
+        case 'turn/completed':
+          driver.turnId = undefined;
+          driver.compacting = false;
+          host.event('turn.completed', { status: p.turn.status, error: p.turn.error ?? null }); break;
+        case 'item/agentMessage/delta': host.event('text.delta', { text: p.delta, itemId: p.itemId }); break;
+        case 'item/started': case 'item/completed':
+          host.event('item', { phase: message.method, item: p.item });
+          if (driver.compacting && message.method === 'item/completed' && p.item?.type === 'contextCompaction') { driver.compacting = false; host.event('turn.completed', { status: 'completed', command: 'compact' }); }
+          break;
+        case 'item/commandExecution/outputDelta': host.event('tool.output', { text: p.delta, itemId: p.itemId }); break;
+        case 'error': host.event('provider.error', p); break;
+        default: break;
+      }
+    });
+    wire.on('request', message => {
+      void (async () => {
+        const { method, params: p = {}, id } = message;
+        if (p.threadId && p.threadId !== driver.nativeId) return wire.reject(id, 'Wrong thread');
+        if (method === 'item/tool/call' && p.tool === 'commander_delegate' && host.delegate) {
+          try { wire.respond(id, { success: true, contentItems: [{ type: 'inputText', text: JSON.stringify(await host.delegate(p.arguments)) }] }); }
+          catch (error) { wire.respond(id, { success: false, contentItems: [{ type: 'inputText', text: error.message }] }); }
+        } else if (method === 'item/commandExecution/requestApproval' || method === 'item/fileChange/requestApproval') {
+          const answer = await host.approval({ kind: 'permission', method, nativeRequestId: id, details: p });
+          const available = p.availableDecisions;
+          let decision = answer.allow ? 'accept' : 'decline';
+          if (Array.isArray(available) && !available.includes(decision)) {
+            if (!answer.allow && available.includes('cancel')) decision = 'cancel';
+            else throw new Error(`Unsupported Codex approval decisions: ${JSON.stringify(available)}`);
+          }
+          wire.respond(id, { decision });
+        } else if (method === 'item/tool/requestUserInput' || method === 'tool/requestUserInput') {
+          const answer = await host.approval({ kind: 'question', method, nativeRequestId: id, details: p });
+          wire.respond(id, { answers: answer.answers ?? {} });
+        } else {
+          wire.reject(id, `BenchGo does not support server request ${method}`);
+          host.event('unsupported.request', { method });
+        }
+      })().catch(error => { try { wire.reject(message.id, error.message); } catch {} host.failure(error); });
+    });
+    try {
+      await wire.request('initialize', { clientInfo: { name: 'dowork_commander', version: '0.1.0' }, capabilities: { experimentalApi: true } });
+      wire.notify('initialized', {});
+      if (this.config.managedProfile?.subscription) {
+        const { account } = await wire.request('account/read', { refreshToken: false });
+        if (account?.type !== 'chatgpt') throw new Error('请先在本机 Codex 中完成 ChatGPT 登录，不能用 API 密钥替代订阅。');
+      }
+      const params = { cwd: session.cwd, approvalPolicy: 'on-request', sandbox: 'workspace-write', ...(session.model ? { model: session.model } : {}) };
+      const result = await wire.request(session.nativeId ? 'thread/resume' : 'thread/start', {
+        ...params, ...(session.nativeId ? { threadId: session.nativeId } : {}),
+        ...(!session.nativeId && host.delegation ? { dynamicTools: [{ name: 'commander_delegate', description: 'Delegate in the same project using provider and text, optionally model. Human approval required. Returns child result; if pending, call again with operation=result and sessionId. Do not create another child for the same task.', inputSchema: host.delegation.schema }] } : {}),
+      });
+      if (!result?.thread?.id) throw new Error('Codex returned no native thread identity');
+      if (session.nativeId && result.thread.id !== session.nativeId) throw new Error('Codex resumed a different thread');
+      driver.nativeId = result.thread.id;
+      return driver;
+    } catch (error) { await wire.close(); throw error; }
+  }
+}

package/src/providers/opencode.mjs

@@ -0,0 +1,138 @@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { commandCatalog, compactCommand } from '../commands.mjs';
+
+// OpenCode v1 HTTP/SSE adapter. v2 has a different contract and is deliberately
+// rejected rather than guessed from a successful TCP connection.
+export class OpenCodeProvider {
+  static capabilities = { stream: true, resume: true, steer: false, approvals: true, discover: true };
+  constructor(config = {}) { this.config = config; }
+
+  async connect(session, host) {
+    const password = randomBytes(24).toString('hex');
+    const inline = this.config.env?.OPENCODE_CONFIG_CONTENT ?? process.env.OPENCODE_CONFIG_CONTENT;
+    const existing = inline ? JSON.parse(inline) : {};
+    const child = spawn(this.config.command ?? 'opencode', [...(this.config.commandArgs ?? []), 'serve', '--hostname', '127.0.0.1', '--port', '0'], {
+      cwd: session.cwd, env: { ...process.env, ...this.config.env, OPENCODE_SERVER_PASSWORD: password,
+        ...(host.delegation ? { OPENCODE_CONFIG_CONTENT: JSON.stringify({ ...existing, mcp: { ...existing.mcp, commander: { type: 'local', command: [host.delegation.command, host.delegation.script], environment: { COMMANDER_DELEGATE_URL: host.delegation.url, COMMANDER_DELEGATE_TOKEN: host.delegation.token }, enabled: true } } }) } : {}),
+      },
+      stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, detached: process.platform !== 'win32',
+    });
+    const controller = new AbortController();
+    let closing = false;
+    let tail = '';
+    let base;
+    let pump;
+    let rejectReady;
+    const exited = new Promise(resolve => child.once('close', resolve));
+    const stop = async () => {
+      closing = true; controller.abort();
+      const kill = signal => {
+        try { if (child.pid) process.platform === 'win32' ? child.kill(signal) : process.kill(-child.pid, signal); }
+        catch (error) { if (error.code !== 'ESRCH') throw error; }
+      };
+      kill('SIGTERM');
+      const timer = setTimeout(() => kill('SIGKILL'), 1500);
+      try { await exited; await pump; } finally { clearTimeout(timer); }
+    };
+    child.on('error', error => { rejectReady?.(error); if (!closing) host.failure(error); });
+    child.on('close', () => { const error = new Error(`OpenCode server exited: ${tail.slice(-1000)}`); rejectReady?.(error); if (!closing) host.failure(error); });
+    try {
+      base = await new Promise((resolve, reject) => {
+        rejectReady = reject;
+        const timer = setTimeout(() => reject(new Error('OpenCode startup timed out')), 20_000);
+        const data = chunk => {
+          tail = (tail + chunk.toString()).slice(-8192);
+          const url = tail.match(/https?:\/\/(?:127\.0\.0\.1|localhost):\d+/)?.[0];
+          if (url) { clearTimeout(timer); resolve(url); }
+        };
+        child.stdout.on('data', data); child.stderr.on('data', data);
+        exited.then(() => clearTimeout(timer));
+      });
+      const headers = { authorization: `Basic ${Buffer.from(`opencode:${password}`).toString('base64')}`, 'content-type': 'application/json' };
+      const request = async (path, method = 'GET', body, timeout = 30_000) => {
+        const url = new URL(path, base); url.searchParams.set('directory', session.cwd);
+        const response = await fetch(url, { method, headers, body: body === undefined ? undefined : JSON.stringify(body), signal: AbortSignal.any([controller.signal, AbortSignal.timeout(timeout)]) });
+        if (!response.ok) throw new Error(`OpenCode ${method} ${path}: HTTP ${response.status} ${(await response.text()).slice(0, 500)}`);
+        const text = await response.text(); return text ? JSON.parse(text) : null;
+      };
+      const health = await request('/global/health');
+      if (!health?.healthy || !/^1\./.test(health.version ?? '')) throw new Error(`Unsupported OpenCode protocol/version: ${health?.version ?? 'unknown'}; v1 required`);
+      const info = session.nativeId
+        ? await request(`/session/${encodeURIComponent(session.nativeId)}`)
+        : await request('/session', 'POST', { permission: [{ permission: '*', pattern: '*', action: 'ask' }] });
+      if (!info?.id || (session.nativeId && info.id !== session.nativeId)) throw new Error('OpenCode returned an invalid native session');
+      const id = encodeURIComponent(info.id);
+      // Open and attach SSE before accepting prompts; no startup race dropping
+      // the first delta/permission request.
+      const streamURL = new URL('/event', base); streamURL.searchParams.set('directory', session.cwd);
+      const response = await fetch(streamURL, { headers, signal: controller.signal });
+      if (!response.ok || !response.body) throw new Error('OpenCode event subscription failed');
+      const handle = async event => {
+        const p = event.properties ?? {};
+        const sessionId = p.sessionID ?? p.part?.sessionID ?? p.info?.sessionID;
+        if (sessionId !== info.id) return;
+        if (event.type === 'message.part.delta' && p.field === 'text') host.event('text.delta', { text: p.delta, itemId: p.partID });
+        else if (event.type === 'message.part.updated') {
+          host.event('item', { part: p.part, delta: p.delta ?? null });
+          if (p.part?.type === 'step-finish' && p.part.tokens) host.event('usage', { id: p.part.id, usage: p.part.tokens });
+        }
+        else if (event.type === 'session.idle') host.event('turn.completed', { status: 'completed' });
+        else if (event.type === 'session.error') host.event('turn.completed', { status: 'failed', error: p.error });
+        else if (event.type === 'permission.asked') {
+          const answer = await host.approval({ kind: 'permission', method: p.permission, nativeRequestId: p.id, details: p });
+          await request(`/permission/${encodeURIComponent(p.id)}/reply`, 'POST', { reply: answer.allow ? 'once' : 'reject' });
+        } else if (event.type === 'question.asked') {
+          const answer = await host.approval({ kind: 'question', method: event.type, nativeRequestId: p.id, details: p });
+          if (answer.answers) await request(`/question/${encodeURIComponent(p.id)}/reply`, 'POST', { answers: answer.answers });
+          else await request(`/question/${encodeURIComponent(p.id)}/reject`, 'POST', {});
+        }
+      };
+      pump = (async () => {
+        const decoder = new TextDecoder(); let buffer = '';
+        try {
+          for await (const chunk of response.body) {
+            buffer += decoder.decode(chunk, { stream: true });
+            buffer = buffer.replace(/\r\n/g, '\n');
+            if (buffer.length > 16 * 1024 * 1024) throw new Error('OpenCode SSE frame too large');
+            let boundary;
+            while ((boundary = buffer.indexOf('\n\n')) !== -1) {
+              const frame = buffer.slice(0, boundary); buffer = buffer.slice(boundary + 2);
+              const data = frame.split('\n').filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n');
+              if (data) void handle(JSON.parse(data)).catch(error => host.failure(error));
+            }
+          }
+          if (!closing) host.failure(new Error('OpenCode event stream disconnected; reconnect the session before continuing'));
+        } catch (error) { if (!closing) host.failure(error); }
+      })();
+      return {
+        nativeId: info.id,
+        async setModel(model) { session.model = model || undefined; },
+        async commands() { return commandCatalog(await request('/command'), [compactCommand, { ...compactCommand, name: 'summarize' }]); },
+        validateCommand({ name, arguments: args }) {
+          if (name !== 'compact' && name !== 'summarize') return;
+          if (args) throw new Error('OpenCode compact does not accept arguments');
+          if (!session.model?.includes('/')) throw new Error('Select an explicit provider/model before OpenCode compact');
+        },
+        async command({ name, arguments: args }) {
+          const model = session.model?.split('/');
+          if (name === 'compact' || name === 'summarize') {
+            if (args) throw new Error('OpenCode compact does not accept arguments');
+            if (!model || model.length < 2) throw new Error('Select an explicit provider/model before OpenCode compact');
+            await request(`/session/${id}/summarize`, 'POST', { providerID: model[0], modelID: model.slice(1).join('/') }, 30 * 60_000);
+          } else await request(`/session/${id}/command`, 'POST', { command: name, arguments: args, ...(session.model ? { model: session.model } : {}) }, 30 * 60_000);
+        },
+        async submit(text) {
+          const model = session.model?.split('/');
+          if (model && model.length < 2) throw new Error('OpenCode model must be provider/model');
+          await request(`/session/${id}/prompt_async`, 'POST', { parts: [{ type: 'text', text }], ...(model ? { model: { providerID: model[0], modelID: model.slice(1).join('/') } } : {}) });
+        },
+        async interrupt() { await request(`/session/${id}/abort`, 'POST', {}); },
+        async history() { return request(`/session/${id}/message`); },
+        async discover() { return request('/session'); },
+        close: stop,
+      };
+    } catch (error) { await stop(); throw error; }
+  }
+}

package/src/providers/pi-permissions.ts

@@ -0,0 +1,24 @@
+// Loaded by the user's Pi runtime. Import is type-only: this plugin does not
+// depend on a second installation of Pi or change its global configuration.
+import type { ExtensionAPI } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+
+export default function commanderPermissions(pi: ExtensionAPI) {
+  if (process.env.COMMANDER_DELEGATE_URL) pi.registerTool({
+    name: 'commander_delegate', label: 'BenchGo', description: 'Delegate a task to another coding engine in the same project. Requires human approval.',
+    parameters: Type.Object({ provider: Type.Optional(Type.Union(['codex', 'claude', 'pi', 'opencode'].map(s => Type.Literal(s)))), text: Type.Optional(Type.String()), model: Type.Optional(Type.String()), operation: Type.Optional(Type.Union([Type.Literal('delegate'), Type.Literal('result')])), sessionId: Type.Optional(Type.String()) }),
+    async execute(_id, args, signal) {
+      const response = await fetch(process.env.COMMANDER_DELEGATE_URL!, { method: 'POST', headers: { authorization: `Bearer ${process.env.COMMANDER_DELEGATE_TOKEN}`, 'content-type': 'application/json' }, body: JSON.stringify(args), signal });
+      const value = await response.text(); if (!response.ok) throw new Error(value);
+      return { content: [{ type: 'text', text: value }], details: {} };
+    },
+  });
+  pi.on('tool_call', async (event, ctx) => {
+    if (!ctx.hasUI) return { block: true, reason: 'BenchGo approval channel is unavailable' };
+    const allowed = await ctx.ui.confirm(
+      `BenchGo: ${event.toolName}`,
+      JSON.stringify({ toolCallId: event.toolCallId, input: event.input }),
+    );
+    if (!allowed) return { block: true, reason: 'Denied by BenchGo user' };
+  });
+}