agent-embassy 3.1.0 → 4.0.0

package/dist/src/gateway/providers.js

@@ -1,975 +0,0 @@
-import { createHash } from "node:crypto";
-import path from "node:path";
-import { BridgeError } from "../errors.js";
-import { isAttestedGatewayNodeInventory } from "./federation-nodes.js";
-import { CLAUDE_PEER_COMPATIBILITY, ClaudePeerAdapter, } from "./claude-peer.js";
-import { ClaudeNativeHelperSupervisor, } from "./claude-helper-supervisor.js";
-import { composeProvenanceEnvelope } from "./provenance-envelope.js";
-const NATIVE_CLAUDE_NAME = /^[a-z][a-z0-9_-]{0,31}$/;
-const PUBLIC_ALIAS = /^[a-z][a-z0-9_-]{0,31}@[a-z0-9](?:[a-z0-9.-]{0,61}[a-z0-9])?$/;
-const OPAQUE_ROUTE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/;
-const MAX_CLAUDE_PENDING = 1_024;
-const DEFAULT_CLAUDE_DISCOVERY_POLL_MS = 1_000;
-const DEFAULT_CODEX_OBSERVATION_POLL_MS = 15_000;
-const DEFAULT_CODEX_OBSERVATION_TIMEOUT_MS = 15_000;
-const DEFAULT_CODEX_OBSERVATION_BACKOFF_MAX_MS = 60_000;
-const MAX_CODEX_OBSERVED_ROUTES = 128;
-export const CLAUDE_CLEAN_PREWRITE_RETRY_CODES = new Set([
-    "CLAUDE_PEER_TARGET_UNKNOWN",
-    "CLAUDE_PEER_WORKSPACE_UNATTESTED",
-]);
-const CODEX_CLEAN_RETRY_CODES = new Set([
-    "THREAD_NOT_OBSERVED",
-    "ROUTE_BUSY",
-    "APPROVAL_REQUIRED",
-    "MANAGED_CODEX_UNAVAILABLE",
-    "LOCAL_APP_SERVER_NOT_RUNNING",
-    "ENDPOINT_GENERATION_CHANGED",
-    "SPAWN_FAILED",
-    "SPAWN_TIMEOUT",
-    "TRANSPORT_CONNECT_FAILED",
-    "REQUEST_TIMEOUT",
-]);
-function claudeCleanPrewriteResult(error) {
-    if (error instanceof BridgeError &&
-        error.code === "CLAUDE_PEER_MESSAGE_EXPIRED") {
-        return { state: "expired", safeErrorCode: "MESSAGE_EXPIRED" };
-    }
-    if (error instanceof BridgeError &&
-        CLAUDE_CLEAN_PREWRITE_RETRY_CODES.has(error.code)) {
-        return { state: "deferred", safeErrorCode: "ROUTE_BUSY" };
-    }
-    const systemCode = typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        typeof error.code === "string"
-        ? error.code
-        : undefined;
-    return {
-        state: "failed",
-        safeErrorCode: error instanceof BridgeError
-            ? error.code
-            : systemCode === "ENOENT"
-                ? "CLAUDE_DISPATCH_PREWRITE_PATH_MISSING"
-                : systemCode === "EACCES" || systemCode === "EPERM"
-                    ? "CLAUDE_DISPATCH_PREWRITE_ACCESS_DENIED"
-                    : systemCode === "ETIMEDOUT"
-                        ? "CLAUDE_DISPATCH_PREWRITE_TIMEOUT"
-                        : "CLAUDE_DISPATCH_PREWRITE_FAILED",
-    };
-}
-function claudePostAuthorizationResult(error) {
-    if (error instanceof BridgeError && error.recoverable) {
-        return {
-            state: "failed",
-            safeErrorCode: error.code === "CLAUDE_PEER_MESSAGE_EXPIRED"
-                ? "MESSAGE_EXPIRED"
-                : error.code,
-        };
-    }
-    return {
-        state: "ambiguous",
-        safeErrorCode: error instanceof BridgeError &&
-            /^[A-Z][A-Z0-9_]{0,95}$/.test(error.code)
-            ? error.code
-            : "CLAUDE_DISPATCH_OUTCOME_AMBIGUOUS",
-    };
-}
-async function cancelPreparedClaude(prepared) {
-    try {
-        await prepared.cancel();
-    }
-    catch {
-        // Cancellation is a no-write cleanup path. Its failure cannot turn a
-        // denied or uncertain authorization into permission to perform.
-    }
-}
-function exactLocalHost(hostId, inventory) {
-    if (!isAttestedGatewayNodeInventory(inventory, hostId)) {
-        throw new BridgeError("GATEWAY_REMOTE_PROVIDER_DISABLED", "The local host coordinate requires an attested node inventory.");
-    }
-    return hostId;
-}
-function positiveBounded(value, fallback, maximum) {
-    const resolved = value ?? fallback;
-    if (!Number.isSafeInteger(resolved) ||
-        resolved <= 0 ||
-        resolved > maximum) {
-        throw new BridgeError("INVALID_GATEWAY_PROVIDER_CONFIGURATION", "A provider capacity is outside its reviewed bound.");
-    }
-    return resolved;
-}
-function sameEndpoint(binding, identity) {
-    return (binding.provider === identity.provider &&
-        binding.hostId === identity.hostId);
-}
-function invokeCallback(operation) {
-    try {
-        operation();
-    }
-    catch {
-        // Provider observation consumers cannot change a transport outcome.
-    }
-}
-function validateClaudeRuntimePathEvidence(runtime) {
-    if ([runtime.sessionsDir, runtime.socketDir].some((value) => !path.isAbsolute(value) ||
-        path.normalize(value) !== value ||
-        value.includes("\0"))) {
-        throw new BridgeError("CLAUDE_RUNTIME_ATTESTATION_INVALID", "The local Claude provider requires bounded absolute runtime evidence.");
-    }
-}
-function claudeRouteState(peer) {
-    return peer.status === "idle" ? "idle" : "busy";
-}
-function claudeRegistryObservation(discovery) {
-    const rejected = Object.entries(discovery.rejected)
-        .filter((entry) => Number.isSafeInteger(entry[1]) && entry[1] > 0)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([safeErrorCode, count]) => Object.freeze({ safeErrorCode, count }));
-    return Object.freeze({
-        entriesScanned: discovery.entriesScanned,
-        parseableRecords: discovery.parseableRecords,
-        rejected: Object.freeze(rejected),
-    });
-}
-function unavailableClaudeRegistryObservation() {
-    return Object.freeze({
-        entriesScanned: 0,
-        parseableRecords: 0,
-        rejected: Object.freeze([
-            Object.freeze({
-                safeErrorCode: "CLAUDE_REGISTRY_UNAVAILABLE",
-                count: 1,
-            }),
-        ]),
-    });
-}
-export class LocalClaudeGatewayProvider {
-    identity;
-    protocol = "claude-peer";
-    protocolVersion = `${CLAUDE_PEER_COMPATIBILITY.peerProtocol}`;
-    peer;
-    stateRoot;
-    maxPending;
-    discoveryPollMs;
-    now;
-    nativeHelpers;
-    discovered = new Map();
-    /** Exact UUID selection plus its display-only observation bookkeeping. */
-    selected = new Map();
-    discoveryInFlight;
-    registryObservation;
-    monitorTimer;
-    callbacks;
-    initialized = false;
-    closed = false;
-    constructor(options) {
-        validateClaudeRuntimePathEvidence(options.runtime);
-        if (!path.isAbsolute(options.stateRoot) || options.stateRoot.includes("\0")) {
-            throw new BridgeError("INVALID_GATEWAY_PROVIDER_CONFIGURATION", "The Claude provider state root must be an absolute path.");
-        }
-        const hostId = exactLocalHost(options.hostId, options.nodeInventory);
-        this.identity = {
-            provider: "claude",
-            hostId,
-        };
-        this.stateRoot = options.stateRoot;
-        this.maxPending = positiveBounded(options.maxPendingMessages, MAX_CLAUDE_PENDING, 4_096);
-        this.discoveryPollMs = positiveBounded(options.discoveryPollMs, DEFAULT_CLAUDE_DISCOVERY_POLL_MS, 30_000);
-        this.now = options.now ?? Date.now;
-        const protocolRuntime = options.runtime;
-        this.peer = (options.peerFactory ??
-            ((runtime, deliveryNotices) => new ClaudePeerAdapter({
-                sessionsDir: runtime.sessionsDir,
-                socketDir: runtime.socketDir,
-                deliveryNotices,
-            })))(protocolRuntime, options.deliveryNotices ?? "merged");
-        this.nativeHelpers =
-            options.nativeHelpers === undefined
-                ? undefined
-                : new ClaudeNativeHelperSupervisor({
-                    identity: this.identity,
-                    runtime: protocolRuntime,
-                    deliveryNotices: options.deliveryNotices ?? "merged",
-                    maxPendingMessages: this.maxPending,
-                    maxHelpers: positiveBounded(options.nativeHelpers.maxHelpers, 128, 128),
-                    callbacks: () => this.callbacks,
-                    ...(options.nativeHelpers.factory === undefined
-                        ? {}
-                        : { factory: options.nativeHelpers.factory }),
-                });
-    }
-    latestRegistryObservation() {
-        return this.registryObservation;
-    }
-    async initialize(callbacks) {
-        if (this.closed) {
-            throw new BridgeError("CLAUDE_PROVIDER_CLOSED", "The local Claude provider is closed.");
-        }
-        if (this.initialized) {
-            throw new BridgeError("CLAUDE_PROVIDER_ALREADY_INITIALIZED", "The local Claude provider can be initialized only once.");
-        }
-        this.callbacks = callbacks;
-        this.initialized = true;
-        return { health: "healthy" };
-    }
-    async discoverClaudePeers() {
-        this.assertReady();
-        return await this.refreshClaudeDiscovery();
-    }
-    async assertWorkspaceDisjoint(routeHandle, stateRoot) {
-        this.assertReady();
-        await this.peer.assertTargetWorkspaceDisjoint(routeHandle, stateRoot);
-        const route = this.selected.get(routeHandle);
-        const alias = route?.alias ?? this.discovered.get(routeHandle)?.alias;
-        if (alias !== undefined) {
-            this.selected.set(routeHandle, {
-                alias,
-                dispatchEpoch: route?.dispatchEpoch ?? 0,
-                observationDirty: route?.observationDirty ?? false,
-                ...(route?.registrationId === undefined ? {} : { registrationId: route.registrationId }),
-                ...(route?.observation === undefined ? {} : { observation: route.observation }),
-                stateRoot,
-            });
-        }
-    }
-    async selectRoute(input) {
-        this.assertReady();
-        const candidate = this.discovered.get(input.routeHandle);
-        if (candidate === undefined || candidate.alias !== input.alias) {
-            // The TARGET moved between discovery and this pin — it renamed or left.
-            // A distinct code from the caller-side CLAUDE_ROUTE_MISMATCH, so the CLI
-            // cannot answer "fix your --from" to a problem at the other end.
-            throw new BridgeError("CLAUDE_TARGET_CHANGED", "The addressed Claude session no longer matches that exact peer generation.");
-        }
-        const route = this.selected.get(input.routeHandle);
-        this.selected.set(input.routeHandle, {
-            alias: input.alias,
-            dispatchEpoch: route?.dispatchEpoch ?? 0,
-            observation: `${candidate.state}:`,
-            observationDirty: false,
-            ...(route?.registrationId === undefined ? {} : { registrationId: route.registrationId }),
-            ...(route?.stateRoot === undefined ? {} : { stateRoot: route.stateRoot }),
-        });
-        this.scheduleClaudeMonitor();
-        return { routeHandle: input.routeHandle, state: candidate.state };
-    }
-    observeLogicalRoute(input) {
-        if (this.closed ||
-            !PUBLIC_ALIAS.test(input.alias) ||
-            !input.alias.endsWith(`@${this.identity.hostId}`) ||
-            !OPAQUE_ROUTE.test(input.routeHandle) ||
-            !OPAQUE_ROUTE.test(input.registrationId)) {
-            return;
-        }
-        const route = this.selected.get(input.routeHandle);
-        this.selected.set(input.routeHandle, {
-            alias: input.alias,
-            registrationId: input.registrationId,
-            stateRoot: this.stateRoot,
-            dispatchEpoch: route?.dispatchEpoch ?? 0,
-            observationDirty: route?.observationDirty ?? false,
-            ...(route?.observation === undefined ? {} : { observation: route.observation }),
-        });
-    }
-    forgetLogicalRoute(registrationId) {
-        for (const [routeHandle, route] of this.selected) {
-            if (route.registrationId === registrationId) {
-                this.selected.delete(routeHandle);
-            }
-        }
-    }
-    /**
-     * Converts an inherited messaging-socket capability into the owning
-     * session's UUID. The session need not hold a route yet: its route installs
-     * on its first send, and the service compares the claimed alias against
-     * discovery for that UUID.
-     */
-    async resolveReplyAddress(address) {
-        this.assertReady();
-        const resolved = await this.peer.resolveReplyAddress(address);
-        if (resolved.kind !== "interactive" && resolved.kind !== "bg") {
-            throw new BridgeError("CLAUDE_REPLY_ROUTE_MISMATCH", "The reply capability does not belong to a Claude session.");
-        }
-        return { routeHandle: resolved.targetId };
-    }
-    async advertiseNativeSourcePeer(input) {
-        await this.helpers().advertise(input);
-    }
-    async unadvertiseNativeSourcePeer(alias) {
-        await this.helpers().unadvertise(alias);
-    }
-    async updateNativeSourcePeerStatus(alias, status) {
-        await this.helpers().updateStatus(alias, status);
-    }
-    async updateNativeInboundStatus(receiptHandle, status, diagnosticCode) {
-        await this.helpers().updateInboundStatus(receiptHandle, status, diagnosticCode);
-    }
-    async notifyNativeInboundProgress(receiptHandle, progress) {
-        await this.helpers().notifyInboundProgress(receiptHandle, progress);
-    }
-    async releaseNativeInboundReceipt(receiptHandle) {
-        return await this.helpers().releaseInboundReceipt(receiptHandle);
-    }
-    async dispatch(input) {
-        if (!this.initialized ||
-            this.closed ||
-            !sameEndpoint(input.binding, this.identity)) {
-            return { state: "failed", safeErrorCode: "CLAUDE_ROUTE_UNAVAILABLE" };
-        }
-        if (input.authorization === "selected_route") {
-            const logical = this.selected.get(input.binding.routeHandle);
-            if (logical === undefined ||
-                logical.alias !== input.targetAlias ||
-                logical.registrationId !== input.binding.registrationId) {
-                return { state: "failed", safeErrorCode: "CLAUDE_ROUTE_UNAVAILABLE" };
-            }
-            logical.dispatchEpoch += 1;
-            logical.observationDirty = true;
-            this.emitClaudeRouteObservation(input.binding.routeHandle, "busy");
-        }
-        let prepared;
-        try {
-            const selected = this.selected.get(input.binding.routeHandle);
-            prepared = await this.helpers().prepareDispatch({
-                sourceAlias: input.sourceAlias,
-                sourceProvider: input.sourceProvider,
-                targetAlias: input.targetAlias,
-                conversationId: input.conversationId,
-                binding: input.binding,
-                authorization: input.authorization,
-                messageId: input.messageId,
-                text: input.text,
-                expectsReply: input.expectsReply,
-                deadlineAt: input.deadlineAt,
-                ...(selected?.alias === undefined ? {} : { selectedAlias: selected.alias }),
-                ...(input.authorization !== "selected_route" || selected?.stateRoot === undefined
-                    ? {}
-                    : { stateRoot: selected.stateRoot }),
-            });
-        }
-        catch (error) {
-            if (error instanceof BridgeError &&
-                CLAUDE_CLEAN_PREWRITE_RETRY_CODES.has(error.code)) {
-                this.emitClaudeRouteObservation(input.binding.routeHandle, "busy", error.code);
-            }
-            return claudeCleanPrewriteResult(error);
-        }
-        const evidence = {
-            attemptId: input.attemptId,
-            kind: "claude_mailbox",
-            bodyBytes: Buffer.byteLength(input.text, "utf8"),
-            bodySha256: createHash("sha256").update(input.text).digest("hex"),
-            frameBytes: prepared.frameBytes,
-            sha256: prepared.sha256,
-        };
-        let authorized;
-        try {
-            authorized = await input.authorizeWrite(evidence);
-        }
-        catch {
-            await cancelPreparedClaude(prepared);
-            return {
-                state: "ambiguous",
-                safeErrorCode: "WRITE_AUTHORIZATION_UNCERTAIN",
-            };
-        }
-        if (!authorized) {
-            await cancelPreparedClaude(prepared);
-            return {
-                state: "failed",
-                safeErrorCode: "WRITE_AUTHORIZATION_DENIED",
-            };
-        }
-        try {
-            // Authorization is the write-authorization linearization point. Invoke the exact
-            // prepared mailbox write in the same continuation with no intervening
-            // await. Claude has no separate acceptance phase: confirmed mailbox
-            // completion is terminal delivered.
-            const operation = prepared.perform();
-            const result = await operation;
-            if (result.state === "deferred") {
-                return {
-                    state: "ambiguous",
-                    safeErrorCode: "CLAUDE_PREPARED_RESULT_INVALID",
-                };
-            }
-            return result.state === "expired"
-                ? { state: "failed", safeErrorCode: "MESSAGE_EXPIRED" }
-                : result;
-        }
-        catch (error) {
-            return claudePostAuthorizationResult(error);
-        }
-    }
-    async releaseRoute(routeHandle) {
-        this.selected.delete(routeHandle);
-        this.discovered.delete(routeHandle);
-        if (this.selected.size === 0 && this.monitorTimer !== undefined) {
-            clearTimeout(this.monitorTimer);
-            this.monitorTimer = undefined;
-        }
-    }
-    async close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        try {
-            await this.nativeHelpers?.close();
-            await this.peer.close();
-        }
-        finally {
-            this.selected.clear();
-            this.discovered.clear();
-            if (this.monitorTimer !== undefined)
-                clearTimeout(this.monitorTimer);
-            this.monitorTimer = undefined;
-            this.callbacks = undefined;
-        }
-    }
-    assertReady() {
-        if (!this.initialized || this.closed) {
-            throw new BridgeError("CLAUDE_PROVIDER_UNAVAILABLE", "The local Claude provider is not available.", true);
-        }
-    }
-    helpers() {
-        this.assertReady();
-        if (this.nativeHelpers === undefined) {
-            throw new BridgeError("CLAUDE_NATIVE_HELPER_UNAVAILABLE", "The supervised native Claude helper is unavailable.", true);
-        }
-        return this.nativeHelpers;
-    }
-    async refreshClaudeDiscovery() {
-        if (this.discoveryInFlight !== undefined) {
-            return await this.discoveryInFlight;
-        }
-        const operation = this.refreshClaudeDiscoveryOnce();
-        this.discoveryInFlight = operation;
-        try {
-            return await operation;
-        }
-        finally {
-            if (this.discoveryInFlight === operation) {
-                this.discoveryInFlight = undefined;
-            }
-        }
-    }
-    async refreshClaudeDiscoveryOnce() {
-        const dispatchEpochAtStart = new Map();
-        for (const [routeHandle, route] of this.selected) {
-            dispatchEpochAtStart.set(routeHandle, route.dispatchEpoch);
-        }
-        let discovery;
-        try {
-            discovery = await this.peer.discover();
-        }
-        catch (error) {
-            this.registryObservation = unavailableClaudeRegistryObservation();
-            throw error;
-        }
-        const registry = claudeRegistryObservation(discovery);
-        this.registryObservation = registry;
-        this.discovered.clear();
-        const rows = [];
-        for (const peer of discovery.peers) {
-            if ((peer.kind !== "interactive" && peer.kind !== "bg") ||
-                !NATIVE_CLAUDE_NAME.test(peer.alias)) {
-                continue;
-            }
-            const alias = `${peer.alias}@${this.identity.hostId}`;
-            if (!PUBLIC_ALIAS.test(alias))
-                continue;
-            const row = {
-                alias,
-                routeHandle: peer.targetId,
-                kind: peer.kind,
-                state: claudeRouteState(peer),
-            };
-            this.discovered.set(peer.targetId, row);
-            rows.push(row);
-        }
-        for (const [routeHandle, selected] of this.selected) {
-            const row = this.discovered.get(routeHandle);
-            if (row === undefined) {
-                this.emitClaudeRouteObservation(routeHandle, "busy", "CLAUDE_PEER_NOT_OBSERVED", true);
-            }
-            else {
-                if (!discovery.truncated && row.alias !== selected.alias) {
-                    // A Claude rename changes only the live name index. The native
-                    // session UUID remains the selected logical route. An incomplete
-                    // scan is display evidence only and cannot rename dispatch authority.
-                    selected.alias = row.alias;
-                }
-                if (row.state === "idle" &&
-                    (dispatchEpochAtStart.get(routeHandle) !==
-                        selected.dispatchEpoch)) {
-                    // Never publish an idle sample from a discovery that overlapped the
-                    // exact mailbox write. A wholly post-terminal discovery may clear
-                    // the dirty epoch.
-                    continue;
-                }
-                this.emitClaudeRouteObservation(routeHandle, row.state, undefined, true);
-            }
-        }
-        return { peers: rows, complete: !discovery.truncated, registry };
-    }
-    emitClaudeRouteObservation(routeHandle, state, safeErrorCode, authoritative = false) {
-        const signature = `${state}:${safeErrorCode ?? ""}`;
-        const selected = this.selected.get(routeHandle);
-        const mustPublish = authoritative && selected?.observationDirty === true;
-        if (selected !== undefined && mustPublish)
-            selected.observationDirty = false;
-        if (!mustPublish && selected?.observation === signature) {
-            return;
-        }
-        if (selected !== undefined)
-            selected.observation = signature;
-        const callbacks = this.callbacks;
-        const registrationId = selected?.registrationId;
-        if (callbacks === undefined ||
-            this.closed ||
-            registrationId === undefined) {
-            return;
-        }
-        invokeCallback(() => callbacks.onRouteState({
-            route: {
-                ...this.identity,
-                routeHandle,
-                registrationId,
-            },
-            observedAt: new Date(this.now()).toISOString(),
-            state,
-            ...(safeErrorCode === undefined ? {} : { safeErrorCode }),
-        }));
-    }
-    scheduleClaudeMonitor() {
-        if (this.closed ||
-            this.selected.size === 0 ||
-            this.monitorTimer !== undefined) {
-            return;
-        }
-        this.monitorTimer = setTimeout(() => {
-            this.monitorTimer = undefined;
-            void this.refreshClaudeDiscovery()
-                .catch(() => {
-                for (const routeHandle of this.selected.keys()) {
-                    this.emitClaudeRouteObservation(routeHandle, "busy", "CLAUDE_DISCOVERY_UNAVAILABLE");
-                }
-            })
-                .finally(() => this.scheduleClaudeMonitor());
-        }, this.discoveryPollMs);
-        this.monitorTimer.unref();
-    }
-}
-export function createLocalClaudeGatewayProvider(options) {
-    return new LocalClaudeGatewayProvider(options);
-}
-function boundedProviderOption(value, fallback, maximum) {
-    const candidate = value ?? fallback;
-    if (!Number.isSafeInteger(candidate) ||
-        candidate <= 0 ||
-        candidate > maximum) {
-        throw new BridgeError("INVALID_GATEWAY_PROVIDER_CONFIGURATION", "The local Codex provider has an invalid bounded option.");
-    }
-    return candidate;
-}
-function cleanCodexResult(result) {
-    if (result.safeErrorCode === "MESSAGE_EXPIRED") {
-        return { state: "expired", safeErrorCode: "MESSAGE_EXPIRED" };
-    }
-    if (CODEX_CLEAN_RETRY_CODES.has(result.safeErrorCode)) {
-        return { state: "deferred", safeErrorCode: result.safeErrorCode };
-    }
-    return { state: "failed", safeErrorCode: result.safeErrorCode };
-}
-function terminalCodexResult(result, expectsReply) {
-    if (result.outcome === "failed") {
-        return { state: "failed", safeErrorCode: "CODEX_TURN_FAILED" };
-    }
-    if (result.outcome === "interrupted") {
-        return { state: "cancelled", safeErrorCode: "CODEX_TURN_INTERRUPTED" };
-    }
-    return {
-        state: "delivered",
-        ...(result.replyCode === "REPLY_TOO_LARGE"
-            ? { safeErrorCode: "CODEX_REPLY_TOO_LARGE" }
-            : {}),
-        ...(expectsReply && result.replyText !== null
-            ? { replyText: result.replyText }
-            : {}),
-    };
-}
-function mapCodexStartResult(result, expectsReply) {
-    if (result.phase === "clean")
-        return cleanCodexResult(result);
-    if (result.phase === "armed") {
-        return { state: "ambiguous", safeErrorCode: result.safeErrorCode };
-    }
-    if (result.phase === "accepted") {
-        return { state: "unconfirmed", safeErrorCode: result.safeErrorCode };
-    }
-    return terminalCodexResult(result, expectsReply);
-}
-function mapCodexSteerResult(result) {
-    if (result.phase === "clean")
-        return cleanCodexResult(result);
-    if (result.phase === "armed") {
-        return { state: "ambiguous", safeErrorCode: result.safeErrorCode };
-    }
-    return { state: "delivered" };
-}
-/**
- * Thin logical Codex adapter. Registration and construction perform no App
- * Server I/O. Each semantic operation owns a fresh attested transport, while
- * the independent observer publishes only best-effort in-memory freshness.
- */
-export class LocalCodexGatewayProvider {
-    hostId;
-    operation;
-    observationPollMs;
-    observationTimeoutMs;
-    observationBackoffMaxMs;
-    maxObservedRoutes;
-    now;
-    timers;
-    observedRoutes = new Map();
-    activeTurns = new Map();
-    inFlightOperations = new Set();
-    operationControllers = new Set();
-    callbacks;
-    observationTimer;
-    observationInFlight;
-    observationController;
-    initialized = false;
-    closing = false;
-    closed = false;
-    constructor(options) {
-        if (!isAttestedGatewayNodeInventory(options.nodeInventory, options.hostId) ||
-            options.operation === undefined ||
-            typeof options.operation.execute !== "function") {
-            throw new BridgeError("INVALID_GATEWAY_PROVIDER_CONFIGURATION", "The stateless Codex provider requires the exact attested local host.");
-        }
-        this.hostId = options.hostId;
-        this.operation = options.operation;
-        this.observationPollMs = boundedProviderOption(options.observationPollMs, DEFAULT_CODEX_OBSERVATION_POLL_MS, 60_000);
-        this.observationTimeoutMs = boundedProviderOption(options.observationTimeoutMs, DEFAULT_CODEX_OBSERVATION_TIMEOUT_MS, 60_000);
-        this.observationBackoffMaxMs = boundedProviderOption(options.observationBackoffMaxMs, DEFAULT_CODEX_OBSERVATION_BACKOFF_MAX_MS, 5 * 60_000);
-        if (this.observationPollMs > this.observationBackoffMaxMs) {
-            throw new BridgeError("INVALID_GATEWAY_PROVIDER_CONFIGURATION", "Codex observer backoff must cover its polling interval.");
-        }
-        this.maxObservedRoutes = boundedProviderOption(options.maxObservedRoutes, MAX_CODEX_OBSERVED_ROUTES, 256);
-        this.now = options.now ?? (() => new Date());
-        this.timers = options.timers ?? {
-            setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
-            clearTimeout: (timer) => clearTimeout(timer),
-        };
-    }
-    get identity() {
-        return { provider: "codex", hostId: this.hostId };
-    }
-    get protocol() {
-        return "codex-app-server";
-    }
-    get protocolVersion() {
-        return "stateless-v1";
-    }
-    async initialize(callbacks) {
-        if (this.initialized || this.closing || this.closed) {
-            throw new BridgeError("CODEX_PROVIDER_INITIALIZATION_REJECTED", "The stateless Codex provider cannot initialize in this state.");
-        }
-        this.callbacks = callbacks;
-        this.initialized = true;
-        this.scheduleObservation();
-        return { health: "healthy" };
-    }
-    observeLogicalRoute(input) {
-        if (!this.initialized ||
-            this.closing ||
-            this.closed ||
-            !PUBLIC_ALIAS.test(input.alias) ||
-            !input.alias.endsWith("@" + this.hostId) ||
-            !OPAQUE_ROUTE.test(input.routeHandle) ||
-            !OPAQUE_ROUTE.test(input.registrationId)) {
-            return;
-        }
-        const existing = this.observedRoutes.get(input.registrationId);
-        if (existing === undefined &&
-            this.observedRoutes.size >= this.maxObservedRoutes) {
-            return;
-        }
-        this.observedRoutes.set(input.registrationId, {
-            ...input,
-            attempt: 0,
-            nextAt: this.now().getTime(),
-        });
-        this.scheduleObservation();
-    }
-    forgetLogicalRoute(registrationId) {
-        this.observedRoutes.delete(registrationId);
-        this.activeTurns.delete(registrationId);
-        this.scheduleObservation();
-    }
-    async dispatch(input) {
-        if (!this.initialized ||
-            this.closing ||
-            this.closed ||
-            input.authorization !== "selected_route" ||
-            input.binding.provider !== "codex" ||
-            input.binding.hostId !== this.hostId ||
-            !PUBLIC_ALIAS.test(input.targetAlias) ||
-            !input.targetAlias.endsWith("@" + this.hostId)) {
-            return { state: "failed", safeErrorCode: "CODEX_ROUTE_UNAVAILABLE" };
-        }
-        let content;
-        try {
-            content = composeProvenanceEnvelope({
-                sourceProvider: input.sourceProvider,
-                recipientProvider: "codex",
-                sourceAlias: input.sourceAlias,
-                targetAlias: input.targetAlias,
-                conversationId: input.conversationId,
-                body: input.text,
-                ...(input.steer === true && input.queuedAhead !== undefined
-                    ? { queuedAhead: input.queuedAhead }
-                    : {}),
-            });
-        }
-        catch (error) {
-            return {
-                state: "failed",
-                safeErrorCode: error instanceof BridgeError &&
-                    error.code === "PROVENANCE_ENVELOPE_TOO_LARGE"
-                    ? error.code
-                    : "PROVENANCE_ENVELOPE_INVALID",
-            };
-        }
-        return input.steer === true
-            ? this.dispatchSteer(input, content)
-            : this.dispatchStart(input, content);
-    }
-    async dispatchSteer(input, content) {
-        const active = this.activeTurns.get(input.binding.registrationId);
-        if (active === undefined ||
-            active.alias !== input.targetAlias ||
-            active.routeHandle !== input.binding.routeHandle) {
-            return { state: "deferred", safeErrorCode: "ROUTE_BUSY" };
-        }
-        const steering = active.accepted.steer({
-            attemptId: input.attemptId,
-            authorizeWrite: async (evidence) => await input.authorizeWrite({
-                attemptId: input.attemptId,
-                kind: "codex_turn_steer",
-                bodyBytes: Buffer.byteLength(input.text, "utf8"),
-                bodySha256: createHash("sha256").update(input.text).digest("hex"),
-                frameBytes: evidence.frameBytes,
-                sha256: evidence.sha256,
-            }),
-            deadlineAt: input.deadlineAt,
-            text: content,
-        });
-        this.inFlightOperations.add(steering);
-        try {
-            return mapCodexSteerResult(await steering);
-        }
-        finally {
-            this.inFlightOperations.delete(steering);
-        }
-    }
-    async dispatchStart(input, content) {
-        if (this.activeTurns.has(input.binding.registrationId)) {
-            return { state: "deferred", safeErrorCode: "ROUTE_BUSY" };
-        }
-        let accepted;
-        const controller = new AbortController();
-        this.operationControllers.add(controller);
-        const operation = this.operation.execute({
-            attemptId: input.attemptId,
-            authorizeWrite: async (evidence) => await input.authorizeWrite({
-                attemptId: input.attemptId,
-                kind: "codex_turn_start",
-                bodyBytes: Buffer.byteLength(input.text, "utf8"),
-                bodySha256: createHash("sha256").update(input.text).digest("hex"),
-                frameBytes: evidence.frameBytes,
-                sha256: evidence.sha256,
-            }),
-            deadlineAt: input.deadlineAt,
-            kind: "start",
-            signal: controller.signal,
-            route: {
-                alias: input.targetAlias,
-                hostId: input.binding.hostId,
-                registrationId: input.binding.registrationId,
-                threadId: input.binding.routeHandle,
-            },
-            text: content,
-            onAccepted: async (current) => {
-                if (this.closing ||
-                    this.closed ||
-                    current.attemptId !== input.attemptId ||
-                    this.activeTurns.has(input.binding.registrationId)) {
-                    throw new BridgeError("ACCEPTANCE_UNCONFIRMED", "The exact Codex attempt cannot acquire its active-turn slot.");
-                }
-                await input.onAccepted({ attemptId: input.attemptId });
-                accepted = current;
-                this.activeTurns.set(input.binding.registrationId, {
-                    attemptId: input.attemptId,
-                    accepted: current,
-                    alias: input.targetAlias,
-                    routeHandle: input.binding.routeHandle,
-                });
-            },
-        });
-        this.inFlightOperations.add(operation);
-        try {
-            const result = await operation;
-            this.publishOperationObservation(input, result);
-            return mapCodexStartResult(result, input.expectsReply);
-        }
-        finally {
-            this.inFlightOperations.delete(operation);
-            this.operationControllers.delete(controller);
-            if (accepted !== undefined &&
-                this.activeTurns.get(input.binding.registrationId)?.attemptId ===
-                    input.attemptId) {
-                this.activeTurns.delete(input.binding.registrationId);
-            }
-        }
-    }
-    async close() {
-        if (this.closed || this.closing)
-            return;
-        this.closing = true;
-        if (this.observationTimer !== undefined) {
-            this.timers.clearTimeout(this.observationTimer);
-            this.observationTimer = undefined;
-        }
-        this.observationController?.abort();
-        for (const controller of this.operationControllers)
-            controller.abort();
-        await this.observationInFlight?.catch(() => undefined);
-        for (const operation of this.inFlightOperations) {
-            void operation.catch(() => undefined);
-        }
-        this.operationControllers.clear();
-        this.activeTurns.clear();
-        this.observedRoutes.clear();
-        this.callbacks = undefined;
-        this.initialized = false;
-        this.closed = true;
-        this.closing = false;
-    }
-    publishOperationObservation(input, result) {
-        const state = !result.cleanupConfirmed
-            ? { state: "unobserved", safeErrorCode: "CLEANUP_FAILED" }
-            : result.phase === "terminal"
-                ? { state: "idle" }
-                : result.safeErrorCode === "ROUTE_BUSY"
-                    ? { state: "busy" }
-                    : result.safeErrorCode === "APPROVAL_REQUIRED"
-                        ? { state: "awaiting_approval" }
-                        : result.safeErrorCode === "THREAD_NOT_OBSERVED"
-                            ? {
-                                state: "unobserved",
-                                safeErrorCode: "THREAD_NOT_OBSERVED",
-                            }
-                            : {
-                                state: "unobserved",
-                                safeErrorCode: "CODEX_OBSERVER_UNAVAILABLE",
-                            };
-        this.emitObservation({
-            alias: input.targetAlias,
-            registrationId: input.binding.registrationId,
-            routeHandle: input.binding.routeHandle,
-        }, state);
-    }
-    scheduleObservation() {
-        if (!this.initialized ||
-            this.closing ||
-            this.closed ||
-            this.observationInFlight !== undefined) {
-            return;
-        }
-        if (this.observationTimer !== undefined) {
-            this.timers.clearTimeout(this.observationTimer);
-            this.observationTimer = undefined;
-        }
-        const next = [...this.observedRoutes.values()].reduce((selected, candidate) => selected === undefined || candidate.nextAt < selected.nextAt
-            ? candidate
-            : selected, undefined);
-        if (next === undefined)
-            return;
-        const delay = Math.max(0, next.nextAt - this.now().getTime());
-        const timer = this.timers.setTimeout(() => {
-            if (this.observationTimer !== timer)
-                return;
-            this.observationTimer = undefined;
-            const operation = this.runObservation(next);
-            this.observationInFlight = operation;
-            void operation.finally(() => {
-                if (this.observationInFlight === operation) {
-                    this.observationInFlight = undefined;
-                }
-                this.scheduleObservation();
-            });
-        }, delay);
-        timer.unref();
-        this.observationTimer = timer;
-    }
-    async runObservation(route) {
-        const controller = new AbortController();
-        this.observationController = controller;
-        let observation;
-        const timeout = this.timers.setTimeout(() => controller.abort(), this.observationTimeoutMs);
-        timeout.unref();
-        try {
-            observation = await this.operation.observe({
-                alias: route.alias,
-                hostId: this.hostId,
-                registrationId: route.registrationId,
-                threadId: route.routeHandle,
-            }, controller.signal);
-        }
-        finally {
-            this.timers.clearTimeout(timeout);
-            if (this.observationController === controller) {
-                this.observationController = undefined;
-            }
-        }
-        const current = this.observedRoutes.get(route.registrationId);
-        if (current !== route || this.closing || this.closed)
-            return;
-        const failed = observation.state === "unobserved";
-        current.attempt = failed ? Math.min(current.attempt + 1, 16) : 0;
-        const delay = failed
-            ? Math.min(this.observationBackoffMaxMs, this.observationPollMs * 2 ** Math.max(0, current.attempt - 1))
-            : this.observationPollMs;
-        current.nextAt = this.now().getTime() + delay;
-        this.emitObservation(current, observation);
-    }
-    emitObservation(route, observation) {
-        const current = this.observedRoutes.get(route.registrationId);
-        if (this.callbacks === undefined ||
-            current === undefined ||
-            current.alias !== route.alias ||
-            current.routeHandle !== route.routeHandle) {
-            return;
-        }
-        invokeCallback(() => this.callbacks.onRouteState({
-            route: {
-                provider: "codex",
-                hostId: this.hostId,
-                routeHandle: route.routeHandle,
-                registrationId: route.registrationId,
-            },
-            state: observation.state,
-            observedAt: this.now().toISOString(),
-            ...(observation.safeErrorCode === undefined
-                ? {}
-                : { safeErrorCode: observation.safeErrorCode }),
-        }));
-    }
-}
-export function createLocalCodexGatewayProvider(options) {
-    return new LocalCodexGatewayProvider(options);
-}
-//# sourceMappingURL=providers.js.map