@opengeni/config 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,721 @@
+import { Entitlements, SandboxBackend, StaticUsageLimits, ReasoningEffort } from '@opengeni/contracts';
+import { z } from 'zod';
+
+declare const sandboxPreparationProfiles: Record<string, {
+    env: string[];
+    hooks: string[];
+}>;
+/**
+ * Placeholder token inside an agent-instructions persona template. The runtime
+ * substitutes the non-bypassable CORE (goal-loop ownership + the dynamic
+ * workspace-environment block) at this marker. A template that omits the
+ * marker still gets the CORE appended after it (a non-bypassable fail-safe),
+ * so a white-labelled persona can never drop the goal-loop contract or the
+ * environment metadata the agent depends on.
+ */
+declare const AGENT_INSTRUCTIONS_CORE_PLACEHOLDER = "{{core}}";
+/**
+ * Default per-workspace agent persona template. This is the BRAND + tool-usage
+ * opinion (the white-labellable surface): the "You are an OpenGeni workspace
+ * agent." identity line, the framing/opinion lines, and the mount-path facts.
+ *
+ * The CORE that MUST survive any override — the goal-loop ownership line (which
+ * names the opengeni__goal_* tools) and the dynamic workspace-environment block
+ * — is injected at AGENT_INSTRUCTIONS_CORE_PLACEHOLDER by the runtime, never
+ * baked into this overridable string.
+ *
+ * INVARIANT: with no per-workspace override and an empty environment, the
+ * runtime's composed instructions are BYTE-IDENTICAL to the historical
+ * hardcoded preamble. The template below is exactly the historical lines 1–11
+ * joined by " ", followed by " " + the placeholder. Changing a single
+ * character here changes that default; a runtime test pins it.
+ */
+declare const DEFAULT_AGENT_INSTRUCTIONS: string;
+declare const SettingsSchema: z.ZodObject<{
+    serviceName: z.ZodDefault<z.ZodString>;
+    environment: z.ZodDefault<z.ZodString>;
+    deploymentRevision: z.ZodDefault<z.ZodString>;
+    databaseUrl: z.ZodDefault<z.ZodString>;
+    dbSchema: z.ZodDefault<z.ZodString>;
+    rlsStrategy: z.ZodDefault<z.ZodEnum<{
+        force: "force";
+        scoped: "scoped";
+    }>>;
+    natsUrl: z.ZodDefault<z.ZodString>;
+    temporalHost: z.ZodDefault<z.ZodString>;
+    temporalNamespace: z.ZodDefault<z.ZodString>;
+    temporalTaskQueue: z.ZodDefault<z.ZodString>;
+    startupDependencyRetryAttempts: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    startupDependencyRetryInitialDelayMs: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    startupDependencyRetryMaxDelayMs: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    observabilityStructuredLogs: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    observabilityMetricsEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    observabilityOtlpEndpoint: z.ZodOptional<z.ZodString>;
+    observabilityOtlpHeaders: z.ZodDefault<z.ZodString>;
+    publicBaseUrl: z.ZodOptional<z.ZodString>;
+    agentReleasesBaseUrl: z.ZodDefault<z.ZodString>;
+    productAccessMode: z.ZodDefault<z.ZodEnum<{
+        local: "local";
+        configured: "configured";
+        managed: "managed";
+    }>>;
+    billingMode: z.ZodDefault<z.ZodEnum<{
+        disabled: "disabled";
+        stripe: "stripe";
+    }>>;
+    entitlementsMode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        managed: "managed";
+        static: "static";
+    }>>;
+    usageLimitsMode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        managed: "managed";
+        static: "static";
+    }>>;
+    staticEntitlementsJson: z.ZodDefault<z.ZodString>;
+    staticUsageLimitsJson: z.ZodDefault<z.ZodString>;
+    delegationSecret: z.ZodOptional<z.ZodString>;
+    streamTokenSecret: z.ZodOptional<z.ZodString>;
+    streamControlEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    environmentsEncryptionKey: z.ZodOptional<z.ZodString>;
+    goalMaxAutoContinuations: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    goalNoProgressLimit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    agentMaxModelCallsPerTurn: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    sessionHistorySource: z.ZodDefault<z.ZodEnum<{
+        run_state: "run_state";
+        items: "items";
+    }>>;
+    contextCompactionMode: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        server: "server";
+        client: "client";
+        off: "off";
+    }>>;
+    contextWindowTokens: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    contextReservedOutputTokens: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    contextServerCompactThresholdTokens: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    contextCompactSoftFraction: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    contextCompactHardFraction: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    contextKeepRecentTokens: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    contextSummaryMaxTokens: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    authRequired: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    accessKey: z.ZodOptional<z.ZodString>;
+    authAllowHealth: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    authAllowMetrics: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    apiHost: z.ZodDefault<z.ZodString>;
+    apiPort: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    opengeniMcpUrl: z.ZodOptional<z.ZodString>;
+    corsAllowOriginRegex: z.ZodDefault<z.ZodString>;
+    openaiProvider: z.ZodDefault<z.ZodEnum<{
+        azure: "azure";
+        openai: "openai";
+    }>>;
+    openaiApiKey: z.ZodOptional<z.ZodString>;
+    openaiBaseUrl: z.ZodOptional<z.ZodString>;
+    openaiModel: z.ZodDefault<z.ZodString>;
+    openaiAllowedModels: z.ZodDefault<z.ZodString>;
+    modelPricingJson: z.ZodDefault<z.ZodString>;
+    modelProvidersJson: z.ZodDefault<z.ZodString>;
+    codexSubscriptionEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    codexProductSku: z.ZodOptional<z.ZodString>;
+    codexToolSearchEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    codexRotationNearExhaustionPct: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    openaiReasoningEffort: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+    }>>;
+    openaiAllowedReasoningEfforts: z.ZodDefault<z.ZodString>;
+    openaiResponsesTransport: z.ZodDefault<z.ZodEnum<{
+        http: "http";
+        websocket: "websocket";
+    }>>;
+    openaiProviderItemIds: z.ZodDefault<z.ZodEnum<{
+        strip: "strip";
+        preserve: "preserve";
+    }>>;
+    openaiReasoningEncryptedContent: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    openaiMaxRetries: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    webSearchEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    agentInstructionsTemplate: z.ZodDefault<z.ZodString>;
+    azureOpenaiBaseUrl: z.ZodOptional<z.ZodString>;
+    azureOpenaiEndpoint: z.ZodOptional<z.ZodString>;
+    azureOpenaiDeployment: z.ZodOptional<z.ZodString>;
+    azureOpenaiApiVersion: z.ZodOptional<z.ZodString>;
+    azureOpenaiApiKey: z.ZodOptional<z.ZodString>;
+    azureOpenaiAdToken: z.ZodOptional<z.ZodString>;
+    disableOpenaiTracing: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    sandboxBackend: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        local: "local";
+        docker: "docker";
+        modal: "modal";
+        daytona: "daytona";
+        runloop: "runloop";
+        e2b: "e2b";
+        blaxel: "blaxel";
+        cloudflare: "cloudflare";
+        vercel: "vercel";
+        selfhosted: "selfhosted";
+    }>>;
+    dockerImage: z.ZodDefault<z.ZodString>;
+    dockerExposedPorts: z.ZodDefault<z.ZodString>;
+    dockerNetwork: z.ZodOptional<z.ZodString>;
+    modalAppName: z.ZodDefault<z.ZodString>;
+    modalImageRef: z.ZodOptional<z.ZodString>;
+    modalTimeoutSeconds: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    modalTokenId: z.ZodOptional<z.ZodString>;
+    modalTokenSecret: z.ZodOptional<z.ZodString>;
+    modalEnvironment: z.ZodOptional<z.ZodString>;
+    modalIdleTimeoutSeconds: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    modalWorkspacePersistence: z.ZodDefault<z.ZodEnum<{
+        tar: "tar";
+        snapshot_filesystem: "snapshot_filesystem";
+        snapshot_directory: "snapshot_directory";
+    }>>;
+    modalSnapshotRetentionSeconds: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    sandboxDesktopEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    sandboxDesktopInteractive: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    sandboxTerminalEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    streamResolutionWidth: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    streamResolutionHeight: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    computerUseEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    computerUseReadOnly: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    recordingEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    recordingDefaultCodec: z.ZodDefault<z.ZodEnum<{
+        "h264-mp4": "h264-mp4";
+        "vp9-webm": "vp9-webm";
+    }>>;
+    recordingFramerate: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    recordingMaxSeconds: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    recordingMaxBytes: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    daytonaApiKey: z.ZodOptional<z.ZodString>;
+    daytonaApiUrl: z.ZodOptional<z.ZodString>;
+    daytonaTarget: z.ZodOptional<z.ZodString>;
+    daytonaImage: z.ZodOptional<z.ZodString>;
+    daytonaSnapshotName: z.ZodOptional<z.ZodString>;
+    daytonaAutoStopInterval: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    daytonaTimeoutSeconds: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    daytonaExposedPortUrlTtlSeconds: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    runloopApiKey: z.ZodOptional<z.ZodString>;
+    runloopBaseUrl: z.ZodOptional<z.ZodString>;
+    runloopBlueprintName: z.ZodOptional<z.ZodString>;
+    runloopBlueprintId: z.ZodOptional<z.ZodString>;
+    runloopTunnel: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    runloopKeepAliveSeconds: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    e2bApiKey: z.ZodOptional<z.ZodString>;
+    e2bTemplate: z.ZodOptional<z.ZodString>;
+    e2bTimeoutSeconds: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    e2bTimeoutAction: z.ZodOptional<z.ZodEnum<{
+        pause: "pause";
+        kill: "kill";
+    }>>;
+    e2bAllowInternetAccess: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean>>;
+    e2bAutoResume: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean>>;
+    e2bWorkspacePersistence: z.ZodOptional<z.ZodEnum<{
+        tar: "tar";
+        snapshot: "snapshot";
+    }>>;
+    blaxelApiKey: z.ZodOptional<z.ZodString>;
+    blaxelImage: z.ZodOptional<z.ZodString>;
+    blaxelRegion: z.ZodOptional<z.ZodString>;
+    blaxelExposedPortPublic: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean>>;
+    blaxelExposedPortUrlTtlSeconds: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    blaxelMemoryMb: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    blaxelTtl: z.ZodOptional<z.ZodString>;
+    cloudflareWorkerUrl: z.ZodOptional<z.ZodString>;
+    cloudflareApiKey: z.ZodOptional<z.ZodString>;
+    vercelToken: z.ZodOptional<z.ZodString>;
+    vercelProjectId: z.ZodOptional<z.ZodString>;
+    vercelTeamId: z.ZodOptional<z.ZodString>;
+    vercelRuntime: z.ZodOptional<z.ZodString>;
+    sandboxOwnershipEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    sandboxSelfhostedEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    enrollmentSigningSecret: z.ZodOptional<z.ZodString>;
+    selfhostedNatsUrl: z.ZodOptional<z.ZodString>;
+    selfhostedRelayUrl: z.ZodOptional<z.ZodString>;
+    selfhostedRelayTokenSecret: z.ZodOptional<z.ZodString>;
+    agentUpdatePublicKey: z.ZodOptional<z.ZodString>;
+    selfhostedNatsCalloutAccountSeed: z.ZodOptional<z.ZodString>;
+    selfhostedNatsCalloutAccountName: z.ZodOptional<z.ZodString>;
+    selfhostedNatsCalloutUser: z.ZodOptional<z.ZodString>;
+    selfhostedNatsCalloutPassword: z.ZodOptional<z.ZodString>;
+    selfhostedNatsControlUser: z.ZodOptional<z.ZodString>;
+    selfhostedNatsControlPassword: z.ZodOptional<z.ZodString>;
+    sandboxLeaseReaperPeriodMs: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    sandboxViewerHolderTtlMs: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    sandboxIdleGraceMs: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    sandboxLeaseTtlMs: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    sandboxLeaseWarmingTtlMs: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    sandboxWarmRateMicrosPerSecondJson: z.ZodDefault<z.ZodString>;
+    sandboxMaxWarmSecondsPerWorkspace: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    sandboxPreparationProfiles: z.ZodDefault<z.ZodString>;
+    sandboxEnvAllowlist: z.ZodDefault<z.ZodString>;
+    objectStorageEndpoint: z.ZodOptional<z.ZodString>;
+    objectStorageSandboxEndpoint: z.ZodOptional<z.ZodString>;
+    objectStorageBackend: z.ZodDefault<z.ZodEnum<{
+        "s3-compatible": "s3-compatible";
+        "aws-s3": "aws-s3";
+        "azure-blob": "azure-blob";
+        gcs: "gcs";
+    }>>;
+    objectStorageBucket: z.ZodDefault<z.ZodString>;
+    objectStorageRegion: z.ZodDefault<z.ZodString>;
+    objectStorageS3Provider: z.ZodDefault<z.ZodString>;
+    objectStorageAccessKeyId: z.ZodOptional<z.ZodString>;
+    objectStorageSecretAccessKey: z.ZodOptional<z.ZodString>;
+    objectStorageForcePathStyle: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    objectStorageAzureConnectionString: z.ZodOptional<z.ZodString>;
+    objectStorageAzureAccountName: z.ZodOptional<z.ZodString>;
+    objectStorageAzureAccountKey: z.ZodOptional<z.ZodString>;
+    objectStorageAzureEndpoint: z.ZodOptional<z.ZodString>;
+    objectStorageGcsProjectId: z.ZodOptional<z.ZodString>;
+    objectStorageGcsCredentialsJson: z.ZodOptional<z.ZodString>;
+    objectStorageGcsKeyFilename: z.ZodOptional<z.ZodString>;
+    objectStorageGcsApiEndpoint: z.ZodOptional<z.ZodString>;
+    documentParser: z.ZodDefault<z.ZodString>;
+    documentChunkSize: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    documentChunkOverlap: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    documentEmbeddingProvider: z.ZodDefault<z.ZodEnum<{
+        openai: "openai";
+        deterministic: "deterministic";
+    }>>;
+    documentEmbeddingModel: z.ZodDefault<z.ZodString>;
+    documentEmbeddingDimensions: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    documentEmbeddingApiKey: z.ZodOptional<z.ZodString>;
+    documentEmbeddingBaseUrl: z.ZodOptional<z.ZodString>;
+    gitAuthorName: z.ZodOptional<z.ZodString>;
+    gitAuthorEmail: z.ZodOptional<z.ZodString>;
+    gitCommitterName: z.ZodOptional<z.ZodString>;
+    gitCommitterEmail: z.ZodOptional<z.ZodString>;
+    githubAppManifestBaseUrl: z.ZodOptional<z.ZodString>;
+    githubAppManifestStateSecret: z.ZodOptional<z.ZodString>;
+    githubAppId: z.ZodOptional<z.ZodString>;
+    githubClientId: z.ZodOptional<z.ZodString>;
+    githubClientSecret: z.ZodOptional<z.ZodString>;
+    githubAppSlug: z.ZodOptional<z.ZodString>;
+    githubWebhookSecret: z.ZodOptional<z.ZodString>;
+    githubAppPrivateKey: z.ZodOptional<z.ZodString>;
+    betterAuthSecret: z.ZodOptional<z.ZodString>;
+    betterAuthAllowedHosts: z.ZodDefault<z.ZodString>;
+    betterAuthCookieDomain: z.ZodOptional<z.ZodString>;
+    betterAuthTrustedOrigins: z.ZodDefault<z.ZodString>;
+    resendApiKey: z.ZodOptional<z.ZodString>;
+    emailFrom: z.ZodDefault<z.ZodString>;
+    stripeSecretKey: z.ZodOptional<z.ZodString>;
+    stripePublishableKey: z.ZodOptional<z.ZodString>;
+    stripeWebhookSecret: z.ZodOptional<z.ZodString>;
+    stripeCreditsProductId: z.ZodOptional<z.ZodString>;
+    mcpServers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        url: z.ZodString;
+        allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        cacheToolsList: z.ZodDefault<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Settings = z.infer<typeof SettingsSchema>;
+type McpServerConfig = Settings["mcpServers"][number];
+type ModelPricing = {
+    inputMicrosPerMillionTokens: number;
+    cachedInputMicrosPerMillionTokens?: number | undefined;
+    outputMicrosPerMillionTokens: number;
+    marginBps?: number | undefined;
+};
+type ModelUsageInput = {
+    inputTokens?: number | undefined;
+    outputTokens?: number | undefined;
+    totalTokens?: number | undefined;
+    inputTokensDetails?: Record<string, number> | Array<Record<string, number>> | undefined;
+    requestUsageEntries?: ModelUsageInput[] | undefined;
+};
+type StaticUsageLimitsConfig = StaticUsageLimits;
+type EntitlementsConfig = Entitlements;
+/**
+ * Wire API a provider speaks. The built-in OpenAI/Azure provider always uses
+ * "responses" (the OpenAI Responses API). Extra registry providers default to
+ * "chat" (the broadly compatible /v1/chat/completions surface); Fireworks is
+ * wired as "chat" because its beta Responses endpoint echoes input back and
+ * silently no-ops hosted tools (see docs/model-providers.md).
+ */
+declare const ModelProviderApi: z.ZodEnum<{
+    responses: "responses";
+    chat: "chat";
+}>;
+type ModelProviderApi = z.infer<typeof ModelProviderApi>;
+/**
+ * Registry provider kind. "api-key" providers carry their own static key/headers;
+ * "codex-subscription" providers authenticate per-request with a ChatGPT/Codex
+ * subscription token resolved at call time (no static key) — see @opengeni/codex.
+ */
+declare const RegistryProviderKind: z.ZodEnum<{
+    "api-key": "api-key";
+    "codex-subscription": "codex-subscription";
+}>;
+type RegistryProviderKind = z.infer<typeof RegistryProviderKind>;
+/** A non-built-in provider declared by the host via OPENGENI_MODEL_PROVIDERS_JSON. */
+declare const RegistryProviderSchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodEnum<{
+        "api-key": "api-key";
+        "codex-subscription": "codex-subscription";
+    }>>;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    api: z.ZodDefault<z.ZodEnum<{
+        responses: "responses";
+        chat: "chat";
+    }>>;
+    baseUrl: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+    apiKeyEnv: z.ZodOptional<z.ZodString>;
+    defaultQuery: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    defaultHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        contextWindowTokens: z.ZodOptional<z.ZodNumber>;
+        reasoningEffort: z.ZodOptional<z.ZodBoolean>;
+        hostedWebSearch: z.ZodOptional<z.ZodBoolean>;
+        pricing: z.ZodOptional<z.ZodObject<{
+            inputMicrosPerMillionTokens: z.ZodNumber;
+            cachedInputMicrosPerMillionTokens: z.ZodOptional<z.ZodNumber>;
+            outputMicrosPerMillionTokens: z.ZodNumber;
+            marginBps: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type RegistryProvider = z.infer<typeof RegistryProviderSchema>;
+/**
+ * Runtime-resolved provider (built-in or registry), client-construction-ready.
+ * The built-in OpenAI/Azure provider is always present and always "responses";
+ * registry providers carry their own base URL / key / wire API. compactionMode
+ * is "server" only for the built-in OpenAI platform provider (its Responses API
+ * honors server-side context_management) and "client" for everything else.
+ */
+interface ResolvedModelProvider {
+    id: string;
+    label: string;
+    kind: RegistryProviderKind;
+    api: ModelProviderApi;
+    builtin: boolean;
+    baseUrl?: string | undefined;
+    apiKey?: string | undefined;
+    defaultQuery?: Record<string, string> | undefined;
+    defaultHeaders?: Record<string, string> | undefined;
+    compactionMode: ContextCompactionMode;
+}
+/** A single exposed model + the provider that serves it. */
+interface ConfiguredModel {
+    id: string;
+    label: string;
+    providerId: string;
+    providerLabel: string;
+    api: ModelProviderApi;
+    contextWindowTokens?: number | undefined;
+    reasoningEffort: boolean;
+    hostedWebSearch: boolean;
+}
+declare const defaultModelPricing: Record<string, ModelPricing>;
+type SandboxRequiredEnv = {
+    field: keyof Settings;
+    env: string;
+};
+declare const SANDBOX_REQUIRED_ENV: Record<z.infer<typeof SandboxBackend>, readonly SandboxRequiredEnv[]>;
+/** The required OPENGENI_* env var names for a backend (for the deployment manifest). */
+declare function requiredSandboxEnvForBackend(backend: z.infer<typeof SandboxBackend>): string[];
+declare function getSettings(): Settings;
+/**
+ * The Modal sandbox idle timeout (seconds) the provider actually passes as
+ * idleTimeoutMs (sandbox-file-persistence). When the operator did not pin
+ * OPENGENI_MODAL_IDLE_TIMEOUT_SECONDS we DEFAULT it to the hard lifetime
+ * (modalTimeoutSeconds): OpenGeni's reaper owns box lifecycle, so Modal's
+ * built-in idle-reap (which would otherwise fire on its short server default and
+ * kill the box BEFORE the reaper can snapshot /workspace) is pushed out to the
+ * hard backstop. An explicit smaller value is honoured (the boot invariant keeps
+ * it above reaperPeriod + idleGrace so a drained box still survives long enough
+ * to be persisted).
+ */
+declare function effectiveModalIdleTimeoutSeconds(settings: Settings): number;
+declare function collectSandboxEnvironment(settings: Settings, source?: NodeJS.ProcessEnv): Record<string, string>;
+/**
+ * Resolved API key for a registry provider: the inline `apiKey` when present,
+ * else the value of the env var named by `apiKeyEnv`. The preferred form is
+ * `apiKeyEnv` (the secret stays out of OPENGENI_MODEL_PROVIDERS_JSON). Reads
+ * from `source` (defaults to process.env) so callers can resolve against an
+ * explicit environment in tests.
+ */
+declare function resolveProviderApiKey(provider: Pick<RegistryProvider, "apiKey" | "apiKeyEnv">, source?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * Every provider a client may route to: the built-in OpenAI/Azure provider
+ * first (id "openai"/"azure", always "responses", compactionMode from
+ * resolveContextCompactionMode), then each registry provider in declaration
+ * order (compactionMode "client"). Client-construction inputs are filled from
+ * the existing flat openai/azure settings for the built-in, and from the
+ * registry entry for the rest. Registry ids may not collide with the built-in
+ * id — validateSettings rejects that at boot.
+ */
+declare function configuredProviders(settings: Settings): ResolvedModelProvider[];
+/**
+ * Every model a client may use, the built-in provider's models first
+ * (configuredAllowedModels-from-openai, mapped to "responses" with
+ * hostedWebSearch/contextWindow/reasoningEffort from the flat settings), then
+ * each registry provider's models (label→id, hostedWebSearch/reasoningEffort
+ * default false). De-duplicated by id (first wins) so the default model stays
+ * first and the built-in allow-list takes precedence over registry entries.
+ */
+declare function configuredModels(settings: Settings): ConfiguredModel[];
+/**
+ * Allowed model ids in selection order. Reimplemented on top of
+ * configuredModels so it is the union of the built-in allow-list and every
+ * registry provider's ids, de-duplicated. INVARIANT (existing callers + tests
+ * depend on it): settings.openaiModel is always first, then the rest of the
+ * openai allow-list, then registry ids.
+ */
+declare function configuredAllowedModels(settings: Settings): string[];
+/**
+ * Resolve a model string to the provider that serves it and its configured
+ * shape. Returns undefined when the id is not exposed (built-in allow-list nor
+ * any registry provider), so the runtime can fall back to the legacy global
+ * client path.
+ */
+declare function resolveModelProvider(settings: Settings, modelId: string): {
+    provider: ResolvedModelProvider;
+    model: ConfiguredModel;
+} | undefined;
+/**
+ * Effective per-model pricing. Merge order (later wins):
+ *   defaultModelPricing → registry model `pricing` entries (keyed by model id)
+ *   → parseModelPricingJson(settings.modelPricingJson) (explicit JSON wins).
+ */
+declare function configuredModelPricing(settings: Settings): Record<string, ModelPricing>;
+/**
+ * Resolved conversation-context compaction path for a run.
+ *  - "server": let the OpenAI platform Responses API compact server-side (the
+ *    SDK emits context_management; we pass the correct gpt-5.5 threshold).
+ *  - "client": run OpenGeni's own client-side compaction (Azure and any other
+ *    backend that rejects/ignores context_management).
+ *  - "off": neither (legacy unbounded growth; escape hatch).
+ *
+ * "auto" maps to "server" on the OpenAI platform provider and "client"
+ * otherwise — Azure's Responses API returns 400 unsupported_parameter for
+ * context_management, so it must never take the server path.
+ */
+type ContextCompactionMode = "server" | "client" | "off";
+declare function resolveContextCompactionMode(settings: Pick<Settings, "contextCompactionMode" | "openaiProvider">): ContextCompactionMode;
+/** Usable input-token budget B = window - reserved output. */
+declare function contextInputBudgetTokens(settings: Pick<Settings, "contextWindowTokens" | "contextReservedOutputTokens">): number;
+/**
+ * Server-path compact_threshold (tokens) handed to the SDK's
+ * StaticCompactionPolicy: the explicit override when set, else
+ * floor(B * softFraction). This is what sidesteps the SDK's wrong 240k
+ * fallback for gpt-5.5 (which is absent from its hardcoded window map).
+ */
+declare function contextServerCompactThreshold(settings: Pick<Settings, "contextWindowTokens" | "contextReservedOutputTokens" | "contextServerCompactThresholdTokens" | "contextCompactSoftFraction">): number;
+declare function configuredStaticUsageLimits(settings: Settings): StaticUsageLimitsConfig;
+declare function configuredEntitlements(settings: Settings): EntitlementsConfig;
+declare function calculateModelUsageCostMicros(settings: Settings, model: string, usage: ModelUsageInput): number;
+declare function configuredAllowedReasoningEfforts(settings: Settings): Array<z.infer<typeof ReasoningEffort>>;
+/**
+ * Decodes OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY (base64, exactly 32 bytes) for
+ * AES-256-GCM workspace environment value encryption. Returns null when unset.
+ * Throws naming only the env var, never echoing its value.
+ */
+declare function environmentsEncryptionKeyBytes(settings: Settings): Uint8Array | null;
+/**
+ * The connection `search_path` for OpenGeni's db handles + the managed-auth pool
+ * (Step I, §7.8 runtime half). Returns `undefined` when `dbSchema` is unset
+ * (standalone) so no `search_path` startup parameter is sent and the server
+ * default (`public`) applies — byte-for-byte today's behavior. When `dbSchema`
+ * is set (embedded), returns `"<schema>,opengeni_private,public"` — `public`
+ * stays LAST so `gen_random_uuid()` (pgcrypto) and the `vector` type still
+ * resolve (the SPIKE-1 live footgun). `opengeni_private` is on the path so the
+ * RLS GUC-reader helpers resolve when referenced unqualified.
+ */
+declare function dbSearchPath(settings: Pick<Settings, "dbSchema">): string | undefined;
+declare function collectGitIdentityEnvironment(settings: Settings): Record<string, string>;
+/**
+ * The STABLE run-scoped sandbox environment: the subset of a run's box-manifest
+ * environment that is IDENTICAL whether the box is first warmed by the worker
+ * TURN or by an API-direct ATTACH (viewer / Channel-A / desktop / terminal). It
+ * is the layered base every cold box must be created with so a later turn's
+ * agent-manifest apply finds an EMPTY environment delta in the SDK's
+ * `validateNoEnvironmentDelta` (which throws "Live sandbox sessions cannot change
+ * manifest environment variables" on ANY key the agent declares that the box's
+ * manifest lacks or carries a different value for).
+ *
+ * Precedence (lowest → highest): deployment allowlist (`collectSandboxEnvironment`)
+ * < git identity (`collectGitIdentityEnvironment`) < the session's attached
+ * workspace environment < the backend-aware HOME default. Reserved-name validation
+ * at write time keeps workspace values from colliding with platform entries.
+ *
+ * DELIBERATELY EXCLUDES the per-run, ROTATING GitHub App installation token
+ * VALUE that `sandboxEnvironmentForRun` mints when a repository resource is
+ * attached: that token is minted FRESH per call, so it is not a stable, attach-
+ * reproducible value and must not be part of the shared base. Under the token-
+ * broker (B1) the token VALUE never rides the manifest at all — it is seeded to a
+ * FILE inside the box (agent-managed, refreshable mid-turn via the `github_token`
+ * MCP tool) and git auth flows through GIT_ASKPASS -> that file. What IS stable and
+ * lives here is the token FILE PATH (`OPENGENI_GIT_TOKEN_FILE`): a constant derived
+ * from HOME, so it appears IDENTICALLY on BOTH the turn AND every attach manifest
+ * (the SDK's per-turn provided-session env delta stays empty even as the token
+ * rotates). The attach surfaces have only the `Session` (no repo resources) and so
+ * never seed a token, but the file-path pointer is harmless (an unwritten file
+ * simply yields no auth); the BLOCKING attach-vs-turn error this helper fixes is
+ * for the common (no-repo) and workspace-environment-attached cases.
+ */
+declare function stableSandboxEnvironmentForRun(settings: Settings, workspaceEnvironment?: Record<string, string>): Record<string, string>;
+/**
+ * Whether a resource set carries a GitHub-App-connected repository (installation
+ * + repository ids present) — the SAME predicate the worker turn uses to decide
+ * whether it declares the stable git-auth pointers. Attach surfaces call this so
+ * an attach-warmed cold box carries the IDENTICAL manifest env a later repo turn
+ * declares (env parity — see applyGitAuthPointerEnvironment).
+ */
+declare function hasGitHubRepositorySelection(resources: ReadonlyArray<{
+    kind: string;
+    githubInstallationId?: unknown;
+    githubRepositoryId?: unknown;
+}>): boolean;
+/**
+ * TOKEN-BROKER (B1) parity: the STABLE git-auth POINTER environment a
+ * repo-attached run declares — GIT_ASKPASS (a fixed path under HOME; the script
+ * itself is provisioned at box setup), GIT_TERMINAL_PROMPT, and the GitHub-App
+ * bot identity fallbacks. NO rotating value rides here (the token lives in the
+ * file behind the askpass), so the layer is attach-reproducible and MUST be
+ * applied identically by the worker turn (sandboxEnvironmentForRun) AND every
+ * API-direct attach surface that can cold-create the box (viewer attach,
+ * channel-A ops). A box cold-created WITHOUT this layer kills the next repo
+ * turn: the turn's manifest declares these keys, the box's env lacks them, and
+ * the SDK's provided-session guard throws "Live sandbox sessions cannot change
+ * manifest environment variables" (observed live: an open session page's viewer
+ * attach won the cold-create race and the first turn died).
+ *
+ * Mutates and returns `environment`. Identity fallbacks preserve values already
+ * present (the deployment git-identity allowlist wins over the bot identity).
+ */
+declare function applyGitAuthPointerEnvironment(environment: Record<string, string>, identity: {
+    name: string;
+    email: string;
+} | null): Record<string, string>;
+type StartupRetryOptions = {
+    attempts?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    onRetry?: (event: {
+        label: string;
+        attempt: number;
+        attempts: number;
+        delayMs: number;
+        error: unknown;
+    }) => void;
+};
+declare function startupRetryOptions(settings: Settings): Required<Omit<StartupRetryOptions, "onRetry">>;
+declare function retryStartupDependency<T>(label: string, operation: () => Promise<T>, options?: StartupRetryOptions): Promise<T>;
+declare function sandboxEnvironmentVariableNames(settings: Settings): string[];
+declare function sandboxLifecycleHookIds(settings: Settings): string[];
+declare function parseExposedPorts(raw: string): number[];
+declare function parseMcpServers(raw: string | undefined): unknown[] | undefined;
+declare function parseModelPricingJson(raw: string): Record<string, ModelPricing>;
+declare function parseSandboxWarmRateJson(raw: string): Record<string, number>;
+declare function sandboxWarmRateMicrosPerSecond(settings: Settings, backend: string): number;
+/**
+ * Parse + validate the extra-provider registry JSON. `[]` (or empty/whitespace)
+ * yields an empty list. Surfaces JSON and zod errors prefixed with the env-var
+ * name so a malformed registry fails fast at boot (validateSettings calls this).
+ */
+declare function parseModelProvidersJson(raw: string): RegistryProvider[];
+declare function parseStaticUsageLimitsJson(raw: string): StaticUsageLimitsConfig;
+declare function parseStaticEntitlementsJson(raw: string): EntitlementsConfig;
+/**
+ * The base URL of OpenGeni's own first-party MCP endpoint, as a `{workspaceId}`
+ * template — the SINGLE source of truth for the `opengeniMcpUrl`-or-loopback
+ * decision. Every site that needs the first-party MCP base (config's tool
+ * registry here, and the worker-side `firstPartyMcpServerUrlForRun` /
+ * `firstPartyMcpUrls` in @opengeni/runtime) MUST route through this so the
+ * default lives in exactly one place.
+ *
+ * BINDING CONTRACT (`opengeniMcpUrl`):
+ *   - STANDALONE (unset): falls back to the loopback default
+ *     `http://127.0.0.1:${apiPort}/v1/workspaces/{workspaceId}/mcp` — the worker
+ *     and API are in/next to the same host:port, so loopback resolves the
+ *     workspace-scoped MCP. Byte-for-byte today's behavior.
+ *   - EMBEDDED / MOUNTED (must set): when OpenGeni's API is mounted as a host
+ *     sub-app under a prefix (e.g. `https://host/og/v1/...`), the loopback
+ *     default is WRONG — the worker runs in the host process and `127.0.0.1:
+ *     ${apiPort}` is not where the mounted, sandbox-routable MCP lives. The host
+ *     MUST set `OPENGENI_MCP_URL` to the externally/sandbox-routable base (a
+ *     `{workspaceId}` template, or a concrete base that gets re-scoped). This is
+ *     the one binding a mounted embed cannot leave unset.
+ */
+declare function firstPartyMcpBaseUrl(settings: Settings): string;
+/**
+ * Resolve the secret used to sign/verify scoped stream tokens (master-spine
+ * §C.3). Falls back to `delegationSecret` (the same HMAC envelope family —
+ * `ogs_` vs `ogd_` prefix) so a deployment that already carries a delegation
+ * secret does not need a second one. Returns undefined when neither is set,
+ * which drives the graceful-degrade (DesktopStream.transport:null).
+ */
+declare function resolveStreamTokenSecret(settings: Settings): string | undefined;
+/**
+ * True iff the desktop pixel plane must GRACEFULLY DEGRADE because desktop is
+ * enabled but no stream-token secret is resolvable (I8/OD-8). When true,
+ * negotiateCapabilities forces DesktopStream.transport:null.
+ */
+declare function streamTokenDegraded(settings: Settings): boolean;
+/**
+ * Resolve the secret the control plane signs the enrollment bearer credential
+ * with (the `oge_` envelope the agent presents back — M5/dossier §10.2). Falls
+ * back to `delegationSecret` (the same HMAC envelope family) so a deployment that
+ * already carries a delegation secret needs no second one. Returns undefined when
+ * neither is set; when selfhosted is enabled but this is undefined, the poll route
+ * reports the credential plane disabled (graceful degrade, never a 500). NEVER log
+ * the returned value.
+ */
+declare function resolveEnrollmentSigningSecret(settings: Settings): string | undefined;
+/**
+ * Resolve the HMAC secret the control plane signs the agent's relay PRODUCER token
+ * with (the `ogr_` envelope; M8b/dossier §10.5). The RELAY verifies the producer
+ * token with the SAME secret (injected into the relay via env). Prefers an explicit
+ * `selfhostedRelayTokenSecret`, then the `streamTokenSecret` (the relay already
+ * needs that one to verify the viewer's `ogs_` token, so a single secret can back
+ * both planes), then `delegationSecret` (same HMAC family). Returns undefined when
+ * none is set — the enrollment poll then returns an empty relayToken (graceful
+ * degrade; the stream plane is unavailable until configured). NEVER log the value.
+ */
+declare function resolveRelayTokenSecret(settings: Settings): string | undefined;
+/**
+ * The resolved NATS auth-callout responder config (M-AUTH). Present only when the
+ * callout plane is FULLY configured: the account signing seed + the responder's own
+ * login. When any piece is missing this returns null and the responder does not
+ * start (selfhosted agents cannot connect — a graceful disabled state, never a boot
+ * crash). The returned `accountSeed` is a secret; NEVER log it.
+ */
+interface NatsCalloutConfig {
+    /** The callout account SIGNING seed (`SA...`) — signs the user + response JWTs. */
+    accountSeed: string;
+    /** The target account NAME the user is placed into (the response `aud`). */
+    accountName: string;
+    /** The responder's NATS login (an `auth_callout.auth_users` user). */
+    user: string;
+    password: string;
+}
+declare function resolveNatsCalloutConfig(settings: Settings): NatsCalloutConfig | null;
+/**
+ * The PRIVILEGED control-plane NATS login (api/worker). Present only when BOTH a
+ * user and password are set; otherwise null and the bus connects anonymously (local
+ * dev / a NATS without auth_callout). When the callout plane is on, this is the
+ * static account user permitted to request `agent.*.rpc`.
+ */
+interface NatsControlPlaneAuth {
+    user: string;
+    password: string;
+}
+declare function resolveNatsControlPlaneAuth(settings: Settings): NatsControlPlaneAuth | null;
+
+export { AGENT_INSTRUCTIONS_CORE_PLACEHOLDER, type ConfiguredModel, type ContextCompactionMode, DEFAULT_AGENT_INSTRUCTIONS, type EntitlementsConfig, type McpServerConfig, type ModelPricing, ModelProviderApi, type ModelUsageInput, type NatsCalloutConfig, type NatsControlPlaneAuth, type RegistryProvider, RegistryProviderKind, type ResolvedModelProvider, SANDBOX_REQUIRED_ENV, type SandboxRequiredEnv, type Settings, type StartupRetryOptions, type StaticUsageLimitsConfig, applyGitAuthPointerEnvironment, calculateModelUsageCostMicros, collectGitIdentityEnvironment, collectSandboxEnvironment, configuredAllowedModels, configuredAllowedReasoningEfforts, configuredEntitlements, configuredModelPricing, configuredModels, configuredProviders, configuredStaticUsageLimits, contextInputBudgetTokens, contextServerCompactThreshold, dbSearchPath, defaultModelPricing, effectiveModalIdleTimeoutSeconds, environmentsEncryptionKeyBytes, firstPartyMcpBaseUrl, getSettings, hasGitHubRepositorySelection, parseExposedPorts, parseMcpServers, parseModelPricingJson, parseModelProvidersJson, parseSandboxWarmRateJson, parseStaticEntitlementsJson, parseStaticUsageLimitsJson, requiredSandboxEnvForBackend, resolveContextCompactionMode, resolveEnrollmentSigningSecret, resolveModelProvider, resolveNatsCalloutConfig, resolveNatsControlPlaneAuth, resolveProviderApiKey, resolveRelayTokenSecret, resolveStreamTokenSecret, retryStartupDependency, sandboxEnvironmentVariableNames, sandboxLifecycleHookIds, sandboxPreparationProfiles, sandboxWarmRateMicrosPerSecond, stableSandboxEnvironmentForRun, startupRetryOptions, streamTokenDegraded };