@opengeni/config 0.6.2 → 0.7.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Entitlements, SandboxBackend, StaticUsageLimits, ReasoningEffort } from '@opengeni/contracts';
+import { Entitlements, TurnExecutionModelSourceV1, TurnExecutionReasoningSourceV1, SandboxBackend, StaticUsageLimits, TurnExecutionPolicyV1, ReasoningEffort } from '@opengeni/contracts';
 import { z } from 'zod';
 
 declare const sandboxPreparationProfiles: Record<string, {
@@ -107,6 +107,7 @@ declare const SettingsSchema: z.ZodObject<{
     delegationSecret: z.ZodOptional<z.ZodString>;
     streamTokenSecret: z.ZodOptional<z.ZodString>;
     streamControlEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    sessionTurnToolReplacementEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     toolspaceEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     toolspaceMaxCallsPerTurn: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     ogtoolPackageSpec: z.ZodOptional<z.ZodString>;
@@ -115,6 +116,7 @@ declare const SettingsSchema: z.ZodObject<{
     integrationsStateSecret: z.ZodOptional<z.ZodString>;
     integrationsAllowPrivateNetworkTargets: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     integrationsOauthClientsJson: z.ZodDefault<z.ZodString>;
+    maxNestedAgentDepth: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     goalMaxAutoContinuations: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     goalNoProgressLimit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     agentMaxModelCallsPerTurn: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
@@ -147,6 +149,8 @@ declare const SettingsSchema: z.ZodObject<{
     codexProductSku: z.ZodOptional<z.ZodString>;
     codexToolSearchEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     codexCredentialLeasingEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    codexFleetPolicyShadowEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    codexRotationNearExhaustionPct: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     openaiReasoningEffort: z.ZodDefault<z.ZodEnum<{
         none: "none";
         minimal: "minimal";
@@ -262,6 +266,7 @@ declare const SettingsSchema: z.ZodObject<{
     vercelTeamId: z.ZodOptional<z.ZodString>;
     vercelRuntime: z.ZodOptional<z.ZodString>;
     sandboxOwnershipEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
+    rigVerificationLeaseOwnershipEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     sandboxLazyProvisionEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     sandboxSelfhostedEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     agentOpStreamEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
@@ -353,7 +358,7 @@ declare const SettingsSchema: z.ZodObject<{
         allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
         timeoutMs: z.ZodOptional<z.ZodNumber>;
         cacheToolsList: z.ZodDefault<z.ZodBoolean>;
-        requireApproval: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        requireApproval: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>]>>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         connectionRef: z.ZodOptional<z.ZodObject<{
             connectionId: z.ZodOptional<z.ZodString>;
@@ -399,6 +404,13 @@ type ModelPricing = {
     outputMicrosPerMillionTokens: number;
     marginBps?: number | undefined;
 };
+type ModelPricingScheduleV1 = {
+    default: ModelPricing;
+    inputTokenTiers?: Array<{
+        minimumInputTokens: number;
+        pricing: ModelPricing;
+    }> | undefined;
+};
 type ModelUsageInput = {
     inputTokens?: number | undefined;
     outputTokens?: number | undefined;
@@ -408,6 +420,165 @@ type ModelUsageInput = {
 };
 type StaticUsageLimitsConfig = StaticUsageLimits;
 type EntitlementsConfig = Entitlements;
+declare const CapabilitySupportV1: z.ZodEnum<{
+    unknown: "unknown";
+    supported: "supported";
+    unsupported: "unsupported";
+}>;
+type CapabilitySupportV1 = z.infer<typeof CapabilitySupportV1>;
+declare const CapabilityStateV1Schema: z.ZodObject<{
+    upstream: z.ZodEnum<{
+        unknown: "unknown";
+        supported: "supported";
+        unsupported: "unsupported";
+    }>;
+    runnable: z.ZodBoolean;
+}, z.core.$strip>;
+type CapabilityStateV1 = z.infer<typeof CapabilityStateV1Schema>;
+declare const ModelCapabilitiesV1Schema: z.ZodObject<{
+    reasoning: z.ZodObject<{
+        upstream: z.ZodEnum<{
+            unknown: "unknown";
+            supported: "supported";
+            unsupported: "unsupported";
+        }>;
+        runnable: z.ZodBoolean;
+        efforts: z.ZodArray<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>>;
+        defaultEffort: z.ZodNullable<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>>;
+        required: z.ZodBoolean;
+    }, z.core.$strip>;
+    functionCalling: z.ZodObject<{
+        upstream: z.ZodEnum<{
+            unknown: "unknown";
+            supported: "supported";
+            unsupported: "unsupported";
+        }>;
+        runnable: z.ZodBoolean;
+    }, z.core.$strip>;
+    structuredOutput: z.ZodObject<{
+        upstream: z.ZodEnum<{
+            unknown: "unknown";
+            supported: "supported";
+            unsupported: "unsupported";
+        }>;
+        runnable: z.ZodBoolean;
+    }, z.core.$strip>;
+    hostedTools: z.ZodObject<{
+        webSearch: z.ZodObject<{
+            upstream: z.ZodEnum<{
+                unknown: "unknown";
+                supported: "supported";
+                unsupported: "unsupported";
+            }>;
+            runnable: z.ZodBoolean;
+        }, z.core.$strip>;
+        xSearch: z.ZodObject<{
+            upstream: z.ZodEnum<{
+                unknown: "unknown";
+                supported: "supported";
+                unsupported: "unsupported";
+            }>;
+            runnable: z.ZodBoolean;
+        }, z.core.$strip>;
+        codeExecution: z.ZodObject<{
+            upstream: z.ZodEnum<{
+                unknown: "unknown";
+                supported: "supported";
+                unsupported: "unsupported";
+            }>;
+            runnable: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    inputModalities: z.ZodArray<z.ZodEnum<{
+        text: "text";
+        image: "image";
+        audio: "audio";
+    }>>;
+    outputModalities: z.ZodArray<z.ZodEnum<{
+        text: "text";
+        image: "image";
+        audio: "audio";
+    }>>;
+    transports: z.ZodObject<{
+        sse: z.ZodObject<{
+            upstream: z.ZodEnum<{
+                unknown: "unknown";
+                supported: "supported";
+                unsupported: "unsupported";
+            }>;
+            runnable: z.ZodBoolean;
+        }, z.core.$strip>;
+        responsesWebSocket: z.ZodObject<{
+            upstream: z.ZodEnum<{
+                unknown: "unknown";
+                supported: "supported";
+                unsupported: "unsupported";
+            }>;
+            runnable: z.ZodBoolean;
+        }, z.core.$strip>;
+        realtimeAudio: z.ZodObject<{
+            upstream: z.ZodEnum<{
+                unknown: "unknown";
+                supported: "supported";
+                unsupported: "unsupported";
+            }>;
+            runnable: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    latencyModes: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            standard: "standard";
+            priority: "priority";
+            fast: "fast";
+        }>;
+        upstream: z.ZodEnum<{
+            unknown: "unknown";
+            supported: "supported";
+            unsupported: "unsupported";
+        }>;
+        runnable: z.ZodBoolean;
+        billingMultiplierBps: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ModelCapabilitiesV1 = z.infer<typeof ModelCapabilitiesV1Schema>;
+type ModelDeploymentV1 = {
+    upstreamModelId: string;
+    wireApi: ModelProviderApi;
+};
+type ModelExecutionLimitsV1 = {
+    contextWindowTokens: number | null;
+    effectiveContextWindowTokens: number | null;
+    autoCompactTokenLimit: number | null;
+    toolOutputTruncationTokens: number | null;
+};
+type CredentialSourceV1 = {
+    kind: "deployment";
+    mechanism: "api_key" | "azure_ad_bearer";
+} | {
+    kind: "connected_subscription";
+    provider: "codex";
+} | {
+    kind: "workspace_connection";
+    mechanism: "api_key";
+};
+type BillingAttributionV1 = {
+    upstreamPayer: "deployment" | "workspace" | "connected_subscription";
+    metering: "opengeni_credits" | "external";
+};
 /**
  * Wire API a provider speaks. The built-in OpenAI/Azure provider always uses
  * "responses" (the OpenAI Responses API). Extra registry providers default to
@@ -447,8 +618,14 @@ declare const RegistryProviderSchema: z.ZodObject<{
     apiKeyEnv: z.ZodOptional<z.ZodString>;
     defaultQuery: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     defaultHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    publicDefaultQueryNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    publicDefaultHeaderNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    credentialSource: z.ZodOptional<z.ZodNever>;
+    billing: z.ZodOptional<z.ZodNever>;
     models: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
+        upstreamModelId: z.ZodOptional<z.ZodString>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
         label: z.ZodOptional<z.ZodString>;
         contextWindowTokens: z.ZodOptional<z.ZodNumber>;
         effectiveContextWindowTokens: z.ZodOptional<z.ZodNumber>;
@@ -456,12 +633,149 @@ declare const RegistryProviderSchema: z.ZodObject<{
         toolOutputTruncationTokens: z.ZodOptional<z.ZodNumber>;
         reasoningEffort: z.ZodOptional<z.ZodBoolean>;
         hostedWebSearch: z.ZodOptional<z.ZodBoolean>;
-        pricing: z.ZodOptional<z.ZodObject<{
+        capabilities: z.ZodOptional<z.ZodObject<{
+            reasoning: z.ZodObject<{
+                upstream: z.ZodEnum<{
+                    unknown: "unknown";
+                    supported: "supported";
+                    unsupported: "unsupported";
+                }>;
+                runnable: z.ZodBoolean;
+                efforts: z.ZodArray<z.ZodEnum<{
+                    none: "none";
+                    minimal: "minimal";
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    xhigh: "xhigh";
+                }>>;
+                defaultEffort: z.ZodNullable<z.ZodEnum<{
+                    none: "none";
+                    minimal: "minimal";
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    xhigh: "xhigh";
+                }>>;
+                required: z.ZodBoolean;
+            }, z.core.$strip>;
+            functionCalling: z.ZodObject<{
+                upstream: z.ZodEnum<{
+                    unknown: "unknown";
+                    supported: "supported";
+                    unsupported: "unsupported";
+                }>;
+                runnable: z.ZodBoolean;
+            }, z.core.$strip>;
+            structuredOutput: z.ZodObject<{
+                upstream: z.ZodEnum<{
+                    unknown: "unknown";
+                    supported: "supported";
+                    unsupported: "unsupported";
+                }>;
+                runnable: z.ZodBoolean;
+            }, z.core.$strip>;
+            hostedTools: z.ZodObject<{
+                webSearch: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        unknown: "unknown";
+                        supported: "supported";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+                xSearch: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        unknown: "unknown";
+                        supported: "supported";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+                codeExecution: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        unknown: "unknown";
+                        supported: "supported";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            inputModalities: z.ZodArray<z.ZodEnum<{
+                text: "text";
+                image: "image";
+                audio: "audio";
+            }>>;
+            outputModalities: z.ZodArray<z.ZodEnum<{
+                text: "text";
+                image: "image";
+                audio: "audio";
+            }>>;
+            transports: z.ZodObject<{
+                sse: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        unknown: "unknown";
+                        supported: "supported";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+                responsesWebSocket: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        unknown: "unknown";
+                        supported: "supported";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+                realtimeAudio: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        unknown: "unknown";
+                        supported: "supported";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            latencyModes: z.ZodArray<z.ZodObject<{
+                id: z.ZodEnum<{
+                    standard: "standard";
+                    priority: "priority";
+                    fast: "fast";
+                }>;
+                upstream: z.ZodEnum<{
+                    unknown: "unknown";
+                    supported: "supported";
+                    unsupported: "unsupported";
+                }>;
+                runnable: z.ZodBoolean;
+                billingMultiplierBps: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        pricing: z.ZodOptional<z.ZodUnion<readonly [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.ZodObject<{
+            default: z.ZodObject<{
+                inputMicrosPerMillionTokens: z.ZodNumber;
+                cachedInputMicrosPerMillionTokens: z.ZodOptional<z.ZodNumber>;
+                outputMicrosPerMillionTokens: z.ZodNumber;
+                marginBps: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            inputTokenTiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                minimumInputTokens: z.ZodNumber;
+                pricing: 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>]>>;
+        credentialSource: z.ZodOptional<z.ZodNever>;
+        billing: z.ZodOptional<z.ZodNever>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type RegistryProvider = z.infer<typeof RegistryProviderSchema>;
@@ -492,14 +806,28 @@ interface ResolvedModelProvider {
     apiKey?: string | undefined;
     defaultQuery?: Record<string, string> | undefined;
     defaultHeaders?: Record<string, string> | undefined;
+    publicDefaultQueryNames?: string[] | undefined;
+    publicDefaultHeaderNames?: string[] | undefined;
+    credentialSource: CredentialSourceV1;
+    billing: BillingAttributionV1;
 }
 /** A single exposed model + the provider that serves it. */
 interface ConfiguredModel {
+    schemaVersion: 1;
     id: string;
+    aliases: string[];
     label: string;
     providerId: string;
     providerLabel: string;
     api: ModelProviderApi;
+    upstreamModelId: string;
+    deployment: ModelDeploymentV1;
+    executionLimits: ModelExecutionLimitsV1;
+    credentialSource: CredentialSourceV1;
+    billing: BillingAttributionV1;
+    capabilities: ModelCapabilitiesV1;
+    pricing?: ModelPricingScheduleV1 | undefined;
+    definitionVersion: string;
     contextWindowTokens?: number | undefined;
     effectiveContextWindowTokens?: number | undefined;
     autoCompactTokenLimit?: number | undefined;
@@ -554,6 +882,13 @@ declare function builtinProviderId(settings: Pick<Settings, "openaiProvider">):
  * id — validateSettings rejects that at boot.
  */
 declare function configuredProviders(settings: Settings): ResolvedModelProvider[];
+/**
+ * Pure catalog overlay for a workspace whose existing Codex connection seam
+ * reports ready. This describes product/provider identity only; it does not
+ * select, lease, refresh, or expose a concrete credential; those runtime
+ * operations remain owned by the credential allocator.
+ */
+declare function withCodexCatalogProvider(settings: Settings): Settings;
 /**
  * The provider identity a model id resolves to, for workspace model-policy
  * evaluation — MUST agree with the real router (resolveTurnModel /
@@ -577,6 +912,8 @@ declare function policyProviderIdForModel(settings: Settings, modelId: string):
  * first and the built-in allow-list takes precedence over registry entries.
  */
 declare function configuredModels(settings: Settings): ConfiguredModel[];
+/** Resolve a known canonical id or alias. Unknown strings are returned unchanged. */
+declare function canonicalizeConfiguredModelId(settings: Settings, modelId: string): string;
 /**
  * Allowed model ids in selection order. Reimplemented on top of
  * configuredModels so it is the union of the built-in allow-list and every
@@ -595,12 +932,46 @@ declare function resolveModelProvider(settings: Settings, modelId: string): {
     provider: ResolvedModelProvider;
     model: ConfiguredModel;
 } | undefined;
+type ResolveTurnExecutionPolicyV1Input = {
+    /** Effective persisted turn model. Aliases are accepted and canonicalized. */
+    modelId: string;
+    /** Exact caller-supplied input before canonicalization, only for explicit switches. */
+    requestedModelId: string | null;
+    modelSource: TurnExecutionModelSourceV1;
+    reasoningEffort: Settings["openaiReasoningEffort"];
+    reasoningSource: TurnExecutionReasoningSourceV1;
+};
+/**
+ * Build a trusted, secret-safe execution policy from the normalized catalog.
+ * The Codex overlay here contains static product/provider identity only; it
+ * neither proves readiness nor chooses, decrypts, leases, or exposes an account.
+ */
+declare function resolveTurnExecutionPolicyV1(settings: Settings, input: ResolveTurnExecutionPolicyV1Input): TurnExecutionPolicyV1;
+/**
+ * Parse-time validation lives in @opengeni/contracts; this verifier binds a
+ * present snapshot to the current executable definition and exact turn row.
+ * Any deployment/provider drift fails before a provider or compaction call.
+ */
+declare function assertTurnExecutionPolicyMatchesConfigV1(settings: Settings, policy: TurnExecutionPolicyV1, expected: {
+    modelId: string;
+    reasoningEffort: Settings["openaiReasoningEffort"];
+}): {
+    policy: TurnExecutionPolicyV1;
+    provider: ResolvedModelProvider;
+    model: ConfiguredModel;
+};
 /**
- * Effective per-model pricing. Merge order (later wins):
- *   defaultModelPricing → registry model `pricing` entries (keyed by model id)
- *   → parseModelPricingJson(settings.modelPricingJson) (explicit JSON wins).
+ * Effective per-model pricing schedules. Merge order (later wins): built-in
+ * flat defaults → registry model flat/scheduled pricing → explicit legacy flat
+ * OPENGENI_MODEL_PRICING_JSON. The explicit legacy map intentionally replaces
+ * a registry schedule with one flat default so its historical precedence stays
+ * exact.
  */
+declare function configuredModelPricingSchedules(settings: Settings): Record<string, ModelPricingScheduleV1>;
+/** Legacy flat projection: returns the default/below-threshold price. */
 declare function configuredModelPricing(settings: Settings): Record<string, ModelPricing>;
+/** Select the per-provider-request price at an exact input-token threshold. */
+declare function selectModelPricing(schedule: ModelPricingScheduleV1, inputTokens: number): ModelPricing;
 /**
  * Usable input-token budget: an explicit model-catalog effective window when
  * available, otherwise the deployment window minus its output reserve.
@@ -835,4 +1206,4 @@ interface NatsControlPlaneAuth {
 }
 declare function resolveNatsControlPlaneAuth(settings: Settings): NatsControlPlaneAuth | null;
 
-export { AGENT_INSTRUCTIONS_CORE_PLACEHOLDER, type ConfiguredModel, DEFAULT_AGENT_INSTRUCTIONS, type EntitlementsConfig, type IntegrationOAuthClientConfig, IntegrationOAuthClientConfigSchema, type McpServerConfig, type McpServerConnectionRef, McpServerConnectionRefSchema, 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, type TemporalConnectionOptions, type TemporalTlsConnectionConfig, applyGitAuthPointerEnvironment, builtinProviderId, calculateModelUsageCostMicros, collectGitIdentityEnvironment, collectSandboxEnvironment, configuredAllowedModels, configuredAllowedReasoningEfforts, configuredEntitlements, configuredModelPricing, configuredModels, configuredProviders, configuredStaticUsageLimits, contextInputBudgetTokens, dbSearchPath, defaultModelPricing, effectiveModalIdleTimeoutSeconds, environmentsEncryptionKeyBytes, firstPartyMcpBaseUrl, firstPartyMcpWorkspaceUrl, getSettings, hasGitCredentialRepositorySelection, hasGitHubRepositorySelection, parseExposedPorts, parseIntegrationsOauthClientsJson, parseMcpServers, parseModelPricingJson, parseModelProvidersJson, parseSandboxWarmRateJson, parseStaticEntitlementsJson, parseStaticUsageLimitsJson, policyProviderIdForModel, requiredSandboxEnvForBackend, resolveEnrollmentSigningSecret, resolveModelProvider, resolveNatsCalloutConfig, resolveNatsControlPlaneAuth, resolveProviderApiKey, resolveRelayTokenSecret, resolveStreamTokenSecret, retryStartupDependency, sandboxEnvironmentVariableNames, sandboxLifecycleHookIds, sandboxPreparationProfiles, sandboxWarmRateMicrosPerSecond, settingsWithResolvedModelContext, stableSandboxEnvironmentForRun, startupRetryOptions, streamTokenDegraded, temporalConnectionOptions };
+export { AGENT_INSTRUCTIONS_CORE_PLACEHOLDER, type BillingAttributionV1, type CapabilityStateV1, CapabilityStateV1Schema, CapabilitySupportV1, type ConfiguredModel, type CredentialSourceV1, DEFAULT_AGENT_INSTRUCTIONS, type EntitlementsConfig, type IntegrationOAuthClientConfig, IntegrationOAuthClientConfigSchema, type McpServerConfig, type McpServerConnectionRef, McpServerConnectionRefSchema, type ModelCapabilitiesV1, ModelCapabilitiesV1Schema, type ModelDeploymentV1, type ModelExecutionLimitsV1, type ModelPricing, type ModelPricingScheduleV1, ModelProviderApi, type ModelUsageInput, type NatsCalloutConfig, type NatsControlPlaneAuth, type RegistryProvider, RegistryProviderKind, type ResolveTurnExecutionPolicyV1Input, type ResolvedModelProvider, SANDBOX_REQUIRED_ENV, type SandboxRequiredEnv, type Settings, type StartupRetryOptions, type StaticUsageLimitsConfig, type TemporalConnectionOptions, type TemporalTlsConnectionConfig, applyGitAuthPointerEnvironment, assertTurnExecutionPolicyMatchesConfigV1, builtinProviderId, calculateModelUsageCostMicros, canonicalizeConfiguredModelId, collectGitIdentityEnvironment, collectSandboxEnvironment, configuredAllowedModels, configuredAllowedReasoningEfforts, configuredEntitlements, configuredModelPricing, configuredModelPricingSchedules, configuredModels, configuredProviders, configuredStaticUsageLimits, contextInputBudgetTokens, dbSearchPath, defaultModelPricing, effectiveModalIdleTimeoutSeconds, environmentsEncryptionKeyBytes, firstPartyMcpBaseUrl, firstPartyMcpWorkspaceUrl, getSettings, hasGitCredentialRepositorySelection, hasGitHubRepositorySelection, parseExposedPorts, parseIntegrationsOauthClientsJson, parseMcpServers, parseModelPricingJson, parseModelProvidersJson, parseSandboxWarmRateJson, parseStaticEntitlementsJson, parseStaticUsageLimitsJson, policyProviderIdForModel, requiredSandboxEnvForBackend, resolveEnrollmentSigningSecret, resolveModelProvider, resolveNatsCalloutConfig, resolveNatsControlPlaneAuth, resolveProviderApiKey, resolveRelayTokenSecret, resolveStreamTokenSecret, resolveTurnExecutionPolicyV1, retryStartupDependency, sandboxEnvironmentVariableNames, sandboxLifecycleHookIds, sandboxPreparationProfiles, sandboxWarmRateMicrosPerSecond, selectModelPricing, settingsWithResolvedModelContext, stableSandboxEnvironmentForRun, startupRetryOptions, streamTokenDegraded, temporalConnectionOptions, withCodexCatalogProvider };