agent-embassy 1.7.1 → 1.8.1

package/dist/src/gateway/providers.d.ts

@@ -1,12 +1,12 @@
-import { ClaudePeerAdapter, type ClaudePeerInboundProgress, type ClaudePeerRegistryPublicationOutcome } from "./claude-peer.js";
+import { ClaudePeerAdapter, type ClaudePeerInboundProgress } from "./claude-peer.js";
 import type { AttestedClaudePeerRuntime } from "./claude-runtime.js";
-import { type CodexConnectorObservation } from "./codex-app-server.js";
 import type { LocalCodexTransportFactory } from "./codex-local-transport.js";
+import type { StatelessCodexOperationTransport } from "./codex-stateless-transport.js";
 import type { GatewayDeliveryNoticeMode } from "./config.js";
 import type { ClaudeNativeHelperFactory } from "./claude-helper-client.js";
 import { type DashboardLocale } from "./locale.js";
-import type { GatewayAdapterCallbacks, GatewayAdapterDiscoverySnapshot, GatewayAdapterDispatchResult, GatewayAdapterEndpointRefresh, GatewayAdapterDispatchInput, GatewayAdapterRouteState, GatewayAdapterRegistryObservation, GatewayAdapterStart, GatewayProviderAdapter } from "./service.js";
-import type { GatewayProvider, PrivateEndpointIdentity } from "./types.js";
+import type { GatewayAdapterCallbacks, GatewayAdapterDiscoverySnapshot, GatewayAdapterDispatchResult, GatewayAdapterDispatchInput, GatewayAdapterRouteState, GatewayAdapterRegistryObservation, GatewayAdapterStart, GatewayProviderAdapter } from "./service.js";
+import type { GatewayProvider } from "./types.js";
 type ClaudePeerFactory = (runtime: AttestedClaudePeerRuntime, locale: DashboardLocale, deliveryNotices: GatewayDeliveryNoticeMode) => ClaudePeerAdapter;
 export type LocalClaudeGatewayProviderOptions = {
     /** Exact result of attestClaudePeerRuntime; paths are never rediscovered. */
@@ -24,85 +24,32 @@ export type LocalClaudeGatewayProviderOptions = {
         maxHelpers: number;
         factory?: ClaudeNativeHelperFactory;
     }>;
-    nativeHelperSourceProvider?: GatewayProvider;
     /** Deterministic test seam. Production callers must omit this. */
     peerFactory?: ClaudePeerFactory;
 };
-export type ClaudeNativeCodexSuccessionBarrier = Readonly<{
-    generation: string;
-    activeGenerationMatched: boolean;
-    ingressQuiesced: boolean;
-    monitorFrozen: boolean;
-    discoveryInFlight: boolean;
-    pendingOutboundReceipts: number;
-    pendingInboundReceipts: number;
-    rejectedInboundSettlements: number;
-    clean: boolean;
-}>;
-export type CodexRouteSuccessionBarrier = Readonly<{
-    routePresent: boolean;
-    connection: CodexConnectorObservation["connection"] | "absent";
-    routeStatus: CodexConnectorObservation["routeStatus"] | "absent";
-    queueDepth: number;
-    hasActiveTurn: boolean;
-    requestInFlight: boolean;
-    routeCreationInFlight: boolean;
-    routeReleaseInFlight: boolean;
-    pendingReplyCorrelations: number;
-    pendingCallbacks: number;
-    clean: boolean;
-}>;
 export declare class LocalClaudeGatewayProvider implements GatewayProviderAdapter {
-    readonly identity: PrivateEndpointIdentity;
+    readonly identity: Readonly<{
+        provider: "claude";
+        hostId: "this-mac";
+    }>;
     readonly protocol = "claude-peer";
     readonly protocolVersion: string;
     private readonly peer;
     private readonly maxPending;
     private readonly discoveryPollMs;
     private readonly now;
-    private readonly selectedStateRoots;
     private readonly nativeHelpers;
-    private readonly nativeHelperSourceProvider;
     private readonly discovered;
+    /** Exact UUID selection plus its display-only observation bookkeeping. */
     private readonly selected;
-    /** Exact live same-UID sessions observed through native inbound frames. */
-    private readonly nativeInbound;
-    /** Exact listener owner for every receipt capability handed to the service. */
-    private readonly nativeInboundReceiptOwners;
-    private readonly selectedObservations;
-    /** Invalidates any discovery that overlaps a dispatch on this route. */
-    private readonly selectedDispatchEpoch;
-    /**
-     * A dispatch invalidates the pre-dispatch registry observation. The first
-     * subsequent successful discovery must therefore be published even when
-     * the native peer completed between polls and is idle again.
-     */
-    private readonly selectedObservationDirty;
-    private readonly pendingByProviderId;
-    private readonly providerIdByGatewayId;
-    /** Includes the pre-write reservation through exact terminal settlement. */
-    private readonly pendingTargetByGatewayId;
-    /** Provider-owned terminal rejections that never enter the service queue. */
-    private readonly rejectedNativeInbound;
     private discoveryInFlight;
     private registryObservation;
     private monitorTimer;
-    /** Invocation-ordered registry mutations; the tail itself never rejects. */
-    private nativeCodexRegistrationTail;
     private callbacks;
-    private activeNativeCodexListener;
-    private preparedNativeCodexListener;
-    private nativeCodexPreparationInFlight;
-    private retiredNativeCodexListener;
-    /** Fences discovery callbacks and monitor restarts across listener rotation. */
-    private nativeCodexSuccessionFreeze;
-    /** External registry trust/availability failures degrade Claude only. */
-    private unavailableCode;
     private initialized;
     private closed;
     constructor(options: LocalClaudeGatewayProviderOptions);
     latestRegistryObservation(): GatewayAdapterRegistryObservation | undefined;
-    activateEndpointGeneration(endpointGeneration: string): void;
     initialize(callbacks: GatewayAdapterCallbacks): Promise<GatewayAdapterStart>;
     discoverClaudePeers(): Promise<GatewayAdapterDiscoverySnapshot>;
     assertWorkspaceDisjoint(routeHandle: string, stateRoot: string): Promise<void>;
@@ -113,6 +60,12 @@ export declare class LocalClaudeGatewayProvider implements GatewayProviderAdapte
         routeHandle: string;
         state: GatewayAdapterRouteState;
     }>;
+    observeLogicalRoute(input: {
+        alias: string;
+        routeHandle: string;
+        registrationId: string;
+    }): void;
+    forgetLogicalRoute(registrationId: string): void;
     resolveReplyAddress(address: string): Promise<{
         routeHandle: string;
     }>;
@@ -121,174 +74,81 @@ export declare class LocalClaudeGatewayProvider implements GatewayProviderAdapte
         sourceProvider: GatewayProvider;
         cwd: string;
     }): Promise<void>;
-    currentNativeCodexPeerGeneration(alias: string): string;
-    /** Child-host initialization seam before its immutable advertisement exists. */
-    currentUnadvertisedNativeCodexPeerGeneration(): string;
-    prepareNativeCodexPeerGeneration(input: {
-        alias: string;
-        cwd: string;
-        generation: string;
-        currentGeneration?: string;
-    }): Promise<void>;
-    quiesceNativeCodexPeerGeneration(generation: string): Promise<void>;
-    observeNativeCodexSuccessionBarrier(generation: string): Promise<ClaudeNativeCodexSuccessionBarrier>;
-    publishPreparedNativeCodexPeer(input: {
-        currentGeneration: string;
-        preparedGeneration: string;
-    }): Promise<ClaudePeerRegistryPublicationOutcome>;
-    activatePreparedNativeCodexPeerGeneration(generation: string): Promise<void>;
-    cleanupPreparedNativeCodexPeerGeneration(generation: string): Promise<void>;
-    resumeNativeCodexPeerGeneration(generation: string): Promise<void>;
-    rollbackPreparedNativeCodexPeerGeneration(input: {
-        preparedGeneration: string;
-        resumeGeneration: string;
-    }): Promise<void>;
-    retireNativeCodexPeerGeneration(input: {
-        retiredGeneration: string;
-        protectedActiveGeneration: string;
-    }): Promise<void>;
-    purgeNativeCodexPeerGenerationReplyCapabilities(generation: string): Promise<number>;
     unadvertiseNativeSourcePeer(alias: string): Promise<void>;
     updateNativeSourcePeerStatus(alias: string, status: "idle" | "busy" | "waiting"): Promise<void>;
     updateNativeInboundStatus(receiptHandle: string, status: "held" | "delivered" | "denied" | "expired", diagnosticCode?: string): Promise<void>;
     notifyNativeInboundProgress(receiptHandle: string, progress: ClaudePeerInboundProgress): Promise<void>;
     releaseNativeInboundReceipt(receiptHandle: string): Promise<boolean>;
-    quiesceNativeInbound(): Promise<void>;
     dispatch(input: GatewayAdapterDispatchInput): Promise<GatewayAdapterDispatchResult>;
     releaseRoute(routeHandle: string): Promise<void>;
     close(): Promise<void>;
     private assertReady;
-    private serializeNativeCodexRegistration;
-    private nativeCodexRegistration;
-    private requireActiveNativeCodexListener;
-    private requireNativeCodexListenerGeneration;
-    private requireNativeInboundReceiptOwner;
-    private ownsNativeCodexListener;
-    private onListenerMessage;
-    private rejectNativeInboundReceipt;
-    private settleRejectedNativeInbound;
-    private ownsNativeCodexListenerGeneration;
-    private waitForRejectedNativeInboundRetry;
-    private releaseRejectedNativeInbound;
-    private trackClaudeMessage;
-    private abandonClaudeTracking;
-    private onReceipt;
-    private recordClaudeWriteEvidence;
-    private finishClaudeMessage;
-    private emitDelivery;
+    private helpers;
     private refreshClaudeDiscovery;
     private refreshClaudeDiscoveryOnce;
     private emitClaudeRouteObservation;
-    private hasPendingClaudeReceipt;
     private scheduleClaudeMonitor;
 }
 export declare function createLocalClaudeGatewayProvider(options: LocalClaudeGatewayProviderOptions): LocalClaudeGatewayProvider;
 export type LocalCodexGatewayProviderOptions = {
-    factory: LocalCodexTransportFactory;
-    /** Re-resolves the managed install after its generation moves. */
-    refreshFactory?: () => Promise<LocalCodexTransportFactory>;
-    cleanupPollMs?: number;
-    cleanupTimeoutMs?: number;
-    recoveryInitialMs?: number;
-    recoveryMaxMs?: number;
-    /** Deterministic test seam; production uses the fixed positive-observation cadence. */
+    hostId: string;
+    operation: StatelessCodexOperationTransport;
+    createObservationFactory?: () => Promise<LocalCodexTransportFactory>;
     observationPollMs?: number;
-    maxCallbackEvents?: number;
-    maxRoutes?: number;
-    maxReplyBytes?: number;
+    observationTimeoutMs?: number;
+    observationBackoffMaxMs?: number;
+    maxObservedRoutes?: number;
     now?: () => Date;
+    timers?: Readonly<{
+        setTimeout: (callback: () => void, delayMs: number) => NodeJS.Timeout;
+        clearTimeout: (timer: NodeJS.Timeout) => void;
+    }>;
 };
+/**
+ * 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 declare class LocalCodexGatewayProvider implements GatewayProviderAdapter {
-    private factory;
-    private readonly refreshFactory;
-    private readonly maxCallbacks;
-    private readonly maxRoutes;
-    private readonly maxReplyBytes;
-    private readonly cleanupPollMs;
-    private readonly cleanupTimeoutMs;
-    private readonly recoveryInitialMs;
-    private readonly recoveryMaxMs;
+    private readonly hostId;
+    private readonly operation;
     private readonly observationPollMs;
+    private readonly observationTimeoutMs;
+    private readonly observationBackoffMaxMs;
+    private readonly maxObservedRoutes;
     private readonly now;
-    private readonly routes;
-    /** Exact public alias authority retained across internal route recovery. */
-    private readonly routeAliases;
-    private readonly routeCreations;
-    private readonly routeReleases;
-    private readonly routeRecoveryAttempts;
-    private readonly routeRecoveryTimers;
-    private readonly routeRecoveries;
-    private readonly routesRequiringRecovery;
-    private readonly trackedRoutes;
+    private readonly timers;
+    private readonly observedRoutes;
+    private readonly activeTurns;
+    private readonly inFlightOperations;
+    private readonly operationControllers;
+    private callbacks;
     private observationTimer;
     private observationInFlight;
-    private retiredEndpointGeneration;
-    private readonly expectsReply;
-    private readonly callbackQueue;
-    private callbackScheduled;
-    private callbacks;
-    private endpointRefresh;
-    private endpointRefreshDelivery;
-    private endpointActivationRetry;
-    private endpointActivationRetryTimer;
-    private callbackDrainFrozen;
-    private endpointUnavailable;
-    private pendingEndpointRefreshEvent;
-    private pendingEndpointRefreshSelectorClaimed;
+    private observationController;
     private initialized;
     private closing;
     private closed;
     constructor(options: LocalCodexGatewayProviderOptions);
-    get identity(): PrivateEndpointIdentity;
+    get identity(): Readonly<{
+        provider: "codex";
+        hostId: string;
+    }>;
     get protocol(): string;
     get protocolVersion(): string;
-    activateEndpointGeneration(endpointGeneration: string): void;
-    releaseEndpointRefreshSelectorClaim(endpointGeneration: string): void;
-    rearmEndpointRefreshActivation(endpointGeneration: string): void;
     initialize(callbacks: GatewayAdapterCallbacks): Promise<GatewayAdapterStart>;
-    selectRoute(input: {
+    observeLogicalRoute(input: {
         alias: string;
         routeHandle: string;
-    }): Promise<{
-        routeHandle: string;
-        state: GatewayAdapterRouteState;
-        endpointRefresh?: GatewayAdapterEndpointRefresh;
-    }>;
-    observeRouteSuccessionBarrier(routeHandle: string): CodexRouteSuccessionBarrier;
+        registrationId: string;
+    }): void;
+    forgetLogicalRoute(registrationId: string): void;
     dispatch(input: GatewayAdapterDispatchInput): Promise<GatewayAdapterDispatchResult>;
-    releaseRoute(routeHandle: string): Promise<void>;
-    private releaseRouteInternal;
     close(): Promise<void>;
-    private assertReady;
-    private ensureRoute;
-    private createRoute;
-    private onConnectorEvent;
-    private scheduleCodexObservation;
-    private refreshCodexObservations;
-    private scheduleRouteRecovery;
-    private recoverRoute;
-    private cancelRouteRecovery;
-    private isEndpointGenerationChanged;
-    private pendingEndpointActivationClaims;
-    private retainedEndpointRefreshResult;
-    private refreshEndpoint;
-    private performEndpointRefresh;
-    private resolveEndpointRefreshCandidate;
-    private retireEndpointGeneration;
-    private reserveSelectorRefresh;
-    private emitSelectorRefreshFallback;
-    private publishEndpointRefresh;
-    private armEndpointActivationRetry;
-    private scheduleEndpointActivationRetry;
-    private clearEndpointActivationRetry;
-    private emitEndpointRefresh;
-    private onTurnResult;
-    private queueRouteObservation;
-    private enqueueCodexCallback;
-    private drainOneCallback;
-    private drainCallbackQueue;
-    private closeRoute;
-    private waitForOwnedTurnToSettle;
+    private publishOperationObservation;
+    private scheduleObservation;
+    private runObservation;
+    private emitObservation;
 }
 export declare function createLocalCodexGatewayProvider(options: LocalCodexGatewayProviderOptions): LocalCodexGatewayProvider;
 export {};