@opengeni/core 2.6.3-canary.0 → 2.6.4-canary.0

package/dist/index.js

@@ -208,6 +208,367 @@ function filenameForMimeType(mimeType) {
   }
 }
 
+// src/model-catalog.ts
+import {
+  applyModelCatalogDocument,
+  configuredGatewayWorkspaceProductModelIds,
+  configuredModels,
+  configuredModelNotes,
+  configuredOpenRouterWorkspaceProductModelIds,
+  configuredProviders,
+  validateModelCatalogSettings,
+  withCodexCatalogProvider,
+  withWorkspaceGatewayCatalogProvider,
+  withWorkspaceOpenRouterCatalogProvider,
+  withXaiSubscriptionCatalogProvider,
+  WORKSPACE_GATEWAY_MODEL_ID_PREFIX,
+  WORKSPACE_OPENROUTER_MODEL_ID_PREFIX,
+  WORKSPACE_OPENROUTER_PROVIDER_ID
+} from "@opengeni/config";
+import {
+  evaluateWorkspaceModelPolicy
+} from "@opengeni/contracts";
+import {
+  getDeploymentModelCatalog,
+  getWorkspaceGatewayCustomModelForExecution,
+  getWorkspaceOpenRouterCustomModelForExecution,
+  listWorkspaceGatewayCustomModels,
+  listWorkspaceOpenRouterCustomModels
+} from "@opengeni/db";
+function isWorkspaceGatewayCustomModelId(settings, modelId) {
+  return modelId.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX) && !configuredGatewayWorkspaceProductModelIds(settings).includes(modelId);
+}
+function isWorkspaceOpenRouterCustomModelId(settings, modelId) {
+  return modelId.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX) && !configuredOpenRouterWorkspaceProductModelIds(settings).includes(modelId);
+}
+function workspaceCustomModelReference(settings, modelId) {
+  if (isWorkspaceGatewayCustomModelId(settings, modelId)) {
+    return {
+      providerKind: "vercel_gateway",
+      upstreamModelId: modelId.slice(WORKSPACE_GATEWAY_MODEL_ID_PREFIX.length)
+    };
+  }
+  if (isWorkspaceOpenRouterCustomModelId(settings, modelId)) {
+    return {
+      providerKind: "openrouter",
+      upstreamModelId: modelId.slice(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX.length)
+    };
+  }
+  return null;
+}
+function isWorkspaceCustomModelId(settings, modelId) {
+  return workspaceCustomModelReference(settings, modelId) !== null;
+}
+async function resolveCatalogSettings(db, envSettings) {
+  if (envSettings.modelCatalogSource === "code") {
+    validateModelCatalogSettings(envSettings);
+    return {
+      settings: envSettings,
+      source: "code",
+      version: null,
+      modelNotes: configuredModelNotes(envSettings)
+    };
+  }
+  const row = await getDeploymentModelCatalog(db);
+  if (!row) {
+    throw new Error("database model catalog source is configured but the singleton row is missing");
+  }
+  const settings = applyModelCatalogDocument(envSettings, row.document);
+  validateModelCatalogSettings(settings);
+  return {
+    settings,
+    source: "database",
+    version: row.version,
+    modelNotes: configuredModelNotes(settings)
+  };
+}
+async function resolveWorkspaceCatalogSettings(db, envSettings, input) {
+  const retainedProductModelIds = [
+    ...input.retainedProductModelIds ?? [],
+    input.retainedProductModelId
+  ];
+  const retainedGatewayUpstreamModelIds = retainedProductModelIds.flatMap(
+    (productModelId) => productModelId?.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX) ? [productModelId.slice(WORKSPACE_GATEWAY_MODEL_ID_PREFIX.length)] : []
+  );
+  const retainedOpenRouterUpstreamModelIds = retainedProductModelIds.flatMap(
+    (productModelId) => productModelId?.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX) ? [productModelId.slice(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX.length)] : []
+  );
+  const [
+    resolved,
+    activeGatewayCustomModels,
+    activeOpenRouterCustomModels,
+    retainedGatewayCustomModels,
+    retainedOpenRouterCustomModels
+  ] = await Promise.all([
+    resolveCatalogSettings(db, envSettings),
+    listWorkspaceGatewayCustomModels(db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId
+    }),
+    listWorkspaceOpenRouterCustomModels(db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId
+    }),
+    Promise.all(
+      [...new Set(retainedGatewayUpstreamModelIds)].map(
+        async (upstreamModelId) => await getWorkspaceGatewayCustomModelForExecution(db, {
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          upstreamModelId
+        })
+      )
+    ),
+    Promise.all(
+      [...new Set(retainedOpenRouterUpstreamModelIds)].map(
+        async (upstreamModelId) => await getWorkspaceOpenRouterCustomModelForExecution(db, {
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          upstreamModelId
+        })
+      )
+    )
+  ]);
+  const includeRetainedModels = (activeModels, retainedModels) => {
+    const customModels = [...activeModels];
+    const includedUpstreamModelIds = new Set(activeModels.map((model) => model.upstreamModelId));
+    for (const retainedCustomModel of retainedModels) {
+      if (retainedCustomModel && !includedUpstreamModelIds.has(retainedCustomModel.upstreamModelId)) {
+        customModels.push(retainedCustomModel);
+        includedUpstreamModelIds.add(retainedCustomModel.upstreamModelId);
+      }
+    }
+    return customModels;
+  };
+  const gatewayCustomModels = includeRetainedModels(
+    activeGatewayCustomModels,
+    retainedGatewayCustomModels
+  );
+  const openRouterCustomModels = includeRetainedModels(
+    activeOpenRouterCustomModels,
+    retainedOpenRouterCustomModels
+  );
+  return {
+    ...resolved,
+    settings: withWorkspaceOpenRouterCatalogProvider(
+      withWorkspaceGatewayCatalogProvider(resolved.settings, gatewayCustomModels),
+      openRouterCustomModels
+    )
+  };
+}
+var MODEL_CREDENTIAL_READINESS_OBSERVATION_MAX_AGE_MS = 5 * 6e4;
+function modelDefinitionRunnable(model) {
+  return model.capabilities.inputModalities.includes("text") && model.capabilities.outputModalities.includes("text") && model.capabilities.transports.sse.runnable;
+}
+function observedCredentialReadiness(input) {
+  if (!input.observation) {
+    return {
+      status: "not_ready",
+      reason: "prerequisites_missing",
+      basis: input.basis,
+      checkedAt: null
+    };
+  }
+  const checkedAtMs = Date.parse(input.observation.checkedAt);
+  if (!Number.isFinite(checkedAtMs)) {
+    return {
+      status: "error",
+      reason: "resolver_error",
+      basis: input.basis,
+      checkedAt: null
+    };
+  }
+  const checkedAt = new Date(checkedAtMs).toISOString();
+  if (Math.abs(input.nowMs - checkedAtMs) > input.maxAgeMs) {
+    return {
+      status: "not_ready",
+      reason: "observation_stale",
+      basis: input.basis,
+      checkedAt
+    };
+  }
+  if (input.observation.status === "ready") {
+    return { status: "ready", reason: null, basis: input.basis, checkedAt };
+  }
+  if (input.observation.status === "not_ready") {
+    return {
+      status: "not_ready",
+      reason: input.observation.reason === "needs_reauth" ? "needs_reauth" : "prerequisites_missing",
+      basis: input.basis,
+      checkedAt
+    };
+  }
+  return {
+    status: "error",
+    reason: "resolver_error",
+    basis: input.basis,
+    checkedAt
+  };
+}
+function credentialReadinessFor(input) {
+  const source = input.model.credentialSource;
+  if (source.kind === "connected_subscription") {
+    const active = source.provider === "xai" ? input.xaiSubscriptionActive : input.codexSubscriptionActive;
+    return active ? { status: "ready", reason: null, basis: "connection", checkedAt: null } : {
+      status: "not_ready",
+      reason: "needs_reauth",
+      basis: "connection",
+      checkedAt: null
+    };
+  }
+  if (source.kind === "workspace_connection") {
+    const connectionActive = input.model.providerId === WORKSPACE_OPENROUTER_PROVIDER_ID ? input.workspaceOpenRouterConnectionActive : input.workspaceGatewayConnectionActive;
+    return connectionActive ? { status: "ready", reason: null, basis: "connection", checkedAt: null } : {
+      status: "not_ready",
+      reason: "needs_reauth",
+      basis: "connection",
+      checkedAt: null
+    };
+  }
+  if (source.kind === "deployment" && source.mechanism === "none") {
+    return { status: "ready", reason: null, basis: "configuration", checkedAt: null };
+  }
+  if (source.kind === "deployment" && source.mechanism === "api_key") {
+    return input.provider?.apiKey ? { status: "ready", reason: null, basis: "configuration", checkedAt: null } : {
+      status: "not_ready",
+      reason: "missing_credential",
+      basis: "configuration",
+      checkedAt: null
+    };
+  }
+  return observedCredentialReadiness({
+    observation: input.observation,
+    basis: "resolver",
+    nowMs: input.nowMs,
+    maxAgeMs: input.maxAgeMs
+  });
+}
+function isXaiGrokModel(model) {
+  return model.providerId === "xai" && model.id.startsWith("xai/grok-");
+}
+function observationTimestamp(observation) {
+  if (!observation || typeof observation.checkedAt !== "string") {
+    return { checkedAt: null, checkedAtMs: null };
+  }
+  const checkedAtMs = Date.parse(observation.checkedAt);
+  if (!Number.isFinite(checkedAtMs)) {
+    return { checkedAt: null, checkedAtMs: null };
+  }
+  return { checkedAt: new Date(checkedAtMs).toISOString(), checkedAtMs };
+}
+function xaiGrokAvailabilityFor(input) {
+  const { checkedAt, checkedAtMs } = observationTimestamp(input.observation);
+  const freshSuccessfulObservation = input.observation?.status === "available" && input.observation.reason === null && checkedAtMs !== null && checkedAtMs <= input.nowMs && input.nowMs - checkedAtMs <= input.maxAgeMs;
+  if (freshSuccessfulObservation) {
+    return {
+      status: "available",
+      selectable: true,
+      reason: null,
+      checkedAt
+    };
+  }
+  return {
+    status: "unavailable",
+    selectable: false,
+    reason: input.observation?.status === "unavailable" ? input.observation.reason ?? "provider_unhealthy" : "provider_unhealthy",
+    checkedAt
+  };
+}
+function availabilityFor(input) {
+  if (!modelDefinitionRunnable(input.model)) {
+    return {
+      status: "unavailable",
+      selectable: false,
+      reason: "unsupported",
+      checkedAt: null
+    };
+  }
+  if (input.credentialReadiness.status !== "ready") {
+    return {
+      status: "unavailable",
+      selectable: false,
+      reason: input.credentialReadiness.reason === "missing_credential" ? "missing_credential" : input.credentialReadiness.reason === "needs_reauth" ? "needs_reauth" : "credential_not_ready",
+      checkedAt: input.credentialReadiness.checkedAt
+    };
+  }
+  if (!input.policyAllowed) {
+    return {
+      status: "unavailable",
+      selectable: false,
+      reason: "policy_blocked",
+      checkedAt: null
+    };
+  }
+  if (isXaiGrokModel(input.model)) {
+    return xaiGrokAvailabilityFor({
+      observation: input.observation,
+      nowMs: input.nowMs,
+      maxAgeMs: input.maxAgeMs
+    });
+  }
+  if (!input.observation) {
+    return { status: "unknown", selectable: true, reason: null, checkedAt: null };
+  }
+  if (input.observation.status === "unavailable") {
+    return {
+      status: "unavailable",
+      selectable: false,
+      reason: input.observation.reason ?? "provider_unhealthy",
+      checkedAt: input.observation.checkedAt
+    };
+  }
+  return {
+    status: input.observation.status,
+    selectable: true,
+    reason: null,
+    checkedAt: input.observation.checkedAt
+  };
+}
+function resolveWorkspaceModelSelection(input) {
+  const codexSettings = input.settings.codexSubscriptionEnabled ? withCodexCatalogProvider(input.settings) : input.settings;
+  const xaiSettings = input.settings.supergrokSubscriptionEnabled ? withXaiSubscriptionCatalogProvider(codexSettings) : codexSettings;
+  const catalogSettings = withWorkspaceOpenRouterCatalogProvider(
+    withWorkspaceGatewayCatalogProvider(xaiSettings, input.workspaceGatewayCustomModels ?? []),
+    input.workspaceOpenRouterCustomModels ?? []
+  );
+  const providers = new Map(
+    configuredProviders(catalogSettings).map((provider) => [provider.id, provider])
+  );
+  const requestedNowMs = input.now?.getTime();
+  const nowMs = typeof requestedNowMs === "number" && Number.isFinite(requestedNowMs) ? requestedNowMs : Date.now();
+  const maxAgeMs = typeof input.credentialReadinessMaxAgeMs === "number" && Number.isFinite(input.credentialReadinessMaxAgeMs) && input.credentialReadinessMaxAgeMs >= 0 ? input.credentialReadinessMaxAgeMs : MODEL_CREDENTIAL_READINESS_OBSERVATION_MAX_AGE_MS;
+  return configuredModels(catalogSettings).map((model) => {
+    const provider = providers.get(model.providerId);
+    const policyAllowed = evaluateWorkspaceModelPolicy(input.policy, {
+      providerId: model.providerId,
+      modelId: model.id
+    }).allowed;
+    const credentialReadiness = credentialReadinessFor({
+      model,
+      provider,
+      codexSubscriptionActive: input.codexSubscriptionActive,
+      xaiSubscriptionActive: input.xaiSubscriptionActive === true,
+      workspaceGatewayConnectionActive: input.workspaceGatewayConnectionActive === true,
+      workspaceOpenRouterConnectionActive: input.workspaceOpenRouterConnectionActive === true,
+      observation: input.credentialReadinessObservations?.[model.definitionVersion],
+      nowMs,
+      maxAgeMs
+    });
+    return {
+      model,
+      credentialReadiness,
+      policyAllowed,
+      availability: availabilityFor({
+        model,
+        credentialReadiness,
+        policyAllowed,
+        observation: input.observations?.[model.definitionVersion],
+        nowMs,
+        maxAgeMs
+      })
+    };
+  });
+}
+
 // src/sandbox/fleet.ts
 import {
   authorizePersonalMachineForAttempt,
@@ -2074,7 +2435,10 @@ async function resolveSessionAuthorizationActor(db, grant) {
 }
 
 // src/billing/limits.ts
-import { configuredStaticUsageLimits, resolveModelProvider } from "@opengeni/config";
+import {
+  configuredStaticUsageLimits,
+  resolveModelProviderForTurn
+} from "@opengeni/config";
 import {
   countActiveApiKeysForWorkspace,
   countActiveOrganizationApiKeysForAccount,
@@ -2086,6 +2450,18 @@ import {
   sumUsageQuantity
 } from "@opengeni/db";
 import { HTTPException as HTTPException2 } from "hono/http-exception";
+function modelFundingForAdmission(settings, model, codexBilled) {
+  const resolvedModel = model ? resolveModelProviderForTurn(settings, model)?.model : null;
+  const codexSubscriptionModel = resolvedModel?.credentialSource.kind === "connected_subscription" && resolvedModel.credentialSource.provider === "codex";
+  return {
+    // A Codex namespace/definition never bypasses credits by itself: the live
+    // workspace credential predicate above remains authoritative. SuperGrok's
+    // static overlay is likewise secret-free; its worker/provider admission
+    // owns live account selection before any upstream request can occur.
+    fundedWithoutCredits: codexBilled || resolvedModel != null && !codexSubscriptionModel && resolvedModel.cost !== "credits",
+    countsTowardTokenCap: !codexBilled && resolvedModel != null && resolvedModel.billing.upstreamPayer === "deployment"
+  };
+}
 async function requireLimit(deps, input) {
   const decision = await checkLimit(deps, input);
   if (decision.allowed) {
@@ -2102,19 +2478,22 @@ async function checkLimit(deps, input) {
     workspaceId: input.workspaceId,
     model: input.model
   }) : false;
-  const credentialFreeExternal = input.model ? (() => {
-    const resolved = resolveModelProvider(deps.settings, input.model);
-    return resolved?.model.billing.metering === "external" && resolved.model.credentialSource.kind === "deployment" && resolved.model.credentialSource.mechanism === "none";
-  })() : false;
-  const externallyBilled = codexBilled || credentialFreeExternal;
-  const creditDecision = await checkCreditBalance(deps, input, externallyBilled);
+  const { fundedWithoutCredits, countsTowardTokenCap } = modelFundingForAdmission(
+    deps.settings,
+    input.model,
+    codexBilled
+  );
+  const creditDecision = await checkCreditBalance(deps, input, fundedWithoutCredits);
   if (!creditDecision.allowed) {
     return creditDecision;
   }
   if (deps.settings.usageLimitsMode !== "static" && deps.settings.usageLimitsMode !== "managed") {
     return { allowed: true };
   }
-  return await checkStaticCaps(deps, input, externallyBilled);
+  return await checkStaticCaps(deps, input, {
+    fundedWithoutCredits,
+    countsTowardTokenCap
+  });
 }
 async function checkCreditBalance(deps, input, externallyBilled) {
   if (externallyBilled) {
@@ -2129,9 +2508,9 @@ async function checkCreditBalance(deps, input, externallyBilled) {
   }
   return { allowed: false, code: "insufficient_credits", message: "insufficient OpenGeni credits" };
 }
-async function checkStaticCaps(deps, input, externallyBilled) {
+async function checkStaticCaps(deps, input, funding) {
   const limits = configuredStaticUsageLimits(deps.settings);
-  if (limits.maxMonthlyCostMicrosPerAccount && isCostlyAction(input.action) && !externallyBilled) {
+  if (limits.maxMonthlyCostMicrosPerAccount && isCostlyAction(input.action) && !funding.fundedWithoutCredits) {
     const used = await sumUsageQuantity(deps.db, {
       accountId: input.accountId,
       eventType: "model.cost",
@@ -2200,7 +2579,7 @@ async function checkStaticCaps(deps, input, externallyBilled) {
       );
     }
     case "tokens:consume": {
-      if (externallyBilled || !limits.maxMonthlyTokensPerWorkspace || !input.workspaceId) {
+      if (!funding.countsTowardTokenCap || !limits.maxMonthlyTokensPerWorkspace || !input.workspaceId) {
         return { allowed: true };
       }
       const used = await sumUsageQuantity(deps.db, {
@@ -7047,6 +7426,8 @@ import {
   getSandbox as getSandbox4,
   getSessionTurnXaiProviderAccountAuthoritySnapshot as getSessionTurnXaiProviderAccountAuthoritySnapshot2,
   getSession as getSession3,
+  lockActiveWorkspaceGatewayCustomModelForAdmission as lockActiveWorkspaceGatewayCustomModelForAdmission2,
+  lockActiveWorkspaceOpenRouterCustomModelForAdmission as lockActiveWorkspaceOpenRouterCustomModelForAdmission2,
   nestedPostgresSqlState as nestedPostgresSqlState2,
   requireWorkspace as requireWorkspace4,
   scopedKnowledgeScopeKey,
@@ -7062,10 +7443,11 @@ import { CODEX_MODEL_ID_PREFIX, isCodexBilledModel } from "@opengeni/codex";
 import {
   canonicalizeConfiguredModelId,
   configuredAllowedModels,
+  WORKSPACE_GATEWAY_MODEL_ID_PREFIX as WORKSPACE_GATEWAY_MODEL_ID_PREFIX2,
+  WORKSPACE_OPENROUTER_MODEL_ID_PREFIX as WORKSPACE_OPENROUTER_MODEL_ID_PREFIX2,
   resolveFirstPartyMcpToolPolicy,
   policyProviderIdForModel,
   resolveTurnExecutionPolicyV1,
-  WORKSPACE_GATEWAY_MODEL_ID_PREFIX,
   XAI_SUBSCRIPTION_MODEL_ID_PREFIX
 } from "@opengeni/config";
 import {
@@ -7079,15 +7461,18 @@ import {
   SessionSpawnDenial,
   ServiceTurnInitiator,
   ServiceTurnInitiatorContext,
-  evaluateWorkspaceModelPolicy,
+  evaluateWorkspaceModelPolicy as evaluateWorkspaceModelPolicy2,
   normalizeAutomaticSessionTitle,
   resolveWorkspaceSessionToolDefaults as resolveWorkspaceSessionToolDefaults2,
+  metadataWithTurnExecutionPolicyV1,
+  readTurnExecutionPolicyV1,
   stableJson as stableJson4,
   SessionMcpApprovalPolicy
 } from "@opengeni/contracts";
 import {
   createSession,
   createSessionWithIdempotencyKeyResult,
+  canonicalSessionCommandHash,
   encryptVariableSetValue as encryptVariableSetValue2,
   getAnySessionInGroup,
   getEnrollment as getEnrollment2,
@@ -7098,10 +7483,10 @@ import {
   listDistinctRigVersionIdsInGroup,
   getSandbox as getSandbox3,
   getSession as getSession2,
+  getInitializedSessionCreateReplay,
   getSessionAuthorityProjection as getSessionAuthorityProjection2,
   SessionIdConflictError,
   NewSessionDraftConflictError,
-  getSessionSpawnDenialByIdempotencyKey,
   getWorkspaceControlEvent,
   getSessionLineage,
   getSessionTurn,
@@ -7113,7 +7498,10 @@ import {
   initializeSessionStartAtomically,
   listSessionTurns,
   listSessionMcpServersForChildInheritance,
+  lockActiveWorkspaceGatewayCustomModelForAdmission,
+  lockActiveWorkspaceOpenRouterCustomModelForAdmission,
   requireSession as requireSession2,
+  replaySubmittedHumanPromptFromBoundaryReceipt,
   submitHumanPromptInTransaction,
   appendSessionEventsWithLockedSessionUpdate,
   updateSessionTitleWithEvent,
@@ -7998,16 +8386,43 @@ function automaticTitleForAgentChildCreate(presentation, goal, initialMessage) {
   return null;
 }
 async function createAndStartSessionWithOutcome(input) {
-  const sessionMetadata = {
-    ...input.metadata,
-    model: input.model,
-    reasoningEffort: input.reasoningEffort,
-    ...input.latencyMode !== void 0 ? { latencyMode: input.latencyMode } : {}
-  };
+  const sessionMetadata = metadataWithTurnExecutionPolicyV1(
+    {
+      ...input.metadata,
+      model: input.model,
+      reasoningEffort: input.reasoningEffort,
+      ...input.latencyMode !== void 0 ? { latencyMode: input.latencyMode } : {}
+    },
+    input.turnExecutionPolicy
+  );
   const frozenCreatedByContext = freezeAgentChildAutomaticTitleInCreatorContext(
     input.createdByContext,
     input.initialAutomaticTitle
   );
+  const requiresActiveWorkspaceCustomModel = (input.workspaceCustomModel === true || input.workspaceGatewayCustomModel === true) && input.retainWorkspaceCustomModel !== true && input.retainWorkspaceGatewayModel !== true;
+  const beforeCreateCommit = requiresActiveWorkspaceCustomModel || input.beforeCreateCommit ? async (tx, sessionId, context) => {
+    if (requiresActiveWorkspaceCustomModel && context?.created !== false) {
+      const openRouter = input.model.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX2);
+      const upstreamModelId = input.model.slice(
+        openRouter ? WORKSPACE_OPENROUTER_MODEL_ID_PREFIX2.length : WORKSPACE_GATEWAY_MODEL_ID_PREFIX2.length
+      );
+      const active = openRouter ? await lockActiveWorkspaceOpenRouterCustomModelForAdmission(tx, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        upstreamModelId
+      }) : await lockActiveWorkspaceGatewayCustomModelForAdmission(tx, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        upstreamModelId
+      });
+      if (!active) {
+        throw new HTTPException11(422, {
+          message: `model is not available: ${input.model}`
+        });
+      }
+    }
+    await input.beforeCreateCommit?.(tx, sessionId);
+  } : void 0;
   if (input.createIdempotencyKey) {
     const keyedResult = await createSessionWithIdempotencyKeyResult(input.db, {
       ...input.requestedSessionId ? { requestedSessionId: input.requestedSessionId } : {},
@@ -8050,15 +8465,23 @@ async function createAndStartSessionWithOutcome(input) {
       maxNestedAgentDepthOverride: input.maxNestedAgentDepthOverride ?? null,
       allowNestedAgentDepthIncrease: input.allowNestedAgentDepthIncrease ?? false,
       subjectId: input.subjectId ?? null,
-      ...input.beforeCreateCommit ? { beforeCreateCommit: input.beforeCreateCommit } : {}
+      ...beforeCreateCommit ? { beforeCreateCommit } : {}
     });
     if (keyedResult.denied) {
       throw new SessionSpawnDeniedError(SessionSpawnDenial.parse(keyedResult.denial));
     }
     const { session: keyed, created } = keyedResult;
     if (!created) {
+      const persistedPolicy = readTurnExecutionPolicyV1(keyed.metadata);
       const finished3 = await finishStartSession(
-        keyed.temporalWorkflowId ? { ...input, seedTargetSandbox: null } : input,
+        keyed.temporalWorkflowId ? {
+          ...input,
+          seedTargetSandbox: null,
+          ...persistedPolicy.kind === "valid" ? { turnExecutionPolicy: persistedPolicy.policy } : {}
+        } : {
+          ...input,
+          ...persistedPolicy.kind === "valid" ? { turnExecutionPolicy: persistedPolicy.policy } : {}
+        },
         keyed
       );
       return {
@@ -8118,7 +8541,7 @@ async function createAndStartSessionWithOutcome(input) {
       maxNestedAgentDepthOverride: input.maxNestedAgentDepthOverride ?? null,
       allowNestedAgentDepthIncrease: input.allowNestedAgentDepthIncrease ?? false,
       subjectId: input.subjectId ?? null,
-      ...input.beforeCreateCommit ? { beforeCreateCommit: input.beforeCreateCommit } : {}
+      ...beforeCreateCommit ? { beforeCreateCommit } : {}
     });
   } catch (error) {
     if (error instanceof SessionSpawnDeniedDbError) {
@@ -8237,9 +8660,6 @@ function canonicalConfiguredModel(settings, model) {
   if (settings.supergrokSubscriptionEnabled && canonicalModel.startsWith(XAI_SUBSCRIPTION_MODEL_ID_PREFIX)) {
     return canonicalModel;
   }
-  if (canonicalModel.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX)) {
-    return canonicalModel;
-  }
   throw new HTTPException11(422, { message: `model is not available: ${model}` });
 }
 function assertConfiguredModel(settings, model) {
@@ -8276,7 +8696,7 @@ async function assertWorkspaceModelPolicyAllows(db, settings, workspaceId, model
     return;
   }
   const providerId = policyProviderIdForModel(settings, canonicalModel);
-  const verdict = evaluateWorkspaceModelPolicy(policy, {
+  const verdict = evaluateWorkspaceModelPolicy2(policy, {
     providerId,
     modelId: canonicalModel
   });
@@ -8298,91 +8718,8 @@ async function requireQueuedTurnForApi(db, workspaceId, sessionId, turnId) {
   }
   return turn;
 }
-async function postUserMessageTurn(input) {
-  const { db, bus, workflowClient, settings, accountId, workspaceId, sessionId } = input;
-  const requestedModel = canonicalConfiguredModel(settings, input.model ?? null) ?? null;
-  const requestedReasoningEffort = input.reasoningEffort ?? null;
-  assertConfiguredModel(settings, requestedModel);
-  await assertWorkspaceModelPolicyAllows(db, settings, workspaceId, requestedModel);
-  const sessionForModelGate = await requireSession2(db, workspaceId, sessionId);
-  const effectiveModelForGate = requestedModel ?? sessionForModelGate.model;
-  try {
-    assertSessionAllowsProductModel(sessionForModelGate, effectiveModelForGate);
-  } catch (error) {
-    if (error instanceof CodexCompactionV2ProviderLockedError) {
-      throw new HTTPException11(422, { message: error.message, cause: error });
-    }
-    throw error;
-  }
-  const operationKey = input.clientEventId ?? crypto.randomUUID();
-  let result;
-  try {
-    result = await runIdempotentPersistenceTransaction(
-      {
-        stage: "session.prompt.submit",
-        eventTypes: ["user.message", "turn.queued", "session.status.changed"],
-        maxAttempts: 3
-      },
-      async () => await withWorkspaceSubjectSessionActivityRls(
-        db,
-        workspaceId,
-        input.actor ?? accountId,
-        (scoped) => submitHumanPromptInTransaction(scoped, {
-          accountId,
-          workspaceId,
-          sessionId,
-          subjectId: input.actor ?? accountId,
-          ...input.actorLabel ? { subjectLabel: input.actorLabel } : {},
-          actor: input.commandActor ?? {
-            type: "human",
-            subjectId: input.actor ?? accountId
-          },
-          operationKey,
-          delivery: input.delivery ?? "send",
-          controlEtag: input.controlEtag ?? null,
-          expectedDraftRevision: input.expectedDraftRevision ?? null,
-          text: input.text,
-          annotations: input.annotations ?? [],
-          modelContext: input.modelContext ?? null,
-          resources: input.resources,
-          ...input.composerDraftResources ? { composerDraftResources: input.composerDraftResources } : {},
-          model: requestedModel,
-          reasoningEffort: requestedReasoningEffort,
-          latencyMode: input.latencyMode ?? null,
-          reasoningEffortFallback: input.reasoningEffortFallback ?? settings.openaiReasoningEffort,
-          turnExecutionPolicy: input.turnExecutionPolicy,
-          source: input.origin === "operator" ? "api" : "user",
-          ...input.recordAgentRunUsage !== void 0 ? { recordAgentRunUsage: input.recordAgentRunUsage } : {},
-          personalConnectionDelegations: input.personalConnectionDelegations ?? [],
-          ...input.personalResourceAttachment ? {
-            personalResourceAttachment: input.personalResourceAttachment
-          } : {},
-          mcpCredentialUpdates: input.mcpCredentialUpdates ?? [],
-          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs()
-        })
-      )
-    );
-  } catch (error) {
-    if (error instanceof WorkspaceControlBusyError) {
-      throw error;
-    }
-    if (error instanceof PersonalResourceAttachmentAcceptanceError) {
-      throw new HTTPException11(
-        error.kind === "invalid" ? 422 : error.kind === "forbidden" ? 403 : 409,
-        { message: error.message, cause: error }
-      );
-    }
-    if (error instanceof QueueCommandConflictError || error instanceof SessionControlConflictError) {
-      throw new HTTPException11(409, { message: error.message });
-    }
-    if (error instanceof Error && error.message.includes("cancelled")) {
-      throw new HTTPException11(409, { message: error.message });
-    }
-    if (error instanceof Error && error.message.startsWith("Unknown session MCP server")) {
-      throw new HTTPException11(422, { message: error.message });
-    }
-    throw error;
-  }
+function finalizePostUserMessageTurn(input, result) {
+  const { db, bus, workflowClient, accountId, workspaceId, sessionId } = input;
   const postCommitTask = async () => {
     await Promise.all([
       (async () => {
@@ -8473,18 +8810,132 @@ async function postUserMessageTurn(input) {
     replay: result.replay
   };
 }
-function resolveChildGoalFromAcceptedSnapshot(goal, parentGoalSnapshot) {
-  const inheritedRootConstraints = parentGoalSnapshot.state === "none" ? [] : parentGoalSnapshot.rootConstraints;
-  const requestedRootConstraints = goal.rootConstraints;
-  if (requestedRootConstraints?.some((constraint) => !inheritedRootConstraints.includes(constraint))) {
-    throw new Error(
-      "child goal rootConstraints must be an exact subset of the calling turn's frozen root constraints"
-    );
+async function postUserMessageTurn(input) {
+  const { db, settings, accountId, workspaceId, sessionId } = input;
+  const requestedModel = canonicalConfiguredModel(settings, input.model ?? null) ?? null;
+  const requestedReasoningEffort = input.reasoningEffort ?? null;
+  assertConfiguredModel(settings, requestedModel);
+  const sessionForModelGate = await requireSession2(db, workspaceId, sessionId);
+  const effectiveModelForGate = requestedModel ?? sessionForModelGate.model;
+  const freshWorkspaceCustomModel = requestedModel !== null && isWorkspaceCustomModelId(settings, requestedModel) && requestedModel !== sessionForModelGate.model ? requestedModel : null;
+  await assertWorkspaceModelPolicyAllows(db, settings, workspaceId, effectiveModelForGate);
+  try {
+    assertSessionAllowsProductModel(sessionForModelGate, effectiveModelForGate);
+  } catch (error) {
+    if (error instanceof CodexCompactionV2ProviderLockedError) {
+      throw new HTTPException11(422, { message: error.message, cause: error });
+    }
+    throw error;
   }
-  return {
-    ...goal,
-    rootConstraints: requestedRootConstraints ?? inheritedRootConstraints
-  };
+  const operationKey = input.clientEventId ?? crypto.randomUUID();
+  let result;
+  try {
+    result = await runIdempotentPersistenceTransaction(
+      {
+        stage: "session.prompt.submit",
+        eventTypes: ["user.message", "turn.queued", "session.status.changed"],
+        maxAttempts: 3
+      },
+      async () => await withWorkspaceSubjectSessionActivityRls(
+        db,
+        workspaceId,
+        input.actor ?? accountId,
+        (scoped) => submitHumanPromptInTransaction(scoped, {
+          accountId,
+          workspaceId,
+          sessionId,
+          subjectId: input.actor ?? accountId,
+          ...input.actorLabel ? { subjectLabel: input.actorLabel } : {},
+          actor: input.commandActor ?? {
+            type: "human",
+            subjectId: input.actor ?? accountId
+          },
+          operationKey,
+          ...input.boundaryRequestHash ? { boundaryRequestHash: input.boundaryRequestHash } : {},
+          delivery: input.delivery ?? "send",
+          controlEtag: input.controlEtag ?? null,
+          expectedDraftRevision: input.expectedDraftRevision ?? null,
+          text: input.text,
+          annotations: input.annotations ?? [],
+          modelContext: input.modelContext ?? null,
+          resources: input.resources,
+          ...input.composerDraftResources ? { composerDraftResources: input.composerDraftResources } : {},
+          model: requestedModel,
+          reasoningEffort: requestedReasoningEffort,
+          latencyMode: input.latencyMode ?? null,
+          reasoningEffortFallback: input.reasoningEffortFallback ?? settings.openaiReasoningEffort,
+          turnExecutionPolicy: input.turnExecutionPolicy,
+          source: input.origin === "operator" ? "api" : "user",
+          ...input.recordAgentRunUsage !== void 0 ? { recordAgentRunUsage: input.recordAgentRunUsage } : {},
+          personalConnectionDelegations: input.personalConnectionDelegations ?? [],
+          ...input.personalResourceAttachment ? {
+            personalResourceAttachment: input.personalResourceAttachment
+          } : {},
+          mcpCredentialUpdates: input.mcpCredentialUpdates ?? [],
+          ...freshWorkspaceCustomModel ? {
+            beforeFreshPromptCommit: async (tx) => {
+              const reference = workspaceCustomModelReference(
+                settings,
+                freshWorkspaceCustomModel
+              );
+              if (!reference) {
+                throw new Error("workspace custom model reference disappeared");
+              }
+              const active = reference.providerKind === "openrouter" ? await lockActiveWorkspaceOpenRouterCustomModelForAdmission(tx, {
+                accountId,
+                workspaceId,
+                upstreamModelId: reference.upstreamModelId
+              }) : await lockActiveWorkspaceGatewayCustomModelForAdmission(tx, {
+                accountId,
+                workspaceId,
+                upstreamModelId: reference.upstreamModelId
+              });
+              if (!active) {
+                throw new HTTPException11(422, {
+                  message: `model is not available: ${freshWorkspaceCustomModel}`
+                });
+              }
+            }
+          } : {},
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs()
+        })
+      )
+    );
+  } catch (error) {
+    if (error instanceof WorkspaceControlBusyError) {
+      throw error;
+    }
+    if (error instanceof PersonalResourceAttachmentAcceptanceError) {
+      throw new HTTPException11(
+        error.kind === "invalid" ? 422 : error.kind === "forbidden" ? 403 : 409,
+        { message: error.message, cause: error }
+      );
+    }
+    if (error instanceof QueueCommandConflictError || error instanceof SessionControlConflictError) {
+      throw new HTTPException11(409, { message: error.message });
+    }
+    if (error instanceof Error && error.message.includes("cancelled")) {
+      throw new HTTPException11(409, { message: error.message });
+    }
+    if (error instanceof Error && error.message.startsWith("Unknown session MCP server")) {
+      throw new HTTPException11(422, { message: error.message });
+    }
+    throw error;
+  }
+  return finalizePostUserMessageTurn(input, result);
+}
+function resolveChildGoalFromAcceptedSnapshot(goal, parentGoalSnapshot) {
+  const inheritedRootConstraints = parentGoalSnapshot.state === "none" ? [] : parentGoalSnapshot.rootConstraints;
+  const requestedRootConstraints = goal.rootConstraints;
+  if (requestedRootConstraints?.some((constraint) => !inheritedRootConstraints.includes(constraint))) {
+    throw new Error(
+      "child goal rootConstraints must be an exact subset of the calling turn's frozen root constraints"
+    );
+  }
+  return {
+    ...goal,
+    rootConstraints: requestedRootConstraints ?? inheritedRootConstraints
+  };
 }
 function resolveSessionCreateVisibility(input) {
   if (input.parentVisibility === "user_private") {
@@ -8501,9 +8952,56 @@ function resolveSessionCreateVisibility(input) {
   }
   return input.requestedVisibility === "private" ? "user_private" : "workspace_shared";
 }
-async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawPayload, authorization, agentChildPresentation) {
-  const { settings, db, bus, workflowClient, objectStorage } = deps;
+async function resolveWorkspaceModelBoundarySettings(deps, grant, workspaceId, modelIds, retainedProductModelId) {
+  const retainedWorkspaceModel = retainedProductModelId?.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX2) === true || retainedProductModelId?.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX2) === true;
+  if (deps.catalogSourceSettings) {
+    if (!retainedWorkspaceModel) return deps.settings;
+  }
+  const workspaceModelIds = modelIds.filter(
+    (modelId) => typeof modelId === "string" && (modelId.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX2) || modelId.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX2))
+  );
+  const needsWorkspaceResolution = deps.settings.modelCatalogSource === "database" || workspaceModelIds.length > 0;
+  if (!needsWorkspaceResolution) return deps.settings;
+  return (await resolveWorkspaceCatalogSettings(deps.db, deps.catalogSourceSettings ?? deps.settings, {
+    accountId: grant.accountId,
+    workspaceId,
+    ...retainedProductModelId !== void 0 ? { retainedProductModelId } : {}
+  })).settings;
+}
+async function withSessionCreateUsageRecording(input) {
+  let usageRecording = "recorded";
+  if (input.startMode !== "realtime") {
+    try {
+      await recordWorkspaceUsage(input.deps, {
+        accountId: input.grant.accountId,
+        workspaceId: input.workspaceId,
+        subjectId: input.grant.subjectId,
+        eventType: "agent_run.created",
+        quantity: 1,
+        unit: "run",
+        sourceResourceType: "session",
+        sourceResourceId: input.createOutcome.session.id,
+        sessionId: input.createOutcome.session.id,
+        initiator: input.createOutcome.session.createdBy,
+        initiatorContext: input.createOutcome.session.createdByContext,
+        origin: input.origin,
+        idempotencyKey: `agent_run.created:${input.workspaceId}:${input.createOutcome.session.id}`
+      });
+    } catch (error) {
+      usageRecording = "failed";
+      reportSessionUsageRecordingFailure(error);
+    }
+  }
+  return { ...input.createOutcome, usageRecording };
+}
+async function createSessionForRequestWithOutcome(unresolvedDeps, grant, workspaceId, rawPayload, authorization, agentChildPresentation) {
   const payload = CreateSessionRequest.parse(rawPayload);
+  if (hasReservedOpenGeniSlackBotSessionMetadata(payload.metadata)) {
+    throw new HTTPException11(422, {
+      message: `${OPENGENI_SLACK_BOT_SESSION_METADATA_KEY2} is reserved for scheduler routing`
+    });
+  }
+  const db = unresolvedDeps.db;
   const visibilityProvided = hasOwnProperty(rawPayload, "visibility");
   if (payload.visibility === "private" && !grant.metadata?.["sessionId"]) {
     if (!authorization) {
@@ -8511,39 +9009,17 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
         message: "managed human session required"
       });
     }
-    await requireManagedHumanPrivateSessionCreate(deps, authorization, workspaceId);
+    await requireManagedHumanPrivateSessionCreate(unresolvedDeps, authorization, workspaceId);
     if (payload.sandbox === "shared" || typeof payload.sandbox === "object") {
       throw new HTTPException11(422, {
         message: "Only-me sessions require their own sandbox"
       });
     }
   }
-  if (hasReservedOpenGeniSlackBotSessionMetadata(payload.metadata)) {
-    throw new HTTPException11(422, {
-      message: `${OPENGENI_SLACK_BOT_SESSION_METADATA_KEY2} is reserved for scheduler routing`
-    });
-  }
-  if (payload.idempotencyKey) {
-    const denial = await getSessionSpawnDenialByIdempotencyKey(
-      db,
-      workspaceId,
-      payload.idempotencyKey
-    );
-    if (denial) {
-      throw new SessionSpawnDeniedError(SessionSpawnDenial.parse(denial));
-    }
-  }
-  await requireAtomicPersonalResourceAttachment(
-    deps,
-    authorization,
-    workspaceId,
-    payload.personalResourceAttachment,
-    false
-  );
   const parentSessionId = typeof grant.metadata?.["sessionId"] === "string" ? grant.metadata["sessionId"] : null;
   if (parentSessionId) {
     try {
-      await requireSessionAuthorization(deps, grant, {
+      await requireSessionAuthorization(unresolvedDeps, grant, {
         sessionId: parentSessionId,
         operation: "session.child.create",
         surface: "core"
@@ -8593,6 +9069,102 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       message: "caller attempt does not belong to the parent session"
     });
   }
+  const replayManagedHumanSubjectId = creationInitiator.actor ? parentCallingTurn?.initiatingHumanSubjectId ?? (parentCallingTurn?.initiator.kind === "subject" ? parentCallingTurn.initiator.subjectId : null) : authorization?.canonicalManagedHumanSession || grant.principalKind === "human_session" ? grant.subjectId : null;
+  let retainedKeyedShellModel = null;
+  if (payload.idempotencyKey && (effectiveVisibility !== "user_private" || replayManagedHumanSubjectId !== null)) {
+    try {
+      const initializedReplay = await getInitializedSessionCreateReplay(db, {
+        accountId: grant.accountId,
+        workspaceId,
+        subjectId: replayManagedHumanSubjectId ?? grant.subjectId,
+        ...replayManagedHumanSubjectId ? { activeManagedHumanSubjectId: replayManagedHumanSubjectId } : {},
+        createIdempotencyKey: payload.idempotencyKey,
+        ...payload.requestedSessionId ? { requestedSessionId: payload.requestedSessionId } : {},
+        visibility: effectiveVisibility,
+        variableSetIds: payload.variableSetIds ?? [],
+        initialPersonalResourceAttachmentIntent: payload.personalResourceAttachment ?? null,
+        deferInitialTurn: payload.startMode === "realtime"
+      });
+      if (initializedReplay) {
+        if (initializedReplay.outcome === "denied") {
+          throw new SessionSpawnDeniedError(SessionSpawnDenial.parse(initializedReplay.denial));
+        }
+        if (initializedReplay.outcome === "pending") {
+          retainedKeyedShellModel = initializedReplay.session.model;
+        } else {
+          if (initializedReplay.workflowWakeRevision !== null) {
+            await unresolvedDeps.workflowClient.wakeSessionWorkflow({
+              accountId: grant.accountId,
+              workspaceId,
+              sessionId: initializedReplay.session.id,
+              workflowId: initializedReplay.temporalWorkflowId,
+              wakeRevision: initializedReplay.workflowWakeRevision
+            });
+          }
+          return await withSessionCreateUsageRecording({
+            deps: unresolvedDeps,
+            grant,
+            workspaceId,
+            startMode: payload.startMode,
+            origin: creationInitiator.actor ? "system" : "user",
+            createOutcome: {
+              session: initializedReplay.session,
+              outcome: initializedReplay.changed ? "repaired" : "replayed",
+              replay: !initializedReplay.changed,
+              changed: initializedReplay.changed
+            }
+          });
+        }
+      }
+    } catch (error) {
+      if (error instanceof SessionIdConflictError) {
+        throw new HTTPException11(409, {
+          message: "requested session id is already in use"
+        });
+      }
+      if (error instanceof SessionCreateIdempotencyConflictError) {
+        throw new HTTPException11(409, { message: error.message, cause: error });
+      }
+      throw error;
+    }
+  }
+  let settings = await resolveWorkspaceModelBoundarySettings(
+    unresolvedDeps,
+    grant,
+    workspaceId,
+    [payload.model],
+    retainedKeyedShellModel
+  );
+  let deps = settings === unresolvedDeps.settings ? unresolvedDeps : {
+    ...unresolvedDeps,
+    catalogSourceSettings: unresolvedDeps.catalogSourceSettings ?? unresolvedDeps.settings,
+    settings
+  };
+  const { bus, workflowClient, objectStorage } = deps;
+  await requireAtomicPersonalResourceAttachment(
+    deps,
+    authorization,
+    workspaceId,
+    payload.personalResourceAttachment,
+    false
+  );
+  const inheritedModel = parentCallingTurn?.model ?? parentSession?.model ?? settings.openaiModel;
+  const effectiveModelId = payload.model ?? inheritedModel;
+  const effectiveCatalogSettings = await resolveWorkspaceModelBoundarySettings(
+    deps,
+    grant,
+    workspaceId,
+    [effectiveModelId],
+    parentSession ? inheritedModel : null
+  );
+  if (effectiveCatalogSettings !== settings) {
+    deps = {
+      ...deps,
+      catalogSourceSettings: deps.catalogSourceSettings ?? settings,
+      settings: effectiveCatalogSettings
+    };
+    settings = effectiveCatalogSettings;
+  }
   let effectiveGoal = payload.goal;
   if (parentSession && payload.goal) {
     try {
@@ -8743,8 +9315,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
     }
     channelId = channel.id;
   }
-  const inheritedModel = parentCallingTurn?.model ?? parentSession?.model ?? settings.openaiModel;
-  const model = canonicalConfiguredModel(settings, payload.model ?? inheritedModel);
+  const model = canonicalConfiguredModel(settings, effectiveModelId);
   if (model === null || model === void 0) {
     throw new Error("effective session model unexpectedly resolved to null");
   }
@@ -9057,6 +9628,8 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       sessionMcpServers: sessionMcpServers.metadata,
       personalConnectionDelegations,
       initialPersonalResourceAttachmentIntent: payload.personalResourceAttachment ?? null,
+      workspaceCustomModel: isWorkspaceCustomModelId(settings, model),
+      retainWorkspaceCustomModel: parentSession !== null && model === inheritedModel,
       ...xaiProviderAccountAuthoritySnapshot ? { xaiProviderAccountAuthoritySnapshot } : {},
       parentSessionId,
       createIdempotencyKey: payload.idempotencyKey ?? null,
@@ -9118,30 +9691,14 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
     }
     throw error;
   }
-  let usageRecording = "recorded";
-  if (payload.startMode !== "realtime") {
-    try {
-      await recordWorkspaceUsage(deps, {
-        accountId: grant.accountId,
-        workspaceId,
-        subjectId: grant.subjectId,
-        eventType: "agent_run.created",
-        quantity: 1,
-        unit: "run",
-        sourceResourceType: "session",
-        sourceResourceId: createOutcome.session.id,
-        sessionId: createOutcome.session.id,
-        initiator: createOutcome.session.createdBy,
-        initiatorContext: createOutcome.session.createdByContext,
-        origin: creationInitiator.actor ? "system" : "user",
-        idempotencyKey: `agent_run.created:${workspaceId}:${createOutcome.session.id}`
-      });
-    } catch (error) {
-      usageRecording = "failed";
-      reportSessionUsageRecordingFailure(error);
-    }
-  }
-  return { ...createOutcome, usageRecording };
+  return await withSessionCreateUsageRecording({
+    deps,
+    grant,
+    workspaceId,
+    startMode: payload.startMode,
+    origin: creationInitiator.actor ? "system" : "user",
+    createOutcome
+  });
 }
 function reportSessionUsageRecordingFailure(_error) {
   console.warn(
@@ -9156,163 +9713,294 @@ function reportSessionUsageRecordingFailure(_error) {
 async function createSessionForRequest(deps, grant, workspaceId, rawPayload, authorization) {
   return (await createSessionForRequestWithOutcome(deps, grant, workspaceId, rawPayload, authorization)).session;
 }
+function sessionPromptBoundaryRequestHash(input) {
+  return `prompt-boundary-v1:${canonicalSessionCommandHash({
+    delivery: input.delivery,
+    controlEtag: input.controlEtag,
+    expectedDraftRevision: input.expectedDraftRevision,
+    text: input.text,
+    annotations: input.annotations,
+    modelContext: input.modelContext,
+    resources: input.resources,
+    composerDraftResourcesProvided: input.composerDraftResources !== void 0,
+    composerDraftResources: input.composerDraftResources ?? [],
+    model: input.model,
+    reasoningEffort: input.reasoningEffort,
+    latencyMode: input.latencyMode,
+    source: input.source,
+    mcpCredentialUpdates: input.mcpCredentialUpdates,
+    connectionAuthorities: input.connectionAuthorities ?? [],
+    personalResourceAttachment: input.personalResourceAttachment ?? null,
+    ...input.commandActor.type === "service" ? {
+      serviceInitiator: {
+        subjectId: input.commandActor.subjectId,
+        subjectLabel: input.commandActor.subjectLabel ?? null,
+        context: input.commandActor.context ?? {}
+      }
+    } : {}
+  })}`;
+}
 async function acceptSessionUserMessageWithOutcome(deps, grant, workspaceId, sessionId, input) {
-  const { settings, db, bus, workflowClient, objectStorage } = deps;
+  const { db, bus, workflowClient, objectStorage } = deps;
   const delegatedServiceInitiator = serviceInitiatorForGrant(grant);
+  const delivery = input.delivery ?? "send";
+  const source = delegatedServiceInitiator || input.origin === "operator" ? "api" : "user";
+  const commandActor = delegatedServiceInitiator ? {
+    type: "service",
+    subjectId: delegatedServiceInitiator.initiator.subjectId,
+    ...delegatedServiceInitiator.initiator.label ? { subjectLabel: delegatedServiceInitiator.initiator.label } : {},
+    context: delegatedServiceInitiator.context
+  } : { type: "human", subjectId: grant.subjectId };
   await requireSessionAuthorization(deps, grant, {
     sessionId,
-    operation: input.delivery === "steer" ? "session.steer" : "session.append",
+    operation: delivery === "steer" ? "session.steer" : "session.append",
     surface: "core"
   });
-  await requireAtomicPersonalResourceAttachment(
-    deps,
-    input.authorization,
-    workspaceId,
-    input.personalResourceAttachment,
-    true
-  );
-  const existingSession = await requireSession2(db, workspaceId, sessionId);
-  const requestedModel = canonicalConfiguredModel(settings, input.model ?? null) ?? null;
-  const effectiveModel = canonicalConfiguredModel(settings, requestedModel ?? existingSession.model) ?? null;
-  if (effectiveModel === null) {
-    throw new Error("effective follow-up model unexpectedly resolved to null");
-  }
-  try {
-    assertSessionAllowsProductModel(existingSession, effectiveModel);
-  } catch (error) {
-    if (error instanceof CodexCompactionV2ProviderLockedError) {
-      throw new HTTPException11(422, { message: error.message, cause: error });
-    }
-    throw error;
-  }
-  const sessionReasoningEffort = existingSession.reasoningEffort;
-  const effectiveReasoningEffort = input.reasoningEffort ?? sessionReasoningEffort;
-  const sessionLatencyMode = existingSession.latencyMode;
-  const effectiveLatencyMode = input.latencyMode ?? sessionLatencyMode;
-  const turnExecutionPolicy = resolveTurnExecutionPolicyV1(settings, {
-    modelId: effectiveModel,
-    requestedModelId: input.model ?? null,
-    modelSource: input.model == null ? "session" : "explicit",
-    reasoningEffort: effectiveReasoningEffort,
-    reasoningSource: input.reasoningEffort == null ? "session" : "explicit",
-    latencyMode: effectiveLatencyMode,
-    latencyModeSource: input.latencyMode == null ? "session" : "explicit"
-  });
   const requestedResources = normalizeResources(input.resources ?? []);
   const composerDraftResources = input.composerDraftResources ? normalizeResources(input.composerDraftResources) : void 0;
-  if (composerDraftResources) {
-    const acceptedResources = new Set(requestedResources.map((resource) => stableJson4(resource)));
-    const unacceptedDraftResource = composerDraftResources.find(
-      (resource) => !acceptedResources.has(stableJson4(resource))
-    );
-    if (unacceptedDraftResource) {
-      throw new HTTPException11(422, {
-        message: "composer draft resources must be included in the accepted resource set"
-      });
-    }
-  }
-  const annotations = await validateSubmittedTimelineAnnotations(
-    db,
-    workspaceId,
-    sessionId,
-    input.annotations ?? []
-  );
-  await requireLimit(deps, {
-    accountId: grant.accountId,
-    workspaceId,
-    action: "agent_run:create",
-    quantity: 1,
-    model: effectiveModel
-  });
-  if (requestedResources.some((resource) => resource.kind === "file") && !objectStorage) {
-    throw new HTTPException11(503, {
-      message: "object storage is not configured"
-    });
-  }
-  await validateFileResources(
-    db,
-    grant.accountId,
-    workspaceId,
-    grant.subjectId,
-    requestedResources
-  );
-  await validateGitHubRepositorySelection(db, workspaceId, [
-    ...existingSession.resources,
-    ...requestedResources
-  ]);
-  const mcpCredentialUpdates = validateSessionMcpCredentialUpdates({
-    settings,
-    grant,
-    session: existingSession,
-    updates: input.mcpCredentialUpdates ?? []
-  });
-  const connectionDelegationSource = personalConnectionDelegationSourceForGrant(grant);
-  const inheritedPersonalConnectionDelegations = connectionDelegationSource.kind === "turn" ? await getSessionTurnPersonalConnectionDelegations2(
-    db,
-    workspaceId,
-    connectionDelegationSource.sessionId,
-    connectionDelegationSource.turnId
-  ) : null;
-  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(
-    db,
-    workspaceId,
-    settings,
-    inheritedPersonalConnectionDelegations ? {
-      personalConnectionDelegations: inheritedPersonalConnectionDelegations
-    } : { subjectId: grant.subjectId }
-  );
-  const personalConnectionDelegations = await freezePersonalConnectionDelegations({
-    db,
-    workspaceId,
-    settings: runtimeSettings,
-    tools: existingSession.tools,
-    resources: [...existingSession.resources, ...requestedResources],
-    source: connectionDelegationSource,
-    targetSessionId: sessionId,
-    googleDrivePublicationEnabled: existingSession.firstPartyMcpTools.includes("editable_artifact_export") && existingSession.firstPartyMcpTools.includes("editable_artifact_export_status") && (!existingSession.firstPartyMcpPermissions?.length || existingSession.firstPartyMcpPermissions.includes("artifacts:read") && existingSession.firstPartyMcpPermissions.includes("artifacts:publish")),
-    atlassianEnabled: existingSession.firstPartyMcpTools.some((tool) => tool.startsWith("atlassian_")) && (!existingSession.firstPartyMcpPermissions?.length || existingSession.firstPartyMcpPermissions.includes("connections:read")),
-    ...input.connectionAuthorities ? { authoritySelections: input.connectionAuthorities } : {}
-  });
-  const { accepted, turn, draft, receipt: receipt2, routing, interruptionCount, replay } = await postUserMessageTurn({
-    db,
-    bus,
-    workflowClient,
-    settings,
-    accountId: grant.accountId,
-    workspaceId,
-    sessionId,
+  const boundaryRequestHash = input.clientEventId ? sessionPromptBoundaryRequestHash({
+    delivery,
+    controlEtag: input.controlEtag ?? null,
+    expectedDraftRevision: input.expectedDraftRevision ?? null,
     text: input.text,
-    annotations,
+    annotations: input.annotations ?? [],
     modelContext: input.modelContext ?? null,
     resources: requestedResources,
     ...composerDraftResources ? { composerDraftResources } : {},
     model: input.model ?? null,
     reasoningEffort: input.reasoningEffort ?? null,
     latencyMode: input.latencyMode ?? null,
-    reasoningEffortFallback: sessionReasoningEffort,
-    turnExecutionPolicy,
-    mcpCredentialUpdates,
-    personalConnectionDelegations,
+    source,
+    mcpCredentialUpdates: input.mcpCredentialUpdates ?? [],
+    ...input.connectionAuthorities ? { connectionAuthorities: input.connectionAuthorities } : {},
     ...input.personalResourceAttachment ? { personalResourceAttachment: input.personalResourceAttachment } : {},
-    delivery: input.delivery ?? "send",
-    origin: delegatedServiceInitiator ? "operator" : input.origin ?? "human",
-    actor: grant.subjectId,
-    ...grant.subjectLabel ? { actorLabel: grant.subjectLabel } : {},
-    ...delegatedServiceInitiator ? {
-      commandActor: {
-        type: "service",
-        subjectId: delegatedServiceInitiator.initiator.subjectId,
-        ...delegatedServiceInitiator.initiator.label ? { subjectLabel: delegatedServiceInitiator.initiator.label } : {},
-        context: delegatedServiceInitiator.context
+    commandActor
+  }) : null;
+  if (input.clientEventId && boundaryRequestHash) {
+    const replay = await withWorkspaceSubjectSessionActivityRls(
+      db,
+      workspaceId,
+      grant.subjectId,
+      async (scopedDb) => await replaySubmittedHumanPromptFromBoundaryReceipt(scopedDb, {
+        workspaceId,
+        sessionId,
+        subjectId: grant.subjectId,
+        actor: commandActor,
+        operationKey: input.clientEventId,
+        delivery,
+        boundaryRequestHash,
+        expectedDraftRevision: input.expectedDraftRevision ?? null
+      })
+    );
+    if (replay) {
+      return finalizePostUserMessageTurn(
+        {
+          db,
+          bus,
+          workflowClient,
+          accountId: grant.accountId,
+          workspaceId,
+          sessionId,
+          delivery,
+          ...deps.schedulePromptPostCommit ? { schedulePostCommit: deps.schedulePromptPostCommit } : {}
+        },
+        replay
+      );
+    }
+  }
+  try {
+    await requireAtomicPersonalResourceAttachment(
+      deps,
+      input.authorization,
+      workspaceId,
+      input.personalResourceAttachment,
+      true
+    );
+    const existingSession = await requireSession2(db, workspaceId, sessionId);
+    const settings = await resolveWorkspaceModelBoundarySettings(
+      deps,
+      grant,
+      workspaceId,
+      [input.model ?? existingSession.model],
+      existingSession.model
+    );
+    if (settings !== deps.settings) {
+      deps = {
+        ...deps,
+        catalogSourceSettings: deps.catalogSourceSettings ?? deps.settings,
+        settings
+      };
+    }
+    const requestedModel = canonicalConfiguredModel(settings, input.model ?? null) ?? null;
+    const effectiveModel = canonicalConfiguredModel(settings, requestedModel ?? existingSession.model) ?? null;
+    if (effectiveModel === null) {
+      throw new Error("effective follow-up model unexpectedly resolved to null");
+    }
+    await assertWorkspaceModelPolicyAllows(db, settings, workspaceId, requestedModel);
+    try {
+      assertSessionAllowsProductModel(existingSession, effectiveModel);
+    } catch (error) {
+      if (error instanceof CodexCompactionV2ProviderLockedError) {
+        throw new HTTPException11(422, { message: error.message, cause: error });
       }
-    } : {},
-    ...input.controlEtag !== void 0 ? { controlEtag: input.controlEtag } : {},
-    ...input.expectedDraftRevision !== void 0 ? { expectedDraftRevision: input.expectedDraftRevision } : {},
-    ...input.clientEventId ? { clientEventId: input.clientEventId } : {},
-    recordAgentRunUsage: true,
-    ...deps.schedulePromptPostCommit ? { schedulePostCommit: deps.schedulePromptPostCommit } : {}
-  });
-  return { accepted, turn, draft, receipt: receipt2, routing, interruptionCount, replay };
+      throw error;
+    }
+    const sessionReasoningEffort = existingSession.reasoningEffort;
+    const effectiveReasoningEffort = input.reasoningEffort ?? sessionReasoningEffort;
+    const sessionLatencyMode = existingSession.latencyMode;
+    const effectiveLatencyMode = input.latencyMode ?? sessionLatencyMode;
+    const turnExecutionPolicy = resolveTurnExecutionPolicyV1(settings, {
+      modelId: effectiveModel,
+      requestedModelId: input.model ?? null,
+      modelSource: input.model == null ? "session" : "explicit",
+      reasoningEffort: effectiveReasoningEffort,
+      reasoningSource: input.reasoningEffort == null ? "session" : "explicit",
+      latencyMode: effectiveLatencyMode,
+      latencyModeSource: input.latencyMode == null ? "session" : "explicit"
+    });
+    if (composerDraftResources) {
+      const acceptedResources = new Set(requestedResources.map((resource) => stableJson4(resource)));
+      const unacceptedDraftResource = composerDraftResources.find(
+        (resource) => !acceptedResources.has(stableJson4(resource))
+      );
+      if (unacceptedDraftResource) {
+        throw new HTTPException11(422, {
+          message: "composer draft resources must be included in the accepted resource set"
+        });
+      }
+    }
+    const annotations = await validateSubmittedTimelineAnnotations(
+      db,
+      workspaceId,
+      sessionId,
+      input.annotations ?? []
+    );
+    await requireLimit(deps, {
+      accountId: grant.accountId,
+      workspaceId,
+      action: "agent_run:create",
+      quantity: 1,
+      model: effectiveModel
+    });
+    if (requestedResources.some((resource) => resource.kind === "file") && !objectStorage) {
+      throw new HTTPException11(503, {
+        message: "object storage is not configured"
+      });
+    }
+    await validateFileResources(
+      db,
+      grant.accountId,
+      workspaceId,
+      grant.subjectId,
+      requestedResources
+    );
+    await validateGitHubRepositorySelection(db, workspaceId, [
+      ...existingSession.resources,
+      ...requestedResources
+    ]);
+    const mcpCredentialUpdates = validateSessionMcpCredentialUpdates({
+      settings,
+      grant,
+      session: existingSession,
+      updates: input.mcpCredentialUpdates ?? []
+    });
+    const connectionDelegationSource = personalConnectionDelegationSourceForGrant(grant);
+    const inheritedPersonalConnectionDelegations = connectionDelegationSource.kind === "turn" ? await getSessionTurnPersonalConnectionDelegations2(
+      db,
+      workspaceId,
+      connectionDelegationSource.sessionId,
+      connectionDelegationSource.turnId
+    ) : null;
+    const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(
+      db,
+      workspaceId,
+      settings,
+      inheritedPersonalConnectionDelegations ? {
+        personalConnectionDelegations: inheritedPersonalConnectionDelegations
+      } : { subjectId: grant.subjectId }
+    );
+    const personalConnectionDelegations = await freezePersonalConnectionDelegations({
+      db,
+      workspaceId,
+      settings: runtimeSettings,
+      tools: existingSession.tools,
+      resources: [...existingSession.resources, ...requestedResources],
+      source: connectionDelegationSource,
+      targetSessionId: sessionId,
+      googleDrivePublicationEnabled: existingSession.firstPartyMcpTools.includes("editable_artifact_export") && existingSession.firstPartyMcpTools.includes("editable_artifact_export_status") && (!existingSession.firstPartyMcpPermissions?.length || existingSession.firstPartyMcpPermissions.includes("artifacts:read") && existingSession.firstPartyMcpPermissions.includes("artifacts:publish")),
+      atlassianEnabled: existingSession.firstPartyMcpTools.some((tool) => tool.startsWith("atlassian_")) && (!existingSession.firstPartyMcpPermissions?.length || existingSession.firstPartyMcpPermissions.includes("connections:read")),
+      ...input.connectionAuthorities ? { authoritySelections: input.connectionAuthorities } : {}
+    });
+    const { accepted, turn, draft, receipt: receipt2, routing, interruptionCount, replay } = await postUserMessageTurn({
+      db,
+      bus,
+      workflowClient,
+      settings,
+      accountId: grant.accountId,
+      workspaceId,
+      sessionId,
+      text: input.text,
+      annotations,
+      modelContext: input.modelContext ?? null,
+      resources: requestedResources,
+      ...composerDraftResources ? { composerDraftResources } : {},
+      model: input.model ?? null,
+      reasoningEffort: input.reasoningEffort ?? null,
+      latencyMode: input.latencyMode ?? null,
+      reasoningEffortFallback: sessionReasoningEffort,
+      turnExecutionPolicy,
+      mcpCredentialUpdates,
+      personalConnectionDelegations,
+      ...input.personalResourceAttachment ? { personalResourceAttachment: input.personalResourceAttachment } : {},
+      delivery,
+      origin: source === "api" ? "operator" : "human",
+      actor: grant.subjectId,
+      ...grant.subjectLabel ? { actorLabel: grant.subjectLabel } : {},
+      commandActor,
+      ...boundaryRequestHash ? { boundaryRequestHash } : {},
+      ...input.controlEtag !== void 0 ? { controlEtag: input.controlEtag } : {},
+      ...input.expectedDraftRevision !== void 0 ? { expectedDraftRevision: input.expectedDraftRevision } : {},
+      ...input.clientEventId ? { clientEventId: input.clientEventId } : {},
+      recordAgentRunUsage: true,
+      ...deps.schedulePromptPostCommit ? { schedulePostCommit: deps.schedulePromptPostCommit } : {}
+    });
+    return { accepted, turn, draft, receipt: receipt2, routing, interruptionCount, replay };
+  } catch (error) {
+    if (input.clientEventId && boundaryRequestHash) {
+      const replay = await withWorkspaceSubjectSessionActivityRls(
+        db,
+        workspaceId,
+        grant.subjectId,
+        async (scopedDb) => await replaySubmittedHumanPromptFromBoundaryReceipt(scopedDb, {
+          workspaceId,
+          sessionId,
+          subjectId: grant.subjectId,
+          actor: commandActor,
+          operationKey: input.clientEventId,
+          delivery,
+          boundaryRequestHash,
+          expectedDraftRevision: input.expectedDraftRevision ?? null,
+          serializeOperation: true
+        })
+      );
+      if (replay) {
+        return finalizePostUserMessageTurn(
+          {
+            db,
+            bus,
+            workflowClient,
+            accountId: grant.accountId,
+            workspaceId,
+            sessionId,
+            delivery,
+            ...deps.schedulePromptPostCommit ? { schedulePostCommit: deps.schedulePromptPostCommit } : {}
+          },
+          replay
+        );
+      }
+    }
+    throw error;
+  }
 }
 async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, input) {
   const { accepted, turn, receipt: receipt2, routing, interruptionCount, replay } = await acceptSessionUserMessageWithOutcome(deps, grant, workspaceId, sessionId, input);
@@ -9637,6 +10325,26 @@ function scheduledTaskToolsProvided(rawPayload) {
     agentConfig && typeof agentConfig === "object" && Object.prototype.hasOwnProperty.call(agentConfig, "tools")
   );
 }
+function workspaceCustomModelCommitGuard(input) {
+  const reference = workspaceCustomModelReference(input.settings, input.modelId);
+  if (!reference) return void 0;
+  return async (tx) => {
+    const active = reference.providerKind === "openrouter" ? await lockActiveWorkspaceOpenRouterCustomModelForAdmission2(tx, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      upstreamModelId: reference.upstreamModelId
+    }) : await lockActiveWorkspaceGatewayCustomModelForAdmission2(tx, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      upstreamModelId: reference.upstreamModelId
+    });
+    if (!active) {
+      throw new HTTPException12(422, {
+        message: `model is not available: ${input.modelId}`
+      });
+    }
+  };
+}
 function scheduledConnectionSurfaceEligibility(settings, target) {
   const tools = target?.firstPartyMcpTools ?? resolveFirstPartyMcpToolPolicy2(settings).default;
   const permissions = target?.firstPartyMcpPermissions?.length ? target.firstPartyMcpPermissions : DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2;
@@ -9728,6 +10436,12 @@ async function createValidatedScheduledTask(input) {
     workspaceId: input.grant.workspaceId,
     subjectId: input.grant.subjectId
   });
+  const beforeCreateCommit = !knowledgeAction && input.payload.runMode !== "existing_session" ? workspaceCustomModelCommitGuard({
+    settings: input.settings,
+    accountId: input.grant.accountId,
+    workspaceId: input.grant.workspaceId,
+    modelId: agentConfig.model ?? input.settings.openaiModel
+  }) : void 0;
   return await withScheduledTaskAuthorityWriteErrors(
     () => createScheduledTask(input.db, {
       id,
@@ -9749,7 +10463,8 @@ async function createValidatedScheduledTask(input) {
       targetSessionId: target?.id ?? null,
       variableSetId: input.payload.variableSetId ?? null,
       rigId: input.payload.rigId ?? null,
-      metadata: input.payload.metadata
+      metadata: input.payload.metadata,
+      ...beforeCreateCommit ? { beforeCreateCommit } : {}
     })
   );
 }
@@ -10075,6 +10790,15 @@ async function validatedScheduledTaskUpdate(input) {
   const nextAgentConfig = update.agentConfig ?? input.existing.agentConfig;
   const authorityTargetChanged = nextRunMode !== input.existing.runMode || nextTargetSessionId !== input.existing.targetSessionId || input.payload.variableSetId !== void 0 && input.payload.variableSetId !== input.existing.variableSetId || input.payload.rigId !== void 0 && input.payload.rigId !== input.existing.rigId;
   const materialExecutionChange = authorityTargetChanged || input.payload.connectionAuthorities !== void 0 || !isDeepStrictEqual(nextAgentConfig, input.existing.agentConfig) || input.payload.action !== void 0 && !isDeepStrictEqual(input.payload.action, input.existing.action) || input.payload.schedule !== void 0 && !isDeepStrictEqual(input.payload.schedule, input.existing.schedule) || input.payload.overlapPolicy !== void 0 && input.payload.overlapPolicy !== input.existing.overlapPolicy || input.payload.metadata !== void 0 && !isDeepStrictEqual(input.payload.metadata, input.existing.metadata) || input.existing.status === "paused" && input.payload.status === "active";
+  if (materialExecutionChange && nextRunMode !== "existing_session") {
+    const beforeUpdateCommit = workspaceCustomModelCommitGuard({
+      settings: input.settings,
+      accountId: input.existing.accountId,
+      workspaceId: input.existing.workspaceId,
+      modelId: nextAgentConfig.model ?? input.settings.openaiModel
+    });
+    if (beforeUpdateCommit) update.beforeUpdateCommit = beforeUpdateCommit;
+  }
   const existingXaiAuthority = await getScheduledTaskXaiProviderAccountAuthoritySnapshot(
     input.db,
     input.existing.workspaceId,
@@ -14575,6 +15299,7 @@ export {
   MEMORY_SLACK_PROJECTION_MAX_UTF8_BYTES,
   MEMORY_SLACK_PROJECTION_VERSION,
   MEMORY_SLACK_SUMMARY_MAX_UTF8_BYTES,
+  MODEL_CREDENTIAL_READINESS_OBSERVATION_MAX_AGE_MS,
   ManagedAuthActorLeaseOutcomeUnknownError,
   MathEditableArtifactOutboxRandom,
   OPENGENI_PR_REVIEW_AGENT_INSTRUCTIONS,
@@ -14777,6 +15502,9 @@ export {
   isTerminalVideoGenerationState,
   isTrustedScheduledSlackBotSession,
   isUserMember,
+  isWorkspaceCustomModelId,
+  isWorkspaceGatewayCustomModelId,
+  isWorkspaceOpenRouterCustomModelId,
   issueManagedHumanUserResourceGrant,
   legacySandboxRuntimeFromPacks,
   listCapabilityPacks,
@@ -14797,6 +15525,7 @@ export {
   mergeResourceRefs,
   mergeRigDefaultVariableSetEnvironment,
   mergeToolRefs,
+  modelFundingForAdmission,
   moveHumanQueuePrompt,
   nativeConnectionCapabilityRecommendations,
   normalizeConversationActor,
@@ -14879,6 +15608,7 @@ export {
   requireVariableSetEncryption,
   requireVariableSetForApi,
   resolveCapabilityPack,
+  resolveCatalogSettings,
   resolveChildGoalFromAcceptedSnapshot,
   resolveCodexAppsCredentialIdForRun,
   resolveFikenDefaultCompanySlug,
@@ -14891,7 +15621,9 @@ export {
   resolveSessionSandboxRuntime,
   resolveSessionToolPolicy,
   resolveSkillImport,
+  resolveWorkspaceCatalogSettings,
   resolveWorkspaceLegacyRuntimePacks,
+  resolveWorkspaceModelSelection,
   restoreScheduledTask,
   retainedProcessBackgroundSettlement,
   revokeManagedHumanUserResourceGrant,
@@ -14978,6 +15710,7 @@ export {
   withScheduledTaskAuthorityWriteErrors,
   withWorkspaceDefaultMcpTools,
   workflowIdForSession,
+  workspaceCustomModelReference,
   workspaceSessionToolPolicyDefaultServerIds,
   workspaceSessionToolPolicyServerIds,
   wrapChannelABoxWithRouting