@jingyi0605/codingns4dsh 0.1.0 → 0.1.1

package/data/build/dist/host/auth-session.js

@@ -1,3 +1,4 @@
+import { CodingNsControlApiError } from './control-api-client.js';
 /**
  * Host 侧认证协调器。
  * 只管理状态和依赖边界，不创建 HTTP、计时器或 WebRTC 资源。
@@ -16,6 +17,7 @@ export class CodingNsAuthSession {
     };
     accessToken = null;
     credential = null;
+    refreshPromise = null;
     constructor(client, credentials, controlBaseUrl) {
         this.client = client;
         this.credentials = credentials;
@@ -43,6 +45,21 @@ export class CodingNsAuthSession {
     getControlClient() {
         return this.client;
     }
+    /**
+     * 执行需要 access token 的请求；服务端拒绝旧 token 时只续期一次并重试。
+     * refresh token 仍然只留在 Host，调用方无需复制认证恢复逻辑。
+     */
+    async withAccessToken(operation) {
+        try {
+            return await operation(this.requireAccessToken());
+        }
+        catch (error) {
+            if (!(error instanceof CodingNsControlApiError) || error.status !== 401)
+                throw error;
+            await this.refresh();
+            return operation(this.requireAccessToken());
+        }
+    }
     /** 使用保存的 refresh token 恢复会话；没有凭据时保持 logged_out。 */
     async restore() {
         const credential = await this.credentials.read();
@@ -68,6 +85,12 @@ export class CodingNsAuthSession {
         }
     }
     async refresh() {
+        if (this.refreshPromise !== null)
+            return this.refreshPromise;
+        this.refreshPromise = this.refreshInternal().finally(() => { this.refreshPromise = null; });
+        return this.refreshPromise;
+    }
+    async refreshInternal() {
         const credential = this.credential ?? await this.credentials.read();
         if (!credential) {
             this.reset('logged_out');
@@ -94,24 +117,23 @@ export class CodingNsAuthSession {
         this.reset('logged_out');
     }
     async getDevices() {
-        const token = this.requireAccessToken();
-        const devices = await this.client.getDevices(token);
+        const devices = await this.withAccessToken((accessToken) => this.client.getDevices(accessToken));
         this.state = { ...this.state, currentDevice: devices.currentDevice };
         return devices;
     }
     async listHostBindings() {
-        const response = await this.client.listHostBindings(this.requireAccessToken());
+        const response = await this.withAccessToken((accessToken) => this.client.listHostBindings(accessToken));
         const binding = response.bindings[0] ?? null;
         this.state = { ...this.state, binding };
         return response.bindings;
     }
     async bindHost(request) {
-        const response = await this.client.bindHost(this.requireAccessToken(), request);
+        const response = await this.withAccessToken((accessToken) => this.client.bindHost(accessToken, request));
         this.state = { ...this.state, binding: response.binding };
         return response.binding;
     }
     async unbindHost(bindingId) {
-        const response = await this.client.unbindHost(this.requireAccessToken(), bindingId);
+        const response = await this.withAccessToken((accessToken) => this.client.unbindHost(accessToken, bindingId));
         if (this.state.binding?.bindingId === response.binding.bindingId) {
             this.state = { ...this.state, binding: null };
         }
@@ -122,7 +144,7 @@ export class CodingNsAuthSession {
         const domain = tunnelDomain?.trim() || this.state.binding?.tunnelDomain;
         if (!domain)
             throw new Error('Codingns4DSH 尚未绑定 Host');
-        return this.client.createSignalingTicket(this.requireAccessToken(), { tunnelDomain: domain });
+        return this.withAccessToken((accessToken) => this.client.createSignalingTicket(accessToken, { tunnelDomain: domain }));
     }
     async saveResponse(response) {
         this.accessToken = response.accessToken;

package/data/build/dist/host/cli-adapters/claude-driver.d.ts

@@ -3,6 +3,8 @@ import type { CodingNsCliSessionProbeInput, CodingNsCliSessionProbeResult } from
 import { StandardStreamDriver, type StandardStreamDriverOptions } from './standard-stream-driver.js';
 export declare class ClaudeCodeDriver extends StandardStreamDriver {
     private readonly sessionRoots;
+    private readonly claudeConfigDir;
+    private readonly discoveryFetch;
     constructor(options?: StandardStreamDriverOptions);
     listModels(): Promise<import("../../shared/contracts/cli-adapter.js").CodingNsCliModelCatalog>;
     probeSession(input: CodingNsCliSessionProbeInput): Promise<CodingNsCliSessionProbeResult>;

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

@@ -1,20 +1,35 @@
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { StandardStreamDriver, emptyCatalog } from './standard-stream-driver.js';
-import { CLAUDE_CATALOG, enrichEfforts, isProviderDefaultModel } from './model-catalog.js';
+import { CLAUDE_CATALOG, isProviderDefaultModel } from './model-catalog.js';
+import { discoverClaudeModelCatalog } from './claude-model-options.js';
 import { probeStoredSession, readFirstJsonRecord } from './session-probe.js';
 import { firstToolText, isToolRecord, serializeToolValue } from './tool-observation.js';
 export class ClaudeCodeDriver extends StandardStreamDriver {
     sessionRoots;
+    claudeConfigDir;
+    discoveryFetch;
     constructor(options = {}) {
         super({ id: 'claude-code', name: 'Claude Code', protocol: 'stream-json', capabilities: ['models', 'stream', 'resume', 'interrupt', 'tool-events', 'reasoning', 'usage'] }, { binaries: ['claude'] }, options);
         this.sessionRoots = options.sessionRoots ?? [join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'projects')];
+        this.claudeConfigDir = options.claudeConfigDir;
+        this.discoveryFetch = options.fetch;
     }
     async listModels() {
-        if (!(await this.detect()).installed)
+        const detected = await this.detect();
+        if (!detected.installed || detected.command === null)
             return emptyCatalog();
-        const catalog = await super.listModels();
-        return catalog.groups.length > 0 ? enrichEfforts(catalog, CLAUDE_CATALOG) : CLAUDE_CATALOG;
+        try {
+            return await discoverClaudeModelCatalog({
+                command: detected.command,
+                spawn: this.runSpawn,
+                ...(this.discoveryFetch ? { fetch: this.discoveryFetch } : {}),
+                ...(this.claudeConfigDir ? { configDir: this.claudeConfigDir } : {}),
+            });
+        }
+        catch {
+            return CLAUDE_CATALOG;
+        }
     }
     async probeSession(input) {
         return probeStoredSession(input, {

package/data/build/dist/host/cli-adapters/claude-model-options.d.ts

@@ -0,0 +1,14 @@
+import { spawn } from 'node:child_process';
+import type { CodingNsCliModelCatalog } from '../../shared/contracts/cli-adapter.js';
+export interface ClaudeModelDiscoveryOptions {
+    readonly command: string;
+    readonly spawn?: typeof spawn;
+    readonly fetch?: typeof fetch;
+    readonly configDir?: string;
+    readonly workspaceDir?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly timeoutMs?: number;
+}
+/** 从 Claude CLI、兼容网关和本地配置合并真实模型目录。凭据只用于请求。 */
+export declare function discoverClaudeModelCatalog(options: ClaudeModelDiscoveryOptions): Promise<CodingNsCliModelCatalog>;
+//# sourceMappingURL=claude-model-options.d.ts.map

package/data/build/dist/host/cli-adapters/claude-model-options.js

@@ -0,0 +1,157 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { CLAUDE_CATALOG, enrichEfforts } from './model-catalog.js';
+import { terminateChildProcess } from './process-utils.js';
+const DEFAULT_TIMEOUT_MS = 8_000;
+const INITIALIZE_REQUEST_ID = 'codingns-model-discovery';
+const DEFAULT_MODEL_ID = 'provider-default';
+const ALIAS_ENV_KEYS = ['ANTHROPIC_DEFAULT_SONNET_MODEL', 'ANTHROPIC_DEFAULT_OPUS_MODEL', 'ANTHROPIC_DEFAULT_HAIKU_MODEL'];
+/** 从 Claude CLI、兼容网关和本地配置合并真实模型目录。凭据只用于请求。 */
+export async function discoverClaudeModelCatalog(options) {
+    const configDir = options.configDir ?? options.env?.CLAUDE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude');
+    const runtimeEnv = { ...process.env, ...(options.env ?? {}), ...readClaudeEnv(configDir, options.workspaceDir ?? process.cwd()) };
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const tasks = [readInitializeModels(options.command, runtimeEnv, options.spawn ?? spawn, timeoutMs)];
+    const gatewayUrl = resolveModelsUrl(runtimeEnv.ANTHROPIC_BASE_URL);
+    if (gatewayUrl)
+        tasks.push(readGatewayModels(gatewayUrl, runtimeEnv, options.fetch ?? fetch, timeoutMs));
+    const settled = await Promise.allSettled(tasks);
+    const discovered = settled.filter((result) => result.status === 'fulfilled').flatMap((result) => result.value);
+    const configured = configuredModels(runtimeEnv);
+    const merged = mergeModels([...CLAUDE_CATALOG.groups[0].models, ...discovered, ...configured]);
+    return enrichEfforts({ groups: [{ id: 'claude', name: 'Claude', models: merged }], currentModel: null, currentEffort: null }, CLAUDE_CATALOG);
+}
+function readClaudeEnv(configDir, workspaceDir) {
+    const files = [join(configDir, 'settings.json'), join(configDir, 'settings.local.json'), join(workspaceDir, '.claude', 'settings.json'), join(workspaceDir, '.claude', 'settings.local.json')];
+    return files.reduce((result, file) => {
+        if (!existsSync(file))
+            return result;
+        try {
+            const env = JSON.parse(readFileSync(file, 'utf8')).env;
+            if (!env || typeof env !== 'object')
+                return result;
+            for (const [key, value] of Object.entries(env))
+                if (typeof value === 'string' && value.trim())
+                    result[key] = value.trim();
+        }
+        catch { /* 损坏的配置不应阻塞模型发现。 */ }
+        return result;
+    }, {});
+}
+function configuredModels(env) {
+    const ids = [env.ANTHROPIC_MODEL, ...ALIAS_ENV_KEYS.map((key) => env[key])].filter((id) => Boolean(id?.trim())).map((id) => id.trim());
+    return ids.map((id) => ({ id, name: id, efforts: [] }));
+}
+function mergeModels(models) {
+    const result = [];
+    const seen = new Set();
+    for (const model of models) {
+        if (!model.id || seen.has(model.id))
+            continue;
+        seen.add(model.id);
+        result.push(model);
+    }
+    return result;
+}
+async function readInitializeModels(command, env, runSpawn, timeoutMs) {
+    const child = runSpawn(command, ['--print', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--no-session-persistence', '--tools', '', '--strict-mcp-config', '--mcp-config', '{"mcpServers":{}}'], { env: env, cwd: process.cwd(), stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true, shell: process.platform === 'win32' });
+    return new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (callback) => { if (settled)
+            return; settled = true; clearTimeout(timer); callback(); };
+        const timer = setTimeout(() => { terminateChildProcess(child); finish(() => reject(new Error('CLAUDE_MODEL_DISCOVERY_TIMEOUT'))); }, timeoutMs);
+        child.stdout.on('data', (chunk) => { stdout += String(chunk).slice(0, 1024 * 1024 - stdout.length); });
+        child.stderr.on('data', (chunk) => { stderr += String(chunk).slice(0, 16_384 - stderr.length); });
+        child.on('error', (error) => finish(() => reject(error)));
+        child.on('close', (code) => finish(() => {
+            if (code !== 0)
+                return reject(new Error(stderr.trim() || `CLAUDE_MODEL_DISCOVERY_FAILED:${code ?? 'unknown'}`));
+            try {
+                resolve(parseInitialize(stdout));
+            }
+            catch (error) {
+                reject(error);
+            }
+        }));
+        child.stdin.end(`${JSON.stringify({ type: 'control_request', request_id: INITIALIZE_REQUEST_ID, request: { subtype: 'initialize' } })}\n`);
+    });
+}
+function parseInitialize(output) {
+    const models = [];
+    for (const line of output.split(/\r?\n/u)) {
+        try {
+            const message = JSON.parse(line);
+            const raw = message.response?.response?.models;
+            if (message.type !== 'control_response' || message.response?.subtype !== 'success' || message.response.request_id !== INITIALIZE_REQUEST_ID || !Array.isArray(raw))
+                continue;
+            for (const item of raw) {
+                if (!item || typeof item !== 'object')
+                    continue;
+                const value = item.value;
+                if (typeof value !== 'string' || !value.trim())
+                    continue;
+                const id = value.trim() === 'default' ? DEFAULT_MODEL_ID : value.trim();
+                const displayName = item.displayName;
+                const efforts = item.supportedEffortLevels;
+                models.push({ id, name: typeof displayName === 'string' && displayName.trim() ? displayName.trim() : value.trim(), efforts: Array.isArray(efforts) ? efforts.filter((level) => typeof level === 'string') : [] });
+            }
+        }
+        catch { /* 忽略 CLI 输出中的非 JSON 行。 */ }
+    }
+    if (models.length === 0)
+        throw new Error('CLAUDE_MODELS_RESPONSE_EMPTY');
+    return mergeModels(models);
+}
+async function readGatewayModels(url, env, request, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const authToken = env.ANTHROPIC_AUTH_TOKEN ?? env.ANTHROPIC_API_KEY;
+        const headers = { accept: 'application/json', 'anthropic-version': '2023-06-01' };
+        if (env.ANTHROPIC_AUTH_TOKEN)
+            headers.authorization = `Bearer ${env.ANTHROPIC_AUTH_TOKEN}`;
+        if (authToken)
+            headers['x-api-key'] = authToken;
+        const response = await request(url, { headers, signal: controller.signal });
+        if (!response.ok)
+            throw new Error(`CLAUDE_MODEL_CATALOG_HTTP_${response.status}`);
+        const body = await response.json();
+        const raw = Array.isArray(body.data) ? body.data : Array.isArray(body.models) ? body.models : [];
+        const models = raw.flatMap((item) => {
+            if (!item || typeof item !== 'object')
+                return [];
+            const object = item;
+            const value = object.id ?? object.value;
+            if (typeof value !== 'string' || !value.trim())
+                return [];
+            const name = object.display_name ?? object.name;
+            return [{ id: value.trim(), name: typeof name === 'string' && name.trim() ? name.trim() : value.trim(), efforts: [] }];
+        });
+        if (models.length === 0)
+            throw new Error('CLAUDE_MODEL_CATALOG_RESPONSE_EMPTY');
+        return mergeModels(models);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function resolveModelsUrl(baseUrl) {
+    if (!baseUrl?.trim())
+        return null;
+    try {
+        const url = new URL(baseUrl.trim());
+        const pathname = url.pathname.replace(/\/+$/u, '');
+        if (/\/v1\/models$/iu.test(pathname))
+            return url.toString();
+        url.pathname = /\/v1$/iu.test(pathname) ? `${pathname}/models` : `${pathname}/v1/models`;
+        return url.toString();
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=claude-model-options.js.map

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

@@ -15,6 +15,7 @@ export declare class CodexAppServerDriver implements CodingNsCliDriver {
         readonly protocol: "json-rpc";
         readonly capabilities: readonly ["models", "stream", "resume", "interrupt", "tool-events", "reasoning", "usage", "permission", "questions", "steer"];
     };
+    readonly supportsSegmentedTurns = true;
     private readonly binaries;
     private readonly runSpawnSync;
     private readonly runSpawn;
@@ -31,6 +32,16 @@ export declare class CodexAppServerDriver implements CodingNsCliDriver {
     listModels(): Promise<CodingNsCliModelCatalog>;
     probeSession(input: CodingNsCliSessionProbeInput): Promise<CodingNsCliSessionProbeResult>;
     executeTurn(input: CodingNsCliTurnInput): AsyncIterable<CodingNsAgentEvent>;
+    /**
+     * 将一个 Codex turn 按工具完成点切成多个 DSH step。
+     *
+     * DSH 的 step 边界只能由 Agent Loop 提交；这里仅提前结束本次 llm/stream，
+     * 保留同一个 Codex turn 的通知队列，下一次 llm/stream 再继续消费它。
+     */
+    private executeSegmentedTurn;
+    private startSegmentedTurn;
+    private consumeSegment;
+    private closeSegmentedTurn;
     /** 将新输入 steer 到当前 Codex turn。 */
     steer(sessionId: string, prompt: string): Promise<void>;
     /** 中断当前 Codex turn，但保留 app-server 线程。 */

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

@@ -10,6 +10,7 @@ import { isQuestionEvent, questionAnswersRecord, readAgentQuestions } from './in
 /** Codex app-server 的 JSON-RPC 驱动，Host 只暴露统一文本流，不暴露线程和 token。 */
 export class CodexAppServerDriver {
     descriptor = { id: 'codex', name: 'Codex', protocol: 'json-rpc', capabilities: ['models', 'stream', 'resume', 'interrupt', 'tool-events', 'reasoning', 'usage', 'permission', 'questions', 'steer'] };
+    supportsSegmentedTurns = true;
     binaries;
     runSpawnSync;
     runSpawn;
@@ -39,7 +40,7 @@ export class CodexAppServerDriver {
         const timer = setTimeout(() => controller.abort(), 12_000);
         try {
             await rpc.request('initialize', {
-                clientInfo: { name: 'codingns4dsh', version: '0.1.0' },
+                clientInfo: { name: 'codingns4dsh', version: '0.1.1' },
                 capabilities: {},
             }, { signal: controller.signal });
             rpc.notify('initialized', {});
@@ -71,6 +72,10 @@ export class CodexAppServerDriver {
         const command = this.cachedBinary ?? (await this.detect()).command;
         if (command === null)
             throw new Error('Codex 未安装');
+        if (input.splitToolSteps) {
+            yield* this.executeSegmentedTurn(input, command);
+            return;
+        }
         const session = await this.getSession(input, command);
         const rpc = session.rpc;
         try {
@@ -167,6 +172,143 @@ export class CodexAppServerDriver {
         }
         finally { /* app-server 在会话结束前保持连接。 */ }
     }
+    /**
+     * 将一个 Codex turn 按工具完成点切成多个 DSH step。
+     *
+     * DSH 的 step 边界只能由 Agent Loop 提交；这里仅提前结束本次 llm/stream，
+     * 保留同一个 Codex turn 的通知队列，下一次 llm/stream 再继续消费它。
+     */
+    async *executeSegmentedTurn(input, command) {
+        const session = await this.getSession(input, command);
+        const rpc = session.rpc;
+        let active;
+        try {
+            if (session.threadId === '') {
+                const thread = input.providerSessionId
+                    ? await rpc.request('thread/resume', { threadId: input.providerSessionId, cwd: input.cwd ?? process.cwd(), ...(!isProviderDefaultModel(input.modelId) ? { model: input.modelId } : {}) }, { signal: input.signal, killOnAbort: false })
+                    : await rpc.request('thread/start', { cwd: input.cwd ?? process.cwd(), ...(!isProviderDefaultModel(input.modelId) ? { model: input.modelId } : {}) }, { signal: input.signal, killOnAbort: false });
+                session.threadId = readId(thread) ?? input.providerSessionId ?? input.sessionId;
+                session.providerSessionId = session.threadId;
+            }
+            active = session.segmentedTurn ?? await this.startSegmentedTurn(session, input);
+            const isNew = session.segmentedTurn === undefined;
+            if (isNew)
+                session.segmentedTurn = active;
+            if (isNew)
+                yield { type: 'session-binding', providerSessionId: session.providerSessionId };
+            for await (const chunk of this.consumeSegment(active, input))
+                yield chunk;
+            if (active.done && session.segmentedTurn === active)
+                session.segmentedTurn = undefined;
+        }
+        catch (error) {
+            if (active !== undefined && !active.done)
+                this.closeSegmentedTurn(session, active);
+            if (!input.signal?.aborted)
+                throw error;
+            await this.interrupt(input.sessionId);
+        }
+    }
+    async startSegmentedTurn(session, input) {
+        const eventQueue = createCodexTurnEventQueue();
+        let activeTurnId = null;
+        let turnStartResolved = false;
+        const notificationsBeforeTurnStart = [];
+        const active = {
+            queue: eventQueue,
+            removeNotificationListener: () => undefined,
+            terminalReason: null,
+            done: false,
+            removeAbortListener: () => undefined,
+        };
+        const acceptNotification = (message, allowUnidentifiedTool) => {
+            if (!isCodexNotificationForTurn(message, session.threadId, activeTurnId, allowUnidentifiedTool))
+                return;
+            const turnId = readTurnId(message);
+            if (turnId !== null) {
+                activeTurnId = turnId;
+                session.turnId = turnId;
+            }
+            eventQueue.push(message);
+            const reason = readCodexTerminalReason(message);
+            if (reason !== null) {
+                active.terminalReason = reason;
+                eventQueue.close();
+            }
+        };
+        const onNotification = (message) => {
+            if (!turnStartResolved) {
+                notificationsBeforeTurnStart.push(message);
+                return;
+            }
+            acceptNotification(message, true);
+        };
+        active.removeNotificationListener = session.rpc.addNotificationListener(onNotification);
+        const onAbort = () => {
+            active.terminalReason = 'cancel';
+            eventQueue.close();
+        };
+        active.removeAbortListener = () => input.signal?.removeEventListener('abort', onAbort);
+        if (input.signal?.aborted)
+            onAbort();
+        else
+            input.signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            const response = await session.rpc.request('turn/start', {
+                threadId: session.threadId,
+                input: [{ type: 'text', text: input.prompt }],
+                ...(input.effortId ? { effort: input.effortId } : {}),
+            }, { signal: input.signal, killOnAbort: false });
+            const responseTurnId = readTurnId(response);
+            if (responseTurnId !== null) {
+                activeTurnId = responseTurnId;
+                session.turnId = responseTurnId;
+            }
+            turnStartResolved = true;
+            for (const message of notificationsBeforeTurnStart.splice(0))
+                acceptNotification(message, false);
+            const responseTerminal = buildCodexCompletionNotification(response, session.threadId);
+            if (responseTerminal !== null)
+                onNotification(responseTerminal);
+            return active;
+        }
+        catch (error) {
+            this.closeSegmentedTurn(session, active);
+            throw error;
+        }
+    }
+    async *consumeSegment(active, input) {
+        while (true) {
+            const next = await active.queue.next();
+            if (next.done) {
+                if (input.signal?.aborted)
+                    throw new Error('请求已取消');
+                active.done = true;
+                active.removeAbortListener();
+                active.removeNotificationListener();
+                yield { type: 'finish', reason: active.terminalReason ?? 'stop' };
+                return;
+            }
+            if (input.signal?.aborted)
+                throw new Error('请求已取消');
+            const chunk = codexMessageToChunk(next.value);
+            if (chunk === null)
+                continue;
+            yield chunk;
+            if (chunk.type === 'tool-event' && (chunk.status === 'completed' || chunk.status === 'failed')) {
+                yield { type: 'step-boundary' };
+                return;
+            }
+        }
+    }
+    closeSegmentedTurn(session, active) {
+        active.done = true;
+        active.removeAbortListener();
+        active.removeNotificationListener();
+        active.queue.close();
+        if (session.segmentedTurn === active)
+            session.segmentedTurn = undefined;
+    }
     /** 将新输入 steer 到当前 Codex turn。 */
     async steer(sessionId, prompt) {
         const session = this.sessions.get(sessionId);
@@ -210,6 +352,8 @@ export class CodexAppServerDriver {
     }
     dispose() {
         for (const session of this.sessions.values()) {
+            if (session.segmentedTurn !== undefined)
+                this.closeSegmentedTurn(session, session.segmentedTurn);
             for (const resolve of session.pendingPermissions.values())
                 resolve({ approved: false });
             session.pendingPermissions.clear();
@@ -226,6 +370,8 @@ export class CodexAppServerDriver {
         const previous = this.sessions.get(input.sessionId);
         if (previous !== undefined && previous.cwd === input.cwd)
             return previous;
+        if (previous?.segmentedTurn !== undefined)
+            this.closeSegmentedTurn(previous, previous.segmentedTurn);
         previous?.rpc.dispose();
         const rpc = new JsonRpcProcess({ command, args: ['app-server'], cwd: input.cwd, spawn: this.runSpawn });
         const session = {
@@ -236,10 +382,11 @@ export class CodexAppServerDriver {
             providerSessionId: input.providerSessionId ?? input.sessionId,
             pendingPermissions: new Map(),
             pendingQuestions: new Map(),
+            segmentedTurn: undefined,
         };
         this.processes.add(rpc);
         this.sessions.set(input.sessionId, session);
-        await rpc.request('initialize', { clientInfo: { name: 'codingns4dsh', version: '0.1.0' }, capabilities: {} }, { signal: input.signal, killOnAbort: false });
+        await rpc.request('initialize', { clientInfo: { name: 'codingns4dsh', version: '0.1.1' }, capabilities: {} }, { signal: input.signal, killOnAbort: false });
         rpc.notify('initialized', {});
         rpc.setServerRequestHandler((request) => {
             const requestId = readRequestId(request);
@@ -314,10 +461,13 @@ function codexMessageToChunk(message) {
         if (requestId !== null)
             return { type: 'permission-request', requestId, kind: typeof params.kind === 'string' ? params.kind : 'unknown', ...(detail ? { detail } : {}) };
     }
-    if (method.includes('agentMessage') || method.includes('message') && (type.includes('text') || type === ''))
-        return text ? { type: 'text-delta', text } : null;
-    if (method.includes('reason') || type.includes('reason'))
-        return text ? { type: 'reasoning-delta', text } : null;
+    const messageId = firstToolText(params.itemId, item.id);
+    if (method.includes('agentMessage') || method.includes('message') && (type.includes('text') || type === '')) {
+        return text ? { type: 'text-delta', text, ...(messageId === undefined ? {} : { messageId }) } : null;
+    }
+    if (method.includes('reason') || type.includes('reason')) {
+        return text ? { type: 'reasoning-delta', text, ...(messageId === undefined ? {} : { messageId }) } : null;
+    }
     if (isCodexToolEvent(method, type)) {
         const name = firstToolText(item.name, item.toolName, item.tool, item.command !== undefined ? 'command_execution' : undefined, type);
         const callId = firstToolText(item.callId, item.call_id, item.toolCallId, item.id, params.itemId);
@@ -424,21 +574,23 @@ function createCodexTurnEventQueue() {
     const values = [];
     const waiters = [];
     let closed = false;
+    const next = () => {
+        const value = values.shift();
+        if (value !== undefined)
+            return Promise.resolve({ done: false, value });
+        if (closed)
+            return Promise.resolve({ done: true, value: undefined });
+        return new Promise((resolve) => waiters.push(resolve));
+    };
     return {
         iterable: {
             [Symbol.asyncIterator]() {
                 return {
-                    next() {
-                        const value = values.shift();
-                        if (value !== undefined)
-                            return Promise.resolve({ done: false, value });
-                        if (closed)
-                            return Promise.resolve({ done: true, value: undefined });
-                        return new Promise((resolve) => waiters.push(resolve));
-                    },
+                    next,
                 };
             },
         },
+        next,
         push(message) {
             if (closed)
                 return;

package/data/build/dist/host/cli-adapters/driver.d.ts

@@ -27,6 +27,8 @@ export interface CodingNsCliSessionProbeResult {
  */
 export interface CodingNsCliDriver {
     readonly descriptor: Omit<CodingNsCliAdapterDescriptor, 'installed' | 'enabled' | 'version' | 'command'>;
+    /** 驱动是否已经自行维护 Provider turn 的 step 边界。 */
+    readonly supportsSegmentedTurns?: boolean;
     detect(): Promise<Pick<CodingNsCliAdapterDescriptor, 'installed' | 'version' | 'command'>>;
     listModels(): Promise<CodingNsCliModelCatalog>;
     probeSession?(input: CodingNsCliSessionProbeInput): Promise<CodingNsCliSessionProbeResult>;

package/data/build/dist/host/cli-adapters/dsh-message-projector.d.ts

@@ -21,6 +21,11 @@ export declare class CodingNsDshMessageProjector {
     private readonly options;
     private readonly normalizer;
     private readonly toolHistory;
+    private reasoningIndex;
+    private textIndex;
+    private nextBlockIndex;
+    private reasoningText;
+    private textText;
     private finished;
     constructor(options: CodingNsDshMessageProjectorOptions);
     get isFinished(): boolean;
@@ -30,7 +35,17 @@ export declare class CodingNsDshMessageProjector {
     /** 把执行异常也交给同一投影层，确保错误正文和终态结构一致。 */
     fail(message: string, cancelled?: boolean): Promise<readonly CodingNsDshStreamChunk[]>;
     private flushUsage;
+    /** Provider 的 usage 到达时立即给 token-meter 一个非 surface 采样点。
+     *
+     * DSH 规范要求正式 usage 仍随 assistant/message 在 finish 前结算，因此这里不
+     * 提前向 LLM 流发送第二个 usage，只写入 assistant/attempt 供上下文计量投影使用。
+     */
+    private recordUsageSample;
     private project;
+    private appendDelta;
+    private openBlock;
+    private closeMessageBlock;
+    private externalToolChunk;
     private requestPermission;
     private requestQuestions;
 }