@pasko70/pibo 2.5.1 → 3.0.0

package/dist/agent-runtimes/codex-native/first-use.js

@@ -0,0 +1,294 @@
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { PENDING_NATIVE_SESSION_METADATA_KEY, } from "../../sessions/runtime-binding.js";
+export const CODEX_FIRST_USE_METADATA_KEY = "codexNativeFirstUse";
+export const CODEX_FIRST_USE_METADATA_VERSION = 3;
+const LEGACY_BYTE_EXACT_METADATA_VERSIONS = new Set([1, 2]);
+const MAX_NATIVE_ID_LENGTH = 512;
+const MAX_MESSAGE_ID_LENGTH = 512;
+const MAX_PROCESS_START_ID_LENGTH = 64;
+const MAX_PID = 0x7fff_ffff;
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+const UUID_V4_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/;
+const PROCESS_START_ID_PATTERN = /^([1-9][0-9]{0,9}):([1-9][0-9]{0,30})$/;
+const TERMINAL_TURN_STATUSES = new Set(["completed", "interrupted", "failed"]);
+const PROCESS_INSTANCE_ID = randomUUID();
+const activeAttemptIds = new Set();
+function boundedNonEmptyString(value, maximumLength) {
+    return typeof value === "string"
+        && value.length > 0
+        && value.length <= maximumLength
+        && !/[\u0000-\u001f\u007f]/.test(value);
+}
+function validPid(value) {
+    return Number.isSafeInteger(value) && Number(value) > 0 && Number(value) <= MAX_PID;
+}
+function errorCode(error) {
+    return error && typeof error === "object" && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+function probeLinuxProcess(pid, readProcStat) {
+    let stat;
+    try {
+        stat = readProcStat(pid);
+    }
+    catch (error) {
+        return ["ENOENT", "ESRCH"].includes(errorCode(error) ?? "")
+            ? { liveness: "dead" }
+            : { liveness: "ambiguous" };
+    }
+    const close = stat.lastIndexOf(")");
+    if (close < 2 || close + 2 >= stat.length)
+        return { liveness: "ambiguous" };
+    const fields = stat.slice(close + 2).trim().split(/\s+/);
+    if (fields.length <= 19)
+        return { liveness: "ambiguous" };
+    if (fields[0] === "Z")
+        return { liveness: "dead" };
+    const startTicks = fields[19];
+    if (!startTicks || !/^[1-9][0-9]{0,30}$/.test(startTicks))
+        return { liveness: "ambiguous" };
+    return { liveness: "active", startId: `${pid}:${startTicks}` };
+}
+function probePortableProcess(pid, probePid) {
+    try {
+        probePid(pid);
+        return "active";
+    }
+    catch (error) {
+        return errorCode(error) === "ESRCH" ? "dead" : "ambiguous";
+    }
+}
+function defaultReadProcStat(pid) {
+    return readFileSync(`/proc/${pid}/stat`, "utf8");
+}
+function defaultProbePid(pid) {
+    process.kill(pid, 0);
+}
+function hashUtf8(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+/**
+ * Canonical first-use prompts use LF line endings and Unicode NFC. Pibo hashes
+ * this representation before native execution and when proving native history.
+ */
+export function canonicalizeCodexNativeFirstUsePrompt(prompt) {
+    return prompt.replace(/\r\n?/g, "\n").normalize("NFC");
+}
+export function hashCanonicalCodexNativeFirstUsePrompt(prompt) {
+    return hashUtf8(canonicalizeCodexNativeFirstUsePrompt(prompt));
+}
+function hashPersistedPromptEvidence(identity, prompt) {
+    return LEGACY_BYTE_EXACT_METADATA_VERSIONS.has(identity.version)
+        ? hashUtf8(prompt)
+        : hashCanonicalCodexNativeFirstUsePrompt(prompt);
+}
+export function codexNativeFirstUseDeliveryReceipt(pending) {
+    return {
+        version: pending.version,
+        state: "delivered",
+        messageId: pending.messageId,
+        promptHash: pending.promptHash,
+    };
+}
+export function readCodexNativePendingFirstUse(binding) {
+    const value = binding.metadata?.[CODEX_FIRST_USE_METADATA_KEY];
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("The pending native Codex first-use metadata is invalid.");
+    }
+    const record = value;
+    const allowedKeys = new Set([
+        "version",
+        "state",
+        "threadId",
+        "messageId",
+        "promptHash",
+        "attemptId",
+        "ownerPid",
+        "ownerProcessStartId",
+        "ownerProcessInstanceId",
+    ]);
+    const ownerProcessStartId = record.ownerProcessStartId;
+    const startMatch = typeof ownerProcessStartId === "string"
+        ? PROCESS_START_ID_PATTERN.exec(ownerProcessStartId)
+        : undefined;
+    if (Object.keys(record).some((key) => !allowedKeys.has(key))
+        || (record.version !== 1 && record.version !== 2 && record.version !== CODEX_FIRST_USE_METADATA_VERSION)
+        || record.state !== "pending"
+        || !boundedNonEmptyString(record.threadId, MAX_NATIVE_ID_LENGTH)
+        || !boundedNonEmptyString(record.messageId, MAX_MESSAGE_ID_LENGTH)
+        || typeof record.promptHash !== "string"
+        || !SHA256_PATTERN.test(record.promptHash)
+        || typeof record.attemptId !== "string"
+        || !UUID_V4_PATTERN.test(record.attemptId)
+        || !validPid(record.ownerPid)
+        || typeof record.ownerProcessInstanceId !== "string"
+        || !UUID_V4_PATTERN.test(record.ownerProcessInstanceId)
+        || (ownerProcessStartId !== undefined
+            && (typeof ownerProcessStartId !== "string"
+                || ownerProcessStartId.length > MAX_PROCESS_START_ID_LENGTH
+                || !startMatch
+                || Number(startMatch[1]) !== record.ownerPid))) {
+        throw new Error("The pending native Codex first-use metadata is invalid.");
+    }
+    return record;
+}
+export function readCodexNativeFirstUseDeliveryReceipt(binding) {
+    const value = binding.metadata?.[CODEX_FIRST_USE_METADATA_KEY];
+    if (value === undefined)
+        return undefined;
+    if (binding.state !== "bound"
+        || binding.metadata?.[PENDING_NATIVE_SESSION_METADATA_KEY] !== undefined
+        || !value
+        || typeof value !== "object"
+        || Array.isArray(value)) {
+        throw new Error("The delivered native Codex first-use receipt is invalid.");
+    }
+    const record = value;
+    const allowedKeys = new Set(["version", "state", "messageId", "promptHash"]);
+    if (Object.keys(record).some((key) => !allowedKeys.has(key))
+        || (record.version !== 1 && record.version !== 2 && record.version !== CODEX_FIRST_USE_METADATA_VERSION)
+        || record.state !== "delivered"
+        || !boundedNonEmptyString(record.messageId, MAX_MESSAGE_ID_LENGTH)
+        || typeof record.promptHash !== "string"
+        || !SHA256_PATTERN.test(record.promptHash)) {
+        throw new Error("The delivered native Codex first-use receipt is invalid.");
+    }
+    return record;
+}
+export function beginCodexNativeFirstUseAttempt() {
+    const attemptId = randomUUID();
+    let ownerProcessStartId;
+    if (process.platform === "linux") {
+        const probe = probeLinuxProcess(process.pid, defaultReadProcStat);
+        if (probe.liveness !== "active" || !probe.startId) {
+            throw new Error("Native Codex first use cannot establish the current process identity safely.");
+        }
+        ownerProcessStartId = probe.startId;
+    }
+    activeAttemptIds.add(attemptId);
+    return {
+        attemptId,
+        ownerPid: process.pid,
+        ...(ownerProcessStartId ? { ownerProcessStartId } : {}),
+        ownerProcessInstanceId: PROCESS_INSTANCE_ID,
+    };
+}
+export function endCodexNativeFirstUseAttempt(attemptId) {
+    activeAttemptIds.delete(attemptId);
+}
+export function codexNativePendingFirstUseOwnerLiveness(pending, dependencies = {}) {
+    const platform = dependencies.platform ?? process.platform;
+    const currentPid = dependencies.currentPid ?? process.pid;
+    const currentProcessInstanceId = dependencies.currentProcessInstanceId ?? PROCESS_INSTANCE_ID;
+    let processLiveness;
+    let observedStartId;
+    if (platform === "linux") {
+        const probe = probeLinuxProcess(pending.ownerPid, dependencies.readProcStat ?? defaultReadProcStat);
+        processLiveness = probe.liveness;
+        observedStartId = probe.startId;
+        if (processLiveness !== "active")
+            return processLiveness;
+        if (!pending.ownerProcessStartId || !observedStartId)
+            return "ambiguous";
+        if (pending.ownerProcessStartId !== observedStartId)
+            return "dead";
+    }
+    else {
+        processLiveness = probePortableProcess(pending.ownerPid, dependencies.probePid ?? defaultProbePid);
+        if (processLiveness !== "active")
+            return processLiveness;
+    }
+    if (pending.ownerPid !== currentPid)
+        return "active";
+    if (pending.ownerProcessInstanceId !== currentProcessInstanceId)
+        return "ambiguous";
+    return activeAttemptIds.has(pending.attemptId) ? "active" : "dead";
+}
+function exactTextUserItem(item) {
+    if (item.type !== "userMessage" || !Array.isArray(item.content) || item.content.length !== 1)
+        return undefined;
+    const part = item.content[0];
+    if (!part || typeof part !== "object" || Array.isArray(part))
+        return undefined;
+    const record = part;
+    if (record.type !== "text" || typeof record.text !== "string")
+        return undefined;
+    if (item.clientId !== undefined && item.clientId !== null && typeof item.clientId !== "string")
+        return undefined;
+    return { ...(item.clientId !== undefined ? { clientId: item.clientId } : {}), text: record.text };
+}
+function assertCodexNativeFirstUseTurnEvidence(identity, turn, state) {
+    if (!TERMINAL_TURN_STATUSES.has(turn.status)) {
+        throw new Error(`The ${state} native Codex first turn is not terminal and cannot be reconciled safely.`);
+    }
+    const userItems = turn.items.filter((item) => item.type === "userMessage");
+    const evidence = userItems.map(exactTextUserItem);
+    if (evidence.length === 0 || evidence.some((item) => !item)) {
+        throw new Error(`The ${state} native Codex first turn has ambiguous user input evidence.`);
+    }
+    const exactEvidence = evidence;
+    const evidenceWithClientIds = exactEvidence.filter((item) => item.clientId !== undefined && item.clientId !== null);
+    let firstRequestEvidence;
+    if (evidenceWithClientIds.length > 0) {
+        if (evidenceWithClientIds.length !== exactEvidence.length) {
+            throw new Error(`The ${state} native Codex first turn has ambiguous user input evidence.`);
+        }
+        const matches = evidenceWithClientIds.filter((item) => item.clientId === identity.messageId);
+        if (matches.length === 0) {
+            throw new Error(`The ${state} native Codex first turn does not match the persisted message id.`);
+        }
+        if (matches.length > 1) {
+            throw new Error(`The ${state} native Codex first turn has ambiguous user input evidence.`);
+        }
+        firstRequestEvidence = matches[0];
+    }
+    else {
+        if (exactEvidence.length !== 1) {
+            throw new Error(`The ${state} native Codex first turn has ambiguous user input evidence.`);
+        }
+        firstRequestEvidence = exactEvidence[0];
+    }
+    if (hashPersistedPromptEvidence(identity, firstRequestEvidence.text) !== identity.promptHash) {
+        throw new Error(`The ${state} native Codex first turn does not match the persisted prompt hash.`);
+    }
+    if (firstRequestEvidence.clientId !== undefined
+        && firstRequestEvidence.clientId !== null
+        && !boundedNonEmptyString(firstRequestEvidence.clientId, MAX_MESSAGE_ID_LENGTH)) {
+        throw new Error(`The ${state} native Codex first turn has invalid message identity evidence.`);
+    }
+}
+export function assertCodexNativePendingFirstUseTurn(pending, thread) {
+    if (thread.id !== pending.threadId || thread.turns.length !== 1) {
+        throw new Error("The pending native Codex first turn is missing, multiple, or belongs to another thread.");
+    }
+    assertCodexNativeFirstUseTurnEvidence(pending, thread.turns[0], "pending");
+}
+export function assertCodexNativeFirstUseDeliveryReceiptTurn(receipt, thread) {
+    const firstTurn = thread.turns[0];
+    if (!firstTurn)
+        throw new Error("The delivered native Codex first turn is missing.");
+    assertCodexNativeFirstUseTurnEvidence(receipt, firstTurn, "delivered");
+    return firstTurn;
+}
+export function isExactCodexNativeFirstUseDeliveryReplay(receipt, messageId, prompt) {
+    if (messageId !== receipt.messageId)
+        return false;
+    if (hashPersistedPromptEvidence(receipt, prompt) !== receipt.promptHash) {
+        throw new Error("Native Codex first-use replay reuses the delivered message id with a different prompt.");
+    }
+    return true;
+}
+export function assertCodexNativePendingFirstUseRequest(pending, messageId, prompt) {
+    if (messageId !== pending.messageId || hashPersistedPromptEvidence(pending, prompt) !== pending.promptHash) {
+        throw new Error("Native Codex first-use retry does not match the persisted message id and prompt.");
+    }
+}
+export function assertCodexNativeFirstUseMessageId(messageId) {
+    if (!boundedNonEmptyString(messageId, MAX_MESSAGE_ID_LENGTH)) {
+        throw new Error("Native Codex first-use message id is invalid.");
+    }
+}

package/dist/agent-runtimes/codex-native/history.js

@@ -1,5 +1,7 @@
+import { historyReconciliationDigest } from "../../agent-runtime/history.js";
 import { redactCodexNativeSensitiveText } from "./redaction.js";
 import { CODEX_NATIVE_ADAPTER_ID } from "./thread.js";
+import { TRACE_RECONCILIATION_ENTRY_CAP } from "../../shared/trace-limits.js";
 const CODEX_HISTORY_CURSOR_PREFIX = "codex-history:";
 const DEFAULT_HISTORY_LIMIT = 100;
 const MAX_HISTORY_LIMIT = 200;
@@ -67,7 +69,7 @@ function reasoningParts(item) {
         .map(redactCodexNativeSensitiveText);
     return values.length > 0 ? [{ type: "reasoning", text: values.join("\n") }] : [];
 }
-function itemEntry(thread, turn, item, sequence) {
+function itemEntry(thread, turn, item, sequence, historyPosition, historyScopeId) {
     const createdAt = isoFromSeconds(turn.startedAt ?? turn.completedAt, thread.updatedAt);
     const base = {
         id: `codex:${thread.id}:${turn.id}:${item.id}`,
@@ -75,6 +77,8 @@ function itemEntry(thread, turn, item, sequence) {
         source: "native",
         createdAt,
         sequence,
+        historyPosition,
+        historyScopeId,
         turnId: turn.id,
         nativeTurnId: turn.id,
         nativeEntryId: item.id,
@@ -159,7 +163,7 @@ function itemEntry(thread, turn, item, sequence) {
     }
     return undefined;
 }
-export function codexThreadHistoryEntries(thread) {
+export function codexThreadHistoryEntries(thread, historyScopeId = `codex:${thread.id}`) {
     const entries = [];
     let sequence = 0;
     if (thread.name) {
@@ -169,13 +173,15 @@ export function codexThreadHistoryEntries(thread) {
             source: "native",
             createdAt: isoFromSeconds(thread.createdAt, thread.createdAt),
             sequence: sequence++,
+            historyPosition: `codex:${thread.id}:session-info`,
+            historyScopeId,
             nativeEntryId: thread.id,
             name: redactCodexNativeSensitiveText(thread.name),
         });
     }
-    for (const turn of thread.turns) {
-        for (const item of turn.items) {
-            const entry = itemEntry(thread, turn, item, sequence);
+    for (const [turnIndex, turn] of thread.turns.entries()) {
+        for (const [itemIndex, item] of turn.items.entries()) {
+            const entry = itemEntry(thread, turn, item, sequence, `codex:${thread.id}:turn:${turnIndex}:item:${itemIndex}:${item.type}`, historyScopeId);
             if (!entry)
                 continue;
             entries.push(entry);
@@ -187,7 +193,9 @@ export function codexThreadHistoryEntries(thread) {
                 type: "message",
                 source: "native",
                 createdAt: isoFromSeconds(turn.completedAt ?? turn.startedAt, thread.updatedAt),
-                sequence: sequence++,
+                sequence,
+                historyPosition: `codex:${thread.id}:turn:${turnIndex}:error`,
+                historyScopeId,
                 turnId: turn.id,
                 nativeTurnId: turn.id,
                 nativeEntryId: `${turn.id}:error`,
@@ -196,6 +204,7 @@ export function codexThreadHistoryEntries(thread) {
                 status: "error",
                 error: "Codex turn failed.",
             });
+            sequence += 1;
         }
     }
     return entries;
@@ -256,7 +265,8 @@ function selectedLimit(value) {
     return Math.min(value, MAX_HISTORY_LIMIT);
 }
 export function pageCodexThreadHistory(input) {
-    const allEntries = codexThreadHistoryEntries(input.thread);
+    const historyScopeId = `codex:${input.runtimeInstanceId}:${input.thread.id}`;
+    const allEntries = codexThreadHistoryEntries(input.thread, historyScopeId);
     const beforeTimestampMs = input.beforeTimestamp === undefined ? undefined : Date.parse(input.beforeTimestamp);
     if (beforeTimestampMs !== undefined && Number.isNaN(beforeTimestampMs)) {
         throw new Error("Codex native history beforeTimestamp is invalid.");
@@ -270,11 +280,20 @@ export function pageCodexThreadHistory(input) {
     const start = Math.max(0, end - limit);
     const entries = filtered.slice(start, end);
     const hasMore = start > 0;
+    const proofComplete = allEntries.length <= TRACE_RECONCILIATION_ENTRY_CAP;
     return {
         runtimeInstanceId: input.runtimeInstanceId,
         adapterId: CODEX_NATIVE_ADAPTER_ID,
         source: "native",
         entries,
+        reconciliationProof: proofComplete
+            ? {
+                complete: true,
+                scopeId: historyScopeId,
+                fullScope: { entryCount: allEntries.length, digest: historyReconciliationDigest(allEntries) },
+                entries: allEntries,
+            }
+            : { complete: false, scopeId: historyScopeId, entries },
         orderOffset: start,
         ...(hasMore ? { nextCursor: encodeCursor({ v: 1, threadId: input.thread.id, beforeIndex: start }) } : {}),
         hasMore,

package/dist/agent-runtimes/codex-native/models.js

@@ -19,6 +19,13 @@ export const CODEX_NATIVE_MODEL_OPTIONS_SCHEMA = {
             enum: ["auto", "concise", "detailed", "none"],
             description: "Optional native Codex reasoning-summary mode.",
         },
+        permissionMode: {
+            type: "string",
+            title: "Permission mode",
+            enum: ["approval", "yolo", "plan"],
+            default: "approval",
+            description: "Codex permissions: Approval asks before privileged work, YOLO disables approvals with unrestricted host access, and Plan uses a read-only planning turn.",
+        },
     },
 };
 const MAX_MODEL_PAGES = 20;
@@ -34,6 +41,7 @@ const MAX_DESCRIPTION_LENGTH = 4_096;
 const MAX_CURSOR_LENGTH = 1_024;
 const PERSONALITIES = new Set(["none", "friendly", "pragmatic"]);
 const REASONING_SUMMARIES = new Set(["auto", "concise", "detailed", "none"]);
+const PERMISSION_MODES = new Set(["approval", "yolo", "plan"]);
 const BINDING_MODEL_KEY = "codexNativeModelId";
 const BINDING_REASONING_KEY = "codexNativeReasoningEffort";
 const BINDING_SERVICE_TIER_KEY = "codexNativeServiceTier";
@@ -271,7 +279,7 @@ export function readCodexNativePersistedSettings(metadata) {
     };
 }
 export function parseCodexNativeProfileOptions(value) {
-    const allowed = new Set(["serviceTier", "personality", "reasoningSummary"]);
+    const allowed = new Set(["serviceTier", "personality", "reasoningSummary", "permissionMode"]);
     const unknown = Object.keys(value).filter((key) => !allowed.has(key));
     if (unknown.length > 0)
         throw new Error(`Unsupported native Codex runtime option${unknown.length === 1 ? "" : "s"}: ${unknown.join(", ")}.`);
@@ -297,8 +305,43 @@ export function parseCodexNativeProfileOptions(value) {
         }
         options.reasoningSummary = value.reasoningSummary;
     }
+    if (Object.hasOwn(value, "permissionMode")) {
+        if (typeof value.permissionMode !== "string" || !PERMISSION_MODES.has(value.permissionMode)) {
+            throw new Error("Native Codex runtime option permissionMode must be one of: approval, yolo, plan.");
+        }
+        options.permissionMode = value.permissionMode;
+    }
     return options;
 }
+export function codexNativePermissionMode(options) {
+    return options.permissionMode ?? "approval";
+}
+export function codexNativeThreadPermissionSelection(mode) {
+    if (mode === "yolo")
+        return { approvalPolicy: "never", sandbox: "danger-full-access" };
+    if (mode === "plan")
+        return { approvalPolicy: "on-request", sandbox: "read-only" };
+    return { approvalPolicy: "on-request", sandbox: "workspace-write" };
+}
+export function codexNativeTurnPermissionOptions(mode, model, effort) {
+    if (mode === "yolo") {
+        return { approvalPolicy: "never", sandboxPolicy: { type: "dangerFullAccess" } };
+    }
+    if (mode === "plan") {
+        return {
+            approvalPolicy: "on-request",
+            sandboxPolicy: { type: "readOnly", networkAccess: false },
+            collaborationMode: {
+                mode: "plan",
+                settings: { model, reasoning_effort: effort, developer_instructions: null },
+            },
+        };
+    }
+    return {
+        approvalPolicy: "on-request",
+        sandboxPolicy: { type: "workspaceWrite", networkAccess: false },
+    };
+}
 function findModel(catalog, value) {
     return catalog.models.find((model) => model.id === value || model.model === value);
 }
@@ -374,6 +417,7 @@ export class CodexNativeSessionSettingsController {
     serviceTier;
     personality;
     reasoningSummary;
+    permissionMode;
     activeThreadId;
     contextUsage;
     pendingContextUsage = new Map();
@@ -394,6 +438,7 @@ export class CodexNativeSessionSettingsController {
         this.serviceTier = validateServiceTier(this.currentModel, selectedTier);
         this.personality = initial.profileOptions.personality;
         this.reasoningSummary = initial.profileOptions.reasoningSummary;
+        this.permissionMode = codexNativePermissionMode(initial.profileOptions);
         this.bindClient(client);
     }
     bindClient(client) {
@@ -459,6 +504,7 @@ export class CodexNativeSessionSettingsController {
             model: this.currentModel.id,
             serviceTier: this.serviceTier,
             ...(this.personality !== undefined ? { personality: this.personality } : {}),
+            ...codexNativeThreadPermissionSelection(this.permissionMode),
         };
     }
     get turnOptions() {
@@ -468,6 +514,7 @@ export class CodexNativeSessionSettingsController {
             serviceTier: this.serviceTier,
             ...(this.reasoningSummary !== undefined ? { summary: this.reasoningSummary } : {}),
             ...(this.personality !== undefined ? { personality: this.personality } : {}),
+            ...codexNativeTurnPermissionOptions(this.permissionMode, this.currentModel.id, this.reasoningLevel),
         };
     }
     setModel(model) {

package/dist/agent-runtimes/codex-native/process.js

@@ -419,10 +419,16 @@ export async function startCodexNativeAppServer(input) {
     if (!input.clientVersion.trim()) {
         throw new CodexNativeProcessError("start_failed", "Codex App Server client version is required.");
     }
+    if (input.realtimeSidebandBaseUrl !== undefined && !input.realtimeSidebandBaseUrl.trim()) {
+        throw new CodexNativeProcessError("start_failed", "Codex realtime sideband base URL must not be empty.");
+    }
+    if (input.realtimeWebrtcCallBaseUrl !== undefined && !input.realtimeWebrtcCallBaseUrl.trim()) {
+        throw new CodexNativeProcessError("start_failed", "Codex realtime WebRTC call base URL must not be empty.");
+    }
     const paths = await prepareCodexNativeSessionPaths(input);
     let client;
     try {
-        const capabilities = { experimentalApi: false };
+        const capabilities = { experimentalApi: input.experimentalApi === true };
         const invocation = codexExecutableInvocation(input.config.executable, [
             "app-server",
             "--stdio",
@@ -431,6 +437,13 @@ export async function startCodexNativeAppServer(input) {
             `tools.experimental_request_user_input.enabled=${input.config.experimentalUserInput}`,
             "-c",
             `features.default_mode_request_user_input=${input.config.experimentalUserInput}`,
+            ...(input.realtimeConversation ? ["-c", "features.realtime_conversation=true"] : []),
+            ...(input.realtimeSidebandBaseUrl
+                ? ["-c", `experimental_realtime_ws_base_url=${JSON.stringify(input.realtimeSidebandBaseUrl)}`]
+                : []),
+            ...(input.realtimeWebrtcCallBaseUrl
+                ? ["-c", `experimental_realtime_webrtc_call_base_url=${JSON.stringify(input.realtimeWebrtcCallBaseUrl)}`]
+                : []),
         ]);
         client = await CodexAppServerClient.start({
             command: invocation.command,
@@ -450,6 +463,7 @@ export async function startCodexNativeAppServer(input) {
             shutdownTimeoutMs: input.config.shutdownTimeoutMs,
             killTimeoutMs: input.config.killTimeoutMs,
             onDiagnostic: input.onDiagnostic,
+            signal: input.signal,
         });
         const [reportedHome, expectedHome] = await Promise.all([
             realpath(client.initializeResponse.codexHome).catch(() => resolve(client.initializeResponse.codexHome)),