@ai-workbench/remote-agent 0.0.0-stage → 0.8.1

package/dist/provider.js

@@ -0,0 +1,164 @@
+import { NeedError } from "./remote.js";
+import { CONNECTION_REQUIRED, TEST_HOST_NOTICE } from "./presentation.js";
+import { CODEX_AGENT } from "./agents.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');
+}
+export function requireLoginState(state) {
+    const object = (v) => !!v && typeof v === 'object' && !Array.isArray(v) && (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
+    const need = (v) => object(v) && typeof v.code === 'string' && v.code.length > 0 && ['enrollment', 'network', 'ssh', 'auth', 'integration', 'settings', 'projects'].includes(v.layer) && typeof v.message === 'string' && typeof v.requires === 'string' && ['employee', 'administrator', 'ai-administrator', 'plugin'].includes(v.actor) && object(v.action) && typeof v.action.id === 'string' && typeof v.action.label === 'string' && typeof v.action.available === 'boolean';
+    if (!Array.isArray(state.checkingProviders) || state.checkingProviders.some(p => p !== 'codex' && p !== 'claude') || !object(state.providerNeeds) || Object.entries(state.providerNeeds).some(([p, v]) => !['codex', 'claude'].includes(p) || !need(v)))
+        throw new NeedError('CONNECT_API_MISMATCH', '我需要按助手区分的真实登录状态', 'L >=0.6.1');
+}
+/** Cancel only this consumer's wait; L owns the shared flight and its lifetime. */
+export function awaitL(operation, signal) {
+    signal?.throwIfAborted();
+    const shared = operation();
+    if (!signal)
+        return shared;
+    return new Promise((resolve, reject) => {
+        const clear = () => signal.removeEventListener('abort', abort);
+        const abort = () => { clear(); reject(new NeedError('ABORTED', 'consumer wait cancelled', 'employee action')); };
+        signal.addEventListener('abort', abort, { once: true });
+        void shared.then(value => { clear(); resolve(value); }, error => { clear(); reject(error); });
+        if (signal.aborted)
+            abort();
+    });
+}
+function verifiedLogin(api, brand, expected) {
+    requireLoginCoordinator(api);
+    const connection = api.getConnectionState(), login = api.getLoginPromptState();
+    if (!connection.instanceId || !Number.isSafeInteger(connection.epoch) || connection.epoch < 0 || connection.phase !== 'connected' || expected && (connection.instanceId !== expected.instanceId || connection.epoch !== expected.epoch))
+        throw new NeedError('CONNECTION_LOST', 'connection binding changed', 'current employee connection');
+    requireLoginState(login);
+    if (login.instanceId !== connection.instanceId || login.checkingProviders.includes(brand) || login.providerNeeds[brand] || login.phase === 'blocked' || login.phase === 'disposed' || login.phase === 'authorizing' && login.provider === brand || typeof login.logins?.[brand] !== 'boolean')
+        throw new NeedError('AUTH_STATUS_INVALID', '无法确认当前品牌的登录状态', 'L核验的本品牌登录状态');
+    if (!login.logins[brand])
+        throw new NeedError('LOGIN_REQUIRED', '需要登录，请到设置 → 远程主机连接 点登录', '本人登录');
+    return { ...connection };
+}
+export function unwrap(result) {
+    if (!result.ok)
+        throw new NeedError(result.error.code, result.error.message, result.error.requires);
+    return result.value;
+}
+export function validateTarget(t) {
+    if (!t || !t.knownHostsFile?.startsWith('/') || !t.proxyCommand || t.session?.protocolVersion !== 1
+        || ![t.projectRoot, t.session.command, t.session.root, t.session.settingsPath].every(p => typeof p === 'string' && p.startsWith('/'))) {
+        throw new NeedError('CONNECT_API_MISMATCH', '我需要 connect-api 0.3.0 的可信主机、项目和 session 能力；旧目标不能继续使用', 'L 提供的完整 0.3.0 目标');
+    }
+    hostContextNotice(t);
+}
+/** Only the declared public check identifiers/statuses, never provider evidence. */
+export function hostContextNotice(t) {
+    const h = t.hostContext;
+    if (h === undefined)
+        return;
+    const checks = (items) => Array.isArray(items) && items.every(item => item && typeof item.id === 'string' && typeof item.status === 'string');
+    if (!h || (h.enforcement !== 'test' && h.enforcement !== 'production') || (h.checkExitCode !== 0 && h.checkExitCode !== 1) || !checks(h.failedChecks) || !checks(h.unverifiedChecks))
+        throw new NeedError('CONNECT_API_MISMATCH', '主机检查背景无效，不能假定已通过生产检查', 'L 提供的有效 hostContext');
+    if (h.enforcement !== 'test')
+        return;
+    return TEST_HOST_NOTICE;
+}
+export function identity(t) { return `${t.username}@${t.host}:${t.port}`; }
+/** Reject draft.3 and legacy runtime rather than inventing workspace bindings. */
+export function requireNativeWorkspace(api) {
+    if (typeof api.getContractInfo !== 'function')
+        throw new NeedError('DEPENDENCY_REQUIRED', '我需要新版远程主机连接组件提供原生工作区绑定', 'L connect-api 0.7.0 / native-local-v1');
+    const info = api.getContractInfo();
+    if (info?.apiVersion !== '0.7.0' || info.status !== 'implemented' || info.workspaceBinding !== 'native-local-v1' || !['ensureReady', 'resolveSessionProject', 'acknowledgeWorkspaceNotice'].every(key => typeof api[key] === 'function'))
+        throw new NeedError('DEPENDENCY_REQUIRED', '我需要新版远程主机连接组件提供原生工作区绑定', 'L connect-api 0.7.0 / native-local-v1');
+}
+/** Authorization stays in L; ensureReady only checks and records the need. */
+export async function offerLogin(connect, request, currentApi, agent = CODEX_AGENT) {
+    requireNativeWorkspace(connect);
+    request.signal?.throwIfAborted();
+    const before = connect.getConnectionState();
+    const target = unwrap(await awaitL(() => connect.ensureReady(agent.loginProvider), request.signal));
+    validateTarget(target);
+    request.signal?.throwIfAborted();
+    if (currentApi && currentApi() !== connect)
+        throw new NeedError('CONNECTION_LOST', '远程主机连接组件已更换', '当前员工连接');
+    verifiedLogin(connect, agent.loginProvider, before);
+}
+export function sameTarget(a, b) {
+    return identity(a) === identity(b) && a.projectRoot === b.projectRoot && a.knownHostsFile === b.knownHostsFile && a.proxyCommand === b.proxyCommand && a.session.command === b.session.command && a.session.root === b.session.root && a.session.settingsPath === b.session.settingsPath;
+}
+export function connectProvider(get, options = {}) {
+    const agent = options.agent ?? CODEX_AGENT;
+    const admissions = new WeakMap();
+    const preflight = async (request) => {
+        request.signal?.throwIfAborted();
+        const api = get();
+        if (!api)
+            throw new NeedError('DEPENDENCY_REQUIRED', CONNECTION_REQUIRED, 'aiWorkbenchConnect');
+        requireNativeWorkspace(api);
+        requireLoginCoordinator(api);
+        if (request.mode === 'one-shot' && !agent.oneShot)
+            throw new NeedError('MODE_UNSUPPORTED', '此远程模型仅支持会话模式', '使用会话模式');
+        const before = api.getConnectionState();
+        const target = unwrap(await awaitL(() => api.ensureReady(agent.loginProvider), request.signal));
+        validateTarget(target);
+        request.signal?.throwIfAborted();
+        if (get() !== api)
+            throw new NeedError('CONNECTION_LOST', '远程主机连接组件已更换', '当前员工连接');
+        const connection = verifiedLogin(api, agent.loginProvider, before);
+        if (request.identity && request.identity !== identity(target))
+            throw new NeedError('SESSION_CONTEXT_MISMATCH', '员工主机与原会话不一致，请新建会话', '原员工主机');
+        admissions.set(request, { api, target, connection });
+    };
+    const resolve = async (request) => {
+        if (!admissions.has(request))
+            await preflight(request);
+        const admitted = admissions.get(request);
+        admissions.delete(request);
+        const { api, target, connection } = admitted;
+        const stable = () => { request.signal?.throwIfAborted(); if (get() !== api)
+            throw new NeedError('CONNECTION_LOST', '远程主机连接组件已更换', '当前员工连接'); verifiedLogin(api, agent.loginProvider, connection); };
+        stable();
+        if (!request.sessionId)
+            throw new NeedError('PROJECT_BINDING_REQUIRED', '我需要当前会话和已选择的工作区，请使用原生工作区入口', 'DSH会话与原生工作区');
+        await options.notice?.reconcile(request, api);
+        stable();
+        const resolved = unwrap(await awaitL(() => api.resolveSessionProject(request.sessionId, { provider: agent.loginProvider, purpose: 'user-turn' }), request.signal));
+        stable();
+        if (!resolved || resolved.instanceId !== connection.instanceId || resolved.epoch !== connection.epoch)
+            throw new NeedError('CONNECTION_LOST', '工作区解析回复已失效', '当前连接代次');
+        validateTarget(resolved.target);
+        const project = resolved.project;
+        if (resolved.sessionId !== request.sessionId || !resolved.workspaceId || !resolved.bindingId || !Number.isSafeInteger(resolved.bindingRevision) || resolved.bindingRevision < 1 || !sameTarget(target, resolved.target) || !project || typeof project.name !== 'string' || !project.name || project.name === '.' || project.name === '..' || /[\\/\x00-\x1f\x7f]/.test(project.name) || project.path !== resolved.target.projectRoot + '/' + project.name)
+            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);
+        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);
+            stable();
+        }
+        if (!options.open)
+            throw new NeedError('RUNTIME_REQUIRED', '我需要主机运行适配器', '主机broker适配');
+        const runtime = await options.open(resolved.target, project, { ...request, agent });
+        try {
+            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;
+    };
+    resolve.preflight = preflight;
+    return resolve;
+}

package/dist/readiness.d.ts

@@ -0,0 +1,28 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type ConnectApi } from './provider.ts';
+import { type AgentDefinition } from './agents.ts';
+export interface TechnicalDetail {
+    label: string;
+    value: string;
+}
+export interface ReadinessState {
+    phase: 'checking' | 'ready' | 'login-required' | 'blocked';
+    loginStatus: 'logged-in' | 'not-logged-in' | 'unknown';
+    title: string;
+    message: string;
+    technical: TechnicalDetail[];
+}
+export declare function createReadiness(get: () => ConnectApi | undefined, agent?: AgentDefinition): {
+    run(operation: string, payload: unknown, signal: AbortSignal): Promise<ReadinessState>;
+};
+export interface ReadinessWatch {
+    cursor: string;
+    available: boolean;
+    message: string;
+}
+/** One latest semantic snapshot, no history queue, polling or auth-check feedback loop. */
+export declare function createReadinessWatch(subscribe: (connection: () => void, prompt: () => void) => () => void, get: () => ConnectApi | undefined, agent?: AgentDefinition): {
+    watch(after: unknown, signal: AbortSignal): Promise<ReadinessWatch>;
+    dispose: () => void;
+};
+export declare function installReadiness(ctx: Context, get: () => ConnectApi | undefined, agent?: AgentDefinition): void;

package/dist/readiness.js

@@ -0,0 +1,192 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { randomUUID } from 'node:crypto';
+import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { unwrap, awaitL, requireLoginCoordinator, requireLoginState } from "./provider.js";
+import { NeedError } from "./remote.js";
+import { CONNECTION_REQUIRED, employeeFailure } from "./presentation.js";
+import { CODEX_AGENT } from "./agents.js";
+function details(target) {
+    const h = target.hostContext;
+    if (!h)
+        return [];
+    return [{ label: '主机配置', value: h.enforcement }, { label: '检查退出码', value: String(h.checkExitCode) }, ...h.failedChecks.map(item => ({ label: '未通过检查', value: `${item.id}（${item.status}）` })), ...h.unverifiedChecks.map(item => ({ label: '未核实检查', value: `${item.id}（${item.status}）` }))];
+}
+function blocked(code, technical = [], agent = CODEX_AGENT) {
+    return { phase: 'blocked', loginStatus: 'unknown', title: `无法确认 ${agent.name.zh} 登录状态`, message: employeeFailure(code), technical: [...technical, { label: '诊断代码', value: code }] };
+}
+/** L owns both evidence and inquiry. Missing per-brand evidence is never false. */
+function snapshot(api, agent = CODEX_AGENT) {
+    const brand = agent.loginProvider;
+    const denied = (code, technical = []) => blocked(code, technical, agent);
+    requireLoginCoordinator(api);
+    const connection = api.getConnectionState();
+    if (connection.phase !== 'connected')
+        return denied(connection.need?.code ?? (connection.phase === 'disposed' ? 'DISPOSED' : 'CONNECTION_LOST'));
+    const state = api.getLoginPromptState();
+    if (!connection.instanceId || state.instanceId !== connection.instanceId)
+        return denied('AUTH_STATUS_INVALID');
+    requireLoginState(state);
+    const technical = details({ hostContext: state.technicalDetails?.hostContext });
+    if (state.phase === 'blocked' || state.phase === 'disposed')
+        return denied(state.technicalDetails?.code ?? 'AUTH_STATUS_INVALID', technical);
+    if (state.checkingProviders.includes(brand) || state.phase === 'authorizing' && state.provider === brand)
+        return { phase: 'checking', loginStatus: 'unknown', title: `正在检查 ${agent.name.zh} 登录状态`, message: '远程主机连接正在检查登录状态。', technical };
+    if (state.providerNeeds[brand])
+        return denied(state.providerNeeds[brand].code, technical);
+    if (typeof state.logins?.[brand] !== 'boolean')
+        return denied('AUTH_STATUS_INVALID', technical);
+    return state.logins[brand] ? { phase: 'ready', loginStatus: 'logged-in', title: `${agent.name.zh}已登录`, message: '本次远程主机连接和主机登录检查已完成。', technical } : { phase: 'login-required', loginStatus: 'not-logged-in', title: `${agent.name.zh} 尚未登录`, message: '需要登录，请到设置 → 远程主机连接 点登录', technical };
+}
+export function createReadiness(get, agent = CODEX_AGENT) {
+    return { async run(operation, payload, signal) {
+            try {
+                signal.throwIfAborted();
+                if (!['status', 'request', 'refresh'].includes(operation) || !payload || typeof payload !== 'object' || Array.isArray(payload) || Object.keys(payload).length)
+                    throw new NeedError('INVALID_REQUEST', 'invalid readiness request', 'readiness request');
+                const api = get();
+                if (!api)
+                    return blocked('DEPENDENCY_REQUIRED', [{ label: '组件标识', value: 'ai-workbench-connect' }, { label: '管理员处理', value: '安装并启用连接组件；检查 aiWorkbenchConnect 服务' }]);
+                requireLoginCoordinator(api);
+                const before = api.getConnectionState();
+                if (operation === 'request')
+                    unwrap(await awaitL(() => api.requestLoginPrompt(agent.loginProvider, 'automatic'), signal));
+                if (operation === 'refresh')
+                    unwrap(await awaitL(() => api.refreshLoginPrompts(), signal));
+                signal.throwIfAborted();
+                const current = api.getConnectionState();
+                if (get() !== api || current.instanceId !== before.instanceId || current.epoch !== before.epoch)
+                    throw new NeedError('CONNECTION_LOST', 'connection epoch changed during check', 'current employee connection');
+                return snapshot(api, agent);
+            }
+            catch (error) {
+                return blocked(signal.aborted ? 'ABORTED' : error instanceof NeedError ? error.code : 'READINESS_FAILED', [], agent);
+            }
+        } };
+}
+/** One latest semantic snapshot, no history queue, polling or auth-check feedback loop. */
+export function createReadinessWatch(subscribe, get, agent = CODEX_AGENT) {
+    const epoch = randomUUID(), lifetime = new AbortController();
+    let revision = 0, key = '', owner, lastEpoch = -1, lastPrompt = -1, instance = '';
+    let current = { cursor: `${epoch}:0`, available: false, message: CONNECTION_REQUIRED };
+    const waiters = new Set();
+    const changed = () => {
+        const api = get();
+        let value, available = false;
+        try {
+            if (!api) {
+                value = blocked('DEPENDENCY_REQUIRED');
+            }
+            else {
+                requireLoginCoordinator(api);
+                const connection = api.getConnectionState(), prompt = api.getLoginPromptState();
+                if (api !== owner || connection.instanceId !== instance) {
+                    owner = api;
+                    instance = connection.instanceId;
+                    lastEpoch = -1;
+                    lastPrompt = -1;
+                }
+                if (connection.epoch < lastEpoch)
+                    return;
+                if (prompt.instanceId === instance) {
+                    if (connection.epoch === lastEpoch && prompt.revision < lastPrompt)
+                        return;
+                    lastPrompt = prompt.revision;
+                }
+                lastEpoch = connection.epoch;
+                available = connection.phase === 'connected';
+                value = snapshot(api, agent);
+            }
+        }
+        catch (error) {
+            value = blocked(error instanceof NeedError ? error.code : 'READINESS_FAILED');
+        }
+        const next = JSON.stringify([instance, lastEpoch, available, value]);
+        if (next === key)
+            return;
+        key = next;
+        current = { cursor: `${epoch}:${++revision}`, available, message: available ? '' : value.message };
+        for (const waiter of [...waiters])
+            waiter();
+    };
+    const off = subscribe(changed, changed);
+    changed();
+    return {
+        async watch(after, signal) {
+            if (after !== null && typeof after !== 'string')
+                throw new NeedError('INVALID_REQUEST', 'invalid readiness cursor', 'readiness cursor');
+            const cancelled = AbortSignal.any([signal, lifetime.signal]);
+            cancelled.throwIfAborted();
+            if (after !== current.cursor)
+                return { ...current };
+            return new Promise((resolve, reject) => {
+                const clear = () => { waiters.delete(update); cancelled.removeEventListener('abort', abort); };
+                const update = () => { clear(); resolve({ ...current }); };
+                const abort = () => { clear(); reject(new NeedError('ABORTED', 'readiness watch cancelled', 'new check')); };
+                waiters.add(update);
+                cancelled.addEventListener('abort', abort, { once: true });
+                if (cancelled.aborted)
+                    abort();
+            });
+        }, dispose: () => { off(); lifetime.abort(); },
+    };
+}
+let ReadinessRemote = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _run_decorators;
+    let _watch_decorators;
+    return class ReadinessRemote extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _run_decorators = [Remote];
+            _watch_decorators = [Remote];
+            __esDecorate(this, null, _run_decorators, { kind: "method", name: "run", static: false, private: false, access: { has: obj => "run" in obj, get: obj => obj.run }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _watch_decorators, { kind: "method", name: "watch", static: false, private: false, access: { has: obj => "watch" in obj, get: obj => obj.watch }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        readiness = __runInitializers(this, _instanceExtraInitializers);
+        changes;
+        constructor(ctx, get, agent) {
+            super(ctx, 'awCodexReadiness');
+            this.readiness = createReadiness(get, agent);
+            this.changes = createReadinessWatch((connection, prompt) => { const a = ctx.on('ai-workbench/connection-state', connection), b = ctx.on('ai-workbench/login-prompt-state', prompt); return () => { a(); b(); }; }, get, agent);
+            ctx.effect(() => () => this.changes.dispose());
+        }
+        async run(operation, payload, signal) { return this.readiness.run(operation, payload, signal); }
+        async watch(after, signal) { return this.changes.watch(after, signal); }
+    };
+})();
+export function installReadiness(ctx, get, agent = CODEX_AGENT) { new ReadinessRemote(ctx, get, agent); }

package/dist/remote-details.d.ts

@@ -0,0 +1,26 @@
+import { type DetailObservation } from './conversation-details.ts';
+import type { ConnectApi as LConnectApi, ConnectionState } from '@ai-workbench/connect/api';
+export type { RemoteConversationDetail as RemoteDetail } from '@ai-workbench/connect/api';
+type Connection = Pick<ConnectionState, 'instanceId' | 'epoch' | 'phase'>;
+export type RemoteDetailsApi = Pick<LConnectApi, 'getConnectionState'> & Partial<Pick<LConnectApi, 'getContractInfo' | 'appendRemoteConversationDetail' | 'getRemoteConversationDetailReceipt' | 'listRemoteConversationDetails'>>;
+export interface DetailChannel {
+    record(observation: DetailObservation): void;
+    beginTurn(ids: {
+        turn: string | number | null;
+        step: string | number | null;
+    }): void;
+    endTurn(): void;
+    flush(): Promise<void>;
+}
+export interface DetailRequest {
+    sessionId: string;
+    provider: 'claude' | 'codex';
+    identity: string;
+    connection: Connection;
+}
+export declare function createRemoteDetails(options: {
+    profileDir: string;
+    getApi: () => RemoteDetailsApi | undefined;
+}): {
+    open(request: DetailRequest): Promise<DetailChannel>;
+};