@opengeni/runtime 0.14.1 → 0.14.15

package/dist/sandbox/index.d.ts

@@ -1,6 +1,190 @@
-export { collectSandboxEnvironment, parseExposedPorts } from '@opengeni/config';
-export { CAPABILITY_DESCRIPTORS, CapabilityDescriptor, DESKTOP_STREAM_PORT, StreamTokenPayload, StreamTokenPayload as StreamTokenPayloadType, TERMINAL_STREAM_PORT } from '@opengeni/contracts';
-import '@openai/agents/sandbox';
-export { A as ActiveBackendResolverDeps, b as ActiveBackendUnresolvableError, c as ActivePointer, B as BackendUnresolvableCode, C as ChannelAConflictError, d as ChannelAEmitter, e as ChannelAExecArgs, f as ChannelAExecResult, g as ChannelANotFoundError, h as ChannelASession, i as ChannelAUnavailableError, j as ChannelAUnsupportedError, k as ChannelAValidationError, l as ControlRpc, D as DEFAULT_DESKTOP_GEOMETRY, m as DISPLAY_STACK_TIMEOUT_MS, n as DefaultBackendLossResult, o as DesktopGeometry, p as DisplayStackCallerKind, q as DisplayStackClassification, r as DisplayStackError, s as DisplayStackTelemetryContext, t as DisplayStackTelemetryEvent, u as DisplayStackTelemetryStatus, v as DisplayStackUnsupportedError, E as EnsureDisplayStackOptions, w as EnsureDisplayStackResult, x as EnsureTerminalServerOptions, y as EnsureTerminalServerResult, z as EstablishedSandboxSession, F as ExposeStreamPortInput, G as ExposeStreamPortResult, H as ExposedPortEndpoint, I as FAULT_FIELD_WHAT_HAPPENED, J as FAULT_FIELD_WHAT_PRESERVED, K as FAULT_FIELD_WHAT_TO_TRY, L as FAULT_FIELD_WHICH_LAYER, M as LiveModalSandboxLeaseAttribution, N as MaterializeRunCredentialsOptions, O as MintStreamTokenInput, P as MockAgentResponder, Q as MockAgentResponderOptions, S as MockExecHandler, T as ModalModuleLoader, U as ModalOrphanSweepResult, V as ModalOrphanSweepTermination, W as ModalSandboxAttribution, X as NEVER_SENT_DETAIL_KEY, Y as NatsControlRpc, Z as NatsOpStreamConnection, _ as NatsOpStreamTransport, $ as NatsRequestConnection, a0 as NegotiationContext, a1 as NormalizedRunCredentialMaterial, a2 as NumstatEntry, a3 as OP_STREAM_ACK_INTERVAL_MS, a4 as OP_STREAM_DEFAULT_WINDOW_BYTES, a5 as OP_STREAM_RECONNECT_HOLD_MS, a6 as OP_STREAM_SILENCE_TIMEOUT_MS, a7 as OpStreamExecOutcome, a8 as OpStreamJournal, a9 as OpStreamSubscription, aa as OpStreamTransport, ab as OpStreamUnavailableError, ac as PROVIDER_REGISTRY, ad as ProviderConstructionContext, ae as ProviderRegistration, af as ProviderSandboxFailure, ag as ProviderSandboxFailureKind, ah as REPOSITORY_DISCOVERY_LIMIT, ai as RecordingArtifactMetadata, aj as RecordingCodec, ak as RecordingContentType, al as RecordingError, am as RecordingProcess, an as RecordingUnavailableError, ao as RepositoryDiscoveryDegradedReason, ap as RepositoryDiscoveryResult, aq as ResolvedActiveBackend, ar as RevalidateModalOrphanTermination, as as RoutableBackendSession, at as RoutableSandbox, au as RoutingBackendRecoveryRequiredError, av as RoutingMutationOutcomeUnknownError, aw as RoutingMutationSettlementResult, ax as RoutingRetainedProcess, ay as RoutingRetainedProcessAdoption, az as RoutingRetainedProcessNotFoundError, aA as RoutingRetainedProcessTerminalProof, aB as RoutingSandboxSession, aC as RoutingSandboxSessionDeps, aD as RoutingTransitionEvent, aE as RoutingUnsupportedError, aF as RunCredentialCommandRunner, aG as RunCredentialCommandSession, aH as RunCredentialExpectedScope, R as RunCredentialSessionReady, aI as RunCredentialValidationError, aJ as SELFHOSTED_DEFAULT_TIMEOUT_MS, aK as SELFHOSTED_DRAINING_MAX_RETRIES, aL as SELFHOSTED_EXEC_DRAINING_MAX_RETRIES, aM as SELFHOSTED_IDEMPOTENT_READONLY_OPS, aN as SELFHOSTED_INFRASTRUCTURE_FAULT_CLASSES, aO as SELFHOSTED_NEVER_SENT_MAX_RETRIES, aP as SELFHOSTED_RECONNECT_WINDOW_MS, aQ as SELFHOSTED_RELAY_STREAM_PATH, aR as SELFHOSTED_RETRY_BACKOFF_BASE_MS, aS as SELFHOSTED_RETRY_BACKOFF_CAP_MS, aT as SELFHOSTED_RETRY_BACKOFF_FACTOR, aU as SELFHOSTED_TIMEOUT_MAX_RETRIES, aV as STREAM_PORT, aW as STREAM_TOKEN_DEFAULT_TTL_SECONDS, aX as SandboxChannelAService, aY as SandboxChannelAServiceOptions, aZ as SandboxConfigError, a_ as SandboxCreatedCallback, a$ as SandboxExecReadinessError, b0 as SandboxProviderUnavailableError, b1 as SandboxReplacementProviderStateError, b2 as SandboxResumeStateUnavailableError, b3 as SelfhostedApplyDiff, b4 as SelfhostedControlError, b5 as SelfhostedEditor, b6 as SelfhostedEnrollment, b7 as SelfhostedExecArgs, b8 as SelfhostedExecResult, b9 as SelfhostedImageOutput, ba as SelfhostedLivenessState, bb as SelfhostedNegotiationInput, bc as SelfhostedOpObservation, bd as SelfhostedOpObserver, be as SelfhostedOpStreamDeps, bf as SelfhostedRelayConfig, bg as SelfhostedRetryClock, bh as SelfhostedRetryDecision, bi as SelfhostedSandboxClient, bj as SelfhostedSession, bk as SelfhostedSessionBuild, bl as SelfhostedSessionDeps, bm as SelfhostedSessionState, bn as SelfhostedUnavailableReason, bo as StartRecordingInput, bp as StreamPortUnavailableError, bq as SwapTargetEstablishability, br as TERMINAL_SERVER_TIMEOUT_MS, bs as TerminalServerError, bt as TerminalServerUnsupportedError, bu as ToolspaceTokenPathError, bv as VerifiedWorkspaceArchive, bw as WORKSPACE_ARCHIVE_DESCRIPTOR_VERSION, bx as WorkspaceArchiveDescriptor, by as WorkspaceArchiveIntegrityCode, bz as WorkspaceArchiveIntegrityError, bA as WorkspaceTreeFingerprint, bB as agentErrorToControlError, bC as assertDescriptorRegistryInvariants, bD as assertProviderRegistryInvariants, bE as assertSafeRelPath, bF as backendSupportsOs, bG as buildDisplayStackScript, bH as buildSelfhostedBackendSession, bI as buildStreamUrl, bJ as buildTerminalServerScript, bK as captureVerifiedWorkspaceArchive, bL as classifyProviderSandboxFailure, bM as clearRunCredentials, bN as clearRunCredentialsForAttempt, bO as contentTypeForCodec, bP as createSandboxClient, bQ as createSandboxClientForBackend, bR as decideSelfhostedRetry, bS as decodeModalSnapshotId, bT as defaultSelfhostedRetryClock, bU as deletePriorPersistedSnapshot, bV as deleteRecordingArtifacts, bW as deserializeSandboxSessionStateEnvelope, bX as desktopCapableBackend, bY as drainingExhaustedError, bZ as drainingMessage, b_ as ensureDisplayStack, b$ as ensureModalRegistryImage, c0 as ensureTerminalServer, c1 as establishSandboxSessionFromEnvelope, c2 as execDeadlineHint, c3 as exposeStreamPort, c4 as extForCodec, c5 as fingerprintSandboxWorkspace, c6 as hasPersistableSandboxProviderIdentity, c7 as inspectRecordingArtifact, c8 as isExecSessionLostBanner, c9 as isProviderSandboxGoneDuringRoutedOperation, ca as isProviderSandboxNotFoundError, cb as isProviderSandboxTransientError, cc as isSelfhostedProviderNotFoundError, cd as makeActiveBackendResolver, ce as materializeRunCredentials, cf as mintStreamToken, cg as modalSandboxAttributionEnvironment, ch as modalSandboxAttributionTags, ci as negotiateCapabilities, cj as negotiateSelfhostedCapabilities, ck as nextDurableOpId, cl as normalizeRunCredentialsResolution, cm as offlineAgentError, cn as offlineControlResponse, co as opAckSubject, cp as opFrameSubject, cq as parseExecBannerExitCode, cr as parseExecBannerSessionId, cs as parseNumstatZ, ct as parsePorcelainV2, cu as parseUnifiedPatch, cv as parseWorkspaceArchiveDescriptor, cw as payloadTooLargeMessage, cx as readVerifiedWorkspaceArchive, cy as readWorkspaceArchiveFromEnvelopeSessionState, cz as recordingStorageKey, cA as renderSelfhostedFault, cB as requirePersistableReplacementSandboxEnvelope, cC as restoredSandboxSessionStateFromEntry, cD as runCredentialPointerFile, cE as runCredentialRoot, cF as runWithToolCallCorrelation, cG as sandboxStateEntryFromRunState, cH as sanitizeOpIdToken, cI as selectBackend, cJ as selfhostedFaultClass, cK as selfhostedLiveness, cL as selfhostedRetryBackoffMs, cM as serializeEstablishedSandboxEnvelope, cN as serializeReplacementSandboxEnvelope, cO as setSelfhostedApplyDiff, cP as startRecording, cQ as stopRecording, cR as stripExecBanner, cS as subjectFor, cT as swapTargetEstablishability, cU as sweepModalOrphanSandboxes, cV as tagModalSandbox, cW as tearDownDisplayStack, cX as tearDownTerminalServer, cY as terminateModalSandboxById, cZ as timeoutAgentError, c_ as timeoutControlResponse, c$ as toolspaceTokenFileForSession, d0 as toolspaceTokenFileFromEnvironment, d1 as uploadRecordingArtifact, d2 as verifyRestoredWorkspace, d3 as verifySandboxExecReadiness, d4 as verifyStreamToken, d5 as withRunCredentialEnvironment, d6 as withRunCredentialsClient, d7 as withRunCredentialsSession, d8 as withToolspaceTokenClient, d9 as withToolspaceTokenEnvironment, da as withToolspaceTokenSession } from '../index-BraazrAO.js';
-import 'modal';
-import '@opengeni/agent-proto';
+import type { Settings } from "@opengeni/config";
+import { type SandboxBackend } from "@opengeni/contracts";
+import type { SandboxClient, SandboxSessionState } from "@openai/agents/sandbox";
+import { type WorkspaceArchiveDescriptor } from "./workspace-archive";
+import type { RuntimeMetricsHooks } from "../metrics";
+export { collectSandboxEnvironment, parseExposedPorts } from "@opengeni/config";
+export { CAPABILITY_DESCRIPTORS, DESKTOP_STREAM_PORT, assertDescriptorRegistryInvariants, type CapabilityDescriptor, } from "./capabilities";
+export { SandboxConfigError, SandboxProviderUnavailableError, SandboxResumeStateUnavailableError, } from "./errors";
+export { PROVIDER_REGISTRY, assertProviderRegistryInvariants, type ProviderRegistration, type ProviderConstructionContext, } from "./providers";
+export { classifyProviderSandboxFailure, isProviderSandboxGoneDuringRoutedOperation, isProviderSandboxNotFoundError, isProviderSandboxTransientError, type ProviderSandboxFailure, type ProviderSandboxFailureKind, } from "./provider-errors";
+export { WORKSPACE_ARCHIVE_DESCRIPTOR_VERSION, WorkspaceArchiveIntegrityError, captureVerifiedWorkspaceArchive, decodeNativeSnapshotRef, describeLegacyNativeSnapshotArchive, describeNativeSnapshotArchive, fingerprintSandboxWorkspace, parseWorkspaceArchiveDescriptor, readVerifiedWorkspaceArchive, verifyRestoredWorkspace, type NativeSnapshotDescriptor, type NativeSnapshotProvider, type NativeSnapshotRef, type TarWorkspaceArchiveDescriptor, type VerifiedWorkspaceArchive, type WorkspaceArchiveDescriptor, type WorkspaceArchiveIntegrityCode, type WorkspaceTreeFingerprint, } from "./workspace-archive";
+export { ensureModalRegistryImage, deleteModalCheckpointSnapshot, inspectModalSandboxLifecycle, modalSessionMatchesCheckpointProviderBinding, modalSandboxAttributionEnvironment, modalSandboxAttributionTags, resolveModalCheckpointProviderBinding, resolveModalCheckpointProviderBindingForLiveSandbox, resolveModalCheckpointProviderBindingForSession, sweepModalOrphanSandboxes, tagModalSandbox, terminateModalSandboxById, type LiveModalSandboxLeaseAttribution, type ModalModuleLoader, type ModalCheckpointProviderBinding, type ModalOrphanSweepResult, type ModalOrphanSweepTermination, type ModalSandboxAttribution, type RevalidateModalOrphanTermination, } from "./providers/modal";
+export { selectBackend, backendSupportsOs, desktopCapableBackend, negotiateCapabilities, type NegotiationContext, } from "./select";
+export { STREAM_TOKEN_DEFAULT_TTL_SECONDS, mintStreamToken, verifyStreamToken, StreamTokenPayload, type MintStreamTokenInput, type StreamTokenPayloadType, } from "./stream-token";
+export { STREAM_PORT, DISPLAY_STACK_TIMEOUT_MS, DEFAULT_DESKTOP_GEOMETRY, DisplayStackError, DisplayStackUnsupportedError, buildDisplayStackScript, ensureDisplayStack, tearDownDisplayStack, type DesktopGeometry, type DisplayStackCallerKind, type DisplayStackClassification, type DisplayStackTelemetryContext, type DisplayStackTelemetryEvent, type DisplayStackTelemetryStatus, type EnsureDisplayStackOptions, type EnsureDisplayStackResult, } from "./display-stack";
+export { TERMINAL_STREAM_PORT, TERMINAL_SERVER_TIMEOUT_MS, TerminalServerError, TerminalServerUnsupportedError, buildTerminalServerScript, ensureTerminalServer, tearDownTerminalServer, type EnsureTerminalServerOptions, type EnsureTerminalServerResult, } from "./terminal-server";
+export { RunCredentialValidationError, normalizeRunCredentialsResolution, runCredentialRoot, runCredentialPointerFile, materializeRunCredentials, clearRunCredentials, clearRunCredentialsForAttempt, withRunCredentialEnvironment, withRunCredentialsSession, withRunCredentialsClient, type RunCredentialExpectedScope, type NormalizedRunCredentialMaterial, type RunCredentialCommandSession, type RunCredentialCommandRunner, type RunCredentialSessionReady, type MaterializeRunCredentialsOptions, } from "./run-credentials";
+export { ToolspaceTokenPathError, toolspaceTokenFileForSession, toolspaceTokenFileFromEnvironment, withToolspaceTokenEnvironment, withToolspaceTokenSession, withToolspaceTokenClient, } from "./toolspace-token";
+export { exposeStreamPort, buildStreamUrl, StreamPortUnavailableError, type ExposedPortEndpoint, type ExposeStreamPortInput, type ExposeStreamPortResult, } from "./stream-port";
+export { startRecording, stopRecording, inspectRecordingArtifact, uploadRecordingArtifact, deleteRecordingArtifacts, recordingStorageKey, contentTypeForCodec, extForCodec, RecordingUnavailableError, RecordingError, type RecordingCodec, type RecordingContentType, type StartRecordingInput, type RecordingProcess, type RecordingArtifactMetadata, } from "./recording";
+export { SandboxChannelAService, ChannelAValidationError, ChannelAUnavailableError, ChannelAConflictError, ChannelANotFoundError, ChannelAUnsupportedError, stripExecBanner, parseExecBannerSessionId, parseExecBannerExitCode, isExecSessionLostBanner, assertSafeRelPath, parsePorcelainV2, parseNumstatZ, parseUnifiedPatch, REPOSITORY_DISCOVERY_LIMIT, type ChannelASession, type ChannelAExecArgs, type ChannelAExecResult, type ChannelAEmitter, type SandboxChannelAServiceOptions, type RepositoryDiscoveryDegradedReason, type RepositoryDiscoveryResult, type NumstatEntry, } from "./channel-a";
+export { type ControlRpc, NatsControlRpc, SelfhostedControlError, agentErrorToControlError, subjectFor, offlineControlResponse, timeoutControlResponse, offlineAgentError, timeoutAgentError, drainingExhaustedError, payloadTooLargeMessage, drainingMessage, execDeadlineHint, NEVER_SENT_DETAIL_KEY, type NatsRequestConnection, type SelfhostedUnavailableReason, } from "./selfhosted/control-rpc";
+export type { SelfhostedOpObserver, SelfhostedOpObservation } from "./selfhosted/op-observer";
+export { selfhostedFaultClass, SELFHOSTED_INFRASTRUCTURE_FAULT_CLASSES, renderSelfhostedFault, FAULT_FIELD_WHAT_HAPPENED, FAULT_FIELD_WHICH_LAYER, FAULT_FIELD_WHAT_PRESERVED, FAULT_FIELD_WHAT_TO_TRY, } from "./selfhosted/fault-rendering";
+export { decideSelfhostedRetry, selfhostedRetryBackoffMs, defaultSelfhostedRetryClock, SELFHOSTED_IDEMPOTENT_READONLY_OPS, SELFHOSTED_DRAINING_MAX_RETRIES, SELFHOSTED_EXEC_DRAINING_MAX_RETRIES, SELFHOSTED_TIMEOUT_MAX_RETRIES, SELFHOSTED_NEVER_SENT_MAX_RETRIES, SELFHOSTED_RETRY_BACKOFF_BASE_MS, SELFHOSTED_RETRY_BACKOFF_FACTOR, SELFHOSTED_RETRY_BACKOFF_CAP_MS, type SelfhostedRetryClock, type SelfhostedRetryDecision, } from "./selfhosted/retry-policy";
+export { SelfhostedSession, SelfhostedSandboxClient, buildSelfhostedBackendSession, isSelfhostedProviderNotFoundError, setSelfhostedApplyDiff, SELFHOSTED_DEFAULT_TIMEOUT_MS, SELFHOSTED_RELAY_STREAM_PATH, type SelfhostedSessionState, type SelfhostedSessionDeps, type SelfhostedSessionBuild, type SelfhostedRelayConfig, type SelfhostedExecArgs, type SelfhostedExecResult, type SelfhostedApplyDiff, type SelfhostedEditor, type SelfhostedImageOutput, type SelfhostedOpStreamDeps, } from "./selfhosted/session";
+export { NatsOpStreamTransport, OpStreamUnavailableError, opAckSubject, opFrameSubject, type NatsOpStreamConnection, type OpStreamSubscription, type OpStreamTransport, } from "./selfhosted/op-transport";
+export { OP_STREAM_ACK_INTERVAL_MS, OP_STREAM_DEFAULT_WINDOW_BYTES, OP_STREAM_RECONNECT_HOLD_MS, OP_STREAM_SILENCE_TIMEOUT_MS, type OpStreamExecOutcome, type OpStreamJournal, } from "./selfhosted/op-stream";
+export { nextDurableOpId, runWithToolCallCorrelation, sanitizeOpIdToken } from "./op-correlation";
+export { negotiateSelfhostedCapabilities, selfhostedLiveness, SELFHOSTED_RECONNECT_WINDOW_MS, type SelfhostedNegotiationInput, type SelfhostedLivenessState, type SelfhostedEnrollment, } from "./selfhosted/capabilities";
+export { MockAgentResponder, type MockAgentResponderOptions, type MockExecHandler, } from "./selfhosted/testing";
+export { RoutingBackendRecoveryRequiredError, RoutingMutationOutcomeUnknownError, RoutingRetainedProcessNotFoundError, RoutingSandboxSession, RoutingUnsupportedError, type ActivePointer, type DefaultBackendLossResult, type RoutableBackendSession, type ResolvedActiveBackend, type RoutingMutationSettlementResult, type RoutingRetainedProcess, type RoutingRetainedProcessAdoption, type RoutingRetainedProcessTerminalProof, type RoutingSandboxSessionDeps, type RoutingTransitionEvent, } from "./routing/routing-session";
+export { makeActiveBackendResolver, ActiveBackendUnresolvableError, swapTargetEstablishability, type ActiveBackendResolverDeps, type RoutableSandbox, type BackendUnresolvableCode, type SwapTargetEstablishability, } from "./routing/backend-resolver";
+/**
+ * Construct the raw provider SandboxClient for the configured backend. Registry-
+ * driven (the old flat if/else is gone): the backend's ProviderRegistration owns
+ * validateCredentials + build, with per-provider units/field-names. Returns
+ * undefined for "none".
+ *
+ * The desktop stream port (6080) is merged into exposedPorts for every desktop-
+ * capable (backend, os) when desktop is enabled AND the provider cannot expose
+ * ports on demand (modal/runloop/e2b pre-declare; blaxel resolves on demand).
+ * Existing modal/docker/local construction is behavior-preserved.
+ */
+export declare function createSandboxClient(settings: Settings, environment?: Record<string, string>): unknown;
+/**
+ * Construct the raw provider SandboxClient for an EXPLICIT backend, independent
+ * of settings.sandboxBackend. This is the resume-by-id builder the per-turn
+ * resume path (and the API-direct control plane) call: a lease's box was created
+ * on a specific backend (the envelope's backendId / the lease's
+ * resume_backend_id), and the client that reattaches to it must be built for
+ * THAT backend, not the process's currently-configured default. When the backend
+ * equals settings.sandboxBackend this is identical to createSandboxClient
+ * (behavior-preserved). Returns undefined for "none".
+ */
+export declare function createSandboxClientForBackend(backend: SandboxBackend, settings: Settings, environment?: Record<string, string>): unknown;
+/**
+ * Extract the sandbox recovery entry from a run state as a plain JSON record,
+ * for storage decoupled from the RunState blob (issue #35). Encapsulates the
+ * underscore-internal `_sandbox` read in exactly one place.
+ */
+export declare function sandboxStateEntryFromRunState(state: unknown): Record<string, unknown> | null;
+/**
+ * Items-mode counterpart of restoredSandboxSessionState: rebuild the live
+ * sandbox session state from a stored entry (as produced by
+ * sandboxStateEntryFromRunState) instead of from a RunState blob.
+ */
+export declare function restoredSandboxSessionStateFromEntry(entry: Record<string, unknown>, client: unknown): Promise<SandboxSessionState | undefined>;
+/**
+ * Read the persisted /workspace snapshot archive off a lease envelope's
+ * `sessionState` (sandbox-file-persistence). The reaper (persistDrainSnapshot)
+ * folds the base64 archive — a Modal native snapshot-ref or a tar archive, the
+ * exact bytes `session.persistWorkspace()` returned — at
+ * `sessionState.workspaceArchive`. Cold-restore decodes it and replays it via
+ * `session.hydrateWorkspace(archive)` on the freshly-created box so /workspace is
+ * restored. Returns undefined when the envelope carries no archive (a box that
+ * was never drain-persisted, or a non-persistence config that stored none).
+ *
+ * It is deliberately read SEPARATELY from deserializeSandboxSessionStateEnvelope:
+ * the archive does NOT ride serializeSessionState (it originates at reaper time),
+ * and the SDK's deserializeSessionState must NOT receive it (it is an opaque
+ * runtime-level field, not provider state).
+ */
+export declare function readWorkspaceArchiveFromEnvelopeSessionState(sessionState: unknown): Uint8Array | undefined;
+/** Decode the Modal snapshot id out of a persisted base64 archive ref, or
+ *  undefined when the archive is a tar payload or is unparseable. */
+export declare function decodeModalSnapshotId(archive: Uint8Array): string | undefined;
+export declare function deserializeSandboxSessionStateEnvelope(client: SandboxClient, envelope: unknown): Promise<SandboxSessionState | undefined>;
+/** A live, externally-owned sandbox session re-established from the group lease
+ *  envelope. The caller injects `{client, session, sessionState}` NON-OWNED into
+ *  the run (or drives session.exec/readFile/resolveExposedPort directly) and
+ *  drops the handle when done — the lease, not this handle, owns the box. */
+export type EstablishedSandboxSession = {
+    client: unknown;
+    session: unknown;
+    sessionState: unknown;
+    instanceId: string;
+    backendId: string;
+    /** How this establish reached a live box: warm reattach by id ("resumed"),
+     *  fresh create ("created"), or fresh create + archive hydration
+     *  ("restored"). Callers use it to emit the durable sandbox.box.* lifecycle
+     *  events — box transitions were previously unrecorded, which made both
+     *  2026-07-06 incidents near-unattributable. Optional so external/legacy
+     *  constructors of this shape stay valid. */
+    origin?: "resumed" | "created" | "restored";
+    /** Set when a create-authorized reattach found the envelope's box GONE
+     *  (provider NotFound) and fell through to cold-restore. */
+    lostInstanceId?: string;
+    /** Exact durable archive revision verified byte-for-byte after hydration. */
+    restoredArchive?: WorkspaceArchiveDescriptor;
+};
+export declare class SandboxExecReadinessError extends Error {
+    readonly backend: string;
+    readonly code: "exec_probe_unavailable" | "exec_probe_timeout" | "exec_probe_failed";
+    readonly timeoutMs: number;
+    readonly exitCode: number | null;
+    readonly name = "SandboxExecReadinessError";
+    constructor(backend: string, code: "exec_probe_unavailable" | "exec_probe_timeout" | "exec_probe_failed", timeoutMs: number, exitCode?: number | null);
+}
+/** A provider handle is not workspace readiness. Modal can return a handle
+ * before its command router accepts exec, so every create path must pass this
+ * bounded probe before atomically publishing the lease warm/ready. */
+export declare function verifySandboxExecReadiness(established: EstablishedSandboxSession, timeoutMs?: number): Promise<void>;
+export type SandboxCreatedCallback = (established: EstablishedSandboxSession) => Promise<void>;
+/**
+ * Establish from one recovery envelope under an explicit creation policy. The
+ * envelope is the lease's box-identity descriptor (the same per-turn `_sandbox`
+ * envelope upserted by the turn activity).
+ *
+ *  - `opts.backendOverride ?? envelope.backendId ?? settings.sandboxBackend`
+ *    selects the backend; the client is built for THAT backend (resume-by-id is
+ *    fenced to the original provider).
+ *  - warm reattach: deserialize the envelope sessionState → client.resume(state)
+ *    (no lock; R4-safe). `resume-only` propagates provider NotFound.
+ *  - `create-or-restore`: the elected owner may replace a missing warm instance,
+ *    or create directly from a cold/null envelope.
+ */
+export declare function establishSandboxSessionFromEnvelope(settings: Settings, envelope: Record<string, unknown> | null, opts: {
+    sessionId: string;
+    recovery: "create-or-restore" | "resume-only";
+    backendOverride?: SandboxBackend;
+    environment?: Record<string, string>;
+    onSandboxCreated?: SandboxCreatedCallback;
+    /** Called after archive hydration but immediately before the exact workspace
+     * fingerprint probe. Lease-aware callers persist `verifying` here so a box
+     * is never observable as ready while verification is in flight. */
+    onWorkspaceRestoreVerifying?: (descriptor: WorkspaceArchiveDescriptor) => Promise<void>;
+    metrics?: RuntimeMetricsHooks;
+    /** Isolated conformance-test/embedding seam. Ordinary runtime callers use
+     * the validated provider registry. */
+    clientFactory?: (backend: SandboxBackend, settings: Settings, environment: Record<string, string>) => unknown;
+}): Promise<EstablishedSandboxSession>;
+/**
+ * Fold a freshly-established (or resumed) sandbox session into the persistable
+ * `resume_state` envelope the lease stores — the SAME `{ backendId, sessionState }`
+ * shape `establishSandboxSessionFromEnvelope` consumes to RESUME BY ID. The
+ * API-direct control plane (viewer attach / Channel-A) MUST persist this onto the
+ * lease at warm-commit time, or a later op (which reads the lease's resume_state)
+ * has nothing to resume from and COLD-CREATES A RIVAL BOX — the box-churn the
+ * prove-it surfaced (fs.write then fs.read 404'd on a different box; N Channel-A
+ * ops leaked N boxes). Returns null when the client cannot serialize (the caller
+ * stores null and the box rides the provider idle-timeout — no rival spawn, just
+ * no warm-reattach).
+ */
+export declare function serializeEstablishedSandboxEnvelope(established: EstablishedSandboxSession): Promise<Record<string, unknown> | null>;
+/**
+ * Whether a replacement envelope contains a provider-resumable identity. An
+ * archive-only envelope is intentionally valid recovery metadata, but it is
+ * never proof that the newly-created provider box can be resumed or attached.
+ */
+export declare function hasPersistableSandboxProviderIdentity(envelope: Record<string, unknown> | null | undefined): envelope is Record<string, unknown>;
+/** A replacement provider may not be published warm without a resumable
+ * identity. Archive-only state is retained only when the caller rolls back to
+ * cold and needs the verified workspace bytes for the next attempt. */
+export declare class SandboxReplacementProviderStateError extends Error {
+    readonly backend: string;
+    readonly code: "replacement_provider_state_unpersistable";
+    constructor(backend: string);
+}
+export declare function requirePersistableReplacementSandboxEnvelope(envelope: Record<string, unknown> | null, backend: string): Record<string, unknown>;
+/**
+ * Build the only resume envelope that may be published for a newly-created
+ * replacement sandbox. Historical state contributes durable archive pointers
+ * only; it can never substitute for serialization of the replacement's provider
+ * identity. If replacement serialization is unavailable or fails, publication
+ * keeps an archive-only envelope (when one exists) or null. The new instance id
+ * remains separately fenced on the lease, while later attach/resume fails closed
+ * rather than targeting the dead provider that initiated rematerialization.
+ */
+export declare function serializeReplacementSandboxEnvelope(established: EstablishedSandboxSession, archiveSource: Record<string, unknown> | null): Promise<Record<string, unknown> | null>;

package/dist/sandbox/index.js

@@ -85,9 +85,12 @@ import {
   createSandboxClientForBackend,
   decideSelfhostedRetry,
   decodeModalSnapshotId,
+  decodeNativeSnapshotRef,
   defaultSelfhostedRetryClock,
-  deletePriorPersistedSnapshot,
+  deleteModalCheckpointSnapshot,
   deleteRecordingArtifacts,
+  describeLegacyNativeSnapshotArchive,
+  describeNativeSnapshotArchive,
   deserializeSandboxSessionStateEnvelope,
   desktopCapableBackend,
   drainingExhaustedError,
@@ -101,6 +104,7 @@ import {
   extForCodec,
   fingerprintSandboxWorkspace,
   hasPersistableSandboxProviderIdentity,
+  inspectModalSandboxLifecycle,
   inspectRecordingArtifact,
   isExecSessionLostBanner,
   isProviderSandboxGoneDuringRoutedOperation,
@@ -112,6 +116,7 @@ import {
   mintStreamToken,
   modalSandboxAttributionEnvironment,
   modalSandboxAttributionTags,
+  modalSessionMatchesCheckpointProviderBinding,
   negotiateCapabilities,
   negotiateSelfhostedCapabilities,
   nextDurableOpId,
@@ -133,6 +138,9 @@ import {
   recordingStorageKey,
   renderSelfhostedFault,
   requirePersistableReplacementSandboxEnvelope,
+  resolveModalCheckpointProviderBinding,
+  resolveModalCheckpointProviderBindingForLiveSandbox,
+  resolveModalCheckpointProviderBindingForSession,
   restoredSandboxSessionStateFromEntry,
   runCredentialPointerFile,
   runCredentialRoot,
@@ -170,8 +178,8 @@ import {
   withToolspaceTokenClient,
   withToolspaceTokenEnvironment,
   withToolspaceTokenSession
-} from "../chunk-HHWIZHQM.js";
-import "../chunk-4YJ5Z52Z.js";
+} from "../chunk-GNEGANUF.js";
+import "../chunk-7E2ZSCZK.js";
 import "../chunk-K4V4QYCL.js";
 import "../chunk-PZ5AY32C.js";
 export {
@@ -261,9 +269,12 @@ export {
   createSandboxClientForBackend,
   decideSelfhostedRetry,
   decodeModalSnapshotId,
+  decodeNativeSnapshotRef,
   defaultSelfhostedRetryClock,
-  deletePriorPersistedSnapshot,
+  deleteModalCheckpointSnapshot,
   deleteRecordingArtifacts,
+  describeLegacyNativeSnapshotArchive,
+  describeNativeSnapshotArchive,
   deserializeSandboxSessionStateEnvelope,
   desktopCapableBackend,
   drainingExhaustedError,
@@ -277,6 +288,7 @@ export {
   extForCodec,
   fingerprintSandboxWorkspace,
   hasPersistableSandboxProviderIdentity,
+  inspectModalSandboxLifecycle,
   inspectRecordingArtifact,
   isExecSessionLostBanner,
   isProviderSandboxGoneDuringRoutedOperation,
@@ -288,6 +300,7 @@ export {
   mintStreamToken,
   modalSandboxAttributionEnvironment,
   modalSandboxAttributionTags,
+  modalSessionMatchesCheckpointProviderBinding,
   negotiateCapabilities,
   negotiateSelfhostedCapabilities,
   nextDurableOpId,
@@ -309,6 +322,9 @@ export {
   recordingStorageKey,
   renderSelfhostedFault,
   requirePersistableReplacementSandboxEnvelope,
+  resolveModalCheckpointProviderBinding,
+  resolveModalCheckpointProviderBindingForLiveSandbox,
+  resolveModalCheckpointProviderBindingForSession,
   restoredSandboxSessionStateFromEntry,
   runCredentialPointerFile,
   runCredentialRoot,

package/dist/sandbox/op-correlation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Sanitize a tool call id into a legal NATS subject TOKEN fragment. The op id
+ * is interpolated into the per-op frame subject, whose tokens must not contain
+ * whitespace/control characters or the subject-structure characters (`.`,
+ * `*`, `>`); the runner refuses illegal ids loudly. The mapping is INJECTIVE
+ * (each disallowed char becomes `_<hex>_`), so two distinct call ids can never
+ * collide into one op id — a collision would merge two different execs through
+ * the idempotent-OpStart dedup and return the wrong result.
+ */
+export declare function sanitizeOpIdToken(raw: string): string;
+/**
+ * Bind a tool-call correlation context around `fn` (the tool's execute). Every
+ * durable op id minted inside — however deep in the transport — is
+ * `{callId}:{ordinal}` with ordinals starting at 0 per invocation.
+ */
+export declare function runWithToolCallCorrelation<T>(callId: string, fn: () => T): T;
+/**
+ * Mint the next durable op id for the current tool invocation, or null when no
+ * correlation context is bound (a non-tool caller, e.g. Channel-A structural
+ * exec). Callers fall back to a random unique id — safe (never collides, never
+ * wrongly dedups), merely not stable across a turn re-dispatch, which degrades
+ * that one op to today's at-least-once semantics.
+ */
+export declare function nextDurableOpId(): string | null;

package/dist/sandbox/provider-errors.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Provider sandbox failure classification.
+ *
+ * This is deliberately structural and fail-closed. DNS failures often contain
+ * the word "not found" (`ENOTFOUND`) while gRPC status values are also used by
+ * unrelated SDKs and command routers. A bare numeric status (including gRPC's
+ * numeric 5) is therefore not enough to retire a provider instance. Only
+ * authoritative, non-transient evidence may retire a provider instance and
+ * license lease recovery.
+ */
+export type ProviderSandboxFailureKind = "not_found" | "transient_transport" | "other";
+export type ProviderSandboxFailure = {
+    kind: ProviderSandboxFailureKind;
+    /** Bounded, non-secret diagnostic suitable for logs and lifecycle events. */
+    diagnostic: string;
+};
+/** Typed transport evidence always dominates nested/string NotFound text. */
+export declare function classifyProviderSandboxFailure(backendId: string, error: unknown): ProviderSandboxFailure;
+export declare function isProviderSandboxNotFoundError(backendId: string, error: unknown): boolean;
+/**
+ * Whether a failure from an operation routed through an already-established
+ * sandbox proves that exact provider sandbox disappeared.
+ *
+ * Routed operations can legitimately return HTTP 404 / `NOT_FOUND` for paths,
+ * files, ports, processes, and other subresources. Those generic signals are
+ * sufficient for provider create/resume APIs, but they must never retire the
+ * live sandbox identity after an arbitrary operation. Only an explicit
+ * sandbox-scoped provider code or Modal's exact terminal sandbox grammar is
+ * authoritative on this path. Transient transport evidence still dominates.
+ */
+export declare function isProviderSandboxGoneDuringRoutedOperation(backendId: string, error: unknown): boolean;
+export declare function isProviderSandboxTransientError(backendId: string, error: unknown): boolean;

package/dist/sandbox/provider-operation-gate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Coordinate every command/filesystem/control call against one in-process
+ * provider session. Ordinary operations may overlap; once a capture queues,
+ * later operations wait until its exclusive provider pause completes.
+ */
+export declare function withSandboxProviderOperation<T>(session: unknown, operation: () => Promise<T>): Promise<T>;
+/**
+ * Hold the provider session exclusively for the complete verified archive
+ * capture. The durable lease claim handles other workers; this local gate
+ * closes the same-holder race between native reads and the heartbeat capture.
+ */
+export declare function withSandboxProviderCapture<T>(session: unknown, capture: () => Promise<T>): Promise<T>;

package/dist/sandbox/providers/blaxel.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderRegistration } from "./types";
+export declare const blaxelProvider: ProviderRegistration;

package/dist/sandbox/providers/cloudflare.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderRegistration } from "./types";
+export declare const cloudflareProvider: ProviderRegistration;

package/dist/sandbox/providers/daytona.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderRegistration } from "./types";
+export declare const daytonaProvider: ProviderRegistration;

package/dist/sandbox/providers/docker.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderRegistration } from "./types";
+export declare const dockerProvider: ProviderRegistration;

package/dist/sandbox/providers/e2b.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderRegistration } from "./types";
+export declare const e2bProvider: ProviderRegistration;

package/dist/sandbox/providers/index.d.ts

@@ -0,0 +1,11 @@
+import { SandboxBackend } from "@opengeni/contracts";
+import type { ProviderRegistration } from "./types";
+export declare const PROVIDER_REGISTRY: Record<SandboxBackend, ProviderRegistration>;
+/**
+ * Assert the descriptor table AND that each registered provider's SDK client
+ * reports the backendId its descriptor claims. The latter is the
+ * deferred-from-P0.1 invariant — it can only run here because it constructs the
+ * real clients. Called once at registry build (and from a unit test).
+ */
+export declare function assertProviderRegistryInvariants(): void;
+export type { ProviderRegistration, ProviderConstructionContext } from "./types";

package/dist/sandbox/providers/local.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderRegistration } from "./types";
+export declare const localProvider: ProviderRegistration;

package/dist/sandbox/providers/modal.d.ts

@@ -0,0 +1,132 @@
+import { ModalImageSelector, ModalSandboxClient, type ModalSandboxSession, type ModalSandboxSessionState } from "@openai/agents-extensions/sandbox/modal";
+import type { Settings } from "@opengeni/config";
+import { type ModalCheckpointProviderBinding } from "@opengeni/contracts";
+import type { ProviderRegistration } from "./types";
+export type { ModalCheckpointProviderBinding } from "@opengeni/contracts";
+export type ModalSandboxAttribution = {
+    leaseId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+};
+export type LiveModalSandboxLeaseAttribution = ModalSandboxAttribution & {
+    instanceId: string | null;
+    liveness?: string;
+};
+export type ModalOrphanSweepTermination = {
+    sandboxId: string;
+    reason: "stale_attribution" | "unattributed";
+    tags: Record<string, string>;
+};
+export type ModalOrphanSweepResult = {
+    examined: number;
+    terminated: ModalOrphanSweepTermination[];
+    skipped: number;
+};
+export type RevalidateModalOrphanTermination = (candidate: ModalOrphanSweepTermination) => Promise<boolean>;
+export declare function modalSandboxAttributionEnvironment(input: ModalSandboxAttribution): Record<string, string>;
+export declare function modalSandboxAttributionTags(input: ModalSandboxAttribution): Record<string, string>;
+/**
+ * Modal proves that the exact exec has already terminated with a typed
+ * FAILED_PRECONDITION from its stdin-write RPC. Keep this deliberately
+ * structural and exact: other FAILED_PRECONDITION errors are not process
+ * lifetime authority.
+ */
+export declare function isModalExecAlreadyCompletedError(error: unknown): boolean;
+/**
+ * Bridge the pinned Agents Extensions Modal adapter to Modal 0.9's provider
+ * contracts. The wrapper re-checks the private provider sandbox on every
+ * capture because snapshot_filesystem hydration replaces that object.
+ */
+export declare function installOpenGeniModalSnapshotPolicy<T extends object>(session: T): T;
+export declare class OpenGeniModalSandboxClient extends ModalSandboxClient {
+    create(args?: Parameters<ModalSandboxClient["create"]>[0], manifestOptions?: Parameters<ModalSandboxClient["create"]>[1]): Promise<ModalSandboxSession>;
+    resume(state: ModalSandboxSessionState): Promise<ModalSandboxSession>;
+}
+export declare const modalProvider: ProviderRegistration;
+type ModalModule = typeof import("modal");
+type ModalClientLike = InstanceType<ModalModule["ModalClient"]>;
+/** Loader seam so unit tests can inject a fake modal module. */
+export type ModalModuleLoader = () => Promise<Pick<ModalModule, "ModalClient">>;
+/**
+ * Resolve + cache the private-registry Modal image. No-op unless BOTH
+ * `modalImageRef` and `modalImageRegistrySecret` are set. Memoized per
+ * (imageRef, secret, environment) so it runs once per worker process. Awaited at
+ * worker boot for the deployment-global image and at turn time for pack-scoped
+ * images BEFORE the first sandbox using that ref is created; `build` then reads the
+ * resolved image and otherwise falls back to the public `fromTag` path.
+ */
+export declare function ensureModalRegistryImage(settings: Settings, loadModal?: ModalModuleLoader): Promise<void>;
+/**
+ * Choose the image selector for a Modal sandbox client from settings. Returns:
+ *  - `fromImage(resolved)` when a private-registry secret is configured AND the
+ *    image has been resolved (ensureModalRegistryImage ran before create);
+ *  - `fromTag(modalImageRef)` for the public path (no secret, or cold cache — the
+ *    resume/attach paths never pull an image so the tag branch is harmless there);
+ *  - `undefined` when no image ref is set (Modal uses its default image).
+ * Exported for unit tests.
+ */
+export declare function resolveModalImageSelector(settings: Settings): ModalImageSelector | undefined;
+/** Test-only: clear the resolved/in-flight image caches. */
+export declare function __resetModalRegistryImageCacheForTest(): void;
+/**
+ * Resolve checkpoint ownership through the exact authenticated Modal client
+ * embedded in the session that creates the snapshot. The field is private in
+ * the pinned Agents extension, so this adapter is intentionally fail-closed:
+ * an upstream shape change disables native publication instead of guessing
+ * ownership from a newly-resolved ambient profile.
+ */
+export declare function resolveModalCheckpointProviderBindingForSession(settings: Settings, session: unknown): Promise<{
+    key: string;
+    binding: ModalCheckpointProviderBinding;
+}>;
+/** Compare a restore receipt against the exact authenticated Modal client
+ * embedded in the created session. This deliberately does not resolve a second
+ * ambient client: the session that will consume the snapshot is the authority. */
+export declare function modalSessionMatchesCheckpointProviderBinding(settings: Settings, session: unknown, expectedBindingKey: string): Promise<boolean>;
+/** Resolve the authoritative Modal workspace behind the configured credential.
+ * Snapshot ids are workspace-scoped; persisting this non-secret binding lets GC
+ * reject a credential rotation that points at a different workspace instead of
+ * issuing a destructive call under ambient credentials. */
+export declare function resolveModalCheckpointProviderBinding(settings: Settings, createClient?: (settings: Settings) => Promise<ModalClientLike>): Promise<{
+    key: string;
+    binding: ModalCheckpointProviderBinding;
+}>;
+/** Prove a legacy lease's live sandbox is visible in the same Modal namespace
+ * whose identity will own the adopted checkpoint row. */
+export declare function resolveModalCheckpointProviderBindingForLiveSandbox(settings: Settings, sandboxId: string, createClient?: (settings: Settings) => Promise<ModalClientLike>): Promise<{
+    key: string;
+    binding: ModalCheckpointProviderBinding;
+}>;
+/**
+ * Observe one exact historical Modal sandbox without consulting the current
+ * lease or its (possibly successor-owned) resume envelope. This is deliberately
+ * lifecycle-only: a running sandbox does not prove whether an individual
+ * retained process is still running, while a terminal/missing sandbox proves
+ * that none of its processes can still execute.
+ */
+export declare function inspectModalSandboxLifecycle(settings: Settings, sandboxId: string, expectedBindingKey?: string | null, createClient?: (settings: Settings) => Promise<ModalClientLike>): Promise<{
+    status: "running";
+    providerBindingKey: string;
+    providerBinding: ModalCheckpointProviderBinding;
+} | {
+    status: "terminated";
+    exitCode: number;
+    providerBindingKey: string;
+    providerBinding: ModalCheckpointProviderBinding;
+} | {
+    status: "not_found";
+    providerBindingKey: string;
+    providerBinding: ModalCheckpointProviderBinding;
+}>;
+export declare function deleteModalCheckpointSnapshot(settings: Settings, expectedBindingKey: string, snapshotId: string, createClient?: (settings: Settings) => Promise<ModalClientLike>): Promise<"deleted" | "not_found">;
+export declare function tagModalSandbox(settings: Settings, sandboxId: string, attribution: ModalSandboxAttribution): Promise<boolean>;
+export declare function terminateModalSandboxById(settings: Settings, sandboxId: string): Promise<boolean>;
+export declare function sweepModalOrphanSandboxes(settings: Settings, liveLeases: LiveModalSandboxLeaseAttribution[], options?: {
+    now?: Date;
+    maxTerminations?: number;
+    unattributedGraceMs?: number;
+    client?: ModalClientLike;
+    /** Re-read durable ownership immediately before provider termination. A
+     * false result or callback failure skips the destructive action. */
+    revalidateTermination?: RevalidateModalOrphanTermination;
+}): Promise<ModalOrphanSweepResult>;

package/dist/sandbox/providers/none.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderRegistration } from "./types";
+export declare const noneProvider: ProviderRegistration;

package/dist/sandbox/providers/runloop.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderRegistration } from "./types";
+export declare const runloopProvider: ProviderRegistration;

package/dist/sandbox/providers/selfhosted.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderRegistration } from "./types";
+export declare const selfhostedProvider: ProviderRegistration;

package/dist/sandbox/providers/types.d.ts

@@ -0,0 +1,30 @@
+import type { Settings } from "@opengeni/config";
+import type { CapabilityDescriptor, SandboxBackend } from "@opengeni/contracts";
+export interface ProviderConstructionContext {
+    settings: Settings;
+    /** The env map for the box (collectSandboxEnvironment / per-run environment). */
+    environment: Record<string, string>;
+    /**
+     * Parsed exposed ports (config string -> number[]); already includes the
+     * desktop stream port (6080) when this is a desktop tier with desktop enabled
+     * and the provider cannot expose ports on demand (the merge happens in
+     * createSandboxClient before build()).
+     */
+    exposedPorts: number[];
+}
+export interface ProviderRegistration {
+    backend: SandboxBackend;
+    descriptor: CapabilityDescriptor;
+    /**
+     * Validate that the settings carry the credentials/config this provider
+     * REQUIRES. Throw SandboxConfigError on any missing/contradictory field.
+     * Pure — no network. Called by both the factory and a deploy-time preflight.
+     * The factory calls this before build(), so build() may assume valid settings.
+     */
+    validateCredentials(settings: Settings): void;
+    /**
+     * Build the raw SDK SandboxClient. Returns undefined ONLY for "none".
+     * The factory calls validateCredentials() first, so build() can assume valid.
+     */
+    build(ctx: ProviderConstructionContext): unknown;
+}

package/dist/sandbox/providers/vercel.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderRegistration } from "./types";
+export declare const vercelProvider: ProviderRegistration;