@opengeni/core 4.6.1 → 4.6.2-canary.39853438886001

package/dist/domain/capabilities.d.ts

@@ -10,6 +10,7 @@ export declare function buildCapabilityCatalog(input: {
     /** The workspace's organization, when the caller knows it (skips a lookup). */
     accountId?: string;
 }): Promise<CapabilityCatalogResponse>;
+export declare function applyGoogleConnectorSetupAvailability(item: CapabilityCatalogItem, settings: Settings): CapabilityCatalogItem;
 export declare function applyOperatorOAuthClientRequirement(item: CapabilityCatalogItem, configured: (issuer: string) => boolean): CapabilityCatalogItem;
 export declare function createCatalogItem(input: {
     db: Database;

package/dist/domain/personal-connection-delegations.d.ts

@@ -57,13 +57,8 @@ export declare function personalConnectionDelegationsFromParent(input: {
     personalGitHubResources?: ResourceRef[];
     targetSessionId?: string;
 }): McpPersonalConnectionDelegation[];
-/**
- * Freezes Google Drive publishing only when one exact subject-owned connection
- * is eligible. Multiple writable Google accounts are intentionally ambiguous:
- * callers must narrow the connection before a later turn can advertise or use
- * the private publication tool.
- */
-export declare function googleDrivePublicationDelegationFromVisibleConnections(input: {
+/** Historical native Drive credentials never become new publication authority. */
+export declare function googleDrivePublicationDelegationFromVisibleConnections(_input: {
     subjectId: string;
     connections: ConnectionMetadata[];
     authoritySelection?: McpConnectionAccountSelection;
@@ -160,7 +155,7 @@ export declare function freezePersonalConnectionDelegations(input: {
     resources?: ResourceRef[];
     source: PersonalConnectionDelegationSource;
     authoritySelections?: McpConnectionAccountSelection[];
-    /** Exact first-party export tool + permission gate, not broad opengeni attachment. */
+    /** @deprecated Native Drive publishing is retired; this flag grants no authority. */
     googleDrivePublicationEnabled?: boolean;
     /** Exact first-party Atlassian tool + permission gate. */
     atlassianEnabled?: boolean;

package/dist/domain/scheduled-tasks.d.ts

@@ -8,7 +8,8 @@ import { type ScheduledTaskSlackChannelVerifier } from "./slack-bot.js";
 export declare function scheduledTaskToolsProvided(rawPayload: unknown): boolean;
 /** Resolve the target's current tool policy before choosing its owner's accounts. */
 export declare function scheduledConnectionTools(db: Database, workspaceId: string, settings: Settings, target: Session | null, taskTools: ToolRef[], subjectId?: string): Promise<ToolRef[]>;
-export declare function scheduledConnectionSurfaceEligibility(settings: Settings, target: (Pick<Session, "firstPartyMcpTools" | "firstPartyMcpPermissions"> & Partial<Pick<Session, "toolPolicy" | "agent">>) | null, workspaceSettings?: unknown): {
+/** Native publication surfaces are retired; MCP uses the ordinary selected-tool policy. */
+export declare function scheduledConnectionSurfaceEligibility(_settings: Settings, _target: (Pick<Session, "firstPartyMcpTools" | "firstPartyMcpPermissions"> & Partial<Pick<Session, "toolPolicy" | "agent">>) | null, _workspaceSettings?: unknown): {
     googleDrivePublicationEnabled: boolean;
     atlassianEnabled: boolean;
 };

package/dist/goal-admission.d.ts

@@ -61,6 +61,8 @@ export declare function resolveGoalModelAdmission(db: Database, settings: Settin
         turnWorkerEmergencyMemoryUsage: number;
         turnWorkerMemoryGuardIntervalMs: number;
         turnWorkerMemoryGuardSustainMs: number;
+        turnWorkerShutdownGraceMs: number;
+        turnWorkerShutdownForceMs: number;
         observabilityStructuredLogs: boolean;
         observabilityMetricsEnabled: boolean;
         observabilityOtlpEndpoint?: string | undefined;
@@ -122,6 +124,8 @@ export declare function resolveGoalModelAdmission(db: Database, settings: Settin
         onePasswordFakeTokens: boolean;
         protonPassCliPath?: string | undefined;
         integrationsEnabled: boolean;
+        googleConnectorSetupEnabled: boolean;
+        googleDriveMcpEnabled: boolean;
         integrationsStateSecret?: string | undefined;
         integrationsAllowPrivateNetworkTargets: boolean;
         privacyOnlyMeAllowed: boolean;

package/dist/index.js

@@ -1637,7 +1637,10 @@ async function buildCapabilityCatalog(input) {
       }
     } : projected;
     return applyCapabilityLifecycle(
-      applyOperatorOAuthClientRequirement(runtimeProjected, operatorOAuthClientConfigured)
+      applyGoogleConnectorSetupAvailability(
+        applyOperatorOAuthClientRequirement(runtimeProjected, operatorOAuthClientConfigured),
+        input.settings
+      )
     );
   }).sort(compareCatalogItems);
   return {
@@ -1651,7 +1654,22 @@ function operatorOAuthClientResolver(settings) {
     configured = parseIntegrationsOauthClientsJson(settings.integrationsOauthClientsJson);
   } catch {
   }
-  return (issuer) => findIntegrationsOauthClient(configured, [issuer]) !== null;
+  return (issuer) => (issuer !== "https://accounts.google.com" || settings.googleConnectorSetupEnabled) && findIntegrationsOauthClient(configured, [issuer]) !== null;
+}
+function applyGoogleConnectorSetupAvailability(item, settings) {
+  const url = item.mcpUrl ?? item.endpointUrl;
+  const drive = url === "https://drivemcp.googleapis.com/mcp/v1";
+  const gmail = url === "https://gmailmcp.googleapis.com/mcp/v1";
+  if (item.kind !== "mcp" || !drive && !gmail || settings.googleConnectorSetupEnabled && (!drive || settings.googleDriveMcpEnabled))
+    return item;
+  return {
+    ...item,
+    runtime: {
+      ...item.runtime,
+      operatorOAuthClient: { configured: false },
+      notes: "New connections are unavailable until Google data-access verification and provider setup are complete."
+    }
+  };
 }
 function applyOperatorOAuthClientRequirement(item, configured) {
   if (item.kind !== "mcp") return item;
@@ -1750,9 +1768,11 @@ async function prepareCapabilityEnable(input) {
   delete installationConfig.headerNames;
   delete installationConfig.connectionRef;
   if (item.kind === "mcp") {
-    if (item.endpointUrl?.replace(/\/+$/u, "") === "https://gmailmcp.googleapis.com/mcp/v1" && (input.payload.connectionRef?.subjectScope !== "subject" || Object.keys(input.payload.headers ?? {}).length > 0)) {
+    if (["https://gmailmcp.googleapis.com/mcp/v1", "https://drivemcp.googleapis.com/mcp/v1"].includes(
+      item.endpointUrl?.replace(/\/+$/u, "") ?? ""
+    ) && (input.payload.connectionRef?.subjectScope !== "subject" || Object.keys(input.payload.headers ?? {}).length > 0)) {
       throw new HTTPException4(422, {
-        message: "Gmail requires a personal-owned connection reference"
+        message: "Google connector requires a personal-owned connection reference"
       });
     }
     const unchanged = await withOrganizationIntegrationPolicyFence(
@@ -2197,6 +2217,7 @@ async function settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings
       readCodexAppsDesignation()
     ]);
   }
+  apiIntegrations = apiIntegrations.filter(apiIntegrationIsExecutable);
   options?.onResolvedApiIntegrations?.(apiIntegrations);
   options?.onResolvedCapabilityServers?.(enabled);
   return settingsWithCodexAppsMcpServer(
@@ -2214,9 +2235,7 @@ async function settingsWithEnabledCapabilityMcpServersForTargets(db, workspaceId
     serverIds: [...serverIds]
   })).filter((server) => serverIds.has(server.id));
   options.signal?.throwIfAborted();
-  const apiIntegrations = await listInstalledApiIntegrations(db, workspaceId, options.subjectId, [
-    ...serverIds
-  ]);
+  const apiIntegrations = (await listInstalledApiIntegrations(db, workspaceId, options.subjectId, [...serverIds])).filter(apiIntegrationIsExecutable);
   options.signal?.throwIfAborted();
   const codexAppsDesignation = settings.codexConnectedAppsEnabled && serverIds.has(CODEX_APPS_MCP_SERVER_ID) ? await resolveCodexAppsDesignationForRun(db, workspaceId, { accountId: options.accountId }) : null;
   options.onResolvedApiIntegrations?.(apiIntegrations);
@@ -2269,10 +2288,15 @@ async function listInstalledApiIntegrationsForDelegations(db, workspaceId, deleg
     byServerId.set(integration.serverId, integration);
   return [...byServerId.values()];
 }
+function apiIntegrationIsExecutable(integration) {
+  return !(integration.definitionProvenance === "curated" && integration.definitionId === "google-drive");
+}
 function settingsWithApiIntegrationServers(settings, integrations) {
   if (integrations.length === 0) return settings;
   const existingIds = new Set(settings.mcpServers.map((server) => server.id));
-  const dynamicServers = integrations.filter((integration) => !existingIds.has(integration.serverId)).map((integration) => ({
+  const dynamicServers = integrations.filter(
+    (integration) => apiIntegrationIsExecutable(integration) && !existingIds.has(integration.serverId)
+  ).map((integration) => ({
     id: integration.serverId,
     name: integration.name,
     // Local adapters never send MCP traffic to this URL. Keeping the exact
@@ -3445,9 +3469,7 @@ function storedConnectionRef(config) {
 // src/domain/personal-connection-delegations.ts
 import {
   GOOGLE_DRIVE_PROVIDER_DOMAIN,
-  GOOGLE_DRIVE_PUBLICATION_SERVER_ID,
-  GoogleDriveConnectionMetadata,
-  googleDriveScopesAllowCapability
+  GOOGLE_DRIVE_PUBLICATION_SERVER_ID
 } from "@opengeni/contracts/google-drive";
 import {
   isPersonalGitHubConnection,
@@ -4039,14 +4061,14 @@ function personalConnectionDelegationsFromParent(input) {
     const ref = server.connectionRef;
     if (!isNativeSubjectConnectionRef(ref)) return [];
     const delegation = input.parentDelegations.find(
-      (candidate) => candidate.connectionType !== "atlassian" && candidate.serverId === server.id && sameProviderDomain(candidate.providerDomain, ref.providerDomain) && (!ref.kind || !candidate.kind || candidate.kind === ref.kind)
+      (candidate) => candidate.connectionType !== "atlassian" && candidate.serverId !== GOOGLE_DRIVE_PUBLICATION_SERVER_ID && candidate.serverId === server.id && sameProviderDomain(candidate.providerDomain, ref.providerDomain) && (!ref.kind || !candidate.kind || candidate.kind === ref.kind)
     );
     return delegation ? [{ ...delegation }] : [];
   });
   const projected = [
     ...mcp,
     ...input.parentDelegations.filter(
-      (item) => item.connectionType === "social" || item.connectionType === "github_personal" || item.serverId === GOOGLE_DRIVE_PUBLICATION_SERVER_ID
+      (item) => item.connectionType === "social" || item.connectionType === "github_personal"
     ).map((item) => ({ ...item }))
   ];
   const requestedGitHub = personalGitHubRepositoryResources(input.personalGitHubResources ?? []);
@@ -4076,52 +4098,8 @@ function personalConnectionDelegationsFromParent(input) {
   }
   return inherited;
 }
-function googleDrivePublicationDelegationFromVisibleConnections(input) {
-  const selection = input.authoritySelection;
-  const eligible = input.connections.filter((connection2) => {
-    if (connection2.subjectId !== input.subjectId || connection2.status !== "active" || !connection2.authorityId || connection2.kind !== "oauth2" || !sameProviderDomain(connection2.providerDomain, GOOGLE_DRIVE_PROVIDER_DOMAIN) || !googleDriveScopesAllowCapability(connection2.grantedScopes, "publish_file")) {
-      return false;
-    }
-    const metadata = GoogleDriveConnectionMetadata.safeParse(connection2.metadata);
-    return Boolean(
-      metadata.success && metadata.data.outputDestination && metadata.data.lifecycle?.state !== "paused" && (!metadata.data.lifecycle || metadata.data.lifecycle.state === "active")
-    );
-  });
-  const selectedEligible = selection ? eligible.filter((connection2) => connection2.id === selection.connectionId) : eligible;
-  if (selection && selectedEligible.length !== 1) {
-    throw new ConnectionAccountSelectionError(
-      "Google Drive publication authority selection is unavailable",
-      {
-        version: 1,
-        reason: "selected_account_unavailable",
-        accounts: [
-          {
-            serverId: GOOGLE_DRIVE_PUBLICATION_SERVER_ID,
-            connectionId: selection.connectionId,
-            reason: "selection_unavailable"
-          }
-        ]
-      }
-    );
-  }
-  if (!selection && selectedEligible.length !== 1) return null;
-  const connection = selectedEligible[0];
-  if (selection && selection.serverId !== GOOGLE_DRIVE_PUBLICATION_SERVER_ID) {
-    throw new Error("Google Drive publication account selection is invalid");
-  }
-  const frozenMetadata = GoogleDriveConnectionMetadata.parse(connection.metadata);
-  if (!frozenMetadata.outputDestination) {
-    throw new Error("Google Drive publication destination disappeared during acceptance");
-  }
-  return {
-    serverId: GOOGLE_DRIVE_PUBLICATION_SERVER_ID,
-    connectionId: connection.id,
-    originWorkspaceId: connection.workspaceId,
-    ownerSubjectId: input.subjectId,
-    providerDomain: connection.providerDomain,
-    kind: connection.kind,
-    outputDestination: frozenMetadata.outputDestination
-  };
+function googleDrivePublicationDelegationFromVisibleConnections(_input) {
+  return null;
 }
 function personalAtlassianDelegationsFromVisibleConnections(_input) {
   return [];
@@ -4392,6 +4370,22 @@ async function availableMcpAccountBindings(input) {
   });
 }
 async function freezePersonalConnectionDelegations(input) {
+  const retiredSelections = (input.authoritySelections ?? []).filter(
+    (selection) => selection.serverId === GOOGLE_DRIVE_PUBLICATION_SERVER_ID
+  );
+  if (retiredSelections.length > 0) {
+    throw new ConnectionAccountSelectionError(
+      "Native Google Drive publishing has been retired; select the Google Drive MCP connection",
+      {
+        version: 1,
+        reason: "selected_account_unavailable",
+        accounts: retiredSelections.map((selection) => ({
+          ...selection,
+          reason: "connector_unavailable"
+        }))
+      }
+    );
+  }
   const servers = selectedPersonalConnectionServers(input.settings, input.tools);
   const includeFirstPartyConnections = input.tools.some((tool) => tool.id === "opengeni");
   const personalGitHubResources = personalGitHubRepositoryResources(input.resources ?? []);
@@ -4426,7 +4420,7 @@ async function freezePersonalConnectionDelegations(input) {
     });
     return inherited.filter((item) => {
       if (item.serverId === GOOGLE_DRIVE_PUBLICATION_SERVER_ID) {
-        return input.googleDrivePublicationEnabled === true;
+        return false;
       }
       if (item.connectionType === "atlassian") {
         return false;
@@ -4462,9 +4456,6 @@ async function freezePersonalConnectionDelegations(input) {
   });
   const selectedMcpServerIds = new Set(servers.map((server) => server.id));
   const supportedSelectionIds = new Set(selectedMcpServerIds);
-  if (input.googleDrivePublicationEnabled) {
-    supportedSelectionIds.add(GOOGLE_DRIVE_PUBLICATION_SERVER_ID);
-  }
   if (personalGitHubResources.length > 0) {
     supportedSelectionIds.add(PERSONAL_GITHUB_CONNECTION_SURFACE_ID);
   }
@@ -4519,18 +4510,9 @@ async function freezePersonalConnectionDelegations(input) {
     subjectId: ownerSubjectId,
     connections: visibleConnections
   }) : [];
-  const googleDriveAuthoritySelection = input.googleDrivePublicationEnabled ? (input.authoritySelections ?? []).find(
-    (selection) => selection.serverId === GOOGLE_DRIVE_PUBLICATION_SERVER_ID
-  ) : void 0;
-  const googleDrivePublication = input.googleDrivePublicationEnabled ? googleDrivePublicationDelegationFromVisibleConnections({
-    subjectId: ownerSubjectId,
-    connections: visibleConnections,
-    ...googleDriveAuthoritySelection ? { authoritySelection: googleDriveAuthoritySelection } : {}
-  }) : null;
   return [
     ...mcp,
     ...personalGitHub ? [personalGitHub] : [],
-    ...googleDrivePublication ? [googleDrivePublication] : [],
     ...[...latest.values()].map((connection) => ({
       serverId: `social:${connection.provider}`,
       connectionId: connection.id,
@@ -14607,7 +14589,6 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     firstPartyMcpTools,
     settings.mcpServers
   );
-  const googleDrivePublicationEnabled = firstPartyMcpTools.includes("editable_artifact_export") && firstPartyMcpTools.includes("editable_artifact_export_status") && (!firstPartyMcpPermissions?.length || firstPartyMcpPermissions.includes("artifacts:read") && firstPartyMcpPermissions.includes("artifacts:publish"));
   const atlassianEnabled = firstPartyMcpTools.some((tool) => tool.startsWith("atlassian_")) && (!firstPartyMcpPermissions?.length || firstPartyMcpPermissions.includes("connections:read"));
   const connectionAccountTools = sessionToolsForConnectionAccounts({
     session: { tools, toolPolicy },
@@ -14629,7 +14610,6 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       resources,
       source: connectionDelegationSource,
       authoritySelections: payload.connectionAccounts,
-      googleDrivePublicationEnabled,
       atlassianEnabled
     })
   );
@@ -15310,11 +15290,6 @@ async function acceptSessionUserMessageInFileScope(deps, grant, workspaceId, ses
         connectionWorkspace.settings
       )
     });
-    const existingEffectiveFirstPartyTools = resolveSessionFirstPartyMcpTools3(
-      settings,
-      existingSession,
-      connectionWorkspace.settings
-    );
     const { personalConnectionDelegations, mcpAccountBindings, connectionAccountIntent } = await freezeConnectionAccounts({
       db,
       accountId: grant.accountId,
@@ -15324,7 +15299,6 @@ async function acceptSessionUserMessageInFileScope(deps, grant, workspaceId, ses
       resources: [...existingSession.resources, ...requestedResources],
       source: connectionDelegationSource,
       targetSessionId: sessionId,
-      googleDrivePublicationEnabled: existingEffectiveFirstPartyTools.includes("editable_artifact_export") && existingEffectiveFirstPartyTools.includes("editable_artifact_export_status") && (!existingSession.firstPartyMcpPermissions?.length || existingSession.firstPartyMcpPermissions.includes("artifacts:read") && existingSession.firstPartyMcpPermissions.includes("artifacts:publish")),
       atlassianEnabled: existingSession.firstPartyMcpTools.some((tool) => tool.startsWith("atlassian_")) && (!existingSession.firstPartyMcpPermissions?.length || existingSession.firstPartyMcpPermissions.includes("connections:read")),
       ...input.connectionAccounts ? { authoritySelections: input.connectionAccounts } : {}
     });
@@ -16334,7 +16308,6 @@ async function freezeSessionRealtimeConnectionAccounts(input) {
     resources: session.resources,
     source: personalConnectionDelegationSourceForGrant(grant),
     targetSessionId: sessionId,
-    googleDrivePublicationEnabled: effectiveFirstPartyTools.includes("editable_artifact_export") && effectiveFirstPartyTools.includes("editable_artifact_export_status") && (!session.firstPartyMcpPermissions?.length || session.firstPartyMcpPermissions.includes("artifacts:read") && session.firstPartyMcpPermissions.includes("artifacts:publish")),
     atlassianEnabled: effectiveFirstPartyTools.some((tool) => tool.startsWith("atlassian_")) && (!session.firstPartyMcpPermissions?.length || session.firstPartyMcpPermissions.includes("connections:read"))
   });
 }
@@ -16366,14 +16339,13 @@ async function resolveContinuedConnectionAccounts(input) {
     session,
     workspace.settings
   );
-  let googleDrivePublicationEnabled = effectiveFirstPartyTools.includes("editable_artifact_export") && effectiveFirstPartyTools.includes("editable_artifact_export_status") && (!session.firstPartyMcpPermissions?.length || session.firstPartyMcpPermissions.includes("artifacts:read") && session.firstPartyMcpPermissions.includes("artifacts:publish"));
   const atlassianEnabled = effectiveFirstPartyTools.some((tool) => tool.startsWith("atlassian_")) && (!session.firstPartyMcpPermissions?.length || session.firstPartyMcpPermissions.includes("connections:read"));
   const withoutPersonalRepositories = (from) => {
     const personal = new Set(personalGitHubRepositoryResources(from));
     return from.filter((resource) => !personal.has(resource));
   };
   let resources = principalSubjectId ? session.resources : withoutPersonalRepositories(session.resources);
-  const applies = (selection) => selection.serverId === GOOGLE_DRIVE_PUBLICATION_SERVER_ID2 ? googleDrivePublicationEnabled : selection.serverId === PERSONAL_GITHUB_CONNECTION_SURFACE_ID2 ? personalGitHubRepositoryResources(resources).length > 0 : tools.some((tool) => tool.kind === "mcp" && tool.id === selection.serverId);
+  const applies = (selection) => selection.serverId === GOOGLE_DRIVE_PUBLICATION_SERVER_ID2 ? false : selection.serverId === PERSONAL_GITHUB_CONNECTION_SURFACE_ID2 ? personalGitHubRepositoryResources(resources).length > 0 : tools.some((tool) => tool.kind === "mcp" && tool.id === selection.serverId);
   let selections = intent.selections.filter(applies);
   const gaps = [];
   for (let round = 0; ; round += 1) {
@@ -16387,7 +16359,6 @@ async function resolveContinuedConnectionAccounts(input) {
         resources,
         source: principalSubjectId ? { kind: "subject", subjectId: principalSubjectId, accountId } : { kind: "none" },
         targetSessionId: sessionId,
-        googleDrivePublicationEnabled,
         atlassianEnabled,
         authoritySelections: selections
       });
@@ -16415,7 +16386,6 @@ async function resolveContinuedConnectionAccounts(input) {
       );
       selections = selections.filter((selection) => !dropped.has(selection.serverId));
       tools = tools.filter((tool) => !(tool.kind === "mcp" && dropped.has(tool.id)));
-      if (dropped.has(GOOGLE_DRIVE_PUBLICATION_SERVER_ID2)) googleDrivePublicationEnabled = false;
       if (dropped.has(PERSONAL_GITHUB_CONNECTION_SURFACE_ID2)) {
         resources = withoutPersonalRepositories(resources);
       }
@@ -16456,6 +16426,7 @@ function integrationSourceForOrganizationPolicy(policy, source) {
 }
 var dedicated = [
   { key: "gmail", label: "Gmail" },
+  { key: "google-drive", label: "Google Drive" },
   { key: "atlassian", label: "Atlassian (Jira and Confluence)" },
   { key: "slack-personal", label: "Slack personal accounts" },
   { key: "slack-bot", label: "Slack workspace bots" },
@@ -23123,6 +23094,11 @@ function personalGitHubActionPolicyActor(input) {
 }
 
 // src/domain/scheduled-tasks.ts
+import {
+  GOOGLE_DRIVE_NATIVE_RETIRED_MESSAGE,
+  isRetiredNativeGoogleDriveSource,
+  isRetiredNativeGoogleDriveTask
+} from "@opengeni/contracts/google-drive-native-retirement";
 import {
   getSessionTurnClaudeProviderAccountAuthoritySnapshot as getSessionTurnClaudeProviderAccountAuthoritySnapshot2,
   getScheduledTaskClaudeProviderAccountAuthoritySnapshot as getScheduledTaskClaudeProviderAccountAuthoritySnapshot2
@@ -23137,7 +23113,6 @@ import {
   SCHEDULED_TASK_OCCURRENCE_PAYLOAD_INGRESS_HEADROOM_BYTES
 } from "@opengeni/contracts";
 import {
-  allowedFirstPartyMcpToolsForSession as allowedFirstPartyMcpToolsForSession2,
   resolveSessionFirstPartyMcpTools as resolveSessionFirstPartyMcpTools5,
   resolveFirstPartyMcpToolPolicy as resolveFirstPartyMcpToolPolicy2
 } from "@opengeni/config";
@@ -23407,17 +23382,8 @@ async function scheduledConnectionTools(db, workspaceId, settings, target, taskT
     )
   }).toolRefs;
 }
-function scheduledConnectionSurfaceEligibility(settings, target, workspaceSettings = {}) {
-  const tools = target?.toolPolicy ? resolveSessionFirstPartyMcpTools5(
-    settings,
-    { ...target, toolPolicy: target.toolPolicy },
-    workspaceSettings
-  ) : allowedFirstPartyMcpToolsForSession2(settings, target?.firstPartyMcpTools);
-  const permissions = target?.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS3;
-  return {
-    googleDrivePublicationEnabled: tools.includes("editable_artifact_export") && tools.includes("editable_artifact_export_status") && permissions.includes("artifacts:read") && permissions.includes("artifacts:publish"),
-    atlassianEnabled: false
-  };
+function scheduledConnectionSurfaceEligibility(_settings, _target, _workspaceSettings = {}) {
+  return { googleDrivePublicationEnabled: false, atlassianEnabled: false };
 }
 function isScheduledTaskMachinePrincipal(grant) {
   return grant.principalKind === "api_key" || grant.principalKind === "configured_key";
@@ -23927,6 +23893,8 @@ var SCHEDULED_TASK_PAUSED_TRIGGER_MESSAGE = "This schedule is paused, so it cann
 async function triggerScheduledTaskForGrant(db, grant, workflowClient, input) {
   await db.transaction(async (tx) => {
     await assertScheduledTaskMutationOwner(tx, grant, input.task.id);
+    if (isRetiredNativeGoogleDriveTask(input.task))
+      throw new HTTPException31(410, { message: GOOGLE_DRIVE_NATIVE_RETIRED_MESSAGE });
     if (isRetiredNativeAtlassianTask(input.task))
       throw new HTTPException31(410, { message: ATLASSIAN_NATIVE_RETIRED_MESSAGE });
     if (input.task.status === "paused")
@@ -24301,6 +24269,8 @@ async function validatedScheduledTaskUpdateWithoutAudience(input) {
     expectedExecutionDigest: input.existing.executionDigest
   };
   const requestedKnowledgeSource = input.payload.agentConfig?.knowledgeSource ?? null;
+  if (isRetiredNativeGoogleDriveTask(input.existing) && (input.payload.status === "active" || requestedKnowledgeSource))
+    throw new HTTPException31(410, { message: GOOGLE_DRIVE_NATIVE_RETIRED_MESSAGE });
   if (isRetiredNativeAtlassianTask(input.existing) && (input.payload.status === "active" || requestedKnowledgeSource))
     throw new HTTPException31(410, { message: ATLASSIAN_NATIVE_RETIRED_MESSAGE });
   const existingKnowledgeSource = scheduledTaskKnowledgeSource(input.existing);
@@ -24691,6 +24661,8 @@ async function restoreScheduledTask(db, previous) {
   });
 }
 async function validateKnowledgeSourceSyncAction(input) {
+  if (isRetiredNativeGoogleDriveSource(input.action))
+    throw new HTTPException31(410, { message: GOOGLE_DRIVE_NATIVE_RETIRED_MESSAGE });
   if (isRetiredNativeAtlassianSource(input.action))
     throw new HTTPException31(410, { message: ATLASSIAN_NATIVE_RETIRED_MESSAGE });
   if (input.action.initiatingSubjectId !== input.grant.subjectId) {
@@ -25071,7 +25043,7 @@ function trimmedScheduledTaskName(name) {
 
 // src/domain/scheduled-task-access.ts
 import {
-  allowedFirstPartyMcpToolsForSession as allowedFirstPartyMcpToolsForSession3,
+  allowedFirstPartyMcpToolsForSession as allowedFirstPartyMcpToolsForSession2,
   resolveFirstPartyMcpToolPolicy as resolveFirstPartyMcpToolPolicy3
 } from "@opengeni/config";
 import {
@@ -25190,7 +25162,7 @@ function sameMembers(left, right) {
 function planScheduledTaskOpenGeniTools(input) {
   const stored2 = input.creatorPolicy?.firstPartyMcpTools;
   if (!stored2) return { missing: [], policy: null };
-  const effective = new Set(allowedFirstPartyMcpToolsForSession3(input.settings, stored2));
+  const effective = new Set(allowedFirstPartyMcpToolsForSession2(input.settings, stored2));
   const missing = resolveFirstPartyMcpToolPolicy3(input.settings).default.filter(
     (tool) => !effective.has(tool) && !input.leaveOut?.has(tool)
   );
@@ -30205,6 +30177,8 @@ import {
   gmailToolSupportsScopes,
   isOfficialGmailMcpConfig,
   isOfficialSlackMcpConfig,
+  isOfficialDriveMcpConfig,
+  mergeDriveMcpTools,
   sessionMcpApprovalConnectionId
 } from "@opengeni/runtime";
 var ConnectorConnectionRequiredError = class extends HTTPException39 {
@@ -30398,7 +30372,8 @@ async function listTools(input, target) {
       throw legacyMcpClientError(error);
     })
   );
-  return tools.filter(
+  const completeTools = isOfficialDriveMcpConfig(target.server) ? mergeDriveMcpTools(tools) : tools;
+  return completeTools.filter(
     (tool) => !target.server.allowedTools || target.server.allowedTools.includes(tool.name)
   );
 }
@@ -30761,6 +30736,7 @@ export {
   appendRigSetupCommand,
   applyCapabilityEnablement,
   applyGitHubRepositoryBindings,
+  applyGoogleConnectorSetupAvailability,
   applyInitialSessionUsageLimit,
   applyOperatorOAuthClientRequirement,
   applySessionAgentConfigWriteThrough,