@jingyi0605/codingns4dsh 0.2.1-beta.9 → 0.2.1-rc.3

package/data/build/dist/host/cli-adapters/codex-driver.js

@@ -9,8 +9,12 @@ import { CODEX_CATALOG, isProviderDefaultModel } from './model-catalog.js';
 import { probeStoredSession, readFirstJsonRecord } from './session-probe.js';
 import { firstToolText, normalizeToolStatus, serializeToolValue } from './tool-observation.js';
 import { isQuestionEvent, questionAnswersRecord, readAgentQuestions } from './interaction-events.js';
-import { codexBridgeArgs, codexBridgeDeveloperInstructions, codexComputerUseLaunchSettings } from '../cli-bridge/injections.js';
+import { codexBridgeArgs, codexBridgeDeveloperInstructions, codexComputerUseLaunchSettings, teamBridgeToken } from '../cli-bridge/injections.js';
 import { CodexFileCitationNormalizer } from './codex-file-citations.js';
+import { CodexPerformanceTracker } from './codex-performance.js';
+/** Codex app-server 对已结束回合执行 turn/steer 时返回的固定错误文本。 */
+const CODEX_NO_ACTIVE_TURN_TO_STEER = 'no active turn to steer';
+const DEFAULT_STEER_TERMINAL_GRACE_MS = 2_000;
 // 只有 Provider 已明确报告超过窗口时才主动压缩；接近上限仍交给 Codex
 // 自身的 auto-compact，避免对正常的高占用回合重复发起压缩。
 const CODEX_COMPACTION_THRESHOLD = 1;
@@ -64,11 +68,13 @@ export class CodexAppServerDriver {
     binaries;
     runSpawnSync;
     runSpawn;
+    now;
     sessionRoots;
     /** Codex 配置根目录；`config.toml` 与 `auth.json` 都位于这里。 */
     codexHome;
     computerUseMode;
     computerUseConfig;
+    steerTerminalGraceMs;
     cachedBinary = null;
     processes = new Set();
     sessions = new Map();
@@ -76,12 +82,14 @@ export class CodexAppServerDriver {
         this.binaries = options.binaries ?? ['codex'];
         this.runSpawnSync = options.spawnSync ?? spawnSync;
         this.runSpawn = options.spawn ?? spawn;
+        this.now = options.now ?? Date.now;
         const codexHome = options.codexHome ?? process.env.CODEX_HOME ?? join(homedir(), '.codex');
         this.codexHome = codexHome;
         // 直接构造驱动时保持旧的安全默认值；正式 Feature 显式传入 auto，避免测试
         // 或第三方嵌入在没有桌面宿主时意外启动 CUA 运行时。
         this.computerUseMode = options.computerUse ?? 'disabled';
         this.computerUseConfig = options.computerUseConfig;
+        this.steerTerminalGraceMs = options.steerTerminalGraceMs ?? DEFAULT_STEER_TERMINAL_GRACE_MS;
         this.sessionRoots = options.sessionRoots ?? [join(codexHome, 'sessions'), join(codexHome, 'archived_sessions')];
     }
     /**
@@ -125,7 +133,7 @@ export class CodexAppServerDriver {
         const timer = setTimeout(() => controller.abort(), 12_000);
         try {
             await rpc.request('initialize', {
-                clientInfo: { name: 'codingns4dsh', version: '0.1.1' },
+                clientInfo: { name: 'Codex', version: '0.1.1' },
                 capabilities: {},
             }, { signal: controller.signal });
             rpc.notify('initialized', {});
@@ -207,8 +215,9 @@ export class CodexAppServerDriver {
         try {
             if (session.threadId === '') {
                 const threadParams = codexThreadParams(input);
-                const thread = input.providerSessionId
-                    ? await rpc.request('thread/resume', { threadId: input.providerSessionId, ...threadParams }, { signal: input.signal, killOnAbort: false })
+                const resumeThreadId = input.providerSessionId ?? session.resumeThreadId;
+                const thread = resumeThreadId
+                    ? await rpc.request('thread/resume', { threadId: resumeThreadId, ...threadParams }, { signal: input.signal, killOnAbort: false })
                     : await rpc.request('thread/start', threadParams, { signal: input.signal, killOnAbort: false });
                 session.threadId = readId(thread) ?? input.providerSessionId ?? input.sessionId;
                 session.providerSessionId = session.threadId;
@@ -248,7 +257,7 @@ export class CodexAppServerDriver {
                 if (turnId !== null) {
                     session.turnId = turnId;
                 }
-                eventQueue.push(message);
+                eventQueue.push(withCodexPerformance(session, message));
                 const reason = readCodexTerminalReason(message);
                 if (reason !== null) {
                     terminalReason = reason;
@@ -335,7 +344,12 @@ export class CodexAppServerDriver {
                 yield { type: 'finish', reason };
             }
         }
-        finally { /* app-server 在会话结束前保持连接。 */ }
+        finally {
+            // app-server 在会话结束前保持连接；但回合中止时仍挂起的问题/审批必须
+            // 结算，否则 Codex 认为该 turn 还在等待输入，后续回合会卡住。
+            if (input.signal?.aborted)
+                this.releasePendingRequests(session);
+        }
     }
     /**
      * 将一个 Codex turn 按 assistant item 切成多个 DSH step。
@@ -351,8 +365,9 @@ export class CodexAppServerDriver {
         try {
             if (session.threadId === '') {
                 const threadParams = codexThreadParams(input);
-                const thread = input.providerSessionId
-                    ? await rpc.request('thread/resume', { threadId: input.providerSessionId, ...threadParams }, { signal: input.signal, killOnAbort: false })
+                const resumeThreadId = input.providerSessionId ?? session.resumeThreadId;
+                const thread = resumeThreadId
+                    ? await rpc.request('thread/resume', { threadId: resumeThreadId, ...threadParams }, { signal: input.signal, killOnAbort: false })
                     : await rpc.request('thread/start', threadParams, { signal: input.signal, killOnAbort: false });
                 session.threadId = readId(thread) ?? input.providerSessionId ?? input.sessionId;
                 session.providerSessionId = session.threadId;
@@ -392,8 +407,11 @@ export class CodexAppServerDriver {
             // Provider turn，单纯续读旧队列会让这条消息只在 DSH 临时快照里出现，
             // 随即被消费掉；只有把真实用户输入转成 `turn/steer`，Codex 才会继续
             // 生成新方向的正文。内部 step 提示和问题回答不属于用户插话，不能重复注入。
-            if (!isNew && isCodexSteeringInput(input))
-                await this.steer(input.sessionId, input.prompt);
+            if (!isNew && isCodexSteeringInput(input)) {
+                const delivered = yield* this.deliverSegmentedSteer(session, active, input, command);
+                if (delivered)
+                    return;
+            }
             for await (const chunk of this.consumeSegment(session, active, input))
                 yield chunk;
             if (active.done && session.segmentedTurn === active)
@@ -407,6 +425,72 @@ export class CodexAppServerDriver {
             await this.interrupt(input.sessionId);
         }
     }
+    /**
+     * 把续段中的真实用户插话交给 Codex；返回 true 表示本次 llm/stream 已经处理完毕。
+     *
+     * DSH 翻译插话期间，挂起的 Provider turn 可能已经结束。此时 `turn/steer` 无处投递，
+     * 只能先产出旧回合的剩余输出，再用新 turn 执行插话。只有 Codex 明确回复“无活动
+     * 回合”才允许重新提交；超时或其他协议错误可能已被接收，重发会让同一输入执行两次。
+     */
+    async *deliverSegmentedSteer(session, active, input, command) {
+        let terminalFallback;
+        if (active.terminalReason === null) {
+            try {
+                await this.steer(input.sessionId, input.prompt);
+                return false;
+            }
+            catch (error) {
+                if (!isCodexNoActiveTurnError(error))
+                    throw error;
+                // 拒绝响应可能先于终态通知到达。立即关闭队列会丢弃随后到达的 interrupted
+                // 或 failed，把被中断的回合误判为正常结束并重新执行插话；因此先等待真实终态。
+                if (active.terminalReason === null) {
+                    terminalFallback = setTimeout(() => {
+                        active.terminalReason ??= 'stop';
+                        active.queue.close();
+                    }, this.steerTerminalGraceMs);
+                }
+            }
+        }
+        try {
+            // 旧回合的剩余输出与新回合正文同属插话后的这一步。中途的 step 边界和 stop
+            // 不能交给 DSH，否则 DSH 会结算这一步并再次消费同一条插话。
+            while (!active.done) {
+                for await (const chunk of this.consumeSegment(session, active, input)) {
+                    if (chunk.type === 'step-boundary')
+                        continue;
+                    if (chunk.type === 'finish' && chunk.reason === 'stop')
+                        continue;
+                    // 旧回合已经结束，它遗留的问题或审批无法再影响结果；直接回绝，
+                    // 不能让 DSH 等待用户回答一个已失效的请求而阻塞插话。
+                    if (chunk.type === 'question-request') {
+                        this.releaseStaleRequest(() => this.respondQuestion(input.sessionId, { requestId: chunk.requestId, answers: [] }));
+                        continue;
+                    }
+                    if (chunk.type === 'permission-request') {
+                        this.releaseStaleRequest(() => this.respondPermission(input.sessionId, { requestId: chunk.requestId, approved: false }));
+                        continue;
+                    }
+                    yield chunk;
+                }
+            }
+        }
+        finally {
+            clearTimeout(terminalFallback);
+        }
+        // 中断或失败的回合已由上面的 finish 报告终态，不能再自动执行插话。
+        if (active.terminalReason !== 'stop' || input.signal?.aborted)
+            return true;
+        yield* this.executeSegmentedTurn({ ...input, resumeSegmentedTurn: false }, command);
+        return true;
+    }
+    /** 回绝已结束回合遗留的反向请求；请求已被其他路径清理时忽略。 */
+    releaseStaleRequest(release) {
+        try {
+            release();
+        }
+        catch { /* 请求已不存在 */ }
+    }
     async startSegmentedTurn(session, input) {
         const eventQueue = createCodexTurnEventQueue();
         let turnStartResolved = false;
@@ -440,7 +524,7 @@ export class CodexAppServerDriver {
             if (turnId !== null) {
                 session.turnId = turnId;
             }
-            eventQueue.push(message);
+            eventQueue.push(withCodexPerformance(session, message));
             const reason = readCodexTerminalReason(message);
             if (reason !== null) {
                 active.terminalReason = reason;
@@ -565,6 +649,32 @@ export class CodexAppServerDriver {
         active.queue.close();
         if (session.segmentedTurn === active)
             session.segmentedTurn = undefined;
+        this.releasePendingRequests(session);
+    }
+    /**
+     * 释放仍挂起的反向请求。
+     *
+     * Codex app-server 把 `requestUserInput` 和各类审批作为 server request 发给
+     * 客户端，驱动只有拿到回包才会让对应 turn 继续。回合被中止、分段被丢弃或
+     * 会话被替换时，如果这些 Promise 永远不 resolve，app-server 侧就会认为
+     * 该 turn 仍在等待输入；后续同一个 thread 上的新回合会表现成“发消息没有
+     * 反应”或直接卡住。这里统一按“取消/拒绝”结算，属于协议层的收尾。
+     */
+    releasePendingRequests(session) {
+        for (const resolve of session.pendingQuestions.values()) {
+            try {
+                resolve({ answers: {} });
+            }
+            catch { /* 请求可能已被其他路径清理 */ }
+        }
+        session.pendingQuestions.clear();
+        for (const pending of session.pendingPermissions.values()) {
+            try {
+                pending.resolve({ approved: false });
+            }
+            catch { /* 请求可能已被其他路径清理 */ }
+        }
+        session.pendingPermissions.clear();
     }
     /**
      * 让线程真正生效的模型与 DSH 当前选择的模型保持一致。
@@ -638,6 +748,7 @@ export class CodexAppServerDriver {
     /** turn/start 遇到上下文超限时压缩一次并重试，兼容关闭自动压缩的 Codex 配置。 */
     async startTurn(session, input) {
         await this.prepareSkillInputs(session, input);
+        session.performance.beginTurn();
         try {
             return await session.rpc.request('turn/start', codexTurnStartParams(input, session.threadId, session.skills), { signal: input.signal, killOnAbort: false });
         }
@@ -645,6 +756,7 @@ export class CodexAppServerDriver {
             if (!isContextWindowError(error))
                 throw error;
             await this.compactThread(session, input);
+            session.performance.beginTurn();
             return session.rpc.request('turn/start', codexTurnStartParams(input, session.threadId, session.skills), { signal: input.signal, killOnAbort: false });
         }
     }
@@ -898,7 +1010,8 @@ export class CodexAppServerDriver {
     }
     async getSession(input, command) {
         const previous = this.sessions.get(input.sessionId);
-        if (previous !== undefined && previous.cwd === input.cwd)
+        const teamToken = teamBridgeToken(input.sessionId);
+        if (previous !== undefined && previous.cwd === input.cwd && previous.teamToken === teamToken && !previous.rpc.isClosed)
             return previous;
         if (previous?.segmentedTurn !== undefined)
             this.closeSegmentedTurn(previous, previous.segmentedTurn);
@@ -909,6 +1022,9 @@ export class CodexAppServerDriver {
         // 统一置于子命令前，避免不同版本对全局/子命令参数的解析差异。
         const rpc = new JsonRpcProcess({ command, args: [...bridgeArgs, ...this.appServerArgs()], cwd: input.cwd, explicitWindowsShell: true, spawn: this.runSpawn });
         const session = {
+            teamToken,
+            resumeThreadId: input.providerSessionId ?? (previous?.cwd === input.cwd ? previous?.threadId || previous?.resumeThreadId : undefined),
+            performance: new CodexPerformanceTracker(this.now),
             rpc,
             cwd: input.cwd,
             modelId: input.modelId,
@@ -940,7 +1056,7 @@ export class CodexAppServerDriver {
             session.skills.clear();
             session.skillsCwd = undefined;
         });
-        await rpc.request('initialize', { clientInfo: { name: 'codingns4dsh', version: '0.1.1' }, capabilities: { experimentalApi: true } }, { signal: input.signal, killOnAbort: false });
+        await rpc.request('initialize', { clientInfo: { name: 'Codex', version: '0.1.1' }, capabilities: { experimentalApi: true } }, { signal: input.signal, killOnAbort: false });
         rpc.notify('initialized', {});
         rpc.setServerRequestHandler((request) => {
             const requestId = readRequestId(request);
@@ -1009,14 +1125,18 @@ function stabilizeCodexEvent(session, event) {
     return { ...event, shadowedTokenCount: session.contextTokens };
 }
 function prepareCodexSession(session, input) {
-    // 未提供 modelId 表示沿用当前 Codex thread 的模型，不能因为配置字段缺省
-    // 就把已经确认的上下文容量清空。
-    if (input.modelId === undefined || session.modelId === input.modelId)
-        return;
-    // 模型切换意味着上下文容量可能改变；只有这类明确路由变化才允许重置
-    // 稳定窗口，同一模型的迟到 usage 不能触发重置。
-    session.modelId = input.modelId;
-    session.contextWindow = undefined;
+    if (input.modelId !== undefined && session.modelId !== input.modelId) {
+        // A model change may change context capacity, so discard the old anchor first.
+        session.modelId = input.modelId;
+        session.contextWindow = undefined;
+    }
+    // Host-validated Magpie metadata is authoritative for this model and must be
+    // applied before the first usage event can anchor a stale provider value.
+    if (typeof input.modelContextWindow === 'number'
+        && Number.isSafeInteger(input.modelContextWindow)
+        && input.modelContextWindow > 0) {
+        session.contextWindow = input.modelContextWindow;
+    }
 }
 function parseCodexCatalog(value) {
     const root = isRecord(value) && isRecord(value.data) ? value.data : value;
@@ -1283,7 +1403,8 @@ function codexMessageToChunk(message, cwd) {
         const callId = firstToolText(item.callId, item.call_id, item.toolCallId, item.id, params.itemId);
         const agentId = firstToolText(item.agentId, item.agent_id, type.includes('agent') || type.includes('collab') ? item.id : undefined);
         const input = serializeToolValue(isFileChangeType(type) ? fileChangeToolInput(item) : item.arguments ?? item.input ?? item.command);
-        const rawOutput = item.result ?? item.output ?? item.aggregated_output;
+        // app-server v2 的 commandExecution 使用 camelCase aggregatedOutput；snake_case 保留给旧协议。
+        const rawOutput = item.result ?? item.output ?? item.aggregatedOutput ?? item.aggregated_output;
         const explicitError = serializeToolValue(item.error);
         const output = serializeToolValue(rawOutput);
         const exitCodeFailed = typeof item.exitCode === 'number' && item.exitCode !== 0 || typeof item.exit_code === 'number' && item.exit_code !== 0;
@@ -1341,10 +1462,16 @@ function codexImageData(value) {
         return undefined;
     return codexImageData(value.b64_json ?? value.base64 ?? value.data ?? value.image_url ?? value.url);
 }
+/** Codex 明确拒绝插话且未接收输入时才返回 true；其他错误都可能已被接收。 */
+function isCodexNoActiveTurnError(error) {
+    return error instanceof JsonRpcRequestError && error.message === CODEX_NO_ACTIVE_TURN_TO_STEER;
+}
 /** 判断分段续流是否带来了新的真实用户插话。 */
 function isCodexSteeringInput(input) {
     if (input.resumeSegmentedTurn !== true || input.prompt.trim() === '')
         return false;
+    if (input.peerInput)
+        return true;
     for (let index = input.messages.length - 1; index >= 0; index -= 1) {
         const message = input.messages[index];
         if (message?.role !== 'user')
@@ -1546,6 +1673,7 @@ function codexUsageChunk(params) {
     const contextTokens = usage.inputTokens;
     return {
         ...usage,
+        ...(params.codingnsCodexPerformance === undefined ? {} : { codexPerformance: params.codingnsCodexPerformance }),
         ...(contextWindow === undefined ? {} : {
             contextWindow,
             contextTokens,
@@ -1556,6 +1684,12 @@ function codexUsageChunk(params) {
 function optionalToken(value) {
     return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
+function withCodexPerformance(session, message) {
+    const performance = session.performance.observe(message);
+    return performance === undefined ? message : {
+        ...message, params: { ...(isRecord(message.params) ? message.params : {}), codingnsCodexPerformance: performance },
+    };
+}
 function readRequestId(value) {
     if (!isRecord(value))
         return null;
@@ -1807,8 +1941,10 @@ function codexTurnStartParams(input, threadId, skills) {
         threadId,
         input: inputBlocks,
         cwd,
+        responsesapiClientMetadata: { workspace_kind: 'project' },
         sandboxPolicy: codexSandboxPolicy(input, cwd),
         approvalPolicy: codexApprovalPolicy(input),
+        ...(!isProviderDefaultModel(input.modelId) ? { model: input.modelId } : {}),
         ...(input.effortId ? { effort: input.effortId } : {}),
     };
 }