@opengeni/api-router 0.15.6 → 0.16.1

package/dist/app.js

@@ -22,7 +22,7 @@ import {
   validateToolRefs,
   withDefaultEnabledCapabilityMcpTools,
   workflowIdForSession
-} from "./chunk-MN7BW3UV.js";
+} from "./chunk-ZD5YBUNA.js";
 export {
   API_MAX_REQUEST_BODY_BYTES,
   allowedCorsOrigin,

package/dist/{chunk-MN7BW3UV.js → chunk-ZD5YBUNA.js}

@@ -627,6 +627,12 @@ async function startMcpOAuth(deps, context) {
   const providerDomain = officialSlackResource ? "slack.com" : canonicalProviderDomain(context.payload.providerDomain ?? new URL(mcpUrl).hostname);
   const personalSlack = officialSlackResource || providerDomain === "slack.com";
   assertPersonalSlackOAuthStart(settings, context.payload, mcpUrl, personalSlack);
+  if (personalSlack && context.payload.ownership === "workspace") {
+    throw new HTTPException2(422, {
+      message: "Slack's hosted MCP connection is personal; use the OpenGeni Slack bot installation for workspace access"
+    });
+  }
+  const requestedOwnership = personalSlack ? "personal" : context.payload.ownership ?? "workspace";
   const returnPath = safeReturnPath(context.payload.returnPath ?? "/integrations");
   const baseUrl = integrationBaseUrl(settings.publicBaseUrl, context.requestUrl);
   const redirectUri = `${baseUrl}/v1/integrations/oauth/callback`;
@@ -637,11 +643,14 @@ async function startMcpOAuth(deps, context) {
     providerDomain,
     mcpUrl,
     personalSlack,
-    connectionId: context.payload.connectionId
+    connectionId: context.payload.connectionId,
+    requestedOwnership: context.payload.ownership,
+    newConnectionOwnership: requestedOwnership
   });
   if (context.payload.connectionId && !existing) {
     throw new HTTPException2(404, { message: "connection not found" });
   }
+  const ownership = existing ? ownershipForConnection(existing.subjectId, context.subjectId) : requestedOwnership;
   const discovery = await discoverMcpOAuth(mcpUrl, settings);
   if (personalSlack && !isLocalTestEnvironment(settings.environment)) {
     assertSlackAuthorizationServer(discovery.as);
@@ -667,6 +676,7 @@ async function startMcpOAuth(deps, context) {
     accountId: context.accountId,
     workspaceId: context.workspaceId,
     subjectId: context.subjectId,
+    ownership,
     providerDomain,
     mcpUrl,
     resource,
@@ -739,6 +749,7 @@ async function completeMcpOAuthCallback(deps, input) {
       })
     };
   }
+  const ownerSubjectId = state.ownership === "personal" ? state.subjectId : null;
   try {
     const baseUrl = integrationBaseUrl(settings.publicBaseUrl, input.requestUrl);
     const redirectUri = `${baseUrl}/v1/integrations/oauth/callback`;
@@ -781,7 +792,7 @@ async function completeMcpOAuthCallback(deps, input) {
         connectionId: state.connectionId,
         visibleToSubjectId: state.subjectId,
         expectedVersion: state.connectionVersion,
-        subjectId: state.subjectId,
+        subjectId: ownerSubjectId,
         providerDomain: state.providerDomain,
         kind: "oauth2",
         status: "active",
@@ -793,7 +804,7 @@ async function completeMcpOAuthCallback(deps, input) {
       }) : createConnection(db, {
         accountId: state.accountId,
         workspaceId: state.workspaceId,
-        subjectId: state.subjectId,
+        subjectId: ownerSubjectId,
         providerDomain: state.providerDomain,
         kind: "oauth2",
         credentialEncrypted,
@@ -812,6 +823,7 @@ async function completeMcpOAuthCallback(deps, input) {
       redirectTo: callbackReturnPath(state.returnPath, "success", {
         connectionId: connection.id,
         providerDomain: connection.providerDomain,
+        ownership: state.ownership,
         ...verification.metadata.status === "failed" ? { verification: "failed" } : {}
       })
     };
@@ -1213,17 +1225,32 @@ async function existingOAuthConnectionForStart(db, input) {
       input.connectionId,
       input.subjectId
     );
-    return connection?.subjectId === input.subjectId && connection.kind === "oauth2" && connection.providerDomain === input.providerDomain && (!input.personalSlack || connection.metadata.mcpUrl === input.mcpUrl) ? connection : null;
+    if (!connection || connection.kind !== "oauth2") {
+      return null;
+    }
+    const ownership = ownershipForConnection(connection.subjectId, input.subjectId);
+    if (input.requestedOwnership && input.requestedOwnership !== ownership) {
+      throw new HTTPException2(409, {
+        message: "connection ownership cannot be changed during OAuth reconnect"
+      });
+    }
+    return connection.providerDomain === input.providerDomain && (!input.personalSlack || connection.metadata.mcpUrl === input.mcpUrl) ? connection : null;
   }
   const visible = await listConnectionsMetadata(db, input.workspaceId, input.subjectId);
+  const ownerSubjectId = input.newConnectionOwnership === "personal" ? input.subjectId : null;
   const matching = visible.filter(
-    (connection) => connection.subjectId === input.subjectId && connection.kind === "oauth2" && connection.providerDomain === input.providerDomain && (!input.personalSlack || connection.metadata.mcpUrl === input.mcpUrl)
+    (connection) => connection.subjectId === ownerSubjectId && connection.kind === "oauth2" && connection.providerDomain === input.providerDomain && (!input.personalSlack || connection.metadata.mcpUrl === input.mcpUrl)
   );
   if (input.personalSlack) {
     return selectCanonicalPersonalSlackConnection(matching);
   }
   return matching.find((connection) => connection.status === "active") ?? null;
 }
+function ownershipForConnection(subjectId, authenticatingSubjectId) {
+  if (subjectId === null) return "workspace";
+  if (subjectId === authenticatingSubjectId) return "personal";
+  throw new HTTPException2(404, { message: "connection not found" });
+}
 function buildAuthorizationUrl(input) {
   const endpoint = oauthEndpointUrl(input.endpoint, input.settings, "OAuth authorization endpoint");
   const url = new URL(endpoint);
@@ -1254,6 +1281,9 @@ function readOAuthState(state, settings) {
     accountId: requiredString(payload.accountId, "state.accountId"),
     workspaceId: requiredString(payload.workspaceId, "state.workspaceId"),
     subjectId: requiredString(payload.subjectId, "state.subjectId"),
+    // OAuth states minted before ownership was explicit were always personal.
+    // Preserve that meaning for in-flight reconnects during a rolling deploy.
+    ownership: connectionOwnership(payload.ownership) ?? "personal",
     providerDomain: requiredString(payload.providerDomain, "state.providerDomain"),
     mcpUrl: stringValue(payload.mcpUrl) ?? resource,
     resource,
@@ -1297,6 +1327,9 @@ function readOAuthState(state, settings) {
     ...connectionVersion !== void 0 ? { connectionVersion } : {}
   };
 }
+function connectionOwnership(value) {
+  return value === "workspace" || value === "personal" ? value : void 0;
+}
 async function clientForState(db, settings, state) {
   if (state.clientRegistrationMethod === "cimd") {
     return {
@@ -2669,6 +2702,7 @@ import {
   requireVariableSetEncryption
 } from "@opengeni/core";
 import {
+  captureScheduledTaskRestoreState,
   createValidatedScheduledTask,
   manualScheduledTaskTriggerUsageKey,
   manualScheduledTaskTriggerWorkflowId,
@@ -5998,6 +6032,7 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
       },
       async ({ id, ...raw }) => {
         const existing = await requireScheduledTask(deps.db, grant.workspaceId, id);
+        const previous = await captureScheduledTaskRestoreState(deps.db, existing);
         const payload = UpdateScheduledTaskRequest.parse(raw);
         requireVariableSetsUseForMcpAttachment(grant, payload.variableSetId);
         const update = await validatedScheduledTaskUpdate({
@@ -6013,7 +6048,7 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
         await syncUpdatedScheduledTask({
           db: deps.db,
           workflowClient: deps.workflowClient,
-          previous: existing,
+          previous,
           task
         });
         return json(task);
@@ -6027,13 +6062,14 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
       },
       async ({ id }) => {
         const existing = await requireScheduledTask(deps.db, grant.workspaceId, id);
+        const previous = await captureScheduledTaskRestoreState(deps.db, existing);
         const task = await updateScheduledTask(deps.db, grant.workspaceId, id, {
           status: "paused"
         });
         await syncUpdatedScheduledTask({
           db: deps.db,
           workflowClient: deps.workflowClient,
-          previous: existing,
+          previous,
           task
         });
         return json(task);
@@ -6047,13 +6083,14 @@ function buildOpenGeniMcpServer(deps, grant, options = {}) {
       },
       async ({ id }) => {
         const existing = await requireScheduledTask(deps.db, grant.workspaceId, id);
+        const previous = await captureScheduledTaskRestoreState(deps.db, existing);
         const task = await updateScheduledTask(deps.db, grant.workspaceId, id, {
           status: "active"
         });
         await syncUpdatedScheduledTask({
           db: deps.db,
           workflowClient: deps.workflowClient,
-          previous: existing,
+          previous,
           task
         });
         return json(task);
@@ -8136,6 +8173,7 @@ import {
 } from "@opengeni/contracts";
 import {
   hasPermission as hasPermission5,
+  withFrozenPersonalConnectionDelegations,
   settingsWithEnabledCapabilityMcpServers
 } from "@opengeni/core";
 import {
@@ -8144,6 +8182,7 @@ import {
   clearPendingSessionToolspaceCall,
   getActiveSessionTurnForExecution,
   getSessionRootId,
+  getWorkspaceGrant as getWorkspaceGrant3,
   listSessionMcpServerMetadata,
   listSessionMcpServersForRun,
   registerPendingSessionToolCall,
@@ -8266,6 +8305,7 @@ async function prepareToolspaceMcpSurface(input) {
     executionGeneration: activeTurn.executionGeneration
   };
   const session = await requireSession2(deps.db, grant.workspaceId, sessionId);
+  const personalConnectionDelegations = activeTurn.personalConnectionDelegations;
   let rootSessionId = sessionId;
   if (deps.connectionCredentials?.mcpCredentials) {
     const resolvedRootSessionId = await getSessionRootId(deps.db, grant.workspaceId, sessionId);
@@ -8300,6 +8340,7 @@ async function prepareToolspaceMcpSurface(input) {
     rootSessionId,
     proxyableIds,
     activeTurn,
+    personalConnectionDelegations,
     getRegistry: () => getRegistry(attemptAuthority.attemptId)
   });
   const tools = listing.map(
@@ -8309,6 +8350,7 @@ async function prepareToolspaceMcpSurface(input) {
       authority: attemptAuthority,
       rootSessionId,
       entry,
+      personalConnectionDelegations,
       getRegistry
     })
   );
@@ -8342,7 +8384,16 @@ async function buildToolspaceRegistry(deps, workspaceId, sessionId, attemptId) {
   return new Map(withSessionServers.mcpServers.map((server) => [server.id, server]));
 }
 async function resolveToolListing(input) {
-  const { deps, grant, sessionId, rootSessionId, proxyableIds, activeTurn, getRegistry } = input;
+  const {
+    deps,
+    grant,
+    sessionId,
+    rootSessionId,
+    proxyableIds,
+    activeTurn,
+    personalConnectionDelegations,
+    getRegistry
+  } = input;
   const cacheKey = await toolListCacheKey(
     deps,
     grant.workspaceId,
@@ -8373,7 +8424,8 @@ async function resolveToolListing(input) {
       config,
       sessionId,
       rootSessionId,
-      turn: activeTurn
+      turn: activeTurn,
+      personalConnectionDelegations
     }).catch((error) => {
       deps.observability?.warn("toolspace upstream connection failed", {
         serverId,
@@ -8510,7 +8562,15 @@ async function connectToolspaceServer(input) {
   };
 }
 function toolspaceToolFor(input) {
-  const { deps, grant, authority, rootSessionId, entry, getRegistry } = input;
+  const {
+    deps,
+    grant,
+    authority,
+    rootSessionId,
+    entry,
+    personalConnectionDelegations,
+    getRegistry
+  } = input;
   const { sessionId } = authority;
   const { serverId, tool } = entry;
   const name = prefixedMcpToolName(serverId, tool.name);
@@ -8545,7 +8605,8 @@ function toolspaceToolFor(input) {
         config,
         sessionId,
         rootSessionId,
-        turn: reservation.turn
+        turn: reservation.turn,
+        personalConnectionDelegations
       }).catch(() => null);
       if (!connection) {
         return mcpError(`upstream tool failed: ${name}`);
@@ -8763,15 +8824,8 @@ function connectionBrokerFetch(baseFetch, input) {
   if (!connectionRef) {
     return baseFetch;
   }
-  const credentialSubjectId = input.turn.initiator.kind === "subject" ? input.turn.initiator.subjectId : void 0;
-  if (connectionRef.subjectScope === "subject" && !credentialSubjectId) {
-    throw new Error(
-      `subject-owned connection for MCP server ${input.config.id} requires a human turn initiator`
-    );
-  }
   const hostCredentialPort = input.deps.connectionCredentials?.mcpCredentials;
-  const resolverSubjectId = hostCredentialPort ? input.grant.subjectId : credentialSubjectId;
-  const resolveCredential = hostCredentialPort ? buildHostConnectionTokenResolver(hostCredentialPort, {
+  const rawResolveCredential = hostCredentialPort ? buildHostConnectionTokenResolver(hostCredentialPort, {
     accountId: input.grant.accountId,
     workspaceId: input.grant.workspaceId,
     sessionId: input.sessionId,
@@ -8783,18 +8837,40 @@ function connectionBrokerFetch(baseFetch, input) {
     initiatorContext: input.turn.initiatorContext,
     surface: "toolspace"
   }) : buildConnectionTokenResolver2(input.deps.db, input.deps.settings);
+  const personalDelegations = input.personalConnectionDelegations ?? [];
+  const delegatedMembershipChecks = /* @__PURE__ */ new Map();
+  const delegatedOwnerHasMembership = async (subjectId) => {
+    const existing = delegatedMembershipChecks.get(subjectId);
+    if (existing) return await existing;
+    const check = getWorkspaceGrant3(input.deps.db, subjectId, input.grant.workspaceId).then(
+      Boolean
+    );
+    delegatedMembershipChecks.set(subjectId, check);
+    return await check;
+  };
+  const resolveCredential = withFrozenPersonalConnectionDelegations({
+    resolveCredential: rawResolveCredential,
+    settings: { mcpServers: [input.config] },
+    personalConnectionDelegations: personalDelegations,
+    ownerHasWorkspaceMembership: delegatedOwnerHasMembership
+  });
   return async (requestInput, init) => {
     const request = await mcpRequestInfo(requestInput, init);
     const destinationUrl = mcpRequestDestinationUrl(requestInput);
-    const first = await resolveCredential({
-      workspaceId: input.grant.workspaceId,
-      serverId: input.config.id,
-      connectionRef,
-      destinationUrl,
-      forceRefresh: false,
-      ...request.toolName ? { toolName: request.toolName } : {},
-      ...resolverSubjectId ? { subjectId: resolverSubjectId } : {}
-    });
+    const resolverSubjectId = connectionRef.subjectScope !== "subject" && hostCredentialPort ? input.grant.subjectId : void 0;
+    const resolve = async (forceRefresh) => {
+      const result = await resolveCredential({
+        workspaceId: input.grant.workspaceId,
+        serverId: input.config.id,
+        connectionRef,
+        destinationUrl,
+        forceRefresh,
+        ...request.toolName ? { toolName: request.toolName } : {},
+        ...resolverSubjectId ? { subjectId: resolverSubjectId } : {}
+      });
+      return result;
+    };
+    const first = await resolve(false);
     if (first.status === "auth_needed") {
       return await authNeededFetchResponse(input, request, first);
     }
@@ -8804,15 +8880,7 @@ function connectionBrokerFetch(baseFetch, input) {
     );
     if (response.status === 401) {
       await cancelMcpResponseBody(response);
-      const refreshed = await resolveCredential({
-        workspaceId: input.grant.workspaceId,
-        serverId: input.config.id,
-        connectionRef,
-        destinationUrl,
-        forceRefresh: true,
-        ...request.toolName ? { toolName: request.toolName } : {},
-        ...resolverSubjectId ? { subjectId: resolverSubjectId } : {}
-      });
+      const refreshed = await resolve(true);
       if (refreshed.status === "auth_needed") {
         return await authNeededFetchResponse(input, request, refreshed);
       }
@@ -8856,7 +8924,7 @@ function authNeededFromStatus(config, first, reason) {
     reason,
     providerDomain: connectionRef.providerDomain,
     ...connectionRef.provider ? { provider: connectionRef.provider } : {},
-    connectionId: first.connectionId,
+    ...connectionRef.subjectScope === "subject" ? {} : { connectionId: first.connectionId },
     ...connectionRef.scopes ? { scopes: connectionRef.scopes } : {},
     ...connectionRef.resource ? { resource: connectionRef.resource } : {},
     ...connectionRef.selectedResources ? { selectedResources: connectionRef.selectedResources } : {}
@@ -10552,7 +10620,7 @@ import {
   createConnectionWithSlackBotSuccessAudit,
   encryptEnvironmentValue as encryptEnvironmentValue5,
   getConnectionMetadata as getConnectionMetadata3,
-  getWorkspaceGrant as getWorkspaceGrant4,
+  getWorkspaceGrant as getWorkspaceGrant5,
   listConnectionsMetadata as listConnectionsMetadata3,
   recordSlackBotInstallCallbackFailure,
   revokeConnection,
@@ -10585,7 +10653,7 @@ import {
   decryptEnvironmentValue as decryptEnvironmentValue3,
   encryptEnvironmentValue as encryptEnvironmentValue4,
   getConnectionMetadata as getConnectionMetadata2,
-  getWorkspaceGrant as getWorkspaceGrant3,
+  getWorkspaceGrant as getWorkspaceGrant4,
   loadConnectionCredentialForBroker,
   updateConnection as updateConnection2
 } from "@opengeni/db";
@@ -11026,7 +11094,7 @@ function readGoogleDriveOAuthState(raw, settings) {
   };
 }
 async function requireGoogleDriveCallbackGrant(deps, state) {
-  const grant = await getWorkspaceGrant3(deps.db, state.subjectId, state.workspaceId);
+  const grant = await getWorkspaceGrant4(deps.db, state.subjectId, state.workspaceId);
   if (!grant || grant.accountId !== state.accountId || !hasPermission7(grant.permissions, "connections:write")) {
     throw new HTTPException10(403, {
       message: "Google Drive OAuth subject no longer has permission for this workspace"
@@ -11269,7 +11337,7 @@ function registerConnectionRoutes(app, deps) {
     const payload = CreateConnectionRequest.parse(await c.req.json());
     assertNotReservedSlackBotMetadata(payload.metadata);
     const key = requireEnvironmentEncryption4(settings);
-    const subjectId = writableSubjectId(payload.subjectId, grant.subjectId);
+    const subjectId = createConnectionSubjectId(payload, grant.subjectId);
     const providerDomain = canonicalProviderDomain(payload.providerDomain);
     assertNotDirectPersonalSlackOAuth(providerDomain, payload.kind);
     assertNotDirectGoogleDriveOAuth(providerDomain, payload.kind, payload.metadata);
@@ -11838,7 +11906,7 @@ function slackInstallErrorReason(error) {
   return "installation_failed";
 }
 async function requireSlackInstallCallbackGrant(db, state) {
-  const grant = await getWorkspaceGrant4(db, state.subjectId, state.workspaceId);
+  const grant = await getWorkspaceGrant5(db, state.subjectId, state.workspaceId);
   if (!grant || grant.accountId !== state.accountId || !hasPermission8(grant.permissions, "connections:write")) {
     throw new SlackInstallCallbackError(
       403,
@@ -11877,6 +11945,18 @@ function writableSubjectId(requested, grantSubjectId) {
   }
   return requested;
 }
+function createConnectionSubjectId(payload, grantSubjectId) {
+  if (payload.ownership === void 0) {
+    return writableSubjectId(payload.subjectId, grantSubjectId);
+  }
+  const subjectId = payload.ownership === "personal" ? grantSubjectId : null;
+  if (payload.subjectId !== void 0 && payload.subjectId !== subjectId) {
+    throw new HTTPException11(422, {
+      message: "ownership and subjectId describe different connection owners"
+    });
+  }
+  return subjectId;
+}
 function encryptCredentialBundle(key, credential) {
   return encryptEnvironmentValue5(key, JSON.stringify(credential));
 }
@@ -15824,6 +15904,7 @@ import {
 import { requireAccessGrant as requireAccessGrant13 } from "@opengeni/core";
 import { recordWorkspaceUsage as recordWorkspaceUsage4, requireLimit as requireLimit6 } from "@opengeni/core";
 import {
+  captureScheduledTaskRestoreState as captureScheduledTaskRestoreState2,
   createValidatedScheduledTask as createValidatedScheduledTask3,
   manualScheduledTaskTriggerUsageKey as manualScheduledTaskTriggerUsageKey2,
   manualScheduledTaskTriggerWorkflowId as manualScheduledTaskTriggerWorkflowId2,
@@ -15873,6 +15954,7 @@ function registerScheduledTaskRoutes(app, deps) {
     const grant = await requireAccessGrant13(c, deps, workspaceId, "scheduled_tasks:manage");
     const taskId = c.req.param("taskId");
     const existing = await requireScheduledTaskForApi(db, workspaceId, taskId);
+    const previous = await captureScheduledTaskRestoreState2(db, existing);
     const rawPayload = await c.req.json();
     const payload = UpdateScheduledTaskRequest2.parse(rawPayload);
     const update = await validatedScheduledTaskUpdate2({
@@ -15885,23 +15967,25 @@ function registerScheduledTaskRoutes(app, deps) {
       toolsProvided: scheduledTaskToolsProvided2(rawPayload)
     });
     const task = await updateScheduledTask2(db, workspaceId, taskId, update);
-    await syncUpdatedScheduledTask2({ db, workflowClient, previous: existing, task });
+    await syncUpdatedScheduledTask2({ db, workflowClient, previous, task });
     return c.json(task);
   });
   app.post("/v1/workspaces/:workspaceId/scheduled-tasks/:taskId/pause", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant13(c, deps, workspaceId, "scheduled_tasks:manage");
     const existing = await requireScheduledTaskForApi(db, workspaceId, c.req.param("taskId"));
+    const previous = await captureScheduledTaskRestoreState2(db, existing);
     const task = await updateScheduledTask2(db, workspaceId, existing.id, { status: "paused" });
-    await syncUpdatedScheduledTask2({ db, workflowClient, previous: existing, task });
+    await syncUpdatedScheduledTask2({ db, workflowClient, previous, task });
     return c.json(task);
   });
   app.post("/v1/workspaces/:workspaceId/scheduled-tasks/:taskId/resume", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant13(c, deps, workspaceId, "scheduled_tasks:manage");
     const existing = await requireScheduledTaskForApi(db, workspaceId, c.req.param("taskId"));
+    const previous = await captureScheduledTaskRestoreState2(db, existing);
     const task = await updateScheduledTask2(db, workspaceId, existing.id, { status: "active" });
-    await syncUpdatedScheduledTask2({ db, workflowClient, previous: existing, task });
+    await syncUpdatedScheduledTask2({ db, workflowClient, previous, task });
     return c.json(task);
   });
   app.post("/v1/workspaces/:workspaceId/scheduled-tasks/:taskId/trigger", async (c) => {
@@ -21560,9 +21644,10 @@ import {
   deleteSlackBotUserLink,
   enqueueSlackInteractionInbox,
   getOrCreateSlackInteraction,
+  getLatestSessionModelForSubject,
   getSlackBotUserLink,
   getSlackInteractionByRoute,
-  getWorkspaceGrant as getWorkspaceGrant5,
+  getWorkspaceGrant as getWorkspaceGrant6,
   listSessionEventPage as listSessionEventPage3,
   listSessionHumanInputRequests as listSessionHumanInputRequests2,
   rekeySlackInteractionRoute,
@@ -21825,6 +21910,14 @@ async function drainSlackInteractionsOnce(deps) {
       });
     } catch (error) {
       const code = safeErrorCode(error);
+      console.error("[slack-interactions] inbox processing failed", {
+        workspaceId: entry.workspaceId,
+        connectionId: entry.connectionId,
+        providerEventId: entry.providerEventId,
+        triggerKind: entry.triggerKind,
+        attemptCount: entry.attemptCount,
+        errorCode: code
+      });
       if (entry.attemptCount >= 5 || permanentSlackInteractionError(error) || permanentSlackDeliveryError(error)) {
         await settleSlackInteractionInbox(deps.db, {
           entry,
@@ -21929,7 +22022,7 @@ async function processSlackInboxEntry(deps, entry) {
     });
     return;
   }
-  const grant = await getWorkspaceGrant5(deps.db, link.subjectId, entry.workspaceId, {
+  const grant = await getWorkspaceGrant6(deps.db, link.subjectId, entry.workspaceId, {
     principalKind: "human_session"
   });
   if (!grant || grant.accountId !== entry.accountId) {
@@ -21958,14 +22051,33 @@ async function processSlackInboxEntry(deps, entry) {
     await continueSlackSession(deps, grant, interaction, entry);
     return;
   }
-  const session = await createSessionForRequest3(deps, grant, entry.workspaceId, {
-    requestedSessionId: interaction.sessionReservationId,
-    initialMessage: entry.text,
-    turnInstructions: SLACK_TASK_INSTRUCTIONS,
-    firstPartyMcpTools: [...SLACK_TASK_FIRST_PARTY_MCP_TOOLS],
-    idempotencyKey: `slack:${entry.connectionId}:${entry.providerEventId}`,
-    clientEventId: `slack:${entry.providerEventId}`
-  });
+  const preferredModel = await getLatestSessionModelForSubject(
+    deps.db,
+    entry.workspaceId,
+    grant.subjectId
+  );
+  let session;
+  try {
+    session = await createSessionForRequest3(deps, grant, entry.workspaceId, {
+      requestedSessionId: interaction.sessionReservationId,
+      initialMessage: entry.text,
+      turnInstructions: SLACK_TASK_INSTRUCTIONS,
+      firstPartyMcpTools: [...SLACK_TASK_FIRST_PARTY_MCP_TOOLS],
+      ...preferredModel ? { model: preferredModel } : {},
+      idempotencyKey: `slack:${entry.connectionId}:${entry.providerEventId}`,
+      clientEventId: `slack:${entry.providerEventId}`
+    });
+  } catch (error) {
+    if (error instanceof HTTPException32) {
+      await client.postMessage({
+        operationId: deterministicUuid(`slack-admission-failed:${interaction.id}`),
+        channelId: entry.slackChannelId,
+        ...entry.triggerKind === "slash_command" ? {} : { threadTimestamp: entry.slackThreadTs ?? entry.slackMessageTs },
+        text: slackAdmissionFailureText(error)
+      });
+    }
+    throw error;
+  }
   const bound = await bindSlackInteractionSession(deps.db, {
     ...interaction,
     owningSubjectId: grant.subjectId,
@@ -22356,9 +22468,19 @@ function safePayloadText(payload, field) {
 }
 function safeErrorCode(error) {
   if (error instanceof SlackBotProviderError) return error.code.slice(0, 128);
+  if (error instanceof HTTPException32) return `http_${error.status}`;
   const raw = error instanceof Error ? error.name : "slack_interaction_error";
   return raw.toLowerCase().replace(/[^a-z0-9_-]/g, "_").slice(0, 128) || "error";
 }
+function slackAdmissionFailureText(error) {
+  if (error.status === 402) {
+    return "OpenGeni could not start this task because the selected model has no available billing source. Open OpenGeni, select a connected subscription model, and try again.";
+  }
+  if (error.status === 429) {
+    return "OpenGeni could not start this task because this workspace has reached a usage limit. Try again later or review the workspace limits in OpenGeni.";
+  }
+  return "OpenGeni could not start this task because the workspace rejected the session settings. Open OpenGeni, select an available model, and try again.";
+}
 var SlackInteractionPermanentError = class extends Error {
 };
 function permanentSlackInteractionError(error) {
@@ -23418,4 +23540,4 @@ export {
   withDefaultEnabledCapabilityMcpTools,
   workflowIdForSession2 as workflowIdForSession
 };
-//# sourceMappingURL=chunk-MN7BW3UV.js.map
+//# sourceMappingURL=chunk-ZD5YBUNA.js.map