@jingyi0605/codingns4dsh 0.1.0

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

@@ -0,0 +1,372 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { JsonRpcProcess } from './json-rpc-process.js';
+import { detectBinary, emptyCatalog, isRecord, textValue, usageChunk } from './rpc-driver-utils.js';
+import { GROK_CATALOG, isProviderDefaultModel } from './model-catalog.js';
+import { isRegularFile, probeStoredSession, resolveSessionDirectory } from './session-probe.js';
+import { firstToolText, isToolRecord, normalizeToolStatus, serializeToolValue } from './tool-observation.js';
+/** Grok Build 的 ACP stdio 驱动。ACP 会话和权限细节只在 Host 进程内处理。 */
+export class GrokBuildDriver {
+    descriptor = { id: 'grok', name: 'Grok Build', protocol: 'acp', capabilities: ['models', 'stream', 'tool-events', 'reasoning', 'usage', 'permission'] };
+    binaries;
+    runSpawnSync;
+    runSpawn;
+    sessionRoots;
+    cachedBinary = null;
+    processes = new Set();
+    sessions = new Map();
+    constructor(options = {}) {
+        this.binaries = options.binaries ?? ['grok', 'grok-build'];
+        this.runSpawnSync = options.spawnSync ?? spawnSync;
+        this.runSpawn = options.spawn ?? spawn;
+        this.sessionRoots = options.sessionRoots ?? [join(process.env.GROK_HOME ?? join(homedir(), '.grok'), 'sessions')];
+    }
+    async detect() {
+        const result = await detectBinary({ binaries: this.binaries, spawnSync: this.runSpawnSync });
+        if (result.installed)
+            this.cachedBinary = result.command;
+        return result;
+    }
+    async listModels() {
+        const command = this.cachedBinary ?? (await this.detect()).command;
+        if (command === null)
+            return emptyCatalog();
+        const rpc = new JsonRpcProcess({ command, args: ['agent', '--no-leader', 'stdio'], spawn: this.runSpawn });
+        try {
+            await rpc.request('initialize', { protocolVersion: 1, clientInfo: { name: 'codingns4dsh', version: '0.1.0' }, capabilities: {} });
+            rpc.notify('initialized', {});
+            const session = await rpc.request('session/new', { cwd: process.cwd(), mcpServers: [] });
+            const parsed = parseGrokCatalog(session);
+            return parsed.groups.length > 0 ? parsed : GROK_CATALOG;
+        }
+        catch {
+            return GROK_CATALOG;
+        }
+        finally {
+            rpc.dispose();
+        }
+    }
+    async probeSession(input) {
+        return probeStoredSession(input, {
+            roots: this.sessionRoots,
+            matches: (path, entry, id) => entry.isDirectory() && basename(path) === id,
+            validate: async (path, id) => {
+                const directory = await resolveSessionDirectory(path);
+                return basename(directory) === id && await isRegularFile(join(directory, 'updates.jsonl'));
+            },
+        });
+    }
+    async *executeTurn(input) {
+        const command = this.cachedBinary ?? (await this.detect()).command;
+        if (command === null)
+            throw new Error('Grok Build 未安装');
+        const state = await this.getSession(input, command);
+        const rpc = state.rpc;
+        let providerSessionId = state.providerSessionId;
+        try {
+            if (providerSessionId === '') {
+                const session = await rpc.request('session/new', {
+                    cwd: input.cwd ?? process.cwd(),
+                    mcpServers: [],
+                    ...(!isProviderDefaultModel(input.modelId) ? { model: input.modelId } : {}),
+                }, { signal: input.signal });
+                providerSessionId = readSessionId(session) ?? input.sessionId;
+                state.providerSessionId = providerSessionId;
+                this.sessions.set(input.sessionId, state);
+                this.sessions.set(providerSessionId, state);
+            }
+            yield { type: 'session-binding', providerSessionId };
+            const stream = streamGrokPrompt(rpc, providerSessionId, input.prompt, input.signal, (notification) => {
+                const requestId = interactionRequestId(notification);
+                if (requestId !== null && notification.id !== undefined && notification.id !== null)
+                    state.requests.set(requestId, notification.id);
+            });
+            let finishReason;
+            while (true) {
+                const item = await stream.next();
+                if (item.done) {
+                    finishReason = item.value;
+                    break;
+                }
+                const chunk = acpMessageToChunk(item.value);
+                if (chunk !== null)
+                    yield chunk;
+            }
+            if (finishReason === 'cancel') {
+                try {
+                    await rpc.request('session/cancel', { sessionId: providerSessionId }, { killOnAbort: false });
+                }
+                catch { /* 不同 ACP 版本的取消方法可能不同，请求级取消已经先行发出。 */ }
+            }
+            yield { type: 'finish', reason: finishReason };
+        }
+        finally { /* ACP 进程和会话跨轮复用，统一由 dispose() 回收。 */ }
+    }
+    respondPermission(sessionId, response) {
+        const state = this.sessions.get(sessionId);
+        if (state === undefined)
+            throw new Error('Grok 权限请求已结束');
+        const rpcId = state.requests.get(response.requestId);
+        if (rpcId === undefined)
+            throw new Error('Grok 权限请求不存在');
+        state.requests.delete(response.requestId);
+        const optionId = response.approved ? 'allow-once' : 'reject-once';
+        state.rpc.respond(rpcId, { outcome: { outcome: 'selected', optionId } });
+    }
+    dispose() { for (const process of this.processes)
+        process.dispose(); this.processes.clear(); this.sessions.clear(); this.cachedBinary = null; }
+    async getSession(input, command) {
+        const previous = this.sessions.get(input.sessionId);
+        if (previous !== undefined && previous.cwd === input.cwd)
+            return previous;
+        previous?.rpc.dispose();
+        const rpc = new JsonRpcProcess({ command, args: ['agent', '--no-leader', 'stdio'], cwd: input.cwd, spawn: this.runSpawn });
+        this.processes.add(rpc);
+        const state = { rpc, cwd: input.cwd, providerSessionId: '', requests: new Map() };
+        await rpc.request('initialize', {
+            protocolVersion: 1,
+            clientInfo: { name: 'codingns4dsh', version: '0.1.0' },
+            capabilities: {},
+        });
+        rpc.notify('initialized', {});
+        if (input.providerSessionId) {
+            try {
+                const loaded = await rpc.request('session/load', { sessionId: input.providerSessionId, cwd: input.cwd ?? process.cwd(), mcpServers: [] });
+                state.providerSessionId = readSessionId(loaded) ?? input.providerSessionId;
+            }
+            catch { /* 旧版 ACP 没有 load，下一轮在同一进程创建新会话 */ }
+        }
+        // ACP 权限是 Grok 发起的 server request，先挂起响应，待标准权限入口明确回复原始 id。
+        rpc.setServerRequestHandler((message) => {
+            const requestId = interactionRequestId(message);
+            if (requestId !== null && message.id !== undefined && message.id !== null)
+                state.requests.set(requestId, message.id);
+            return new Promise(() => undefined);
+        });
+        this.sessions.set(input.sessionId, state);
+        if (state.providerSessionId !== '')
+            this.sessions.set(state.providerSessionId, state);
+        return state;
+    }
+}
+const GROK_DRAIN_WAIT_MS = 250;
+/**
+ * Grok 可能先返回 prompt 响应，再补发最后一批 session/update。
+ * 响应或终态任一先到都会启动固定排空窗口，窗口内的文本和错误仍会被消费。
+ */
+async function* streamGrokPrompt(rpc, sessionId, prompt, signal, onNotification) {
+    const queue = [];
+    const requestController = new AbortController();
+    let wake;
+    let drainDeadline = null;
+    let terminalReason = null;
+    const notify = () => { wake?.(); wake = undefined; };
+    const beginDrain = () => {
+        if (drainDeadline === null)
+            drainDeadline = Date.now() + GROK_DRAIN_WAIT_MS;
+        notify();
+    };
+    const listener = (message) => {
+        queue.push(message);
+        onNotification(message);
+        const notificationReason = grokNotificationReason(message);
+        if (notificationReason === null) {
+            notify();
+            return;
+        }
+        terminalReason = mergeGrokReason(terminalReason, notificationReason);
+        // 部分 Grok 版本只发终态通知而不回复 prompt，主动取消可清理待处理请求。
+        requestController.abort();
+        beginDrain();
+    };
+    const removeListener = rpc.addNotificationListener(listener);
+    const onAbort = () => {
+        terminalReason = 'cancel';
+        queue.length = 0;
+        requestController.abort();
+        drainDeadline = Date.now();
+        notify();
+    };
+    if (signal?.aborted)
+        onAbort();
+    else
+        signal?.addEventListener('abort', onAbort, { once: true });
+    void rpc.request('session/prompt', {
+        sessionId,
+        prompt: [{ type: 'text', text: prompt }],
+    }, { signal: requestController.signal, killOnAbort: false }).then((response) => {
+        const responseReason = grokPromptReason(response);
+        if (responseReason !== null)
+            terminalReason = mergeGrokReason(terminalReason, responseReason);
+        beginDrain();
+    }, () => {
+        if (terminalReason === null)
+            terminalReason = signal?.aborted ? 'cancel' : 'error';
+        beginDrain();
+    });
+    try {
+        while (true) {
+            if (queue.length > 0) {
+                yield queue.shift();
+                continue;
+            }
+            if (drainDeadline === null) {
+                await new Promise((resolve) => { wake = resolve; });
+                continue;
+            }
+            const remaining = drainDeadline - Date.now();
+            if (remaining <= 0)
+                break;
+            await Promise.race([
+                new Promise((resolve) => { wake = resolve; }),
+                new Promise((resolve) => setTimeout(resolve, remaining)),
+            ]);
+            wake = undefined;
+        }
+        return terminalReason ?? 'stop';
+    }
+    finally {
+        signal?.removeEventListener('abort', onAbort);
+        removeListener();
+    }
+}
+function grokPromptReason(value) {
+    if (!isRecord(value) || typeof value.stopReason !== 'string')
+        return null;
+    const reason = value.stopReason.toLowerCase();
+    return reason === 'cancelled' || reason === 'error' || reason === 'failed' ? 'error' : 'stop';
+}
+function mergeGrokReason(current, next) {
+    if (current === 'error' || next === 'error')
+        return 'error';
+    if (current === 'cancel' || next === 'cancel')
+        return 'cancel';
+    return 'stop';
+}
+function grokNotificationReason(message) {
+    const params = isRecord(message.params) ? message.params : message;
+    const update = isRecord(params.update) ? params.update : params;
+    const type = typeof update.sessionUpdate === 'string'
+        ? update.sessionUpdate.toLowerCase()
+        : typeof update.type === 'string'
+            ? update.type.toLowerCase()
+            : '';
+    if (type.includes('error') || type.includes('failed'))
+        return 'error';
+    if (type.includes('turn_completed') || type.includes('turn_complete') || type === 'completed' || type === 'done')
+        return 'stop';
+    return null;
+}
+function acpMessageToChunk(message) {
+    const params = isRecord(message.params) ? message.params : message;
+    const update = isRecord(params.update) ? params.update : params;
+    const type = typeof update.sessionUpdate === 'string' ? update.sessionUpdate : typeof update.type === 'string' ? update.type : typeof message.method === 'string' ? message.method : '';
+    const text = textValue(update.delta ?? update.text ?? update.content ?? update.message ?? update.detail);
+    if (type.includes('permission')) {
+        const requestId = permissionRequestId(message) ?? (typeof update.requestId === 'string' ? update.requestId : typeof update.id === 'string' ? update.id : null);
+        if (requestId !== null)
+            return { type: 'permission-request', requestId, kind: typeof update.kind === 'string' ? update.kind : 'unknown', ...(text ? { detail: text } : {}) };
+    }
+    if (type.includes('agent_message') || type.includes('text') || type === 'message')
+        return text ? { type: 'text-delta', text } : null;
+    if (type.includes('thought') || type.includes('reason'))
+        return text ? { type: 'reasoning-delta', text } : null;
+    if (type.includes('tool') || type.includes('command')) {
+        const tool = isToolRecord(update.toolCall) ? update.toolCall : isToolRecord(update.tool_call) ? update.tool_call : update;
+        const name = firstToolText(tool.name, tool.toolName, tool.tool_name, tool.title, update.name, update.toolName, update.title);
+        const callId = firstToolText(tool.callId, tool.call_id, tool.toolCallId, tool.tool_call_id, tool.id, update.toolCallId, update.tool_call_id, update.id);
+        if (!name && !callId)
+            return null;
+        const input = serializeToolValue(tool.rawInput ?? tool.input ?? tool.arguments ?? tool.args ?? update.rawInput);
+        const output = serializeToolValue(tool.rawOutput ?? tool.output ?? tool.result ?? update.rawOutput);
+        const error = serializeToolValue(tool.error ?? update.error);
+        const agentId = firstToolText(tool.agentId, tool.agent_id, update.agentId, update.agent_id);
+        const detail = serializeToolValue(tool.detail ?? update.detail ?? update.content);
+        const fallback = error !== undefined || type.includes('error') || type.includes('fail')
+            ? 'failed'
+            : output !== undefined || type.includes('result') || type.includes('complete')
+                ? 'completed'
+                : 'running';
+        return {
+            type: 'tool-event',
+            toolName: name ?? 'tool',
+            status: normalizeToolStatus(tool.status ?? tool.state ?? update.status, fallback),
+            ...(callId ? { callId } : {}),
+            ...(input !== undefined ? { input } : {}),
+            ...(output !== undefined ? { output } : {}),
+            ...(output !== undefined ? { outputMode: type.toLowerCase().includes('delta') ? 'delta' : 'snapshot' } : {}),
+            ...(error !== undefined ? { error } : {}),
+            ...(agentId ? { agentId } : {}),
+            ...(detail !== undefined ? { detail } : {}),
+        };
+    }
+    return usageChunk(update);
+}
+function permissionRequestId(message) {
+    const params = isRecord(message.params) ? message.params : message;
+    const update = isRecord(params.update) ? params.update : params;
+    const type = typeof update.sessionUpdate === 'string' ? update.sessionUpdate : typeof update.type === 'string' ? update.type : typeof message.method === 'string' ? message.method : '';
+    if (!type.toLowerCase().includes('permission'))
+        return null;
+    const id = message.id ?? update.requestId ?? update.id;
+    return typeof id === 'string' || typeof id === 'number' ? String(id) : null;
+}
+function interactionRequestId(message) {
+    return permissionRequestId(message);
+}
+function readSessionId(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.sessionId === 'string')
+        return value.sessionId;
+    if (isRecord(value.session) && typeof value.session.id === 'string')
+        return value.session.id;
+    return typeof value.id === 'string' ? value.id : null;
+}
+function parseGrokCatalog(value) {
+    if (!isRecord(value))
+        return emptyCatalog();
+    const models = isRecord(value.models) && Array.isArray(value.models.availableModels)
+        ? value.models.availableModels
+        : [];
+    const configOptions = Array.isArray(value.configOptions) ? value.configOptions : [];
+    const efforts = new Map();
+    for (const option of configOptions) {
+        if (!isRecord(option))
+            continue;
+        const id = typeof option.id === 'string' ? option.id : '';
+        if (!/model|reasoning/iu.test(id))
+            continue;
+        const values = Array.isArray(option.options) ? option.options : Array.isArray(option.values) ? option.values : [];
+        if (!/reasoning/iu.test(id))
+            continue;
+        for (const value of values) {
+            const effort = typeof value === 'string' ? value : isRecord(value) && typeof value.id === 'string' ? value.id : null;
+            if (!effort)
+                continue;
+            const modelId = typeof option.modelId === 'string' ? option.modelId : '*';
+            const current = efforts.get(modelId) ?? [];
+            if (!current.includes(effort))
+                current.push(effort);
+            efforts.set(modelId, current);
+        }
+    }
+    const items = models.flatMap((entry) => {
+        if (typeof entry === 'string')
+            return [{ id: entry, name: entry, efforts: efforts.get(entry) ?? [] }];
+        if (!isRecord(entry))
+            return [];
+        const id = typeof entry.modelId === 'string' ? entry.modelId : typeof entry.id === 'string' ? entry.id : null;
+        if (!id)
+            return [];
+        const meta = isRecord(entry._meta) ? entry._meta : {};
+        const declared = Array.isArray(meta.reasoningEfforts) ? meta.reasoningEfforts.flatMap((item) => typeof item === 'string' ? [item] : isRecord(item) && typeof item.id === 'string' ? [item.id] : []) : [];
+        return [{ id, name: typeof entry.name === 'string' ? entry.name : id, efforts: declared.length > 0 ? declared : efforts.get(id) ?? efforts.get('*') ?? [] }];
+    });
+    if (items.length === 0)
+        return emptyCatalog();
+    const deduped = [...new Map(items.map((item) => [item.id, item])).values()];
+    return { groups: [{ id: 'grok', name: 'Grok', models: deduped }], currentModel: null, currentEffort: null };
+}
+//# sourceMappingURL=grok-driver.js.map

package/data/build/dist/host/cli-adapters/http-sse-client.d.ts

@@ -0,0 +1,22 @@
+export interface HttpSseClientOptions {
+    readonly fetch?: typeof fetch;
+}
+export interface HttpJsonResponse<T = unknown> {
+    readonly status: number;
+    readonly headers: Headers;
+    readonly data: T | null;
+    readonly text: string;
+}
+export interface SseEvent {
+    readonly event: string | null;
+    readonly data: string;
+    readonly id?: string;
+}
+/** 只负责 HTTP JSON 与 SSE framing，不理解任何 Agent 私有事件。 */
+export declare class HttpSseClient {
+    private readonly fetchImpl;
+    constructor(options?: HttpSseClientOptions);
+    json<T = unknown>(url: string, init?: RequestInit): Promise<HttpJsonResponse<T>>;
+    sse(url: string, init?: RequestInit): AsyncIterable<SseEvent>;
+}
+//# sourceMappingURL=http-sse-client.d.ts.map

package/data/build/dist/host/cli-adapters/http-sse-client.js

@@ -0,0 +1,99 @@
+/** 只负责 HTTP JSON 与 SSE framing，不理解任何 Agent 私有事件。 */
+export class HttpSseClient {
+    fetchImpl;
+    constructor(options = {}) {
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    async json(url, init = {}) {
+        const headers = new Headers(init.headers);
+        headers.set('accept', 'application/json');
+        const response = await this.fetchImpl(url, {
+            ...init,
+            headers,
+        });
+        const text = await response.text();
+        let data = null;
+        if (text.trim()) {
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                data = null;
+            }
+        }
+        return { status: response.status, headers: response.headers, data, text };
+    }
+    async *sse(url, init = {}) {
+        const headers = new Headers(init.headers);
+        headers.set('accept', 'text/event-stream');
+        const response = await this.fetchImpl(url, {
+            ...init,
+            headers,
+        });
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status} ${response.statusText}`);
+        if (!response.body)
+            return;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let eventName = null;
+        let eventId;
+        let dataLines = [];
+        const flush = () => {
+            if (dataLines.length === 0 && eventName === null && eventId === undefined)
+                return null;
+            const event = { event: eventName, data: dataLines.join('\n'), ...(eventId === undefined ? {} : { id: eventId }) };
+            eventName = null;
+            eventId = undefined;
+            dataLines = [];
+            return event;
+        };
+        try {
+            while (true) {
+                const result = await reader.read();
+                if (result.done)
+                    break;
+                buffer += decoder.decode(result.value, { stream: true }).replace(/\r\n/gu, '\n').replace(/\r/gu, '\n');
+                let newline = buffer.indexOf('\n');
+                while (newline >= 0) {
+                    const line = buffer.slice(0, newline);
+                    buffer = buffer.slice(newline + 1);
+                    if (line === '') {
+                        const event = flush();
+                        if (event !== null)
+                            yield event;
+                    }
+                    else if (line.startsWith(':')) {
+                        // SSE 注释通常只是心跳。
+                    }
+                    else {
+                        const separator = line.indexOf(':');
+                        const field = separator < 0 ? line : line.slice(0, separator);
+                        const value = separator < 0 ? '' : line.slice(separator + 1).replace(/^ /u, '');
+                        if (field === 'event')
+                            eventName = value;
+                        else if (field === 'id')
+                            eventId = value;
+                        else if (field === 'data')
+                            dataLines.push(value);
+                    }
+                    newline = buffer.indexOf('\n');
+                }
+            }
+            buffer += decoder.decode();
+            if (buffer.trim())
+                dataLines.push(buffer);
+            const event = flush();
+            if (event !== null)
+                yield event;
+        }
+        finally {
+            try {
+                await reader.cancel();
+            }
+            catch { /* 连接可能已经关闭 */ }
+        }
+    }
+}
+//# sourceMappingURL=http-sse-client.js.map

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

@@ -0,0 +1,11 @@
+import type { CodingNsAgentQuestion, CodingNsAgentQuestionResponse } from '../../shared/contracts/cli-adapter.js';
+/** 从不同 Provider 的问题结构中提取公共问题列表。 */
+export declare function readAgentQuestions(value: unknown): readonly CodingNsAgentQuestion[];
+/** 把公共回答转换成 Provider 常用的 id -> answers 结构。 */
+export declare function questionAnswersRecord(response: CodingNsAgentQuestionResponse): Record<string, {
+    answers: string[];
+}>;
+/** 把公共回答转换成 ACP/OpenCode 常用的二维字符串数组。 */
+export declare function questionAnswersList(response: CodingNsAgentQuestionResponse): string[][];
+export declare function isQuestionEvent(type: string): boolean;
+//# sourceMappingURL=interaction-events.d.ts.map

package/data/build/dist/host/cli-adapters/interaction-events.js

@@ -0,0 +1,80 @@
+/** 从不同 Provider 的问题结构中提取公共问题列表。 */
+export function readAgentQuestions(value) {
+    const record = isRecord(value) ? value : null;
+    const source = Array.isArray(value)
+        ? value
+        : Array.isArray(record?.questions)
+            ? record.questions
+            : Array.isArray(record?.items)
+                ? record.items
+                : [];
+    return source.flatMap((item, index) => {
+        const question = readQuestion(item, index);
+        return question === null ? [] : [question];
+    });
+}
+/** 把公共回答转换成 Provider 常用的 id -> answers 结构。 */
+export function questionAnswersRecord(response) {
+    return Object.fromEntries(response.answers.map((answer) => [
+        answer.id,
+        { answers: [...answer.selected, ...(answer.custom?.trim() ? [answer.custom.trim()] : [])] },
+    ]));
+}
+/** 把公共回答转换成 ACP/OpenCode 常用的二维字符串数组。 */
+export function questionAnswersList(response) {
+    return response.answers.map((answer) => [
+        ...answer.selected,
+        ...(answer.custom?.trim() ? [answer.custom.trim()] : []),
+    ]);
+}
+export function isQuestionEvent(type) {
+    const normalized = type
+        .replace(/([a-z0-9])([A-Z])/gu, '$1_$2')
+        .toLowerCase()
+        .replace(/[./-]+/gu, '_');
+    return normalized.includes('question') || normalized.includes('request_user_input') || normalized.includes('request_input') || normalized.includes('ask_user');
+}
+function readQuestion(value, index) {
+    const record = isRecord(value) ? value : null;
+    const text = typeof value === 'string'
+        ? value
+        : firstString(record, ['question', 'prompt', 'message', 'text']);
+    if (text === null || text.trim() === '')
+        return null;
+    const optionsSource = Array.isArray(record?.options) ? record.options : Array.isArray(record?.choices) ? record.choices : [];
+    const options = optionsSource.flatMap((option) => {
+        if (typeof option === 'string' && option.trim())
+            return [{ label: option.trim() }];
+        if (!isRecord(option))
+            return [];
+        const label = firstString(option, ['label', 'value', 'name', 'title']);
+        if (label === null || label.trim() === '')
+            return [];
+        const description = firstString(option, ['description', 'detail']);
+        return [{ label: label.trim(), ...(description?.trim() ? { description: description.trim() } : {}) }];
+    });
+    const id = firstString(record, ['id', 'questionId', 'question_id'])?.trim() || `question-${index + 1}`;
+    const detail = firstString(record, ['detail', 'description']);
+    const header = firstString(record, ['header', 'title']);
+    const multiSelect = record?.multiSelect === true || record?.multi_select === true || record?.multiple === true;
+    return {
+        id,
+        question: text.trim(),
+        ...(detail?.trim() ? { detail: detail.trim() } : {}),
+        ...(header?.trim() ? { header: header.trim() } : {}),
+        ...(options.length > 0 ? { options } : {}),
+        ...(multiSelect ? { multiSelect: true } : {}),
+    };
+}
+function firstString(record, keys) {
+    if (record === null)
+        return null;
+    for (const key of keys)
+        if (typeof record[key] === 'string')
+            return record[key];
+    return null;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=interaction-events.js.map

package/data/build/dist/host/cli-adapters/json-rpc-process.d.ts

@@ -0,0 +1,65 @@
+import { spawn } from 'node:child_process';
+/** JSON-RPC 消息的最小形状。不同 Agent 的扩展字段保持在 unknown 中。 */
+export interface JsonRpcMessage {
+    readonly jsonrpc?: string;
+    readonly id?: number | string | null;
+    readonly method?: string;
+    readonly params?: unknown;
+    readonly result?: unknown;
+    readonly error?: {
+        readonly code?: number;
+        readonly message?: string;
+        readonly data?: unknown;
+    };
+    readonly [key: string]: unknown;
+}
+export interface JsonRpcProcessOptions {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly cwd?: string | undefined;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly spawn?: typeof spawn;
+}
+export interface JsonRpcRequestOptions {
+    readonly signal?: AbortSignal | undefined;
+    readonly onNotification?: (message: JsonRpcMessage) => void;
+    /** 取消本次请求时是否同时终止整个 Agent 进程；长期会话应关闭此项。 */
+    readonly killOnAbort?: boolean;
+}
+/**
+ * 统一管理 stdio JSON-RPC 子进程：请求编号、逐行解码、取消和退出清理都在这里完成。
+ * 凭据不会被记录，也不会进入错误文本。
+ */
+export declare class JsonRpcProcess {
+    private readonly options;
+    private readonly runSpawn;
+    private child;
+    private nextId;
+    private readonly pending;
+    private closed;
+    private lineLoop;
+    private exitPromise;
+    private readonly notificationHandlers;
+    private serverRequestHandler;
+    constructor(options: JsonRpcProcessOptions);
+    request(method: string, params?: unknown, options?: JsonRpcRequestOptions): Promise<unknown>;
+    /** 发送无需响应的 JSON-RPC 通知，例如 initialized 或 cancel。 */
+    notify(method: string, params?: unknown): void;
+    /** 注册 Agent 发起的 JSON-RPC 服务端请求处理器，例如 Codex 权限审批。 */
+    setServerRequestHandler(handler: ((message: JsonRpcMessage) => unknown | Promise<unknown>) | undefined): void;
+    /** 为一段流式请求注册独立监听器，响应先到时也不会提前移除。 */
+    addNotificationListener(listener: (message: JsonRpcMessage) => void): () => void;
+    /** 回复由 Agent 发起的 JSON-RPC server request，保留原始 id。 */
+    respond(id: number | string, result: unknown): void;
+    /** 回复 JSON-RPC server request 的错误结果。错误文本不回传 Provider 原文。 */
+    respondError(id: number | string, code?: number, message?: string): void;
+    cancel(id: number | string): void;
+    dispose(): void;
+    /** 销毁并等待子进程退出，避免下一轮恢复与上一轮残留进程交叉。 */
+    disposeAndWait(timeoutMs?: number): Promise<void>;
+    private ensureStarted;
+    private consumeLines;
+    private write;
+    private fail;
+}
+//# sourceMappingURL=json-rpc-process.d.ts.map