@opengeni/core 5.1.1 → 5.2.0-canary.37090756480001

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "5.1.1",
+  "version": "5.2.0-canary.37090756480001",
   "description": "OpenGeni framework-agnostic core: the domain, access, and billing layers (neutral access, off-HTTP V2 surface). Behavior-preserving extraction from apps/api — keeps Hono's HTTPException for error throwing (typed-errors cleanup deferred).",
   "license": "Apache-2.0",
   "repository": {
@@ -50,17 +50,17 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opengeni/capabilities": "^0.3.5",
-    "@opengeni/codex": "^0.2.31",
-    "@opengeni/config": "^3.2.1",
-    "@opengeni/contracts": "^5.6.0",
-    "@opengeni/db": "^6.5.0",
-    "@opengeni/documents": "^0.8.40",
-    "@opengeni/events": "^0.4.38",
-    "@opengeni/network": "^0.3.1",
-    "@opengeni/observability": "^0.8.37",
-    "@opengeni/runtime": "^4.6.0",
-    "@opengeni/storage": "^0.2.138",
+    "@opengeni/capabilities": "^0.3.6-canary.37090756480001",
+    "@opengeni/codex": "^0.2.32-canary.37090756480001",
+    "@opengeni/config": "^3.3.0-canary.37090756480001",
+    "@opengeni/contracts": "^5.7.0-canary.37090756480001",
+    "@opengeni/db": "^6.6.0-canary.37090756480001",
+    "@opengeni/documents": "^0.8.41-canary.37090756480001",
+    "@opengeni/events": "^0.4.39-canary.37090756480001",
+    "@opengeni/network": "^0.3.1-canary.37090756480001",
+    "@opengeni/observability": "^0.8.38-canary.37090756480001",
+    "@opengeni/runtime": "^4.7.0-canary.37090756480001",
+    "@opengeni/storage": "^0.2.139-canary.37090756480001",
     "hono": "^4.12.18",
     "zod": "^4.2.1"
   },

package/src/access/index.ts

@@ -20,6 +20,7 @@ import {
   bootstrapWorkspace,
   ensureManagedAccessForUser,
   ensureExternalIdentity,
+  lockExternalWorkspaceMembershipLifecycle,
   resolveExternalIdentityLink,
   managedPersonalWorkspacePermissions,
   nestedPostgresSqlState,
@@ -957,9 +958,15 @@ async function apiKeyAccessContext(
     }
     let identity: ExternalIdentity;
     try {
-      identity = await ensureExternalIdentity(deps.db, {
-        accountId: apiKey.accountId,
-        ...selection.identity,
+      identity = await withAccountRls(deps.db, apiKey.accountId, async (tx) => {
+        // Provisioning locks the live membership after its identity lock.
+        // Claim the lifecycle prefix first so a membership-fenced session
+        // writer can recheck that identity without a lock inversion.
+        await lockExternalWorkspaceMembershipLifecycle(tx, apiKey.accountId);
+        return await ensureExternalIdentity(tx, {
+          accountId: apiKey.accountId,
+          ...selection.identity,
+        });
       });
     } catch (error) {
       if (nestedPostgresSqlState(error) === "42501") {

package/src/default-session-model.ts

@@ -114,8 +114,22 @@ function creditsCandidate(
 ): DefaultModelSelection | null {
   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 (deployment?.availability.selectable && deployment.model.cost === "credits") {
+    // An operator's paid deployment default is never replaced. When it is the
+    // credits default model itself, credit holders get the credits default
+    // effort rather than the deployment-wide fallback effort.
+    if (configured?.model.id !== deployment.model.id) return null;
+    return {
+      model: deployment.model.id,
+      reasoningEffort: clampReasoningEffortForConfiguredModel(
+        deployment.model,
+        input.settings.creditsDefaultReasoningEffort,
+        fallbackEffort,
+      ),
+      source: "credits",
+    };
+  }
   if (configured?.availability.selectable && configured.model.cost === "credits") {
     return {
       model: configured.model.id,
@@ -155,9 +169,10 @@ function creditsCandidate(
  *    balance (a purchase, a grant, or the verified-signup trial grant), the
  *    configured credits default (`OPENGENI_CREDITS_DEFAULT_MODEL`, effort
  *    clamped to what the model supports), or the first selectable
- *    credits-billed model when that one is not selectable. Skipped when the
- *    deployment default is already a selectable credits-billed model, so an
- *    operator's paid default is never replaced.
+ *    credits-billed model when that one is not selectable. When the
+ *    deployment default is already a selectable credits-billed model it is
+ *    never replaced: it keeps the deployment effort, except that it takes the
+ *    credits default effort when it is the credits default model itself.
  * 4. `deployment`: the deployment default with the deployment reasoning effort
  *    when stably admissible; otherwise the first stably admissible catalog
  *    model with its own default effort. With no admitted models, retain the

package/src/dependencies.ts

@@ -206,6 +206,8 @@ export type AppDependencies = {
   managedEmailTransport?: ManagedEmailTransport;
   /** Injectable Codex HTTP transport for deterministic API/provider tests. */
   codexFetch?: typeof fetch;
+  /** Injectable transport for customer OpenAI/Azure connection checks. */
+  directModelFetch?: typeof fetch;
   /** Injectable GitHub transport for deterministic personal-OAuth tests. */
   githubPersonalFetch?: typeof fetch;
   /** Injectable credential-free GitHub transport for public repository verification tests. */

package/src/domain/connector-tool-permissions.ts

@@ -15,6 +15,8 @@ import type {
   ConnectorToolPermissionEntry,
   ConnectorToolPermissionsResponse,
   UpdateConnectorToolPermissionsRequest,
+  ConnectionMetadata,
+  McpServerConnectionRef,
 } from "@opengeni/contracts";
 import {
   buildConnectionTokenResolver,
@@ -59,6 +61,34 @@ export function connectorToolGroup(tool: ListedTool): "read" | "write" | "other"
   return "other";
 }
 
+/** A selector can supply discovery credentials only when one visible account
+ * matches. Never apply one account's approval choices to an arbitrary sibling. */
+export function unpinnedConnectorToolPermissionAccount<T extends ConnectionMetadata>(
+  ref: McpServerConnectionRef,
+  visible: T[],
+  subjectId: string,
+): T | null {
+  const matches = visible.filter(
+    (candidate) =>
+      candidate.subjectId === (ref.subjectScope === "subject" ? subjectId : null) &&
+      candidate.providerDomain === ref.providerDomain &&
+      (!ref.kind || candidate.kind === ref.kind) &&
+      candidate.status === "active",
+  );
+  if (matches.length > 1)
+    throw new HTTPException(409, {
+      message: "Choose one account to manage its tool permissions",
+    });
+  return matches[0] ?? null;
+}
+
+export function connectorToolPermissionReference(
+  ref: McpServerConnectionRef,
+  connectionId: string,
+): McpServerConnectionRef {
+  return { ...ref, accountSelection: undefined, connectionId };
+}
+
 async function resolveTarget(input: Input) {
   if (input.capabilityId.startsWith("api:")) {
     // API Integrations are not MCP connectors: their per-tool approval is part
@@ -97,20 +127,17 @@ async function resolveTarget(input: Input) {
         input.grant.subjectId,
       )
     : null;
-  if (ref?.subjectScope === "subject" && !ref.connectionId) {
+  if (
+    ref &&
+    !ref.connectionId &&
+    (ref.subjectScope === "subject" || ref.accountSelection === "all_eligible")
+  ) {
     const visible = await listConnectionsMetadata(
       input.db,
       input.workspaceId,
       input.grant.subjectId,
     );
-    connection =
-      visible.find(
-        (candidate) =>
-          candidate.subjectId === input.grant.subjectId &&
-          candidate.providerDomain === ref.providerDomain &&
-          (!ref.kind || candidate.kind === ref.kind) &&
-          candidate.status === "active",
-      ) ?? null;
+    connection = unpinnedConnectorToolPermissionAccount(ref, visible, input.grant.subjectId);
   }
   if (
     ref &&
@@ -155,7 +182,10 @@ async function listTools(
       ...(target.connection?.subjectId ? { subjectId: input.grant.subjectId } : {}),
       serverId: target.server.id,
       toolName: "tools/list",
-      connectionRef: { ...target.server.connectionRef, connectionId: target.connectionId },
+      connectionRef: connectorToolPermissionReference(
+        target.server.connectionRef,
+        target.connectionId,
+      ),
       destinationUrl: target.server.url,
     });
     if (result.status !== "ok") throw new Error("Reconnect this connector to load its tools.");

package/src/domain/direct-model-provider.ts

@@ -0,0 +1,62 @@
+import { DirectModelProviderMetadata } from "@opengeni/contracts";
+import { HTTPException } from "hono/http-exception";
+
+/** Verify the customer's exact route without persisting their key or test response. */
+export async function verifyDirectModelAccess(
+  input: DirectModelProviderMetadata,
+  apiKey: string,
+  fetchImpl: typeof fetch = fetch,
+): Promise<void> {
+  const config = DirectModelProviderMetadata.parse(input);
+  const baseUrl = config.provider === "openai" ? "https://api.openai.com/v1" : config.endpoint!;
+  let response: Response;
+  try {
+    response = await fetchImpl(`${baseUrl}/responses`, {
+      method: "POST",
+      redirect: "error",
+      signal: AbortSignal.timeout(15_000),
+      headers: {
+        "content-type": "application/json",
+        ...(config.provider === "openai"
+          ? { authorization: `Bearer ${apiKey}` }
+          : { "api-key": apiKey }),
+      },
+      body: JSON.stringify({
+        model: config.model,
+        input: "Reply OK.",
+        max_output_tokens: 32,
+        store: false,
+      }),
+    });
+  } catch {
+    throw new HTTPException(502, {
+      message: "We couldn’t reach your model provider. Check the endpoint and try again.",
+    });
+  }
+  // Never reflect provider responses: they can include credentials or request details.
+  if (response.status === 401 || response.status === 403) {
+    throw new HTTPException(422, {
+      message: "Your provider didn’t accept this API key. Check the key and its permissions.",
+    });
+  }
+  if (response.status === 404 || response.status === 400) {
+    throw new HTTPException(422, {
+      message:
+        config.provider === "azure_openai"
+          ? "Azure couldn’t use this deployment. Check the endpoint and deployment name."
+          : "OpenAI couldn’t use this model. Check the model name and your account’s access.",
+    });
+  }
+  if (response.status === 429) {
+    throw new HTTPException(422, {
+      message:
+        "Your provider’s quota or rate limit blocked the check. Check your provider billing or try again shortly.",
+    });
+  }
+  const body = response.ok ? await response.json().catch(() => null) : null;
+  if (!body || !["completed", "incomplete"].includes(body.status)) {
+    throw new HTTPException(502, {
+      message: "Your provider couldn’t complete the connection check. Try again shortly.",
+    });
+  }
+}

package/src/domain/insights.ts

@@ -11,6 +11,7 @@ import {
   countSessionsAttachedToGroups,
   enumerateUtcDays,
   enumerateUtcHours,
+  getSessionAccessProjection,
   listFloorSessions,
   listLiveWarmLeases,
   listScheduledTasks,
@@ -27,20 +28,35 @@ const MACHINE_HEARTBEAT_FRESH_MS = 120_000;
 export const WORKSPACE_INSIGHTS_PROVIDER_FILTER_MAX_UTF8_BYTES = 256;
 export const WORKSPACE_INSIGHTS_MODEL_FILTER_MAX_UTF8_BYTES = 512;
 
-export type WorkspaceInsightsFilterField = "provider" | "model";
+export type WorkspaceInsightsFilterField = "provider" | "model" | "rootSessionId" | "sessionId";
 
 export class WorkspaceInsightsFilterValidationError extends Error {
   readonly field: WorkspaceInsightsFilterField;
   readonly maxUtf8Bytes: number;
 
-  constructor(field: WorkspaceInsightsFilterField, maxUtf8Bytes: number) {
-    super(`${field} must be at most ${maxUtf8Bytes} UTF-8 bytes`);
+  constructor(field: WorkspaceInsightsFilterField, maxUtf8Bytes: number, message?: string) {
+    super(message ?? `${field} must be at most ${maxUtf8Bytes} UTF-8 bytes`);
     this.name = "WorkspaceInsightsFilterValidationError";
     this.field = field;
     this.maxUtf8Bytes = maxUtf8Bytes;
   }
 }
 
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/** Normalize a session drilldown scope; only exact UUIDs are accepted. */
+export function normalizeWorkspaceInsightsSessionScope(
+  value: string | null | undefined,
+  field: "rootSessionId" | "sessionId",
+): string | null {
+  const normalized = value?.trim() || null;
+  if (normalized === null || normalized === "all") return null;
+  if (!UUID_PATTERN.test(normalized)) {
+    throw new WorkspaceInsightsFilterValidationError(field, 36, `${field} must be a UUID`);
+  }
+  return normalized.toLowerCase();
+}
+
 /** Normalize the public filter sentinel and enforce the database authority envelope. */
 export function normalizeWorkspaceInsightsFilter(
   value: string | null | undefined,
@@ -63,6 +79,8 @@ export type GetWorkspaceInsightsInput = {
   range: InsightsRange;
   provider?: string | null;
   model?: string | null;
+  rootSessionId?: string | null;
+  sessionId?: string | null;
   now?: Date;
 };
 
@@ -209,6 +227,23 @@ export function insightsSessionLabel(input: {
   return `${(input.depth ?? 0) > 0 ? "Agent" : "Session"} ${input.id.slice(0, 8)}`;
 }
 
+export function insightsProjectLabel(input: {
+  kind: "project" | "other" | "unfiled" | "unavailable";
+  name: string | null;
+  projects: number;
+}): string {
+  switch (input.kind) {
+    case "project":
+      return input.name?.trim() || "Untitled project";
+    case "other":
+      return `${input.projects.toLocaleString("en-US")} other ${input.projects === 1 ? "project" : "projects"}`;
+    case "unfiled":
+      return "No project";
+    case "unavailable":
+      return "Root session not visible";
+  }
+}
+
 export async function getWorkspaceInsights(
   db: Database,
   settings: Settings,
@@ -217,13 +252,23 @@ export async function getWorkspaceInsights(
 ): Promise<WorkspaceInsightsResponse> {
   const provider = normalizeWorkspaceInsightsFilter(input.provider, "provider");
   const model = normalizeWorkspaceInsightsFilter(input.model, "model");
+  const rootSessionId = normalizeWorkspaceInsightsSessionScope(
+    input.rootSessionId,
+    "rootSessionId",
+  );
+  const sessionId = normalizeWorkspaceInsightsSessionScope(input.sessionId, "sessionId");
   await measureInsightsPhase(observePhase, "require_workspace", () =>
     requireWorkspace(db, input.workspaceId),
   );
+  const [visibleRootScope, visibleSessionScope] = await Promise.all([
+    rootSessionId ? getSessionAccessProjection(db, input.workspaceId, rootSessionId) : null,
+    sessionId ? getSessionAccessProjection(db, input.workspaceId, sessionId) : null,
+  ]);
   const now = input.now ?? new Date();
   const window = resolveRangeWindow(input.range, now);
   const modelFilterActive = Boolean(provider || model);
-  const filter = { provider, model };
+  const scopeActive = Boolean(rootSessionId || sessionId);
+  const filter = { provider, model, rootSessionId, sessionId };
 
   const [modelBundle, usageBundle, liveWarm, tasks, depth, floorRows, machinesOnline] =
     await Promise.all([
@@ -275,10 +320,18 @@ export async function getWorkspaceInsights(
     factBuckets: factDays,
     rootDrivers,
     priorRootDrivers,
+    projects,
+    privateChats,
+    privateChatsTruncated,
     scheduleFacts,
     facets,
     recentCalls,
     promptContributions,
+    dataThrough,
+    driverGroups,
+    driversTruncated,
+    facetsTruncated,
+    recentCallsTruncated,
   } = modelBundle;
   const {
     workspaceCreditMicros,
@@ -369,6 +422,8 @@ export async function getWorkspaceInsights(
     0,
   );
   const modelCalls = modelRows.reduce((sum, row) => sum + row.calls, 0);
+  const cachedTokens = modelRows.reduce((sum, row) => sum + row.cachedTokens, 0);
+  const cacheInputTokens = modelRows.reduce((sum, row) => sum + row.cacheInputTokens, 0);
   const priorInputTokens = priorModelRows.reduce((sum, row) => sum + row.inputTokens, 0);
   const priorTotalTokens = priorModelRows.reduce((sum, row) => sum + row.totalTokens, 0);
   const priorCachedTokens = priorModelRows.reduce((sum, row) => sum + row.cachedTokens, 0);
@@ -397,9 +452,10 @@ export async function getWorkspaceInsights(
       cacheKnownCalls: 0,
       calls: 0,
     };
-    const modelCostMicros = modelFilterActive
-      ? facts.costMicros
-      : (usageBuckets.get(bucket)?.costMicros ?? facts.costMicros);
+    const modelCostMicros =
+      modelFilterActive || scopeActive
+        ? facts.costMicros
+        : (usageBuckets.get(bucket)?.costMicros ?? facts.costMicros);
     return {
       label: input.range === "today" ? bucket.slice(11) : bucket.slice(5),
       modelCostUsd: microsToUsd(modelCostMicros),
@@ -452,6 +508,20 @@ export async function getWorkspaceInsights(
     };
   });
 
+  const projectRows = projects.map((row) => ({
+    id: row.kind === "project" && row.channelId ? `project:${row.channelId}` : row.kind,
+    kind: row.kind,
+    label: insightsProjectLabel(row),
+    projects: row.projects,
+    rootSessions: row.rootSessions,
+    calls: row.calls,
+    creditUsd: microsToUsd(row.pricedCostMicros),
+    estimatedProviderUsd: microsToUsd(row.estimatedProviderCostMicros),
+    estimatedProviderCostKnownCalls: row.estimatedProviderCostKnownCalls,
+    tokens: row.totalTokens,
+    cacheHitPct: cacheHitPct(row.cachedTokens, row.cacheInputTokens),
+  }));
+
   const scheduleFactById = new Map(scheduleFacts.map((row) => [row.scheduledTaskId, row] as const));
   const schedules = tasks.map((task) => {
     const fact = scheduleFactById.get(task.id);
@@ -512,6 +582,9 @@ export async function getWorkspaceInsights(
       sessions: bucket.sessions,
     })),
     drivers,
+    projects: projectRows,
+    privateChats,
+    privateChatsTruncated,
     schedules,
     recentCalls: recentCalls.map((row) => ({
       id: row.id,
@@ -601,7 +674,17 @@ export async function getWorkspaceInsights(
     billableTokenCap: limits.maxMonthlyTokensPerWorkspace ?? null,
     agentRunsUsed,
     agentRunCap: limits.maxMonthlyAgentRunsPerWorkspace ?? null,
-    modelFilterActive,
+    modelFilterActive: modelFilterActive || scopeActive,
+    dataThrough: dataThrough?.toISOString() ?? null,
+    cacheHitPct: cacheHitPct(cachedTokens, cacheInputTokens),
+    scope: {
+      rootSessionId: visibleRootScope ? rootSessionId : null,
+      sessionId: visibleSessionScope ? sessionId : null,
+    },
+    driverGroups,
+    driversTruncated,
+    facetsTruncated,
+    recentCallsTruncated,
   });
 
   return { snapshot };

package/src/domain/scheduled-tasks.ts

@@ -103,6 +103,7 @@ import {
   assertWorkspaceModelPolicyAllows,
   canonicalConfiguredModel,
   creationInitiatorForGrant,
+  modelUnavailableHttpException,
   settingsWithSessionMcpServerMetadata,
 } from "./sessions";
 import {
@@ -155,9 +156,7 @@ function workspaceCustomModelCommitGuard(input: {
       reference,
     });
     if (!active) {
-      throw new HTTPException(422, {
-        message: `model is not available: ${input.modelId}`,
-      });
+      throw modelUnavailableHttpException(input.modelId);
     }
   };
 }

package/src/domain/session-tool-policy.ts

@@ -227,6 +227,28 @@ export function resolveTurnToolPolicy(
   });
 }
 
+/** Resolve availability and defaults from the same subject-scoped registry read. */
+export async function workspaceSessionToolPolicyContext(
+  db: Database,
+  workspaceId: string,
+  settings: Settings,
+  subjectId?: string,
+): Promise<{ workspaceServerIds: string[]; workspaceDefaultServerIds: string[] }> {
+  const [runtimeSettings, workspace] = await Promise.all([
+    settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings, {
+      ...(subjectId ? { subjectId } : {}),
+    }),
+    requireWorkspace(db, workspaceId),
+  ]);
+  return {
+    workspaceServerIds: sortedIds(runtimeSettings.mcpServers.map((server) => server.id)),
+    workspaceDefaultServerIds: workspaceSessionToolPolicyDefaultServerIdsFor(
+      runtimeSettings.mcpServers,
+      workspace.settings,
+    ),
+  };
+}
+
 /** Current full runtime registry IDs, including configured static servers. */
 export async function workspaceSessionToolPolicyServerIds(
   db: Database,
@@ -478,11 +500,15 @@ export function sessionEffectiveToolProjectionInput(
         "browser_screenshot",
         "browser_clipboard",
         "browser_debug",
+        "browser_downloads",
         "computer_targets",
         "computer_observe",
         "computer_clipboard",
       ].includes(name);
-      if (permissionAllowed(readOnly ? "sessions:read" : "sessions:control")) {
+      if (
+        permissionAllowed(readOnly ? "sessions:read" : "sessions:control") &&
+        (name !== "browser_download_save" || permissionAllowed("files:upload"))
+      ) {
         firstPartyModelNames.set(name, `interaction__${name}`);
         if (
           !firstPartyMcpTools.includes(name) &&

package/src/domain/sessions.ts

@@ -1,3 +1,4 @@
+import { isDirectModelId, ModelUnavailableError } from "@opengeni/contracts";
 import { acceptSessionFileAttachments } from "@opengeni/db";
 import { knowledgeContextForAccess } from "./knowledge";
 import {
@@ -286,6 +287,7 @@ function defaultPolicyExclusions(
 
 function isCatalogOverlayModel(modelId: string | null | undefined): boolean {
   return (
+    (modelId != null && isDirectModelId(modelId)) ||
     modelId?.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX) === true ||
     modelId?.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX) === true ||
     modelId?.startsWith(ORGANIZATION_GATEWAY_MODEL_ID_PREFIX) === true ||
@@ -1120,9 +1122,7 @@ export async function createAndStartSessionWithOutcome(input: {
               reference,
             });
             if (!active) {
-              throw new HTTPException(422, {
-                message: `model is not available: ${input.model}`,
-              });
+              throw modelUnavailableHttpException(input.model);
             }
           }
           // Reject an already-stale browser draft before the newly inserted
@@ -1543,6 +1543,17 @@ export function workflowIdForSession(sessionId: string): string {
   return `session-${sessionId}`;
 }
 
+/**
+ * The one 422 for a model that is not selectable in the live catalog (retired,
+ * removed, or never offered). The message keeps its historical text; the typed
+ * cause lets the API envelope add `details.code: "model_unavailable"` so
+ * clients can ask for another model instead of offering a futile retry.
+ */
+export function modelUnavailableHttpException(model: string): HTTPException {
+  const cause = new ModelUnavailableError(model);
+  return new HTTPException(422, { message: cause.message, cause });
+}
+
 /**
  * Reject an explicit model that the host does not expose. The set of usable
  * models is the union surfaced by `configuredAllowedModels` (the built-in
@@ -1578,7 +1589,7 @@ export function canonicalConfiguredModel(
     ) {
       return canonicalModel;
     }
-    throw new HTTPException(422, { message: `model is not available: ${model}` });
+    throw modelUnavailableHttpException(model);
   }
   if (configuredAllowedModels(settings).includes(canonicalModel)) {
     return canonicalModel;
@@ -1602,7 +1613,7 @@ export function canonicalConfiguredModel(
   ) {
     return canonicalModel;
   }
-  throw new HTTPException(422, { message: `model is not available: ${model}` });
+  throw modelUnavailableHttpException(model);
 }
 
 export function assertConfiguredModel(settings: Settings, model: string | null | undefined): void {
@@ -1976,9 +1987,7 @@ export async function postUserMessageTurn(
                         reference,
                       });
                       if (!active) {
-                        throw new HTTPException(422, {
-                          message: `model is not available: ${freshWorkspaceCustomModel}`,
-                        });
+                        throw modelUnavailableHttpException(freshWorkspaceCustomModel);
                       }
                     },
                   }
@@ -2964,7 +2973,7 @@ async function createSessionForRequestInFileScope(
     channelId = channel.id;
   }
   // A spawned worker is causally part of the exact turn that created it. Omitted
-  // execution policy fields therefore inherit that calling turn rather than the
+  // model and reasoning fields therefore inherit that calling turn rather than the
   // deployment defaults. This is especially important for Codex subscription
   // managers: falling back to the deployment model would silently move a child
   // onto the OpenGeni-credits billing path. Legacy session-bound grants without
@@ -2998,10 +3007,11 @@ async function createSessionForRequestInFileScope(
     parentSession?.reasoningEffort ??
     resolvedDefault?.reasoningEffort ??
     settings.openaiReasoningEffort;
-  const inheritedLatencyMode =
-    parentCallingTurn?.latencyMode ?? parentSession?.latencyMode ?? "standard";
   const reasoningEffort = payload.reasoningEffort ?? inheritedReasoningEffort;
-  const latencyMode = payload.latencyMode ?? inheritedLatencyMode;
+  // A fresh session never implicitly opts into a faster, higher-cost tier.
+  // This is a fresh-creation default only: replay/repair preserves persisted
+  // policy, and follow-ups use the recipient session's own frozen settings.
+  const latencyMode = payload.latencyMode ?? "standard";
   if (payload.expectedNewSessionDraftRevision !== undefined && payload.rigId === null) {
     throw new HTTPException(409, {
       message: "The submitted session options are not represented by the new-session draft",
@@ -3062,12 +3072,7 @@ async function createSessionForRequestInFileScope(
             : "deployment"
           : "explicit",
       latencyMode,
-      latencyModeSource:
-        payload.latencyMode === undefined
-          ? inheritedFromParent
-            ? "continuation"
-            : "deployment"
-          : "explicit",
+      latencyModeSource: payload.latencyMode === undefined ? "deployment" : "explicit",
     }),
     { grant, authorization, trustedMetadata: [parentSession?.metadata] },
   );

package/src/index.ts

@@ -1,4 +1,5 @@
 export { readSessionAttachmentFiles } from "./domain/session-file-access";
+export { verifyDirectModelAccess } from "./domain/direct-model-provider";
 export * from "./domain/skills";
 export * from "./domain/mcp-account-bindings";
 export * from "./domain/session-connection-accounts";