@opengeni/core 0.24.1 → 0.28.0

package/src/domain/fiken.ts

@@ -0,0 +1,88 @@
+import {
+  FIKEN_CREDENTIAL_LABEL,
+  FIKEN_CREDENTIAL_ROLE,
+  FIKEN_PROVIDER_DOMAIN,
+  FikenConnectionMetadata,
+  type ConnectionMetadata,
+  type FikenCompanySummary,
+  type FikenConnectionMetadata as FikenMetadata,
+} from "@opengeni/contracts";
+
+export function fikenConnectionMetadata(metadata: Record<string, unknown>): FikenMetadata | null {
+  const parsed = FikenConnectionMetadata.safeParse(metadata);
+  return parsed.success ? parsed.data : null;
+}
+
+/**
+ * A workspace-shared Fiken connection created through one of the verified
+ * install paths: the pasted personal API token (`api_key`) or the Fiken OAuth
+ * app flow (`oauth2`). Both are deliberately workspace-owned; personal
+ * ("Connect only for me") ownership needs the delegation-snapshot lane and is
+ * not yet wired for the first-party fiken tools.
+ */
+export function isFikenConnection(connection: ConnectionMetadata): boolean {
+  return (
+    connection.subjectId === null &&
+    connection.providerDomain === FIKEN_PROVIDER_DOMAIN &&
+    (connection.kind === "api_key" || connection.kind === "oauth2") &&
+    fikenConnectionMetadata(connection.metadata)?.credentialRole === FIKEN_CREDENTIAL_ROLE
+  );
+}
+
+/**
+ * The Fiken credential role is reserved for the verified install routes.
+ * Generic connection create/update must reject it so a caller cannot forge a
+ * "verified" Fiken row (with attacker-chosen companies metadata) that the
+ * first-party fiken tools would then bind to. Mirrors the Slack bot guard.
+ */
+export function hasReservedFikenMetadata(
+  metadata: Record<string, unknown> | null | undefined,
+): boolean {
+  return (
+    metadata?.credentialRole === FIKEN_CREDENTIAL_ROLE ||
+    metadata?.credentialLabel === FIKEN_CREDENTIAL_LABEL
+  );
+}
+
+/**
+ * One default-company rule for both verified lanes: an explicit request wins
+ * when the credential can access it, then a still-accessible previous default
+ * survives reconnect, then a single-company credential auto-selects. Returns
+ * null (caller decides whether that is an error) when a requested slug is not
+ * among the verified companies.
+ */
+export function resolveFikenDefaultCompanySlug(input: {
+  requested: string | null;
+  previous: string | null;
+  companies: readonly FikenCompanySummary[];
+}): string | null {
+  const accessible = (slug: string | null): slug is string =>
+    slug !== null && input.companies.some((company) => company.slug === slug);
+  if (input.requested !== null) {
+    return accessible(input.requested) ? input.requested : null;
+  }
+  if (accessible(input.previous)) {
+    return input.previous;
+  }
+  return input.companies.length === 1 ? input.companies[0]!.slug : null;
+}
+
+/**
+ * The row a capability tile or tool default should bind to when several Fiken
+ * connections exist: usable status first, then newest update, then immutable
+ * UUID descending as the stable tie-breaker.
+ */
+export function preferredFikenConnection<
+  T extends Pick<ConnectionMetadata, "status" | "updatedAt" | "id">,
+>(connections: readonly T[]): T | null {
+  const statusRank = (status: ConnectionMetadata["status"]): number =>
+    status === "active" ? 0 : status === "needs_reauth" ? 1 : 2;
+  return (
+    [...connections].sort(
+      (left, right) =>
+        statusRank(left.status) - statusRank(right.status) ||
+        right.updatedAt.localeCompare(left.updatedAt) ||
+        right.id.localeCompare(left.id),
+    )[0] ?? null
+  );
+}

package/src/domain/insights.ts

@@ -7,6 +7,7 @@ import {
 import {
   aggregateModelCallFacts,
   aggregateModelCallFactsByDay,
+  aggregateModelCallFactsByHour,
   aggregateRootSessionDrivers,
   aggregateScheduleFacts,
   aggregateSessionDepth,
@@ -15,6 +16,7 @@ import {
   countScheduledTaskFires,
   countSessionsAttachedToGroups,
   enumerateUtcDays,
+  enumerateUtcHours,
   listFloorSessions,
   listLiveWarmLeases,
   listModelCallFacets,
@@ -23,6 +25,7 @@ import {
   requireWorkspace,
   sumUsageQuantity,
   sumUsageQuantityByDay,
+  sumUsageQuantityByHour,
   sumUsageQuantityInRange,
   type Database,
 } from "@opengeni/db";
@@ -82,29 +85,29 @@ function resolveRangeWindow(
       since = startOfUtcDay(now);
       rangeLabel = "Today (UTC)";
       priorLabel = "Prior equal window";
-      seriesLabel = "Credit $ (UTC day)";
-      cacheSeriesLabel = "Cache hit %";
+      seriesLabel = "Credit $ / UTC hour";
+      cacheSeriesLabel = "Cache hit % / UTC hour";
       break;
     case "week":
       since = new Date(startOfUtcDay(now).getTime() - 6 * 24 * 60 * 60 * 1000);
       rangeLabel = "Last 7 days (UTC)";
       priorLabel = "Prior 7 days";
-      seriesLabel = "Credit $ / day";
-      cacheSeriesLabel = "Cache hit % / day";
+      seriesLabel = "Credit $ / UTC day";
+      cacheSeriesLabel = "Cache hit % / UTC day";
       break;
     case "month":
       since = startOfUtcMonth(now);
       rangeLabel = "This month (UTC)";
       priorLabel = "Prior equal window";
-      seriesLabel = "Credit $ / day";
-      cacheSeriesLabel = "Cache hit % / day";
+      seriesLabel = "Credit $ / UTC day";
+      cacheSeriesLabel = "Cache hit % / UTC day";
       break;
     case "ytd":
       since = startOfUtcYear(now);
       rangeLabel = "Year to date (UTC)";
       priorLabel = "Prior equal window";
-      seriesLabel = "Credit $ / day";
-      cacheSeriesLabel = "Cache hit % / day";
+      seriesLabel = "Credit $ / UTC day";
+      cacheSeriesLabel = "Cache hit % / UTC day";
       break;
     default: {
       const _exhaustive: never = range;
@@ -182,6 +185,10 @@ export async function getWorkspaceInsights(
   const model = input.model?.trim() || null;
   const modelFilterActive = Boolean(provider || model);
   const filter = { provider, model };
+  const aggregateFactsForSeries =
+    input.range === "today" ? aggregateModelCallFactsByHour : aggregateModelCallFactsByDay;
+  const sumUsageForSeries =
+    input.range === "today" ? sumUsageQuantityByHour : sumUsageQuantityByDay;
 
   const [
     workspaceCreditMicros,
@@ -242,19 +249,19 @@ export async function getWorkspaceInsights(
       until: window.priorUntil,
       ...filter,
     }),
-    aggregateModelCallFactsByDay(db, {
+    aggregateFactsForSeries(db, {
       workspaceId: input.workspaceId,
       since: window.since,
       until: window.until,
       ...filter,
     }),
-    sumUsageQuantityByDay(db, {
+    sumUsageForSeries(db, {
       workspaceId: input.workspaceId,
       eventType: "sandbox.warm_seconds",
       since: window.since,
       until: window.until,
     }),
-    sumUsageQuantityByDay(db, {
+    sumUsageForSeries(db, {
       workspaceId: input.workspaceId,
       eventType: "model.cost",
       since: window.since,
@@ -382,9 +389,12 @@ export async function getWorkspaceInsights(
   const priorCacheInputTokens = priorModelRows.reduce((sum, row) => sum + row.cacheInputTokens, 0);
   const priorCalls = priorModelRows.reduce((sum, row) => sum + row.calls, 0);
 
-  const days = enumerateUtcDays(window.since, window.until);
-  const series = days.map((day) => {
-    const facts = factDays.get(day) ?? {
+  const buckets =
+    input.range === "today"
+      ? enumerateUtcHours(window.since, window.until)
+      : enumerateUtcDays(window.since, window.until);
+  const series = buckets.map((bucket) => {
+    const facts = factDays.get(bucket) ?? {
       costMicros: 0,
       estimatedProviderCostMicros: 0,
       estimatedProviderCostKnownCalls: 0,
@@ -401,13 +411,13 @@ export async function getWorkspaceInsights(
     };
     const modelCostMicros = modelFilterActive
       ? facts.costMicros
-      : (costDays.get(day) ?? facts.costMicros);
+      : (costDays.get(bucket) ?? facts.costMicros);
     return {
-      label: day.slice(5),
+      label: input.range === "today" ? bucket.slice(11) : bucket.slice(5),
       modelCostUsd: microsToUsd(modelCostMicros),
       estimatedProviderUsd: microsToUsd(facts.estimatedProviderCostMicros),
       estimatedProviderCostKnownCalls: facts.estimatedProviderCostKnownCalls,
-      warmSeconds: warmDays.get(day) ?? 0,
+      warmSeconds: warmDays.get(bucket) ?? 0,
       inputTokens: facts.inputTokens,
       outputTokens: facts.outputTokens,
       cachedTokens: facts.cachedTokens,

package/src/domain/scheduled-tasks.ts

@@ -10,6 +10,7 @@ import type {
   SessionAuthorizationSurface,
   CreateScheduledTaskRequest as CreateScheduledTaskPayload,
   UpdateScheduledTaskRequest as UpdateScheduledTaskPayload,
+  XaiProviderAccountAuthoritySnapshotV1,
 } from "@opengeni/contracts";
 import { OPENGENI_SLACK_BOT_SESSION_METADATA_KEY } from "@opengeni/contracts";
 import {
@@ -21,10 +22,12 @@ import {
   getRig,
   getScheduledTask,
   getScheduledTaskPersonalConnectionDelegations,
+  getSessionTurnXaiProviderAccountAuthoritySnapshot,
   getSession,
   requireWorkspace,
   scopedKnowledgeScopeKey,
   updateScheduledTask,
+  resolveXaiProviderAccountAuthoritySnapshotForAcceptance,
   type Database,
   type UpdateScheduledTaskInput,
 } from "@opengeni/db";
@@ -161,6 +164,18 @@ export async function createValidatedScheduledTask(input: {
         source: personalConnectionDelegationSourceForGrant(input.grant),
       });
   const creationInitiator = creationInitiatorForGrant(input.grant);
+  const xaiProviderAccountAuthoritySnapshot: XaiProviderAccountAuthoritySnapshotV1 =
+    creationInitiator.actor
+      ? await getSessionTurnXaiProviderAccountAuthoritySnapshot(
+          input.db,
+          input.grant.workspaceId,
+          creationInitiator.actor.sessionId,
+          creationInitiator.actor.turnId,
+        )
+      : await resolveXaiProviderAccountAuthoritySnapshotForAcceptance(input.db, {
+          workspaceId: input.grant.workspaceId,
+          subjectId: input.grant.subjectId,
+        });
   return await createScheduledTask(input.db, {
     id,
     accountId: input.grant.accountId,
@@ -177,6 +192,7 @@ export async function createValidatedScheduledTask(input: {
     ...(creationInitiator.context ? { createdByContext: creationInitiator.context } : {}),
     createdByActor: creationInitiator.actor ?? null,
     personalConnectionDelegations,
+    xaiProviderAccountAuthoritySnapshot,
     targetSessionId: target?.id ?? null,
     variableSetId: input.payload.variableSetId ?? null,
     rigId: input.payload.rigId ?? null,

package/src/domain/sessions.ts

@@ -2,9 +2,11 @@ import { CODEX_MODEL_ID_PREFIX, isCodexBilledModel } from "@opengeni/codex";
 import {
   canonicalizeConfiguredModelId,
   configuredAllowedModels,
+  resolveFirstPartyMcpToolPolicy,
   policyProviderIdForModel,
   resolveTurnExecutionPolicyV1,
   WORKSPACE_GATEWAY_MODEL_ID_PREFIX,
+  XAI_SUBSCRIPTION_MODEL_ID_PREFIX,
   type Settings,
 } from "@opengeni/config";
 import {
@@ -46,6 +48,7 @@ import {
   type TurnInitiator,
   type TurnInitiatorContext,
   type TurnExecutionPolicyV1,
+  type XaiProviderAccountAuthoritySnapshotV1,
 } from "@opengeni/contracts";
 import {
   createSession,
@@ -53,6 +56,7 @@ import {
   encryptVariableSetValue,
   getAnySessionInGroup,
   getEnrollment,
+  getChannel,
   getRig,
   getWorkspaceDefaultRigId,
   listDistinctVariableSetIdsInGroup,
@@ -64,6 +68,7 @@ import {
   getWorkspaceControlEvent,
   getSessionLineage,
   getSessionTurn,
+  getSessionTurnXaiProviderAccountAuthoritySnapshot,
   getWorkspaceModelPolicy,
   initializeSessionStartAtomically,
   listSessionTurns,
@@ -98,7 +103,10 @@ import type {
   ApiRouteDeps,
   SessionWorkflowClient,
 } from "../dependencies";
-import { requireSessionAuthorization } from "../session-authorization";
+import {
+  requireSessionAuthorization,
+  SessionAuthorizationDeniedError,
+} from "../session-authorization";
 import { swapActiveSandbox, type FleetContext } from "../sandbox/fleet";
 import { settingsWithEnabledCapabilityMcpServers } from "./capabilities";
 import { validateSubmittedTimelineAnnotations } from "./timeline-annotations";
@@ -148,10 +156,18 @@ export class SessionSpawnDeniedError extends Error {
 export function resolveFirstPartyMcpToolsForCreate(
   requested: FirstPartyMcpToolName[] | undefined,
   parentStored: FirstPartyMcpToolName[] | null | undefined,
+  policy: {
+    default: readonly FirstPartyMcpToolName[];
+    allowed: readonly FirstPartyMcpToolName[];
+  } = {
+    default: DEFAULT_FIRST_PARTY_MCP_TOOLS,
+    allowed: FIRST_PARTY_MCP_TOOL_NAMES,
+  },
 ): FirstPartyMcpToolName[] {
   if (requested !== undefined) return [...requested];
-  if (parentStored === undefined) return [...DEFAULT_FIRST_PARTY_MCP_TOOLS];
-  return [...(parentStored ?? DEFAULT_FIRST_PARTY_MCP_TOOLS)];
+  const allowed = new Set(policy.allowed);
+  const inherited = parentStored === undefined ? policy.default : (parentStored ?? policy.default);
+  return [...inherited].filter((tool) => allowed.has(tool));
 }
 
 function sessionSpawnDeniedMessage(denial: SessionSpawnDenial): string {
@@ -540,7 +556,10 @@ export async function createAndStartSessionWithOutcome(input: {
   requestedSessionId?: string;
   db: Database;
   bus: EventBus;
-  workflowClient: SessionWorkflowClient;
+  workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
+  /** Internal database-only composition seam. The exact session shell and this
+   * linkage commit together before its first event/turn can be initialized. */
+  beforeCreateCommit?: (tx: Database, sessionId: string) => Promise<void>;
   accountId: string;
   workspaceId: string;
   initialMessage: string;
@@ -572,6 +591,9 @@ export async function createAndStartSessionWithOutcome(input: {
   // rig promote never moves an existing session's version.
   rigId?: string | null;
   rigVersionId?: string | null;
+  // The workspace channel the session is filed under (rail organization only;
+  // resolved workspace-scoped by the caller). Null/omitted ⇒ unfiled (inbox).
+  channelId?: string | null;
   goal?: GoalSpec | null;
   // Per-session agent persona/system instructions (org-visible metadata, not a
   // secret). Persisted on the session row and composed system-level AFTER the
@@ -591,6 +613,7 @@ export async function createAndStartSessionWithOutcome(input: {
   mcpServers?: CreateSessionMcpServerInput[];
   sessionMcpServers?: SessionMcpServerMetadata[];
   personalConnectionDelegations?: McpPersonalConnectionDelegation[];
+  xaiProviderAccountAuthoritySnapshot?: XaiProviderAccountAuthoritySnapshotV1;
   // The manager session spawning this worker (a worker-signed sessionId claim
   // on the creating grant); null for direct API creates and scheduled runs.
   // When set, the worker's terminal-for-now transitions wake this parent.
@@ -665,6 +688,7 @@ export async function createAndStartSessionWithOutcome(input: {
       variableSetId: input.variableSet?.id ?? null,
       rigId: input.rigId ?? null,
       rigVersionId: input.rigVersionId ?? null,
+      channelId: input.channelId ?? null,
       firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
       firstPartyMcpTools: input.firstPartyMcpTools,
       instructions: input.instructions ?? null,
@@ -675,9 +699,15 @@ export async function createAndStartSessionWithOutcome(input: {
       ...(input.sandboxOs ? { sandboxOs: input.sandboxOs } : {}),
       mcpServers: input.mcpServers ?? [],
       personalConnectionDelegations: input.personalConnectionDelegations ?? [],
+      ...(input.xaiProviderAccountAuthoritySnapshot
+        ? {
+            initialXaiProviderAccountAuthoritySnapshot: input.xaiProviderAccountAuthoritySnapshot,
+          }
+        : {}),
       maxNestedAgentDepthOverride: input.maxNestedAgentDepthOverride ?? null,
       allowNestedAgentDepthIncrease: input.allowNestedAgentDepthIncrease ?? false,
       subjectId: input.subjectId ?? null,
+      ...(input.beforeCreateCommit ? { beforeCreateCommit: input.beforeCreateCommit } : {}),
     });
     if (keyedResult.denied) {
       throw new SessionSpawnDeniedError(SessionSpawnDenial.parse(keyedResult.denial));
@@ -724,6 +754,7 @@ export async function createAndStartSessionWithOutcome(input: {
       variableSetId: input.variableSet?.id ?? null,
       rigId: input.rigId ?? null,
       rigVersionId: input.rigVersionId ?? null,
+      channelId: input.channelId ?? null,
       firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
       firstPartyMcpTools: input.firstPartyMcpTools,
       instructions: input.instructions ?? null,
@@ -733,9 +764,15 @@ export async function createAndStartSessionWithOutcome(input: {
       ...(input.sandboxOs ? { sandboxOs: input.sandboxOs } : {}),
       mcpServers: input.mcpServers ?? [],
       personalConnectionDelegations: input.personalConnectionDelegations ?? [],
+      ...(input.xaiProviderAccountAuthoritySnapshot
+        ? {
+            initialXaiProviderAccountAuthoritySnapshot: input.xaiProviderAccountAuthoritySnapshot,
+          }
+        : {}),
       maxNestedAgentDepthOverride: input.maxNestedAgentDepthOverride ?? null,
       allowNestedAgentDepthIncrease: input.allowNestedAgentDepthIncrease ?? false,
       subjectId: input.subjectId ?? null,
+      ...(input.beforeCreateCommit ? { beforeCreateCommit: input.beforeCreateCommit } : {}),
     });
   } catch (error) {
     if (error instanceof SessionSpawnDeniedDbError) {
@@ -769,7 +806,7 @@ async function finishStartSession(
   input: {
     db: Database;
     bus: EventBus;
-    workflowClient: SessionWorkflowClient;
+    workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
     initialMessage: string;
     deferInitialTurn?: boolean;
     turnInstructions?: string | null;
@@ -924,6 +961,16 @@ export function canonicalConfiguredModel(
   if (settings.codexSubscriptionEnabled && canonicalModel.startsWith(CODEX_MODEL_ID_PREFIX)) {
     return canonicalModel;
   }
+  // SuperGrok subscription models are also discovered per workspace rather
+  // than stored in the deployment-global allow-list. Connection availability
+  // is enforced by the workspace policy and worker; this edge guard only needs
+  // to admit the product-model namespace when the feature is enabled.
+  if (
+    settings.supergrokSubscriptionEnabled &&
+    canonicalModel.startsWith(XAI_SUBSCRIPTION_MODEL_ID_PREFIX)
+  ) {
+    return canonicalModel;
+  }
   if (canonicalModel.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX)) {
     return canonicalModel;
   }
@@ -1270,11 +1317,18 @@ export async function createSessionForRequestWithOutcome(
       ? (grant.metadata["sessionId"] as string)
       : null;
   if (parentSessionId) {
-    await requireSessionAuthorization(deps, grant, {
-      sessionId: parentSessionId,
-      operation: "session.child.create",
-      surface: "core",
-    });
+    try {
+      await requireSessionAuthorization(deps, grant, {
+        sessionId: parentSessionId,
+        operation: "session.child.create",
+        surface: "core",
+      });
+    } catch (error) {
+      if (error instanceof SessionAuthorizationDeniedError) {
+        throw new HTTPException(403, { message: error.message, cause: error });
+      }
+      throw error;
+    }
   }
   const parentSession = parentSessionId ? await getSession(db, workspaceId, parentSessionId) : null;
   if (parentSessionId && !parentSession) {
@@ -1295,11 +1349,22 @@ export async function createSessionForRequestWithOutcome(
       message: "caller attempt does not belong to the parent session",
     });
   }
+  const xaiProviderAccountAuthoritySnapshot =
+    parentSession && creationInitiator.actor
+      ? await getSessionTurnXaiProviderAccountAuthoritySnapshot(
+          db,
+          workspaceId,
+          parentSession.id,
+          creationInitiator.actor.turnId,
+        )
+      : undefined;
   const capabilityRuntimeSettings = await settingsWithEnabledCapabilityMcpServers(
     db,
     workspaceId,
     settings,
-    { subjectId: grant.subjectId },
+    {
+      subjectId: grant.subjectId,
+    },
   );
   const sessionMcpServers = hasOwnProperty(rawPayload, "mcpServers")
     ? validateSessionMcpServersForCreate(capabilityRuntimeSettings, grant, payload.mcpServers)
@@ -1429,6 +1494,20 @@ export async function createSessionForRequestWithOutcome(
       frozenRigVersionId = rig.activeVersion.id;
     }
   }
+  // CHANNEL FILING. Pure rail organization: a UUID files the session into that
+  // workspace channel, omission/null leaves it unfiled (inbox). Resolved
+  // workspace-scoped so a foreign channel id can never attach; an explicit
+  // unknown channelId is a caller error → 422.
+  let channelId: string | null = null;
+  if (payload.channelId) {
+    const channel = await getChannel(db, workspaceId, payload.channelId);
+    if (!channel) {
+      throw new HTTPException(422, {
+        message: `unknown channelId: ${payload.channelId}`,
+      });
+    }
+    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
   // deployment defaults. This is especially important for Codex subscription
@@ -1548,12 +1627,22 @@ export async function createSessionForRequestWithOutcome(
   // Tool visibility is independent from permission authority. A child that
   // omits the field inherits the parent's exact effective selection; a
   // top-level omission selects the safe non-connector default catalog.
+  const deploymentFirstPartyMcpToolPolicy = resolveFirstPartyMcpToolPolicy(settings);
+  const disallowedFirstPartyMcpTool = payload.firstPartyMcpTools?.find(
+    (tool) => !deploymentFirstPartyMcpToolPolicy.allowed.includes(tool),
+  );
+  if (disallowedFirstPartyMcpTool) {
+    throw new HTTPException(422, {
+      message: `first-party MCP tool is disabled by deployment policy: ${disallowedFirstPartyMcpTool}`,
+    });
+  }
   const firstPartyMcpTools = resolveFirstPartyMcpToolsForCreate(
     payload.firstPartyMcpTools,
     parentSession ? parentSession.firstPartyMcpTools : undefined,
+    deploymentFirstPartyMcpToolPolicy,
   );
   if (payload.goal) {
-    const missingGoalTools = ["goal_update", "goal_complete", "goal_pause"].filter(
+    const missingGoalTools = ["goal_update", "goal_progress", "goal_complete", "goal_pause"].filter(
       (name) => !firstPartyMcpTools.includes(name as FirstPartyMcpToolName),
     );
     if (missingGoalTools.length > 0) {
@@ -1824,6 +1913,7 @@ export async function createSessionForRequestWithOutcome(
       // Frozen rig binding (M3): both null for a rig-less session (today's path).
       rigId: frozenRigId,
       rigVersionId: frozenRigVersionId,
+      channelId,
       goal: payload.goal ?? null,
       // Per-session persona instructions (already trimmed/validated by the
       // contracts schema). Persisted on the row; composed system-level at turn
@@ -1835,6 +1925,7 @@ export async function createSessionForRequestWithOutcome(
       mcpServers: sessionMcpServers.dbServers,
       sessionMcpServers: sessionMcpServers.metadata,
       personalConnectionDelegations,
+      ...(xaiProviderAccountAuthoritySnapshot ? { xaiProviderAccountAuthoritySnapshot } : {}),
       parentSessionId,
       createIdempotencyKey: payload.idempotencyKey ?? null,
       maxNestedAgentDepthOverride: payload.maxNestedAgentDepth ?? null,
@@ -1952,6 +2043,7 @@ export async function acceptSessionUserMessageWithOutcome(
   replay: boolean;
 }> {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
+  const delegatedServiceInitiator = serviceInitiatorForGrant(grant);
   await requireSessionAuthorization(deps, grant, {
     sessionId,
     operation: input.delivery === "steer" ? "session.steer" : "session.append",
@@ -2031,7 +2123,6 @@ export async function acceptSessionUserMessageWithOutcome(
     tools: existingSession.tools,
     source: personalConnectionDelegationSourceForGrant(grant),
   });
-  const delegatedServiceInitiator = serviceInitiatorForGrant(grant);
   const { accepted, turn, interruptionCount, replay } = await postUserMessageTurn({
     db,
     bus,
@@ -2317,11 +2408,20 @@ export async function updateSessionToolPolicy(
   const explicitRequestedFirstPartyTools = explicitRequest
     ? [...explicitRequest.firstPartyMcpTools]
     : null;
+  const deploymentFirstPartyMcpToolPolicy = resolveFirstPartyMcpToolPolicy(deps.settings);
+  const disallowedFirstPartyMcpTool = explicitRequestedFirstPartyTools?.find(
+    (tool) => !deploymentFirstPartyMcpToolPolicy.allowed.includes(tool),
+  );
+  if (disallowedFirstPartyMcpTool) {
+    throw new HTTPException(422, {
+      message: `first-party MCP tool is disabled by deployment policy: ${disallowedFirstPartyMcpTool}`,
+    });
+  }
   const workspaceDefaultTools = withFirstPartyTools(
     withDefaultEnabledCapabilityMcpTools([], deps.settings, capabilityRuntimeSettings),
     runtimeSettings,
   );
-  const workspaceDefaultFirstPartyTools = [...FIRST_PARTY_MCP_TOOL_NAMES];
+  const workspaceDefaultFirstPartyTools = [...deploymentFirstPartyMcpToolPolicy.default];
   const events = await appendSessionEventsWithLockedSessionUpdate(
     deps.db,
     grant.workspaceId,
@@ -2353,9 +2453,12 @@ export async function updateSessionToolPolicy(
             : parent.tools,
           runtimeSettings,
         );
+        const deploymentAllowedFirstPartyMcpTools = new Set(
+          deploymentFirstPartyMcpToolPolicy.allowed,
+        );
         const parentFirstPartyMcpTools = [
-          ...(parent.firstPartyMcpTools ?? DEFAULT_FIRST_PARTY_MCP_TOOLS),
-        ];
+          ...(parent.firstPartyMcpTools ?? deploymentFirstPartyMcpToolPolicy.default),
+        ].filter((tool) => deploymentAllowedFirstPartyMcpTools.has(tool));
         if (requestedMode === "workspace_default") {
           if (!parentTracksWorkspaceDefaults) {
             throw new HTTPException(403, {
@@ -2409,7 +2512,8 @@ export async function updateSessionToolPolicy(
       const unchanged =
         stableJson({
           tools: session.tools,
-          firstPartyMcpTools: session.firstPartyMcpTools ?? DEFAULT_FIRST_PARTY_MCP_TOOLS,
+          firstPartyMcpTools:
+            session.firstPartyMcpTools ?? deploymentFirstPartyMcpToolPolicy.default,
           policy: currentPolicy,
         }) ===
         stableJson({
@@ -2430,7 +2534,7 @@ export async function updateSessionToolPolicy(
               before: toolPolicyAuditSnapshot(
                 session,
                 session.tools,
-                [...(session.firstPartyMcpTools ?? DEFAULT_FIRST_PARTY_MCP_TOOLS)],
+                [...(session.firstPartyMcpTools ?? deploymentFirstPartyMcpToolPolicy.default)],
                 currentPolicy,
               ),
               after: toolPolicyAuditSnapshot(

package/src/domain/video-generation-capabilities.ts

@@ -1,4 +1,5 @@
 import {
+  GROK_IMAGINE_VIDEO_1_5_MODEL_ID,
   SEEDANCE_2_5_MODEL_ID,
   VideoGenerationCapabilities,
   VideoGenerationPolicy,
@@ -23,11 +24,41 @@ export const VIDEO_GENERATION_MODEL_CATALOG: readonly VideoGenerationModelCapabi
       ]),
       resolutions: Object.freeze(["480p", "720p"]),
       aspectRatios: Object.freeze(["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "adaptive"]),
-      duration: Object.freeze({ minSeconds: 4, maxSeconds: 30, stepSeconds: 1 }),
+      duration: Object.freeze({
+        minSeconds: 4,
+        maxSeconds: 30,
+        stepSeconds: 1,
+      }),
+      supportsAudio: true,
+    }) as VideoGenerationModelCapability,
+    Object.freeze({
+      modelId: GROK_IMAGINE_VIDEO_1_5_MODEL_ID,
+      label: "Grok Imagine Video 1.5",
+      providerLabel: "Connected SuperGrok",
+      sourceModes: Object.freeze(["text", "first_frame", "image_reference"]),
+      resolutions: Object.freeze(["480p", "720p"]),
+      aspectRatios: Object.freeze(["16:9", "4:3", "1:1", "3:4", "9:16"]),
+      duration: Object.freeze({
+        minSeconds: 4,
+        maxSeconds: 15,
+        stepSeconds: 1,
+      }),
+      // xAI emits audio but exposes no separate audio wire option.
       supportsAudio: true,
     }) as VideoGenerationModelCapability,
   ]);
 
+export function videoGenerationModelSupportsFundingSource(
+  modelId: string,
+  fundingSource: VideoGenerationPolicyType["fundingSource"],
+): boolean {
+  return modelId === GROK_IMAGINE_VIDEO_1_5_MODEL_ID
+    ? fundingSource === "supergrok_subscription"
+    : modelId === SEEDANCE_2_5_MODEL_ID
+      ? fundingSource === "opengeni_credits" || fundingSource === "workspace_gateway"
+      : false;
+}
+
 export function defaultVideoGenerationPolicy(): VideoGenerationPolicyType {
   return VideoGenerationPolicy.parse({
     schemaVersion: 1,
@@ -44,7 +75,11 @@ export function videoGenerationCapabilitiesForPolicy(input: {
 }): VideoGenerationCapabilities {
   const policy = VideoGenerationPolicy.parse(input.policy);
   const enabled = new Set(policy.enabledModelIds);
-  const models = VIDEO_GENERATION_MODEL_CATALOG.filter((model) => enabled.has(model.modelId));
+  const models = VIDEO_GENERATION_MODEL_CATALOG.filter(
+    (model) =>
+      enabled.has(model.modelId) &&
+      videoGenerationModelSupportsFundingSource(model.modelId, policy.fundingSource),
+  );
   if (models.length === 0 || policy.defaultModelId === null) {
     throw new Error("Video generation is disabled for this workspace");
   }

package/src/index.ts

@@ -71,6 +71,8 @@ export * from "./domain/durable-learning-slack-publication";
 export * from "./domain/slack-publication-secret-safety";
 export * from "./domain/company-profile-durable-learning-adapter";
 export * from "./domain/slack-bot";
+export * from "./domain/conversation-integrations";
+export * from "./domain/fiken";
 export * from "./domain/workspace-members";
 export * from "./domain/video-generation";
 export * from "./domain/video-generation-capabilities";