@jingyi0605/codingns4dsh 0.1.0

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

@@ -0,0 +1,256 @@
+import { spawn } from 'node:child_process';
+import readline from 'node:readline';
+import { terminateChildProcess, WINDOWS } from './process-utils.js';
+/**
+ * 统一管理 stdio JSON-RPC 子进程：请求编号、逐行解码、取消和退出清理都在这里完成。
+ * 凭据不会被记录，也不会进入错误文本。
+ */
+export class JsonRpcProcess {
+    options;
+    runSpawn;
+    child = null;
+    nextId = 1;
+    pending = new Map();
+    closed = false;
+    lineLoop = null;
+    exitPromise = Promise.resolve();
+    notificationHandlers = new Set();
+    serverRequestHandler;
+    constructor(options) {
+        this.options = options;
+        this.runSpawn = options.spawn ?? spawn;
+    }
+    async request(method, params = {}, options = {}) {
+        this.ensureStarted();
+        const id = this.nextId++;
+        const promise = new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
+        if (options.onNotification !== undefined)
+            this.notificationHandlers.add(options.onNotification);
+        const onAbort = () => {
+            this.cancel(id);
+            this.pending.get(id)?.reject(new Error('请求已取消'));
+            if (options.killOnAbort !== false) {
+                const child = this.child;
+                if (child !== null)
+                    terminateChild(child, 'SIGTERM');
+            }
+        };
+        if (options.signal?.aborted)
+            onAbort();
+        else
+            options.signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            // Pi 的模型探测命令是自定义 RPC：请求体使用 `type`，不能包成 JSON-RPC
+            // method，否则 Pi 会回报 “Unknown command: undefined”。其余适配器仍走标准 JSON-RPC。
+            if (method === 'get_available_models') {
+                this.write({ id, type: method, ...(isRecord(params) ? params : {}) });
+            }
+            else {
+                this.write({ jsonrpc: '2.0', id, method, params });
+            }
+            const result = await promise;
+            if (options.signal?.aborted)
+                throw new Error('请求已取消');
+            return result;
+        }
+        finally {
+            options.signal?.removeEventListener('abort', onAbort);
+            if (options.onNotification !== undefined)
+                this.notificationHandlers.delete(options.onNotification);
+            this.pending.delete(id);
+        }
+    }
+    /** 发送无需响应的 JSON-RPC 通知，例如 initialized 或 cancel。 */
+    notify(method, params = {}) {
+        this.ensureStarted();
+        this.write({ jsonrpc: '2.0', method, params });
+    }
+    /** 注册 Agent 发起的 JSON-RPC 服务端请求处理器，例如 Codex 权限审批。 */
+    setServerRequestHandler(handler) {
+        this.serverRequestHandler = handler;
+    }
+    /** 为一段流式请求注册独立监听器，响应先到时也不会提前移除。 */
+    addNotificationListener(listener) {
+        this.notificationHandlers.add(listener);
+        return () => this.notificationHandlers.delete(listener);
+    }
+    /** 回复由 Agent 发起的 JSON-RPC server request，保留原始 id。 */
+    respond(id, result) {
+        if (this.closed)
+            throw new Error('Agent 进程已关闭');
+        this.ensureStarted();
+        this.write({ jsonrpc: '2.0', id, result });
+    }
+    /** 回复 JSON-RPC server request 的错误结果。错误文本不回传 Provider 原文。 */
+    respondError(id, code = -32000, message = '请求被拒绝') {
+        if (this.closed)
+            throw new Error('Agent 进程已关闭');
+        this.ensureStarted();
+        this.write({ jsonrpc: '2.0', id, error: { code, message } });
+    }
+    cancel(id) {
+        if (this.closed || this.child === null)
+            return;
+        try {
+            this.write({ jsonrpc: '2.0', method: '$/cancelRequest', params: { id } });
+        }
+        catch { /* 尽力取消 */ }
+    }
+    dispose() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const pending of this.pending.values())
+            pending.reject(new Error('Agent 进程已退出'));
+        this.pending.clear();
+        const child = this.child;
+        this.child = null;
+        if (child === null)
+            return;
+        terminateChild(child, 'SIGTERM');
+        const forceKill = setTimeout(() => terminateChild(child, 'SIGKILL'), 500);
+        forceKill.unref?.();
+    }
+    /** 销毁并等待子进程退出，避免下一轮恢复与上一轮残留进程交叉。 */
+    async disposeAndWait(timeoutMs = 2_000) {
+        this.dispose();
+        let timer;
+        try {
+            await Promise.race([this.exitPromise, new Promise((resolve) => {
+                    timer = setTimeout(resolve, timeoutMs);
+                    timer.unref?.();
+                })]);
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        }
+    }
+    ensureStarted() {
+        if (this.closed)
+            throw new Error('Agent 进程已关闭');
+        if (this.child !== null)
+            return;
+        const child = this.runSpawn(this.options.command, this.options.args ?? [], {
+            cwd: this.options.cwd,
+            env: { ...process.env, ...(this.options.env ?? {}) },
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+            shell: WINDOWS,
+            // CLI 可能是 Node 包装脚本，直接 kill 包装进程不会连带真正的 Node 子进程。
+            // POSIX 下单独进程组后才能可靠地一次清理整棵进程树。
+            detached: process.platform !== 'win32',
+        });
+        this.child = child;
+        this.exitPromise = childExitPromise(child);
+        // stderr 必须持续消费，但绝不能把命令参数、环境变量或文件片段回传给 DSH。
+        child.stderr.on('data', () => undefined);
+        this.lineLoop = this.consumeLines(child).catch((error) => this.fail(error));
+    }
+    async consumeLines(child) {
+        const lines = readline.createInterface({ input: child.stdout });
+        try {
+            for await (const line of lines) {
+                if (!line.trim())
+                    continue;
+                let value;
+                try {
+                    value = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (!isRecord(value))
+                    continue;
+                if (typeof value.method === 'string' && value.id !== undefined && value.id !== null) {
+                    const handler = this.serverRequestHandler;
+                    if (handler === undefined) {
+                        this.write({ jsonrpc: '2.0', id: value.id, error: { code: -32601, message: '请求不受支持' } });
+                    }
+                    else {
+                        // 先通知流消费者，再等待上层审批结果；通知内容只包含标准协议字段。
+                        for (const listener of this.notificationHandlers)
+                            listener(value);
+                        const requestId = value.id;
+                        void Promise.resolve(handler(value)).then((result) => this.write({ jsonrpc: '2.0', id: requestId, result }), () => this.write({ jsonrpc: '2.0', id: requestId, error: { code: -32000, message: '请求被拒绝' } }));
+                    }
+                    continue;
+                }
+                // Pi 的 RPC 线协议沿用 request id，但响应字段是 success/data，而不是
+                // JSON-RPC 的 result/error；两种形状都必须收敛到同一个 pending 请求。
+                if (value.id !== undefined && value.id !== null && value.type === 'response' && typeof value.success === 'boolean') {
+                    const pending = this.pending.get(value.id);
+                    if (pending === undefined)
+                        continue;
+                    if (value.success === false)
+                        pending.reject(new Error('JSON-RPC 请求失败'));
+                    else
+                        pending.resolve(value.data);
+                    continue;
+                }
+                if (value.id !== undefined && value.id !== null && (value.result !== undefined || value.error !== undefined)) {
+                    const pending = this.pending.get(value.id);
+                    if (pending === undefined)
+                        continue;
+                    // Provider 错误可能带命令行、路径或凭据片段，只向上层暴露稳定错误，不回传原文。
+                    if (isRecord(value.error))
+                        pending.reject(new Error('JSON-RPC 请求失败'));
+                    else
+                        pending.resolve(value.result);
+                    continue;
+                }
+                for (const listener of this.notificationHandlers)
+                    listener(value);
+            }
+        }
+        finally {
+            lines.close();
+            if (!this.closed && this.child === child)
+                this.fail(new Error('Agent 进程已退出'));
+        }
+    }
+    write(message) {
+        const stdin = this.child?.stdin;
+        if (stdin === undefined)
+            throw new Error('Agent 进程不支持 stdin');
+        stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    fail(error) {
+        const failure = error instanceof Error ? error : new Error('Agent 进程读取失败');
+        for (const pending of this.pending.values())
+            pending.reject(failure);
+        this.pending.clear();
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function childExitPromise(child) {
+    return new Promise((resolve) => {
+        const eventChild = child;
+        if (typeof eventChild.once !== 'function') {
+            resolve();
+            return;
+        }
+        let settled = false;
+        const settle = () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve();
+        };
+        eventChild.once('close', settle);
+        eventChild.once('error', settle);
+    });
+}
+function terminateChild(child, signal) {
+    const pid = child.pid;
+    if (process.platform !== 'win32' && typeof pid === 'number' && pid > 0) {
+        try {
+            process.kill(-pid, signal);
+        }
+        catch { /* 进程组可能已经退出 */ }
+    }
+    terminateChildProcess(child, signal);
+}
+//# sourceMappingURL=json-rpc-process.js.map

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

@@ -0,0 +1,21 @@
+import type { CodingNsAgentEvent, CodingNsAgentQuestionResponse, CodingNsAgentPermissionResponse, CodingNsCliTurnInput } from '../../shared/contracts/cli-adapter.js';
+import type { CodingNsCliSessionProbeInput, CodingNsCliSessionProbeResult } from './driver.js';
+import { StandardStreamDriver, type StandardStreamDriverOptions } from './standard-stream-driver.js';
+/** Kimi 的 wire 协议优先，旧版 CLI 不支持时自动回退 stream-json。 */
+export declare class KimiCliDriver extends StandardStreamDriver {
+    private legacySyntax;
+    private readonly sessionRoots;
+    private readonly interactions;
+    constructor(options?: StandardStreamDriverOptions);
+    listModels(): Promise<import("../../shared/contracts/cli-adapter.js").CodingNsCliModelCatalog>;
+    probeSession(input: CodingNsCliSessionProbeInput): Promise<CodingNsCliSessionProbeResult>;
+    protected buildArgs(input: CodingNsCliTurnInput): readonly string[];
+    respondPermission(sessionId: string, response: CodingNsAgentPermissionResponse): void;
+    respondQuestion(sessionId: string, response: CodingNsAgentQuestionResponse): void;
+    dispose(): void;
+    executeTurn(input: CodingNsCliTurnInput): AsyncIterable<CodingNsAgentEvent>;
+    private executeWireTurn;
+    private detectSyntax;
+}
+export { KimiCliDriver as KimiDriver };
+//# sourceMappingURL=kimi-driver.d.ts.map

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

@@ -0,0 +1,382 @@
+import readline from 'node:readline';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { StandardStreamDriver, emptyCatalog } from './standard-stream-driver.js';
+import { KIMI_CATALOG, enrichEfforts, isProviderDefaultModel } from './model-catalog.js';
+import { probeStoredSession, readFirstJsonRecord, resolveSessionDirectory } from './session-probe.js';
+import { firstToolText, isToolRecord, normalizeToolStatus, serializeToolValue } from './tool-observation.js';
+import { isQuestionEvent, readAgentQuestions } from './interaction-events.js';
+import { usageChunk } from './rpc-driver-utils.js';
+import { terminateChildProcess } from './process-utils.js';
+/** Kimi 的 wire 协议优先，旧版 CLI 不支持时自动回退 stream-json。 */
+export class KimiCliDriver extends StandardStreamDriver {
+    legacySyntax = false;
+    sessionRoots;
+    interactions = new Map();
+    constructor(options = {}) {
+        super({ id: 'kimi', name: 'Kimi CLI', protocol: 'stream-json', capabilities: ['models', 'stream', 'resume', 'interrupt', 'tool-events', 'reasoning', 'usage', 'permission', 'questions', 'steer'] }, { binaries: ['kimi', 'kimi-cli'] }, options);
+        this.sessionRoots = options.sessionRoots ?? [join(process.env.KIMI_HOME ?? join(homedir(), '.kimi'), 'sessions')];
+    }
+    async listModels() {
+        if (!(await this.detect()).installed)
+            return emptyCatalog();
+        const catalog = await super.listModels();
+        return catalog.groups.length > 0 ? enrichEfforts(catalog, KIMI_CATALOG) : KIMI_CATALOG;
+    }
+    async probeSession(input) {
+        return probeStoredSession(input, {
+            roots: this.sessionRoots,
+            matches: (path, entry, id) => entry.isDirectory() && basename(path) === id,
+            validate: async (path) => {
+                const directory = await resolveSessionDirectory(path);
+                return await readFirstJsonRecord(join(directory, 'context.jsonl')) !== null;
+            },
+        });
+    }
+    buildArgs(input) {
+        const args = ['--print', '--output-format', 'stream-json', '--input-format', 'stream-json'];
+        if (input.providerSessionId)
+            args.push(this.legacySyntax ? '--resume' : '--session', input.providerSessionId);
+        if (this.legacySyntax) {
+            if (input.cwd)
+                args.push('--cwd', input.cwd);
+        }
+        else if (input.cwd)
+            args.push('--work-dir', input.cwd);
+        if (input.modelId && !isProviderDefaultModel(input.modelId))
+            args.push('--model', input.modelId);
+        return args;
+    }
+    respondPermission(sessionId, response) {
+        const state = this.interactions.get(sessionId);
+        const pending = state?.pending.get(response.requestId);
+        if (state === undefined || pending?.kind !== 'permission')
+            throw new Error('Kimi 权限请求已结束');
+        state.pending.delete(response.requestId);
+        state.write(`${JSON.stringify({
+            jsonrpc: '2.0',
+            id: pending.rpcId,
+            result: {
+                request_id: response.requestId,
+                response: response.approved ? 'approve' : 'reject',
+                ...(response.reason ? { feedback: response.reason } : {}),
+            },
+        })}\n`);
+    }
+    respondQuestion(sessionId, response) {
+        const state = this.interactions.get(sessionId);
+        const pending = state?.pending.get(response.requestId);
+        if (state === undefined || pending?.kind !== 'question')
+            throw new Error('Kimi 问题请求已结束');
+        state.pending.delete(response.requestId);
+        const answers = Object.fromEntries(response.answers.map((answer) => [
+            pending.questions?.get(answer.id) ?? answer.id,
+            [...answer.selected, ...(answer.custom?.trim() ? [answer.custom.trim()] : [])].join(', '),
+        ]));
+        state.write(`${JSON.stringify({
+            jsonrpc: '2.0',
+            id: pending.rpcId,
+            result: { request_id: response.requestId, answers },
+        })}\n`);
+    }
+    dispose() {
+        this.interactions.clear();
+        super.dispose();
+    }
+    async *executeTurn(input) {
+        try {
+            yield* this.executeWireTurn(input);
+            return;
+        }
+        catch {
+            if (input.signal?.aborted) {
+                yield { type: 'finish', reason: 'cancel' };
+                return;
+            }
+            for await (const chunk of super.executeTurn(input))
+                yield chunk;
+        }
+    }
+    async *executeWireTurn(input) {
+        const detection = await this.detect();
+        const command = detection.command;
+        if (command === null)
+            throw new Error('Kimi CLI 未安装');
+        this.detectSyntax(command);
+        const args = this.legacySyntax ? ['wire', '--output-format', 'stream-json'] : ['--wire'];
+        if (input.providerSessionId)
+            args.push(this.legacySyntax ? '--resume' : '--session', input.providerSessionId);
+        else if (this.legacySyntax)
+            args.push('--new-session');
+        if (input.cwd)
+            args.push(this.legacySyntax ? '--cwd' : '--work-dir', input.cwd);
+        if (input.modelId && !isProviderDefaultModel(input.modelId))
+            args.push('--model', input.modelId);
+        const child = this.runSpawn(command, args, {
+            cwd: input.cwd ?? process.cwd(), env: { ...process.env }, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true, shell: process.platform === 'win32',
+        });
+        const stdin = child.stdin;
+        const interaction = {
+            write: (data) => stdin.write(data),
+            pending: new Map(),
+        };
+        this.interactions.set(input.sessionId, interaction);
+        let finished = false;
+        let sawProtocol = false;
+        const onAbort = () => { terminateChildProcess(child); };
+        input.signal?.addEventListener('abort', onAbort, { once: true });
+        if (input.signal?.aborted)
+            onAbort();
+        child.stderr.on('data', () => undefined);
+        try {
+            const initializeId = `initialize:${input.sessionId}`;
+            const promptId = `prompt:${input.sessionId}`;
+            stdin.write(`${JSON.stringify({
+                jsonrpc: '2.0',
+                id: initializeId,
+                method: 'initialize',
+                params: {
+                    protocol_version: '1.10',
+                    client: { name: 'codingns4dsh', version: '0.1.0' },
+                    capabilities: { supports_question: true },
+                },
+            })}\n`);
+            let promptSent = false;
+            const sendPrompt = () => {
+                if (promptSent)
+                    return;
+                promptSent = true;
+                stdin.write(`${JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: promptId,
+                    method: 'prompt',
+                    params: { user_input: input.prompt },
+                })}\n`);
+            };
+            const lines = readline.createInterface({ input: child.stdout });
+            try {
+                for await (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    let value;
+                    try {
+                        value = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!isRecord(value))
+                        continue;
+                    if (value.id === initializeId && (value.result !== undefined || value.error !== undefined)) {
+                        // initialize 是可选握手；旧版返回 method not found 时仍可直接 prompt。
+                        sendPrompt();
+                        continue;
+                    }
+                    if (!promptSent)
+                        sendPrompt();
+                    const request = kimiInteractionRequest(value);
+                    if (request !== null) {
+                        interaction.pending.set(request.event.requestId, request.pending);
+                        sawProtocol = true;
+                        yield request.event;
+                        continue;
+                    }
+                    if (value.id === promptId && value.result !== undefined) {
+                        const result = isRecord(value.result) ? value.result : null;
+                        yield { type: 'finish', reason: input.signal?.aborted || result?.status === 'cancelled' ? 'cancel' : 'stop' };
+                        finished = true;
+                        break;
+                    }
+                    if (value.id === promptId && value.error !== undefined)
+                        throw new Error('Kimi wire 请求失败');
+                    const result = mapKimiWireEvent(value, input.signal?.aborted ?? false);
+                    if (result.protocol)
+                        sawProtocol = true;
+                    if (result.error)
+                        throw new Error('Kimi wire 请求失败');
+                    for (const chunk of result.chunks) {
+                        if (chunk.type === 'finish')
+                            finished = true;
+                        yield chunk;
+                    }
+                    if (finished)
+                        break;
+                }
+            }
+            finally {
+                lines.close();
+            }
+            if (input.signal?.aborted) {
+                if (!finished)
+                    yield { type: 'finish', reason: 'cancel' };
+                return;
+            }
+            if (!finished)
+                throw new Error(sawProtocol ? 'Kimi wire 未返回完成事件' : 'Kimi wire 不可用');
+        }
+        finally {
+            if (this.interactions.get(input.sessionId) === interaction)
+                this.interactions.delete(input.sessionId);
+            input.signal?.removeEventListener('abort', onAbort);
+            terminateChildProcess(child);
+        }
+    }
+    detectSyntax(command) {
+        try {
+            const result = this.runSpawnSync(command, ['--help'], { encoding: 'utf8', timeout: 5_000, windowsHide: true, shell: process.platform === 'win32' });
+            const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`.toLowerCase();
+            this.legacySyntax = /(?:^|\s)wire(?:\s|$)/u.test(output) && !output.includes('--wire');
+        }
+        catch {
+            this.legacySyntax = false;
+        }
+    }
+}
+function mapKimiWireEvent(value, cancelled) {
+    const params = isRecord(value.params) ? value.params : null;
+    const event = isRecord(params?.payload)
+        ? params.payload
+        : isRecord(value.event)
+            ? value.event
+            : isRecord(value.payload)
+                ? value.payload
+                : value;
+    const envelopeType = params?.type ?? value.type ?? event.type ?? value.event ?? '';
+    const type = `${envelopeType}`.toLowerCase();
+    const isToolEvent = type.includes('tool') || type.includes('command') || type.includes('function');
+    const chunks = [];
+    const sessionId = firstString(value, event, ['session_id', 'sessionId', 'id']);
+    if (sessionId && (type.includes('session') || type.includes('ready')))
+        chunks.push({ type: 'session-binding', providerSessionId: sessionId });
+    if (isQuestionEvent(type)) {
+        const requestId = firstString(event, value, ['request_id', 'requestId', 'question_id', 'id']);
+        const questions = readAgentQuestions(event.questions ?? value.questions ?? event);
+        if (requestId && questions.length > 0)
+            chunks.push({ type: 'question-request', requestId, questions });
+    }
+    const permissionId = firstString(event, value, ['request_id', 'requestId', 'permission_id']);
+    if (permissionId && type.includes('permission'))
+        chunks.push({ type: 'permission-request', requestId: permissionId, kind: firstString(event, value, ['kind', 'type']) ?? 'unknown' });
+    const contentType = typeof event.type === 'string' ? event.type.toLowerCase() : '';
+    const text = isQuestionEvent(type) || type.includes('permission')
+        ? ''
+        : type === 'contentpart' && contentType === 'think'
+            ? firstString(event, event, ['think'])
+            : textFrom(event);
+    if (text) {
+        if (type.includes('think') || type.includes('reason') || contentType === 'think')
+            chunks.push({ type: 'reasoning-delta', text });
+        else if (!type.includes('result') && !type.includes('complete') && !type.includes('done'))
+            chunks.push({ type: 'text-delta', text });
+    }
+    const nestedTool = isToolRecord(event.tool_call)
+        ? event.tool_call
+        : isToolRecord(event.tool_result)
+            ? event.tool_result
+            : isToolRecord(event.function)
+                ? event.function
+                : event;
+    const toolName = firstToolText(nestedTool.tool_name, nestedTool.toolName, nestedTool.name, event.tool_name, event.toolName, event.name);
+    if ((toolName || firstToolText(nestedTool.call_id, nestedTool.callId, event.tool_call_id, event.tool_use_id)) && isToolEvent) {
+        const callId = firstToolText(nestedTool.call_id, nestedTool.callId, nestedTool.id, event.tool_call_id, event.tool_use_id, event.toolUseId, event.id);
+        const input = serializeToolValue(nestedTool.input ?? nestedTool.arguments ?? nestedTool.args ?? nestedTool.parameters ?? event.input ?? event.arguments);
+        const returnValue = isRecord(event.return_value) ? event.return_value : null;
+        const output = serializeToolValue(nestedTool.output ?? nestedTool.result ?? event.output ?? event.result ?? returnValue?.output ?? returnValue?.message);
+        const error = serializeToolValue(nestedTool.error ?? event.error ?? (returnValue?.is_error === true ? returnValue.message : undefined));
+        const fallback = error !== undefined || type.includes('error') || type.includes('fail')
+            ? 'failed'
+            : output !== undefined || type.includes('result') || type.includes('complete') || type.includes('return')
+                ? 'completed'
+                : 'running';
+        chunks.push({
+            type: 'tool-event',
+            toolName: toolName ?? 'tool',
+            status: normalizeToolStatus(nestedTool.status ?? event.status, fallback),
+            ...(callId ? { callId } : {}),
+            ...(input !== undefined ? { input } : {}),
+            ...(output !== undefined ? { output } : {}),
+            ...(output !== undefined ? { outputMode: type.includes('delta') ? 'delta' : 'snapshot' } : {}),
+            ...(error !== undefined ? { error } : {}),
+            ...(firstToolText(nestedTool.agent_id, nestedTool.agentId, event.agent_id, event.agentId) ? { agentId: firstToolText(nestedTool.agent_id, nestedTool.agentId, event.agent_id, event.agentId) } : {}),
+            ...(serializeToolValue(nestedTool.detail ?? event.detail) !== undefined ? { detail: serializeToolValue(nestedTool.detail ?? event.detail) } : {}),
+        });
+    }
+    const usage = isRecord(event.usage) ? event.usage : isRecord(value.usage) ? value.usage : null;
+    const usageEvent = usageChunk(usage);
+    if (usageEvent)
+        chunks.push(usageEvent);
+    if ((type.includes('error') || type.includes('failed')) && !isToolEvent)
+        return { protocol: true, error: true, chunks };
+    if (type.includes('turnend') || type.includes('turn_end') || type.includes('completed') || type.includes('complete') || type === 'done' || type === 'result' || type.includes('session.completed'))
+        chunks.push({ type: 'finish', reason: cancelled ? 'cancel' : 'stop' });
+    return { protocol: true, error: false, chunks };
+}
+function kimiInteractionRequest(value) {
+    if (value.method !== 'request' || (typeof value.id !== 'string' && typeof value.id !== 'number'))
+        return null;
+    const params = isRecord(value.params) ? value.params : null;
+    const payload = isRecord(params?.payload) ? params.payload : null;
+    const type = typeof params?.type === 'string' ? params.type.toLowerCase() : '';
+    const requestId = firstString(payload ?? {}, payload ?? {}, ['id']);
+    if (payload === null || requestId === null)
+        return null;
+    if (type === 'approvalrequest') {
+        const toolName = firstString(payload, payload, ['sender']) ?? 'external-agent';
+        const detail = firstString(payload, payload, ['description', 'action']);
+        const callId = firstString(payload, payload, ['tool_call_id']);
+        return {
+            event: {
+                type: 'permission-request',
+                requestId,
+                kind: firstString(payload, payload, ['action']) ?? toolName,
+                toolName,
+                ...(callId ? { callId } : {}),
+                ...(detail ? { detail } : {}),
+            },
+            pending: { rpcId: value.id, kind: 'permission' },
+        };
+    }
+    if (type === 'questionrequest') {
+        const questions = readAgentQuestions(payload.questions);
+        if (questions.length === 0)
+            return null;
+        return {
+            event: { type: 'question-request', requestId, questions },
+            pending: {
+                rpcId: value.id,
+                kind: 'question',
+                questions: new Map(questions.map((question) => [question.id, question.question])),
+            },
+        };
+    }
+    return null;
+}
+function textFrom(value) {
+    for (const key of ['text', 'delta', 'content', 'message']) {
+        const item = value[key];
+        if (typeof item === 'string' && item.trim())
+            return item;
+        if (Array.isArray(item)) {
+            const parts = item.flatMap((part) => typeof part === 'string' ? [part] : isRecord(part) ? [textFrom(part) ?? ''] : []);
+            const joined = parts.join('');
+            if (joined.trim())
+                return joined;
+        }
+        if (isRecord(item)) {
+            const nested = textFrom(item);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+}
+function firstString(a, b, keys) {
+    for (const key of keys)
+        for (const source of [a, b])
+            if (typeof source[key] === 'string' && source[key].trim())
+                return source[key];
+    return null;
+}
+function isRecord(value) { return typeof value === 'object' && value !== null && !Array.isArray(value); }
+export { KimiCliDriver as KimiDriver };
+//# sourceMappingURL=kimi-driver.js.map

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

@@ -0,0 +1,22 @@
+import type { CodingNsCliModelCatalog } from '../../shared/contracts/cli-adapter.js';
+/**
+ * 外部 CLI 没有稳定的模型目录接口时，使用随适配器验证过的最小目录。
+ * 目录只保存模型 id 和 CLI 接受的思考档位，不包含凭据或远端响应。
+ */
+export declare function staticCatalog(groupId: string, groupName: string, models: readonly {
+    id: string;
+    name?: string;
+    efforts: readonly string[];
+}[]): CodingNsCliModelCatalog;
+/** Gemini ACP 只返回模型标识；思考档位需按 Gemini 官方能力表补齐。 */
+export declare function resolveGeminiEfforts(modelId: string): readonly string[];
+export declare const CLAUDE_CATALOG: CodingNsCliModelCatalog;
+export declare const KIMI_CATALOG: CodingNsCliModelCatalog;
+export declare const GEMINI_CATALOG: CodingNsCliModelCatalog;
+export declare const CODEX_CATALOG: CodingNsCliModelCatalog;
+export declare const GROK_CATALOG: CodingNsCliModelCatalog;
+export declare const PI_CATALOG: CodingNsCliModelCatalog;
+/** 把 CLI 帮助解析到的模型补上已知档位，未知模型保持空数组。 */
+export declare function enrichEfforts(catalog: CodingNsCliModelCatalog, known: CodingNsCliModelCatalog): CodingNsCliModelCatalog;
+export declare function isProviderDefaultModel(modelId: string | undefined): boolean;
+//# sourceMappingURL=model-catalog.d.ts.map