@opengeni/core 4.0.3 → 4.0.4-canary.36239117573001

package/dist/index.js

@@ -220,22 +220,22 @@ async function requireLiveAgentAttemptAuthorization(db, grant, callerSessionId)
 async function requireSessionAuthorization(deps, grant, input) {
   const port = deps.sessionAuthorization;
   const isAgentAttempt = grantHasAgentAttemptAuthority(grant);
-  const [slackAccess, authority] = await Promise.all([
-    getSlackInteractionSessionAccessForSession(deps.db, {
-      accountId: grant.accountId,
-      workspaceId: grant.workspaceId,
-      sessionId: input.sessionId
-    }),
-    getSessionAuthorityProjection(deps.db, grant.workspaceId, input.sessionId)
-  ]);
+  const slackAccess = await getSlackInteractionSessionAccessForSession(deps.db, {
+    accountId: grant.accountId,
+    workspaceId: grant.workspaceId,
+    sessionId: input.sessionId
+  });
+  const authority = await getSessionAuthorityProjection(
+    deps.db,
+    grant.workspaceId,
+    input.sessionId
+  );
   if (!port && !isAgentAttempt && slackAccess?.visibility !== "private" && authority?.visibility !== "user_private") {
     return null;
   }
   if (!authority) throw new SessionAuthorizationDeniedError("not_found");
-  const [resolvedActor, resolvedTarget] = await Promise.all([
-    resolveSessionAuthorizationActor(deps.db, grant),
-    resolveSessionAuthorizationTarget(deps.db, grant, input.sessionId)
-  ]);
+  const resolvedActor = await resolveSessionAuthorizationActor(deps.db, grant);
+  const resolvedTarget = await resolveSessionAuthorizationTarget(deps.db, grant, input.sessionId);
   const actor = resolvedActor.actor;
   const target = resolvedTarget.target;
   const agentRelatedSessionAccess = actor.kind === "agent_attempt" ? relatedSessionAccessForAgentAttempt(actor, target.sessionId) : null;
@@ -357,10 +357,8 @@ async function resolveSessionAuthorizationActor(db, grant) {
   if (typeof callerSessionId !== "string" || typeof turnId !== "string" || typeof attemptId !== "string" || typeof executionGeneration !== "number" || !Number.isSafeInteger(executionGeneration) || executionGeneration < 1) {
     throw new SessionAuthorizationDeniedError("caller_stale");
   }
-  const [callerSession, turn] = await Promise.all([
-    getSession(db, grant.workspaceId, callerSessionId),
-    getSessionTurnForAttempt(db, grant.workspaceId, callerSessionId, attemptId)
-  ]);
+  const callerSession = await getSession(db, grant.workspaceId, callerSessionId);
+  const turn = await getSessionTurnForAttempt(db, grant.workspaceId, callerSessionId, attemptId);
   if (!callerSession || callerSession.accountId !== grant.accountId || !turn || turn.id !== turnId || turn.executionGeneration !== executionGeneration || callerSession.activeTurnId !== turn.id) {
     throw new SessionAuthorizationDeniedError("caller_stale");
   }
@@ -2323,6 +2321,270 @@ function resolveWorkspaceModelSelection(input) {
   });
 }
 
+// src/default-session-model.ts
+import {
+  canonicalizeConfiguredModelId
+} from "@opengeni/config";
+import {
+  resolveWorkspaceSessionDefaults
+} from "@opengeni/contracts";
+import {
+  getScheduledTaskXaiProviderAccountAuthoritySnapshot,
+  getSession as getSession2,
+  getWorkspace,
+  getWorkspaceConnectionModelRestrictions,
+  getWorkspaceModelPolicy,
+  listOrganizationModelProviderCustomModelsForWorkspace as listOrganizationModelProviderCustomModelsForWorkspace2,
+  listWorkspaceGatewayCustomModels as listWorkspaceGatewayCustomModels2,
+  listWorkspaceOpenRouterCustomModels as listWorkspaceOpenRouterCustomModels2,
+  organizationModelProviderConnectionActiveForWorkspace,
+  workspaceCodexSubscriptionActive,
+  workspaceOpenRouterConnectionActive,
+  workspaceVercelAiGatewayConnectionActive,
+  organizationHoldsCredits,
+  workspaceXaiSubscriptionActive,
+  workspaceXaiSubscriptionActiveForAuthority,
+  XaiAuthorityPoolInactiveError
+} from "@opengeni/db";
+var REASONING_EFFORT_ORDER = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function supportedReasoningEfforts(model) {
+  const efforts = model.capabilities.reasoning.efforts;
+  return REASONING_EFFORT_ORDER.filter((effort) => efforts.includes(effort));
+}
+function defaultReasoningEffortForConfiguredModel(model, fallback) {
+  const options = supportedReasoningEfforts(model);
+  if (options.length === 0) return fallback;
+  const configured = model.capabilities.reasoning.defaultEffort;
+  if (configured && options.includes(configured)) return configured;
+  return options[0];
+}
+function clampReasoningEffortForConfiguredModel(model, preferred, fallback) {
+  const options = supportedReasoningEfforts(model);
+  if (options.length === 0) return fallback;
+  if (options.includes(preferred)) return preferred;
+  const ceiling = REASONING_EFFORT_ORDER.indexOf(preferred);
+  const below = options.filter((effort) => REASONING_EFFORT_ORDER.indexOf(effort) <= ceiling);
+  return below.at(-1) ?? defaultReasoningEffortForConfiguredModel(model, fallback);
+}
+function findSelection(selections, modelId) {
+  return selections.find((selection) => selection.model.id === modelId) ?? selections.find((selection) => selection.model.aliases.includes(modelId));
+}
+function creditsCandidate(input) {
+  const fallbackEffort = input.settings.openaiReasoningEffort;
+  const deployment = findSelection(input.selections, input.settings.openaiModel);
+  if (deployment?.availability.selectable && deployment.model.cost === "credits") return null;
+  const configured = findSelection(input.selections, input.settings.creditsDefaultModel);
+  if (configured?.availability.selectable && configured.model.cost === "credits") {
+    return {
+      model: configured.model.id,
+      reasoningEffort: clampReasoningEffortForConfiguredModel(
+        configured.model,
+        input.settings.creditsDefaultReasoningEffort,
+        fallbackEffort
+      ),
+      source: "credits"
+    };
+  }
+  const first = input.selections.find(
+    (selection) => selection.availability.selectable && selection.model.cost === "credits"
+  );
+  return first ? {
+    model: first.model.id,
+    reasoningEffort: defaultReasoningEffortForConfiguredModel(first.model, fallbackEffort),
+    source: "credits"
+  } : null;
+}
+function selectDefaultSessionModel(input) {
+  const fallbackEffort = input.settings.openaiReasoningEffort;
+  if (input.workspaceDefaults) {
+    const saved = findSelection(input.selections, input.workspaceDefaults.model);
+    if (saved?.availability.selectable) {
+      return {
+        model: saved.model.id,
+        reasoningEffort: clampReasoningEffortForConfiguredModel(
+          saved.model,
+          input.workspaceDefaults.reasoningEffort,
+          fallbackEffort
+        ),
+        source: "workspace"
+      };
+    }
+  }
+  const deployment = findSelection(input.selections, input.settings.openaiModel);
+  const subscription = deployment?.availability.selectable && deployment.model.cost === "subscription" ? deployment : input.selections.find(
+    (selection) => selection.availability.selectable && selection.model.cost === "subscription"
+  );
+  if (subscription) {
+    return {
+      model: subscription.model.id,
+      reasoningEffort: defaultReasoningEffortForConfiguredModel(subscription.model, fallbackEffort),
+      source: "subscription"
+    };
+  }
+  if (input.creditsAvailable) {
+    const credits = creditsCandidate(input);
+    if (credits) return credits;
+  }
+  return {
+    model: deployment?.model.id ?? canonicalizeConfiguredModelId(input.settings, input.settings.openaiModel),
+    reasoningEffort: fallbackEffort,
+    source: "deployment"
+  };
+}
+function creditsDefaultSessionModel(input) {
+  if (input.settings.billingMode !== "stripe") return null;
+  return selectDefaultSessionModel({
+    settings: input.settings,
+    selections: input.selections,
+    workspaceDefaults: resolveWorkspaceSessionDefaults(input.workspaceSettings),
+    creditsAvailable: true
+  });
+}
+async function resolveDefaultSessionModelForSelections(db, input) {
+  const decision = {
+    settings: input.settings,
+    selections: input.selections,
+    workspaceDefaults: resolveWorkspaceSessionDefaults(input.workspaceSettings)
+  };
+  const withoutCredits = selectDefaultSessionModel({ ...decision, creditsAvailable: false });
+  if (withoutCredits.source !== "deployment" || input.settings.billingMode !== "stripe" || creditsCandidate(decision) === null) {
+    return withoutCredits;
+  }
+  return await organizationHoldsCredits(db, input.accountId) ? selectDefaultSessionModel({ ...decision, creditsAvailable: true }) : withoutCredits;
+}
+async function connectionRestrictionsAndXaiReadiness(db, settings, context) {
+  const { workspaceId, subjectId, xaiAuthoritySnapshot } = context;
+  if (!xaiAuthoritySnapshot) {
+    const [restrictions2, xaiSubscriptionActive] = await Promise.all([
+      getWorkspaceConnectionModelRestrictions(db, workspaceId, subjectId),
+      workspaceXaiSubscriptionActive(db, settings, workspaceId, subjectId)
+    ]);
+    return { restrictions: restrictions2, xaiSubscriptionActive };
+  }
+  const frozen = await Promise.allSettled([
+    getWorkspaceConnectionModelRestrictions(db, workspaceId, subjectId, xaiAuthoritySnapshot),
+    workspaceXaiSubscriptionActiveForAuthority(db, settings, {
+      workspaceId,
+      subjectId,
+      authoritySnapshot: xaiAuthoritySnapshot
+    })
+  ]);
+  const [restrictions, readiness] = frozen;
+  if (restrictions.status === "fulfilled" && readiness.status === "fulfilled") {
+    return { restrictions: restrictions.value, xaiSubscriptionActive: readiness.value };
+  }
+  for (const result of frozen) {
+    if (result.status === "rejected" && !(result.reason instanceof XaiAuthorityPoolInactiveError)) {
+      throw result.reason;
+    }
+  }
+  const current = await getWorkspaceConnectionModelRestrictions(db, workspaceId, subjectId);
+  return {
+    restrictions: { ...current, "supergrok/": [] },
+    xaiSubscriptionActive: false
+  };
+}
+async function loadWorkspaceModelSelectionInput(db, settings, context) {
+  const { accountId, workspaceId } = context;
+  const [
+    { restrictions: connectionModelRestrictions, xaiSubscriptionActive },
+    policy,
+    codexSubscriptionActive,
+    workspaceGatewayConnectionActive,
+    workspaceGatewayCustomModels,
+    openRouterConnectionActive,
+    workspaceOpenRouterCustomModels,
+    organizationGatewayConnectionActive,
+    organizationOpenRouterConnectionActive,
+    organizationGatewayCustomModels,
+    organizationOpenRouterCustomModels
+  ] = await Promise.all([
+    connectionRestrictionsAndXaiReadiness(db, settings, context),
+    getWorkspaceModelPolicy(db, workspaceId),
+    workspaceCodexSubscriptionActive(db, settings, workspaceId),
+    workspaceVercelAiGatewayConnectionActive(db, workspaceId),
+    listWorkspaceGatewayCustomModels2(db, { accountId, workspaceId }),
+    workspaceOpenRouterConnectionActive(db, workspaceId),
+    listWorkspaceOpenRouterCustomModels2(db, { accountId, workspaceId }),
+    organizationModelProviderConnectionActiveForWorkspace(db, {
+      accountId,
+      workspaceId,
+      providerKind: "vercel_gateway"
+    }),
+    organizationModelProviderConnectionActiveForWorkspace(db, {
+      accountId,
+      workspaceId,
+      providerKind: "openrouter"
+    }),
+    listOrganizationModelProviderCustomModelsForWorkspace2(db, {
+      accountId,
+      workspaceId,
+      providerKind: "vercel_gateway"
+    }),
+    listOrganizationModelProviderCustomModelsForWorkspace2(db, {
+      accountId,
+      workspaceId,
+      providerKind: "openrouter"
+    })
+  ]);
+  return {
+    connectionModelRestrictions,
+    settings,
+    policy,
+    codexSubscriptionActive,
+    xaiSubscriptionActive,
+    workspaceGatewayConnectionActive,
+    workspaceGatewayCustomModels,
+    workspaceOpenRouterConnectionActive: openRouterConnectionActive,
+    workspaceOpenRouterCustomModels,
+    organizationGatewayConnectionActive,
+    organizationOpenRouterConnectionActive,
+    organizationGatewayCustomModels,
+    organizationOpenRouterCustomModels
+  };
+}
+async function resolveDefaultSessionModel(db, settings, context) {
+  const [selectionInput, workspaceSettings] = await Promise.all([
+    loadWorkspaceModelSelectionInput(db, settings, context),
+    context.workspaceSettings !== void 0 ? Promise.resolve(context.workspaceSettings) : getWorkspace(db, context.workspaceId).then((workspace) => workspace?.settings ?? {})
+  ]);
+  return await resolveDefaultSessionModelForSelections(db, {
+    settings,
+    accountId: context.accountId,
+    workspaceSettings,
+    selections: resolveWorkspaceModelSelection(selectionInput)
+  });
+}
+async function resolveScheduledTaskDefaultModel(db, settings, task) {
+  return await resolveDefaultSessionModel(db, settings, {
+    accountId: task.accountId,
+    workspaceId: task.workspaceId,
+    subjectId: task.ownerSubjectId ?? task.createdBy.subjectId,
+    xaiAuthoritySnapshot: await getScheduledTaskXaiProviderAccountAuthoritySnapshot(
+      db,
+      task.workspaceId,
+      task.id
+    )
+  });
+}
+async function resolveScheduledTaskPreflightModel(db, settings, task) {
+  if (task.agentConfig.model) return task.agentConfig.model;
+  const targetSessionId = task.runMode === "existing_session" ? task.targetSessionId : task.runMode === "reusable_session" ? task.reusableSessionId : null;
+  if (targetSessionId) {
+    const session = await getSession2(db, task.workspaceId, targetSessionId);
+    if (session) return session.model;
+  }
+  return (await resolveScheduledTaskDefaultModel(db, settings, task)).model;
+}
+
 // src/sandbox/fleet.ts
 import {
   authorizePersonalMachineForAttempt,
@@ -4024,7 +4286,7 @@ function sessionCreationMetadata(metadata) {
 
 // src/domain/sessions.ts
 import {
-  canonicalizeConfiguredModelId,
+  canonicalizeConfiguredModelId as canonicalizeConfiguredModelId2,
   configuredAllowedModels,
   withCodexCatalogProvider as withCodexCatalogProvider2,
   ORGANIZATION_GATEWAY_MODEL_ID_PREFIX as ORGANIZATION_GATEWAY_MODEL_ID_PREFIX2,
@@ -4034,7 +4296,8 @@ import {
   resolveTurnExecutionPolicyV1,
   WORKSPACE_GATEWAY_MODEL_ID_PREFIX as WORKSPACE_GATEWAY_MODEL_ID_PREFIX2,
   WORKSPACE_OPENROUTER_MODEL_ID_PREFIX as WORKSPACE_OPENROUTER_MODEL_ID_PREFIX2,
-  XAI_SUBSCRIPTION_MODEL_ID_PREFIX
+  XAI_SUBSCRIPTION_MODEL_ID_PREFIX,
+  codeSearchDeploymentPolicy
 } from "@opengeni/config";
 import {
   AUTOMATIC_SESSION_TITLE_FALLBACK,
@@ -4075,7 +4338,7 @@ import {
   listEnabledMcpCapabilityServers as listEnabledMcpCapabilityServers2,
   requireApprovalWithFloor,
   getSandbox as getSandbox3,
-  getSession as getSession2,
+  getSession as getSession3,
   getInitializedSessionCreateReplay,
   getSessionAuthorityProjection as getSessionAuthorityProjection4,
   SessionIdConflictError,
@@ -4086,7 +4349,7 @@ import {
   getSessionTurnForAttempt as getSessionTurnForAttempt3,
   getSessionTurnPersonalConnectionDelegations as getSessionTurnPersonalConnectionDelegations2,
   getSessionTurnXaiProviderAccountAuthoritySnapshot,
-  getWorkspaceModelPolicy,
+  getWorkspaceModelPolicy as getWorkspaceModelPolicy2,
   requireWorkspace as requireWorkspace4,
   initializeSessionStartAtomically,
   listSessionTurns,
@@ -4205,6 +4468,7 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { isDeepStrictEqual } from "util";
 import { withLockedCapabilityInstallation } from "@opengeni/db/capability-reconciliation";
 import { environmentsEncryptionKeyBytes as environmentsEncryptionKeyBytes2 } from "@opengeni/config";
+import { pinnedFetch } from "@opengeni/network";
 import {
   CapabilityCatalogItem,
   capabilityCatalogItemIsTrustedForExposure,
@@ -4478,7 +4742,12 @@ async function prepareCapabilityEnable(input) {
     assertRequiredMcpCredentialHeaders(item, headers, connectionRef);
     installationMetadata = {
       ...installationMetadata,
-      ...connectionRef && !headers ? authDeferredMcpConnectivity() : await validateMcpCapabilityConnection(item, input.probeMcpServer, headers ?? void 0)
+      ...connectionRef && !headers ? authDeferredMcpConnectivity() : await validateMcpCapabilityConnection(
+        item,
+        input.probeMcpServer,
+        headers ?? void 0,
+        input.settings
+      )
     };
     if (connectionRef) {
       installationConfig.connectionRef = connectionRef;
@@ -4725,7 +4994,7 @@ function requireCapabilityHeaderEncryption(settings) {
   }
   return key;
 }
-async function validateMcpCapabilityConnection(item, probe = probeStreamableHttpMcpServer, headers) {
+async function validateMcpCapabilityConnection(item, probe = probeStreamableHttpMcpServer, headers, settings) {
   if (item.kind !== "mcp") {
     return {};
   }
@@ -4740,7 +5009,8 @@ async function validateMcpCapabilityConnection(item, probe = probeStreamableHttp
       name: item.name,
       url: item.endpointUrl,
       timeoutMs: mcpCapabilityProbeTimeoutMs,
-      ...headers ? { headers } : {}
+      ...headers ? { headers } : {},
+      ...settings ? { settings } : {}
     });
     return {
       mcpConnectivity: {
@@ -4756,6 +5026,8 @@ async function validateMcpCapabilityConnection(item, probe = probeStreamableHttp
   }
 }
 async function probeStreamableHttpMcpServer(input) {
+  const settings = input.settings;
+  if (!settings) throw new Error("Network policy is unavailable for MCP validation");
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
   const client = new Client(
@@ -4767,7 +5039,11 @@ async function probeStreamableHttpMcpServer(input) {
       requestInit: {
         signal: controller.signal,
         ...input.headers ? { headers: input.headers } : {}
-      }
+      },
+      fetch: (url, init) => pinnedFetch(url, init, settings, {
+        label: "MCP capability probe",
+        requireHttpsOutsideLocalTest: true
+      })
     });
     await client.connect(transport, {
       timeout: input.timeoutMs,
@@ -6460,18 +6736,18 @@ async function listOwnConnectionAccountsForGrant(db, grant) {
 }
 async function listOwnConnectionMetadata(db, input) {
   const accounts = await listOwnedConnectionAccounts(db, input);
-  const connections = await Promise.all(
-    accounts.map(async (account) => {
-      const connection = await getConnectionMetadata2(
-        db,
-        account.originWorkspaceId,
-        account.connectionId,
-        input.subjectId
-      );
-      return connection?.accountId === input.accountId && connection.subjectId === input.subjectId && connection.authorityId != null && connection.status === "active" ? connection : null;
-    })
-  );
-  return connections.filter((connection) => connection !== null);
+  const connections = [];
+  for (const account of accounts) {
+    const connection = await getConnectionMetadata2(
+      db,
+      account.originWorkspaceId,
+      account.connectionId,
+      input.subjectId
+    );
+    if (connection?.accountId === input.accountId && connection.subjectId === input.subjectId && connection.authorityId != null && connection.status === "active")
+      connections.push(connection);
+  }
+  return connections;
 }
 async function authorizedSocialConnectionsForGrant(input) {
   const workspace = await listSocialConnections2(
@@ -8030,6 +8306,7 @@ async function createAndStartSessionWithOutcome(input) {
       ...input.scopeSubjectId !== void 0 ? { scopeSubjectId: input.scopeSubjectId } : {},
       ...input.memoryScope ? { memoryScope: input.memoryScope } : {},
       parentSessionId: input.parentSessionId ?? null,
+      ...input.codeSearchDeploymentPolicy ? { codeSearchDeploymentPolicy: input.codeSearchDeploymentPolicy } : {},
       sandboxGroupId: input.sandboxGroupId ?? null,
       ...input.sandboxOs ? { sandboxOs: input.sandboxOs } : {},
       mcpServers: input.mcpServers ?? [],
@@ -8154,7 +8431,7 @@ function canonicalConfiguredModel(settings, model) {
   if (model === null || model === void 0) {
     return model;
   }
-  const canonicalModel = canonicalizeConfiguredModelId(settings, model);
+  const canonicalModel = canonicalizeConfiguredModelId2(settings, model);
   if (canonicalModel.startsWith(CODEX_MODEL_ID_PREFIX) && settings.resolvedCodexModelsJson !== void 0) {
     if (settings.codexSubscriptionEnabled && configuredAllowedModels(withCodexCatalogProvider2(settings)).includes(canonicalModel)) {
       return canonicalModel;
@@ -8201,7 +8478,7 @@ async function assertWorkspaceModelPolicyAllows(db, settings, workspaceId, model
   if (canonicalModel === null || canonicalModel === void 0) {
     return;
   }
-  const policy = await getWorkspaceModelPolicy(db, workspaceId);
+  const policy = await getWorkspaceModelPolicy2(db, workspaceId);
   if (!policy) {
     return;
   }
@@ -8683,7 +8960,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       throw error;
     }
   }
-  const parentSession = parentSessionId ? await getSession2(db, workspaceId, parentSessionId) : null;
+  const parentSession = parentSessionId ? await getSession3(db, workspaceId, parentSessionId) : null;
   if (parentSessionId && !parentSession) {
     throw new HTTPException15(404, {
       message: `parent session not found in workspace: ${parentSessionId}`
@@ -8750,6 +9027,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   }
   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;
+  let retainedKeyedShellReasoningEffort = null;
   if (payload.idempotencyKey && (effectiveVisibility !== "user_private" || replayManagedHumanSubjectId !== null)) {
     try {
       const initializedReplay = await getInitializedSessionCreateReplay(db, {
@@ -8774,6 +9052,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
         }
         if (initializedReplay.outcome === "pending") {
           retainedKeyedShellModel = initializedReplay.session.model;
+          retainedKeyedShellReasoningEffort = initializedReplay.session.reasoningEffort;
         } else {
           if (initializedReplay.workflowWakeRevision !== null) {
             await unresolvedDeps.workflowClient.wakeSessionWorkflow({
@@ -8831,7 +9110,13 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     payload.personalResourceAttachment,
     false
   );
-  const inheritedModel = parentCallingTurn?.model ?? parentSession?.model ?? settings.openaiModel;
+  const resolvedDefault = parentSession || payload.model !== void 0 ? null : retainedKeyedShellModel !== null && retainedKeyedShellReasoningEffort !== null ? { model: retainedKeyedShellModel, reasoningEffort: retainedKeyedShellReasoningEffort } : await resolveDefaultSessionModel(db, settings, {
+    accountId: grant.accountId,
+    workspaceId,
+    subjectId: grant.subjectId,
+    workspaceSettings: workspace.settings
+  });
+  const inheritedModel = parentCallingTurn?.model ?? parentSession?.model ?? resolvedDefault?.model ?? settings.openaiModel;
   const effectiveModelId = payload.model ?? inheritedModel;
   const effectiveCatalogSettings = await resolveWorkspaceModelBoundarySettings(
     deps,
@@ -9085,7 +9370,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     throw new Error("effective session model unexpectedly resolved to null");
   }
   await assertWorkspaceModelPolicyAllows(db, settings, workspaceId, model);
-  const inheritedReasoningEffort = parentCallingTurn?.reasoningEffort ?? parentSession?.reasoningEffort ?? settings.openaiReasoningEffort;
+  const inheritedReasoningEffort = parentCallingTurn?.reasoningEffort ?? parentSession?.reasoningEffort ?? resolvedDefault?.reasoningEffort ?? settings.openaiReasoningEffort;
   const inheritedLatencyMode = parentCallingTurn?.latencyMode ?? parentSession?.latencyMode ?? "standard";
   const reasoningEffort = payload.reasoningEffort ?? inheritedReasoningEffort;
   const latencyMode = payload.latencyMode ?? inheritedLatencyMode;
@@ -9373,6 +9658,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       db,
       bus,
       workflowClient,
+      codeSearchDeploymentPolicy: codeSearchDeploymentPolicy(deps.settings),
       accountId: grant.accountId,
       workspaceId,
       visibility: effectiveVisibility,
@@ -10229,7 +10515,7 @@ async function readSessionLineage(deps, grant, sessionId) {
     surface: "core"
   });
   if (authorization?.relatedSessionAccess === "target") {
-    const session = await getSession2(deps.db, grant.workspaceId, sessionId);
+    const session = await getSession3(deps.db, grant.workspaceId, sessionId);
     if (!session) {
       throw new HTTPException15(404, { message: "session not found" });
     }
@@ -10271,6 +10557,39 @@ async function acceptSessionUserMessageWithOutcome(...args) {
   return withSessionRlsActorContext4(actor, () => acceptSessionUserMessageInFileScope(...args));
 }
 
+// src/domain/session-native-connection-replacement.ts
+import { connectionMetadataMatchesBinding } from "@opengeni/db/session-mcp-credential-rotation";
+function nativeSessionConnectionReplacement(input) {
+  const connection = input.connections.find(
+    (candidate) => candidate.id === input.nativeConnectionId
+  );
+  if (!connection || connection.accountId !== input.accountId || connection.status !== "active" || (connection.subjectId === null ? connection.workspaceId !== input.workspaceId : !input.subjectId || connection.subjectId !== input.subjectId || !connection.authorityId)) {
+    throw new Error("native connection unavailable");
+  }
+  const {
+    authoritySource: _authoritySource,
+    hostBinding: _hostBinding,
+    accountSelection: _accountSelection,
+    ...retained
+  } = input.currentRef ?? {};
+  if (input.currentRef && input.currentRef.providerDomain.toLowerCase() !== connection.providerDomain.toLowerCase())
+    throw new Error("native connection provider mismatch");
+  const ref = {
+    ...retained,
+    ...!input.currentRef?.resource && typeof connection.metadata.resource === "string" ? { resource: connection.metadata.resource } : {},
+    connectionId: connection.id,
+    providerDomain: connection.providerDomain,
+    kind: connection.kind,
+    subjectScope: connection.subjectId === null ? "workspace" : "subject"
+  };
+  const destination = input.replacementServerUrl ?? input.serverUrl;
+  if (input.replacementServerUrl && (typeof connection.metadata.mcpUrl !== "string" || !connection.metadata.mcpUrl.trim()))
+    throw new Error("native connection destination unavailable");
+  if (!connectionMetadataMatchesBinding(connection, ref, destination))
+    throw new Error("native connection binding mismatch");
+  return ref;
+}
+
 // src/application/session-mcp-credential-rotation.ts
 function sessionMcpRotationFingerprint(key, scope, request) {
   return {
@@ -10302,9 +10621,14 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
         id: update.id,
         expectedCredentialVersion: update.expectedCredentialVersion,
         expectedServerUrl: update.expectedServerUrl,
-        headers: Object.fromEntries(
-          Object.entries(normalizedSessionMcpCredentialHeaders(update.headers)).map(([name, value]) => [name.toLowerCase(), value]).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
-        )
+        ..."nativeConnectionId" in update ? {
+          nativeConnectionId: update.nativeConnectionId,
+          ...update.replacementServerUrl ? { replacementServerUrl: update.replacementServerUrl } : {}
+        } : {
+          headers: Object.fromEntries(
+            Object.entries(normalizedSessionMcpCredentialHeaders(update.headers)).map(([name, value]) => [name.toLowerCase(), value]).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+          )
+        }
       })).sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0)
     };
     if (new Set(request.updates.map((update) => update.id)).size !== request.updates.length)
@@ -10320,20 +10644,43 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
     actorType: grant.principalKind === "service" ? "service" : "human"
   };
   const externalAuthorize = externalContinuationCommitAuthorizer(authorization);
+  let authorizedGrant = grant;
   try {
     return await rotateSessionMcpCredentialsAtomically(deps.db, {
       ...scope,
       operationKey: request.operationKey,
       ...sessionMcpRotationFingerprint(encryptionKey, scope, request),
-      updates: request.updates.map(({ headers, ...update }) => ({
-        ...update,
-        headersEncrypted: Object.fromEntries(
-          Object.entries(headers).map(([name, value]) => [
-            name,
-            encryptVariableSetValue3(encryptionKey, value)
-          ])
-        )
-      })),
+      updates: request.updates.map(
+        (update) => "nativeConnectionId" in update ? update : {
+          id: update.id,
+          expectedCredentialVersion: update.expectedCredentialVersion,
+          expectedServerUrl: update.expectedServerUrl,
+          headersEncrypted: Object.fromEntries(
+            Object.entries(update.headers).map(([name, value]) => [
+              name,
+              encryptVariableSetValue3(encryptionKey, value)
+            ])
+          )
+        }
+      ),
+      resolveNativeConnection: async (tx, server, nativeConnectionId, replacementServerUrl) => {
+        const connections = await listOwnConnectionAccountsForGrant(tx, authorizedGrant);
+        const source = personalConnectionDelegationSourceForGrant(authorizedGrant);
+        try {
+          return nativeSessionConnectionReplacement({
+            accountId: grant.accountId,
+            workspaceId: grant.workspaceId,
+            subjectId: source.kind === "subject" ? source.subjectId : null,
+            serverUrl: server.url,
+            ...replacementServerUrl ? { replacementServerUrl } : {},
+            currentRef: server.connectionRef,
+            nativeConnectionId,
+            connections
+          });
+        } catch {
+          throw new SessionMcpCredentialRotationError("connection_unavailable");
+        }
+      },
       authorize: async (tx) => {
         await externalAuthorize?.(tx);
         const fresh = await reauthorize(tx);
@@ -10356,6 +10703,7 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
           operation: "session.mcp.credentials.rotate",
           surface: "http"
         });
+        authorizedGrant = fresh;
       }
     });
   } catch (error) {
@@ -10366,7 +10714,7 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
     if (error instanceof SessionAuthorizationUnavailableError)
       throw new HTTPException16(503, { message: "credential rotation authorization unavailable" });
     if (error instanceof SessionMcpCredentialRotationError) {
-      const status = error.code === "receipt_key_unavailable" ? 503 : error.code === "authority_revoked" ? 403 : error.code === "not_found" ? 404 : error.code === "invalid_request" || error.code === "brokered_server" ? 422 : 409;
+      const status = error.code === "receipt_key_unavailable" ? 503 : error.code === "authority_revoked" ? 403 : error.code === "not_found" ? 404 : error.code === "invalid_request" || error.code === "brokered_server" || error.code === "connection_unavailable" ? 422 : 409;
       throw new HTTPException16(status, { message: `credential_rotation_${error.code}` });
     }
     throw new HTTPException16(503, { message: "credential rotation unavailable" });
@@ -10807,7 +11155,7 @@ function sha256Hex2(bytes) {
 }
 
 // src/domain/skill-search.ts
-import { pinnedFetch, readResponseJsonBounded } from "@opengeni/network";
+import { pinnedFetch as pinnedFetch2, readResponseJsonBounded } from "@opengeni/network";
 var PublicSkillSearchError = class extends Error {
   constructor(code, message, retryAfterSeconds = null) {
     super(message);
@@ -10822,7 +11170,7 @@ var maxResponseBytes = 256 * 1024;
 var maxResults = 20;
 var ownerPattern = /^[a-z0-9](?:[a-z0-9-]{0,38})$/iu;
 var segmentPattern = /^[a-z0-9](?:[a-z0-9._-]{0,98}[a-z0-9])?$/iu;
-function createPublicSkillSearchClient(settings, fetcher = pinnedFetch) {
+function createPublicSkillSearchClient(settings, fetcher = pinnedFetch2) {
   return {
     async search(input) {
       const query = input.query.trim();
@@ -10949,7 +11297,7 @@ function parseRetryAfter(value) {
 
 // src/domain/github-skill-source.ts
 import { HTTPException as HTTPException19 } from "hono/http-exception";
-import { pinnedFetch as pinnedFetch2, readResponseJsonBounded as readResponseJsonBounded2, readResponseTextBounded } from "@opengeni/network";
+import { pinnedFetch as pinnedFetch3, readResponseJsonBounded as readResponseJsonBounded2, readResponseTextBounded } from "@opengeni/network";
 import {
   PORTABLE_SKILL_MAX_FILES as PORTABLE_SKILL_MAX_FILES2,
   PORTABLE_SKILL_MAX_FILE_BYTES as PORTABLE_SKILL_MAX_FILE_BYTES2,
@@ -11050,7 +11398,7 @@ function createGitHubSkillSourceClient(settings, requestJson = (path, maxBytes,
 }
 async function downloadSkillSnapshot(settings, owner, repository, slug) {
   const signal = AbortSignal.timeout(githubRequestTimeoutMs);
-  const response = await pinnedFetch2(
+  const response = await pinnedFetch3(
     `https://skills.sh/api/download/${[owner, repository, slug].map(encodeURIComponent).join("/")}`,
     { headers: { accept: "application/json" }, credentials: "omit", redirect: "manual", signal },
     settings,
@@ -11085,7 +11433,7 @@ async function githubJson(settings, path, maxBytes, label) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), githubRequestTimeoutMs);
   try {
-    const response = await pinnedFetch2(
+    const response = await pinnedFetch3(
       `${githubApiBase}${path}`,
       {
         method: "GET",
@@ -12544,10 +12892,10 @@ import {
   getRig as getRig4,
   getScheduledTask,
   getScheduledTaskIncludingDeletedForUpdate,
-  getScheduledTaskXaiProviderAccountAuthoritySnapshot,
+  getScheduledTaskXaiProviderAccountAuthoritySnapshot as getScheduledTaskXaiProviderAccountAuthoritySnapshot2,
   getSandbox as getSandbox4,
   getSessionTurnXaiProviderAccountAuthoritySnapshot as getSessionTurnXaiProviderAccountAuthoritySnapshot2,
-  getSession as getSession3,
+  getSession as getSession4,
   getSessionAuthorityProjection as getSessionAuthorityProjection5,
   withSessionRlsActorContext as withSessionRlsActorContext5,
   nestedPostgresSqlState as nestedPostgresSqlState6,
@@ -12804,7 +13152,7 @@ async function createValidatedScheduledTask(input) {
   );
 }
 async function frozenScheduledTaskCreatorPolicy(input) {
-  const session = await getSession3(input.db, input.grant.workspaceId, input.sessionId);
+  const session = await getSession4(input.db, input.grant.workspaceId, input.sessionId);
   if (!session) {
     throw new HTTPException21(403, {
       message: "the calling agent session is not available in this workspace"
@@ -13002,7 +13350,7 @@ async function validateScheduledTaskTarget(input) {
     }
     throw error;
   }
-  const session = await getSession3(input.db, input.grant.workspaceId, input.targetSessionId);
+  const session = await getSession4(input.db, input.grant.workspaceId, input.targetSessionId);
   if (!session || session.accountId !== input.grant.accountId) {
     throw new HTTPException21(404, { message: "target session not found" });
   }
@@ -13274,7 +13622,7 @@ async function validatedScheduledTaskUpdate(input) {
     });
     if (beforeUpdateCommit) update.beforeUpdateCommit = beforeUpdateCommit;
   }
-  const existingXaiAuthority = await getScheduledTaskXaiProviderAccountAuthoritySnapshot(
+  const existingXaiAuthority = await getScheduledTaskXaiProviderAccountAuthoritySnapshot2(
     input.db,
     input.existing.workspaceId,
     input.existing.id
@@ -13304,22 +13652,32 @@ async function validatedScheduledTaskUpdate(input) {
       rigId: input.payload.rigId !== void 0 ? input.payload.rigId : input.existing.rigId,
       agentConfig: nextAgentConfig
     });
+    const nextConnectionTools = await scheduledConnectionTools(
+      input.db,
+      input.grant.workspaceId,
+      runtimeSettings,
+      nextTarget,
+      nextAgentConfig.tools,
+      ownerSubjectId ?? void 0
+    );
+    const priorMcpIds = new Set(
+      input.existing.agentConfig.tools.filter((tool) => tool.kind === "mcp").map((tool) => tool.id)
+    );
+    const nextMcpIds = new Set(
+      nextConnectionTools.filter((tool) => tool.kind === "mcp").map((tool) => tool.id)
+    );
+    const authoritySelections = (nextAgentConfig.connectionAccounts ?? []).filter(
+      (selection) => input.payload.connectionAccounts !== void 0 || !priorMcpIds.has(selection.serverId) || nextMcpIds.has(selection.serverId)
+    );
     const acceptedConnections = await freezeConnectionAccounts({
       db: input.db,
       accountId: input.grant.accountId,
       workspaceId: input.grant.workspaceId,
       settings: nextTarget ? settingsWithSessionMcpServerMetadata(runtimeSettings, nextTarget.mcpServers) : runtimeSettings,
-      tools: await scheduledConnectionTools(
-        input.db,
-        input.grant.workspaceId,
-        runtimeSettings,
-        nextTarget,
-        nextAgentConfig.tools,
-        ownerSubjectId ?? void 0
-      ),
+      tools: nextConnectionTools,
       resources: nextTarget?.resources ?? nextAgentConfig.resources,
       source: ownerSubjectId ? { kind: "subject", subjectId: ownerSubjectId, accountId: input.existing.accountId } : { kind: "none" },
-      authoritySelections: nextAgentConfig.connectionAccounts ?? [],
+      authoritySelections,
       authoritySelectionsFrozen: input.payload.connectionAccounts === void 0 && input.existing.agentConfig.connectionAccountsFrozen === true,
       ...scheduledConnectionSurfaceEligibility(runtimeSettings, nextTarget)
     });
@@ -13564,7 +13922,7 @@ function manualScheduledTaskTriggerUsageKey(workspaceId, taskId, triggerToken) {
 }
 async function validateScheduledTaskAgentConfig(input) {
   const actor = scheduledTaskInitiatorForGrant(input.grant).actor;
-  const parent = actor ? await getSession3(input.db, input.workspaceId, actor.sessionId) : null;
+  const parent = actor ? await getSession4(input.db, input.workspaceId, actor.sessionId) : null;
   if (actor && (!parent || parent.accountId !== input.grant.accountId)) {
     throw new HTTPException21(403, {
       message: "Scheduled Skill selection requires the creating agent's session"
@@ -16109,6 +16467,7 @@ import {
   getSandbox as getSandbox5,
   getVariableSet as getVariableSet3,
   NewSessionDraftAccessError,
+  newSessionDraftModelProvided,
   newSessionDraftSelectedProjectChannelId,
   newSessionDraftToolsProvided,
   newSessionSelectionHistory,
@@ -16119,6 +16478,7 @@ import {
   withWorkspaceSubjectRls as withWorkspaceSubjectRls6
 } from "@opengeni/db";
 import { HTTPException as HTTPException23 } from "hono/http-exception";
+import { canonicalizeConfiguredModelId as canonicalizeConfiguredModelId3 } from "@opengeni/config";
 function hasOwn(value, key) {
   return typeof value === "object" && value !== null && Object.hasOwn(value, key);
 }
@@ -16134,16 +16494,39 @@ function mapNewSessionDraft(row) {
     model: row.model,
     reasoningEffort: row.reasoningEffort,
     latencyMode: row.latencyMode,
+    ...newSessionDraftModelProvided(row) !== void 0 ? { modelProvided: newSessionDraftModelProvided(row) } : {},
     ...selectedProjectChannelId !== void 0 ? { selectedProjectChannelId } : {},
     options: publicNewSessionDraftOptions(row),
     selectionHistory: newSessionSelectionHistory(row),
     updatedAt: row.updatedAt.toISOString()
   });
 }
-async function hydrateNewSessionDraft(deps, grant, workspaceId, row) {
+function draftModelProvided(settings, draft) {
+  if (draft.modelProvided !== void 0) return draft.modelProvided;
+  return !(canonicalizeConfiguredModelId3(settings, draft.model) === canonicalizeConfiguredModelId3(settings, settings.openaiModel) && draft.reasoningEffort === settings.openaiReasoningEffort && draft.latencyMode === "standard");
+}
+async function actorDefaultModel(deps, grant, workspaceId) {
+  return await resolveDefaultSessionModel(deps.db, deps.settings, {
+    accountId: grant.accountId,
+    workspaceId,
+    subjectId: grant.subjectId
+  });
+}
+async function hydrateNewSessionDraft(deps, grant, workspaceId, row, readOptions = {}) {
   if (!row) return null;
-  const mapped = mapNewSessionDraft(row);
-  if (!mapped) return null;
+  const stored = mapNewSessionDraft(row);
+  if (!stored) return null;
+  const modelProvided = draftModelProvided(deps.settings, stored);
+  let mapped = { ...stored, modelProvided };
+  if (!modelProvided && readOptions.projectDefaultModel !== false) {
+    const resolved = await actorDefaultModel(deps, grant, workspaceId);
+    mapped = {
+      ...mapped,
+      model: resolved.model,
+      reasoningEffort: resolved.reasoningEffort,
+      latencyMode: resolved.model === stored.model ? stored.latencyMode : "standard"
+    };
+  }
   const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(
     deps.db,
     workspaceId,
@@ -16233,7 +16616,7 @@ async function hydrateNewSessionDraft(deps, grant, workspaceId, row) {
     options
   };
 }
-async function getActorNewSessionDraftInFileScope(deps, grant, workspaceId) {
+async function getActorNewSessionDraftInFileScope(deps, grant, workspaceId, readOptions = {}) {
   const row = await withWorkspaceSubjectRls6(
     deps.db,
     workspaceId,
@@ -16243,15 +16626,19 @@ async function getActorNewSessionDraftInFileScope(deps, grant, workspaceId) {
       subjectId: grant.subjectId
     })
   );
-  return await hydrateNewSessionDraft(deps, grant, workspaceId, row) ?? {
+  const hydrated = await hydrateNewSessionDraft(deps, grant, workspaceId, row, readOptions);
+  if (hydrated) return hydrated;
+  const resolved = readOptions.projectDefaultModel === false ? { model: deps.settings.openaiModel, reasoningEffort: deps.settings.openaiReasoningEffort } : await actorDefaultModel(deps, grant, workspaceId);
+  return {
     revision: 0,
     text: "",
     resources: [],
     tools: [],
     toolsProvided: false,
-    model: deps.settings.openaiModel,
-    reasoningEffort: deps.settings.openaiReasoningEffort,
+    model: resolved.model,
+    reasoningEffort: resolved.reasoningEffort,
     latencyMode: "standard",
+    modelProvided: false,
     options: {},
     selectionHistory: { projects: [] },
     updatedAt: null
@@ -16302,6 +16689,7 @@ async function saveActorNewSessionDraftInFileScope(deps, grant, workspaceId, raw
           model: input.model,
           reasoningEffort: input.reasoningEffort,
           latencyMode: input.latencyMode,
+          ...input.modelProvided !== void 0 ? { modelProvided: input.modelProvided } : {},
           ...input.selectedProjectChannelId !== void 0 ? { selectedProjectChannelId: input.selectedProjectChannelId } : {},
           options: input.options,
           // Only managed people are removed through removeWorkspaceMember().
@@ -16317,7 +16705,8 @@ async function saveActorNewSessionDraftInFileScope(deps, grant, workspaceId, raw
         })
       )
     );
-    return mapNewSessionDraft(saved);
+    const mapped = mapNewSessionDraft(saved);
+    return { ...mapped, modelProvided: draftModelProvided(deps.settings, mapped) };
   } catch (error) {
     if (error instanceof NewSessionDraftAccessError) {
       throw new HTTPException23(403, { message: error.message });
@@ -16325,11 +16714,11 @@ async function saveActorNewSessionDraftInFileScope(deps, grant, workspaceId, raw
     throw error;
   }
 }
-async function getActorNewSessionDraft(deps, grant, workspaceId, authorization) {
+async function getActorNewSessionDraft(deps, grant, workspaceId, authorization, readOptions = {}) {
   const actor = authorization ? await fileOwnerContextForAccess(deps, authorization, "sessions:read") : { subjectId: grant.subjectId, privateFileOwnerSubjectId: null };
   return withSessionRlsActorContext6(
     actor,
-    () => getActorNewSessionDraftInFileScope(deps, grant, workspaceId)
+    () => getActorNewSessionDraftInFileScope(deps, grant, workspaceId, readOptions)
   );
 }
 async function saveActorNewSessionDraft(...args) {
@@ -16338,11 +16727,15 @@ async function saveActorNewSessionDraft(...args) {
   return withSessionRlsActorContext6(actor, () => saveActorNewSessionDraftInFileScope(...args));
 }
 async function getActorNewSessionDefaults(deps, grant, workspaceId) {
-  const draft = await getActorNewSessionDraft(deps, grant, workspaceId);
+  const draft = await getActorNewSessionDraft(deps, grant, workspaceId, void 0, {
+    projectDefaultModel: false
+  });
   const options = draft.options;
   return {
-    // Revision zero is a synthetic empty form, not a user's model preference.
-    ...draft.revision > 0 ? {
+    // Only a model the person chose is carried over. A draft that follows the
+    // default (including the synthetic revision-zero form) leaves the model
+    // out, so session creation resolves the same default itself.
+    ...draft.revision > 0 && draft.modelProvided === true ? {
       model: draft.model,
       reasoningEffort: draft.reasoningEffort,
       latencyMode: draft.latencyMode
@@ -16405,7 +16798,7 @@ import {
   deleteSessionQueueItemInTransaction,
   editQueuedTurnInTransaction,
   getComposerDraftInTransaction,
-  getSession as getSession4,
+  getSession as getSession5,
   getSessionEvent as getSessionEvent3,
   getWorkspaceControlEvent as getWorkspaceControlEvent2,
   getSessionQueueSnapshot,
@@ -17103,7 +17496,7 @@ async function getHumanComposerDraft(deps, context) {
   );
   const mapped = composerDraft(row);
   if (mapped) return mapped;
-  const session = await getSession4(deps.db, context.workspaceId, context.sessionId);
+  const session = await getSession5(deps.db, context.workspaceId, context.sessionId);
   if (!session) throw new Error(`Session not found: ${context.sessionId}`);
   return {
     revision: 0,
@@ -18044,6 +18437,7 @@ export {
   causalFrontierDominates,
   causalFrontiersEqual,
   checkLimit,
+  clampReasoningEffortForConfiguredModel,
   classifyRigVerificationOutcome,
   codexAppsCatalogItem,
   compareCodeUnits,
@@ -18069,10 +18463,12 @@ export {
   createSessionForRequestWithOutcome,
   createValidatedScheduledTask,
   creationInitiatorForGrant,
+  creditsDefaultSessionModel,
   decodeEditableArtifactBrokerHint,
   decodeEditableArtifactLiveClientWireFrame,
   decodeEditableArtifactLiveServerWireFrame,
   defaultPrReviewProviderBaseUrl,
+  defaultReasoningEffortForConfiguredModel,
   defaultSessionMcpServerIds,
   defaultVideoGenerationPolicy,
   deleteHumanQueuePrompt,
@@ -18083,6 +18479,7 @@ export {
   disableCapability,
   discoverMcpRegistryCapabilities,
   documentEmbeddingCostMicros,
+  draftModelProvided,
   editHumanQueuePrompt,
   editableArtifactActorKey,
   editableArtifactAuthorizationRevisionPortFromPostgres,
@@ -18187,6 +18584,7 @@ export {
   listRigVersionsForApi,
   listSkills,
   loadRigDefaultVariableSetEnvironment,
+  loadWorkspaceModelSelectionInput,
   lockActiveCustomModelForAdmission,
   lookupExternalIdentityForRequest,
   managedSessionGroupBackend,
@@ -18305,12 +18703,16 @@ export {
   resolveCatalogSettings,
   resolveChildGoalFromAcceptedSnapshot,
   resolveCodexAppsCredentialIdForRun,
+  resolveDefaultSessionModel,
+  resolveDefaultSessionModelForSelections,
   resolveFikenDefaultCompanySlug,
   resolveFirstPartyMcpToolsForCreate,
   resolveGitHubRepositoryBindings,
   resolveMemberSubjectId,
   resolveRigProviderImageForRun,
   resolveRigProviderImageSelection,
+  resolveScheduledTaskDefaultModel,
+  resolveScheduledTaskPreflightModel,
   resolveSessionCreateScope,
   resolveSessionCreateVisibility,
   resolveSessionSandboxRuntime,
@@ -18351,6 +18753,7 @@ export {
   scheduledTaskTriggerToken,
   searchCapabilityCatalogItems,
   searchKnowledgeEntries,
+  selectDefaultSessionModel,
   selectedPersonalConnectionServers,
   sendAgentSessionMessage,
   sessionGroupMachinePresentation,