ds-harness-remote 0.4.9 → 0.4.12

package/dist/codex/virtual-harness.js

@@ -1,4 +1,5 @@
 import { CodexRemoteClient, deriveCodexCwdWorkspaces, projectCodexThread, } from '@dsh-remote/client-core';
+import { codexPermissionPresetFromResponse } from './permissions.js';
 const CODEX_SESSION_PREFIX = 'codex:';
 const CODEX_WORKSPACE_PREFIX = 'codex-workspace:';
 const CODEX_PROVIDER = 'codex';
@@ -31,6 +32,7 @@ export async function discoverCodexVirtualWorkspaces(client, signal) {
 export class CodexVirtualHarness {
     client;
     host;
+    sessionGeneration;
     api;
     catalog;
     workspaceStreams = new Set();
@@ -52,13 +54,14 @@ export class CodexVirtualHarness {
     commandSeq = 0;
     selectedWorkspaceId;
     closed = false;
-    constructor(client, host) {
+    constructor(client, host, sessionGeneration = 'legacy') {
         this.client = client;
         this.host = host;
+        this.sessionGeneration = sessionGeneration;
         this.api = this.createApiProxy();
     }
-    static remote(core, host) {
-        return new CodexVirtualHarness(new CodexRemoteClient(core), host);
+    static remote(core, host, sessionGeneration = 'legacy') {
+        return new CodexVirtualHarness(new CodexRemoteClient(core), host, sessionGeneration);
     }
     async workspaces(signal) {
         return (await this.refreshCatalog(signal)).workspaces;
@@ -245,10 +248,13 @@ export class CodexVirtualHarness {
         return this.selectedModels.get(sessionId) ?? directory?.default ?? modelSelection();
     }
     permissionSelection(sessionId) {
-        return this.selectedPermissions.get(sessionId) ?? CODEX_DEFAULT_PERMISSION;
+        return this.selectedPermissions.get(sessionId);
     }
     setPermissionSelection(sessionId, preset) {
-        this.selectedPermissions.set(sessionId, preset);
+        if (preset === undefined)
+            this.selectedPermissions.delete(sessionId);
+        else
+            this.selectedPermissions.set(sessionId, preset);
         this.publishProjection(sessionId, 'permissions', codexPermissionsProjection(preset), this.nextProjectionSeq());
     }
     commandList(args) {
@@ -275,19 +281,25 @@ export class CodexVirtualHarness {
                 result: { kind: 'error', text: 'CodeX Remote permission commands do not accept attachments.' },
             };
         const requested = (match[1] ?? '').trim();
-        if (requested === '')
+        if (requested === '') {
+            await this.readHistoryPage(threadId, { maxMessages: 1 }, signal);
             return {
                 commandId,
-                result: { kind: 'success', text: `current preset ${this.permissionSelection(sessionId)}` },
+                result: { kind: 'success', text: `current preset ${this.permissionSelection(sessionId) ?? 'Host settings (not reported)'}` },
             };
+        }
         if (!isCodexPermissionPreset(requested))
             return {
                 commandId,
                 result: { kind: 'error', text: `unknown preset "${requested}" (available: workspace-write, danger-full-access)` },
             };
         const result = await this.client.request('thread/resume', { threadId, permissionPreset: requested }, signal);
-        const effective = codexPermissionPresetFromResponse(result) ?? requested;
+        const effective = codexPermissionPresetFromResponse(result);
+        if (effective === undefined)
+            throw new Error('The Host did not confirm the CodeX permission preset.');
         this.setPermissionSelection(sessionId, effective);
+        if (effective !== requested)
+            throw new Error('The Host did not apply the requested CodeX permission preset.');
         return { commandId, result: { kind: 'success', text: `preset ${effective}` } };
     }
     sessionTitle(sessionId) {
@@ -446,6 +458,7 @@ export class CodexVirtualHarness {
             streamedBlocks: new Map(),
             nextBlockIndex: 0,
             streamActive: false,
+            assistantStreamRevision: 0,
             liveItems: new Map(),
             liveToolOutput: new Map(),
             liveToolResultSeq: new Map(),
@@ -470,6 +483,7 @@ export class CodexVirtualHarness {
                     imageLimits: codexImageLimitsProjection(),
                 },
             },
+            ...(this.sessionGeneration === 'v3' ? { assistantStream: { revision: 0 } } : {}),
         });
         try {
             const stream = await this.client.subscribe(threadId, frame => this.acceptCodexFrame(follow, frame), signal, () => this.closeFollowAfterRemoteStreamClosed(follow));
@@ -499,12 +513,12 @@ export class CodexVirtualHarness {
         }
         if (frame.method === 'thread/settings/updated') {
             const preset = codexPermissionPresetFromResponse(params);
-            if (preset !== undefined)
-                this.setPermissionSelection(follow.sessionId, preset);
+            this.setPermissionSelection(follow.sessionId, preset);
             return;
         }
         if (frame.method === 'turn/started') {
             const turn = record(params.turn);
+            this.endAssistantAttempt(follow, { kind: 'abandoned' });
             this.resetLiveTurn(follow);
             follow.turn += 1;
             follow.activeTurnId = string(turn.id);
@@ -641,6 +655,7 @@ export class CodexVirtualHarness {
                 this.closeAllStreamBlocks(follow);
                 if (follow.streamActive)
                     this.finishStream(follow);
+                this.endAssistantAttempt(follow, { kind: 'abandoned' });
                 this.pushEvent(follow, 'step/end', { turn: follow.turn, step: 1 });
                 follow.stepOpen = false;
             }
@@ -686,13 +701,24 @@ export class CodexVirtualHarness {
         if (type === 'agentMessage' && follow.streamActive && follow.streamedBlocks.size === 0)
             this.finishStream(follow);
         const supplementalImages = type === 'agentMessage' ? follow.pendingToolImages : [];
+        let assistantMessageSeq;
         for (const event of itemEvents(item, follow.turn, 1, follow.requestId, this.modelSelection(follow.sessionId), follow.sessionId, supplementalImages)) {
             if (event.type === 'tool/call' && follow.startedItems.has(itemId))
                 continue;
             if (event.type === 'tool/result')
                 this.pushToolResult(follow, itemId, event);
-            else
-                this.pushEvent(follow, event.type, event.data, event.view);
+            else {
+                const seq = this.pushEvent(follow, event.type, event.data, event.view);
+                if (event.type === 'assistant/message')
+                    assistantMessageSeq = seq;
+            }
+        }
+        if (type === 'agentMessage' && assistantMessageSeq !== undefined) {
+            this.endAssistantAttempt(follow, {
+                kind: 'committed',
+                eventType: 'assistant/message',
+                seq: assistantMessageSeq,
+            });
         }
         if (type === 'agentMessage' && supplementalImages.length > 0)
             follow.pendingToolImages = [];
@@ -710,24 +736,25 @@ export class CodexVirtualHarness {
             type,
             seq,
             time: Date.now(),
-            data,
+            data: adaptEventData(type, type === 'assistant/message' && this.sessionGeneration === 'v3' && follow.assistantAttempt !== undefined
+                ? { ...record(data), stream: follow.assistantAttempt.stream }
+                : data, this.sessionGeneration),
             ...(isSurfaceEvent(type)
                 ? placement === undefined
                     ? { surfaceOp: 'append' }
                     : {
-                        surfaceOp: { op: 'replace', start: placement.replaceSeq, end: placement.replaceSeq },
+                        surfaceOp: this.sessionGeneration === 'v3'
+                            ? { op: 'replace', startSeq: placement.replaceSeq, endSeq: placement.replaceSeq }
+                            : { op: 'replace', start: placement.replaceSeq, end: placement.replaceSeq },
                         sourceEventSeqs: [placement.replaceSeq],
                     }
                 : {}),
         };
         this.cacheImageBlocks(follow.sessionId, event.data);
         if (!follow.rcOnly) {
-            const alphaEvent = typeof event.surfaceOp === 'object'
-                ? { ...event, surfaceOp: 'replace' }
-                : event;
             follow.queue.push({
                 type: 'event',
-                event: alphaEvent,
+                event,
                 ...(view === undefined ? {} : { view }),
             });
         }
@@ -756,52 +783,100 @@ export class CodexVirtualHarness {
         const block = { itemId, index: follow.nextBlockIndex++, kind, text: '' };
         follow.streamedBlocks.set(key, block);
         follow.streamActive = true;
-        this.pushEvent(follow, 'assistant/chunk', {
-            turn: follow.turn,
-            step: 1,
-            chunk: { type: 'block-start', index: block.index, blockType: kind },
-        });
+        this.pushAssistantChunk(follow, { type: 'block-start', index: block.index, blockType: kind });
         return block;
     }
     appendStreamDelta(follow, key, itemId, kind, delta) {
         const block = this.ensureStreamBlock(follow, key, itemId, kind);
         block.text = appendBoundedText(block.text, delta);
-        this.pushEvent(follow, 'assistant/chunk', {
-            turn: follow.turn,
-            step: 1,
-            chunk: { type: kind === 'reasoning' ? 'reasoning-delta' : 'text-delta', index: block.index, text: delta },
+        this.pushAssistantChunk(follow, {
+            type: kind === 'reasoning' ? 'reasoning-delta' : 'text-delta', index: block.index, text: delta,
         });
     }
     closeItemStreamBlocks(follow, itemId, fallback) {
         const matches = [...follow.streamedBlocks].filter(([, block]) => block.itemId === itemId);
         for (const [key, block] of matches) {
             const text = block.text || fallback || '';
-            this.pushEvent(follow, 'assistant/chunk', {
-                turn: follow.turn,
-                step: 1,
-                chunk: { type: 'block-end', index: block.index, block: { type: block.kind, text } },
+            this.pushAssistantChunk(follow, {
+                type: 'block-end', index: block.index, block: { type: block.kind, text },
             });
             follow.streamedBlocks.delete(key);
         }
     }
     closeAllStreamBlocks(follow) {
         for (const block of follow.streamedBlocks.values()) {
-            this.pushEvent(follow, 'assistant/chunk', {
-                turn: follow.turn,
-                step: 1,
-                chunk: { type: 'block-end', index: block.index, block: { type: block.kind, text: block.text } },
+            this.pushAssistantChunk(follow, {
+                type: 'block-end', index: block.index, block: { type: block.kind, text: block.text },
             });
         }
         follow.streamedBlocks.clear();
     }
     finishStream(follow) {
-        this.pushEvent(follow, 'assistant/chunk', {
-            turn: follow.turn,
-            step: 1,
-            chunk: { type: 'finish', reason: { kind: 'stop' } },
-        });
+        this.pushAssistantChunk(follow, { type: 'finish', reason: { kind: 'stop' } });
         follow.streamActive = false;
     }
+    pushAssistantChunk(follow, chunk) {
+        if (this.sessionGeneration !== 'v3' || follow.rcOnly === true) {
+            this.pushEvent(follow, 'assistant/chunk', { turn: follow.turn, step: 1, chunk });
+            return;
+        }
+        let attempt = follow.assistantAttempt;
+        if (attempt === undefined) {
+            attempt = {
+                attemptId: `codex-attempt:${follow.activeTurnId ?? follow.turn}:${follow.nextSeq}`,
+                startedAfterSeq: follow.nextSeq - 1,
+                nextIndex: 0,
+                stream: [],
+            };
+            follow.assistantAttempt = attempt;
+            follow.assistantStreamRevision += 1;
+            follow.queue.push({
+                type: 'assistant-stream',
+                frame: {
+                    type: 'start',
+                    attemptId: attempt.attemptId,
+                    revision: follow.assistantStreamRevision,
+                    startedAfterSeq: attempt.startedAfterSeq,
+                    turn: follow.turn,
+                    step: 1,
+                },
+            });
+        }
+        const time = Date.now();
+        const index = attempt.nextIndex++;
+        attempt.stream.push({ time, chunk });
+        follow.assistantStreamRevision += 1;
+        follow.queue.push({
+            type: 'assistant-stream',
+            frame: {
+                type: 'chunk',
+                attemptId: attempt.attemptId,
+                revision: follow.assistantStreamRevision,
+                index,
+                time,
+                chunk,
+            },
+        });
+    }
+    endAssistantAttempt(follow, outcome) {
+        const attempt = follow.assistantAttempt;
+        if (attempt === undefined)
+            return;
+        follow.assistantAttempt = undefined;
+        follow.assistantStreamRevision += 1;
+        if (this.sessionGeneration === 'v3' && follow.rcOnly !== true) {
+            follow.queue.push({
+                type: 'assistant-stream',
+                frame: {
+                    type: 'end',
+                    attemptId: attempt.attemptId,
+                    revision: follow.assistantStreamRevision,
+                    index: attempt.nextIndex,
+                    outcome,
+                },
+            });
+        }
+    }
     ensureToolStarted(follow, item) {
         const itemId = string(item.id);
         if (itemId === undefined)
@@ -835,6 +910,7 @@ export class CodexVirtualHarness {
         follow.streamedBlocks.clear();
         follow.nextBlockIndex = 0;
         follow.streamActive = false;
+        follow.assistantAttempt = undefined;
         follow.liveItems.clear();
         follow.liveToolOutput.clear();
         follow.liveToolResultSeq.clear();
@@ -1006,17 +1082,15 @@ export class CodexVirtualHarness {
     }
     async forkSession(request, signal) {
         const sessionId = requiredString(request.sessionId, 'sessionId');
-        let permissionPreset = this.selectedPermissions.get(sessionId);
         const result = record(await this.client.request('thread/fork', {
             threadId: nativeThreadId(sessionId),
-            ...(permissionPreset === undefined ? {} : { permissionPreset }),
         }, signal));
-        permissionPreset = codexPermissionPresetFromResponse(result) ?? permissionPreset ?? CODEX_DEFAULT_PERMISSION;
+        const permissionPreset = codexPermissionPresetFromResponse(result);
         const projected = projectCodexThread(record(result.thread));
         if (projected === undefined)
             return failure('internal', 'CodeX returned an invalid forked Thread.');
         this.selectedModels.set(projected.id, this.modelSelection(sessionId, await this.models(signal)));
-        this.selectedPermissions.set(projected.id, permissionPreset);
+        this.setPermissionSelection(projected.id, permissionPreset);
         await this.refreshAndPublishWorkspaces();
         const seq = this.nextProjectionSeq();
         this.publishProjection(projected.id, 'title', displayTitle(projected), seq);
@@ -1030,7 +1104,6 @@ export class CodexVirtualHarness {
             return failure('attachment-error', 'CodeX virtual Sessions accept text and pasted PNG, JPEG, WebP, or GIF images only.');
         const threadId = nativeThreadId(sessionId);
         const selection = this.modelSelection(sessionId, await this.models(signal));
-        let permissionPreset = this.selectedPermissions.get(sessionId);
         const isFreshBlankThread = this.blankThreads.has(threadId) || this.pendingThreads.has(threadId);
         await this.ensureRcFollow(sessionId);
         if (!isFreshBlankThread) {
@@ -1039,8 +1112,7 @@ export class CodexVirtualHarness {
                 model: selection.model,
             }, signal);
             const serverPreset = codexPermissionPresetFromResponse(resumeResult);
-            if (permissionPreset === undefined && serverPreset !== undefined) {
-                permissionPreset = serverPreset;
+            if (serverPreset !== undefined) {
                 this.setPermissionSelection(sessionId, serverPreset);
             }
         }
@@ -1057,7 +1129,6 @@ export class CodexVirtualHarness {
                 threadId,
                 input,
                 ...codexModelParams(selection),
-                ...(permissionPreset === undefined ? {} : { permissionPreset }),
             }, signal);
         }
         this.blankThreads.delete(threadId);
@@ -1144,15 +1215,20 @@ export class CodexVirtualHarness {
             const thread = record(result.thread);
             if (string(thread.id) !== threadId)
                 throw new Error('CodeX returned an invalid Thread history.');
-            value = paginateCodexNativeHistory(projectCodexNativeHistory(thread, `codex:${threadId}`), {
+            value = paginateCodexNativeHistory(projectCodexNativeHistory(thread, `codex:${threadId}`, this.sessionGeneration), {
                 beforeSeq: page.beforeSeq,
                 throughSeq: page.throughSeq,
                 maxMessages: page.maxMessages,
             });
         }
+        value = adaptCodexHistoryPage(value, this.sessionGeneration);
         if (!isCodexNativeHistoryPage(value, `codex:${threadId}`)) {
             throw new Error('CodeX Remote returned an invalid paginated History.');
         }
+        if (Object.hasOwn(value, 'permissionPreset')) {
+            const preset = value.permissionPreset;
+            this.setPermissionSelection(`codex:${threadId}`, preset === 'workspace-write' || preset === 'danger-full-access' ? preset : undefined);
+        }
         this.cacheHistoryImages(value);
         return value;
     }
@@ -1222,6 +1298,7 @@ export class CodexVirtualHarness {
             streamedBlocks: new Map(),
             nextBlockIndex: 0,
             streamActive: false,
+            assistantStreamRevision: 0,
             liveItems: new Map(),
             liveToolOutput: new Map(),
             liveToolResultSeq: new Map(),
@@ -1531,7 +1608,7 @@ async function loadModelDirectory(client, signal) {
         models,
     };
 }
-export function projectCodexNativeHistory(thread, sessionId) {
+export function projectCodexNativeHistory(thread, sessionId, sessionGeneration = 'legacy') {
     const entries = [];
     let seq = 0;
     let turnNumber = 0;
@@ -1544,7 +1621,7 @@ export function projectCodexNativeHistory(thread, sessionId) {
                 type,
                 seq: eventSeq,
                 time,
-                data,
+                data: adaptEventData(type, data, sessionGeneration),
                 ...(sourceEventSeqs === undefined ? {} : { sourceEventSeqs }),
                 ...(isSurfaceEvent(type) ? { surfaceOp: 'append' } : {}),
             },
@@ -1588,10 +1665,11 @@ export function projectCodexNativeHistory(thread, sessionId) {
     const projected = projectCodexThread(thread);
     return {
         header: {
-            version: 1,
+            version: sessionGeneration === 'v3' ? 3 : 1,
             id: sessionId,
             createdAt: projected?.createdAt ?? Date.now(),
             ...(projected?.cwd === undefined ? {} : { cwd: projected.cwd }),
+            ...(sessionGeneration === 'v3' ? { isSeeded: false } : {}),
         },
         entries,
         lastSeq: seq - 1,
@@ -1625,6 +1703,54 @@ export function paginateCodexNativeHistory(history, request) {
         ...(history.activeTurnId === undefined ? {} : { activeTurnId: history.activeTurnId }),
     };
 }
+function adaptEventData(type, data, sessionGeneration) {
+    if (sessionGeneration !== 'v3' || type !== 'assistant/message')
+        return data;
+    const value = record(data);
+    return Array.isArray(value.stream) ? value : { ...value, stream: [] };
+}
+function adaptCodexHistoryPage(value, sessionGeneration) {
+    if (sessionGeneration !== 'v3')
+        return value;
+    const page = record(value);
+    const sourceHeader = record(page.header);
+    const { seedLength: _seedLength, ...header } = sourceHeader;
+    const records = Array.isArray(page.records)
+        ? page.records.map(raw => {
+            const entry = record(raw);
+            const sourceEvent = record(entry.event);
+            const sourceSurfaceOp = record(sourceEvent.surfaceOp);
+            const surfaceOp = sourceEvent.surfaceOp === 'append'
+                ? 'append'
+                : sourceSurfaceOp.op === 'replace'
+                    && integer(sourceSurfaceOp.startSeq) !== undefined
+                    && integer(sourceSurfaceOp.endSeq) !== undefined
+                    ? sourceSurfaceOp
+                    : sourceSurfaceOp.op === 'replace'
+                        && integer(sourceSurfaceOp.start) !== undefined
+                        && integer(sourceSurfaceOp.end) !== undefined
+                        ? {
+                            op: 'replace',
+                            startSeq: sourceSurfaceOp.start,
+                            endSeq: sourceSurfaceOp.end,
+                        }
+                        : sourceEvent.surfaceOp;
+            return {
+                ...entry,
+                event: {
+                    ...sourceEvent,
+                    data: adaptEventData(string(sourceEvent.type) ?? '', sourceEvent.data, sessionGeneration),
+                    ...(surfaceOp === undefined ? {} : { surfaceOp }),
+                },
+            };
+        })
+        : page.records;
+    return {
+        ...page,
+        header: { ...header, version: 3, isSeeded: sourceHeader.isSeeded === true },
+        records,
+    };
+}
 function itemEvents(item, turn, step, requestId, selection = modelSelection(), sessionId = CODEX_SESSION_PREFIX, supplementalImages = []) {
     const type = string(item.type);
     const id = string(item.id) ?? `${turn}:${step}:${hashString(JSON.stringify(item))}`;
@@ -2256,7 +2382,7 @@ function isCanonicalBase64(value) {
 function modelSelectionProjection(selection) {
     return { lastUsed: selection, next: selection };
 }
-function codexPermissionsProjection(currentValue) {
+function codexPermissionsProjection(preset) {
     return {
         options: [
             {
@@ -2270,7 +2396,7 @@ function codexPermissionsProjection(currentValue) {
                 description: 'Full Host file access without approval prompts for subsequent turns in this virtual Session.',
             },
         ],
-        currentValue,
+        currentValue: preset ?? 'Host settings (not reported)',
     };
 }
 function codexImageLimitsProjection() {
@@ -2286,25 +2412,6 @@ function codexImageLimitsProjection() {
 function isCodexPermissionPreset(value) {
     return value === 'workspace-write' || value === 'danger-full-access';
 }
-function codexPermissionPresetFromResponse(value) {
-    const root = record(value);
-    return codexPermissionPresetFromPolicyRecord(root)
-        ?? codexPermissionPresetFromPolicyRecord(record(root.threadSettings));
-}
-function codexPermissionPresetFromPolicyRecord(value) {
-    const sandbox = value.sandbox ?? value.sandboxPolicy;
-    if (value.approvalPolicy === 'never' && isDangerFullAccessSandbox(sandbox))
-        return 'danger-full-access';
-    if (value.approvalPolicy === 'on-request' && isWorkspaceWriteSandbox(sandbox))
-        return 'workspace-write';
-    return undefined;
-}
-function isDangerFullAccessSandbox(value) {
-    return value === 'danger-full-access' || record(value).type === 'dangerFullAccess';
-}
-function isWorkspaceWriteSandbox(value) {
-    return value === 'workspace-write' || record(value).type === 'workspaceWrite';
-}
 function modelCatalog(directory) {
     return {
         default: directory.default,