@playcraft/cli 0.0.59 → 0.1.0

package/dist/workspace-runtime/serve.js

@@ -5,7 +5,10 @@ import { INCOMPATIBLE_EXIT_CODE, negotiateProtocol, } from '@playcraft/common/cl
 import { RuntimeJournal } from './persistence/journal.js';
 import { createCodexAppServerAdapter } from './codex/app-server.js';
 import { createLoopbackNativeAdapter } from './codex/loopback.js';
+import { attachNativeCollector } from './server/dispatch.js';
 import { handleRuntimeRequest } from './server/http.js';
+import { desktopHost, disposeDesktopHost } from './server/desktop-host.js';
+import { disposeTerminalHost, terminalHost } from './server/terminal-host.js';
 import { handleExecutionGroupCrash } from './server/execution-group.js';
 import { RuntimeProcessLock } from './server/lock.js';
 import { probeGitBinary } from './workspaces/git.js';
@@ -21,8 +24,9 @@ export async function startWorkspaceRuntime(config, options = {}) {
     }
     const lock = new RuntimeProcessLock(config.stateDir);
     lock.acquire();
+    let journal;
     try {
-        const journal = new RuntimeJournal(config.stateDir);
+        journal = new RuntimeJournal(config.stateDir);
         await journal.load();
         await mkdir(config.workspaceRoot, { recursive: true, mode: 0o700 });
         const native = options.nativeAdapter ?? defaultNativeAdapter(config);
@@ -36,6 +40,12 @@ export async function startWorkspaceRuntime(config, options = {}) {
             executionQueue: Promise.resolve(),
             instanceToken: randomUUID(),
         };
+        await journal.bindRuntime({
+            runtimeId: config.runtimeId,
+            generation: config.generation,
+            runtimeEpoch: state.runtimeEpoch,
+        });
+        attachNativeCollector(state);
         native?.onUnexpectedExit?.((event) => {
             void handleExecutionGroupCrash(state, event.pid);
         });
@@ -51,12 +61,26 @@ export async function startWorkspaceRuntime(config, options = {}) {
         const server = createServer((request, response) => {
             void handleRuntimeRequest(state, request, response);
         });
+        server.on('upgrade', (request, socket, head) => {
+            const pathname = new URL(request.url ?? '/', 'http://127.0.0.1').pathname;
+            if (/^\/runtime\/terminals\/[^/]+\/connect$/.test(pathname)) {
+                void terminalHost(state).handleUpgrade(request, socket, head);
+                return;
+            }
+            if (pathname === '/runtime/desktop/connect') {
+                desktopHost(state).handleUpgrade(request, socket, head);
+                return;
+            }
+            socket.destroy();
+        });
         const port = await listenOn(server, config.listen.host, config.listen.port);
         return {
             config: state.config,
             state,
             url: `http://${formatHost(config.listen.host)}:${port}`,
             async close() {
+                disposeDesktopHost(state);
+                disposeTerminalHost(state);
                 await closeServer(server);
                 try {
                     await native?.close?.();
@@ -64,11 +88,13 @@ export async function startWorkspaceRuntime(config, options = {}) {
                 catch {
                     /* adapter shutdown is best-effort */
                 }
+                await journal?.close();
                 lock.release();
             },
         };
     }
     catch (error) {
+        await journal?.close().catch(() => undefined);
         lock.release();
         throw error;
     }

package/dist/workspace-runtime/server/desktop-host.js

@@ -0,0 +1,314 @@
+import { connect as connectTcp } from 'node:net';
+import { WebSocket, WebSocketServer } from 'ws';
+import { desktopHealthSchema, desktopResourceName, runtimeError, } from '@playcraft/common/cloud-workspace/runtime';
+import { controlTokenMatches, extractControlToken } from './auth.js';
+const sources = new WeakMap();
+const hosts = new WeakMap();
+export function setDesktopSource(state, source) {
+    if (source)
+        sources.set(state, source);
+    else
+        sources.delete(state);
+    hosts.get(state)?.replaceSource(source);
+}
+export function desktopHost(state) {
+    let host = hosts.get(state);
+    if (!host) {
+        host = new DesktopHost(state);
+        hosts.set(state, host);
+    }
+    return host;
+}
+export function disposeDesktopHost(state) {
+    hosts.get(state)?.dispose();
+    hosts.delete(state);
+    sources.delete(state);
+}
+export class DesktopHost {
+    state;
+    generation = 0;
+    holder = 'none';
+    probed = 'display_not_started';
+    viewers = new Set();
+    sockets = new WebSocketServer({ noServer: true });
+    source;
+    upstream = loopbackUpstream(process.env.PLAYCRAFT_DESKTOP_UPSTREAM);
+    constructor(state) {
+        this.state = state;
+        this.source = sources.get(state);
+    }
+    replaceSource(source) {
+        this.source = source;
+    }
+    snapshot() {
+        return desktopHealthSchema.parse({
+            status: this.currentStatus(),
+            streamGeneration: this.generation,
+            holder: this.holder,
+            agentInput: this.holder === 'human' ? 'revoked' : 'open',
+        });
+    }
+    async refresh() {
+        if (!this.source && this.upstream) {
+            this.probed = (await probePort(this.upstream.port)) ? 'ready' : 'display_not_started';
+        }
+        return this.snapshot();
+    }
+    async handleHttp(request, response, url) {
+        if (this.state.journal.destroyed()) {
+            writeError(response, 'runtime_destroyed');
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/desktop/health') {
+            writeJson(response, 200, await this.refresh());
+            return;
+        }
+        if (request.method === 'POST' && url.pathname === '/runtime/desktop/takeover') {
+            await this.refresh();
+            if (this.currentStatus() !== 'ready') {
+                writeError(response, this.currentStatus());
+                return;
+            }
+            this.holder = 'human';
+            this.cutViewers();
+            writeJson(response, 200, this.snapshot());
+            return;
+        }
+        if (request.method === 'DELETE' && url.pathname === '/runtime/desktop') {
+            this.holder = 'none';
+            this.cutViewers();
+            writeJson(response, 200, this.snapshot());
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/desktop/connect') {
+            await this.refresh();
+            this.rejectPlainConnect(response, url);
+            return;
+        }
+        if (request.method === 'GET' && url.pathname.startsWith('/runtime/desktop/resources/')) {
+            await this.refresh();
+            await this.writeResource(response, url);
+            return;
+        }
+        writeJson(response, 404, { error: 'not_found' });
+    }
+    handleUpgrade(request, socket, head) {
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        if (!controlTokenMatches(this.state.config.controlToken, extractControlToken(request.headers))) {
+            rejectUpgrade(socket, 401, runtimeError('unauthenticated', 'control_token_required'));
+            return;
+        }
+        if (this.state.journal.destroyed()) {
+            rejectUpgrade(socket, 409, runtimeError('capability_unavailable', 'runtime_destroyed'));
+            return;
+        }
+        if (this.currentStatus() !== 'ready') {
+            rejectUpgrade(socket, 409, runtimeError('capability_unavailable', this.currentStatus()));
+            return;
+        }
+        const generation = generationOf(url);
+        if (generation === undefined || generation !== this.generation) {
+            rejectUpgrade(socket, 409, runtimeError('capability_unavailable', 'desktop_stale'));
+            return;
+        }
+        this.sockets.handleUpgrade(request, socket, head, (ws) => this.attach(ws, generation));
+    }
+    dispose() {
+        this.holder = 'none';
+        this.cutViewers();
+        this.sockets.close();
+    }
+    currentStatus() {
+        if (this.source)
+            return this.source.health().status;
+        if (this.upstream)
+            return this.probed;
+        return 'display_not_started';
+    }
+    cutViewers() {
+        this.generation += 1;
+        for (const viewer of this.viewers)
+            this.drop(viewer);
+        this.viewers.clear();
+    }
+    drop(viewer) {
+        viewer.detach();
+        viewer.upstream?.close();
+        if (viewer.ws.readyState === WebSocket.OPEN)
+            viewer.ws.close();
+    }
+    attach(ws, generation) {
+        const viewer = { generation, ws, detach: () => undefined };
+        const send = (chunk, binary = true) => {
+            if (this.generation !== generation || ws.readyState !== WebSocket.OPEN)
+                return;
+            ws.send(chunk, { binary });
+        };
+        if (this.source) {
+            viewer.detach = this.source.attach(generation, (chunk) => send(chunk));
+        }
+        else if (this.upstream) {
+            const upstream = new WebSocket(`ws://127.0.0.1:${this.upstream.port}/`);
+            viewer.upstream = upstream;
+            viewer.detach = () => upstream.close();
+            upstream.on('message', (data, isBinary) => {
+                if (this.generation !== generation) {
+                    this.drop(viewer);
+                    return;
+                }
+                const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                send(chunk, isBinary);
+            });
+            upstream.on('close', () => {
+                if (ws.readyState === WebSocket.OPEN)
+                    ws.close();
+            });
+        }
+        this.viewers.add(viewer);
+        let closed = false;
+        const close = () => {
+            if (closed)
+                return;
+            closed = true;
+            this.viewers.delete(viewer);
+            viewer.detach();
+            viewer.upstream?.close();
+        };
+        ws.on('close', close);
+        ws.on('error', close);
+        ws.on('message', (data, isBinary) => {
+            if (this.holder !== 'human' || this.generation !== generation)
+                return;
+            if (viewer.upstream?.readyState === WebSocket.OPEN)
+                viewer.upstream.send(data, { binary: isBinary });
+        });
+    }
+    rejectPlainConnect(response, url) {
+        if (this.currentStatus() !== 'ready') {
+            writeError(response, this.currentStatus());
+            return;
+        }
+        const generation = generationOf(url);
+        if (generation === undefined || generation !== this.generation) {
+            writeError(response, 'desktop_stale');
+            return;
+        }
+        writeError(response, 'websocket_required');
+    }
+    async writeResource(response, url) {
+        if (this.currentStatus() !== 'ready') {
+            writeError(response, this.currentStatus());
+            return;
+        }
+        const name = desktopResourceName(decodeURIComponent(url.pathname.slice('/runtime/desktop/resources/'.length)));
+        if (!name) {
+            writeJson(response, 400, { error: 'invalid_desktop_resource' });
+            return;
+        }
+        const generation = url.searchParams.get('generation');
+        const document = name === 'vnc.html' || name.endsWith('/vnc.html');
+        if (document && Number(generation) !== this.generation) {
+            writeError(response, 'desktop_stale');
+            return;
+        }
+        if (generation !== null && Number(generation) !== this.generation) {
+            writeError(response, 'desktop_stale');
+            return;
+        }
+        if (this.source) {
+            const file = this.source.readResource(name);
+            if (!file) {
+                writeJson(response, 404, { error: 'not_found' });
+                return;
+            }
+            writeBytes(response, 200, file.contentType, file.body);
+            return;
+        }
+        if (!this.upstream) {
+            writeError(response, 'display_not_started');
+            return;
+        }
+        const upstream = await fetch(`http://127.0.0.1:${this.upstream.port}/${name}`, {
+            redirect: 'error',
+            signal: AbortSignal.timeout(5_000),
+        }).catch(() => undefined);
+        if (!upstream) {
+            writeError(response, 'display_unavailable');
+            return;
+        }
+        const body = Buffer.from(await upstream.arrayBuffer());
+        if (!upstream.ok) {
+            writeBytes(response, upstream.status, upstream.headers.get('content-type') ?? 'application/octet-stream', body);
+            return;
+        }
+        writeBytes(response, 200, upstream.headers.get('content-type') ?? 'application/octet-stream', body);
+    }
+}
+export function desktopRoute(pathname) {
+    return (pathname === '/runtime/desktop/health' ||
+        pathname === '/runtime/desktop/connect' ||
+        pathname === '/runtime/desktop/takeover' ||
+        pathname === '/runtime/desktop' ||
+        pathname.startsWith('/runtime/desktop/resources/'));
+}
+function generationOf(url) {
+    const value = url.searchParams.get('generation');
+    if (!value || !/^\d+$/.test(value))
+        return undefined;
+    return Number(value);
+}
+function loopbackUpstream(value) {
+    if (!value)
+        return undefined;
+    const match = /^(?:127\.0\.0\.1|localhost):(\d+)$/.exec(value.trim());
+    if (!match)
+        return undefined;
+    const port = Number(match[1]);
+    if (port < 1 || port > 65535)
+        return undefined;
+    return { port };
+}
+function probePort(port) {
+    return new Promise((resolve) => {
+        const socket = connectTcp({ host: '127.0.0.1', port });
+        const timer = setTimeout(() => {
+            socket.destroy();
+            resolve(false);
+        }, 200);
+        socket.once('connect', () => {
+            clearTimeout(timer);
+            socket.end();
+            resolve(true);
+        });
+        socket.once('error', () => {
+            clearTimeout(timer);
+            resolve(false);
+        });
+    });
+}
+function writeError(response, reason) {
+    writeJson(response, 409, runtimeError('capability_unavailable', reason));
+}
+function writeJson(response, status, body) {
+    const payload = JSON.stringify(body);
+    response.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(payload),
+        'cache-control': 'no-store',
+    });
+    response.end(payload);
+}
+function writeBytes(response, status, contentType, body) {
+    response.writeHead(status, {
+        'content-type': contentType,
+        'content-length': body.length,
+        'cache-control': 'no-store',
+    });
+    response.end(body);
+}
+function rejectUpgrade(socket, status, body) {
+    const payload = JSON.stringify(body);
+    const title = status === 401 ? 'Unauthorized' : 'Conflict';
+    socket.write(`HTTP/1.1 ${status} ${title}\r\ncontent-type: application/json; charset=utf-8\r\ncontent-length: ${Buffer.byteLength(payload)}\r\nconnection: close\r\n\r\n${payload}`);
+    socket.destroy();
+}

package/dist/workspace-runtime/server/dispatch.js

@@ -2,7 +2,8 @@ import { withObservedFile } from '../workspaces/revisions.js';
 import { revisionScope, workspaceRoot, workspaceSessions } from '../workspaces/registry.js';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { checkpointRecordSchema, fileWritePayloadSchema, gitCommitPayloadSchema, gitPushPayloadSchema, hashOperationPayload, nextSourceSequence, parameterPatchPayloadSchema, pendingSourceEventSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
+import { checkpointRecordSchema, fileWritePayloadSchema, gitCommitPayloadSchema, gitPushPayloadSchema, parameterPatchPayloadSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
+import { disposeTerminalHost } from './terminal-host.js';
 import { captureWorkspaceTree, materializeSnapshot, publishFileSnapshot, } from '../workspaces/file-snapshot.js';
 import { InvalidWorkspacePathError, resolveWorkspaceFile, restoreWorkspaceFiles, snapshotWorkspaceFiles, writeWorkspaceFile, } from '../workspaces/files.js';
 import { GitWorkspaceError, commitWorkspaceGit, pushWorkspaceGit } from '../workspaces/git.js';
@@ -148,54 +149,79 @@ async function executeTurn(state, scopeKey, operation, payload) {
     if (binding.recoverability !== 'native') {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'native_not_recoverable' }));
     }
+    if (sessionTurnBusy(binding)) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_already_active' }));
+    }
     const body = asRecord(payload);
-    let result = await native(state).startTurn({
+    const result = await native(state).startTurn({
         sessionId,
         threadId: binding.threadId,
         text: String(body.text ?? ''),
         clientRequestId: operation.clientRequestId,
         simulateLostReceipt: body.simulateLostReceipt === true,
+        persistReservation: async ({ nativeRequestId }) => {
+            await persist(state, scopeKey, {
+                ...operation,
+                nativeRequestId,
+                nativeThreadId: binding.threadId,
+                updatedAt: new Date().toISOString(),
+            });
+            await state.journal.putSession({ ...binding, turnStatus: 'starting' });
+        },
     });
-    if (result.outcome === 'uncertain') {
-        await recordNativeEvents(state, operation, result.events);
-        return persist(state, scopeKey, transitionOperation(operation, 'uncertain', {
-            error: 'native_receipt_lost',
-            nativeThreadId: binding.threadId,
-        }));
-    }
-    if (result.outcome === 'failed' || !result.turnId) {
-        await recordNativeEvents(state, operation, result.events);
-        return persist(state, scopeKey, transitionOperation(operation, 'failed', {
-            error: 'native_failed',
+    const reserved = state.journal.getOperation(scopeKey) ?? operation;
+    if (result.outcome === 'uncertain' || result.outcome === 'failed' || !result.turnId) {
+        const failed = result.outcome === 'failed';
+        await state.journal.putSession({
+            ...(state.journal.getSession(sessionId) ?? binding),
+            turnStatus: failed ? undefined : 'starting',
+            turnBlock: failed ? undefined : 'uncertain',
+            activeTurnId: undefined,
+        });
+        return persist(state, scopeKey, transitionOperation(reserved, failed ? 'failed' : 'uncertain', {
+            error: result.outcome === 'failed' ? result.error : 'native_receipt_lost',
             nativeThreadId: binding.threadId,
+            nativeRequestId: reserved.nativeRequestId,
         }));
     }
-    if (!result.approvalId &&
-        process.env.PLAYCRAFT_RECORD_PENDING_APPROVAL === '1' &&
+    let approvalId;
+    if (process.env.PLAYCRAFT_RECORD_PENDING_APPROVAL === '1' &&
         String(body.text ?? '').includes('[approval]')) {
-        result = { ...result, approvalId: `approval_${result.turnId}` };
-    }
-    if (result.approvalId) {
+        approvalId = `approval_${result.turnId}`;
         await state.journal.putApproval({
-            approvalId: result.approvalId,
+            approvalId,
             sessionId,
             runtimeEpoch: state.runtimeEpoch,
             nativeRequestId: `turn/start:${result.turnId}`,
             status: 'pending',
         });
+        await state.journal.putSession({
+            ...(state.journal.getSession(sessionId) ?? binding),
+            turnStatus: 'waiting_for_user',
+            activeTurnId: result.turnId,
+        });
     }
-    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', {
-        nativeRequestId: `turn/start:${result.turnId}`,
+    const accepted = await persist(state, scopeKey, transitionOperation(reserved, 'accepted', {
+        nativeRequestId: reserved.nativeRequestId ?? `turn/start:${result.turnId}`,
         nativeThreadId: binding.threadId,
         nativeTurnId: result.turnId,
-        nativeApprovalId: result.approvalId,
-    }));
-    await recordNativeEvents(state, accepted, result.events);
-    const terminal = result.outcome === 'interrupted' ? 'interrupted' : 'completed';
-    return persist(state, scopeKey, transitionOperation(accepted, terminal, {
-        nativeTurnId: result.turnId,
-        nativeApprovalId: result.approvalId,
+        nativeApprovalId: approvalId,
     }));
+    const released = await state.journal.bindTurn({
+        scopeKey,
+        operation: accepted,
+        sessionId,
+        threadId: binding.threadId,
+        turnId: result.turnId,
+    });
+    if (released.length > 0)
+        await publishSourceEvents(state, released);
+    const latest = state.journal.getOperation(scopeKey) ?? accepted;
+    if (approvalId && latest.status === 'accepted') {
+        const session = state.journal.getSession(sessionId) ?? binding;
+        await state.journal.putSession({ ...session, turnStatus: 'waiting_for_user', activeTurnId: result.turnId });
+    }
+    return state.journal.getOperation(scopeKey) ?? latest;
 }
 async function executeInterrupt(state, scopeKey, operation) {
     const sessionId = required(operation.sessionId, 'sessionId');
@@ -204,12 +230,10 @@ async function executeInterrupt(state, scopeKey, operation) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unknown_session' }));
     }
     const result = await native(state).interrupt({ sessionId, threadId: binding.threadId });
-    if (result.outcome === 'uncertain') {
+    if (result.outcome !== 'accepted') {
         return persist(state, scopeKey, transitionOperation(operation, 'uncertain', { error: 'native_receipt_lost' }));
     }
-    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { nativeThreadId: binding.threadId }));
-    await recordNativeEvents(state, accepted, result.events);
-    return persist(state, scopeKey, transitionOperation(accepted, 'interrupted', { nativeThreadId: binding.threadId }));
+    return persist(state, scopeKey, transitionOperation(operation, 'accepted', { nativeThreadId: binding.threadId, nativeTurnId: result.turnId }));
 }
 async function executeApproval(state, scopeKey, operation, payload) {
     const sessionId = required(operation.sessionId, 'sessionId');
@@ -234,7 +258,6 @@ async function executeApproval(state, scopeKey, operation, payload) {
         });
     }
     const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { nativeApprovalId: approvalId }));
-    await recordNativeEvents(state, accepted, result.events);
     const terminal = result.outcome === 'failed' ? 'failed' : 'completed';
     return persist(state, scopeKey, transitionOperation(accepted, terminal, {
         nativeApprovalId: approvalId,
@@ -446,6 +469,7 @@ async function executeRestore(state, scopeKey, operation, payload) {
 }
 async function executeDestroy(state, scopeKey, operation) {
     await state.journal.markDestroyed();
+    disposeTerminalHost(state);
     try {
         await state.native?.close?.();
     }
@@ -796,35 +820,70 @@ function previousFilePaths(state) {
 function fileCheckpointDir(state, checkpointId) {
     return join(state.config.stateDir, 'file-checkpoints', checkpointId);
 }
+export function attachNativeCollector(state) {
+    state.native?.onCollected?.((event) => {
+        void ingestCollected(state, event);
+    });
+}
+async function ingestCollected(state, event) {
+    const ids = nativeIds(event.params);
+    const recorded = await state.journal.ingestNative({
+        runtimeId: state.config.runtimeId,
+        generation: state.config.generation,
+        runtimeEpoch: state.runtimeEpoch,
+        kind: event.kind,
+        method: event.method,
+        params: event.params,
+        threadId: ids.threadId,
+        turnId: ids.turnId,
+        itemId: ids.itemId,
+        occurredAt: event.occurredAt,
+    });
+    if (recorded.length > 0)
+        await publishSourceEvents(state, recorded);
+}
 export async function recordNativeEvents(state, operation, events) {
     const recorded = [];
     for (const event of events) {
-        const sourceSequence = nextSourceSequence(state.journal.lastSourceSequence());
         const payload = {
             ...(asRecord(event.payload)),
             ...(operation.sessionId ? { sessionId: operation.sessionId } : {}),
             ...(operation.workspaceId ? { workspaceId: operation.workspaceId } : {}),
         };
-        const pending = pendingSourceEventSchema.parse({
-            source: {
-                runtimeId: state.config.runtimeId,
-                generation: state.config.generation,
-                runtimeEpoch: state.runtimeEpoch,
-                sourceSequence,
-            },
-            payloadHash: hashOperationPayload(payload),
+        recorded.push(await state.journal.allocateSourceEvent({
+            runtimeId: state.config.runtimeId,
+            generation: state.config.generation,
+            runtimeEpoch: state.runtimeEpoch,
             type: event.type,
             payload,
             occurredAt: event.occurredAt,
-        });
-        recorded.push(await state.journal.appendEvent(pending));
-    }
-    if (recorded.length > 0) {
-        await notifyCallback(state, recorded).catch(() => undefined);
+            sessionId: operation.sessionId,
+            workspaceId: operation.workspaceId,
+            operationId: operation.operationId,
+        }));
     }
-    void operation;
+    if (recorded.length > 0)
+        await publishSourceEvents(state, recorded);
     return recorded;
 }
+async function publishSourceEvents(state, events) {
+    await notifyCallback(state, events).catch(() => undefined);
+}
+function sessionTurnBusy(session) {
+    if (session.turnBlock === 'uncertain')
+        return true;
+    return session.turnStatus === 'starting' || session.turnStatus === 'running' || session.turnStatus === 'waiting_for_user';
+}
+function nativeIds(params) {
+    const record = asRecord(params);
+    const turn = asRecord(record.turn);
+    const thread = asRecord(record.thread);
+    return {
+        threadId: typeof record.threadId === 'string' ? record.threadId : typeof thread.id === 'string' ? thread.id : undefined,
+        turnId: typeof record.turnId === 'string' ? record.turnId : typeof turn.id === 'string' ? turn.id : undefined,
+        itemId: typeof record.itemId === 'string' ? record.itemId : typeof record.approvalId === 'string' ? record.approvalId : undefined,
+    };
+}
 async function notifyCallback(state, events) {
     await fetch(state.config.callbackUrl, {
         method: 'POST',