@ai-workbench/remote-agent 0.8.2 → 0.8.5

package/dist/provider.js

@@ -2,6 +2,7 @@ import { loginDiagnostic, loginReason } from "./login-diagnostic.js";
 import { NeedError } from "./remote.js";
 import { CONNECTION_REQUIRED, TEST_HOST_NOTICE } from "./presentation.js";
 import { CODEX_AGENT } from "./agents.js";
+import { StageTiming } from "./stage-timing.js";
 export function requireLoginCoordinator(api) {
     if (!['getConnectionState', 'getLoginPromptState', 'requestLoginPrompt', 'refreshLoginPrompts'].every(key => typeof api[key] === 'function'))
         throw new NeedError('CONNECT_API_MISMATCH', '我需要 connect-api 0.6.1 的统一登录询问与连接状态能力', 'L >=0.6.1');
@@ -155,6 +156,7 @@ export function connectProvider(get, options = {}) {
     const agent = options.agent ?? CODEX_AGENT;
     const admissions = new WeakMap();
     const preflight = async (request) => {
+        request.timing ??= new StageTiming();
         request.signal?.throwIfAborted();
         const api = get();
         if (!api)
@@ -163,13 +165,16 @@ export function connectProvider(get, options = {}) {
         requireLoginCoordinator(api);
         if (request.mode === 'one-shot' && !agent.oneShot)
             throw new NeedError('MODE_UNSUPPORTED', '此远程模型仅支持会话模式', '使用会话模式');
-        const before = api.getConnectionState();
-        const target = await ensureReady(api, agent.loginProvider, request.signal);
-        validateTarget(target);
-        request.signal?.throwIfAborted();
-        if (get() !== api)
-            throw new NeedError('CONNECTION_LOST', '远程主机连接组件已更换', '当前员工连接');
-        const connection = await waitForLogin(api, agent.loginProvider, before, get, request.signal);
+        const { target, connection } = await request.timing.run('login-ready', async () => {
+            const before = api.getConnectionState();
+            const target = await ensureReady(api, agent.loginProvider, request.signal);
+            validateTarget(target);
+            request.signal?.throwIfAborted();
+            if (get() !== api)
+                throw new NeedError('CONNECTION_LOST', '远程主机连接组件已更换', '当前员工连接');
+            const connection = await waitForLogin(api, agent.loginProvider, before, get, request.signal);
+            return { target, connection };
+        });
         if (request.identity && request.identity !== identity(target))
             throw new NeedError('SESSION_CONTEXT_MISMATCH', '员工主机与原会话不一致，请新建会话', '原员工主机');
         admissions.set(request, { api, target, connection });
@@ -180,13 +185,13 @@ export function connectProvider(get, options = {}) {
         const admitted = admissions.get(request);
         admissions.delete(request);
         const { api, target, connection } = admitted;
-        const stable = () => waitForLogin(api, agent.loginProvider, connection, get, request.signal);
+        const stable = () => request.timing.run('connection-confirm', () => waitForLogin(api, agent.loginProvider, connection, get, request.signal));
         await stable();
         if (!request.sessionId)
             throw new NeedError('PROJECT_BINDING_REQUIRED', '我需要当前会话和已选择的工作区，请使用原生工作区入口', 'DSH会话与原生工作区');
         await options.notice?.reconcile(request, api);
         await stable();
-        const resolved = unwrap(await awaitL(() => api.resolveSessionProject(request.sessionId, { provider: agent.loginProvider, purpose: 'user-turn' }), request.signal));
+        const resolved = await request.timing.run('workspace-resolve', async () => unwrap(await awaitL(() => api.resolveSessionProject(request.sessionId, { provider: agent.loginProvider, purpose: 'user-turn' }), request.signal)));
         await stable();
         if (!resolved || resolved.instanceId !== connection.instanceId || resolved.epoch !== connection.epoch)
             throw new NeedError('CONNECTION_LOST', '工作区解析回复已失效', '当前连接代次');
@@ -196,32 +201,57 @@ export function connectProvider(get, options = {}) {
             throw new NeedError('PROJECT_BINDING_INVALID', '工作区绑定与当前会话或可信主机不一致', 'L核验的原生工作区绑定');
         if (request.cwd && request.cwd !== project.path || request.bindingId && request.bindingId !== resolved.bindingId || request.workspaceId && request.workspaceId !== resolved.workspaceId)
             throw new NeedError('SESSION_CONTEXT_MISMATCH', '原会话的工作区绑定已改变，请新建会话', '原工作区绑定');
-        const details = await options.details?.(request, api, connection, target);
-        await stable();
-        let workspaceNotice = undefined;
-        if (resolved.notice) {
-            if (!options.notice)
-                throw new NeedError('DEPENDENCY_REQUIRED', '我需要官方会话持久记录来确认工作区说明', '官方会话与持久化服务');
-            workspaceNotice = await options.notice.deliver(resolved.notice, resolved, request, api);
-            await stable();
-        }
-        if (!options.open)
-            throw new NeedError('RUNTIME_REQUIRED', '我需要主机运行适配器', '主机broker适配');
-        const runtime = await options.open(resolved.target, project, { ...request, agent });
+        const details = await request.timing.run('details-open', async () => options.details?.(request, api, connection, target));
         try {
+            if (details)
+                request.timing.bind(detail => details.record(detail));
             await stable();
+            let workspaceNotice = undefined;
+            if (resolved.notice) {
+                if (!options.notice)
+                    throw new NeedError('DEPENDENCY_REQUIRED', '我需要官方会话持久记录来确认工作区说明', '官方会话与持久化服务');
+                workspaceNotice = await request.timing.run('workspace-notice', () => options.notice.deliver(resolved.notice, resolved, request, api));
+                await stable();
+            }
+            if (!options.open)
+                throw new NeedError('RUNTIME_REQUIRED', '我需要主机运行适配器', '主机broker适配');
+            const observedBinding = api.getWorkspaceBindingState?.();
+            const validateContext = async (ignoreCancellation = false) => {
+                const check = () => waitForLogin(api, agent.loginProvider, connection, get, ignoreCancellation ? undefined : request.signal);
+                await check();
+                if (observedBinding) {
+                    const current = api.getWorkspaceBindingState();
+                    if (current.instanceId !== observedBinding.instanceId || !current.items.some(item => item.bindingId === resolved.bindingId && item.workspaceId === resolved.workspaceId && item.status === 'ready'))
+                        throw new NeedError('SESSION_CONTEXT_MISMATCH', '当前工作区绑定已改变，原会话操作未执行', '原生会话原绑定');
+                }
+                await check();
+            };
+            const runtime = await options.open(resolved.target, project, { ...request, agent, bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, bindingRevision: resolved.bindingRevision, detailChannel: details, validateContext });
+            try {
+                await stable();
+            }
+            catch (error) {
+                await runtime.dispose?.();
+                throw error;
+            }
+            // The transport can outlive a turn; presentation belongs only to this invocation.
+            runtime.workspaceNotice = workspaceNotice || undefined;
+            runtime.details = details ?? runtime.details;
+            runtime.binding = { bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, revision: resolved.bindingRevision };
+            runtime.connection = { ...connection };
+            runtime.loginRequired = () => offerLogin(api, request, get, agent);
+            return runtime;
         }
         catch (error) {
-            await runtime.dispose?.();
+            try {
+                await details?.flush();
+            }
+            catch (diagnostic) {
+                const code = (value) => value instanceof NeedError && /^[A-Z][A-Z0-9_]*$/.test(value.code) ? value.code : 'UNKNOWN_FAILURE';
+                throw new NeedError('CONVERSATION_DETAILS_FAILED', '技术详情未能保存；本轮已停止', `原错误代码 ${code(error)}；诊断错误代码 ${code(diagnostic)}`);
+            }
             throw error;
         }
-        // The transport can outlive a turn; presentation belongs only to this invocation.
-        runtime.workspaceNotice = workspaceNotice || undefined;
-        runtime.details = details ?? runtime.details;
-        runtime.binding = { bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, revision: resolved.bindingRevision };
-        runtime.connection = { ...connection };
-        runtime.loginRequired = () => offerLogin(api, request, get, agent);
-        return runtime;
     };
     resolve.preflight = preflight;
     return resolve;

package/dist/recovery-checkpoint.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { RuntimeRequest } from './provider.ts';
+/** A step's accepted batch follows step/start in the official event contract. */
+export declare function currentInputIds(ctx: Context, request: RuntimeRequest): Promise<readonly string[]>;
+/** Read only the official persistence API after its awaited durability checkpoint. */
+export declare function verifyRecoveryCheckpoint(ctx: Context, request: RuntimeRequest, provider: string): Promise<boolean>;

package/dist/recovery-checkpoint.js

@@ -0,0 +1,71 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { BlockAssembler, expandAssistantStream } from '@deepseek-ai/dsh-llm';
+import { isDeepStrictEqual } from 'node:util';
+/** A step's accepted batch follows step/start in the official event contract. */
+export async function currentInputIds(ctx, request) {
+    if (!request.sessionId)
+        return [];
+    const id = SessionId(request.sessionId), store = ctx.get('sessions'), session = store?.get(id);
+    const persistence = ctx.get('sessionPersistence');
+    if (!session || !store || !persistence || !await store.flush(session))
+        return [];
+    const handle = await persistence.open(id, 'read');
+    try {
+        if (handle.id !== id || handle.header?.id !== id || handle.access !== 'read')
+            return [];
+        const { events } = await handle.read();
+        if (!Array.isArray(events))
+            return [];
+        let step;
+        let ids = [];
+        for (const event of events) {
+            if (event.type === 'step/start') {
+                step = event;
+                ids = [];
+            }
+            else if (event.type === 'turn/start' || event.type === 'step/end' || event.type === 'turn/end') {
+                step = undefined;
+                ids = [];
+            }
+            else if (event.type === 'user/message' && step)
+                ids.push(event.data.id);
+        }
+        return ids;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Read only the official persistence API after its awaited durability checkpoint. */
+export async function verifyRecoveryCheckpoint(ctx, request, provider) {
+    if (!request.sessionId || !request.recoveryCheckpointId || !request.resumeSessionId)
+        return false;
+    const id = SessionId(request.sessionId), store = ctx.get('sessions'), session = store?.get(id);
+    const persistence = ctx.get('sessionPersistence');
+    if (!session || typeof store?.flush !== 'function' || typeof persistence?.open !== 'function')
+        return false;
+    if (!await store.flush(session))
+        return false;
+    const handle = await persistence.open(id, 'read');
+    try {
+        if (handle?.id !== id || handle.header?.id !== id || handle.access !== 'read')
+            return false;
+        const { events } = await handle.read();
+        if (!Array.isArray(events))
+            return false;
+        const final = events.findLast(e => e.type === 'assistant/message' && e.surfaceOp === 'append');
+        const live = session.deriveMessages().findLast(m => m.role === 'assistant');
+        if (final?.type !== 'assistant/message' || final.data.interrupted || !live || live.id !== final.data.message.id || !isDeepStrictEqual(live, final.data.message))
+            return false;
+        const message = final.data.message, pointer = message.source.replayState?.response;
+        if (message.source.provider !== provider || pointer?.agent !== provider || pointer.dshSessionId !== id || pointer.sessionId !== request.resumeSessionId || pointer.recoveryCheckpointId !== request.recoveryCheckpointId)
+            return false;
+        const assembled = new BlockAssembler();
+        for (const part of expandAssistantStream(final.data.stream))
+            assembled.push(part.chunk);
+        return ['stop', 'max-tokens'].includes(assembled.finish.kind) && isDeepStrictEqual(assembled.replayState, message.source.replayState) && isDeepStrictEqual(assembled.blocks(), message.content);
+    }
+    finally {
+        await handle.close();
+    }
+}

package/dist/recovery.d.ts

@@ -0,0 +1,34 @@
+import type { AgentCapabilities, SessionConfigOption } from '@agentclientprotocol/sdk/unstable';
+export interface AcpRecovery {
+    sessionId: string;
+    capabilities: AgentCapabilities;
+    modelConfiguration?: {
+        configOptions: SessionConfigOption[];
+        resolvedEvidence?: {
+            modelValue: string;
+            resolvedModel: string;
+        };
+    };
+    configUpdates?: SessionConfigOption[][];
+}
+export interface RecoveryState {
+    version: 1;
+    phase: 'dirty' | 'clean' | 'ended';
+    scope: string;
+    brokerId: string;
+    instanceId?: string;
+    pid?: number;
+    cursor?: number;
+    checkpointId?: string;
+    acp?: AcpRecovery;
+}
+export interface RecoveryJournal {
+    read(): Promise<RecoveryState | undefined>;
+    write(state: RecoveryState): Promise<void>;
+}
+export declare function validateRecovery(value: unknown): RecoveryState;
+/** Only negotiated booleans/known empty capability markers, never agent metadata. */
+export declare function recoveryCapabilities(c: AgentCapabilities): AgentCapabilities;
+export declare function recoveryKey(value: unknown): string;
+/** History is immutable; current is atomically replaced only after fsync. No expiry. */
+export declare function recoveryJournal(profileDir: string, key: string): RecoveryJournal;

package/dist/recovery.js

@@ -0,0 +1,52 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { open, rename } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { privateDirectory, durableWrite, readJournal } from "./remote-details.js";
+import { NeedError } from "./remote.js";
+const invalid = () => new NeedError('RECOVERY_STORAGE_INVALID', '会话恢复记录无效，本轮尚未发送', '有效的私有会话恢复记录');
+export function validateRecovery(value) {
+    const s = value;
+    if (!s || s.version !== 1 || !['dirty', 'clean', 'ended'].includes(s.phase) || !/^[a-f0-9]{64}$/.test(s.scope) || !/^r[a-f0-9]{23}$/.test(s.brokerId))
+        throw invalid();
+    if (s.instanceId !== undefined && !/^[a-f0-9-]{36}$/.test(s.instanceId) || s.pid !== undefined && (!Number.isSafeInteger(s.pid) || s.pid < 1))
+        throw invalid();
+    if (s.phase === 'clean' && (!s.instanceId || !Number.isSafeInteger(s.cursor) || s.cursor < 0 || typeof s.checkpointId !== 'string' || !s.checkpointId || !s.acp || typeof s.acp.sessionId !== 'string' || !s.acp.sessionId || !s.acp.capabilities || typeof s.acp.capabilities !== 'object' || Array.isArray(s.acp.capabilities)))
+        throw invalid();
+    return structuredClone(s);
+}
+/** Only negotiated booleans/known empty capability markers, never agent metadata. */
+export function recoveryCapabilities(c) {
+    return { loadSession: c.loadSession === true, promptCapabilities: { image: c.promptCapabilities?.image === true, audio: c.promptCapabilities?.audio === true, embeddedContext: c.promptCapabilities?.embeddedContext === true }, sessionCapabilities: { ...(c.sessionCapabilities?.resume ? { resume: {} } : {}), ...(c.sessionCapabilities?.systemPrompt ? { systemPrompt: {} } : {}) } };
+}
+export function recoveryKey(value) { return createHash('sha256').update(JSON.stringify(value)).digest('hex'); }
+/** History is immutable; current is atomically replaced only after fsync. No expiry. */
+export function recoveryJournal(profileDir, key) {
+    if (!/^[a-f0-9]{64}$/.test(key))
+        throw invalid();
+    const parent = join(profileDir, 'ai-workbench-remote-agent'), dir = join(parent, 'recovery', key), current = join(dir, 'current.json');
+    let tail = Promise.resolve();
+    const prepare = async () => { await privateDirectory(parent); await privateDirectory(join(parent, 'recovery')); await privateDirectory(dir); };
+    return {
+        async read() { await tail; await prepare(); try {
+            return validateRecovery(await readJournal(current));
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return;
+            throw error;
+        } },
+        write(state) { const value = validateRecovery(state); const task = tail.then(async () => { await prepare(); const id = randomUUID(); await durableWrite(join(dir, id + '.json'), value); const temp = join(dir, id + '.current'); const file = await open(temp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600); try {
+            await file.writeFile(JSON.stringify(value) + '\n');
+            await file.sync();
+        }
+        finally {
+            await file.close();
+        } await rename(temp, current); const directory = await open(dir, 'r'); try {
+            await directory.sync();
+        }
+        finally {
+            await directory.close();
+        } }); tail = task; return task; },
+    };
+}

package/dist/remote-details.d.ts

@@ -19,6 +19,9 @@ export interface DetailRequest {
     identity: string;
     connection: Connection;
 }
+export declare function privateDirectory(path: string): Promise<void>;
+export declare function durableWrite(path: string, value: unknown): Promise<void>;
+export declare function readJournal(path: string): Promise<unknown>;
 export declare function createRemoteDetails(options: {
     profileDir: string;
     getApi: () => RemoteDetailsApi | undefined;

package/dist/remote-details.js

@@ -23,7 +23,7 @@ function kind(observation) {
         return observation.severity === 'action-required' ? 'action-required' : 'unknown';
     return { extension: 'extensions', tool: 'tools', need: 'action-required', notice: 'extensions', session: 'extensions' }[observation.kind] ?? observation.kind;
 }
-async function privateDirectory(path) {
+export async function privateDirectory(path) {
     if (!isAbsolute(path))
         throw failure('REMOTE_DETAIL_STORAGE_FAILED');
     // Existing parent/profile ownership is the host's responsibility; reject symlinks
@@ -57,7 +57,7 @@ async function privateDirectory(path) {
     if ((info.mode & 0o077) !== 0 || (process.getuid && info.uid !== process.getuid()))
         throw failure('REMOTE_DETAIL_STORAGE_FAILED');
 }
-async function durableWrite(path, value) {
+export async function durableWrite(path, value) {
     const file = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
     try {
         await file.writeFile(JSON.stringify(value) + '\n');
@@ -74,7 +74,7 @@ async function durableWrite(path, value) {
         await parent.close();
     }
 }
-async function readJournal(path) {
+export async function readJournal(path) {
     const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
         const info = await file.stat();

package/dist/rpc-namespace.d.ts

@@ -0,0 +1,3 @@
+import type { Stream } from '@agentclientprotocol/sdk/unstable';
+/** Public Stream only. Server request/approval IDs are never changed. */
+export declare function isolateRpcIds(stream: Stream): Stream;

package/dist/rpc-namespace.js

@@ -0,0 +1,50 @@
+import { randomUUID } from 'node:crypto';
+import { NeedError } from "./remote.js";
+/** Public Stream only. Server request/approval IDs are never changed. */
+export function isolateRpcIds(stream) {
+    const prefix = randomUUID() + '/';
+    const pending = new Map();
+    const readable = stream.readable.pipeThrough(new TransformStream({ transform(message, controller) {
+            const raw = message;
+            if (!raw.method && Object.hasOwn(raw, 'id')) {
+                if (typeof raw.id !== 'string' || !pending.has(raw.id))
+                    throw new NeedError('ACP_FOREIGN_RESPONSE', '收到不属于当前客户端的协议响应', '原会话的完整客户端状态');
+                const id = pending.get(raw.id);
+                pending.delete(raw.id);
+                controller.enqueue({ ...raw, id });
+            }
+            else
+                controller.enqueue(message);
+        } }));
+    const writable = new WritableStream({ async write(message) {
+            const raw = message;
+            let outgoing = raw;
+            if (typeof raw.method === 'string' && Object.hasOwn(raw, 'id')) {
+                const id = prefix + JSON.stringify(raw.id);
+                pending.set(id, raw.id);
+                outgoing = { ...raw, id };
+            }
+            else if (raw.method === '$/cancel_request' && raw.params && typeof raw.params === 'object') {
+                const params = raw.params;
+                outgoing = { ...raw, params: { ...params, requestId: prefix + JSON.stringify(params.requestId) } };
+            }
+            const writer = stream.writable.getWriter();
+            try {
+                await writer.write(outgoing);
+            }
+            finally {
+                writer.releaseLock();
+            }
+        }, async close() { const writer = stream.writable.getWriter(); try {
+            await writer.close();
+        }
+        finally {
+            writer.releaseLock();
+        } }, async abort(reason) { const writer = stream.writable.getWriter(); try {
+            await writer.abort(reason);
+        }
+        finally {
+            writer.releaseLock();
+        } } });
+    return { readable, writable };
+}

package/dist/stage-timing.d.ts

@@ -0,0 +1,27 @@
+import type { DetailObservation } from './conversation-details.ts';
+export declare const STAGES: Readonly<{
+    readonly 'login-ready': "登录就绪检查";
+    readonly 'connection-confirm': "核对当前连接状态";
+    readonly 'input-prepare': "准备本轮输入";
+    readonly 'workspace-resolve': "解析工作区";
+    readonly 'details-open': "打开技术详情";
+    readonly 'details-flush': "等待技术详情持久确认";
+    readonly 'workspace-notice': "记录工作区说明";
+    readonly 'broker-list': "查询主机会话";
+    readonly 'broker-start': "启动主机会话";
+    readonly 'broker-attach': "连接主机会话";
+    readonly 'acp-initialize': "初始化远程模型";
+    readonly 'acp-session-new': "新建模型会话";
+    readonly 'acp-session-load': "加载模型会话";
+    readonly 'acp-session-resume': "恢复模型会话";
+    readonly 'acp-prompt': "模型处理本轮（含等待审批）";
+}>;
+export type Stage = keyof typeof STAGES;
+/** Passive client observations; no thresholds, retries, or remote-clock claims. */
+export declare class StageTiming {
+    private readonly started;
+    private pending;
+    private sink?;
+    bind(sink: (detail: DetailObservation) => void): void;
+    run<T>(phase: Stage, operation: () => Promise<T>): Promise<T>;
+}

package/dist/stage-timing.js

@@ -0,0 +1,39 @@
+export const STAGES = Object.freeze({
+    'login-ready': '登录就绪检查', 'connection-confirm': '核对当前连接状态', 'input-prepare': '准备本轮输入', 'workspace-resolve': '解析工作区',
+    'details-open': '打开技术详情', 'details-flush': '等待技术详情持久确认', 'workspace-notice': '记录工作区说明',
+    'broker-list': '查询主机会话', 'broker-start': '启动主机会话', 'broker-attach': '连接主机会话',
+    'acp-initialize': '初始化远程模型', 'acp-session-new': '新建模型会话',
+    'acp-session-load': '加载模型会话', 'acp-session-resume': '恢复模型会话',
+    'acp-prompt': '模型处理本轮（含等待审批）',
+});
+/** Passive client observations; no thresholds, retries, or remote-clock claims. */
+export class StageTiming {
+    started = performance.now();
+    pending = [];
+    sink;
+    bind(sink) {
+        this.sink = sink;
+        const pending = this.pending;
+        this.pending = [];
+        for (const detail of pending)
+            sink(detail);
+    }
+    async run(phase, operation) {
+        const started = performance.now();
+        let outcome = 'failed';
+        try {
+            const result = await operation();
+            outcome = 'ok';
+            return result;
+        }
+        finally {
+            const ended = performance.now();
+            const durationMs = ended - started, elapsedMs = ended - this.started;
+            const detail = { kind: 'session', severity: outcome === 'ok' ? 'info' : 'warning', code: 'REMOTE_STAGE_TIMING', summary: STAGES[phase] + '：' + durationMs.toFixed(1) + '毫秒', payload: { phase, durationMs, elapsedMs, outcome, clock: 'client-monotonic' } };
+            if (this.sink)
+                this.sink(detail);
+            else
+                this.pending.push(detail);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-workbench/remote-agent",
-  "version": "0.8.2",
+  "version": "0.8.5",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,7 +19,7 @@
     "cordis.patch.yml"
   ],
   "scripts": {
-    "test": "npm run build && node --test lib/test/*.test.js",
+    "test": "npm run build && node --test --test-concurrency=1 lib/test/*.test.js",
     "typecheck": "node node_modules/typescript/bin/tsc --noEmit",
     "build": "node node_modules/typescript/bin/tsc && node node_modules/typescript/bin/tsc -p tsconfig.build.json && chmod 755 lib/src/sdk-ssh-wrapper.js dist/sdk-ssh-wrapper.js && node tools/build-client.mjs",
     "probe:host": "node tools/probe-host.ts",
@@ -36,7 +36,7 @@
     "zod": "4.6.7"
   },
   "devDependencies": {
-    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.11.tgz",
+    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.13.tgz",
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/cordis-plugin-group": "1.0.4",
     "@deepseek-ai/cordis-plugin-include": "1.0.9",
@@ -56,7 +56,7 @@
     "@deepseek-ai/dsh-attachment": "0.2.0-rc.2"
   },
   "peerDependencies": {
-    "@ai-workbench/connect": "~0.7.11",
+    "@ai-workbench/connect": "~0.7.13",
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
     "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",