@opengeni/api-router 0.15.6 → 0.16.1

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   createAppComposition,
   startSlackInteractionPump
-} from "./chunk-MN7BW3UV.js";
+} from "./chunk-ZD5YBUNA.js";
 
 // src/index.ts
 import {

package/dist/mcp/toolspace.d.ts

@@ -1,6 +1,6 @@
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { type McpServerConfig } from "@opengeni/config";
-import { type AccessGrant, type SessionTurn } from "@opengeni/contracts";
+import { type AccessGrant, type McpPersonalConnectionDelegation, type SessionTurn } from "@opengeni/contracts";
 import { type ApiRouteDeps } from "@opengeni/core";
 import { type FetchLike } from "@opengeni/network";
 export type ToolspaceCallResult = CallToolResult;
@@ -57,5 +57,6 @@ export declare function connectionBrokerFetch(baseFetch: FetchLike, input: {
     sessionId: string;
     rootSessionId: string;
     turn: SessionTurn;
+    personalConnectionDelegations?: McpPersonalConnectionDelegation[];
 }): FetchLike;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/api-router",
-  "version": "0.15.6",
+  "version": "0.16.1",
   "description": "OpenGeni HTTP surface: the Hono adapter/router (createApp), routes, MCP HTTP transport, and HTTP access adapters over @opengeni/core. An engine-distribution surface — its runtime closure includes engine-internal packages.",
   "license": "Apache-2.0",
   "repository": {
@@ -44,17 +44,17 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opengeni/agent-proto": "^0.3.0",
     "@opengeni/codex": "^0.2.9",
-    "@opengeni/config": "^0.9.1",
-    "@opengeni/contracts": "^0.28.1",
-    "@opengeni/core": "^0.16.3",
-    "@opengeni/db": "^0.19.0",
-    "@opengeni/documents": "^0.2.64",
-    "@opengeni/events": "^0.3.55",
-    "@opengeni/github": "^0.4.13",
+    "@opengeni/config": "^0.9.3",
+    "@opengeni/contracts": "^0.30.0",
+    "@opengeni/core": "^0.17.1",
+    "@opengeni/db": "^0.21.0",
+    "@opengeni/documents": "^0.2.66",
+    "@opengeni/events": "^0.3.57",
+    "@opengeni/github": "^0.4.15",
     "@opengeni/network": "^0.1.1",
-    "@opengeni/observability": "^0.4.0",
-    "@opengeni/runtime": "^0.16.0",
-    "@opengeni/storage": "^0.2.50",
+    "@opengeni/observability": "^0.4.2",
+    "@opengeni/runtime": "^0.16.2",
+    "@opengeni/storage": "^0.2.52",
     "@temporalio/client": "^1.17.0",
     "better-auth": "^1.6.14",
     "hono": "^4.12.18",

package/src/integrations/oauth-client.ts

@@ -6,6 +6,7 @@ import {
   OPENGENI_PERSONAL_SLACK_MCP_URL,
   OAuthStartResponse,
   selectCanonicalPersonalSlackConnection,
+  type ConnectionOwnership,
   type OAuthStartRequest,
 } from "@opengeni/contracts";
 import { hasPermission, requireEnvironmentEncryption } from "@opengeni/core";
@@ -100,6 +101,7 @@ type OAuthStatePayload = {
   accountId: string;
   workspaceId: string;
   subjectId: string;
+  ownership: ConnectionOwnership;
   providerDomain: string;
   mcpUrl: string;
   resource: string;
@@ -154,6 +156,15 @@ export async function startMcpOAuth(
     : 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 HTTPException(422, {
+      message:
+        "Slack's hosted MCP connection is personal; use the OpenGeni Slack bot installation for workspace access",
+    });
+  }
+  const requestedOwnership: ConnectionOwnership = 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`;
@@ -165,10 +176,15 @@ export async function startMcpOAuth(
     mcpUrl,
     personalSlack,
     connectionId: context.payload.connectionId,
+    requestedOwnership: context.payload.ownership,
+    newConnectionOwnership: requestedOwnership,
   });
   if (context.payload.connectionId && !existing) {
     throw new HTTPException(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)) {
@@ -195,6 +211,7 @@ export async function startMcpOAuth(
     accountId: context.accountId,
     workspaceId: context.workspaceId,
     subjectId: context.subjectId,
+    ownership,
     providerDomain,
     mcpUrl,
     resource,
@@ -274,6 +291,7 @@ export async function completeMcpOAuthCallback(
     };
   }
 
+  const ownerSubjectId = state.ownership === "personal" ? state.subjectId : null;
   try {
     const baseUrl = integrationBaseUrl(settings.publicBaseUrl, input.requestUrl);
     const redirectUri = `${baseUrl}/v1/integrations/oauth/callback`;
@@ -313,7 +331,7 @@ export async function completeMcpOAuthCallback(
             connectionId: state.connectionId,
             visibleToSubjectId: state.subjectId,
             expectedVersion: state.connectionVersion,
-            subjectId: state.subjectId,
+            subjectId: ownerSubjectId,
             providerDomain: state.providerDomain,
             kind: "oauth2",
             status: "active",
@@ -326,7 +344,7 @@ export async function completeMcpOAuthCallback(
         : createConnection(db, {
             accountId: state.accountId,
             workspaceId: state.workspaceId,
-            subjectId: state.subjectId,
+            subjectId: ownerSubjectId,
             providerDomain: state.providerDomain,
             kind: "oauth2",
             credentialEncrypted,
@@ -349,6 +367,7 @@ export async function completeMcpOAuthCallback(
       redirectTo: callbackReturnPath(state.returnPath, "success", {
         connectionId: connection.id,
         providerDomain: connection.providerDomain,
+        ownership: state.ownership,
         ...(verification.metadata.status === "failed" ? { verification: "failed" } : {}),
       }),
     };
@@ -853,6 +872,8 @@ async function existingOAuthConnectionForStart(
     mcpUrl: string;
     personalSlack: boolean;
     connectionId?: string | undefined;
+    requestedOwnership?: ConnectionOwnership | undefined;
+    newConnectionOwnership: ConnectionOwnership;
   },
 ) {
   if (input.connectionId) {
@@ -862,17 +883,25 @@ async function existingOAuthConnectionForStart(
       input.connectionId,
       input.subjectId,
     );
-    return connection?.subjectId === input.subjectId &&
-      connection.kind === "oauth2" &&
-      connection.providerDomain === input.providerDomain &&
+    if (!connection || connection.kind !== "oauth2") {
+      return null;
+    }
+    const ownership = ownershipForConnection(connection.subjectId, input.subjectId);
+    if (input.requestedOwnership && input.requestedOwnership !== ownership) {
+      throw new HTTPException(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.subjectId === ownerSubjectId &&
       connection.kind === "oauth2" &&
       connection.providerDomain === input.providerDomain &&
       (!input.personalSlack || connection.metadata.mcpUrl === input.mcpUrl),
@@ -883,6 +912,15 @@ async function existingOAuthConnectionForStart(
   return matching.find((connection) => connection.status === "active") ?? null;
 }
 
+function ownershipForConnection(
+  subjectId: string | null,
+  authenticatingSubjectId: string,
+): ConnectionOwnership {
+  if (subjectId === null) return "workspace";
+  if (subjectId === authenticatingSubjectId) return "personal";
+  throw new HTTPException(404, { message: "connection not found" });
+}
+
 function buildAuthorizationUrl(input: {
   endpoint: string;
   settings: Settings;
@@ -926,6 +964,9 @@ function readOAuthState(state: string, settings: Settings): OAuthStatePayload {
     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,
@@ -972,6 +1013,10 @@ function readOAuthState(state: string, settings: Settings): OAuthStatePayload {
   };
 }
 
+function connectionOwnership(value: unknown): ConnectionOwnership | undefined {
+  return value === "workspace" || value === "personal" ? value : undefined;
+}
+
 async function clientForState(
   db: Database,
   settings: Settings,

package/src/integrations/slack-interactions.ts

@@ -18,6 +18,7 @@ import {
   deleteSlackBotUserLink,
   enqueueSlackInteractionInbox,
   getOrCreateSlackInteraction,
+  getLatestSessionModelForSubject,
   getSlackBotUserLink,
   getSlackInteractionByRoute,
   getWorkspaceGrant,
@@ -344,6 +345,14 @@ export async function drainSlackInteractionsOnce(deps: ApiRouteDeps): Promise<bo
       });
     } 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) ||
@@ -492,14 +501,35 @@ async function processSlackInboxEntry(deps: ApiRouteDeps, entry: SlackInteractio
     await continueSlackSession(deps, grant, interaction, entry);
     return;
   }
-  const session = await createSessionForRequest(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: Awaited<ReturnType<typeof createSessionForRequest>>;
+  try {
+    session = await createSessionForRequest(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 HTTPException) {
+      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,
@@ -982,6 +1012,7 @@ function safePayloadText(payload: unknown, field: string) {
 
 function safeErrorCode(error: unknown) {
   if (error instanceof SlackBotProviderError) return error.code.slice(0, 128);
+  if (error instanceof HTTPException) return `http_${error.status}`;
   const raw = error instanceof Error ? error.name : "slack_interaction_error";
   return (
     raw
@@ -991,6 +1022,16 @@ function safeErrorCode(error: unknown) {
   );
 }
 
+function slackAdmissionFailureText(error: HTTPException) {
+  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.";
+}
+
 class SlackInteractionPermanentError extends Error {}
 
 function permanentSlackInteractionError(error: unknown) {

package/src/mcp/server.ts

@@ -130,6 +130,7 @@ import {
   requireVariableSetEncryption,
 } from "@opengeni/core";
 import {
+  captureScheduledTaskRestoreState,
   createValidatedScheduledTask,
   manualScheduledTaskTriggerUsageKey,
   manualScheduledTaskTriggerWorkflowId,
@@ -829,6 +830,7 @@ export function buildOpenGeniMcpServer(
       },
       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({
@@ -844,7 +846,7 @@ export function buildOpenGeniMcpServer(
         await syncUpdatedScheduledTask({
           db: deps.db,
           workflowClient: deps.workflowClient,
-          previous: existing,
+          previous,
           task,
         });
         return json(task);
@@ -859,13 +861,14 @@ export function buildOpenGeniMcpServer(
       },
       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);
@@ -880,13 +883,14 @@ export function buildOpenGeniMcpServer(
       },
       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);

package/src/mcp/toolspace.ts

@@ -6,11 +6,13 @@ import { environmentsEncryptionKeyBytes, type McpServerConfig } from "@opengeni/
 import {
   prefixedMcpToolName,
   type AccessGrant,
+  type McpPersonalConnectionDelegation,
   type SessionTurn,
   type ToolRef,
 } from "@opengeni/contracts";
 import {
   hasPermission,
+  withFrozenPersonalConnectionDelegations,
   settingsWithEnabledCapabilityMcpServers,
   type ApiRouteDeps,
 } from "@opengeni/core";
@@ -20,6 +22,7 @@ import {
   clearPendingSessionToolspaceCall,
   getActiveSessionTurnForExecution,
   getSessionRootId,
+  getWorkspaceGrant,
   listSessionMcpServerMetadata,
   listSessionMcpServersForRun,
   registerPendingSessionToolCall,
@@ -229,6 +232,7 @@ export async function prepareToolspaceMcpSurface(input: {
     executionGeneration: activeTurn.executionGeneration,
   };
   const session = await requireSession(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);
@@ -270,6 +274,7 @@ export async function prepareToolspaceMcpSurface(input: {
     rootSessionId,
     proxyableIds,
     activeTurn,
+    personalConnectionDelegations,
     getRegistry: () => getRegistry(attemptAuthority.attemptId),
   });
   const tools = listing.map((entry) =>
@@ -279,6 +284,7 @@ export async function prepareToolspaceMcpSurface(input: {
       authority: attemptAuthority,
       rootSessionId,
       entry,
+      personalConnectionDelegations,
       getRegistry,
     }),
   );
@@ -330,9 +336,19 @@ async function resolveToolListing(input: {
   rootSessionId: string;
   proxyableIds: string[];
   activeTurn: SessionTurn;
+  personalConnectionDelegations: McpPersonalConnectionDelegation[];
   getRegistry: () => Promise<Map<string, McpServerConfig>>;
 }): Promise<ToolListingEntry[]> {
-  const { deps, grant, sessionId, rootSessionId, proxyableIds, activeTurn, getRegistry } = input;
+  const {
+    deps,
+    grant,
+    sessionId,
+    rootSessionId,
+    proxyableIds,
+    activeTurn,
+    personalConnectionDelegations,
+    getRegistry,
+  } = input;
   // Host credentials can be initiator-specific. A prior turn's tool list must
   // never be reused under a different frozen authority in the same session.
   const cacheKey = await toolListCacheKey(
@@ -370,6 +386,7 @@ async function resolveToolListing(input: {
       sessionId,
       rootSessionId,
       turn: activeTurn,
+      personalConnectionDelegations,
     }).catch((error) => {
       deps.observability?.warn("toolspace upstream connection failed", {
         serverId,
@@ -508,6 +525,7 @@ async function connectToolspaceServer(input: {
   sessionId: string;
   rootSessionId: string;
   turn: SessionTurn;
+  personalConnectionDelegations: McpPersonalConnectionDelegation[];
 }): Promise<ConnectedToolspaceServer> {
   // npm Undici's dispatcher transport is not reliable under Bun. The worker's
   // model-visible MCP path already uses Bun's native fetch while retaining the
@@ -555,9 +573,18 @@ function toolspaceToolFor(input: {
   authority: ToolspaceAttemptAuthority;
   rootSessionId: string;
   entry: ToolListingEntry;
+  personalConnectionDelegations: McpPersonalConnectionDelegation[];
   getRegistry: (attemptId: string) => Promise<Map<string, McpServerConfig>>;
 }): ToolspaceRegisteredTool {
-  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);
@@ -598,6 +625,7 @@ function toolspaceToolFor(input: {
         sessionId,
         rootSessionId,
         turn: reservation.turn,
+        personalConnectionDelegations,
       }).catch(() => null);
       if (!connection) {
         return mcpError(`upstream tool failed: ${name}`);
@@ -882,22 +910,15 @@ export function connectionBrokerFetch(
     sessionId: string;
     rootSessionId: string;
     turn: SessionTurn;
+    personalConnectionDelegations?: McpPersonalConnectionDelegation[];
   },
 ): FetchLike {
   const connectionRef = input.config.connectionRef;
   if (!connectionRef) {
     return baseFetch;
   }
-  const credentialSubjectId =
-    input.turn.initiator.kind === "subject" ? input.turn.initiator.subjectId : undefined;
-  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
+  const rawResolveCredential = hostCredentialPort
     ? buildHostConnectionTokenResolver(hostCredentialPort, {
         accountId: input.grant.accountId,
         workspaceId: input.grant.workspaceId,
@@ -911,18 +932,43 @@ export function connectionBrokerFetch(
         surface: "toolspace",
       })
     : buildConnectionTokenResolver(input.deps.db, input.deps.settings);
+  const personalDelegations = input.personalConnectionDelegations ?? [];
+  const delegatedMembershipChecks = new Map<string, Promise<boolean>>();
+  const delegatedOwnerHasMembership = async (subjectId: string): Promise<boolean> => {
+    const existing = delegatedMembershipChecks.get(subjectId);
+    if (existing) return await existing;
+    const check = getWorkspaceGrant(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
+        : undefined;
+    const resolve = async (forceRefresh: boolean) => {
+      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);
     }
@@ -932,15 +978,7 @@ export function connectionBrokerFetch(
     );
     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);
       }
@@ -989,7 +1027,7 @@ function authNeededFromStatus(
     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

package/src/routes/connections.ts

@@ -105,7 +105,7 @@ export function registerConnectionRoutes(app: Hono, deps: ApiRouteDeps): void {
     const payload = CreateConnectionRequest.parse(await c.req.json());
     assertNotReservedSlackBotMetadata(payload.metadata);
     const key = requireEnvironmentEncryption(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);
@@ -836,6 +836,22 @@ function writableSubjectId(
   return requested;
 }
 
+function createConnectionSubjectId(
+  payload: Pick<CreateConnectionRequest, "ownership" | "subjectId">,
+  grantSubjectId: string,
+): string | null {
+  if (payload.ownership === undefined) {
+    return writableSubjectId(payload.subjectId, grantSubjectId);
+  }
+  const subjectId = payload.ownership === "personal" ? grantSubjectId : null;
+  if (payload.subjectId !== undefined && payload.subjectId !== subjectId) {
+    throw new HTTPException(422, {
+      message: "ownership and subjectId describe different connection owners",
+    });
+  }
+  return subjectId;
+}
+
 function encryptCredentialBundle(key: Uint8Array, credential: Record<string, unknown>): string {
   return encryptEnvironmentValue(key, JSON.stringify(credential));
 }

package/src/routes/scheduled-tasks.ts

@@ -14,6 +14,7 @@ import { requireAccessGrant } from "@opengeni/core";
 import { recordWorkspaceUsage, requireLimit } from "@opengeni/core";
 import type { ApiRouteDeps } from "@opengeni/core";
 import {
+  captureScheduledTaskRestoreState,
   createValidatedScheduledTask,
   manualScheduledTaskTriggerUsageKey,
   manualScheduledTaskTriggerWorkflowId,
@@ -69,6 +70,7 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
     const grant = await requireAccessGrant(c, deps, workspaceId, "scheduled_tasks:manage");
     const taskId = c.req.param("taskId");
     const existing = await requireScheduledTaskForApi(db, workspaceId, taskId);
+    const previous = await captureScheduledTaskRestoreState(db, existing);
     const rawPayload = await c.req.json();
     const payload = UpdateScheduledTaskRequest.parse(rawPayload);
     const update = await validatedScheduledTaskUpdate({
@@ -81,7 +83,7 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
       toolsProvided: scheduledTaskToolsProvided(rawPayload),
     });
     const task = await updateScheduledTask(db, workspaceId, taskId, update);
-    await syncUpdatedScheduledTask({ db, workflowClient, previous: existing, task });
+    await syncUpdatedScheduledTask({ db, workflowClient, previous, task });
     return c.json(task);
   });
 
@@ -89,8 +91,9 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant(c, deps, workspaceId, "scheduled_tasks:manage");
     const existing = await requireScheduledTaskForApi(db, workspaceId, c.req.param("taskId"));
+    const previous = await captureScheduledTaskRestoreState(db, existing);
     const task = await updateScheduledTask(db, workspaceId, existing.id, { status: "paused" });
-    await syncUpdatedScheduledTask({ db, workflowClient, previous: existing, task });
+    await syncUpdatedScheduledTask({ db, workflowClient, previous, task });
     return c.json(task);
   });
 
@@ -98,8 +101,9 @@ export function registerScheduledTaskRoutes(app: Hono, deps: ApiRouteDeps): void
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant(c, deps, workspaceId, "scheduled_tasks:manage");
     const existing = await requireScheduledTaskForApi(db, workspaceId, c.req.param("taskId"));
+    const previous = await captureScheduledTaskRestoreState(db, existing);
     const task = await updateScheduledTask(db, workspaceId, existing.id, { status: "active" });
-    await syncUpdatedScheduledTask({ db, workflowClient, previous: existing, task });
+    await syncUpdatedScheduledTask({ db, workflowClient, previous, task });
     return c.json(task);
   });