@datalayer/agent-runtimes 1.0.4 → 1.0.6

package/lib/hooks/{useAgents.d.ts → useAgentRuntimes.d.ts}

@@ -4,6 +4,7 @@ import type { AgentConnection } from '../types/connection';
 import type { AgentStatus, AgentRuntimeData } from '../types/agents';
 import type { CreateAgentRuntimeRequest, AgentLifecycleState, CreateRuntimeApiResponse } from '../types/agents-lifecycle';
 import { ServiceManager } from '@jupyterlab/services/lib/manager';
+export type RuntimeCreationTarget = 'backend-services' | 'local-agent-runtimes';
 /**
  * Options for the useAgents hook.
  */
@@ -18,6 +19,14 @@ export interface UseAgentOptions {
     autoStart?: boolean;
     /** Full agent spec object (persisted with checkpoints) */
     agentSpec?: Record<string, any>;
+    /**
+     * Where runtime create/list operations should be sent.
+     * - `backend-services`: use backend runtimes service URL
+     * - `local-agent-runtimes`: use local agent-runtimes URL
+     */
+    runtimeCreationTarget?: RuntimeCreationTarget;
+    /** Explicit base URL for runtime create/list operations. */
+    runtimeCreationBaseUrl?: string;
 }
 /**
  * Return type for the useAgents hook.
@@ -53,6 +62,10 @@ export interface UseAgentReturn {
     isReady: boolean;
     /** Error if any */
     error: string | null;
+    /** Effective runtime creation target mode. */
+    runtimeCreationTarget: RuntimeCreationTarget;
+    /** Effective base URL used for runtime create/list operations. */
+    runtimeCreationBaseUrl: string;
 }
 /** Default query options for all agent runtime queries. */
 export declare const AGENT_QUERY_OPTIONS: {
@@ -87,7 +100,7 @@ export declare const agentQueryKeys: {
  * // Connect mode — attach to an existing runtime
  * const { isReady, endpoint, connectToRuntime } = useAgents({
  *   autoCreateAgent: true,
- *   agentConfig: { model: 'bedrock:us.anthropic.claude-3-5-haiku-20241022-v1:0' },
+ *   agentConfig: { model: 'bedrock:us.anthropic.claude-sonnet-4-5-20250929-v1:0' },
  * });
  *
  * // Lifecycle mode — full lifecycle with agentSpecId
@@ -98,14 +111,22 @@ export declare const agentQueryKeys: {
  * });
  * ```
  */
-export declare function useAgents(options?: UseAgentOptions): UseAgentReturn;
+export declare function useAgentRuntimes(options?: UseAgentOptions): UseAgentReturn;
 /**
  * Hook to fetch user's agent runtimes (running agent instances).
  *
  * The backend returns active runtimes from the operator **plus** paused
  * runtimes synthesised from Solr checkpoint records (with ``status="paused"``).
  */
-export declare function useAgentRuntimes(): import("@tanstack/react-query").UseQueryResult<AgentRuntimeData[], Error>;
+export declare function useAgentRuntimesQuery(scope?: {
+    selectedUserUid?: string;
+    selectedOrganizationUid?: string;
+    selectedTeamUid?: string;
+    selectedAgentUid?: string;
+}, queryOptions?: {
+    enabled?: boolean;
+    refetchInterval?: number | false;
+}): import("@tanstack/react-query").UseQueryResult<AgentRuntimeData[], Error>;
 /**
  * Hook to fetch a single agent runtime by pod name.
  */
@@ -149,4 +170,49 @@ export interface UseAgentsRuntimesReturn {
 /**
  * Consolidated runtime list and mutations.
  */
-export declare function useAgentsRuntimes(): UseAgentsRuntimesReturn;
+export declare function useAgentsRuntimes(scope?: {
+    selectedUserUid?: string;
+    selectedOrganizationUid?: string;
+    selectedTeamUid?: string;
+    selectedAgentUid?: string;
+}, queryOptions?: {
+    enabled?: boolean;
+    refetchInterval?: number | false;
+}): UseAgentsRuntimesReturn;
+export interface UseAgentRuntimeWebSocketOptions {
+    /** Enable/disable the connection. Defaults to `true`. */
+    enabled?: boolean;
+    /**
+     * Base URL of the agent-runtime server
+     * (e.g. `http://localhost:8765`). The WS path is appended automatically.
+     */
+    baseUrl: string;
+    /** Auth token passed as `?token=` query parameter. */
+    authToken?: string;
+    /** Optional `agent_id` query parameter to scope the stream. */
+    agentId?: string;
+    /** Auto-reconnect on unexpected disconnects. Defaults to `true`. */
+    autoReconnect?: boolean;
+    /** Delay between reconnection attempts (ms). Defaults to 3 000. */
+    reconnectDelayMs?: number | ((attempt: number) => number);
+    /** Maximum reconnect attempts. Unbounded by default. */
+    maxReconnectAttempts?: number;
+    /** Additional callback fired for every incoming WS message. */
+    onMessage?: (msg: {
+        type?: string;
+        payload?: unknown;
+        raw: unknown;
+    }) => void;
+}
+/**
+ * Connect to the agent-runtime monitoring WebSocket.
+ *
+ * The hook writes all incoming data into the `useAgentRuntimeStore` Zustand
+ * store. Components that need approvals, MCP status, context snapshots, or
+ * full-context data simply read from the store.
+ *
+ * Mount this hook **once** near the top of your component tree (e.g. in
+ * the example root or in `ChatBase`). All other components read from the
+ * store — no extra WebSocket connections needed.
+ */
+export declare function useAgentRuntimeWebSocket(options: UseAgentRuntimeWebSocketOptions): void;

package/lib/hooks/{useAgents.js → useAgentRuntimes.js}

@@ -3,13 +3,13 @@
  * Distributed under the terms of the Modified BSD License.
  */
 /**
- * Unified hook for managing agents.
+ * Unified hook for managing agent runtimes.
  *
  * Combines agent lifecycle management (ephemeral/durable),
  * runtime catalog (React Query CRUD), lifecycle/catalog stores,
- * and the AI Agents REST API.
+ * the AI Agents REST API, and the agent-runtime WebSocket stream.
  *
- * @module hooks/useAgents
+ * @module hooks/useAgentRuntimes
  */
 import { useState, useCallback, useMemo, useEffect, useRef } from 'react';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
@@ -17,7 +17,8 @@ import { create } from 'zustand';
 import { persist, createJSONStorage } from 'zustand/middleware';
 import { useCoreStore, useDatalayer } from '@datalayer/core';
 import { useIAMStore } from '@datalayer/core/lib/state';
-import { useAgentStore, useAgentRuntime, useAgentStatus, useAgentError, useIsLaunching, } from '../stores/agentsStore';
+import { agentRuntimeStore, useAgentRuntimeStore, useAgentRuntimeConnection, useAgentRuntimeStatus, useAgentRuntimeError, useAgentRuntimeIsLaunching, } from '../stores/agentRuntimeStore';
+import { parseAgentStreamMessage, } from '../types/stream';
 import { DEFAULT_AGENT_CONFIG } from '../types/config';
 // ═══════════════════════════════════════════════════════════════════════════
 // Constants
@@ -64,6 +65,14 @@ const RUNTIME_STATUS_MAP = {
 function toAgentRuntimeData(raw) {
     const status = typeof raw.status === 'string' ? raw.status.toLowerCase() : '';
     const normalizedStatus = RUNTIME_STATUS_MAP[status] ?? 'running';
+    const rawVolumeUids = Array.isArray(raw.volume_uids)
+        ? raw.volume_uids
+        : raw.volume_uid
+            ? [raw.volume_uid]
+            : [];
+    const volume_uids = rawVolumeUids
+        .map((uid) => String(uid || '').trim())
+        .filter(Boolean);
     return {
         ...raw,
         status: normalizedStatus,
@@ -72,6 +81,8 @@ function toAgentRuntimeData(raw) {
         url: raw.ingress,
         messageCount: 0,
         agent_spec_id: raw.agent_spec_id || undefined,
+        volume_uids,
+        volume_uid: raw.volume_uid || volume_uids[0] || undefined,
     };
 }
 // ═══════════════════════════════════════════════════════════════════════════
@@ -92,7 +103,7 @@ function toAgentRuntimeData(raw) {
  * // Connect mode — attach to an existing runtime
  * const { isReady, endpoint, connectToRuntime } = useAgents({
  *   autoCreateAgent: true,
- *   agentConfig: { model: 'bedrock:us.anthropic.claude-3-5-haiku-20241022-v1:0' },
+ *   agentConfig: { model: 'bedrock:us.anthropic.claude-sonnet-4-5-20250929-v1:0' },
  * });
  *
  * // Lifecycle mode — full lifecycle with agentSpecId
@@ -103,18 +114,19 @@ function toAgentRuntimeData(raw) {
  * });
  * ```
  */
-export function useAgents(options = {}) {
-    const { agentSpecId, agentConfig, autoCreateAgent = true, autoStart = false, agentSpec, } = options;
+export function useAgentRuntimes(options = {}) {
+    const { agentSpecId, agentConfig, autoCreateAgent = true, autoStart = false, agentSpec, runtimeCreationTarget = 'backend-services', runtimeCreationBaseUrl, } = options;
+    const { configuration } = useCoreStore();
     // Base store state
-    const runtime = useAgentRuntime();
-    const baseStatus = useAgentStatus();
-    const storeError = useAgentError();
-    const isLaunching = useIsLaunching();
+    const runtime = useAgentRuntimeConnection();
+    const baseStatus = useAgentRuntimeStatus();
+    const storeError = useAgentRuntimeError();
+    const isLaunching = useAgentRuntimeIsLaunching();
     // Store actions
-    const storeLaunchAgent = useAgentStore(state => state.launchAgent);
-    const storeConnectAgent = useAgentStore(state => state.connectAgent);
-    const storeCreateAgent = useAgentStore(state => state.createAgent);
-    const storeDisconnect = useAgentStore(state => state.disconnect);
+    const storeLaunchAgent = useAgentRuntimeStore(state => state.launchAgent);
+    const storeConnectAgent = useAgentRuntimeStore(state => state.connectAgent);
+    const storeCreateAgent = useAgentRuntimeStore(state => state.createAgent);
+    const storeDisconnect = useAgentRuntimeStore(state => state.disconnect);
     // Lifecycle local state
     const [lifecycleStatus, setLifecycleStatus] = useState('idle');
     const [lifecycleError, setLifecycleError] = useState(null);
@@ -127,6 +139,23 @@ export function useAgents(options = {}) {
     agentConfigRef.current = agentConfig;
     // Whether we're managing a full agent lifecycle (agentSpecId provided)
     const hasSpec = !!agentSpecId;
+    const resolvedRuntimeCreationBaseUrl = useMemo(() => {
+        if (runtimeCreationBaseUrl) {
+            return runtimeCreationBaseUrl;
+        }
+        if (runtimeCreationTarget === 'local-agent-runtimes') {
+            return (import.meta.env.VITE_DATALAYER_AGENT_RUNTIMES_URL ||
+                import.meta.env.VITE_BASE_URL ||
+                'http://localhost:8765');
+        }
+        return (configuration?.runtimesRunUrl ||
+            import.meta.env.VITE_DATALAYER_AGENT_RUNTIMES_URL ||
+            'https://r1.datalayer.run');
+    }, [
+        configuration?.runtimesRunUrl,
+        runtimeCreationBaseUrl,
+        runtimeCreationTarget,
+    ]);
     // ─── Auth helpers ─────────────────────────────────────────────────
     const getAuthHeaders = useCallback(async () => {
         try {
@@ -134,30 +163,39 @@ export function useAgents(options = {}) {
             const token = iamStore.getState().token || '';
             const config = coreStore.getState().configuration;
             const runUrl = config?.aiagentsRunUrl || '';
-            const runtimesRunUrl = config?.runtimesRunUrl || '';
+            const runtimesRunUrl = resolvedRuntimeCreationBaseUrl;
             return { token, runUrl, runtimesRunUrl };
         }
         catch {
             return { token: '', runUrl: '', runtimesRunUrl: '' };
         }
-    }, []);
+    }, [resolvedRuntimeCreationBaseUrl]);
     // ─── Launch Runtime ─────────────────────────────────────────────────
     const launchRuntime = useCallback(async (runtimeOptions) => {
         if (hasSpec) {
             setLifecycleStatus('launching');
             setLifecycleError(null);
             try {
-                const safeName = `${agentSpecId}`
+                const preferredRuntimeName = (typeof agentConfig?.name === 'string' && agentConfig.name) ||
+                    (typeof agentSpec?.name === 'string' && agentSpec.name) ||
+                    `${agentSpecId}`;
+                const safeName = preferredRuntimeName
                     .replace(/\//g, '-')
                     .replace(/[^a-z0-9-]/g, '-')
                     .replace(/-+/g, '-')
                     .replace(/^-|-$/g, '')
                     .slice(0, 63);
-                const conn = await storeLaunchAgent(runtimeOptions || {
-                    environmentName: 'ai-agents-env',
-                    creditsLimit: 10,
-                    givenName: safeName,
-                });
+                const conn = await storeLaunchAgent(runtimeOptions
+                    ? {
+                        ...runtimeOptions,
+                        runtimesRunUrl: resolvedRuntimeCreationBaseUrl,
+                    }
+                    : {
+                        environmentName: 'ai-agents-env',
+                        creditsLimit: 10,
+                        givenName: safeName,
+                        runtimesRunUrl: resolvedRuntimeCreationBaseUrl,
+                    });
                 setLifecycleStatus('ready');
                 return conn;
             }
@@ -172,9 +210,19 @@ export function useAgents(options = {}) {
             if (!runtimeOptions) {
                 throw new Error('Runtime options are required in connect mode');
             }
-            return storeLaunchAgent(runtimeOptions);
+            return storeLaunchAgent({
+                ...runtimeOptions,
+                runtimesRunUrl: resolvedRuntimeCreationBaseUrl,
+            });
         }
-    }, [agentSpecId, hasSpec, storeLaunchAgent]);
+    }, [
+        agentConfig?.name,
+        agentSpec?.name,
+        agentSpecId,
+        hasSpec,
+        resolvedRuntimeCreationBaseUrl,
+        storeLaunchAgent,
+    ]);
     // ─── Create Agent ───────────────────────────────────────────────────
     const createAgent = useCallback(async (config) => {
         if (creatingRef.current) {
@@ -397,6 +445,8 @@ export function useAgents(options = {}) {
         // Status
         isReady,
         error,
+        runtimeCreationTarget,
+        runtimeCreationBaseUrl: resolvedRuntimeCreationBaseUrl,
     };
 }
 // ═══════════════════════════════════════════════════════════════════════════
@@ -408,16 +458,36 @@ export function useAgents(options = {}) {
  * The backend returns active runtimes from the operator **plus** paused
  * runtimes synthesised from Solr checkpoint records (with ``status="paused"``).
  */
-export function useAgentRuntimes() {
+export function useAgentRuntimesQuery(scope, queryOptions) {
     const { configuration } = useCoreStore();
     const { requestDatalayer } = useDatalayer({ notifyOnError: false });
     const { user } = useIAMStore();
     const queryClient = useQueryClient();
     return useQuery({
-        queryKey: agentQueryKeys.agentRuntimes.lists(),
+        queryKey: [
+            ...agentQueryKeys.agentRuntimes.lists(),
+            scope?.selectedUserUid || '',
+            scope?.selectedOrganizationUid || '',
+            scope?.selectedTeamUid || '',
+            scope?.selectedAgentUid || '',
+        ],
         queryFn: async () => {
+            const params = new URLSearchParams();
+            if (scope?.selectedUserUid) {
+                params.set('selected_user_uid', scope.selectedUserUid);
+            }
+            if (scope?.selectedOrganizationUid) {
+                params.set('selected_organization_uid', scope.selectedOrganizationUid);
+            }
+            if (scope?.selectedTeamUid) {
+                params.set('selected_team_uid', scope.selectedTeamUid);
+            }
+            if (scope?.selectedAgentUid) {
+                params.set('selected_agent_uid', scope.selectedAgentUid);
+            }
+            const query = params.toString();
             const resp = await requestDatalayer({
-                url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes`,
+                url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes${query ? `?${query}` : ''}`,
                 method: 'GET',
             });
             if (resp.success && resp.runtimes) {
@@ -432,8 +502,10 @@ export function useAgentRuntimes() {
             return [];
         },
         ...AGENT_QUERY_OPTIONS,
-        refetchInterval: 10000,
-        enabled: !!user,
+        refetchInterval: queryOptions?.refetchInterval ?? 10000,
+        refetchOnMount: true,
+        refetchOnWindowFocus: true,
+        enabled: (queryOptions?.enabled ?? true) && !!user,
     });
 }
 /**
@@ -473,6 +545,11 @@ export function useCreateAgentRuntime() {
     const queryClient = useQueryClient();
     return useMutation({
         mutationFn: async (data) => {
+            const normalizedVolumeUids = Array.isArray(data.volumeUids)
+                ? data.volumeUids.map(uid => String(uid || '').trim()).filter(Boolean)
+                : data.volumeUid
+                    ? [String(data.volumeUid).trim()]
+                    : [];
             return requestDatalayer({
                 url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes`,
                 method: 'POST',
@@ -485,6 +562,15 @@ export function useCreateAgentRuntime() {
                     enable_codemode: data.enableCodemode ?? false,
                     agent_spec_id: data.agentSpecId || undefined,
                     agent_spec: data.agentSpec || undefined,
+                    user_account_handle: data.userAccountHandle || undefined,
+                    billable_account_uid: data.billableAccountUid || undefined,
+                    billable_account_type: data.billableAccountType || undefined,
+                    billable_account_handle: data.billableAccountHandle || undefined,
+                    billable_source_organization_uid: data.billableSourceOrganizationUid || undefined,
+                    billable_source_organization_handle: data.billableSourceOrganizationHandle || undefined,
+                    mount_home_folder: data.mountHomeFolder ?? false,
+                    volume_uids: normalizedVolumeUids.length > 0 ? normalizedVolumeUids : undefined,
+                    volume_uid: normalizedVolumeUids[0] || data.volumeUid || undefined,
                 },
             });
         },
@@ -514,6 +600,12 @@ export function useDeleteAgentRuntime() {
             });
         },
         onSuccess: (_data, podName) => {
+            queryClient.setQueriesData({ queryKey: agentQueryKeys.agentRuntimes.lists() }, (current) => {
+                if (!Array.isArray(current)) {
+                    return current;
+                }
+                return current.filter(runtime => runtime.pod_name !== podName);
+            });
             queryClient.cancelQueries({
                 queryKey: agentQueryKeys.agentRuntimes.detail(podName),
             });
@@ -523,6 +615,10 @@ export function useDeleteAgentRuntime() {
             queryClient.invalidateQueries({
                 queryKey: agentQueryKeys.agentRuntimes.lists(),
             });
+            queryClient.refetchQueries({
+                queryKey: agentQueryKeys.agentRuntimes.lists(),
+                type: 'active',
+            });
         },
     });
 }
@@ -606,8 +702,8 @@ export const useAgentLifecycleStore = create()(persist((set, get) => ({
 /**
  * Consolidated runtime list and mutations.
  */
-export function useAgentsRuntimes() {
-    const runtimesQuery = useAgentRuntimes();
+export function useAgentsRuntimes(scope, queryOptions) {
+    const runtimesQuery = useAgentRuntimesQuery(scope, queryOptions);
     const createRuntimeMutation = useCreateAgentRuntime();
     const deleteRuntimeMutation = useDeleteAgentRuntime();
     const refreshRuntimes = useRefreshAgentRuntimes();
@@ -631,3 +727,112 @@ export function useAgentsRuntimes() {
         deleteRuntimeMutation,
     ]);
 }
+const DEFAULT_WS_PATH = '/api/v1/tool-approvals/ws';
+const DEFAULT_RECONNECT_DELAY_MS = 3_000;
+/**
+ * Connect to the agent-runtime monitoring WebSocket.
+ *
+ * The hook writes all incoming data into the `useAgentRuntimeStore` Zustand
+ * store. Components that need approvals, MCP status, context snapshots, or
+ * full-context data simply read from the store.
+ *
+ * Mount this hook **once** near the top of your component tree (e.g. in
+ * the example root or in `ChatBase`). All other components read from the
+ * store — no extra WebSocket connections needed.
+ */
+export function useAgentRuntimeWebSocket(options) {
+    const { enabled = true, baseUrl, authToken, agentId, autoReconnect = true, reconnectDelayMs = DEFAULT_RECONNECT_DELAY_MS, maxReconnectAttempts, } = options;
+    const onMessageRef = useRef(options.onMessage);
+    onMessageRef.current = options.onMessage;
+    useEffect(() => {
+        if (!enabled || !baseUrl) {
+            agentRuntimeStore.getState().setWsState('closed');
+            return;
+        }
+        let disposed = false;
+        let reconnectAttempts = 0;
+        let reconnectTimer = null;
+        function buildWsUrl() {
+            const httpUrl = `${baseUrl}${DEFAULT_WS_PATH}`;
+            const url = new URL(httpUrl.replace(/^http/, 'ws'));
+            if (authToken) {
+                url.searchParams.set('token', authToken);
+            }
+            if (agentId) {
+                url.searchParams.set('agent_id', agentId);
+            }
+            return url.toString();
+        }
+        function connect() {
+            if (disposed)
+                return;
+            const wsUrl = buildWsUrl();
+            agentRuntimeStore.getState().setWsState('connecting');
+            const ws = new WebSocket(wsUrl);
+            agentRuntimeStore.getState().setWs(ws, agentId);
+            ws.onopen = () => {
+                reconnectAttempts = 0;
+                agentRuntimeStore.getState().setWsState('connected');
+            };
+            ws.onmessage = (ev) => {
+                let raw;
+                try {
+                    raw = JSON.parse(String(ev.data));
+                }
+                catch {
+                    return;
+                }
+                const parsed = parseAgentStreamMessage(raw);
+                onMessageRef.current?.({
+                    type: parsed?.type,
+                    payload: parsed?.payload,
+                    raw,
+                });
+                if (!parsed)
+                    return;
+                const state = agentRuntimeStore.getState();
+                if (parsed.type === 'agent.snapshot') {
+                    state.applySnapshot(parsed.payload);
+                    return;
+                }
+            };
+            ws.onclose = () => {
+                agentRuntimeStore.getState().setWs(null, agentId);
+                agentRuntimeStore.getState().setWsState('closed');
+                if (disposed || !autoReconnect)
+                    return;
+                reconnectAttempts += 1;
+                if (typeof maxReconnectAttempts === 'number' &&
+                    reconnectAttempts > maxReconnectAttempts) {
+                    return;
+                }
+                const delay = typeof reconnectDelayMs === 'function'
+                    ? reconnectDelayMs(reconnectAttempts)
+                    : reconnectDelayMs;
+                reconnectTimer = setTimeout(connect, Math.max(0, delay));
+            };
+            ws.onerror = () => {
+                if (ws.readyState === WebSocket.CONNECTING ||
+                    ws.readyState === WebSocket.OPEN) {
+                    ws.close();
+                }
+            };
+        }
+        connect();
+        return () => {
+            disposed = true;
+            if (reconnectTimer)
+                clearTimeout(reconnectTimer);
+            agentRuntimeStore.getState().setWs(null, agentId);
+            agentRuntimeStore.getState().resetWs();
+        };
+    }, [
+        enabled,
+        baseUrl,
+        authToken,
+        agentId,
+        autoReconnect,
+        reconnectDelayMs,
+        maxReconnectAttempts,
+    ]);
+}

package/lib/hooks/useAgentsCatalog.js

@@ -3,7 +3,7 @@
  * Distributed under the terms of the Modified BSD License.
  */
 /**
- * Agent catalog hooks.
+ * Agents catalog hooks.
  *
  * Includes the Zustand catalog store and the agent registry hook.
  *

package/lib/hooks/useAgentsService.d.ts

@@ -4,7 +4,7 @@ export type RequestOptions = {
 };
 export type RoomType = 'notebook_persist' | 'notebook_memory' | 'doc_memory';
 /**
- * @deprecated Use useAgents instead
+ * @deprecated Use useAgentRuntimes instead
  */
 export declare const useAgentsService: (baseUrlOverride?: string) => {
     createAgent: (documentId: string, documentType: RoomType, ingress?: string, token?: string, kernelId?: string, { signal, baseUrl }?: RequestOptions) => Promise<any>;
@@ -17,6 +17,6 @@ export declare const useAgentsService: (baseUrlOverride?: string) => {
  * Get the notebook AI agent if any.
  *
  * This performs a periodic liveness check and keeps the local store in sync.
- * @deprecated Use useAgents instead
+ * @deprecated Use useAgentRuntimes instead
  */
 export declare function useNotebookAgents(notebookId: string): import("..").AgentRegistryEntry | undefined;

package/lib/hooks/useAgentsService.js

@@ -11,12 +11,12 @@
 import { useEffect } from 'react';
 import { useCoreStore, useDatalayer } from '@datalayer/core';
 import { URLExt } from '@jupyterlab/coreutils';
-import { useAgentStore } from '../stores/agentsStore';
+import { useAgentRuntimeStore } from '../stores/agentRuntimeStore';
 // ═══════════════════════════════════════════════════════════════════════════
 // Agents Service REST API hook.
 // ═══════════════════════════════════════════════════════════════════════════
 /**
- * @deprecated Use useAgents instead
+ * @deprecated Use useAgentRuntimes instead
  */
 export const useAgentsService = (baseUrlOverride = 'api/ai-agents/v1') => {
     const { configuration } = useCoreStore();
@@ -86,14 +86,14 @@ export const useAgentsService = (baseUrlOverride = 'api/ai-agents/v1') => {
  * Get the notebook AI agent if any.
  *
  * This performs a periodic liveness check and keeps the local store in sync.
- * @deprecated Use useAgents instead
+ * @deprecated Use useAgentRuntimes instead
  */
 export function useNotebookAgents(notebookId) {
     const { getAgent } = useAgentsService();
-    const agents = useAgentStore(state => state.agents);
-    const upsertAgent = useAgentStore(state => state.upsertAgent);
-    const deleteAgent = useAgentStore(state => state.deleteAgent);
-    const getAgentById = useAgentStore(state => state.getAgentById);
+    const agents = useAgentRuntimeStore(state => state.agents);
+    const upsertAgent = useAgentRuntimeStore(state => state.upsertAgent);
+    const deleteAgent = useAgentRuntimeStore(state => state.deleteAgent);
+    const getAgentById = useAgentRuntimeStore(state => state.getAgentById);
     useEffect(() => {
         let abortController;
         const refreshAIAgent = async () => {

package/lib/hooks/useCheckpoints.js

@@ -14,7 +14,7 @@ import { useMemo, useState, useCallback } from 'react';
 import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
 import { useIAMStore } from '@datalayer/core/lib/state';
 import { useCoreStore, useDatalayer } from '@datalayer/core';
-import { agentQueryKeys, AGENT_QUERY_OPTIONS } from './useAgents';
+import { agentQueryKeys, AGENT_QUERY_OPTIONS } from './useAgentRuntimes';
 // ═══════════════════════════════════════════════════════════════════════════
 // Query hooks
 // ═══════════════════════════════════════════════════════════════════════════

package/lib/hooks/useConfig.d.ts

@@ -3,9 +3,12 @@ import type { RemoteConfig } from '../types/config';
  * Hook to safely use query when QueryClient is available.
  * Returns a mock result if no QueryClientProvider is present.
  */
-export declare function useConfig(enabled: boolean, configEndpoint?: string, authToken?: string): import("@tanstack/query-core").QueryObserverRefetchErrorResult<RemoteConfig, Error> | import("@tanstack/query-core").QueryObserverSuccessResult<RemoteConfig, Error> | import("@tanstack/query-core").QueryObserverLoadingErrorResult<RemoteConfig, Error> | import("@tanstack/query-core").QueryObserverPendingResult<RemoteConfig, Error> | import("@tanstack/query-core").QueryObserverPlaceholderResult<RemoteConfig, Error> | {
+export declare function useConfig(enabled: boolean, configEndpoint?: string, authToken?: string, agentId?: string): import("@tanstack/query-core").QueryObserverRefetchErrorResult<RemoteConfig, Error> | import("@tanstack/query-core").QueryObserverSuccessResult<RemoteConfig, Error> | import("@tanstack/query-core").QueryObserverLoadingErrorResult<RemoteConfig, Error> | import("@tanstack/query-core").QueryObserverPendingResult<RemoteConfig, Error> | import("@tanstack/query-core").QueryObserverPlaceholderResult<RemoteConfig, Error> | {
     data: undefined;
     isLoading: boolean;
     isError: boolean;
     error: null;
+    refetch: () => Promise<{
+        data: undefined;
+    }>;
 };

package/lib/hooks/useConfig.js

@@ -9,7 +9,7 @@ import { requestAPI } from '../api/handler';
  * Hook to safely use query when QueryClient is available.
  * Returns a mock result if no QueryClientProvider is present.
  */
-export function useConfig(enabled, configEndpoint, authToken) {
+export function useConfig(enabled, configEndpoint, authToken, agentId) {
     const queryClient = useContext(QueryClientContext);
     if (!queryClient) {
         return {
@@ -17,6 +17,7 @@ export function useConfig(enabled, configEndpoint, authToken) {
             isLoading: false,
             isError: false,
             error: null,
+            refetch: () => Promise.resolve({ data: undefined }),
         };
     }
     // eslint-disable-next-line react-hooks/rules-of-hooks
@@ -30,7 +31,13 @@ export function useConfig(enabled, configEndpoint, authToken) {
                 if (authToken) {
                     headers['Authorization'] = `Bearer ${authToken}`;
                 }
-                const response = await fetch(configEndpoint, { headers });
+                let endpoint = configEndpoint;
+                if (agentId) {
+                    const url = new URL(configEndpoint, window.location.origin);
+                    url.searchParams.set('agent_id', agentId);
+                    endpoint = url.toString();
+                }
+                const response = await fetch(endpoint, { headers });
                 if (!response.ok) {
                     throw new Error(`Config fetch failed: ${response.statusText}`);
                 }
@@ -39,7 +46,7 @@ export function useConfig(enabled, configEndpoint, authToken) {
             // Otherwise use Jupyter requestAPI.
             return requestAPI('configure');
         },
-        queryKey: ['models', configEndpoint || 'jupyter'],
+        queryKey: ['models', configEndpoint || 'jupyter', agentId || 'global'],
         enabled,
         retry: 1,
     });