@datalayer/core 1.2.10 → 1.2.13

package/lib/hooks/useCache.js

@@ -58,6 +58,19 @@ const DEFAULT_QUERY_OPTIONS = {
     // Ensure queries prioritize cache over network when data is fresh
     networkMode: 'online',
 };
+/**
+ * A list of what a space holds — all of it, or the items of one type. Every
+ * such list takes these options (`spaceListsRefetchOnMount.unit.test.ts`
+ * holds them to it). Refetched every time a page mounts it: an item
+ * created elsewhere — a cell has no create mutation here to clear this cache —
+ * would otherwise stay missing from the list for the five minutes the default
+ * options keep it fresh, and coming back to the list is exactly when somebody
+ * looks for it.
+ */
+const LIST_QUERY_OPTIONS = {
+    ...DEFAULT_QUERY_OPTIONS,
+    refetchOnMount: 'always',
+};
 /**
  * Refresh what a visitor sees, not just what the editor is looking at.
  *
@@ -727,6 +740,10 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
          */
         if (raw.publicUrl)
             meta.publicUrl = raw.publicUrl;
+        if (raw.shareCardUrl)
+            meta.shareCardUrl = raw.shareCardUrl;
+        if (raw.shareCardVersion)
+            meta.shareCardVersion = raw.shareCardVersion;
         return meta;
     };
     /**
@@ -859,6 +876,32 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             owner: toItemOwner(raw),
         };
     };
+    /**
+     * A published agentic UI application: what it answers, and its definition
+     * as the library hands it over — `model_s`, the string the Studio reads
+     * the definition from, left unparsed because the Studio owns its shape.
+     */
+    const toApp = (raw) => {
+        return {
+            id: raw.uid,
+            type: 'app',
+            name: raw.name_t,
+            description: raw.description_t,
+            tags: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            public: raw.is_public_b ?? false,
+            model_s: raw.model_s,
+            creationDate: raw.creation_ts_dt
+                ? new Date(raw.creation_ts_dt)
+                : undefined,
+            lastUpdateDate: raw.last_update_ts_dt
+                ? new Date(raw.last_update_ts_dt)
+                : undefined,
+            lastPublicationDate: raw.published_ts_dt
+                ? new Date(raw.published_ts_dt)
+                : undefined,
+            owner: toItemOwner(raw),
+        };
+    };
     /** An evaluator of the platform's catalogue (B5-01), published as an agent is. */
     const toEvaluator = (raw) => {
         return {
@@ -1371,6 +1414,10 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 return toInvestigation(item);
             case 'evaluator':
                 return toEvaluator(item);
+            // Without this a published app answered `{}`, as a deck once did: a
+            // card with no type and no name.
+            case 'app':
+                return toApp(item);
             case 'sitecard':
                 return toSiteCard(item);
             default:
@@ -2341,7 +2388,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 }
                 return [];
             },
-            ...DEFAULT_QUERY_OPTIONS,
+            ...LIST_QUERY_OPTIONS,
             enabled: !!spaceId,
         });
     };
@@ -2473,7 +2520,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 }
                 return [];
             },
-            ...DEFAULT_QUERY_OPTIONS,
+            ...LIST_QUERY_OPTIONS,
             enabled: !!spaceId,
         });
     };
@@ -2648,7 +2695,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 }
                 return [];
             },
-            ...DEFAULT_QUERY_OPTIONS,
+            ...LIST_QUERY_OPTIONS,
             enabled: !!spaceId,
         });
     };
@@ -4156,7 +4203,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 return [];
             },
             enabled: !!spaceId,
-            ...DEFAULT_QUERY_OPTIONS,
+            ...LIST_QUERY_OPTIONS,
         });
     };
     /**
@@ -4343,7 +4390,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 return [];
             },
             enabled: !!spaceId,
-            ...DEFAULT_QUERY_OPTIONS,
+            ...LIST_QUERY_OPTIONS,
         });
     };
     /**
@@ -4434,7 +4481,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 return [];
             },
             enabled: !!spaceId,
-            ...DEFAULT_QUERY_OPTIONS,
+            ...LIST_QUERY_OPTIONS,
         });
     };
     /**
@@ -4474,7 +4521,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 return [];
             },
             enabled: !!spaceId,
-            ...DEFAULT_QUERY_OPTIONS,
+            ...LIST_QUERY_OPTIONS,
         });
     };
     /**
@@ -4543,7 +4590,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 return [];
             },
             enabled: !!spaceId,
-            ...DEFAULT_QUERY_OPTIONS,
+            ...LIST_QUERY_OPTIONS,
         });
     };
     /**
@@ -4637,7 +4684,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 return [];
             },
             enabled: !!spaceId,
-            ...DEFAULT_QUERY_OPTIONS,
+            ...LIST_QUERY_OPTIONS,
         });
     };
     /**
@@ -6328,6 +6375,8 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         'evalset',
         'dataset',
         'agent',
+        // An agentic UI application, published from the Studio.
+        'app',
     ];
     const librarySearchQueryString = ({ q, types, max = 20, offset = 0, sort = 'relevance', featured = false, owner, }) => {
         const normalizedTypes = Array.from(new Set((types || [])
@@ -6853,6 +6902,157 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             onSuccess: invalidateArtifactVisibility,
         });
     };
+    /** Publish a public artifact natively to LinkedIn through Library's saga. */
+    const usePublishLinkedInShare = () => {
+        return useMutation({
+            mutationFn: async ({ itemId, commentary, idempotencyKey, imageDataUrl, imageAltText, }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/shares/linkedin`,
+                    method: 'POST',
+                    headers: { 'Idempotency-Key': idempotencyKey },
+                    body: { commentary, imageDataUrl, imageAltText },
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to publish to LinkedIn');
+                }
+                return resp.share;
+            },
+        });
+    };
+    const useUnpublishLinkedInShare = () => {
+        return useMutation({
+            mutationFn: async (idempotencyKey) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/shares/linkedin/${encodeURIComponent(idempotencyKey)}`,
+                    method: 'DELETE',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to unpublish from LinkedIn');
+                }
+                return resp.share;
+            },
+        });
+    };
+    const useLinkedInShares = (itemId, enabled = true) => {
+        return useQuery({
+            queryKey: ['library', 'social-shares', 'linkedin', itemId],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/shares/linkedin`,
+                    method: 'GET',
+                    notifyOnError: false,
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to load LinkedIn publications');
+                }
+                return Array.isArray(resp.shares) ? resp.shares : [];
+            },
+            ...DEFAULT_QUERY_OPTIONS,
+            enabled: Boolean(configuration.libraryUrl) && Boolean(itemId) && enabled,
+        });
+    };
+    /**
+     * Post a public artifact to X through the Library's saga: the author's
+     * text, then the artifact's attributed share-card link (X draws the card),
+     * and optionally one picked result as an image.
+     */
+    const usePublishXShare = () => {
+        return useMutation({
+            mutationFn: async ({ itemId, text, idempotencyKey, imageDataUrl, }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/shares/x`,
+                    method: 'POST',
+                    headers: { 'Idempotency-Key': idempotencyKey },
+                    body: { text, imageDataUrl },
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to post to X');
+                }
+                return resp.share;
+            },
+        });
+    };
+    const useUnpublishXShare = () => {
+        return useMutation({
+            mutationFn: async (idempotencyKey) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/shares/x/${encodeURIComponent(idempotencyKey)}`,
+                    method: 'DELETE',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to remove the X post');
+                }
+                return resp.share;
+            },
+        });
+    };
+    const useXShares = (itemId, enabled = true) => {
+        return useQuery({
+            queryKey: ['library', 'social-shares', 'x', itemId],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/shares/x`,
+                    method: 'GET',
+                    notifyOnError: false,
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to load X posts');
+                }
+                return Array.isArray(resp.shares) ? resp.shares : [];
+            },
+            ...DEFAULT_QUERY_OPTIONS,
+            enabled: Boolean(configuration.libraryUrl) && Boolean(itemId) && enabled,
+        });
+    };
+    /** Publish one selected public result through the durable Bluesky saga. */
+    const usePublishBlueskyShare = () => {
+        return useMutation({
+            mutationFn: async ({ itemId, finding, cellId, outputIndex, idempotencyKey, imageDataUrl, imageAltText, }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/shares/bluesky`,
+                    method: 'POST',
+                    headers: { 'Idempotency-Key': idempotencyKey },
+                    body: { finding, cellId, outputIndex, imageDataUrl, imageAltText },
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to publish to Bluesky');
+                }
+                return resp.share;
+            },
+        });
+    };
+    const useUnpublishBlueskyShare = () => {
+        return useMutation({
+            mutationFn: async (idempotencyKey) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/shares/bluesky/${encodeURIComponent(idempotencyKey)}`,
+                    method: 'DELETE',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to unpublish from Bluesky');
+                }
+                return resp.share;
+            },
+        });
+    };
+    const useBlueskyShares = (itemId, enabled = true) => {
+        return useQuery({
+            queryKey: ['library', 'social-shares', 'bluesky', itemId],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/shares/bluesky`,
+                    method: 'GET',
+                    notifyOnError: false,
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to load Bluesky publications');
+                }
+                return Array.isArray(resp.shares) ? resp.shares : [];
+            },
+            ...DEFAULT_QUERY_OPTIONS,
+            enabled: Boolean(configuration.libraryUrl) && Boolean(itemId) && enabled,
+        });
+    };
     /**
      * Tell the library that an artifact was reused: cloned into a space, or
      * instantiated as a runtime. The reuse itself belongs to the service that
@@ -6860,11 +7060,14 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
      */
     const useCountItemReuse = () => {
         return useMutation({
-            mutationFn: async ({ itemId, kind, }) => {
+            mutationFn: async ({ itemId, kind, signupSource, shareRef, }) => {
                 const resp = await requestDatalayer({
                     url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/reused`,
                     method: 'POST',
-                    body: { kind },
+                    body: {
+                        kind,
+                        ...(signupSource && shareRef ? { signupSource, shareRef } : {}),
+                    },
                 });
                 if (!resp.success) {
                     throw new Error(resp.message || 'Failed to count the reuse');
@@ -7062,215 +7265,113 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             },
         });
     };
-    /**
-     * Get LinkedIn profile via proxy
-     */
+    /** Get the server-connected LinkedIn profile. */
     const useGetLinkedinProfile = () => {
         return useMutation({
-            mutationFn: async (accessToken) => {
+            mutationFn: async () => {
                 return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                    method: 'POST',
-                    body: {
-                        request_method: 'GET',
-                        request_url: 'https://api.linkedin.com/v2/userinfo',
-                        request_token: accessToken,
-                    },
+                    url: `${configuration.iamUrl}/api/iam/v1/social/linkedin/profile`,
+                    method: 'GET',
                 });
             },
         });
     };
-    /**
-     * Post LinkedIn share
-     */
+    /** Publish a LinkedIn text post through the server-held connection. */
     const usePostLinkedinShare = () => {
         return useMutation({
-            mutationFn: async ({ linkedinUserUrn, postText, accessToken, }) => {
-                const postShareRequest = {
-                    author: linkedinUserUrn,
-                    lifecycleState: 'PUBLISHED',
-                    specificContent: {
-                        'com.linkedin.ugc.ShareContent': {
-                            shareCommentary: { text: postText },
-                            shareMediaCategory: 'NONE',
-                        },
-                    },
-                    visibility: {
-                        'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC',
-                    },
-                };
+            mutationFn: async ({ postText }) => {
                 return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
+                    url: `${configuration.iamUrl}/api/iam/v1/social/linkedin/posts`,
                     method: 'POST',
-                    body: {
-                        request_method: 'POST',
-                        request_url: 'https://api.linkedin.com/v2/ugcPosts',
-                        request_token: accessToken,
-                        request_body: postShareRequest,
-                    },
+                    body: { commentary: postText },
                 });
             },
         });
     };
-    /**
-     * Post LinkedIn share with image upload
-     */
+    /** Publish a LinkedIn post, optionally with one uploaded image. */
     const usePostLinkedinShareWithUpload = () => {
         return useMutation({
-            mutationFn: async ({ linkedinUserUrn, postText, uploadObject, accessToken, }) => {
-                let shareRequest;
-                if (uploadObject) {
-                    // Step 1: Register upload
-                    const registerUploadRequest = {
-                        registerUploadRequest: {
-                            recipes: ['urn:li:digitalmediaRecipe:feedshare-image'],
-                            owner: linkedinUserUrn,
-                            serviceRelationships: [
-                                {
-                                    relationshipType: 'OWNER',
-                                    identifier: 'urn:li:userGeneratedContent',
-                                },
-                            ],
-                        },
-                    };
-                    const registerResp = await requestDatalayer({
-                        url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                        method: 'POST',
-                        body: {
-                            request_method: 'POST',
-                            request_url: 'https://api.linkedin.com/v2/assets?action=registerUpload',
-                            request_token: accessToken,
-                            request_body: registerUploadRequest,
-                        },
-                    });
-                    const asset = registerResp.response.value.asset;
-                    const uploadUrl = registerResp.response.value.uploadMechanism['com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest'].uploadUrl;
-                    // Step 2: Upload image
-                    await requestDatalayer({
-                        url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                        method: 'POST',
-                        body: {
-                            request_method: 'PUT',
-                            request_url: uploadUrl,
-                            request_token: accessToken,
-                            request_body: {
-                                uploadURL: uploadUrl,
-                                content: uploadObject,
-                                userURN: linkedinUserUrn,
-                            },
-                        },
-                    });
-                    // Step 3: Create share with media
-                    shareRequest = {
-                        author: linkedinUserUrn,
-                        lifecycleState: 'PUBLISHED',
-                        specificContent: {
-                            'com.linkedin.ugc.ShareContent': {
-                                shareCommentary: { text: postText },
-                                shareMediaCategory: 'IMAGE',
-                                media: [
-                                    {
-                                        status: 'READY',
-                                        description: { text: 'Datalayer Notebook' },
-                                        media: asset,
-                                        title: { text: 'Datalayer Notebook' },
-                                    },
-                                ],
-                            },
-                        },
-                        visibility: {
-                            'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC',
-                        },
-                    };
-                }
-                else {
-                    // Text-only share (no image upload)
-                    shareRequest = {
-                        author: linkedinUserUrn,
-                        lifecycleState: 'PUBLISHED',
-                        specificContent: {
-                            'com.linkedin.ugc.ShareContent': {
-                                shareCommentary: { text: postText },
-                                shareMediaCategory: 'NONE',
-                            },
-                        },
-                        visibility: {
-                            'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC',
-                        },
-                    };
-                }
-                return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                    method: 'POST',
-                    body: {
-                        request_method: 'POST',
-                        request_url: 'https://api.linkedin.com/v2/ugcPosts',
-                        request_token: accessToken,
-                        request_body: shareRequest,
-                    },
-                });
-            },
-        });
-    };
-    // ============================================================================
-    // Proxy Operations
-    // ============================================================================
-    /**
-     * Proxy GET request
-     */
-    const useProxyGET = () => {
-        return useMutation({
-            mutationFn: async ({ url, token }) => {
+            mutationFn: async ({ postText, uploadObject, }) => {
                 return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
+                    url: `${configuration.iamUrl}/api/iam/v1/social/linkedin/posts`,
                     method: 'POST',
                     body: {
-                        request_method: 'GET',
-                        request_url: url,
-                        request_token: token,
-                    },
-                });
-            },
-        });
-    };
-    /**
-     * Proxy POST request
-     */
-    const useProxyPOST = () => {
-        return useMutation({
-            mutationFn: async ({ url, body, token, }) => {
-                return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                    method: 'POST',
-                    body: {
-                        request_method: 'POST',
-                        request_url: url,
-                        request_token: token,
-                        request_body: body,
+                        commentary: postText,
+                        image_data_url: uploadObject,
                     },
                 });
             },
         });
     };
+    /** Connect-only AT Protocol account operations. */
+    const useGetBlueskyConnection = () => useMutation({
+        mutationFn: async () => requestDatalayer({
+            url: `${configuration.iamUrl}/api/iam/v1/social/bluesky/profile`,
+            method: 'GET',
+            notifyOnError: false,
+        }),
+    });
     /**
-     * Proxy PUT request
-     */
-    const useProxyPUT = () => {
-        return useMutation({
-            mutationFn: async ({ url, body, token, }) => {
-                return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                    method: 'POST',
-                    body: {
-                        request_method: 'PUT',
-                        request_url: url,
-                        request_token: token,
-                        request_body: body,
-                    },
-                });
-            },
-        });
-    };
+     * Begin a Bluesky connection.
+     *
+     * `returnOrigin` is where the reader should come back to — their own origin,
+     * so a connection begun on a developer's machine does not end on
+     * production. IAM takes the origin only and builds the address itself, so
+     * this cannot ask to be sent anywhere.
+     */
+    const useConnectBluesky = () => useMutation({
+        mutationFn: async (asked) => {
+            const { identifier, returnOrigin } = typeof asked === 'string'
+                ? { identifier: asked, returnOrigin: undefined }
+                : asked;
+            return requestDatalayer({
+                url: `${configuration.iamUrl}/api/iam/v1/social/bluesky/connect`,
+                method: 'POST',
+                body: returnOrigin
+                    ? { identifier, return_origin: returnOrigin }
+                    : { identifier },
+            });
+        },
+    });
+    const useDisconnectBluesky = () => useMutation({
+        mutationFn: async () => requestDatalayer({
+            url: `${configuration.iamUrl}/api/iam/v1/social/bluesky/connection`,
+            method: 'DELETE',
+        }),
+    });
+    /**
+     * The X connection, as IAM reports it: whether X is configured on this
+     * deployment, whether the caller connected it, and the account (no token).
+     */
+    const useXConnection = (enabled = true) => useQuery({
+        queryKey: ['iam', 'social', 'x', 'status'],
+        queryFn: async () => requestDatalayer({
+            url: `${configuration.iamUrl}/api/iam/v1/social/x/status`,
+            method: 'GET',
+            notifyOnError: false,
+        }),
+        ...DEFAULT_QUERY_OPTIONS,
+        enabled: Boolean(configuration.iamUrl) && enabled,
+    });
+    /**
+     * Begin connecting X. Answers the start link to open at top level;
+     * `returnOrigin` is where to come back to (an origin only: IAM builds the
+     * path, so this cannot ask to be sent anywhere).
+     */
+    const useConnectX = () => useMutation({
+        mutationFn: async (returnOrigin) => requestDatalayer({
+            url: `${configuration.iamUrl}/api/iam/v1/social/x/connect`,
+            method: 'POST',
+            body: returnOrigin ? { return_origin: returnOrigin } : {},
+        }),
+    });
+    const useDisconnectX = () => useMutation({
+        mutationFn: async () => requestDatalayer({
+            url: `${configuration.iamUrl}/api/iam/v1/social/x/connection`,
+            method: 'DELETE',
+        }),
+        onSuccess: () => queryClient.invalidateQueries({ queryKey: ['iam', 'social', 'x'] }),
+    });
     // ============================================================================
     // Waiting List & Growth
     // ============================================================================
@@ -8319,11 +8420,22 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         useGetLinkedinProfile,
         usePostLinkedinShare,
         usePostLinkedinShareWithUpload,
+        useGetBlueskyConnection,
+        useConnectBluesky,
+        useDisconnectBluesky,
+        useXConnection,
+        useConnectX,
+        useDisconnectX,
+        usePublishXShare,
+        useUnpublishXShare,
+        useXShares,
+        usePublishLinkedInShare,
+        useUnpublishLinkedInShare,
+        useLinkedInShares,
+        usePublishBlueskyShare,
+        useUnpublishBlueskyShare,
+        useBlueskyShares,
         useRegisterToWaitingList,
-        // Proxy
-        useProxyGET,
-        useProxyPOST,
-        useProxyPUT,
         // Users
         useUser,
         useUserByHandle,

package/lib/hooks/useContents.js

@@ -156,6 +156,9 @@ export const useContentSources = (filters = {}) => {
         queryFn: () => listSources(token ?? '', filters, contentsUrl),
         enabled: Boolean(token && contentsUrl),
         staleTime: 30_000,
+        // Coming back to a list is when somebody looks for what they just made:
+        // it is read again, whatever made it.
+        refetchOnMount: 'always',
         refetchOnWindowFocus: true,
     });
 };

package/lib/hooks/useMcp.js

@@ -34,7 +34,7 @@ import { deleteMcpPolicy, getAdmittedClients, getMcpPolicy, setMcpPolicy, } from
 import { createServiceAgent, listServiceAgents, revokeServiceAgent, rotateServiceAgentKey, } from '../api/iam/serviceAgents.js';
 import { useCoreStore, useIAMStore } from '../state/index.js';
 import { queryKeys } from './useCache.js';
-const useMcpServerUrl = () => useCoreStore(state => state.configuration.jupyterMcpServerUrl);
+const useMcpServerUrl = () => useCoreStore(state => state.configuration.datalayerMcpServerUrl);
 const useIamUrl = () => useCoreStore(state => state.configuration.iamUrl);
 const useOtelUrl = () => useCoreStore(state => state.configuration.otelUrl);
 // -- Tasks -----------------------------------------------------------------