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

package/dist/index.js

@@ -1,7 +1,10 @@
+import { ToolBridgeLoop } from "./toolbridge-loop.js";
+import { openToolBridgeMcp, TOOLBRIDGE_NOTICE } from "./toolbridge.js";
 import { connectNeedMessage } from "./connect-need.js";
 import { CloseDiagnostics, withFirstFailureEvidence, failureEvidenceSummary, closeCode } from "./close-diagnostics.js";
 import { withRemoteFailureEvidence } from "./failure-evidence.js";
 import { SessionId } from '@deepseek-ai/dsh-session';
+import { createAssistantMessage } from '@deepseek-ai/dsh-llm';
 import Schema from '@deepseek-ai/schemastery';
 import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
 import { createHash } from 'node:crypto';
@@ -91,6 +94,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
     directory;
     preflightDiagnostics;
     permissions;
+    bridgeLoop;
     config;
     sessions = new Map();
     turns = new Map();
@@ -99,7 +103,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
     detached = new Set();
     modelPresentation = new ModelPresentation();
     employeeNoticeSessions = new Set();
-    constructor(config, resolveRuntime, approve, providerName = () => CODEX_AGENT.name.zh, agent = CODEX_AGENT, readImage, reportLoginFailure, directory, preflightDiagnostics, permissions) {
+    pendingEmployeeNotices = new Set();
+    constructor(config, resolveRuntime, approve, providerName = () => CODEX_AGENT.name.zh, agent = CODEX_AGENT, readImage, reportLoginFailure, directory, preflightDiagnostics, permissions, bridgeStopped) {
         super();
         this.resolveRuntime = resolveRuntime;
         this.approve = approve;
@@ -110,6 +115,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
         this.directory = directory;
         this.preflightDiagnostics = preflightDiagnostics;
         this.permissions = permissions;
+        this.bridgeLoop = new ToolBridgeLoop(readImage, bridgeStopped);
         this.config = typeof config === 'function' ? config : () => config;
     }
     providerInfo(provider) { return { id: provider, name: this.providerName() }; }
@@ -156,7 +162,10 @@ export class CodexRemoteAdapter extends LlmAdapter {
         void Promise.resolve().then(() => runtime.dispose?.(cause)).catch(() => console.warn('[remote-agent] 旧主机会话暂未清理，将由主机自动回收'));
         return Promise.resolve();
     }
+    completeDshTurn(sessionId, messages) { this.sessions.get(sessionId)?.runtime.execution?.endTurn(); return this.bridgeLoop.conclude(sessionId, messages); }
+    hasBridgeSession(sessionId) { return this.bridgeLoop.active(sessionId); }
     async disposeSession(sessionId) {
+        await this.bridgeLoop.cancel(sessionId);
         this.turns.get(sessionId)?.abort();
         const current = this.sessions.get(sessionId);
         if (!current)
@@ -166,6 +175,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
         await this.cleanupRuntime(current.runtime);
     }
     async detachSession(sessionId) {
+        await this.bridgeLoop.cancel(sessionId);
         const current = this.sessions.get(sessionId), turn = this.turns.get(sessionId);
         if (!current && !turn)
             return;
@@ -188,8 +198,10 @@ export class CodexRemoteAdapter extends LlmAdapter {
         for (const live of this.sessions.values())
             live.runtime.closeDiagnostics?.record({ layer: 'adapter', initiator: 'adapter.dispose', reason: 'PLUGIN_DISPOSED', action: 'dispose', changes: [{ field: 'adapter.shutting-down', before: this.shuttingDown, after: true }] });
         this.shuttingDown = true;
+        await this.bridgeLoop.dispose();
         this.modelPresentation.clear();
         this.employeeNoticeSessions.clear();
+        this.pendingEmployeeNotices.clear();
         const results = await Promise.allSettled([...new Set([...this.sessions.keys(), ...this.turns.keys()])].map(id => this.detachSession(id)));
         this.lifetime.abort();
         const failure = results.find(result => result.status === 'rejected');
@@ -197,9 +209,15 @@ export class CodexRemoteAdapter extends LlmAdapter {
             throw failure.reason;
     }
     async *stream(options) {
-        let promptDispatched = false;
+        let promptDispatched = !!options.sessionId && (this.sessions.get(options.sessionId)?.session.promptDispatchCount ?? 0) > 0;
         try {
-            yield* this.generate(options, () => { promptDispatched = true; });
+            for await (const chunk of this.bridgeLoop.stream(options, (o, b) => this.generate(o, () => { promptDispatched = true; }, b))) {
+                if (options.sessionId && this.pendingEmployeeNotices.has(options.sessionId) && chunk.type === 'text-delta' && chunk.text.startsWith(EMPLOYEE_EXECUTION_NOTICE)) {
+                    this.employeeNoticeSessions.add(options.sessionId);
+                    this.pendingEmployeeNotices.delete(options.sessionId);
+                }
+                yield chunk;
+            }
         }
         catch (error) {
             if (error instanceof ModelConfigurationError)
@@ -223,8 +241,12 @@ export class CodexRemoteAdapter extends LlmAdapter {
             }
             throw new LlmError(employeeFailure('TURN_FAILED', this.agent.loginProvider, promptDispatched), 'TURN_FAILED', { cause: error });
         }
+        finally {
+            if (options.sessionId)
+                this.pendingEmployeeNotices.delete(options.sessionId);
+        }
     }
-    async *generate(original, onPromptDispatched) {
+    async *generate(original, onPromptDispatched, bridge) {
         if (original.purpose)
             throw new NeedError('PURPOSE_UNSUPPORTED', '此远程模型不处理后台标题或上下文整理请求，未发送模型请求', '独立的后台请求能力');
         if (this.lifetime.signal.aborted)
@@ -238,6 +260,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
         const signal = AbortSignal.any([this.lifetime.signal, turn.signal, ...(original.signal ? [original.signal] : [])]);
         const options = { ...original, signal };
         const abortOffs = [];
+        let bridgeMcp;
         let request;
         let earlyStage = 'input-prepare';
         let runtime;
@@ -261,7 +284,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 runtime.details.record(entry); };
         const config = this.config();
         const mode = 'session';
-        request = { sessionId: options.sessionId, mode: mode ?? 'session', signal };
+        request = { sessionId: options.sessionId, mode: mode ?? 'session', signal, toolBridge: bridge };
         const observeAbort = (source, initiator, reason) => { if (!source)
             return; const record = () => { (request?.closeDiagnostics ?? runtime?.closeDiagnostics)?.record({ layer: 'adapter', initiator, reason, action: 'abort', changes: [{ field: 'adapter.turn-aborted', before: false, after: source.aborted }] }); }; source.addEventListener('abort', record, { once: true }); abortOffs.push(() => source.removeEventListener('abort', record)); };
         observeAbort(original.signal, 'signal.caller', 'CALLER_ABORTED');
@@ -329,6 +352,10 @@ export class CodexRemoteAdapter extends LlmAdapter {
             if (runtime.hostWorkspace && mode === 'session' && Buffer.byteLength(JSON.stringify({ prompt: input.prompt, systemPrompt: input.systemPrompt }), 'utf8') > config.acpMaxMessageBytes)
                 throw new NeedError('ACP_MESSAGE_TOO_LARGE', '本轮输入超过已设置的会话消息容量，未截断或发送', '管理员调整acpMaxMessageBytes');
             const details = runtime.details ?? await createRemoteDetails({ warn: line => console.warn(line) }).open({ sessionId: options.sessionId ?? 'unscoped', provider: this.agent.loginProvider, identity: runtime.identity, connection: runtime.connection });
+            if (bridge && runtime.employeeExecutionMeta && !runtime.hostWorkspace && bridge.table.size) {
+                bridge.enable(event => details.record(event));
+                bridgeMcp = await openToolBridgeMcp(bridge, config.acpMaxMessageBytes);
+            }
             recordInformation();
             request.recordEarlyFailure = undefined;
             if (input.historyTransfer)
@@ -339,16 +366,22 @@ export class CodexRemoteAdapter extends LlmAdapter {
             activeMapper = mapper;
             let id;
             let stop;
+            const pointerRuntime = runtime;
+            const makePointer = (nativeId) => ({ ...(pointerRuntime.hostSource ? { hostSource: pointerRuntime.hostSource } : {}), ...(modelConfiguration ? { modelConfiguration } : {}), version: 2, agent: this.agent.id, contextSha256, ...(mode === 'session' ? { usageSnapshot: mapper.usageSnapshot } : {}), ...(options.sessionId ? { dshSessionId: options.sessionId } : {}), identity: pointerRuntime.identity, cwd: pointerRuntime.cwd, sessionId: nativeId, ...(pointerRuntime.binding ? { bindingId: pointerRuntime.binding.bindingId, workspaceId: pointerRuntime.binding.workspaceId } : {}) });
             if (runtime.employeePresentation)
                 details.record({ kind: 'session', severity: 'warning', code: 'EMPLOYEE_EXECUTION_SCOPE', summary: runtime.employeePresentation, payload: { source: 'local' } });
             if (runtime.execution)
                 details.record({ kind: 'session', severity: 'warning', code: 'CLAUDE_EMPLOYEE_SCOPE', summary: runtime.execution.notice, payload: runtime.execution.scope });
             if ((runtime.employeePresentation || runtime.execution) && !employeeNoticeShown) {
-                for (const chunk of mapper.text(EMPLOYEE_EXECUTION_NOTICE + '\n\n')) {
+                for (const chunk of mapper.text(EMPLOYEE_EXECUTION_NOTICE + (bridge?.enabled ? '\n\n' + TOOLBRIDGE_NOTICE : '') + '\n\n')) {
                     if (chunk.type === 'text-delta') {
                         employeeNoticeShown = true;
-                        if (key)
-                            this.employeeNoticeSessions.add(key);
+                        if (key) {
+                            if (bridge)
+                                this.pendingEmployeeNotices.add(key);
+                            else
+                                this.employeeNoticeSessions.add(key);
+                        }
                     }
                     yield chunk;
                 }
@@ -363,7 +396,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 let failure;
                 const push = (chunks) => { queue.push(...chunks); wake?.(); wake = undefined; };
                 let promptPermit;
-                const hooks = { closeDiagnostics: runtime.closeDiagnostics, broker: runtime.broker, employeeExecution: runtime.employeeExecution, ...this.permissions ? { promptGuard: () => {
+                let confirmedNativeMode;
+                const hooks = { closeDiagnostics: runtime.closeDiagnostics, broker: runtime.broker, sessionOwnership: runtime.sessionOwnership, employeeExecution: runtime.employeeExecution, ...this.permissions ? { promptGuard: () => {
                             if (!promptPermit)
                                 throw new NeedError('PERMISSION_POLICY_CHANGED', '当前权限没有保持确认，本次没有继续派发。', '当前权限代次和同值回执');
                             return promptPermit;
@@ -373,6 +407,17 @@ export class CodexRemoteAdapter extends LlmAdapter {
                         } } : {}, approve: async (permission, approvalSignal) => {
                         const execution = runtime.execution;
                         const toolName = permission.toolCall.name ?? permission.toolCall._meta?.claudeCode?.toolName;
+                        if (execution && bridge?.enabled && bridge.isBridge(toolName)) {
+                            const current = this.permissions ? permissionMode('claude', this.permissions.read(options.sessionId)) : undefined;
+                            if (current === 'plan') {
+                                details.record({ kind: 'tool', severity: 'info', code: 'TOOLBRIDGE_PLAN_PERMISSION_REJECTED', summary: '本轮为plan档，桥接原生权限请求未放行。' });
+                                return 'rejected';
+                            }
+                            if (current === 'default' && confirmedNativeMode === 'default') {
+                                details.record({ kind: 'tool', severity: 'info', code: 'TOOLBRIDGE_NATIVE_PERMISSION_ANSWERED', summary: '已确认桥接工具仅在DSH审批，原生请求自动答复一次。', payload: { tool: toolName } });
+                                return 'allowed-once';
+                            }
+                        }
                         if (execution) {
                             if (toolName && ['Agent', 'Task', 'TaskOutput', 'TaskStop', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash'].includes(toolName)) {
                                 details.record({ kind: 'need', severity: 'warning', code: 'CLAUDE_HOST_TOOL_UNSUPPORTED', summary: '这类原生调用没有经过员工端别名，本机来源不支持；本次审批已取消', payload: { operation: toolName } });
@@ -383,6 +428,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                         const answer = await this.approve?.(permission, approvalSignal, options, execution && toolName?.startsWith('mcp__employee__') ? 'employee-local' : undefined, runtime.hostWorkspace) ?? 'unavailable';
                         return answer;
                     }, onEmployeeNotice: notice => push(mapper.text(notice + '\n\n')), onUpdate: notification => { try {
+                        bridge?.observe(notification.update);
                         push(mapper.acp(notification.update));
                     }
                     catch (error) {
@@ -412,6 +458,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                         const remoteMode = permissionMode(this.agent.loginProvider, policy);
                         details.record({ kind: 'session', severity: 'info', code: 'DSH_PERMISSION_POLICY', summary: '按DSH当前会话权限同步远程工具；不会把关闭审批提示解释为自动批准。', payload: { ...policy, remoteMode } });
                         await session.selectPermissionMode(remoteMode, modelSignal, this.agent.loginProvider);
+                        confirmedNativeMode = remoteMode;
                         permissionKey = next;
                     });
                 };
@@ -437,7 +484,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 const task = (async () => {
                     remoteAttempted = true;
                     try {
-                        await session.start(runtime.execution?.hostCwd ?? runtime.cwd, previous?.sessionId, modelSignal, { systemPrompt: input.systemPrompt, ...(runtime.execution ? { employeeRouting: runtime.execution.routing } : {}), ...(codex ? { codexNewSessionOnly: true } : {}), ...(runtime.employeeExecutionMeta ? { employeeExecution: runtime.employeeExecutionMeta } : {}) }, input.prompt);
+                        await session.start(runtime.execution?.hostCwd ?? runtime.cwd, previous?.sessionId, modelSignal, { systemPrompt: input.systemPrompt, ...(bridgeMcp ? { toolBridgeServers: bridgeMcp.mcpServers } : {}), ...(runtime.execution ? { employeeRouting: runtime.execution.routing } : {}), ...(codex ? { codexNewSessionOnly: true } : {}), ...(runtime.employeeExecutionMeta ? { employeeExecution: runtime.employeeExecutionMeta } : {}) }, input.prompt);
                     }
                     catch (error) {
                         details.record({ kind: 'session', severity: 'action-required', code: 'SESSION_START_FAILED', summary: '远端会话建立或恢复失败，本轮用户输入未发送。', payload: { operation: previous ? 'resume-or-load' : 'new', reason: closeCode(error, 'ACP_FAILED'), promptDispatched: false } });
@@ -488,9 +535,14 @@ export class CodexRemoteAdapter extends LlmAdapter {
                     recordInformation();
                     details.beginTurn(runtime.detailContext?.() ?? { turn: null, step: null });
                     await runtime.execution?.beginTurn(modelSignal);
+                    if (bridge?.enabled)
+                        bridge.replayState = { response: makePointer(session.id) };
+                    bridge?.begin(modelSignal);
                     id = session.id;
                     try {
                         const result = await dispatchPrompt();
+                        if (bridge?.unsettled)
+                            bridge.abandon('HOST_PROMPT_ENDED_WITH_PENDING_CALL');
                         permissionOff?.();
                         permissionOff = undefined;
                         await permissionTail;
@@ -499,6 +551,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                     finally {
                         permissionOff?.();
                         permissionOff = undefined;
+                        bridge?.end();
                         runtime.execution?.endTurn();
                         details.endTurn();
                     }
@@ -533,13 +586,15 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 }
             }
             yield* mapper.flush();
-            const pointer = { ...(runtime.hostSource ? { hostSource: runtime.hostSource } : {}), ...(modelConfiguration ? { modelConfiguration } : {}), version: 2, agent: this.agent.id, contextSha256, ...(mode === 'session' ? { usageSnapshot: mapper.usageSnapshot } : {}), ...(options.sessionId ? { dshSessionId: options.sessionId } : {}), identity: runtime.identity, cwd: runtime.cwd, sessionId: id, ...(runtime.binding ? { bindingId: runtime.binding.bindingId, workspaceId: runtime.binding.workspaceId } : {}) };
+            const pointer = makePointer(id);
             succeeded = true;
             yield { type: 'finish', reason: { kind: stop === 'max_tokens' || stop === 'max_turn_requests' ? 'max-tokens' : 'stop' }, replayState: { response: pointer } };
         }
         catch (error) {
             if (session && session.promptDispatchCount > promptBaseline)
                 onPromptDispatched();
+            if (bridge?.unsettled && !signal.aborted)
+                bridge.abandon('HOST_PROMPT_FAILED');
             turnFailure = error;
             runtime?.closeDiagnostics?.record({ layer: 'adapter', initiator: 'adapter.turn-failure', reason: closeCode(error, signal.aborted ? 'ABORTED' : 'TURN_FAILED'), action: 'failure' });
             recordInformation();
@@ -559,6 +614,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
             for (const off of abortOffs)
                 off();
             runtime?.execution?.endTurn();
+            if (bridgeMcp)
+                await bridgeMcp.close();
             if (runtime) {
                 session?.close({ layer: 'adapter', initiator: 'adapter.turn-finally', reason: succeeded ? 'TURN_FINISHED' : 'TURN_FAILED', action: 'close' });
                 if (key && this.sessions.get(key) === live)
@@ -575,16 +632,25 @@ export class CodexRemoteAdapter extends LlmAdapter {
 /** One official registration owns both routes, preserving opaque replay ownership. */
 export class RemoteAgentsAdapter extends LlmAdapter {
     adapters = new Map();
-    constructor(config, makeRuntime, approve, nameFor, readImage, reportLoginFailure, directory, preflightDiagnostics, permissions) { super(); for (const agent of AGENTS)
-        this.adapters.set(agent.id, new CodexRemoteAdapter(config, makeRuntime(agent), approve, () => nameFor(agent), agent, readImage, reportLoginFailure, directory, preflightDiagnostics, permissions)); }
+    constructor(config, makeRuntime, approve, nameFor, readImage, reportLoginFailure, directory, preflightDiagnostics, permissions, bridgeStopped) { super(); for (const agent of AGENTS)
+        this.adapters.set(agent.id, new CodexRemoteAdapter(config, makeRuntime(agent), approve, () => nameFor(agent), agent, readImage, reportLoginFailure, directory, preflightDiagnostics, permissions, bridgeStopped)); }
     adapter(provider) { const adapter = this.adapters.get(provider); if (!adapter)
         throw new LlmError('远程模型未注册', 'PROVIDER_NOT_FOUND'); return adapter; }
     providerInfo(provider) { return this.adapter(provider).providerInfo(provider); }
     listModels(provider) { return this.adapter(provider).listModels(provider); }
     resolveModel(provider, model, signal) { return this.adapter(provider).resolveModel(provider, model, signal); }
-    prepareCall(provider, model, signal) { return this.adapter(provider).prepareCall(provider, model, signal); }
+    async prepareCall(provider, model, signal) { const prepared = await this.adapter(provider).prepareCall(provider, model, signal); return { ...prepared, stream: (options) => this.stream(options) }; }
     providerRetryPolicy() { return { mode: 'normal', maxRetries: 0, retryableCodes: [], initialDelayMs: 0, maxDelayMs: 0, jitterRatio: 0 }; }
-    stream(options) { return this.adapter(options.provider).stream(options); }
+    stream(options) {
+        if (options.sessionId)
+            for (const [provider, adapter] of this.adapters)
+                if (provider !== options.provider && adapter.hasBridgeSession(options.sessionId)) {
+                    void adapter.disposeSession(options.sessionId);
+                    throw new LlmError('原主机还在等待DSH工具结果，切换助手已停止原轮次；请核对已执行的工具后重新发送，结果不会重放。', 'TOOLBRIDGE_ROUTE_CHANGED');
+                }
+        return this.adapter(options.provider).stream(options);
+    }
+    async completeDshTurn(sessionId, messages) { await Promise.all([...this.adapters.values()].map(adapter => adapter.completeDshTurn(sessionId, messages))); }
     async disposeSession(sessionId) { await Promise.all([...this.adapters.values()].map(adapter => adapter.disposeSession(sessionId))); }
     async detachSession(sessionId) { await Promise.all([...this.adapters.values()].map(adapter => adapter.detachSession(sessionId))); }
     async dispose() { await Promise.all([...this.adapters.values()].map(adapter => adapter.dispose())); }
@@ -688,7 +754,33 @@ export function apply(ctx, live) {
                 step = null;
         }
         return managerForProfile().recordLoginFailure({ sessionId, code, diagnostic, context: { turn, step } });
-    }, modelDirectory, preflightDiagnostics, dshPermissionSource(ctx));
+    }, modelDirectory, preflightDiagnostics, dshPermissionSource(ctx), (sessionId, notice) => {
+        const agent = ctx.get('agents')?.get(SessionId(sessionId));
+        if (!agent)
+            return;
+        let turn = null, step = null;
+        for (const e of agent.session.snapshotEvents()) {
+            if (e.type === 'turn/start') {
+                turn = e.data.turn;
+                step = null;
+            }
+            else if (e.type === 'turn/end') {
+                turn = null;
+                step = null;
+            }
+            else if (e.type === 'step/start')
+                step = e.data.step;
+            else if (e.type === 'step/end')
+                step = null;
+        }
+        if (turn !== null && step !== null)
+            agent.session.append('assistant/message', { turn, step, message: createAssistantMessage({ content: [{ type: 'text', text: notice }], source: { provider: 'ai-workbench-toolbridge', model: 'notice' } }), stream: [] }, { surfaceOp: 'append' });
+        agent.cancel({ kind: 'hook', reason: 'DSH_BRIDGE_CALL_ABANDONED_BY_HOST' }, { keepInbox: true });
+    });
+    ctx.on('session/event', (session, event) => { if (event.type === 'turn/end') {
+        const operation = event.data.reason.kind === 'completed' ? adapter.completeDshTurn(session.id, session.deriveMessages()) : adapter.disposeSession(session.id);
+        void operation.catch(() => ctx.logger('remote-agent').warn('TOOLBRIDGE_RESULT_DELIVERY_UNCONFIRMED'));
+    } });
     const ids = AGENTS.map(agent => agent.id);
     const entries = () => AGENTS.map(agent => ({ provider: agent.id, displayName: agent.name[language], settingsNs: actualSettingsNamespace ?? settingsNamespace, settingsPath: [] }));
     const directory = ctx.llm.registerConfigurableProviders(entries());

package/dist/presentation.js

@@ -42,6 +42,9 @@ export function employeeFailure(code, brand = 'codex', promptDispatched = true)
         POLICY_DENIED: '这个账号暂时不能使用，请联系公司账号管理员。',
         SESSION_CONTEXT_MISMATCH: '远程主机连接已改变，请重新开始本次检查。',
         REMOTE_SESSION_BUSY: '原会话仍被主机上的上一轮占用，' + (promptDispatched ? '本轮请求未能完成' : '本轮输入未发送') + '；请稍后在原会话重新发送。若持续占用，请联系管理员检查上一轮主机会话。',
+        BROKER_OWNERSHIP_UNAVAILABLE: '主机会话组件缺少安全续接能力，本轮输入未发送；请联系管理员更新主机组件。',
+        BROKER_OWNERSHIP_UNCONFIRMED: '主机尚未确认这条会话的归属，本轮输入未发送；请检查远程主机连接后在原会话重试。',
+        BROKER_OWNERSHIP_INVALID: '远端会话编号无法确认，本轮输入未发送；请联系管理员查看技术详情。',
         ABORTED: promptDispatched ? '本轮已停止。操作可能已部分执行，请先确认文件；恢复连接后可在原会话继续。' : '本轮已停止，本轮输入未发送；恢复连接后可在原会话重新发送。',
         CONFIRMATION_REQUIRED: '请先选择是否打开授权窗口。',
         CONTEXT_UNSUPPORTED: '远程 Codex 暂不支持这类会话内容，请联系管理员。',

package/dist/provider.d.ts

@@ -1,3 +1,4 @@
+import type { ToolBridge } from './toolbridge.ts';
 import { type SessionSource } from './host-workspace.ts';
 import type { CloseCause, CloseDiagnostics } from './close-diagnostics.ts';
 import type { AgentApp } from '@agentclientprotocol/sdk';
@@ -14,6 +15,7 @@ import type { SourceAdmissionStage } from './workspace-source.ts';
 import type { LocalWorkspaceContext } from '@ai-workbench/connect/api';
 import type { EmployeeRouting } from './employee-relay.ts';
 import type { HostWorkspacePresentation } from './input.ts';
+import type { SessionOwnership } from './broker-ownership.ts';
 export interface EmployeeExecution {
     hostCwd: string;
     routing: EmployeeRouting;
@@ -37,6 +39,7 @@ export interface Runtime {
         readable: ReadableStream<Uint8Array>;
     } | AgentApp | ExtendedAgentApp;
     broker?: BrokerTransport;
+    sessionOwnership?: SessionOwnership;
     loginRequired?: () => Promise<void>;
     dispose?: (cause?: CloseCause) => Promise<void>;
     binding?: {
@@ -64,6 +67,7 @@ export interface Runtime {
     closeDiagnostics?: CloseDiagnostics;
 }
 export interface RuntimeRequest extends Invocation {
+    toolBridge?: ToolBridge;
     workspaceSource?: SessionSource;
     hostSource?: Extract<SessionSource, {
         source: 'host';

package/dist/toolbridge-loop.d.ts

@@ -0,0 +1,19 @@
+import { type GenerateOptions, type StreamChunk } from '@deepseek-ai/dsh-llm';
+import { ToolBridge } from './toolbridge.ts';
+import type { ImageReader } from './input.ts';
+type Producer = (options: GenerateOptions, bridge: ToolBridge) => AsyncGenerator<StreamChunk>;
+/** Owns the original prompt across official generate/tool/generate steps. No tool execution. */
+export declare class ToolBridgeLoop {
+    private readImage?;
+    private stopped?;
+    private runs;
+    private concluding;
+    constructor(readImage?: ImageReader | undefined, stopped?: ((sessionId: string, notice: string) => void) | undefined);
+    private launch;
+    conclude(id: string, messages: GenerateOptions['messages']): Promise<void>;
+    active(id: string): boolean;
+    cancel(id: string): void;
+    dispose(): Promise<void>;
+    stream(options: GenerateOptions, producer: Producer): AsyncGenerator<StreamChunk>;
+}
+export {};

package/dist/toolbridge-loop.js

@@ -0,0 +1,251 @@
+import { createAssistantMessage } from '@deepseek-ai/dsh-llm';
+import { ToolBridge } from "./toolbridge.js";
+import { NeedError } from "./remote.js";
+/** Rebase native text blocks at each DSH step; a parked stream must end all open blocks. */
+class Projection {
+    blocks = new Map();
+    next = 0;
+    chunks(chunk) {
+        if (chunk.type === 'block-start') {
+            if (chunk.blockType !== 'text' && chunk.blockType !== 'reasoning')
+                throw Error('TOOLBRIDGE_NATIVE_BLOCK_UNSUPPORTED');
+            this.blocks.set(chunk.index, { type: chunk.blockType, text: '' });
+            return [];
+        }
+        if (chunk.type === 'text-delta' || chunk.type === 'reasoning-delta') {
+            const block = this.blocks.get(chunk.index);
+            if (!block)
+                throw Error('TOOLBRIDGE_NATIVE_BLOCK_MISSING');
+            const result = [];
+            if (block.index === undefined) {
+                block.index = this.next++;
+                result.push({ type: 'block-start', index: block.index, blockType: block.type });
+            }
+            const text = chunk.type === 'text-delta' ? chunk.text : chunk.text;
+            block.text += text;
+            result.push({ ...chunk, index: block.index });
+            return result;
+        }
+        if (chunk.type === 'block-end') {
+            const block = this.blocks.get(chunk.index);
+            this.blocks.delete(chunk.index);
+            return block?.index === undefined ? [] : [{ type: 'block-end', index: block.index, block: { type: block.type, text: block.text } }];
+        }
+        return [chunk];
+    }
+    park() { const chunks = []; for (const block of this.blocks.values())
+        if (block.index !== undefined) {
+            chunks.push({ type: 'block-end', index: block.index, block: { type: block.type, text: block.text } });
+            block.index = undefined;
+            block.text = '';
+        } return chunks; }
+}
+/** Owns the original prompt across official generate/tool/generate steps. No tool execution. */
+export class ToolBridgeLoop {
+    readImage;
+    stopped;
+    runs = new Map();
+    concluding = new Map();
+    constructor(readImage, stopped) {
+        this.readImage = readImage;
+        this.stopped = stopped;
+    }
+    launch(options, producer) {
+        const controller = new AbortController(), bridge = new ToolBridge(options, this.readImage);
+        const run = { bridge, controller, options, latest: options, queue: [], wake: Promise.withResolvers(), done: false, task: undefined, seen: new Set(options.messages.flatMap(m => 'id' in m && typeof m.id === 'string' ? [m.id] : [])), deferred: [], text: '', reading: false, projection: new Projection(), off: () => { } };
+        const signal = AbortSignal.any([controller.signal, ...options.signal ? [options.signal] : []]);
+        const changed = () => { run.wake.resolve(); };
+        bridge.changed = changed;
+        bridge.onAbandon = notice => { controller.abort(); if (options.sessionId)
+            this.stopped?.(options.sessionId, notice); };
+        const abort = () => { bridge.close(); changed(); };
+        signal.addEventListener('abort', abort, { once: true });
+        run.off = () => signal.removeEventListener('abort', abort);
+        run.task = (async () => {
+            try {
+                for await (const chunk of producer({ ...options, signal }, bridge)) {
+                    if (chunk.type === 'finish') {
+                        run.finish = chunk;
+                        continue;
+                    }
+                    if (chunk.type === 'text-delta')
+                        run.text += chunk.text;
+                    run.queue.push(chunk);
+                    changed();
+                }
+                if (bridge.unsettled)
+                    bridge.abandon('HOST_PROMPT_ENDED_WITH_PENDING_CALL');
+            }
+            catch (error) {
+                run.error = error;
+                if (bridge.unsettled)
+                    bridge.abandon('HOST_PROMPT_FAILED');
+            }
+            finally {
+                run.done = true;
+                changed();
+            }
+        })();
+        return run;
+    }
+    async conclude(id, messages) {
+        const existing = this.concluding.get(id);
+        if (existing)
+            return existing.flight;
+        const run = this.runs.get(id);
+        if (!run || !run.bridge.enabled || !run.bridge.unsettled) {
+            this.cancel(id);
+            return;
+        }
+        this.runs.delete(id);
+        run.bridge.beginConclude();
+        run.bridge.onConcludeAcknowledged = () => run.controller.abort();
+        const flight = (async () => {
+            try {
+                await run.bridge.results({ ...run.latest, messages, signal: run.controller.signal });
+                await run.task;
+                if (run.error && !run.bridge.concludeAcknowledged)
+                    throw run.error;
+            }
+            catch (error) {
+                run.bridge.close();
+                run.controller.abort();
+                throw error;
+            }
+            finally {
+                run.off();
+            }
+        })();
+        this.concluding.set(id, { run, flight });
+        void flight.then(() => { if (this.concluding.get(id)?.flight === flight)
+            this.concluding.delete(id); }, () => { });
+        await flight;
+    }
+    active(id) { return (this.runs.get(id)?.bridge.enabled ?? false) || this.concluding.has(id); }
+    cancel(id) {
+        const closing = this.concluding.get(id);
+        if (closing) {
+            this.concluding.delete(id);
+            closing.run.bridge.close();
+            closing.run.controller.abort();
+            closing.run.off();
+        }
+        const run = this.runs.get(id);
+        if (!run)
+            return;
+        this.runs.delete(id);
+        run.bridge.close();
+        run.controller.abort();
+        run.off();
+    }
+    async dispose() { for (const id of new Set([...this.runs.keys(), ...this.concluding.keys()]))
+        this.cancel(id); }
+    async *stream(options, producer) {
+        const key = options.sessionId ?? '';
+        const closing = this.concluding.get(key);
+        if (closing) {
+            let aborted;
+            try {
+                await Promise.race([closing.flight, ...(options.signal ? [new Promise((_r, reject) => { aborted = () => reject(new NeedError('ABORTED', '本轮等待已取消，尚未发送新输入。', '原主机prompt收尾')); options.signal.addEventListener('abort', aborted, { once: true }); if (options.signal.aborted)
+                            aborted(); })] : [])]);
+            }
+            catch (error) {
+                if (this.concluding.get(key) === closing)
+                    this.cancel(key);
+                else {
+                    closing.run.bridge.close();
+                    closing.run.controller.abort();
+                    closing.run.off();
+                }
+                throw error;
+            }
+            finally {
+                if (aborted)
+                    options.signal?.removeEventListener('abort', aborted);
+                if (this.concluding.get(key) === closing)
+                    this.concluding.delete(key);
+            }
+        }
+        let run = this.runs.get(key), boundary = false;
+        if (run?.reading)
+            throw new NeedError('TURN_BUSY', '工具桥仍在处理当前生成步骤。', '等待当前步骤结束');
+        if (!run) {
+            run = this.launch(options, producer);
+            if (key)
+                this.runs.set(key, run);
+        }
+        run.reading = true;
+        run.projection.next = 0;
+        try {
+            if (options.signal?.aborted)
+                throw new NeedError('ABORTED', '本轮已取消，工具结果没有重放。', '确认主机取消状态');
+            if (run.latest !== options) {
+                for (const m of options.messages)
+                    if (m.role === 'user' && 'source' in m && m.source?.kind === 'user' && 'id' in m && typeof m.id === 'string' && !run.seen.has(m.id)) {
+                        run.seen.add(m.id);
+                        run.deferred.push(m);
+                    }
+                run.latest = options;
+                await run.bridge.results(options);
+            }
+            for (;;) {
+                const wake = run.wake;
+                run.wake = Promise.withResolvers();
+                while (run.queue.length)
+                    yield* run.projection.chunks(run.queue.shift());
+                if (run.error)
+                    throw run.error;
+                if (run.bridge.pending.length && !run.done) {
+                    yield* run.projection.park();
+                    for (const p of run.bridge.pending) {
+                        p.exported = true;
+                        const index = run.projection.next++;
+                        yield { type: 'block-start', index, blockType: 'tool-call' };
+                        yield { type: 'tool-call-delta', index, id: p.block.id, name: p.block.name, argumentsDelta: p.block.arguments };
+                        yield { type: 'block-end', index, block: p.block };
+                    }
+                    boundary = true;
+                    yield { type: 'finish', reason: { kind: 'tool-calls' }, ...(run.bridge.replayState ? { replayState: run.bridge.replayState } : {}) };
+                    return;
+                }
+                if (run.done) {
+                    yield* run.projection.park();
+                    run.off();
+                    if (run.deferred.length) {
+                        const deferred = run.deferred, ids = new Set(deferred.flatMap(m => 'id' in m ? [m.id] : []));
+                        const last = createAssistantMessage({ content: run.text ? [{ type: 'text', text: run.text }] : [], source: { provider: run.options.provider, model: run.options.model, ...(run.finish?.replayState ? { replayState: { response: run.finish.replayState.response } } : {}) } });
+                        const next = { ...options, messages: [...run.latest.messages.filter(m => !('id' in m && ids.has(m.id))), last, ...deferred] };
+                        const nextIndex = run.projection.next;
+                        run.bridge.close();
+                        run = this.launch(next, producer);
+                        run.projection.next = nextIndex;
+                        run.reading = true;
+                        if (key)
+                            this.runs.set(key, run);
+                        continue;
+                    }
+                    if (key)
+                        this.runs.delete(key);
+                    run.bridge.close();
+                    boundary = true;
+                    yield run.finish ?? { type: 'finish', reason: { kind: 'stop' } };
+                    return;
+                }
+                if (options.signal?.aborted)
+                    throw new NeedError('ABORTED', '本轮已取消，工具结果没有重放。', '确认主机取消状态');
+                await Promise.race([wake.promise, run.wake.promise]);
+            }
+        }
+        finally {
+            run.reading = false;
+            if (!boundary || options.signal?.aborted) {
+                run.bridge.close();
+                run.controller.abort();
+                run.off();
+                if (key && this.runs.get(key) === run)
+                    this.runs.delete(key);
+                await run.task;
+            }
+        }
+    }
+}

package/dist/toolbridge-table.d.ts

@@ -0,0 +1,10 @@
+import type { ToolSchema } from '@deepseek-ai/dsh-llm';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+/** Fixed official tool names; no description heuristics or plugin-name branches. */
+export declare const TOOLBRIDGE_EXCLUDED: readonly ["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"];
+export interface BridgeTool {
+    alias: string;
+    schema: ToolSchema;
+    wire: Tool;
+}
+export declare function bridgeTable(tools?: readonly ToolSchema[]): ReadonlyMap<string, BridgeTool>;