codex-chatgpt-control 0.5.1-alpha.2 → 0.5.1-alpha.4

package/dist/src/backend/session.js

@@ -1,14 +1,25 @@
+import { randomUUID } from "node:crypto";
 import { createChatGPT } from "../client.js";
+import { toOperationCollectWireResult, toOperationControlWireResult, toOperationInspectWireResult, toOperationSubmitWireResult } from "../operations/wire-results.js";
+import { OperationWireRequestError, validateOperationCollectRequest as validateWireCollectRequest, validateOperationControlRequest as validateWireControlRequest, validateOperationInspectRequest as validateWireInspectRequest, validateOperationSubmitRequest as validateWireSubmitRequest } from "../operations/wire-requests.js";
+import { assertOperationAwareDispatchAllowed, classifyCommandRouting, commandRoutingDisposition, CommandRoutingError } from "../runtime/command-routing.js";
 import { BACKEND_REQUEST_SCHEMA_VERSION, backendCommands, backendResponseError, backendEvent, backendEventCompleted, backendResponseOk, ProtocolError } from "./protocol.js";
+// A stdio backend process owns one identity. BackendSession objects created by
+// that process share it unless an embedding explicitly injects a diagnostic
+// identity (for example, a test or a separately fenced runtime).
+const PROCESS_BACKEND_SESSION_ID = randomUUID();
+const MAX_IDENTITY_FIELD_LENGTH = 512;
 export class BackendSession {
     options;
     clientInstance;
+    identity;
     constructor(options = {}) {
         this.options = options;
+        this.identity = backendRuntimeIdentity(options.backendIdentity);
     }
     async dispatch(request) {
         try {
-            const result = await dispatchBackendCommand(this.client(), request);
+            const result = await dispatchBackendCommand(request, payload => this.hello(payload), this.identity, () => this.client());
             return backendResponseOk(request.requestId, result);
         }
         catch (error) {
@@ -17,6 +28,8 @@ export class BackendSession {
     }
     async *stream(request) {
         try {
+            assertCommandRoutingClassified(request.command);
+            assertBackendOperationRoutingAllowed(request.command, request.payload);
             if (request.command !== "runner.stream") {
                 const response = await this.dispatch(request);
                 if (response.ok) {
@@ -40,9 +53,11 @@ export class BackendSession {
             yield backendEventCompleted(request.requestId, await stream.completed);
         }
         catch (error) {
+            // Runner/provider errors may contain prompt or page content. Only an
+            // explicit ProtocolError carries a reviewed wire-safe message.
             const protocolError = error instanceof ProtocolError
                 ? error
-                : new ProtocolError("invalid_request", error instanceof Error ? error.message : String(error), false);
+                : new ProtocolError("invalid_request", "Backend stream failed safely.", false);
             yield backendEvent(request.requestId, {
                 type: "error",
                 error: {
@@ -53,19 +68,41 @@ export class BackendSession {
             });
         }
     }
+    hello(payload) {
+        const requestedProtocol = payload.protocolVersion;
+        const hasRequestedCapabilities = Object.hasOwn(payload, "capabilities");
+        const baseCapabilities = backendCapabilities(this.identity);
+        const requestedCapabilities = isRecord(payload.capabilities) ? payload.capabilities : undefined;
+        const capabilities = intersectCapabilities(baseCapabilities, requestedCapabilities);
+        const accepted = (requestedProtocol === undefined || requestedProtocol === this.identity.protocolVersion)
+            && (!hasRequestedCapabilities
+                || (requestedCapabilities !== undefined
+                    && requestedCapabilitiesSatisfied(baseCapabilities, capabilities, requestedCapabilities)));
+        return {
+            ...this.identity,
+            accepted,
+            capabilities
+        };
+    }
     client() {
         this.clientInstance ??= createChatGPT(this.options);
         return this.clientInstance;
     }
 }
-async function dispatchBackendCommand(client, request) {
+async function dispatchBackendCommand(request, hello, identity, clientFactory) {
+    assertCommandRoutingClassified(request.command);
+    assertBackendOperationRoutingAllowed(request.command, request.payload);
     const payload = request.payload;
+    const client = new Proxy({}, {
+        get: (_target, property, receiver) => Reflect.get(clientFactory(), property, receiver)
+    });
     switch (request.command) {
+        case "backend.hello":
+            return hello(payload);
         case "backend.version":
             return {
                 name: "codex-chatgpt-control-backend",
-                runtime: "node",
-                protocolVersion: BACKEND_REQUEST_SCHEMA_VERSION
+                ...identity
             };
         case "backend.health":
             return {
@@ -74,7 +111,7 @@ async function dispatchBackendCommand(client, request) {
                 timestamp: new Date().toISOString()
             };
         case "backend.capabilities":
-            return backendCapabilities();
+            return backendCapabilities(identity);
         case "runner.run": {
             const agent = client.agent(agentConfig(payload));
             return client.runner.run(agent, runInput(payload));
@@ -189,19 +226,453 @@ async function dispatchBackendCommand(client, request) {
             return client.tools.select(payload);
         case "response.copy":
             return client.response.copy(emptyToUndefined(payload));
+        case "operations.submit":
+            return dispatchOperationSubmit(client, payload);
+        case "operations.collect":
+            return dispatchOperationCollect(client, payload);
+        case "operations.inspect":
+            return dispatchOperationInspect(client, payload);
+        case "operations.control":
+            return dispatchOperationControl(client, payload);
+    }
+}
+function assertCommandRoutingClassified(command) {
+    if (classifyCommandRouting(command) === undefined) {
+        throw new ProtocolError("invalid_request", "Backend command routing classification is unavailable.", false);
+    }
+    if (commandRoutingDisposition(command) === undefined) {
+        // A known legacy browser command may only be admitted once its bounded
+        // coordinator seam is present. Keep this static: command payloads can
+        // contain prompts, local paths, or operation handles.
+        throw new ProtocolError("invalid_request", "Backend command has no bounded coordinator route.", false);
+    }
+}
+function assertBackendOperationRoutingAllowed(command, payload) {
+    try {
+        assertOperationAwareDispatchAllowed(command, payload);
+    }
+    catch (error) {
+        if (error instanceof CommandRoutingError) {
+            // Keep the protocol error static. Operation payloads can contain raw
+            // prompts, instructions, file paths, or handles and must never be
+            // echoed as part of a routing failure.
+            throw new ProtocolError("invalid_request", error.message, false);
+        }
+        throw error;
     }
 }
-function backendCapabilities() {
+function backendCapabilities(identity) {
     return {
+        ...identity,
         protocolVersion: BACKEND_REQUEST_SCHEMA_VERSION,
         commands: [...backendCommands],
         transports: ["stdio"],
         streaming: {
             modes: ["ndjson"],
             tokenDeltas: false
+        },
+        supportedProtocolVersions: [BACKEND_REQUEST_SCHEMA_VERSION],
+        requestIds: {
+            required: true,
+            scope: "connection"
+        },
+        multiplexing: {
+            unary: true,
+            streams: true
+        },
+        cancellation: {
+            supported: false,
+            requests: false,
+            streams: false
+        },
+        tabs: {
+            stableProviderIdentity: false,
+            stableBrowserIdentity: false,
+            stableTabIdentity: false,
+            coordinationScope: "none",
+            authoritativeClaim: false,
+            fencing: false,
+            concurrentTabs: false,
+            stableIdentity: false,
+            coordination: false,
+            concurrent: false
+        }
+    };
+}
+async function dispatchOperationSubmit(client, payload) {
+    const operations = requireOperations(client);
+    const request = operationSubmitRequest(payload);
+    const result = await runOperationSafely(() => operations.submit(request));
+    const inspected = await runOperationSafely(() => operations.inspect(result.handle));
+    return operationWireSafely(() => toOperationSubmitWireResult(result, inspected.state.receipt));
+}
+async function dispatchOperationCollect(client, payload) {
+    const operations = requireOperations(client);
+    const request = operationCollectRequest(payload);
+    const result = await runOperationSafely(() => operations.collect(request.handle, {
+        ...(request.wait === undefined ? {} : { wait: request.wait }),
+        ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
+        ...(request.pollIntervalMs === undefined ? {} : { pollIntervalMs: request.pollIntervalMs }),
+        ...(request.responseContent === undefined ? {} : { responseContent: request.responseContent })
+    }));
+    // The caller's locator is never returned as authoritative state. Reloading
+    // after the attempt obtains a fresh, authenticated handle for the wire
+    // envelope and keeps collection's browser-free terminal path intact.
+    const inspected = await runOperationSafely(() => operations.inspect(request.handle));
+    return operationWireSafely(() => toOperationCollectWireResult(inspected.handle, result, inspected.state.receipt));
+}
+async function dispatchOperationInspect(client, payload) {
+    const operations = requireOperations(client);
+    const request = operationInspectRequest(payload);
+    // OperationClient.inspect is explicitly browser-free. Keep this command on
+    // that path; no adapter factory or browser bridge is consulted here.
+    const result = await runOperationSafely(() => operations.inspect(request.handle));
+    return operationWireSafely(() => toOperationInspectWireResult(result));
+}
+async function dispatchOperationControl(client, payload) {
+    const operations = requireOperations(client);
+    const request = operationControlRequest(payload);
+    const result = await runOperationSafely(() => operations.control(request));
+    const inspected = await runOperationSafely(() => operations.inspect(request.parent));
+    return operationWireSafely(() => toOperationControlWireResult(result, inspected.handle));
+}
+function requireOperations(client) {
+    const operations = client.operations;
+    if (operations === undefined
+        || typeof operations !== "object"
+        || typeof operations.submit !== "function"
+        || typeof operations.collect !== "function"
+        || typeof operations.inspect !== "function"
+        || typeof operations.control !== "function") {
+        throw new ProtocolError("invalid_request", "Transactional browser operations are unavailable in this backend.", false);
+    }
+    return operations;
+}
+function operationSubmitRequest(payload) {
+    return validateOperationPayload(payload, validateWireSubmitRequest);
+}
+function operationCollectRequest(payload) {
+    return validateOperationPayload(payload, validateWireCollectRequest);
+}
+function operationInspectRequest(payload) {
+    return validateOperationPayload(payload, validateWireInspectRequest);
+}
+function operationControlRequest(payload) {
+    return validateOperationPayload(payload, validateWireControlRequest);
+}
+function validateOperationPayload(payload, validator) {
+    try {
+        validator(payload);
+        return payload;
+    }
+    catch (error) {
+        if (error instanceof OperationWireRequestError)
+            throw invalidOperationPayload();
+        throw error;
+    }
+}
+function invalidOperationPayload() {
+    // Do not include the offending value: it may contain a prompt or local path.
+    return new ProtocolError("invalid_request", "Transactional operation payload is invalid.", false);
+}
+async function runOperationSafely(call) {
+    try {
+        return await call();
+    }
+    catch (error) {
+        if (error instanceof ProtocolError)
+            throw error;
+        // Operation adapters and journal errors can contain raw prompts, paths,
+        // URLs, or provider-private diagnostics. None may cross the backend wire.
+        throw new ProtocolError("invalid_request", "Transactional browser operation could not complete safely.", false);
+    }
+}
+function operationWireSafely(call) {
+    try {
+        return call();
+    }
+    catch (error) {
+        if (error instanceof ProtocolError)
+            throw error;
+        throw new ProtocolError("invalid_request", "Transactional browser operation could not complete safely.", false);
+    }
+}
+function intersectCapabilities(base, requested) {
+    if (requested === undefined)
+        return base;
+    const requestedStreaming = isRecord(requested.streaming) ? requested.streaming : undefined;
+    const requestedRequestIds = isRecord(requested.requestIds) ? requested.requestIds : undefined;
+    const requestedMultiplexing = isRecord(requested.multiplexing) ? requested.multiplexing : undefined;
+    const requestedCancellation = isRecord(requested.cancellation) ? requested.cancellation : undefined;
+    const requestedTabs = isRecord(requested.tabs) ? requested.tabs : undefined;
+    const intersectedCommands = Array.isArray(requested.commands)
+        ? base.commands.filter(command => includesString(requested.commands, command))
+        : base.commands;
+    const commands = intersectedCommands.length > 0 ? intersectedCommands : base.commands;
+    const intersectedTransports = Array.isArray(requested.transports)
+        ? base.transports.filter(transport => includesString(requested.transports, transport))
+        : base.transports;
+    const transports = intersectedTransports.length > 0 ? intersectedTransports : base.transports;
+    const intersectedModes = requestedStreaming !== undefined && Array.isArray(requestedStreaming.modes)
+        ? base.streaming.modes.filter(mode => includesString(requestedStreaming.modes, mode))
+        : base.streaming.modes;
+    const modes = intersectedModes.length > 0 ? intersectedModes : base.streaming.modes;
+    const intersectedProtocolVersions = Array.isArray(requested.supportedProtocolVersions)
+        ? base.supportedProtocolVersions.filter(version => includesString(requested.supportedProtocolVersions, version))
+        : base.supportedProtocolVersions;
+    const requestIdScope = requestedRequestIds?.scope === undefined || requestedRequestIds.scope === base.requestIds.scope
+        ? base.requestIds.scope
+        : "none";
+    const coordinationScope = requestedTabs?.coordinationScope === undefined
+        || requestedTabs.coordinationScope === base.tabs.coordinationScope
+        ? base.tabs.coordinationScope
+        : "none";
+    const stableProviderIdentity = base.tabs.stableProviderIdentity && requestedTabs?.stableProviderIdentity !== false;
+    const stableBrowserIdentity = base.tabs.stableBrowserIdentity && requestedTabs?.stableBrowserIdentity !== false;
+    const stableTabIdentity = base.tabs.stableTabIdentity && requestedTabs?.stableTabIdentity !== false;
+    const authoritativeClaim = base.tabs.authoritativeClaim && requestedTabs?.authoritativeClaim !== false;
+    const fencing = base.tabs.fencing && requestedTabs?.fencing !== false;
+    const concurrentTabs = base.tabs.concurrentTabs && requestedTabs?.concurrentTabs !== false;
+    return {
+        ...base,
+        supportedProtocolVersions: intersectedProtocolVersions.length > 0
+            ? intersectedProtocolVersions
+            : base.supportedProtocolVersions,
+        commands,
+        transports,
+        streaming: {
+            modes,
+            tokenDeltas: base.streaming.tokenDeltas && requestedStreaming?.tokenDeltas !== false
+        },
+        requestIds: {
+            required: base.requestIds.required && requestedRequestIds?.required !== false,
+            scope: requestIdScope
+        },
+        multiplexing: {
+            unary: base.multiplexing.unary && requestedMultiplexing?.unary !== false,
+            streams: base.multiplexing.streams && requestedMultiplexing?.streams !== false
+        },
+        cancellation: {
+            supported: base.cancellation.supported && requestedCancellation?.supported === true,
+            requests: base.cancellation.requests && requestedCancellation?.requests === true,
+            streams: base.cancellation.streams && requestedCancellation?.streams === true
+        },
+        tabs: {
+            ...base.tabs,
+            stableProviderIdentity,
+            stableBrowserIdentity,
+            stableTabIdentity,
+            coordinationScope,
+            authoritativeClaim,
+            fencing,
+            concurrentTabs,
+            stableIdentity: stableProviderIdentity && stableBrowserIdentity && stableTabIdentity,
+            coordination: coordinationScope !== "none",
+            concurrent: concurrentTabs
         }
     };
 }
+function requestedCapabilitiesSatisfied(base, intersection, requested) {
+    if (!requestedCapabilitiesShapeValid(requested))
+        return false;
+    if ((Array.isArray(requested.commands) && requested.commands.length === 0)
+        || (Array.isArray(requested.transports) && requested.transports.length === 0)
+        || (Array.isArray(requested.supportedProtocolVersions) && requested.supportedProtocolVersions.length === 0))
+        return false;
+    if (Array.isArray(requested.commands)
+        && requested.commands.some(command => typeof command !== "string" || !base.commands.includes(command)))
+        return false;
+    if (Array.isArray(requested.transports)
+        && requested.transports.some(transport => typeof transport !== "string" || !base.transports.includes(transport)))
+        return false;
+    const requestedStreaming = isRecord(requested.streaming) ? requested.streaming : undefined;
+    if (requested.streaming !== undefined && requestedStreaming === undefined)
+        return false;
+    if (requestedStreaming
+        && Array.isArray(requestedStreaming.modes)) {
+        if (requestedStreaming.modes.length === 0
+            || requestedStreaming.modes.some(mode => typeof mode !== "string" || !base.streaming.modes.includes(mode)))
+            return false;
+    }
+    if (requestedStreaming?.tokenDeltas === true && !intersection.streaming.tokenDeltas)
+        return false;
+    if (Array.isArray(requested.supportedProtocolVersions)
+        && requested.supportedProtocolVersions.some(version => typeof version !== "string" || !base.supportedProtocolVersions.includes(version)))
+        return false;
+    const requestedRequestIds = isRecord(requested.requestIds) ? requested.requestIds : undefined;
+    if (requested.requestIds !== undefined && requestedRequestIds === undefined)
+        return false;
+    if (requestedRequestIds
+        && ((requestedRequestIds.required === true && !intersection.requestIds.required)
+            || (requestedRequestIds.scope !== undefined && requestedRequestIds.scope !== intersection.requestIds.scope)))
+        return false;
+    const requestedMultiplexing = isRecord(requested.multiplexing) ? requested.multiplexing : undefined;
+    if (requested.multiplexing !== undefined && requestedMultiplexing === undefined)
+        return false;
+    if (requestedMultiplexing
+        && ((requestedMultiplexing.unary === true && !intersection.multiplexing.unary)
+            || (requestedMultiplexing.streams === true && !intersection.multiplexing.streams)))
+        return false;
+    const requestedCancellation = isRecord(requested.cancellation) ? requested.cancellation : undefined;
+    if (requested.cancellation !== undefined && requestedCancellation === undefined)
+        return false;
+    if (requestedCancellation
+        && ((requestedCancellation.supported === true && !intersection.cancellation.supported)
+            || (requestedCancellation.requests === true && !intersection.cancellation.requests)
+            || (requestedCancellation.streams === true && !intersection.cancellation.streams)))
+        return false;
+    const requestedTabs = isRecord(requested.tabs) ? requested.tabs : undefined;
+    if (requested.tabs !== undefined && requestedTabs === undefined)
+        return false;
+    if (requestedTabs
+        && ((requestedTabs.stableProviderIdentity === true && !intersection.tabs.stableProviderIdentity)
+            || (requestedTabs.stableBrowserIdentity === true && !intersection.tabs.stableBrowserIdentity)
+            || (requestedTabs.stableTabIdentity === true && !intersection.tabs.stableTabIdentity)
+            || (requestedTabs.authoritativeClaim === true && !intersection.tabs.authoritativeClaim)
+            || (requestedTabs.fencing === true && !intersection.tabs.fencing)
+            || (requestedTabs.concurrentTabs === true && !intersection.tabs.concurrentTabs)
+            || (requestedTabs.stableIdentity === true && !intersection.tabs.stableIdentity)
+            || (requestedTabs.coordination === true && !intersection.tabs.coordination)
+            || (requestedTabs.concurrent === true && !intersection.tabs.concurrent)
+            || (requestedTabs.coordinationScope !== undefined && requestedTabs.coordinationScope !== intersection.tabs.coordinationScope)
+            || !requestedDeprecatedTabAliasesConsistent(requestedTabs)))
+        return false;
+    return true;
+}
+function requestedCapabilitiesShapeValid(requested) {
+    if (!optionalStringArray(requested.commands)
+        || !optionalStringArray(requested.transports)
+        || !optionalStringArray(requested.supportedProtocolVersions))
+        return false;
+    for (const field of ["backendSessionId", "packageName", "packageVersion", "runtimeVersion", "buildDigest"]) {
+        if (Object.hasOwn(requested, field) && !optionalIdentityString(requested[field]))
+            return false;
+    }
+    if (Object.hasOwn(requested, "runtime") && requested.runtime !== "node")
+        return false;
+    if (Object.hasOwn(requested, "protocolVersion")
+        && requested.protocolVersion !== BACKEND_REQUEST_SCHEMA_VERSION)
+        return false;
+    if (Object.hasOwn(requested, "streaming")) {
+        if (!isRecord(requested.streaming)
+            || !optionalStringArray(requested.streaming.modes)
+            || !optionalBoolean(requested.streaming.tokenDeltas))
+            return false;
+    }
+    if (Object.hasOwn(requested, "requestIds")) {
+        if (!isRecord(requested.requestIds)
+            || !optionalBoolean(requested.requestIds.required)
+            || (requested.requestIds.scope !== undefined
+                && requested.requestIds.scope !== "connection"
+                && requested.requestIds.scope !== "process"
+                && requested.requestIds.scope !== "none"))
+            return false;
+    }
+    if (Object.hasOwn(requested, "multiplexing")) {
+        if (!isRecord(requested.multiplexing)
+            || !optionalBoolean(requested.multiplexing.unary)
+            || !optionalBoolean(requested.multiplexing.streams))
+            return false;
+    }
+    if (Object.hasOwn(requested, "cancellation")) {
+        if (!isRecord(requested.cancellation)
+            || !optionalBoolean(requested.cancellation.supported)
+            || !optionalBoolean(requested.cancellation.requests)
+            || !optionalBoolean(requested.cancellation.streams))
+            return false;
+    }
+    if (Object.hasOwn(requested, "tabs")) {
+        if (!isRecord(requested.tabs)
+            || !optionalBoolean(requested.tabs.stableProviderIdentity)
+            || !optionalBoolean(requested.tabs.stableBrowserIdentity)
+            || !optionalBoolean(requested.tabs.stableTabIdentity)
+            || (requested.tabs.coordinationScope !== undefined
+                && requested.tabs.coordinationScope !== "none"
+                && requested.tabs.coordinationScope !== "process"
+                && requested.tabs.coordinationScope !== "provider")
+            || !optionalBoolean(requested.tabs.authoritativeClaim)
+            || !optionalBoolean(requested.tabs.fencing)
+            || !optionalBoolean(requested.tabs.concurrentTabs)
+            || !optionalBoolean(requested.tabs.stableIdentity)
+            || !optionalBoolean(requested.tabs.coordination)
+            || !optionalBoolean(requested.tabs.concurrent))
+            return false;
+    }
+    return true;
+}
+function optionalStringArray(value) {
+    return value === undefined || (Array.isArray(value) && value.every(item => typeof item === "string"));
+}
+function optionalBoolean(value) {
+    return value === undefined || typeof value === "boolean";
+}
+function optionalIdentityString(value) {
+    return value === undefined
+        || (typeof value === "string"
+            && value.length > 0
+            && value.length <= MAX_IDENTITY_FIELD_LENGTH
+            && value.trim() === value
+            && !/[\u0000-\u001f\u007f]/u.test(value));
+}
+function requestedDeprecatedTabAliasesConsistent(tabs) {
+    const hasStableFields = ["stableProviderIdentity", "stableBrowserIdentity", "stableTabIdentity"]
+        .every(field => Object.hasOwn(tabs, field));
+    const expectedStableIdentity = hasStableFields
+        && tabs.stableProviderIdentity === true
+        && tabs.stableBrowserIdentity === true
+        && tabs.stableTabIdentity === true;
+    const expectedCoordination = tabs.coordinationScope !== undefined && tabs.coordinationScope !== "none";
+    const expectedConcurrent = tabs.concurrentTabs === true;
+    return (!Object.hasOwn(tabs, "stableIdentity")
+        || !hasStableFields
+        || tabs.stableIdentity === expectedStableIdentity)
+        && (!Object.hasOwn(tabs, "coordination")
+            || tabs.coordination === expectedCoordination)
+        && (!Object.hasOwn(tabs, "concurrent")
+            || tabs.concurrent === expectedConcurrent);
+}
+function includesString(value, expected) {
+    return Array.isArray(value) && value.includes(expected);
+}
+function backendRuntimeIdentity(rawOverrides = {}) {
+    const overrides = validateIdentityOverrides(rawOverrides);
+    return {
+        backendSessionId: identityString(overrides.backendSessionId ?? PROCESS_BACKEND_SESSION_ID, "backendSessionId"),
+        packageName: identityString(overrides.packageName ?? process.env.CHATGPT_BROWSER_CONTROL_PACKAGE_NAME ?? "codex-chatgpt-control", "packageName"),
+        packageVersion: identityString(overrides.packageVersion ?? process.env.CHATGPT_BROWSER_CONTROL_PACKAGE_VERSION ?? "unknown", "packageVersion"),
+        runtime: "node",
+        runtimeVersion: identityString(overrides.runtimeVersion ?? process.env.CHATGPT_BROWSER_CONTROL_RUNTIME_VERSION ?? process.version, "runtimeVersion"),
+        buildDigest: identityString(overrides.buildDigest
+            ?? process.env.CHATGPT_BROWSER_CONTROL_BUILD_DIGEST
+            ?? process.env.CHATGPT_BROWSER_CONTROL_BUILD_SHA
+            ?? "unknown", "buildDigest"),
+        protocolVersion: BACKEND_REQUEST_SCHEMA_VERSION
+    };
+}
+function validateIdentityOverrides(value) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        throw new TypeError("backendIdentity must be an object when provided.");
+    const allowed = new Set(["backendSessionId", "packageName", "packageVersion", "runtimeVersion", "buildDigest"]);
+    if (Object.keys(value).some(key => !allowed.has(key))) {
+        throw new TypeError("backendIdentity contains unsupported fields.");
+    }
+    for (const [key, field] of Object.entries(value)) {
+        identityString(field, key);
+    }
+    return value;
+}
+function identityString(value, label) {
+    if (typeof value !== "string"
+        || value.length === 0
+        || value.length > MAX_IDENTITY_FIELD_LENGTH
+        || value.trim() !== value
+        || /[\u0000-\u001f\u007f]/u.test(value)) {
+        throw new TypeError(`backend identity ${label} must be a bounded, non-empty string.`);
+    }
+    return value;
+}
 function agentConfig(payload) {
     return requiredRecord(payload, "agent");
 }

package/dist/src/backend/stdio-server.d.ts

@@ -1,9 +1,12 @@
 import type { Readable, Writable } from "node:stream";
-import { BackendSession } from "./session.js";
+import { BackendSession, type BackendSessionOptions } from "./session.js";
 export type BackendStdioServerOptions = {
     input: Readable;
     output: Writable;
     error?: Writable;
     session?: BackendSession;
+    backendIdentity?: BackendSessionOptions["backendIdentity"];
+    maxInFlight?: number;
+    frameLimitBytes?: number;
 };
 export declare function runBackendStdioServer(options: BackendStdioServerOptions): Promise<void>;