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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (46) hide show
  1. package/README.md +23 -8
  2. package/dist/acp.d.ts +13 -1
  3. package/dist/acp.js +101 -16
  4. package/dist/broker-runtime.d.ts +2 -0
  5. package/dist/broker-runtime.js +52 -3
  6. package/dist/broker.d.ts +56 -1
  7. package/dist/broker.js +300 -10
  8. package/dist/claude-local.js +26 -5
  9. package/dist/client.js +1 -1
  10. package/dist/close-diagnostics.d.ts +1 -1
  11. package/dist/close-diagnostics.js +1 -1
  12. package/dist/cold-protocol.d.ts +17 -0
  13. package/dist/cold-protocol.js +358 -0
  14. package/dist/cold-recovery.d.ts +63 -0
  15. package/dist/cold-recovery.js +598 -0
  16. package/dist/cold-store.d.ts +100 -0
  17. package/dist/cold-store.js +29 -0
  18. package/dist/employee-endpoint.js +15 -1
  19. package/dist/employee-mcp.js +1 -1
  20. package/dist/employee-provider.js +26 -6
  21. package/dist/employee-relay.js +148 -1
  22. package/dist/employee-shell.d.ts +2 -0
  23. package/dist/employee-shell.js +22 -19
  24. package/dist/employee-tools.js +2 -2
  25. package/dist/employee-workspace.d.ts +20 -4
  26. package/dist/employee-workspace.js +26 -5
  27. package/dist/index.d.ts +12 -3
  28. package/dist/index.js +205 -40
  29. package/dist/input.js +4 -1
  30. package/dist/live-steering.d.ts +46 -0
  31. package/dist/live-steering.js +45 -0
  32. package/dist/model-catalog.d.ts +2 -0
  33. package/dist/model-catalog.js +5 -1
  34. package/dist/preflight-diagnostic.js +1 -1
  35. package/dist/presentation.js +1 -0
  36. package/dist/provider.d.ts +13 -0
  37. package/dist/rpc-namespace.js +16 -2
  38. package/dist/session-source.d.ts +3 -1
  39. package/dist/session-source.js +2 -1
  40. package/dist/toolbridge-loop.d.ts +3 -2
  41. package/dist/toolbridge-loop.js +4 -2
  42. package/dist/toolbridge-table.d.ts +4 -3
  43. package/dist/toolbridge-table.js +15 -5
  44. package/dist/toolbridge.d.ts +1 -1
  45. package/dist/toolbridge.js +4 -4
  46. package/package.json +23 -16
package/README.md CHANGED
@@ -1,14 +1,25 @@
1
- # AI Workbench 远程助手 · @ai-workbench/remote-agent@0.9.0-toolbridge.2 · 插件 → 添加插件
1
+ # AI Workbench 远程助手 · @ai-workbench/remote-agent@0.9.0-toolbridge.20 · 插件 → 添加插件
2
2
 
3
3
  ## 含工具桥预发布线
4
4
 
5
- 本包为 `0.9.0-toolbridge.2`,在独立 `toolbridge` 分支开发;稳定 main/0.8.x 和原总包保持原样。员工安装由连接组件提供的「AI 写作工作台(含工具桥)」总包,与不含工具桥的版本二选一。预发布渠道为 `toolbridge`,本轮仅提供本地固定包,不发布 npm。
5
+ 本包为 `0.9.0-toolbridge.20`,从 `v0.9.0-toolbridge.14` 派生,使用 `host-toolbridge` 发布渠道。员工安装由连接组件提供的「AI 写作工作台(含工具桥)」总包 `@ai-workbench/workbench-toolbridge@0.1.17`,与不含工具桥的版本二选一。
6
6
 
7
- 选择本机文件夹后,Claude 和 Codex 可以把 DSH 已启用的 MCP、web、skill、ask_user、todo/present/goal 等工具交给 DSH 原生执行和审批。内置文件/命令、子代理/agent-team、run_code 不在桥接表;原有文件和命令执行方式保留。plan 不自动放行桥接权限;default 下 Claude 的桥接原生权限由插件单次应答,员工只在 DSH 审批实际工具。主机文件夹不开放工具桥。
7
+ 本轮增加两家运行中插话(DSH 原生 nextStep),保留官方队列和原话;明确 followup 仍排下一轮。Codex 含桥组件需 `2.2.2-aw.12`,Claude 仍为官方 `0.94.0`。插件确定消息未发出时保留排队资格;送达未确认时明确报错且不重放。已注入旧正文不能撤回,编辑版下一步骤交付。
8
+
9
+ host `0.8.11` 的新 broker 支持同一客户端/SDK 在切网后按输出游标和输入 ACK 水位接回原 prompt、结果及用量,不重新发送原 prompt;旧本机执行端失效仍为 UNKNOWN,不用新进程替换或重放旧操作。客户端完全退出、崩溃后,重新打开同一 DSH 会话会自动接回已持久登记的原 prompt,显示未落盘输出并取回原结果、增量用量。原 prompt 只执行一次;旧审批仅取消,不复活未知本机执行。旧运行 broker 和 X.14 在途轮不会被安装自动补造冷恢复记录。无新增设置;512,000,000 字节默认保留,实际协议头计入同一容量。
10
+
11
+ 原轮正常完成(或冷接回已交付原结果)后结束该轮主机 broker,原生线程写锁随之释放,同一 DSH 会话下一轮不再因旧轮保留 10 分钟而报“原会话仍被占用”;结果未定(插件退出、断开、失败)时仍保留原轮待接回。旧 X.14–.16 发出的结束请求在主机上始终不生效,只有升级本包才消除;只升主机不够。
12
+
13
+ 本机文件夹下的主机 Claude 可以开自己的子代理(原生 Agent 与 TaskStop),子代理还能再开子代理,插件不加层数或次数限制。子代理继承同一工具表:原生 Read/Write/Edit/Glob/Grep/Bash 仍关闭,文件和命令只走员工本机工具并按原审批;工具桥的 DSH 工具同样可用。子代理的工具事件进技术详情,结论由主 Claude 在原回复里给出;取消本轮会一并结束子代理。Claude 原生的 SendMessage/ListAgents 不开放(DSH 同名的 send_message/list_agents 见下段),因为它们能触及主机账号的其他本地和云端会话;子代理完成后结果仍自动交回主 Claude。主机文件夹本就允许,行为不变。Codex 自身的多代理功能本线没有关闭(层数和线程数是 Codex 上游默认值,插件不改)。
14
+
15
+ 任何 agent 都可以调用其他 agent:本机文件夹下的主机 Claude/Codex 经工具桥使用 DSH 自带的子代理工具(subagent、subagent_fork、list_subagent_models、send_message、interrupt_agent、list_agents、wait_agent、spawn_teammate、team_task_*、workflow 及后台任务 job_output/job_list/job_kill),由 DSH 执行、审批、显示子代理卡片和交回结果。被调方可以是主机 Claude 新会话、主机 Codex 新会话或员工在 DSH 配好的模型;跨品牌路由需员工在 DSH 子代理设置里允许。DSH 的子会话不是工作区成员,插件沿 live 的 parentSession 找到最近一个登记在工作区里的祖先会话,按它的工作区执行(子会话 cwd 仍须等于该工作区,本机/主机文件夹同样适用);子会话有自己的主机原生会话、broker、冷接回记录,文件和命令照常走员工本机或所选主机目录。层数、并发由 DSH 自己的用户设置决定,插件不加任何层数、并发、次数或预算限制,也不改 DSH 设置。主机文件夹不开放工具桥,所以主机文件夹下的主机 Claude/Codex 只能用自己的原生子代理,作为被调方时由 DSH 子代理派出。
16
+
17
+
18
+ 选择本机文件夹后,Claude 和 Codex 可以把 DSH 已启用的 MCP、web、skill、ask_user、todo/present/goal 等工具交给 DSH 原生执行和审批。DSH 内置文件/命令、终端、run_code 不经工具桥转交;DSH 子代理/agent-team/workflow/后台任务工具经工具桥交给 DSH;原有文件和命令执行方式保留。plan 不自动放行桥接权限;default 下 Claude 的桥接原生权限由插件单次应答,员工只在 DSH 审批实际工具。主机文件夹不开放工具桥。
8
19
 
9
20
  工具表按每次主机连接生成快照,新增/移除在下一次连接生效;不承诺 Codex 当前 MCP 会话热刷新。审批期间的插话等当前主机 prompt 结束后再发,停泊中切换助手会停止原轮次并明确提示。工具主动结束DSH轮次时,已提交结果仍交回原agent;确认原生工具收到后结束原prompt,下一条沿原线程继续,不在已关闭步骤追加模型回复。取消和主机结束等待后的结果不重放;工具已执行的副作用不能因取消而撤销,请按说明核对。图片结果由官方附件组件读取后交回。
10
21
 
11
- Codex 需要 S 后续安装的独立受保护命令 `/usr/local/aw-host/bin/codex-acp-toolbridge`(aw.7),不会替换原 codex-acp/aw.6;Claude命令不变。指定桥接 server 的等待为 owner 确认的 **1800 秒**、审批交 DSH;不改其他 server 或全局策略,不新增设置项。N0.4.9、L0.7.37沿既有公开合同;真实界面/员工验收由编排安排。完整合同和证据见 `docs/contracts/codex-toolbridge.md`、`docs/evidence/2026-10-26-toolbridge/REPORT.md`。
22
+ Codex 需要 S 后续安装的独立受保护命令 `/usr/local/aw-host/bin/codex-acp-toolbridge`(aw.8),不会替换原 codex-acp/aw.6;Claude命令不变。指定桥接 server 的等待为 owner 确认的 **1800 秒**、审批交 DSH;不改其他server的调用时限,不新增插件设置项。含桥的本机Codex会话按原生规则等各扩展现有启动时限结算后再捕获工具;启动失败会明确说明,文件和命令仍按原方式执行,本轮不自动重试。N0.4.9、L0.7.37沿既有公开合同;真实界面/员工验收由编排安排。完整合同和本轮启动修复证据见 `docs/contracts/codex-toolbridge.md`、`docs/evidence/2026-10-27-toolbridge-startup/REPORT.md`。
12
23
 
13
24
  通过官方 DSH 插件入口使用 Claude(远程主机)与 Codex(远程主机)。登录和工作区来源由“远程主机连接”组件提供;员工在原生工作区和模型菜单中选择文件夹与型号。
14
25
 
@@ -16,13 +27,17 @@ Codex 需要 S 后续安装的独立受保护命令 `/usr/local/aw-host/bin/code
16
27
 
17
28
  需要远程主机连接组件 0.7.37 或更新的 0.7.x、联网助手 0.4.9,以及支持公开会话归属接口的主机组件 S0.4.26。主机来源保存于官方 storage.domain 的会话元数据表,每轮仅由连接组件检查一次主机目录,不检查本机占位目录。
18
29
 
19
- Claude 本机 Bash 会单独消费员工桥代理的控制诊断,不把它交给模型当作命令输出;真实传输中断仍提示结果未知。命令自身的标准输出、标准错误与退出码照常返回。
30
+ Claude 员工MCP的stdio通道保持在当前原生客户端上。底层员工SSH/Unix流断开时,在途工具只返回结果未知,不重放;连接恢复后下一次新工具调用串行重新连接并初始化。同一DSH会话无需新建;若连接/绑定已撤销或DSH桥工具在途结束本轮,网络恢复后在原会话发新消息,沿原生编号续接。只使用原已核验的设备/账户/绑定,不跨代偷接。
31
+
32
+ DSH技能工具仅使用DSH公布的目录,主机原生技能按各自原生指令加载;本机文件夹下主机 Claude 的主会话和子代理都能用原生 Skill 加载主机账户的用户级技能(0.9.0-toolbridge.20 起),技能里的 `!` 内联命令需要原生 Bash,原生 Bash 仍关闭,所以不会在主机执行,该技能加载失败并明确报错;工具描述标明目录快照与返回的资源基址。
33
+
34
+ Claude 本机 Bash 会单独消费员工桥代理的控制诊断,不把它交给模型当作命令输出;真实传输中断仍提示结果未知。命令自身的标准输出、标准错误与退出码照常返回。非UTF-8流不拒绝,按原始字节base64返回并增加对应stdoutEncoding/stderrEncoding标记;有效UTF-8格式不变。没有新增原始字节上限,编码后的消息沿既有512MB容量核验。
20
35
 
21
36
  模型列表读取会随连接状态或连接代际变化取消,连接恢复时通过官方机制刷新。目录失败原因写入当前 profile 的 `ai-workbench-remote-agent/logs/model-catalog.jsonl`(脱敏);未增加单次读取时限或重试。
22
37
 
23
38
  ## 会话行为
24
39
 
25
- 每轮启动一个新助手进程,按原生会话编号恢复上下文;不接回旧进程或重放上一轮输入。主机会话始终使用创建时保存的主机和目录;工作区之后的选择只影响新会话。
40
+ 新的用户轮启动一个新助手进程,按原生会话编号恢复上下文;退出前尚未结算的原轮则附着原进程,仅取回该轮输出、结果和用量,不重发原输入。主机会话始终使用创建时保存的主机和目录;工作区之后的选择只影响新会话。
26
41
 
27
42
  同一 DSH 会话切换 Claude/Codex 时,切回会接本品牌最近的远端会话,并补充它尚未见过的可见对话;首次使用某品牌则带入全部可见历史。工具内部状态、推理和技术详情不转交。历史超出既有 `acpMaxMessageBytes` 容量时,只带能容纳的最近完整轮,并在技术详情说明省略数量;当前输入保持完整,超限仍明确失败。没有新增设置、重试或时限。
28
43
 
@@ -47,7 +62,7 @@ Codex 员工端只使用随包提供的原生组件,通道等待本次组件
47
62
 
48
63
  | 参数 | 默认值 | 作用 |
49
64
  | --- | ---: | --- |
50
- | acpMaxMessageBytes | 4194304 | 会话消息容量 |
65
+ | acpMaxMessageBytes | 512000000 | 会话消息容量;默认512 MB(十进制),自有Codex适配器接收参数另留协议外壳余量;不代表模型上下文或上游Claude适配器承诺 |
51
66
  | brokerMaxFrameBytes | 2097152 | 主机回传单段容量 |
52
67
  | brokerControlMaxBytes | 1048576 | 主机会话管理回复容量 |
53
68
  | employeeShellKillGraceMs | 1000 | 本机命令连接取消后的清理宽限毫秒 |
@@ -56,7 +71,7 @@ Codex 员工端只使用随包提供的原生组件,通道等待本次组件
56
71
 
57
72
  ## 技术详情与交付
58
73
 
59
- 技术详情只写官方 profile 下本地私有日志,并由既有技术详情界面展开显示。写入失败不覆盖原始错误、不等待远端投递回执。每个运行环境只记录首次关闭原因;首先观察到的原因不自动等同跨层根因。
74
+ 技术详情只写官方 profile 下本地私有日志,并由既有技术详情界面展开显示。写入失败不覆盖原始错误、不等待远端投递回执。连接与独立工具操作分别保留首次关闭原因,普通工具退出不再占用连接首因;首先观察到的原因不自动等同跨层根因。
60
75
 
61
76
  工程验证和独立审查见 `docs/evidence/2026-10-25-X-host-source-v2/`;AUTH profile 夹具补齐与最终 main 全套复验见其中的 `auth-profile-return.md`。固定包摘要及真实设备验收状态以项目 X 回执为准。插件不修改 DSH 核心,不添加启动器或自定义 profile。
62
77
 
package/dist/acp.d.ts CHANGED
@@ -10,7 +10,7 @@ import type { SessionOwnership } from './broker-ownership.ts';
10
10
  export type ApprovalOutcome = 'allowed-once' | 'rejected' | 'cancelled' | 'unavailable';
11
11
  export interface AcpHooks {
12
12
  closeDiagnostics?: CloseDiagnostics;
13
- onUpdate?: (notification: acp.SessionNotification) => void;
13
+ onUpdate?: (notification: acp.SessionNotification, originSequence?: number) => void;
14
14
  onResponse?: (response: acp.PromptResponse) => void;
15
15
  approve?: (request: acp.RequestPermissionRequest, signal?: AbortSignal) => Promise<ApprovalOutcome>;
16
16
  /** A grant belongs to the exact official permission generation that asked it. */
@@ -53,6 +53,10 @@ export declare class AcpSession {
53
53
  private turnSignal?;
54
54
  private turnToken?;
55
55
  private busy;
56
+ private steeringSupported;
57
+ private dispatchedSteers;
58
+ get canSteer(): boolean;
59
+ get steerDispatchCount(): number;
56
60
  private startAttempted;
57
61
  private negotiated;
58
62
  private method?;
@@ -96,6 +100,12 @@ export declare class AcpSession {
96
100
  private detail;
97
101
  private employeeNoticeNames;
98
102
  private employeeNoticeUnshown;
103
+ private employeeBridge;
104
+ private pendingBridgeStartupFailures;
105
+ private bridgeStartupFailed;
106
+ private bridgeStartupNoticeDelivered;
107
+ private confirmBridgeStartupFailure;
108
+ private flushBridgeStartupNotice;
99
109
  private employeeInfo;
100
110
  private need;
101
111
  constructor(transport: acp.Stream | acp.AgentApp | stable.AgentApp, hooks: AcpHooks);
@@ -112,6 +122,8 @@ export declare class AcpSession {
112
122
  start(cwd: string, resumeId?: string, signal?: AbortSignal, context?: AcpStartContext, prompt?: acp.ContentBlock[]): Promise<string>;
113
123
  /** Codex context is immutable after creation; keep the old remote session intact. */
114
124
  prompt(input: string | acp.ContentBlock[], signal?: AbortSignal): Promise<acp.StopReason>;
125
+ steer(prompt: acp.ContentBlock[], signal?: AbortSignal, isCurrent?: () => boolean, maxBytes?: number): Promise<'injected' | 'promptRequired'>;
115
126
  close(cause?: CloseCause, error?: Error): void;
116
127
  }
117
128
  export declare function acpNeed(error: unknown): NeedError;
129
+ export declare const isKnownAcpUpdate: (update: unknown) => boolean;
package/dist/acp.js CHANGED
@@ -7,7 +7,10 @@ import { employeeFailure } from "./presentation.js";
7
7
  import { isolateRpcIds } from "./rpc-namespace.js";
8
8
  import { sanitizeObservation, sanitizeDisplayLabel } from "./conversation-details.js";
9
9
  import { ModelConfiguration, ModelConfigurationError } from "./model-configuration.js";
10
- function employeeClaudeOptions(routing) { return { tools: [], disallowedTools: ['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash', 'Agent', 'Task', 'TaskOutput', 'TaskStop'], toolAliases: structuredClone(routing.toolAliases) }; }
10
+ // Native subagents stay on (Agent/TaskStop): children inherit this tool pool, deny rules and the employee MCP aliases, so their files/commands also run on the employee device.
11
+ // Skill stays on for the main session and subagents; a skill's `!` inline command needs native Bash, which stays disallowed, so it never runs on the host.
12
+ // SendMessage/ListAgents stay off: they also reach other local and cloud sessions of the host account.
13
+ function employeeClaudeOptions(routing) { return { tools: ['Agent', 'TaskStop', 'Skill'], disallowedTools: ['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash'], toolAliases: structuredClone(routing.toolAliases) }; }
11
14
  const permissionRanks = { claude: { plan: 0, default: 1, acceptEdits: 1, bypassPermissions: 2 }, codex: { 'read-only': 0, 'workspace-write': 1, agent: 1, 'agent-full-access': 2 } };
12
15
  /** ACP v1 with explicitly negotiated SDK 2.0 lifecycle/context extensions. */
13
16
  export class AcpSession {
@@ -18,6 +21,10 @@ export class AcpSession {
18
21
  turnSignal;
19
22
  turnToken;
20
23
  busy = false;
24
+ steeringSupported = false;
25
+ dispatchedSteers = 0;
26
+ get canSteer() { return this.steeringSupported && this.busy && !this.closeRequested; }
27
+ get steerDispatchCount() { return this.dispatchedSteers; }
21
28
  startAttempted = false;
22
29
  negotiated = {};
23
30
  method;
@@ -226,6 +233,27 @@ export class AcpSession {
226
233
  }
227
234
  employeeNoticeNames = new Set();
228
235
  employeeNoticeUnshown = false;
236
+ employeeBridge = false;
237
+ pendingBridgeStartupFailures = new Set();
238
+ bridgeStartupFailed = false;
239
+ bridgeStartupNoticeDelivered = false;
240
+ confirmBridgeStartupFailure() {
241
+ if (!this.sessionId)
242
+ return;
243
+ const failed = this.pendingBridgeStartupFailures.has(this.sessionId);
244
+ this.pendingBridgeStartupFailures.clear();
245
+ if (failed && !this.bridgeStartupFailed) {
246
+ this.bridgeStartupFailed = true;
247
+ this.detail({ kind: 'extension', severity: 'warning', code: 'TOOLBRIDGE_STARTUP_FAILED', summary: '本轮DSH扩展工具桥启动失败;文件和命令继续使用原生路径,没有自动重试。', method: 'session/update', payload: { server: 'employee', status: 'failed', source: 'codex-acp/mcp-startup-report', nativeSessionId: this.sessionId } });
248
+ }
249
+ this.flushBridgeStartupNotice();
250
+ }
251
+ flushBridgeStartupNotice() {
252
+ if (!this.bridgeStartupFailed || this.bridgeStartupNoticeDelivered || !this.busy || this.closeRequested || this.turnSignal?.aborted || !this.hooks.onEmployeeNotice)
253
+ return;
254
+ this.hooks.onEmployeeNotice('本轮DSH里的扩展工具未能连接到Codex,暂时不可用。文件和命令仍按原方式执行;具体原因见技术详情。本轮不会自动重试。');
255
+ this.bridgeStartupNoticeDelivered = true;
256
+ }
229
257
  employeeInfo(value) {
230
258
  const bridge = record(record(value)?.mcpBridge);
231
259
  if (bridge)
@@ -252,7 +280,8 @@ export class AcpSession {
252
280
  this.hooks = hooks;
253
281
  this.closeDiagnostics = hooks.closeDiagnostics ?? new CloseDiagnostics(event => this.detail(event));
254
282
  const app = acp.client({ name: '@ai-workbench/remote-agent' })
255
- .onNotification(acp.methods.client.session.update, ({ params: notification }) => {
283
+ .onNotification(acp.methods.client.session.update, ({ params: incoming }) => {
284
+ const { notification, sequence } = this.hooks.broker?.stripOutputOrigin(incoming) ?? { notification: incoming, sequence: undefined };
256
285
  if (this.creatingReplacement) {
257
286
  if (notification.sessionId !== this.sessionId && notification.update.sessionUpdate === 'config_option_update')
258
287
  this.pendingConfiguration(notification.sessionId, notification.update.configOptions);
@@ -263,6 +292,11 @@ export class AcpSession {
263
292
  this.detail({ kind: 'session', severity: 'warning', code: 'ACP_FOREIGN_SESSION_UPDATE', summary: '收到不属于当前远端会话的通知,未作为正文处理', method: 'session/update', payload: notification });
264
293
  return;
265
294
  }
295
+ const update = notification.update;
296
+ if (this.employeeBridge && !this.closeRequested && (update.sessionUpdate === 'tool_call' || update.sessionUpdate === 'tool_call_update') && update.status === 'failed' && update.title === 'mcp__employee__startup' && update.toolCallId.startsWith('mcp_startup.employee.') && update.toolCallId.length > 'mcp_startup.employee.'.length) {
297
+ this.pendingBridgeStartupFailures.add(notification.sessionId);
298
+ this.confirmBridgeStartupFailure();
299
+ }
266
300
  const meta = record(notification._meta);
267
301
  if (notification.update.sessionUpdate === 'current_mode_update') {
268
302
  this.nativeModeId = notification.update.currentModeId;
@@ -289,7 +323,7 @@ export class AcpSession {
289
323
  if (meta && Object.keys(meta).length)
290
324
  this.detail({ kind: 'extension', severity: 'info', code: 'ACP_NOTIFICATION_META', summary: '远端通知扩展', method: 'session/update', payload: notification._meta });
291
325
  if (this.busy) {
292
- this.hooks.onUpdate?.(notification);
326
+ this.hooks.onUpdate?.(notification, sequence);
293
327
  }
294
328
  else
295
329
  this.detail({ kind: notification.update.sessionUpdate === 'available_commands_update' ? 'commands' : 'session', severity: 'info', code: 'ACP_IDLE_UPDATE', summary: '远端会话建立、恢复或空闲时的轨迹', method: 'session/update', payload: notification });
@@ -404,10 +438,14 @@ export class AcpSession {
404
438
  throw new acp.RequestError(-32601, '不支持此扩展交互');
405
439
  })
406
440
  .onNotification('*', ({ method, params }) => {
441
+ if (method === '_aw/broker-replay-complete') {
442
+ this.hooks.broker?.confirmReplay(record(params)?.generation);
443
+ return;
444
+ }
407
445
  this.detail({ kind: 'extension', severity: 'warning', code: 'ACP_UNKNOWN_NOTIFICATION', summary: '收到未知远端扩展通知,已保留技术记录', method, payload: params });
408
446
  });
409
447
  if ('readable' in transport && 'writable' in transport)
410
- this.connection = app.connect(isolateRpcIds(this.observe(transport), message => this.observeDispatch(message)));
448
+ this.connection = app.connect(isolateRpcIds(this.observe(this.hooks.broker?.withOutputOrigins(transport) ?? transport), message => this.observeDispatch(message)));
411
449
  else {
412
450
  // Stable and unstable apps use distinct private symbols. Bridge only their
413
451
  // public stream interfaces so either SDK entry point remains supported.
@@ -423,7 +461,8 @@ export class AcpSession {
423
461
  /** A rejected request on an already-closed SDK never reaches this write.
424
462
  * Once a transport write starts, failure remains delivery-unknown. */
425
463
  observeDispatch(message) {
426
- if (record(message)?.method !== 'session/prompt' || !Object.hasOwn(message, 'id'))
464
+ const method = record(message)?.method;
465
+ if (!['session/prompt', '_session/steering'].includes(String(method)) || !Object.hasOwn(message, 'id'))
427
466
  return;
428
467
  const params = record(record(message)?.params), current = params ? this.promptPermissions.get(params) : undefined;
429
468
  if (params)
@@ -432,6 +471,8 @@ export class AcpSession {
432
471
  this.closeDiagnostics.record({ layer: 'acp', initiator: 'acp.permission-dispatch-gate', reason: 'PERMISSION_POLICY_CHANGED', operation: 'session/prompt', action: 'failure' });
433
472
  throw new NeedError('PERMISSION_POLICY_CHANGED', '当前权限已变化或无法核对,这次派发已停止;原输入没有重放。', '当前权限代次与远端同值回执');
434
473
  }
474
+ if (current.maxBytes !== undefined && Buffer.byteLength(JSON.stringify(message)) + 1 > current.maxBytes)
475
+ throw new NeedError('ACP_MESSAGE_TOO_LARGE', '中途消息超过已设置的会话消息容量,未发送。', '管理员调整acpMaxMessageBytes');
435
476
  current.native();
436
477
  this.hooks.broker?.authorizePrompt(() => { try {
437
478
  if (!current.current())
@@ -442,21 +483,26 @@ export class AcpSession {
442
483
  catch {
443
484
  return false;
444
485
  } });
445
- this.dispatchedPrompts++;
486
+ if (method === 'session/prompt')
487
+ this.dispatchedPrompts++;
488
+ else
489
+ this.dispatchedSteers++;
446
490
  }
447
491
  observe(stream) {
448
492
  // Observe already-parsed public Stream messages: no NDJSON parsing, second
449
493
  // byte buffer, message-size policy, or transport fallback is introduced.
450
494
  const observe = this.closeDiagnostics.capture();
451
495
  const readable = stream.readable.pipeThrough(new TransformStream({ transform: (message, controller) => {
452
- const raw = record(message);
453
- const params = record(raw?.params);
454
- const update = record(params?.update);
455
- if (raw?.method === acp.methods.client.session.update && typeof update?.sessionUpdate === 'string' && !knownUpdates.has(update.sessionUpdate)) {
456
- this.detail({ kind: 'extension', severity: 'warning', code: 'ACP_UNKNOWN_UPDATE', summary: '收到未知远端会话事件,已保留结构', method: 'session/update', payload: params });
457
- return;
458
- }
459
- controller.enqueue(message);
496
+ const inspect = (value) => { if (Array.isArray(value)) {
497
+ const members = value.flatMap(item => inspect(item));
498
+ return members.length ? [members] : [];
499
+ } const raw = record(value), params = record(raw?.params), update = record(params?.update); if (raw?.method === acp.methods.client.session.update && typeof update?.sessionUpdate === 'string' && !knownUpdates.has(update.sessionUpdate)) {
500
+ const notification = this.hooks.broker?.stripOutputOrigin(params).notification ?? params;
501
+ this.detail({ kind: 'extension', severity: 'warning', code: 'ACP_UNKNOWN_UPDATE', summary: '收到未知远端会话事件,已保留结构', method: 'session/update', payload: notification });
502
+ return [];
503
+ } return [value]; };
504
+ for (const value of inspect(message))
505
+ controller.enqueue(value);
460
506
  }, flush: () => observe({ layer: 'acp', initiator: 'acp.read-eof', reason: 'ACP_STREAM_EOF', action: 'eof' }) }));
461
507
  return { readable, writable: stream.writable };
462
508
  }
@@ -482,17 +528,20 @@ export class AcpSession {
482
528
  throw new NeedError('SESSION_ALREADY_STARTED', '此连接已用于建立会话,不能转用工作区或身份', '新的独立远端连接');
483
529
  this.startAttempted = true;
484
530
  this.employeeMeta = context?.employeeExecution;
531
+ this.employeeBridge = !!this.employeeMeta && !!context?.toolBridgeServers;
485
532
  const abort = () => this.close({ layer: 'acp', initiator: 'acp.start-signal', reason: 'ABORTED', action: 'abort' }, new NeedError('ABORTED', '会话建立已取消', '重新连接主机'));
486
533
  signal?.throwIfAborted();
487
534
  signal?.addEventListener('abort', abort, { once: true });
488
535
  try {
489
536
  const hello = await this.stage('acp-initialize', () => this.connection.agent.request(acp.methods.agent.initialize, {
490
- protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: '@ai-workbench/remote-agent', version: '0.9.0-toolbridge.2' },
537
+ protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: '@ai-workbench/remote-agent', version: '0.9.0-toolbridge.9' },
491
538
  clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false, session: { notices: {} }, ...(this.employeeMeta ? { _meta: { awEmployeeExecution: { version: 1, closeReason: 1, ...(context?.toolBridgeServers ? { mcpBridge: 1 } : {}) } } } : {}) },
492
539
  }, { cancellationSignal: signal }));
493
540
  if (hello.protocolVersion !== acp.PROTOCOL_VERSION)
494
541
  throw new NeedError('ACP_VERSION_MISMATCH', 'ACP 协议版本不兼容', '支持 ACP v1 的远端 agent');
495
542
  this.negotiated = hello.agentCapabilities ?? {};
543
+ const steering = record(hello._meta?.steering);
544
+ this.steeringSupported = steering?.supported === true && (!context?.codexNewSessionOnly || steering.idleBehavior === 'promptRequired');
496
545
  if (this.employeeMeta) {
497
546
  const policy = record(hello._meta?.awEmployeeExecution);
498
547
  if (!this.hooks.employeeExecution || !policy || Object.keys(policy).length !== (context?.toolBridgeServers ? 6 : 5) || context?.toolBridgeServers && policy.mcpBridge !== 1 || policy.version !== 1 || policy.nativeCliVersion !== '0.160.1' || policy.native !== true || policy.perRpcGate !== true || policy.noHostFallback !== true)
@@ -555,6 +604,7 @@ export class AcpSession {
555
604
  this.lifecycleConfiguration(result, configRevision);
556
605
  this.method = acp.methods.agent.session.new;
557
606
  }
607
+ this.confirmBridgeStartupFailure();
558
608
  await this.hooks.sessionOwnership?.bind(this.sessionId, signal);
559
609
  this.ready = true;
560
610
  this.cwd = cwd;
@@ -597,7 +647,18 @@ export class AcpSession {
597
647
  this.turnToken = Symbol('turn');
598
648
  let rejectAbort;
599
649
  const interrupted = new Promise((_resolve, reject) => { rejectAbort = reject; });
650
+ const requestAbort = new AbortController();
600
651
  const cancel = () => {
652
+ if (signal?.reason?.kind === 'disposed') {
653
+ this.close({ layer: 'acp', initiator: 'acp.owner-disposed', reason: 'SESSION_DETACHED', action: 'detach' });
654
+ rejectAbort?.(new NeedError('ABORTED', '客户端已退出,主机原轮保留,未发送取消', '原轮冷恢复'));
655
+ return;
656
+ }
657
+ if (this.closeRequested) {
658
+ rejectAbort?.(new NeedError('ABORTED', '客户端已分离,未重发或取消主机原轮', '原轮恢复状态'));
659
+ return;
660
+ }
661
+ requestAbort.abort(signal?.reason);
601
662
  this.closeDiagnostics.record({ layer: 'acp', initiator: 'acp.prompt-cancel', reason: 'ABORTED', operation: 'session/prompt', action: 'abort' });
602
663
  rejectAbort?.(new NeedError('ABORTED', '已请求取消本轮,远端状态需确认', '确认主机取消状态'));
603
664
  void this.connection.agent.notify(acp.methods.agent.session.cancel, { sessionId: this.sessionId }).catch(() => {
@@ -606,9 +667,10 @@ export class AcpSession {
606
667
  };
607
668
  signal?.addEventListener('abort', cancel, { once: true });
608
669
  try {
670
+ this.flushBridgeStartupNotice();
609
671
  const result = await this.stage('acp-prompt', () => {
610
672
  this.promptPermissions.set(params, { current, native });
611
- const request = this.connection.agent.request(acp.methods.agent.session.prompt, params, { cancellationSignal: signal });
673
+ const request = this.connection.agent.request(acp.methods.agent.session.prompt, params, { cancellationSignal: requestAbort.signal });
612
674
  return signal ? Promise.race([request, interrupted]) : request;
613
675
  });
614
676
  signal?.throwIfAborted();
@@ -627,12 +689,34 @@ export class AcpSession {
627
689
  this.turnToken = undefined;
628
690
  }
629
691
  }
692
+ async steer(prompt, signal, isCurrent, maxBytes) {
693
+ if (!this.canSteer || !this.sessionId || isCurrent && !isCurrent())
694
+ return 'promptRequired';
695
+ this.validatePrompt(prompt);
696
+ signal?.throwIfAborted();
697
+ const token = this.turnToken, permit = this.hooks.promptGuard?.(), expected = this.selectedPermission, reported = new Set();
698
+ const current = () => this.canSteer && (!isCurrent || isCurrent()) && this.turnToken === token && !signal?.aborted && (!permit || !permit.signal.aborted && permit.isCurrent());
699
+ const params = { sessionId: this.sessionId, prompt, _meta: { steering: { idleBehavior: 'promptRequired' } } };
700
+ this.promptPermissions.set(params, { current, native: () => this.validateNativePermission(expected, reported), maxBytes });
701
+ try {
702
+ const result = await this.connection.agent.request('_session/steering', params, { cancellationSignal: signal });
703
+ if (result.outcome === 'injected' || result.outcome === 'promptRequired')
704
+ return result.outcome;
705
+ throw new NeedError('INPUT_DELIVERY_UNCONFIRMED', '中途消息未获得同一轮的注入回执,没有重复提交。', '原轮injected或promptRequired回执');
706
+ }
707
+ catch (error) {
708
+ throw acpNeed(error);
709
+ }
710
+ }
630
711
  close(cause = { layer: 'acp', initiator: 'acp.close', reason: 'ACP_CLOSE_REQUESTED', action: 'close' }, error) { this.closeDiagnostics.record({ ...cause, changes: cause.changes ?? [{ field: 'acp.close-requested', before: this.closeRequested, after: true }] }); this.closeRequested = true; this.connection?.close(error); }
631
712
  }
632
713
  export function acpNeed(error) {
633
714
  if (error instanceof NeedError)
634
715
  return error;
635
716
  if (error instanceof acp.RequestError) {
717
+ const localCode = record(error.data)?.localDispatchCode;
718
+ if (error.message === 'ACP_LOCAL_REQUEST_REJECTED' && (localCode === 'ACP_MESSAGE_TOO_LARGE' || localCode === 'PERMISSION_POLICY_CHANGED'))
719
+ return new NeedError(localCode, '中途消息在实际派发前被拒绝,仍在官方队列中,未发送。', '当前消息、权限与acpMaxMessageBytes');
636
720
  if (record(error.data)?.reason === 'thread_active_writer')
637
721
  return new NeedError('REMOTE_SESSION_BUSY', employeeFailure('REMOTE_SESSION_BUSY'), '原远端线程仍被占用;需要按同一DSH会话和远端线程定位已断开的旧broker并确认释放;RPC 错误码 ' + error.code);
638
722
  // Host SDK1.9 uses Internal error + data.details for thrown adapter errors.
@@ -664,3 +748,4 @@ export function acpNeed(error) {
664
748
  function record(value) { return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined; }
665
749
  const knownUpdates = new Set(['user_message_chunk', 'agent_message_chunk', 'agent_thought_chunk', 'tool_call', 'tool_call_update', 'plan', 'plan_update', 'plan_removed', 'available_commands_update', 'current_mode_update', 'config_option_update', 'session_info_update', 'usage_update', 'notice', 'compaction_update', 'compaction_summary_chunk', 'subagent_update', 'session_message', 'session_message_chunk']);
666
750
  function safeLabel(value) { return value.replaceAll(/[\r\n\x00-\x1f\x7f]/g, ' '); }
751
+ export const isKnownAcpUpdate = (update) => !!update && typeof update === 'object' && knownUpdates.has(update.sessionUpdate);
@@ -1,3 +1,4 @@
1
+ import { type ColdStore } from './cold-store.ts';
1
2
  import { type SshArgv, type BrokerIo, type BrokerSettings } from './broker.ts';
2
3
  import { type ConnectApi, type ConnectTarget, type Project, type Runtime, type RuntimeRequest } from './provider.ts';
3
4
  import type { Interaction } from './interaction.ts';
@@ -5,4 +6,5 @@ import type { Interaction } from './interaction.ts';
5
6
  export declare function brokerFactory(_get: () => ConnectApi | undefined, _ask: Interaction | undefined, configuration: BrokerSettings | (() => BrokerSettings), provided?: {
6
7
  argv?: SshArgv;
7
8
  io?: (target: ConnectTarget) => BrokerIo;
9
+ coldStore?: ColdStore;
8
10
  }): (target: ConnectTarget, project: Project, request: RuntimeRequest) => Promise<Runtime>;
@@ -6,6 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
6
6
  }
7
7
  return path;
8
8
  };
9
+ import { newColdId } from "./cold-store.js";
9
10
  import { randomUUID } from 'node:crypto';
10
11
  import { CloseDiagnostics } from "./close-diagnostics.js";
11
12
  import { BrokerTransport, brokerCommand, brokerId, sshIo, controlJson } from "./broker.js";
@@ -36,14 +37,62 @@ export function brokerFactory(_get, _ask, configuration, provided) {
36
37
  throw new NeedError(started.code, '主机的环境配置会覆盖本机执行位置,本轮已停止;请由管理员移开该配置后在原会话重试。', '主机 CODEX_HOME/environments.toml 不存在');
37
38
  if (started.protocolVersion !== 1 || started.id !== id || !started.instanceId)
38
39
  throw new NeedError('BROKER_PROTOCOL_INVALID', '主机会话未能启动,请恢复连接后再试。', '有效的主机会话启动回应');
39
- const channel = new BrokerTransport({ observeClose: diagnostics.capture(), maxFrameBytes: settings.brokerMaxFrameBytes, instanceId: started.instanceId, leased: true, controlMaxBytes: started.controlMaxBytes, attach: () => io.attach(command(['attach', id, '--after', '0', '--framed', '--leased', '--if-instance', started.instanceId])) });
40
+ const coldStore = started.messageInputProtocolVersion === 1 ? provided?.coldStore : undefined, roundId = newColdId(), boundOrigin = Promise.withResolvers();
41
+ void boundOrigin.promise.catch(() => { });
42
+ if (coldStore)
43
+ await coldStore.put({ version: 1, id: roundId, sessionId: request.sessionId, provider: agent.id, brand: agent.loginProvider, phase: 'opening', target: structuredClone(target), brokerId: id, instanceId: started.instanceId, controlMaxBytes: started.controlMaxBytes, heartbeatIntervalMs: started.lifecycle.heartbeatIntervalMs, rpcIds: [], answered: [], inputSequence: 0, outputAfter: 0 });
44
+ const beforeMessage = coldStore ? async (bytes, message) => {
45
+ const rpc = JSON.parse(Buffer.from(bytes).toString('utf8'));
46
+ try {
47
+ let record = await coldStore.update(request.sessionId, agent.id, roundId, row => {
48
+ if (rpc.method && Object.hasOwn(rpc, 'id') && !row.rpcIds.includes(rpc.id))
49
+ row.rpcIds.push(rpc.id);
50
+ if (rpc.method === 'session/cancel' && rpc.params?.sessionId === row.nativeId || rpc.method === '$/cancel_request' && String(rpc.params?.requestId) === row.promptId)
51
+ row.cancelIntent ??= { source: 'wire' };
52
+ row.pending = { id: message.id, sha256: message.sha256, wire: Buffer.from(bytes).toString('base64'), baseSequence: message.baseSequence, chunkBytes: message.chunkBytes, chunks: Math.ceil(bytes.length / message.chunkBytes), ...(rpc.method ? { method: rpc.method } : {}), ...(Object.hasOwn(rpc, 'id') ? { rpcId: rpc.id } : {}) };
53
+ if (rpc.method === 'session/prompt') {
54
+ if (!row.meta || row.nativeId !== rpc.params?.sessionId || row.promptId)
55
+ throw new NeedError('INPUT_DELIVERY_UNCONFIRMED', '原轮归属未完成持久登记,未发送输入', '完整冷恢复快照');
56
+ row.promptId = String(rpc.id);
57
+ row.promptSha256 = message.sha256;
58
+ row.promptBytes = bytes.length;
59
+ row.phase = 'running';
60
+ }
61
+ });
62
+ if (rpc.method === 'session/prompt') {
63
+ const bound = controlJson(await io.run(command(['bind-round', id, '--if-instance', started.instanceId, '--dsh-session-id', request.sessionId, '--provider', agent.loginProvider, '--remote-session-id', record.nativeId, '--round-id', roundId, '--prompt-id', record.promptId, '--prompt-sha256', record.promptSha256, '--prompt-bytes', String(record.promptBytes)]), request.signal));
64
+ if (!Number.isSafeInteger(bound.round?.outputStartSequence))
65
+ throw new NeedError('BROKER_PROTOCOL_INVALID', '原轮输出起点未确认', '原轮绑定回执');
66
+ await coldStore.update(request.sessionId, agent.id, roundId, row => { row.outputStart = bound.round.outputStartSequence; });
67
+ boundOrigin.resolve(bound.round.outputStartSequence);
68
+ }
69
+ }
70
+ catch (error) {
71
+ if (rpc.method === 'session/prompt')
72
+ boundOrigin.reject(error);
73
+ throw error;
74
+ }
75
+ } : undefined;
76
+ const afterMessage = coldStore ? async (sequence) => { await coldStore.update(request.sessionId, agent.id, roundId, row => { if (row.pending && !row.pending.method && row.pending.rpcId !== undefined && !row.answered.includes(row.pending.rpcId))
77
+ row.answered.push(row.pending.rpcId); if (row.pending && ['session/cancel', '$/cancel_request'].includes(row.pending.method ?? '') && row.cancelIntent)
78
+ row.cancelIntent.delivered = true; row.inputSequence = sequence; delete row.pending; }); } : undefined;
79
+ const channel = new BrokerTransport({ observeClose: diagnostics.capture(), maxFrameBytes: settings.brokerMaxFrameBytes, instanceId: started.instanceId, leased: true, controlMaxBytes: started.controlMaxBytes, ...(started.inputProtocolVersion === 2 ? { inputProtocolVersion: 2, recoverDisconnect: true } : {}), ...(coldStore ? { messageInput: true, outputOrigins: true, beforeMessage, afterMessage } : {}), attach: (after = 0) => io.attach(command(['attach', id, '--after', String(after), '--framed', '--leased', ...(started.inputProtocolVersion === 2 ? ['--input-protocol', '2'] : []), ...(coldStore ? ['--message-input'] : []), '--if-instance', started.instanceId])) });
80
+ const reconnectOff = started.inputProtocolVersion === 2 ? _get()?.onConnectionState?.(state => { if (state.phase === 'connected' && !channel.online)
81
+ void channel.connect().catch(() => { }); }) : undefined;
40
82
  let ended = false;
41
- const dispose = async (cause = { layer: 'broker', initiator: 'broker.dispose', reason: 'BROKER_DISPOSE', action: 'dispose' }) => {
83
+ const detach = async (cause = { layer: 'broker', initiator: 'broker.detach', reason: 'SESSION_DETACHED', action: 'detach' }) => {
42
84
  if (ended)
43
85
  return;
44
86
  ended = true;
87
+ reconnectOff?.();
45
88
  diagnostics.record(cause);
46
89
  channel.close(cause);
90
+ };
91
+ const dispose = async (cause = { layer: 'broker', initiator: 'broker.dispose', reason: 'BROKER_DISPOSE', action: 'dispose' }) => {
92
+ if (ended)
93
+ return;
94
+ // Ending the round ends its host agent, so the native thread writer is free for the next round.
95
+ await detach(cause);
47
96
  void io.run(command(['kill', id, '--if-instance', started.instanceId])).catch(() => console.warn('[remote-agent] 旧主机会话暂未清理,将由主机自动回收'));
48
97
  };
49
98
  const aborted = () => channel.fail(new NeedError('ABORTED', '本轮已取消。', '确认主机状态'), { layer: 'broker', initiator: 'broker.open-signal', reason: 'ABORTED', action: 'abort' });
@@ -61,6 +110,6 @@ export function brokerFactory(_get, _ask, configuration, provided) {
61
110
  finally {
62
111
  request.signal?.removeEventListener('abort', aborted);
63
112
  }
64
- return { identity: identity(target), cwd: project.path, closeDiagnostics: diagnostics, broker: channel, sessionOwnership, acpTransport: channel, dispose, detach: dispose };
113
+ return { ...(coldStore ? { cold: { id: roundId, store: coldStore, bound: boundOrigin.promise, failBinding: error => boundOrigin.reject(error), prepare: async (nativeId, meta) => { await coldStore.update(request.sessionId, agent.id, roundId, row => { row.nativeId = nativeId; row.meta = structuredClone(meta); }); } } } : {}), identity: identity(target), cwd: project.path, closeDiagnostics: diagnostics, broker: channel, sessionOwnership, acpTransport: channel, dispose, detach: channel.supportsRecovery ? detach : dispose };
65
114
  };
66
115
  }
package/dist/broker.d.ts CHANGED
@@ -1,3 +1,4 @@
1
+ import type { ColdWrite } from './cold-store.ts';
1
2
  import { type CloseCause, type CloseObserver } from './close-diagnostics.ts';
2
3
  import { type ChildProcessWithoutNullStreams } from 'node:child_process';
3
4
  import { NeedError, type Need } from './remote.ts';
@@ -9,7 +10,23 @@ export interface BrokerOptions {
9
10
  instanceId?: string;
10
11
  leased?: boolean;
11
12
  controlMaxBytes?: number;
12
- attach: () => Promise<Attachment>;
13
+ attach: (after?: number) => Promise<Attachment>;
14
+ inputProtocolVersion?: 2;
15
+ recoverDisconnect?: boolean;
16
+ messageInput?: boolean;
17
+ outputOrigins?: boolean;
18
+ initialSequence?: number;
19
+ restoreInput?: {
20
+ sequence: number;
21
+ pending?: ColdWrite;
22
+ };
23
+ beforeMessage?: (bytes: Uint8Array, message: {
24
+ id: string;
25
+ sha256: string;
26
+ chunkBytes: number;
27
+ baseSequence: number;
28
+ }) => Promise<void>;
29
+ afterMessage?: (sequence: number) => Promise<void>;
13
30
  onNeed?: (need: Need) => void;
14
31
  }
15
32
  /** One byte stream / SDK app over one SSH attachment of a new agent. Input is never replayed. */
@@ -20,6 +37,44 @@ export declare class BrokerTransport {
20
37
  private output;
21
38
  private attachment?;
22
39
  private cursor;
40
+ get lastSequence(): number;
41
+ private originKey;
42
+ private originNonce;
43
+ private originPartial;
44
+ private originFinalSequence;
45
+ private originMarker;
46
+ private stdout;
47
+ withOutputOrigins<T extends {
48
+ readable: ReadableStream<any>;
49
+ writable: WritableStream<any>;
50
+ }>(stream: T): T;
51
+ stripOutputOrigin<T>(notification: T): {
52
+ notification: T;
53
+ sequence?: number;
54
+ };
55
+ private promptReceipt?;
56
+ get promptDelivered(): boolean | undefined;
57
+ private receipt;
58
+ get inputReceipt(): any;
59
+ private controlWait?;
60
+ private resendControl;
61
+ private controlMessage;
62
+ completeRestoredInput(): void;
63
+ discardMessage(id: string): Promise<any>;
64
+ observeMessage(id: string): Promise<any>;
65
+ resumeMessage(write: ColdWrite): Promise<void>;
66
+ private inputSequence;
67
+ private inputReady;
68
+ private pendingInput?;
69
+ private recoveryTimer?;
70
+ private recoveryIntervalMs?;
71
+ private everReady;
72
+ get recovering(): boolean;
73
+ get supportsRecovery(): boolean;
74
+ confirmReplay(generation: unknown): void;
75
+ private recover;
76
+ private waitInput;
77
+ private acknowledge;
23
78
  private epoch;
24
79
  private attached;
25
80
  private ended;