@ai-workbench/remote-agent 0.8.28 → 0.9.0-toolbridge.2

package/dist/toolbridge-table.js

@@ -0,0 +1,27 @@
+import { createHash } from 'node:crypto';
+import { NeedError } from "./remote.js";
+/** Fixed official tool names; no description heuristics or plugin-name branches. */
+export const TOOLBRIDGE_EXCLUDED = Object.freeze([
+    'read', 'write', 'edit', 'read_image', 'glob', 'grep', 'bash', 'pwsh', 'str_replace_editor',
+    'job_output', 'job_list', 'job_kill', 'load_workspace_dependencies',
+    'terminal_open', 'terminal_send', 'terminal_read', 'terminal_signal', 'terminal_close', 'terminal_list',
+    'subagent', 'list_subagent_models', 'send_message', 'interrupt_agent', 'spawn_teammate', 'list_agents', 'wait_agent',
+    'team_task_create', 'team_task_list', 'team_task_get', 'team_task_update', 'run_code',
+]);
+const excluded = new Set(TOOLBRIDGE_EXCLUDED);
+export function bridgeTable(tools = []) {
+    const table = new Map(), names = new Set();
+    for (const tool of tools) {
+        if (excluded.has(tool.name))
+            continue;
+        if (names.has(tool.name))
+            throw new NeedError('TOOLBRIDGE_TOOL_DUPLICATE', '当前工具表存在重名，工具桥未开始。', '官方唯一工具名称');
+        names.add(tool.name);
+        const alias = 'dsh_' + createHash('sha256').update(tool.name).digest('hex').slice(0, 32);
+        if (table.has(alias))
+            throw new NeedError('TOOLBRIDGE_NAME_COLLISION', '工具桥名称冲突，未执行。', '唯一工具桥名称');
+        const schema = structuredClone(tool);
+        table.set(alias, { alias, schema, wire: { name: alias, description: 'DSH工具 ' + schema.name + '：' + schema.description, inputSchema: structuredClone(schema.parameters) } });
+    }
+    return table;
+}

package/dist/toolbridge.d.ts

@@ -0,0 +1,114 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { GenerateOptions, ToolCallBlock } from '@deepseek-ai/dsh-llm';
+import type { SessionUpdate } from '@agentclientprotocol/sdk/unstable';
+import { type BridgeTool } from './toolbridge-table.ts';
+import type { ImageReader } from './input.ts';
+import type { DetailObservation } from './conversation-details.ts';
+export declare const TOOLBRIDGE_TIMEOUT_SECONDS = 1800;
+export declare const TOOLBRIDGE_NOTICE = "\u542B\u5DE5\u5177\u6865\uFF1A\u672C\u673A\u6587\u4EF6\u5939\u7684\u6269\u5C55\u5DE5\u5177\u7531DSH\u6267\u884C\u5E76\u6309\u5F53\u524D\u6743\u9650\u5BA1\u6279\uFF1B\u6587\u4EF6\u548C\u547D\u4EE4\u4FDD\u6301\u539F\u6267\u884C\u65B9\u5F0F\u3002\u5DE5\u5177\u8868\u5728\u65B0\u4E00\u8F6E\u4E3B\u673A\u8FDE\u63A5\u65F6\u66F4\u65B0\u3002";
+export declare const TOOLBRIDGE_ENDED = "\u4E3B\u673A\u5DF2\u7ED3\u675F\u8FD9\u6B21\u5DE5\u5177\u7B49\u5F85\uFF1B\u672C\u8F6E\u5DF2\u505C\u6B62\uFF0C\u8FDF\u5230\u7ED3\u679C\u4E0D\u4F1A\u4EA4\u56DE\uFF0C\u4E5F\u4E0D\u4F1A\u91CD\u65B0\u6267\u884C\u3002\u8BF7\u6838\u5BF9\u5DF2\u53D1\u751F\u7684\u64CD\u4F5C\u3002";
+interface Pending {
+    block: ToolCallBlock;
+    alias: string;
+    reply: ReturnType<typeof Promise.withResolvers<CallToolResult>>;
+    exported: boolean;
+    settled: boolean;
+    off(): void;
+}
+/** Only a protocol queue. Tool execution and authorization belong to DSH. */
+export declare class ToolBridge {
+    private options;
+    private readImage?;
+    readonly controller: AbortController;
+    private snapshot?;
+    get table(): ReadonlyMap<string, BridgeTool>;
+    readonly calls: Map<string, Pending>;
+    enabled: boolean;
+    ended: boolean;
+    notice?: string;
+    replayState?: {
+        response: unknown;
+    };
+    localTurnEnded: boolean;
+    concludeAcknowledged: boolean;
+    onConcludeAcknowledged: () => void;
+    private nativeCompleted;
+    private nativeTerminated;
+    private concludeNative;
+    beginConclude(): void;
+    private active?;
+    begin(signal: AbortSignal): void;
+    end(): void;
+    changed: () => void;
+    record: (event: DetailObservation) => void;
+    onAbandon: (notice: string) => void;
+    private nativeBridgeIds;
+    constructor(options: GenerateOptions, readImage?: ImageReader | undefined);
+    enable(record: (event: DetailObservation) => void): void;
+    get tools(): {
+        inputSchema: {
+            [x: string]: unknown;
+            type: "object";
+            properties?: {
+                [x: string]: object;
+            } | undefined;
+            required?: string[] | undefined;
+        };
+        name: string;
+        description?: string | undefined;
+        outputSchema?: {
+            [x: string]: unknown;
+            type: "object";
+            properties?: {
+                [x: string]: object;
+            } | undefined;
+            required?: string[] | undefined;
+        } | undefined;
+        annotations?: {
+            title?: string | undefined;
+            readOnlyHint?: boolean | undefined;
+            destructiveHint?: boolean | undefined;
+            idempotentHint?: boolean | undefined;
+            openWorldHint?: boolean | undefined;
+        } | undefined;
+        execution?: {
+            taskSupport?: "optional" | "required" | "forbidden" | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    }[];
+    isBridge(name: unknown): boolean;
+    call(alias: string, args: Record<string, unknown>, signal: AbortSignal): Promise<CallToolResult>;
+    get pending(): Pending[];
+    get unsettled(): boolean;
+    get waiting(): boolean;
+    results(options: GenerateOptions): Promise<void>;
+    private mapResult;
+    private concludeAck;
+    observe(update: SessionUpdate): void;
+    /** A failed native bridge cancels the entire parked round; never guess between parallel identical calls. */
+    abandon(reason: string): void;
+    close(): void;
+}
+/** Codex executes nc in its existing employee environment, never on the host. */
+export declare function openToolBridgeMcp(bridge: ToolBridge, maxBytes: number): Promise<{
+    mcpServers: {
+        name: string;
+        command: string;
+        args: string[];
+        env: {
+            name: string;
+            value: string;
+        }[];
+    }[];
+    close: () => Promise<void>;
+}>;
+export {};

package/dist/toolbridge.js

@@ -0,0 +1,205 @@
+import { randomUUID } from 'node:crypto';
+import { createServer } from 'node:net';
+import { mkdtemp, lstat, rm } from 'node:fs/promises';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { EmployeeSocketTransport } from "./employee-mcp.js";
+import { bridgeTable } from "./toolbridge-table.js";
+import { NeedError } from "./remote.js";
+export const TOOLBRIDGE_TIMEOUT_SECONDS = 1800;
+export const TOOLBRIDGE_NOTICE = '含工具桥：本机文件夹的扩展工具由DSH执行并按当前权限审批；文件和命令保持原执行方式。工具表在新一轮主机连接时更新。';
+export const TOOLBRIDGE_ENDED = '主机已结束这次工具等待；本轮已停止，迟到结果不会交回，也不会重新执行。请核对已发生的操作。';
+const errorResult = (text) => ({ isError: true, content: [{ type: 'text', text }] });
+/** Only a protocol queue. Tool execution and authorization belong to DSH. */
+export class ToolBridge {
+    options;
+    readImage;
+    controller = new AbortController();
+    snapshot;
+    get table() { return this.snapshot ??= bridgeTable(this.options.tools); }
+    calls = new Map();
+    enabled = false;
+    ended = false;
+    notice;
+    replayState;
+    localTurnEnded = false;
+    concludeAcknowledged = false;
+    onConcludeAcknowledged = () => { };
+    nativeCompleted = new Set();
+    nativeTerminated = new Set();
+    concludeNative = new Set();
+    beginConclude() { this.localTurnEnded = true; this.concludeNative = new Set([...this.nativeBridgeIds].filter(id => !this.nativeTerminated.has(id))); }
+    active;
+    begin(signal) { this.active = signal; }
+    end() { this.active = undefined; }
+    changed = () => { };
+    record = () => { };
+    onAbandon = () => { };
+    nativeBridgeIds = new Set();
+    constructor(options, readImage) {
+        this.options = options;
+        this.readImage = readImage;
+    }
+    enable(record) { if (!this.table.size)
+        return; this.enabled = true; this.record = record; record({ kind: 'session', severity: 'info', code: 'TOOLBRIDGE_SELECTED', summary: TOOLBRIDGE_NOTICE, payload: { toolCount: this.table.size, toolTimeoutSec: TOOLBRIDGE_TIMEOUT_SECONDS, timeoutSource: 'owner-2026-10-26', snapshot: 'native-session-open', excluded: 'official-file-command-subagent-team-run_code' } }); }
+    get tools() { return [...this.table.values()].map(t => t.wire); }
+    isBridge(name) { return typeof name === 'string' && this.table.has(name.replace(/^mcp__employee__/, '')); }
+    async call(alias, args, signal) {
+        const tool = this.table.get(alias);
+        if (!this.enabled || this.ended || this.localTurnEnded || !this.active || this.active.aborted || !tool || signal.aborted)
+            return errorResult('工具桥当前不可用，未执行。');
+        const id = ('awb-' + randomUUID());
+        const abort = () => this.abandon('MCP_REQUEST_CANCELLED');
+        const pending = { block: { type: 'tool-call', id, name: tool.schema.name, arguments: JSON.stringify(args) }, alias, reply: Promise.withResolvers(), exported: false, settled: false, off: () => signal.removeEventListener('abort', abort) };
+        this.calls.set(id, pending);
+        signal.addEventListener('abort', abort, { once: true });
+        this.record({ kind: 'tool', severity: 'info', code: 'TOOLBRIDGE_CALL_PARKED', summary: '主机工具调用交给DSH执行与审批，原prompt继续等待。', payload: { callId: id, tool: tool.schema.name } });
+        this.changed();
+        if (signal.aborted)
+            abort();
+        return pending.reply.promise;
+    }
+    get pending() { return [...this.calls.values()].filter(p => !p.settled && !p.exported); }
+    get unsettled() { return [...this.calls.values()].some(p => !p.settled); }
+    get waiting() { return [...this.calls.values()].some(p => p.exported && !p.settled); }
+    async results(options) {
+        const batch = [];
+        for (const p of this.calls.values()) {
+            if (!p.exported || p.settled)
+                continue;
+            const matches = options.messages.filter((m) => m.role === 'tool' && m.toolCallId === p.block.id);
+            if (matches.length !== 1)
+                throw new NeedError('TOOLBRIDGE_RESULT_MISSING', '工具桥没有收到唯一匹配的DSH结果，本轮已停止；不会重跑。', '原toolCallId对应的官方tool结果');
+            batch.push({ pending: p, result: await this.mapResult(matches[0], options.signal) });
+        }
+        // Map the whole DSH batch before releasing any native Promise. A normal MCP
+        // isError must not race an unfinished image mapping from this same batch.
+        if (this.ended) {
+            for (const { pending: p } of batch)
+                this.record({ kind: 'tool', severity: 'warning', code: 'DSH_BRIDGE_LATE_RESULT_DROPPED', summary: TOOLBRIDGE_ENDED, payload: { callId: p.block.id } });
+            return;
+        }
+        if (this.localTurnEnded)
+            for (const p of this.calls.values())
+                if (!p.exported && !p.settled) {
+                    batch.push({ pending: p, result: errorResult('DSH工具已结束本轮，这个尚未派发的调用没有执行。') });
+                    this.record({ kind: 'tool', severity: 'info', code: 'TOOLBRIDGE_CONCLUDED_UNDISPATCHED', summary: 'DSH工具结束了本轮，尚未交给DSH的调用没有执行。', payload: { callId: p.block.id } });
+                }
+        const ready = batch.filter(row => !row.pending.settled);
+        for (const { pending: p } of ready) {
+            p.settled = true;
+            p.off();
+        }
+        for (const { pending: p, result } of ready)
+            p.reply.resolve(result);
+        this.concludeAck();
+    }
+    async mapResult(message, signal) {
+        const content = [];
+        for (const block of message.content) {
+            if (block.type === 'text') {
+                content.push({ type: 'text', text: block.text });
+                continue;
+            }
+            if (block.type === 'image') {
+                if (block.offloaded)
+                    return errorResult('这张图片已按DSH策略移出上下文，工具桥未将占位内容冒充图片结果。');
+                if (!this.readImage)
+                    throw new NeedError('ATTACHMENT_REQUIRED', '我需要官方附件组件读取工具返回的图片。', 'attachments.readImage');
+                const image = await this.readImage(block.attachment, signal);
+                signal?.throwIfAborted();
+                if (image.ref.attachmentId !== block.attachment.attachmentId || image.ref.bytes !== image.data.byteLength || !['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(image.ref.mediaType))
+                    throw new NeedError('ATTACHMENT_INVALID', '工具图片的附件内容无法核对，本轮没有交回。', '官方核验的图片字节与媒体类型');
+                content.push({ type: 'image', mimeType: image.ref.mediaType, data: Buffer.from(image.data).toString('base64') });
+                continue;
+            }
+            return errorResult('工具返回了本版工具桥尚不支持的内容类型：' + block.type + '；没有静默丢弃或重新执行。');
+        }
+        return { content, isError: !!message.isError };
+    }
+    concludeAck() {
+        if (this.localTurnEnded && !this.unsettled && !this.concludeAcknowledged && this.concludeNative.size && [...this.concludeNative].every(id => this.nativeCompleted.has(id))) {
+            this.concludeAcknowledged = true;
+            this.record({ kind: 'tool', severity: 'info', code: 'TOOLBRIDGE_CONCLUDED_RESULT_DELIVERED', summary: 'DSH工具结束了本轮，原生工具已确认收到结果；结束原prompt，不再派发新工具。' });
+            this.onConcludeAcknowledged();
+        }
+    }
+    observe(update) {
+        if (!this.enabled || this.ended)
+            return;
+        if (update.sessionUpdate !== 'tool_call' && update.sessionUpdate !== 'tool_call_update')
+            return;
+        const u = update;
+        const raw = u.rawInput;
+        const name = u.name ?? u._meta?.claudeCode?.toolName;
+        if (this.isBridge(name) || raw?.server === 'employee' && this.isBridge(raw.tool) || this.isBridge(u.title))
+            this.nativeBridgeIds.add(u.toolCallId);
+        if ((u.status === 'completed' || u.status === 'failed') && this.nativeBridgeIds.has(u.toolCallId))
+            this.nativeTerminated.add(u.toolCallId);
+        if (u.status === 'failed' && this.nativeBridgeIds.has(u.toolCallId) && !this.unsettled && u.rawOutput?.result?.isError === true && Array.isArray(u.rawOutput.result.content)) {
+            this.nativeCompleted.add(u.toolCallId);
+            this.concludeAck();
+        }
+        if (u.status === 'completed' && this.nativeBridgeIds.has(u.toolCallId)) {
+            this.nativeCompleted.add(u.toolCallId);
+            this.concludeAck();
+        }
+        if (u.status === 'failed' && this.nativeBridgeIds.has(u.toolCallId) && (!this.localTurnEnded || this.concludeNative.has(u.toolCallId)) && this.unsettled)
+            this.abandon('HOST_TOOL_FAILED');
+    }
+    /** A failed native bridge cancels the entire parked round; never guess between parallel identical calls. */
+    abandon(reason) {
+        if (this.ended)
+            return;
+        this.notice = TOOLBRIDGE_ENDED;
+        this.record({ kind: 'tool', severity: 'warning', code: 'DSH_BRIDGE_CALL_ABANDONED_BY_HOST', summary: this.notice, payload: { reason, toolTimeoutSec: TOOLBRIDGE_TIMEOUT_SECONDS, fixedTimeoutReasonAvailable: false, scope: 'entire-parked-round', replayed: false } });
+        this.close();
+        this.onAbandon(this.notice);
+    }
+    close() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.controller.abort();
+        for (const p of this.calls.values())
+            if (!p.settled) {
+                p.settled = true;
+                p.off();
+                p.reply.resolve(errorResult('本轮工具等待已结束；结果不重放。'));
+            }
+        this.changed();
+    }
+}
+/** Codex executes nc in its existing employee environment, never on the host. */
+export async function openToolBridgeMcp(bridge, maxBytes) {
+    const root = await mkdtemp('/private/tmp/aw-tb-'), socketPath = root + '/mcp';
+    const clients = new Set();
+    let closed = false;
+    const listener = createServer(socket => {
+        if (closed) {
+            socket.destroy();
+            return;
+        }
+        const server = new Server({ name: 'ai-workbench-toolbridge', version: '0.9.0' }, { capabilities: { tools: {} } });
+        clients.add(server);
+        server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: bridge.tools }));
+        server.setRequestHandler(CallToolRequestSchema, (r, extra) => bridge.call(r.params.name, r.params.arguments ?? {}, extra.signal));
+        server.onclose = () => clients.delete(server);
+        server.onerror = () => bridge.abandon('MCP_TRANSPORT_FAILED');
+        void server.connect(new EmployeeSocketTransport(socket, maxBytes)).catch(() => { socket.destroy(); bridge.abandon('MCP_CONNECT_FAILED'); });
+    });
+    const close = async () => { if (closed)
+        return; closed = true; bridge.close(); await Promise.allSettled([...clients].map(c => c.close())); if (listener.listening)
+        await new Promise(r => listener.close(() => r())); await rm(root, { recursive: true }); };
+    try {
+        const stat = await lstat(root);
+        if (stat.uid !== process.getuid?.() || (stat.mode & 0o077) !== 0)
+            throw Error('TOOLBRIDGE_PRIVATE_DIRECTORY_REQUIRED');
+        await new Promise((yes, no) => { listener.once('error', no); listener.listen(socketPath, () => { listener.removeListener('error', no); yes(); }); });
+        return { mcpServers: [{ name: 'employee', command: '/usr/bin/nc', args: ['-U', socketPath], env: [] }], close };
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-workbench/remote-agent",
-  "version": "0.8.28",
+  "version": "0.9.0-toolbridge.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,7 +36,7 @@
     "zod": "4.6.7"
   },
   "devDependencies": {
-    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.29.tgz",
+    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.37.tgz",
     "@ai-workbench/network": "file:test/fixtures/ai-workbench-network-0.4.9.tgz",
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/cordis-plugin-group": "1.0.4",
@@ -67,7 +67,7 @@
     "@deepseek-ai/dsh-storage-domain": "0.2.0-rc.2"
   },
   "peerDependencies": {
-    "@ai-workbench/connect": "~0.7.29",
+    "@ai-workbench/connect": "~0.7.37",
     "@ai-workbench/network": "~0.4.9",
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
@@ -102,10 +102,11 @@
       "optional": true
     }
   },
-  "description": "通过远程主机运行Claude与Codex会话。",
+  "description": "AI 写作工作台（含工具桥）：远程Claude与Codex，本机目录工具由DSH执行与审批。",
   "publishConfig": {
     "access": "public",
-    "registry": "https://registry.npmjs.org/"
+    "registry": "https://registry.npmjs.org/",
+    "tag": "toolbridge"
   },
   "keywords": [
     "dsh",