@myagentroam/node 0.1.3 → 0.1.6

package/dist/runner/codex-runner.js

@@ -0,0 +1,365 @@
+import { CodexAppServerClient } from '../codex-app-server.js';
+import { AbstractRunner } from './abstract-runner.js';
+import { declaredRunnerProfiles } from '../runner-profiles.js';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { createHash } from 'node:crypto';
+import { discoverAllNativeSessions } from '../native-session-history.js';
+import { readCodexNativeContextUsage } from '../native-session-history.js';
+import { codexActiveTurnId, codexOfficialConversationPage, codexThreadCwd, codexThreadActivity, deduplicateDirectSessions, externalResumeFailureDetail, extractCodexThreads, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
+import { codexSessionControl } from '../codex-app-server.js';
+import { extractId } from '../util/runner-native-session-parsers.js';
+export class CodexRunner extends AbstractRunner {
+    client;
+    name = 'codex';
+    discoveryScope = 'ALL_WORKSPACES';
+    execution = new CodexExecutionState();
+    fastEnabled = false;
+    environmentFingerprint;
+    environmentRuns = new Set();
+    constructor(client = new CodexAppServerClient()) {
+        super();
+        this.client = client;
+    }
+    profile(capabilities) {
+        return declaredRunnerProfiles({
+            codexAvailable: capabilities.codex.available,
+            claudeCodeAvailable: capabilities.claudeCode.available,
+            openCodeAvailable: capabilities.openCode?.available === true
+        }).find((profile) => profile.runner === this.name);
+    }
+    available(capabilities) {
+        return capabilities.codex.available;
+    }
+    executeGlobalCommand(commandId, input) {
+        if (commandId !== 'fast' || !/^\/fast(?:\s+(on|off|status))?\s*$/i.test(input))
+            throw new Error('RUNNER_COMMAND_INVALID');
+        const argument = input.trim().split(/\s+/, 2)[1]?.toLowerCase() ?? 'status';
+        if (argument === 'on')
+            this.fastEnabled = true;
+        else if (argument === 'off')
+            this.fastEnabled = false;
+        return { command: 'fast', enabled: this.fastEnabled };
+    }
+    serviceTier() {
+        return this.fastEnabled ? 'fast' : undefined;
+    }
+    usesRunnerTitleForRename() {
+        return true;
+    }
+    async renameNative(session, input, database) {
+        if (session.externalSessionId === null)
+            return;
+        if (input.title !== undefined) {
+            await this.start();
+            await this.setThreadName(session.externalSessionId, input.title ?? '');
+        }
+        database.saveNativeSessionMetadata({
+            runner: this.name,
+            externalSessionId: session.externalSessionId,
+            workspaceId: session.workspaceId,
+            ...(input.title === undefined ? {} : { runnerTitle: input.title }),
+            ...(input.title === undefined
+                ? {}
+                : { runnerTitlePending: input.title !== null && input.title.trim().length > 0 }),
+            ...(input.pinned === undefined ? {} : { pinned: input.pinned })
+        });
+    }
+    projectedRunnerTitle(metadata, input, database) {
+        const cached = metadata?.runnerTitle ?? null;
+        if (input.titleOrigin !== 'OFFICIAL' || input.title === undefined)
+            return cached ?? input.title ?? null;
+        if (metadata?.runnerTitlePending === true) {
+            if (input.title === cached)
+                database?.saveNativeSessionMetadata({
+                    runner: this.name,
+                    externalSessionId: input.externalSessionId,
+                    workspaceId: input.workspaceId,
+                    runnerTitle: cached,
+                    runnerTitlePending: false
+                });
+            return cached ?? input.title;
+        }
+        return input.title;
+    }
+    async readOfficialConversation(session, input, managedTurn) {
+        if (session.externalSessionId === null)
+            return undefined;
+        try {
+            await this.start();
+            return codexOfficialConversationPage(session, await this.readThread(session.externalSessionId), input, managedTurn);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async readExternalActivity(session) {
+        if (session.nativeControl !== 'EXTERNAL' || session.externalSessionId === null)
+            return undefined;
+        try {
+            await this.start();
+            return codexThreadActivity(await this.readThread(session.externalSessionId, false));
+        }
+        catch {
+            return 'UNAVAILABLE';
+        }
+    }
+    acceptsTruncatedNativeHistory() {
+        return false;
+    }
+    async readManagedRunnerTitle(session, nativeSessionId) {
+        void session;
+        await this.start();
+        return extractCodexThreads(await this.listThreads()).find((thread) => thread.id === nativeSessionId)?.title;
+    }
+    nativeImageRoot(session) {
+        return session.externalSessionId === null
+            ? undefined
+            : resolve(homedir(), '.codex', 'generated_images', session.externalSessionId);
+    }
+    managedRunForNativeTurn(nativeTurnId) {
+        return this.execution.managedTurns.get(nativeTurnId)?.runId;
+    }
+    profileForValidation() {
+        return this.profile({
+            platform: 'linux',
+            architecture: 'validation',
+            nodeAppVersion: 'validation',
+            nodeVersion: 'validation',
+            codex: { available: true },
+            claudeCode: { available: false },
+            openCode: { available: false }
+        });
+    }
+    defaultConfiguration() {
+        return { runner: this.name, model: 'gpt-5.6-sol', effort: 'medium', access: 'on-request' };
+    }
+    async resumeExternal(external, context, force = false) {
+        if (external.runner !== this.name ||
+            external.nativeControl !== 'EXTERNAL' ||
+            external.externalSessionId === null ||
+            !context.available)
+            return { failureCode: 'RUNNER_UNAVAILABLE' };
+        try {
+            const detail = await this.readThread(external.externalSessionId, force);
+            const activity = codexThreadActivity(detail);
+            if (activity === 'UNAVAILABLE')
+                return { activity, failureCode: 'RUNNER_UNAVAILABLE' };
+            if (activity === 'EXTERNAL_ACTIVE' && !force)
+                return { activity, failureCode: 'EXTERNAL_SESSION_ACTIVE' };
+            if (activity === 'EXTERNAL_ACTIVE') {
+                const turnId = codexActiveTurnId(detail);
+                if (turnId === undefined)
+                    return { activity, failureCode: 'RUNNER_TURN_NOT_INTERRUPTIBLE' };
+                await this.interruptTurn(external.externalSessionId, turnId);
+            }
+            await this.resumeThread(external.externalSessionId, external.cwd);
+            const projection = context.projectionFor(external);
+            if (projection !== undefined) {
+                const promoted = context.promote(projection.id);
+                if (promoted !== undefined)
+                    return { activity: 'IDLE', session: context.ensureConfiguration(promoted) };
+            }
+            return { activity: 'IDLE', session: context.create(external) };
+        }
+        catch (error) {
+            return {
+                activity: 'UNAVAILABLE',
+                failureCode: 'RUNNER_RESUME_FAILED',
+                failureDetail: externalResumeFailureDetail(error)
+            };
+        }
+    }
+    async discoverSessions(context, workspace) {
+        let threads = [];
+        try {
+            await this.start();
+            threads = extractCodexThreads(await this.listThreads());
+        }
+        catch {
+            // Native transcripts remain a valid read-only discovery source.
+        }
+        const sessions = [];
+        for (const thread of threads) {
+            if (thread.source !== 'cli' && thread.source !== 'vscode')
+                continue;
+            let cwd;
+            try {
+                cwd = codexThreadCwd(thread.cwd);
+            }
+            catch {
+                continue;
+            }
+            const target = workspace ?? context.workspaces.find((candidate) => isWithinWorkspace(cwd, candidate.path));
+            if (target === undefined || !isWithinWorkspace(cwd, target.path))
+                continue;
+            sessions.push(context.createProjection({
+                workspace: target,
+                runner: this.name,
+                externalSessionId: thread.id,
+                cwd,
+                ...(thread.title === undefined ? {} : { title: thread.title }),
+                titleOrigin: 'OFFICIAL'
+            }));
+        }
+        for (const entry of await discoverAllNativeSessions(this.name)) {
+            const target = workspace ??
+                context.workspaces.find((candidate) => isWithinWorkspace(entry.cwd, candidate.path));
+            if (target === undefined || !isWithinWorkspace(entry.cwd, target.path))
+                continue;
+            const native = context.createProjection({
+                workspace: target,
+                runner: this.name,
+                externalSessionId: entry.externalSessionId,
+                cwd: entry.cwd,
+                ...(entry.title === undefined ? {} : { title: entry.title }),
+                titleOrigin: 'NATIVE',
+                lastActivityAt: latestNativeActivity(entry)
+            });
+            const index = sessions.findIndex((candidate) => candidate.id === native.id);
+            if (index < 0)
+                sessions.push(native);
+            else {
+                const official = sessions[index];
+                sessions[index] =
+                    official.runnerTitle === null
+                        ? native
+                        : {
+                            ...native,
+                            runnerTitle: official.runnerTitle,
+                            titleSource: official.titleSource
+                        };
+            }
+        }
+        return deduplicateDirectSessions(sessions);
+    }
+    readContextUsage(session) {
+        return session.externalSessionId === null
+            ? Promise.resolve(undefined)
+            : readCodexNativeContextUsage(session.cwd, session.externalSessionId);
+    }
+    presentSession(session, capabilities, context) {
+        const activeTurn = [...this.execution.runs.values()].some((run) => run.sessionId === session.id && run.turnId !== undefined);
+        const control = codexSessionControl({
+            available: capabilities.codex.available,
+            nativeThreadId: session.externalSessionId,
+            nativeControl: session.nativeControl,
+            activeTurn
+        });
+        const activity = !capabilities.codex.available
+            ? 'UNAVAILABLE'
+            : context.managedActive
+                ? 'MANAGED_ACTIVE'
+                : session.nativeControl === 'EXTERNAL'
+                    ? (context.externalActivity ?? 'IDLE')
+                    : 'IDLE';
+        return {
+            control,
+            activity,
+            commandStates: context.commandStates,
+            runtime: {
+                level: control.level,
+                capabilities: [
+                    ...control.capabilities,
+                    ...(control.level === 'MANAGED' ? ['turn.queue', 'run.cancel', 'approval.respond'] : []),
+                    'session.rename',
+                    'session.remove',
+                    'session.pin',
+                    ...(session.externalSessionId === null ? [] : ['session.rewind'])
+                ],
+                reasonCode: control.level === 'UNAVAILABLE' ? 'RUNNER_UNAVAILABLE' : null
+            }
+        };
+    }
+    onNotification(listener) {
+        return this.client.onNotification(listener);
+    }
+    start() {
+        return this.client.start();
+    }
+    prepareEnvironment(environment, runId) {
+        if (Object.keys(environment).length === 0 && this.environmentFingerprint === undefined) {
+            this.environmentRuns.add(runId);
+            return;
+        }
+        const fingerprint = createHash('sha256')
+            .update(JSON.stringify(Object.entries(environment).sort(([left], [right]) => left.localeCompare(right))))
+            .digest('base64url');
+        if (fingerprint === this.environmentFingerprint) {
+            this.environmentRuns.add(runId);
+            return;
+        }
+        if (this.environmentRuns.size > 0 || this.execution.runs.size > 0)
+            throw new Error('CODEX_SECRET_ENVIRONMENT_CONFLICT');
+        this.client.stop();
+        this.client.configureEnvironment(environment);
+        this.environmentFingerprint = fingerprint;
+        this.environmentRuns.add(runId);
+    }
+    releaseEnvironment(runId) {
+        this.environmentRuns.delete(runId);
+        if (this.environmentRuns.size !== 0 || this.environmentFingerprint === undefined)
+            return;
+        this.client.stop();
+        this.client.clearEnvironment();
+        this.environmentFingerprint = undefined;
+    }
+    stop() {
+        this.client.stop();
+        if (this.environmentFingerprint !== undefined)
+            this.client.clearEnvironment();
+        this.environmentFingerprint = undefined;
+        this.environmentRuns.clear();
+    }
+    request(method, params) {
+        return this.client.request(method, params);
+    }
+    respond(requestId, result) {
+        this.client.respond(requestId, result);
+    }
+    listThreads() {
+        return this.client.listThreads();
+    }
+    readThread(threadId, includeTurns) {
+        return this.client.readThread(threadId, includeTurns);
+    }
+    startThread(cwd, configuration) {
+        return this.client.startThread(cwd, configuration);
+    }
+    forkThread(threadId, cwd, lastTurnId, configuration) {
+        return this.client.forkThread(threadId, cwd, lastTurnId, configuration);
+    }
+    async forkNative(session, boundary, title) {
+        if (session.externalSessionId === null)
+            throw new Error('SESSION_REWIND_UNAVAILABLE');
+        await this.start();
+        const configuration = { model: session.model, effort: session.effort, access: session.access };
+        const result = boundary === null
+            ? await this.startThread(session.cwd, configuration)
+            : await this.forkThread(session.externalSessionId, session.cwd, boundary, configuration);
+        const threadId = extractId(result, 'thread');
+        await this.setThreadName(threadId, title);
+        return threadId;
+    }
+    resumeThread(threadId, cwd, configuration) {
+        return this.client.resumeThread(threadId, cwd, configuration);
+    }
+    startTurn(threadId, text, cwd, configuration, attachments) {
+        return this.client.startTurn(threadId, text, cwd, configuration, attachments);
+    }
+    interruptTurn(threadId, turnId) {
+        return this.client.interruptTurn(threadId, turnId);
+    }
+    setThreadName(threadId, name) {
+        return this.client.setThreadName(threadId, name);
+    }
+    listCollaborationModes() {
+        return this.client.listCollaborationModes();
+    }
+}
+export class CodexExecutionState {
+    runs = new Map();
+    managedTurns = new Map();
+    approvals = new Map();
+    userInputs = new Map();
+}

package/dist/runner/fake-test-runner.d.ts

@@ -0,0 +1,26 @@
+import { FakeRunner, type FakeRunnerCallbacks, type FakeRunnerStep } from '../fake-runner.js';
+import { AbstractRunner } from './abstract-runner.js';
+import type { RunnerDefaultConfiguration, RunnerProfile } from '@myagentroam/protocol';
+import type { NodeAgentSession } from '../database.js';
+import type { ExternalResumeResult } from './abstract-runner.js';
+/** Registered only by tests; never contributes a production Runner Profile. */
+export declare class FakeTestRunner extends AbstractRunner<'fake'> {
+    private readonly runner;
+    readonly name: "fake";
+    readonly discoveryScope: "WORKSPACE_REQUIRED";
+    readonly advertised = false;
+    readonly interceptsRuns = true;
+    constructor(runner: FakeRunner);
+    stop(): void;
+    profile(): undefined;
+    available(): boolean;
+    protected profileForValidation(): RunnerProfile;
+    defaultConfiguration(): RunnerDefaultConfiguration;
+    resumeExternal(): Promise<ExternalResumeResult>;
+    discoverSessions(): Promise<readonly NodeAgentSession[]>;
+    readContextUsage(): Promise<undefined>;
+    start(runId: string, script: readonly FakeRunnerStep[], callbacks: FakeRunnerCallbacks): Promise<void>;
+    decide(runId: string, approvalId: string, decision: 'APPROVED' | 'REJECTED'): boolean;
+    interrupt(runId: string): boolean;
+    cancel(runId: string): boolean;
+}

package/dist/runner/fake-test-runner.js

@@ -0,0 +1,47 @@
+import { AbstractRunner } from './abstract-runner.js';
+/** Registered only by tests; never contributes a production Runner Profile. */
+export class FakeTestRunner extends AbstractRunner {
+    runner;
+    name = 'fake';
+    discoveryScope = 'WORKSPACE_REQUIRED';
+    advertised = false;
+    interceptsRuns = true;
+    constructor(runner) {
+        super();
+        this.runner = runner;
+    }
+    stop() { }
+    profile() {
+        return undefined;
+    }
+    available() {
+        return false;
+    }
+    profileForValidation() {
+        throw new Error('FAKE_RUNNER_NOT_ADVERTISED');
+    }
+    defaultConfiguration() {
+        throw new Error('FAKE_RUNNER_NOT_ADVERTISED');
+    }
+    resumeExternal() {
+        return Promise.resolve({ failureCode: 'RUNNER_CAPABILITY_UNSUPPORTED' });
+    }
+    discoverSessions() {
+        return Promise.resolve([]);
+    }
+    readContextUsage() {
+        return Promise.resolve(undefined);
+    }
+    start(runId, script, callbacks) {
+        return this.runner.start(runId, script, callbacks);
+    }
+    decide(runId, approvalId, decision) {
+        return this.runner.decide(runId, approvalId, decision);
+    }
+    interrupt(runId) {
+        return this.runner.interrupt(runId);
+    }
+    cancel(runId) {
+        return this.runner.cancel(runId);
+    }
+}

package/dist/runner/opencode/conversation-parser.d.ts

@@ -0,0 +1,27 @@
+import type { NodeAgentSession, NodeConversationTurn } from '../../database.js';
+export declare function openCodeConversationPage(session: NodeAgentSession, messages: readonly unknown[], input: {
+    readonly cursor?: string;
+    readonly limit?: number;
+}, managedTurn: (nativeTurnId: string) => NodeConversationTurn | undefined): {
+    readonly turns: readonly NodeConversationTurn[];
+    readonly nextCursor: string | null;
+} | undefined;
+export declare function openCodeQuestions(value: unknown): {
+    id: string;
+    prompt: string;
+    input: string;
+    options: {
+        value: string;
+        label: string;
+        description: string | null;
+    }[];
+    allowOther: boolean;
+    multiSelect: boolean;
+}[];
+export declare function openCodePatchChanges(value: unknown): {
+    path: string;
+    change: string;
+    additions: null;
+    deletions: null;
+    diffAvailable: boolean;
+}[];

package/dist/runner/opencode/conversation-parser.js

@@ -0,0 +1,217 @@
+import { basename } from 'node:path';
+import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../codex/conversation-parser.js';
+export function openCodeConversationPage(session, messages, input, managedTurn) {
+    const records = messages.flatMap((value) => {
+        const entry = record(value);
+        const info = record(entry?.info);
+        return info === undefined || typeof info.id !== 'string'
+            ? []
+            : [{ info, parts: array(entry?.parts) }];
+    });
+    const parsedTurns = records
+        .filter(({ info }) => info.role === 'user')
+        .flatMap(({ info, parts }, sequence) => {
+        const assistants = records.filter((candidate) => candidate.info.role === 'assistant' && candidate.info.parentID === info.id);
+        const existing = managedTurn(info.id);
+        const turn = openCodeTurn(session, info, parts, assistants, sequence, existing);
+        const after = assistants.at(-1)?.info.id ?? info.id;
+        return turn === undefined || typeof after !== 'string' ? [] : [{ after, turn }];
+    });
+    const turns = parsedTurns.map(({ after, turn }, index) => ({
+        ...turn,
+        rewind: { before: parsedTurns[index - 1]?.after ?? null, after }
+    }));
+    if (turns.length === 0)
+        return undefined;
+    const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+    const end = pageEnd(input.cursor, session.id, turns.length);
+    const start = Math.max(0, end - limit);
+    return {
+        turns: turns.slice(start, end),
+        nextCursor: start === 0
+            ? null
+            : Buffer.from(JSON.stringify({ sessionId: session.id, end: start })).toString('base64url')
+    };
+}
+function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
+    const nativeTurnId = user.id;
+    const startedAt = number(record(user.time)?.created);
+    const items = [];
+    const userText = userParts
+        .flatMap((part) => {
+        const value = record(part);
+        return value?.type === 'text' && typeof value.text === 'string' ? [value.text] : [];
+    })
+        .join('\n');
+    const localUser = managed?.items.find((item) => item.kind === 'user_message');
+    if (localUser !== undefined)
+        items.push({ ...localUser, turnId: managed.id });
+    else if (userText.length > 0)
+        items.push(item(session, nativeTurnId, `user-${nativeTurnId}`, 'user_message', 'COMPLETED', {
+            text: compactRunnerText(userText, 20_000),
+            attachments: []
+        }, startedAt, startedAt, sequence));
+    for (const assistant of assistants) {
+        const completedAt = number(record(assistant.info.time)?.completed);
+        for (const part of assistant.parts) {
+            const projected = partItem(session, nativeTurnId, part, assistant.info.mode === 'plan', startedAt, completedAt, sequence);
+            if (projected !== undefined)
+                items.push(projected);
+        }
+    }
+    if (items.length === 0)
+        return undefined;
+    const completedAt = Math.max(startedAt ?? 0, ...assistants.map(({ info }) => number(record(info.time)?.completed) ?? 0)) || startedAt;
+    const id = managed?.id ?? `${session.id}:official:${nativeTurnId}`;
+    const runId = managed?.runId ?? null;
+    return {
+        id,
+        sessionId: session.id,
+        runId,
+        userItemId: items.find((value) => value.kind === 'user_message')?.id ?? null,
+        status: assistants.some(({ info }) => info.error !== undefined) ? 'FAILED' : 'SUCCEEDED',
+        model: assistants.find(({ info }) => typeof info.modelID === 'string')?.info.modelID ?? null,
+        effort: managed?.effort ?? null,
+        access: managed?.access ?? null,
+        items: items.map((value) => ({ ...value, turnId: id, runId })),
+        startedAt,
+        completedAt
+    };
+}
+function partItem(session, turnId, raw, planMode, startedAt, completedAt, sequence) {
+    const part = record(raw);
+    if (typeof part?.id !== 'string' || typeof part.type !== 'string')
+        return undefined;
+    if ((part.type === 'text' || part.type === 'reasoning') && typeof part.text === 'string')
+        return item(session, turnId, part.id, part.type === 'text' ? (planMode ? 'plan' : 'assistant_message') : 'reasoning_summary', completedAt === null ? 'IN_PROGRESS' : 'COMPLETED', part.type === 'text'
+            ? planMode
+                ? { explanation: compactRunnerText(part.text, 20_000), steps: [] }
+                : { text: compactRunnerText(part.text, 20_000), format: 'markdown', model: null }
+            : { sections: [{ index: 0, text: compactRunnerText(part.text, 10_000) }] }, startedAt, completedAt, sequence);
+    if (part.type === 'tool' && typeof part.tool === 'string') {
+        const state = record(part.state);
+        if (part.tool === 'question' && typeof part.callID === 'string') {
+            const questions = openCodeQuestions(record(state?.input)?.questions);
+            if (questions.length > 0)
+                return item(session, turnId, part.id, 'user_input_request', 'COMPLETED', { requestId: `native:${part.callID}`, questions }, startedAt, completedAt, sequence);
+        }
+        const status = state?.status === 'completed'
+            ? 'COMPLETED'
+            : state?.status === 'error'
+                ? 'FAILED'
+                : 'IN_PROGRESS';
+        return item(session, turnId, part.id, 'tool_call', status, {
+            namespace: 'opencode',
+            toolName: compactRunnerText(part.tool, 128),
+            title: compactRunnerText(typeof state?.title === 'string' ? state.title : part.tool, 500),
+            inputSummary: compactRunnerValue(state?.input, 10_000).text || null,
+            outputSummary: typeof state?.output === 'string' ? compactRunnerText(state.output, 10_000) : null,
+            progressLabel: null,
+            errorCode: status === 'FAILED' ? 'OPENCODE_TOOL_FAILED' : null,
+            truncated: false
+        }, startedAt, completedAt, sequence);
+    }
+    if (part.type === 'compaction')
+        return item(session, turnId, part.id, 'context_compaction', 'COMPLETED', {
+            phase: 'COMPLETED',
+            summary: '上下文已整理'
+        }, startedAt, completedAt, sequence);
+    if (part.type === 'patch')
+        return item(session, turnId, part.id, 'file_change', 'COMPLETED', { changes: openCodePatchChanges(part.files) }, startedAt, completedAt, sequence);
+    if (part.type === 'step-start' || part.type === 'step-finish')
+        return undefined;
+    if (part.type === 'text' || part.type === 'reasoning')
+        return undefined;
+    return item(session, turnId, part.id, 'unknown', completedAt === null ? 'IN_PROGRESS' : 'COMPLETED', {
+        sourceEventType: `opencode:${part.type}`,
+        label: `OpenCode ${compactRunnerText(part.type, 128)}`
+    }, startedAt, completedAt, sequence);
+}
+export function openCodeQuestions(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 4)
+        return [];
+    return value.flatMap((value, index) => {
+        const question = record(value);
+        if (typeof question?.question !== 'string')
+            return [];
+        const options = (Array.isArray(question.options) ? question.options : []).flatMap((value) => {
+            const option = record(value);
+            const label = typeof option?.label === 'string' ? compactRunnerText(option.label, 500) : '';
+            return label.length === 0
+                ? []
+                : [
+                    {
+                        value: label,
+                        label,
+                        description: typeof option?.description === 'string'
+                            ? compactRunnerText(option.description, 1_000)
+                            : null
+                    }
+                ];
+        });
+        const multiSelect = question.multiple === true;
+        return [
+            {
+                id: `question-${index + 1}`,
+                prompt: compactRunnerText(question.question, 5_000),
+                input: options.length === 0 ? 'SHORT_TEXT' : multiSelect ? 'MULTI_SELECT' : 'SINGLE_SELECT',
+                options,
+                allowOther: true,
+                multiSelect
+            }
+        ];
+    });
+}
+export function openCodePatchChanges(value) {
+    return (Array.isArray(value) ? value : []).flatMap((path) => typeof path === 'string' && path.length > 0
+        ? [
+            {
+                path: basename(path),
+                change: 'MODIFIED',
+                additions: null,
+                deletions: null,
+                diffAvailable: false
+            }
+        ]
+        : []);
+}
+function item(session, turnId, nativeId, kind, status, payload, startedAt, completedAt, sequence) {
+    return {
+        id: boundedConversationItemId(`${session.id}:official:${turnId}`, nativeId),
+        sessionId: session.id,
+        turnId: `${session.id}:official:${turnId}`,
+        runId: null,
+        parentItemId: null,
+        sourceSequence: sequence,
+        revision: 1,
+        kind,
+        status,
+        payload,
+        startedAt,
+        completedAt
+    };
+}
+function pageEnd(cursor, sessionId, fallback) {
+    if (cursor === undefined)
+        return fallback;
+    try {
+        const parsed = record(JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8')));
+        return parsed?.sessionId === sessionId && Number.isInteger(parsed.end)
+            ? Math.min(Math.max(Number(parsed.end), 0), fallback)
+            : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function array(value) {
+    return Array.isArray(value) ? value : [];
+}
+function number(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}