@jingyi0605/codingns4dsh 0.1.0

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

@@ -0,0 +1,180 @@
+import { CodingNsDshToolHistoryProjector } from './dsh-tool-history.js';
+import { CodingNsAgentEventNormalizer, } from './stream-normalizer.js';
+/**
+ * 所有外部 Agent 共用的 DSH 消息投影器。
+ *
+ * 驱动只产生 CodingNsAgentEvent。本类统一完成快照去重、通道索引、工具历史、
+ * 原生权限/问题交互、usage 和终态映射，调用方不再按 Provider 或消息类型分支。
+ */
+export class CodingNsDshMessageProjector {
+    options;
+    normalizer = new CodingNsAgentEventNormalizer();
+    toolHistory;
+    finished = false;
+    constructor(options) {
+        this.options = options;
+        this.toolHistory = new CodingNsDshToolHistoryProjector(options.nativeSessions, options.sessionId);
+    }
+    get isFinished() {
+        return this.finished;
+    }
+    async push(event) {
+        if (this.finished)
+            return [];
+        const projected = [];
+        for (const normalized of this.normalizer.push(event)) {
+            projected.push(...await this.project(normalized));
+            if (this.finished)
+                break;
+        }
+        return projected;
+    }
+    /** Provider 未发送 finish 时补齐 usage 和正常终态。 */
+    async complete(reason = 'stop') {
+        if (this.finished)
+            return [];
+        const projected = await this.flushUsage();
+        projected.push(...await this.project({ type: 'finish', reason }));
+        return projected;
+    }
+    /** 把执行异常也交给同一投影层，确保错误正文和终态结构一致。 */
+    async fail(message, cancelled = false) {
+        if (this.finished)
+            return [];
+        const projected = await this.flushUsage();
+        const reason = cancelled ? 'cancel' : 'error';
+        if (!cancelled) {
+            projected.push({ type: 'text-delta', index: 1, text: formatExecutionFailure(this.options.adapterId, message) });
+        }
+        projected.push(...await this.project({ type: 'finish', reason }, message));
+        return projected;
+    }
+    async flushUsage() {
+        const projected = [];
+        for (const event of this.normalizer.flush())
+            projected.push(...await this.project(event));
+        return projected;
+    }
+    async project(event, failureMessage) {
+        switch (event.type) {
+            case 'reasoning-delta':
+                return event.text === '' ? [] : [{ type: 'reasoning-delta', index: 0, text: event.text }];
+            case 'text-delta':
+                return event.text === '' ? [] : [{ type: 'text-delta', index: 1, text: event.text }];
+            case 'tool-event':
+                return externalToolChunk(this.toolHistory.observe(event));
+            case 'permission-request':
+                await this.requestPermission(event);
+                return [];
+            case 'question-request':
+                await this.requestQuestions(event);
+                return [];
+            case 'usage':
+                if (event.contextWindow !== undefined) {
+                    this.options.nativeSessions?.appendRequestContext?.(this.options.sessionId, {
+                        provider: this.options.adapterId,
+                        model: this.options.modelId ?? this.options.adapterId,
+                        contextWindow: event.contextWindow,
+                    });
+                }
+                return [{
+                        type: 'usage',
+                        usage: {
+                            inputTokens: event.inputTokens,
+                            outputTokens: event.outputTokens,
+                            ...(event.cacheReadTokens === undefined ? {} : { cacheReadTokens: event.cacheReadTokens }),
+                            ...(event.cacheWriteTokens === undefined ? {} : { cacheWriteTokens: event.cacheWriteTokens }),
+                            ...(event.uncachedInputTokens === undefined ? {} : { uncachedInputTokens: event.uncachedInputTokens }),
+                            ...(event.totalTokens === undefined ? {} : { totalTokens: event.totalTokens }),
+                            ...(event.cacheHitRate === undefined ? {} : { cacheHitRate: event.cacheHitRate }),
+                            ...(event.contextWindow === undefined ? {} : { contextWindow: event.contextWindow }),
+                            ...(event.contextTokens === undefined ? {} : { contextTokens: event.contextTokens }),
+                            ...(event.contextUsageRatio === undefined ? {} : { contextUsageRatio: event.contextUsageRatio }),
+                        },
+                    }];
+            case 'session-binding':
+                return [];
+            case 'finish':
+                this.finished = true;
+                this.toolHistory.finalize(event.reason, failureMessage);
+                return [{ type: 'finish', reason: toDshFinishReason(event.reason, failureMessage) }];
+        }
+    }
+    async requestPermission(event) {
+        const responder = this.options.respondPermission;
+        if (responder === undefined)
+            throw new Error('外部 Agent 发送了权限请求，但适配器没有权限回复接口');
+        const outcome = await this.options.nativeSessions?.requestApproval?.(this.options.sessionId, {
+            requestId: event.requestId,
+            toolName: event.toolName ?? (event.kind || 'external-agent'),
+            ...(event.callId ? { callId: event.callId } : {}),
+            ...(event.detail ? { reason: event.detail } : {}),
+            ...(this.options.signal === undefined ? {} : { signal: this.options.signal }),
+        }) ?? 'unavailable';
+        const approved = outcome === 'allowed-once';
+        const reason = approvalReason(outcome);
+        await responder({ requestId: event.requestId, approved, ...(reason === undefined ? {} : { reason }) });
+    }
+    async requestQuestions(event) {
+        const responder = this.options.respondQuestion;
+        if (responder === undefined)
+            throw new Error('外部 Agent 发送了问题请求，但适配器没有问题回复接口');
+        const response = await this.options.nativeSessions?.askQuestions?.(this.options.sessionId, {
+            requestId: event.requestId,
+            questions: event.questions,
+            ...(this.options.signal === undefined ? {} : { signal: this.options.signal }),
+        }) ?? null;
+        if (response === null)
+            throw new Error('DSH 原生问题组件不可用或问题已取消');
+        await responder(response);
+    }
+}
+/**
+ * 没有 DSH 原生 Session 时的工具展示回退：使用空白 reasoning chunk 携带私有标记，
+ * 只让 Client 的实时 Conversation 投影读取，不会再次执行工具。完整 Host 直接使用
+ * 原生 tool/call 与 tool/result，不经过这里。
+ */
+function externalToolChunk(marker) {
+    if (marker === null)
+        return [];
+    return [{
+            type: 'reasoning-delta',
+            index: 0,
+            // 空 delta 会被 DSH 的流式聚合器丢弃，空格能保留 live-chunk 但不会显示思考正文。
+            text: ' ',
+            codingnsExternalTool: marker,
+        }];
+}
+function toDshFinishReason(reason, failureMessage) {
+    if (reason === 'cancel') {
+        return { kind: 'aborted', failure: { message: failureMessage ?? '外部 Agent 执行已取消', code: 'ABORTED' } };
+    }
+    if (reason === 'error') {
+        return { kind: 'error', failure: { message: failureMessage ?? '外部 Agent 执行失败', code: 'PROVIDER_ERROR' } };
+    }
+    return { kind: 'stop' };
+}
+function approvalReason(outcome) {
+    if (outcome === 'rejected')
+        return '用户拒绝了权限请求';
+    if (outcome === 'cancelled')
+        return '权限请求已取消';
+    if (outcome === 'unavailable')
+        return 'DSH 原生权限组件不可用';
+    return undefined;
+}
+function formatExecutionFailure(adapterId, message) {
+    const content = `[${adapterId}] ${message}`;
+    const fence = '~'.repeat(Math.max(3, longestCharacterRun(content, '~') + 1));
+    return `\n\n**外部 Agent 执行失败**\n\n${fence}text\n${content}\n${fence}\n`;
+}
+function longestCharacterRun(value, character) {
+    let longest = 0;
+    let current = 0;
+    for (const item of value) {
+        current = item === character ? current + 1 : 0;
+        longest = Math.max(longest, current);
+    }
+    return longest;
+}
+//# sourceMappingURL=dsh-message-projector.js.map

package/data/build/dist/host/cli-adapters/dsh-tool-history.d.ts

@@ -0,0 +1,48 @@
+import type { CodingNsAgentToolEvent } from '../../shared/contracts/cli-adapter.js';
+import type { CodingNsNativeSessionBridge } from '../native-session-bridge.js';
+/** 外部工具的实时回退标记；正常 Host 会优先写入 Session 持久时间线。 */
+export interface CodingNsDshExternalToolMarker {
+    readonly source: 'codingns-external-tool';
+    readonly phase: 'start' | 'update';
+    readonly callId: string;
+    readonly name: string;
+    readonly arguments: string;
+    readonly status: 'running' | 'completed' | 'failed';
+    readonly output?: string;
+    readonly error?: string;
+}
+/**
+ * 所有外部 Agent 共用的 DSH 工具历史投影器。
+ *
+ * 驱动只需要产出统一的 tool-event 观察事件；这里负责生命周期聚合、工具别名、
+ * 参数修正、结果文本和 diff 元数据，最后经唯一的原生 Session 桥接落盘。
+ */
+export declare class CodingNsDshToolHistoryProjector {
+    private readonly nativeSessions;
+    private readonly sessionId;
+    private readonly records;
+    private readonly deferNativeAppend;
+    private readonly removeNativeEventListener;
+    private anonymousSequence;
+    private turnChars;
+    private observedCalls;
+    private finalized;
+    private flushScheduled;
+    constructor(nativeSessions: CodingNsNativeSessionBridge | undefined, sessionId: string);
+    observe(event: CodingNsAgentToolEvent): CodingNsDshExternalToolMarker | null;
+    /** 流结束时补齐 Provider 遗漏的终态，避免原生组件永久停留在运行中。 */
+    finalize(reason: 'stop' | 'cancel' | 'error', failure?: string): void;
+    private assign;
+    private settle;
+    /** 按 Provider 到达顺序把工具调用和结果写入当前 DSH step。 */
+    private flushNativeRecords;
+    private persistNativeRecord;
+    private scheduleFlush;
+    /** 活动 step 晚于首个工具通知时，补写尚未进入 Session 的工具标记。 */
+    private flushExternalMarkers;
+    /** 先补齐同一调用的 start，再追加当前 update，保持 Conversation 生命周期合法。 */
+    private persistExternalMarker;
+    private appendCall;
+    private nextAnonymousCallId;
+}
+//# sourceMappingURL=dsh-tool-history.d.ts.map

package/data/build/dist/host/cli-adapters/dsh-tool-history.js

@@ -0,0 +1,373 @@
+const FIELD_LIMIT = 64 * 1024;
+const CALL_LIMIT = 192 * 1024;
+const TURN_LIMIT = 768 * 1024;
+const CALL_COUNT_LIMIT = 256;
+const TRUNCATION_MARKER = '\n...[内容因长度限制已截断]';
+/**
+ * 所有外部 Agent 共用的 DSH 工具历史投影器。
+ *
+ * 驱动只需要产出统一的 tool-event 观察事件；这里负责生命周期聚合、工具别名、
+ * 参数修正、结果文本和 diff 元数据，最后经唯一的原生 Session 桥接落盘。
+ */
+export class CodingNsDshToolHistoryProjector {
+    nativeSessions;
+    sessionId;
+    records = new Map();
+    deferNativeAppend;
+    removeNativeEventListener;
+    anonymousSequence = 0;
+    turnChars = 0;
+    observedCalls = 0;
+    finalized = false;
+    flushScheduled = false;
+    constructor(nativeSessions, sessionId) {
+        this.nativeSessions = nativeSessions;
+        this.sessionId = sessionId;
+        // 工具事件必须尽早进入当前 step。新桥接优先写入原生 tool/call 与 tool/result；
+        // 自定义标记只负责把这次通知立即送进实时 Conversation。不能把工具伪装成
+        // assistant/attempt，因为 DSH 会把后者当成模型结算，天然排到正文之后。
+        const subscribe = nativeSessions?.supportsEvents === true ? nativeSessions.subscribe : undefined;
+        this.deferNativeAppend = nativeSessions?.appendToolCall === undefined && nativeSessions?.appendExternalToolEvent === undefined && subscribe !== undefined;
+        this.removeNativeEventListener = subscribe?.call(nativeSessions, {
+            onEvent: (session, event) => {
+                if (session !== nativeSessions?.get(sessionId))
+                    return;
+                if (!isNativeStepStart(event) || this.flushScheduled)
+                    return;
+                this.flushScheduled = true;
+                queueMicrotask(() => {
+                    this.flushScheduled = false;
+                    if (nativeSessions?.appendToolCall !== undefined)
+                        this.flushNativeRecords();
+                    else
+                        this.flushExternalMarkers();
+                });
+            },
+        });
+    }
+    observe(event) {
+        const explicitCallId = event.callId?.trim();
+        const callId = explicitCallId || this.nextAnonymousCallId();
+        const key = explicitCallId ? `id:${explicitCallId}` : `anonymous:${callId}`;
+        const current = this.records.get(key);
+        if (current === undefined && this.observedCalls >= CALL_COUNT_LIMIT)
+            return null;
+        const toolName = meaningfulToolName(event.toolName, current?.toolName);
+        const input = event.input ?? current?.input;
+        const record = current ?? {
+            callId,
+            toolName,
+            handle: null,
+            failed: false,
+            settled: false,
+            resultAppended: false,
+            externalPersisted: false,
+            externalMarkerPersisted: false,
+        };
+        if (current === undefined)
+            this.observedCalls += 1;
+        record.toolName = toolName;
+        this.assign(record, 'input', input, 'snapshot');
+        if (event.output !== undefined) {
+            if (event.outputMode === undefined)
+                throw new Error('工具输出事件缺少 outputMode');
+            this.assign(record, 'output', event.output, event.outputMode);
+        }
+        this.assign(record, 'error', event.error, 'snapshot');
+        if (event.status === 'failed' || event.error !== undefined)
+            record.failed = true;
+        this.records.set(key, record);
+        if (event.status === 'completed' || event.status === 'failed') {
+            this.settle(record, record.failed);
+        }
+        const normalized = normalizeToolCall(record.toolName, record.input);
+        const status = record.failed
+            ? 'failed'
+            : record.settled
+                ? 'completed'
+                : 'running';
+        const marker = {
+            source: 'codingns-external-tool',
+            phase: current === undefined ? 'start' : 'update',
+            callId: record.callId,
+            name: normalized.name,
+            arguments: normalized.arguments,
+            status,
+            ...(record.output === undefined ? {} : { output: record.output }),
+            ...(record.error === undefined ? {} : { error: record.error }),
+        };
+        record.externalMarker = marker;
+        record.externalMarkerPersisted = false;
+        if (this.nativeSessions?.appendToolCall !== undefined && this.sessionId.trim() !== '') {
+            // DSH Chat 原生识别 tool/call 为运行中的工具节点，tool/result 负责更新它。
+            // 不再额外伪造 reasoning-delta，否则每个工具通知都会触发 assistant 正文刷新。
+            const persisted = this.persistNativeRecord(record);
+            if (!persisted && this.nativeSessions.supportsEvents)
+                this.scheduleFlush();
+            return null;
+        }
+        const hasExternalAppender = this.nativeSessions?.appendExternalToolEvent !== undefined && this.sessionId.trim() !== '';
+        if (hasExternalAppender)
+            this.persistExternalMarker(record);
+        if (!hasExternalAppender && !this.deferNativeAppend)
+            this.flushNativeRecords();
+        return marker;
+    }
+    /** 流结束时补齐 Provider 遗漏的终态，避免原生组件永久停留在运行中。 */
+    finalize(reason, failure) {
+        this.finalized = true;
+        for (const record of this.records.values()) {
+            if (record.settled)
+                continue;
+            if (failure !== undefined && record.error === undefined)
+                this.assign(record, 'error', failure, 'snapshot');
+            this.settle(record, record.failed || reason !== 'stop');
+        }
+        if (this.nativeSessions?.appendToolCall !== undefined) {
+            this.flushNativeRecords();
+            this.removeNativeEventListener?.();
+        }
+        else if (this.nativeSessions?.appendExternalToolEvent !== undefined) {
+            this.flushExternalMarkers();
+            this.removeNativeEventListener?.();
+        }
+        else if (!this.deferNativeAppend)
+            this.flushNativeRecords();
+    }
+    assign(record, field, incoming, mode) {
+        if (incoming === undefined)
+            return;
+        const current = record[field] ?? '';
+        const callChars = (record.input?.length ?? 0) + (record.output?.length ?? 0) + (record.error?.length ?? 0);
+        const available = Math.max(0, Math.min(FIELD_LIMIT, current.length + CALL_LIMIT - callChars, current.length + TURN_LIMIT - this.turnChars));
+        const next = mode === 'snapshot'
+            ? bounded(incoming, available)
+            : bounded(`${current}${incoming}`, available);
+        if (next === current)
+            return;
+        record[field] = next;
+        this.turnChars += next.length - current.length;
+    }
+    settle(record, isError) {
+        if (record.settled)
+            return;
+        record.settled = true;
+        record.failed = isError;
+    }
+    /** 按 Provider 到达顺序把工具调用和结果写入当前 DSH step。 */
+    flushNativeRecords() {
+        if (this.nativeSessions?.appendToolCall === undefined || this.sessionId.trim() === '')
+            return;
+        for (const record of this.records.values())
+            this.persistNativeRecord(record);
+        if (this.finalized)
+            this.removeNativeEventListener?.();
+    }
+    persistNativeRecord(record) {
+        const append = this.nativeSessions?.appendToolCall;
+        if (append === undefined || this.sessionId.trim() === '')
+            return false;
+        if (record.handle === null)
+            record.handle = this.appendCall(record, append);
+        if (!record.settled || record.resultAppended || record.handle === null)
+            return record.handle !== null;
+        const appendResult = this.nativeSessions?.appendToolResult;
+        if (appendResult === undefined)
+            return false;
+        const normalized = normalizeToolCall(record.toolName, record.input);
+        const error = record.error?.trim();
+        const output = normalizeToolOutput(record.output ?? error ?? '');
+        try {
+            record.resultAppended = appendResult.call(this.nativeSessions, record.handle, {
+                output,
+                isError: record.failed,
+                ...(error ? { error } : {}),
+                ...toolResultMeta(normalized.name, normalized.arguments),
+            });
+        }
+        catch {
+            record.resultAppended = false;
+        }
+        return record.resultAppended;
+    }
+    scheduleFlush() {
+        if (this.flushScheduled)
+            return;
+        this.flushScheduled = true;
+        queueMicrotask(() => {
+            this.flushScheduled = false;
+            if (this.nativeSessions?.appendToolCall !== undefined)
+                this.flushNativeRecords();
+            else
+                this.flushExternalMarkers();
+        });
+    }
+    /** 活动 step 晚于首个工具通知时，补写尚未进入 Session 的工具标记。 */
+    flushExternalMarkers() {
+        if (this.nativeSessions?.appendExternalToolEvent === undefined || this.sessionId.trim() === '')
+            return;
+        for (const record of this.records.values()) {
+            if (record.externalMarker === undefined || record.externalMarkerPersisted)
+                continue;
+            this.persistExternalMarker(record);
+        }
+    }
+    /** 先补齐同一调用的 start，再追加当前 update，保持 Conversation 生命周期合法。 */
+    persistExternalMarker(record) {
+        const append = this.nativeSessions?.appendExternalToolEvent;
+        const marker = record.externalMarker;
+        if (append === undefined || marker === undefined || this.sessionId.trim() === '')
+            return false;
+        if (!record.externalPersisted) {
+            const start = marker.phase === 'start'
+                ? marker
+                : { source: marker.source, phase: 'start', callId: marker.callId, name: marker.name, arguments: marker.arguments, status: 'running' };
+            try {
+                if (!append.call(this.nativeSessions, this.sessionId, start))
+                    return false;
+                record.externalPersisted = true;
+            }
+            catch {
+                return false;
+            }
+            if (marker.phase === 'start') {
+                record.externalMarkerPersisted = true;
+                return true;
+            }
+        }
+        try {
+            record.externalMarkerPersisted = append.call(this.nativeSessions, this.sessionId, marker);
+            return record.externalMarkerPersisted;
+        }
+        catch {
+            return false;
+        }
+    }
+    appendCall(record, append) {
+        const normalized = normalizeToolCall(record.toolName, record.input);
+        try {
+            return append.call(this.nativeSessions, this.sessionId, {
+                callId: record.callId,
+                name: normalized.name,
+                arguments: normalized.arguments,
+            });
+        }
+        catch {
+            // 原生展示失败不能中断外部 Agent 的真实执行。
+            return null;
+        }
+    }
+    nextAnonymousCallId() {
+        this.anonymousSequence += 1;
+        return `external-tool-${this.anonymousSequence}`;
+    }
+}
+function normalizeToolCall(toolName, input) {
+    const name = canonicalToolName(toolName);
+    const parsed = parseRecord(input);
+    const args = parsed ?? (input === undefined || input === ''
+        ? {}
+        : name === 'bash'
+            ? { command: input }
+            : { input });
+    if (name === 'read' || name === 'write' || name === 'edit') {
+        rename(args, 'path', 'file_path');
+        rename(args, 'filePath', 'file_path');
+    }
+    if (name === 'edit') {
+        rename(args, 'oldString', 'old_string');
+        rename(args, 'newString', 'new_string');
+        rename(args, 'replaceAll', 'replace_all');
+    }
+    return { name, arguments: JSON.stringify(args) };
+}
+function canonicalToolName(value) {
+    const original = value.trim() || 'tool';
+    const key = original.toLowerCase().replace(/[\s-]+/gu, '_');
+    if (['read', 'read_file'].includes(key))
+        return 'read';
+    if (['write', 'write_file'].includes(key))
+        return 'write';
+    if (['edit', 'edit_file'].includes(key))
+        return 'edit';
+    if (['bash', 'shell', 'shell_command', 'run_shell_command', 'command_execution'].includes(key))
+        return 'bash';
+    return original;
+}
+function toolResultMeta(name, argumentsJson) {
+    if (name !== 'edit' && name !== 'write')
+        return {};
+    const args = parseRecord(argumentsJson);
+    const path = stringValue(args?.file_path);
+    const newText = stringValue(name === 'edit' ? args?.new_string : args?.content);
+    if (path === null || newText === null)
+        return {};
+    const oldText = name === 'edit' ? stringValue(args?.old_string) : null;
+    return {
+        meta: {
+            diffs: [{ path, oldText, newText }],
+        },
+    };
+}
+/** Command Code 等 Provider 会把文本块包成 JSON；原生结果只展示真正文本。 */
+function normalizeToolOutput(value) {
+    if (value === '')
+        return '';
+    try {
+        const parsed = JSON.parse(value);
+        const texts = collectTextBlocks(parsed);
+        return texts.length > 0 ? texts.join('\n') : value;
+    }
+    catch {
+        return value;
+    }
+}
+function collectTextBlocks(value) {
+    if (Array.isArray(value))
+        return value.flatMap(collectTextBlocks);
+    if (!isRecord(value))
+        return [];
+    if (value.type === 'text' && typeof value.text === 'string')
+        return [value.text];
+    if (Array.isArray(value.content))
+        return value.content.flatMap(collectTextBlocks);
+    return [];
+}
+function meaningfulToolName(incoming, previous) {
+    const normalized = incoming.trim() || 'tool';
+    return normalized === 'tool' && previous !== undefined ? previous : normalized;
+}
+function isNativeStepStart(value) {
+    return isRecord(value) && value.type === 'step/start';
+}
+function parseRecord(value) {
+    if (value === undefined || value.trim() === '')
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed) ? { ...parsed } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function rename(record, source, target) {
+    if (record[target] === undefined && record[source] !== undefined)
+        record[target] = record[source];
+    if (source !== target)
+        delete record[source];
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : null;
+}
+function bounded(value, limit = FIELD_LIMIT) {
+    if (value.length <= limit)
+        return value;
+    if (limit <= TRUNCATION_MARKER.length)
+        return TRUNCATION_MARKER.slice(0, limit);
+    return `${value.slice(0, limit - TRUNCATION_MARKER.length)}${TRUNCATION_MARKER}`;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=dsh-tool-history.js.map

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

@@ -0,0 +1,7 @@
+import type { FeatureModule } from '../../shared/contracts/feature.js';
+import { CodingNsCliAdapterRegistry } from './registry.js';
+import type { CodingNsHostServices } from '../features/types.js';
+export declare function createCliAdaptersFeature(options?: {
+    registry?: CodingNsCliAdapterRegistry;
+}): FeatureModule<CodingNsHostServices>;
+//# sourceMappingURL=feature.d.ts.map