@datalayer/agent-runtimes 1.0.28 → 1.3.10

package/lib/state/index.d.ts

@@ -1,4 +1,4 @@
 export * from './substates';
 export * from '@datalayer/core/lib/state/storage';
 export * from '@datalayer/core/lib/state/State';
-export { coreStore, useCoreStore, iamStore, useIAMStore, RESERVATION_WARNING_TIME_MS, layoutStore, useLayoutStore, organizationStore, useOrganizationStore, surveysStore, useSurveysStore, teamStore, useTeamStore, datasourceStore, useDatasourceStore, runStore, useRunStore, DATALAYER_IAM_TOKEN_KEY, DATALAYER_IAM_USER_KEY, } from '@datalayer/core/lib/state';
+export { coreStore, useCoreStore, iamStore, useIAMStore, RESERVATION_WARNING_TIME_MS, layoutStore, useLayoutStore, organizationStore, useOrganizationStore, surveysStore, useSurveysStore, teamStore, useTeamStore, runStore, useRunStore, DATALAYER_IAM_TOKEN_KEY, DATALAYER_IAM_USER_KEY, } from '@datalayer/core/lib/state';

package/lib/state/index.js

@@ -7,4 +7,4 @@ export * from './substates';
 // Re-export core state modules and stores that remain owned by core.
 export * from '@datalayer/core/lib/state/storage';
 export * from '@datalayer/core/lib/state/State';
-export { coreStore, useCoreStore, iamStore, useIAMStore, RESERVATION_WARNING_TIME_MS, layoutStore, useLayoutStore, organizationStore, useOrganizationStore, surveysStore, useSurveysStore, teamStore, useTeamStore, datasourceStore, useDatasourceStore, runStore, useRunStore, DATALAYER_IAM_TOKEN_KEY, DATALAYER_IAM_USER_KEY, } from '@datalayer/core/lib/state';
+export { coreStore, useCoreStore, iamStore, useIAMStore, RESERVATION_WARNING_TIME_MS, layoutStore, useLayoutStore, organizationStore, useOrganizationStore, surveysStore, useSurveysStore, teamStore, useTeamStore, runStore, useRunStore, DATALAYER_IAM_TOKEN_KEY, DATALAYER_IAM_USER_KEY, } from '@datalayer/core/lib/state';

package/lib/state/substates/RuntimesState.d.ts

@@ -1,6 +1,6 @@
 import type { IMultiServiceManager } from '../../runtimes';
 import type { IRuntimesConfiguration } from '@datalayer/core/lib/config';
-import type { IRuntimePod, ICodeSandboxSnapshot, IRuntimeModel } from '../../models';
+import type { IRuntimeRecord, ICodeSandboxSnapshot, IRuntimeModel } from '../../models';
 /**
  * Datalayer Runtimes state.
  */
@@ -20,19 +20,19 @@ export type RuntimesState = {
     /**
      * Runtime pods.
      */
-    runtimePods: IRuntimePod[];
+    runtimes: IRuntimeRecord[];
     /**
      * Refresh the runtime pods.
      */
-    refreshRuntimePods: () => Promise<void>;
+    refreshRuntimes: () => Promise<void>;
     /**
      * Remove a runtime pod from the local state by its pod name.
      *
      * Used to prune a pod immediately after it is deleted, without waiting for
-     * the next `refreshRuntimePods()` poll tick. This lets the remote service
+     * the next `refreshRuntimes()` poll tick. This lets the remote service
      * managers dispose right away and stop polling the (now dead) pod ingress.
      */
-    removeRuntimePod: (podName: string) => void;
+    removeRuntime: (runtimeName: string) => void;
     /**
      * Cached runtime models.
      */

package/lib/state/substates/RuntimesState.js

@@ -30,28 +30,28 @@ export const runtimesStore = createStore((set, get) => {
         /**
          * Remote runtime pods.
          */
-        runtimePods: [],
+        runtimes: [],
         /**
          * Refresh the runtime pods.
          */
-        refreshRuntimePods: async () => {
+        refreshRuntimes: async () => {
             const servers = await getRuntimes();
             // Update the state with the Remote Kernels.
-            if (!JSONExt.deepEqual(get().runtimePods, servers)) {
-                set({ runtimePods: [...servers] });
+            if (!JSONExt.deepEqual(get().runtimes, servers)) {
+                set({ runtimes: [...servers] });
             }
         },
         /**
          * Remove a runtime pod by its pod name.
          */
-        removeRuntimePod: (podName) => {
-            if (!podName) {
+        removeRuntime: (runtimeName) => {
+            if (!runtimeName) {
                 return;
             }
-            const current = get().runtimePods;
-            const next = current.filter(pod => pod.pod_name !== podName);
+            const current = get().runtimes;
+            const next = current.filter(pod => pod.runtime_name !== runtimeName);
             if (next.length !== current.length) {
-                set({ runtimePods: next });
+                set({ runtimes: next });
             }
         },
         /**
@@ -65,7 +65,7 @@ export const runtimesStore = createStore((set, get) => {
             const kernels = get().runtimeModels;
             // Identity check: a runtime may not have a kernel `id` yet (it appears
             // only once a kernel is attached), so fall back to the stable pod `uid`.
-            // See the IRuntimeModel / IRuntimePod / Kernel.IModel docs in models/Runtime.ts.
+            // See the IRuntimeModel / IRuntimeRecord / Kernel.IModel docs in models/Runtime.ts.
             const index = kernels.findIndex(m => (model.id && model.id === m.id) ||
                 (!!model.uid && model.uid === m.uid));
             if (index < 0) {
@@ -77,7 +77,10 @@ export const runtimesStore = createStore((set, get) => {
          */
         removeRuntimeModel: (id) => {
             const kernels = [...get().runtimeModels];
-            const index = kernels?.findIndex(model => id === model.id) ?? -1;
+            // By the kernel it runs, or by the pod it is: a sandbox of an external
+            // provider has no kernel, so its pod name is the only name it answers
+            // to — matched on the kernel alone it was never removed from the list.
+            const index = kernels?.findIndex(model => (!!model.id && id === model.id) || id === model.runtime_name) ?? -1;
             if (index >= 0) {
                 kernels.splice(index, 1);
                 set({ runtimeModels: kernels });
@@ -147,7 +150,7 @@ export const runtimesStore = createStore((set, get) => {
 // Poll remote kernels
 const kernelsPoll = new Poll({
     auto: true,
-    factory: () => runtimesStore.getState().refreshRuntimePods(),
+    factory: () => runtimesStore.getState().refreshRuntimes(),
     frequency: {
         interval: 61 * 1000,
         backoff: true,
@@ -160,9 +163,9 @@ const kernelsPoll = new Poll({
 });
 // Force refresh at expiration date if next tick is after it.
 runtimesStore.subscribe((state, prevState) => {
-    if (!JSONExt.deepEqual(state.runtimePods, prevState.runtimePods)) {
+    if (!JSONExt.deepEqual(state.runtimes, prevState.runtimes)) {
         const now = Date.now();
-        const minExpiredAt = Math.min(...state.runtimePods.map(kernel => kernel.expired_at ? parseFloat(kernel.expired_at) : Infinity)) * 1_000;
+        const minExpiredAt = Math.min(...state.runtimes.map(kernel => kernel.expired_at ? parseFloat(kernel.expired_at) : Infinity)) * 1_000;
         // Refresh 2 sec after the closest expiration time
         // to let some times to the system to dispose the resources.
         if (now + kernelsPoll.frequency.interval > minExpiredAt + 2_000) {

package/lib/state/substates/index.d.ts

@@ -5,4 +5,4 @@ export * from './NbformatState';
 export * from './RuntimesState';
 export * from './JupyterLabState';
 export * from './SpaceState';
-export { coreStore, useCoreStore, iamStore, useIAMStore, layoutStore, useLayoutStore, organizationStore, useOrganizationStore, surveysStore, useSurveysStore, teamStore, useTeamStore, datasourceStore, useDatasourceStore, runStore, useRunStore, DATALAYER_IAM_TOKEN_KEY, DATALAYER_IAM_USER_KEY, } from '@datalayer/core/lib/state';
+export { coreStore, useCoreStore, iamStore, useIAMStore, layoutStore, useLayoutStore, organizationStore, useOrganizationStore, surveysStore, useSurveysStore, teamStore, useTeamStore, runStore, useRunStore, DATALAYER_IAM_TOKEN_KEY, DATALAYER_IAM_USER_KEY, } from '@datalayer/core/lib/state';

package/lib/state/substates/index.js

@@ -11,4 +11,4 @@ export * from './RuntimesState';
 export * from './JupyterLabState';
 export * from './SpaceState';
 // Re-export the identity/plans/layout state that stays in core.
-export { coreStore, useCoreStore, iamStore, useIAMStore, layoutStore, useLayoutStore, organizationStore, useOrganizationStore, surveysStore, useSurveysStore, teamStore, useTeamStore, datasourceStore, useDatasourceStore, runStore, useRunStore, DATALAYER_IAM_TOKEN_KEY, DATALAYER_IAM_USER_KEY, } from '@datalayer/core/lib/state';
+export { coreStore, useCoreStore, iamStore, useIAMStore, layoutStore, useLayoutStore, organizationStore, useOrganizationStore, surveysStore, useSurveysStore, teamStore, useTeamStore, runStore, useRunStore, DATALAYER_IAM_TOKEN_KEY, DATALAYER_IAM_USER_KEY, } from '@datalayer/core/lib/state';

package/lib/stores/agentRuntimeStore.d.ts

@@ -7,6 +7,14 @@ import type { ContextSnapshotData } from '../types/context';
 import type { McpToolsetsStatusResponse } from '../types/mcp';
 import type { LoadedSkillInfo } from '../types/skills';
 import type { EphemeralSurfaceMode } from '../types/chat';
+/** A subagent run is over once its events carry an `end` or an `error`. */
+export declare function isSubagentRunOver(events: readonly AgentStreamSubagentPayload[]): boolean;
+/**
+ * The subagents with a run still going, by name and in the order their runs
+ * were opened — what a roster badges as running. A name appears once however
+ * many of its runs are open.
+ */
+export declare function runningSubagentNames(activity: Record<string, readonly AgentStreamSubagentPayload[]>): string[];
 /**
  * A URL-addressable agent that has been previously connected.
  * May originate from an agent runtime pod OR from the stable agents service.
@@ -70,6 +78,22 @@ export interface AgentRuntimeStoreState {
     mcpStatus: McpToolsetsStatusResponse | null;
     codemodeStatus: CodemodeStatusData | null;
     fullContext: Record<string, unknown> | null;
+    /**
+     * Bumped when the transcript changed on the server outside a run — a
+     * rewind to a checkpoint, a restore — so the chat reloads what it shows.
+     */
+    historyVersion: number;
+    /**
+     * A decision on a held tool call made outside the chat — a host page's own
+     * approval banner. The chat picks it up and answers the run with it, the
+     * way its own card would; `seq` tells one request from the next.
+     */
+    toolDecisionRequest: {
+        seq: number;
+        approvalId: string;
+        approved: boolean;
+        toolName?: string;
+    } | null;
     monitoringCache: Record<string, MonitoringCacheEntry>;
     loadedSkillsByAgentId: Record<string, LoadedSkillInfo[]>;
     ephemeralNotebookModels: Record<string, INotebookContent>;
@@ -111,7 +135,7 @@ export interface AgentRuntimeStoreActions {
     getEditorMode: (runtimeId: string) => EphemeralSurfaceMode | null;
     launchAgent: (options: LaunchAgentOptions) => Promise<AgentConnection>;
     connectAgent: (connection: {
-        podName: string;
+        runtimeName: string;
         environmentName: string;
         serviceManager?: ServiceManager.IManager;
         jupyterBaseUrl?: string;
@@ -126,6 +150,16 @@ export interface AgentRuntimeStoreActions {
     applySnapshot: (payload: AgentStreamSnapshotPayload) => void;
     appendSubagentEvent: (event: AgentStreamSubagentPayload) => void;
     clearSubagentActivity: () => void;
+    /** Mark every delegation still running as stopped, as the person just did. */
+    stopSubagentActivity: () => void;
+    /** Ask the chat to reload its transcript from the server's next snapshot. */
+    requestHistoryReload: () => void;
+    /** Decide a held tool call from outside the chat: approve or deny it. */
+    requestToolDecision: (decision: {
+        approvalId: string;
+        approved: boolean;
+        toolName?: string;
+    }) => void;
     setCompaction: (payload: AgentStreamCompactionPayload | null) => void;
     upsertApproval: (approval: AgentStreamToolApprovalPayload) => void;
     removeApproval: (approvalId: string) => void;
@@ -250,6 +284,14 @@ export declare const useAgentRuntimeSubagentActivityByToolCall: (toolCallId?: st
  * several are active the most recently started one wins.
  */
 export declare const useAgentRuntimeActiveSubagentToolCallId: () => string | null;
+/**
+ * Names of the subagents with a run still going, for a roster to badge.
+ * Compared element by element, so a store update that changes nothing about
+ * who is running does not re-render the roster.
+ */
+export declare const useAgentRuntimeRunningSubagentNames: () => string[];
+/** Bumped each time the chat is asked to reload its transcript. */
+export declare const useAgentRuntimeHistoryVersion: () => number;
 /** Latest history-compaction activity for the connected agent. */
 export declare const useAgentRuntimeCompaction: () => AgentStreamCompactionPayload | null;
 export declare const getAgentRuntimeState: () => AgentRuntimeStore;

package/lib/stores/agentRuntimeStore.js

@@ -21,7 +21,28 @@
  */
 import { createStore } from 'zustand/vanilla';
 import { useStore } from 'zustand';
+import { useShallow } from 'zustand/react/shallow';
 import { persist, createJSONStorage, subscribeWithSelector, } from 'zustand/middleware';
+import { SUBAGENT_STOPPED } from '../types/stream';
+/** A subagent run is over once its events carry an `end` or an `error`. */
+export function isSubagentRunOver(events) {
+    return events.some(event => event.phase === 'end' || event.phase === 'error');
+}
+/**
+ * The subagents with a run still going, by name and in the order their runs
+ * were opened — what a roster badges as running. A name appears once however
+ * many of its runs are open.
+ */
+export function runningSubagentNames(activity) {
+    const names = [];
+    for (const events of Object.values(activity)) {
+        const name = events[0]?.subagentName;
+        if (!name || names.includes(name) || isSubagentRunOver(events))
+            continue;
+        names.push(name);
+    }
+    return names;
+}
 export function getMonitoringCacheKey(serviceName, agentId) {
     return `${serviceName || '__unknown_service__'}::${agentId || '__unknown_agent__'}`;
 }
@@ -41,7 +62,24 @@ function getTransportEndpoint(baseUrl, transport, agentId) {
             return `${baseUrl}/api/v1/ag-ui/${agentId}/`;
     }
 }
+function toAgentRuntimeBaseUrl(baseUrl) {
+    const normalized = baseUrl.replace(/\/$/, '');
+    if (normalized.includes('/api/agent-runtimes'))
+        return normalized;
+    if (normalized.includes('/api/jupyter-server')) {
+        return normalized.replace('/api/jupyter-server', '/api/agent-runtimes');
+    }
+    if (normalized.includes('/jupyter/server/')) {
+        return normalized.replace('/jupyter/server/', '/agent-runtimes/');
+    }
+    if (normalized.includes('/jupyter-server/')) {
+        return normalized.replace('/jupyter-server/', '/agent-runtimes/');
+    }
+    return normalized.replace('/jupyter/', '/agent-runtimes/');
+}
 async function createAgentOnRuntime(agentBaseUrl, agentId, config = {}) {
+    const { iamStore } = await import('@datalayer/core/lib/state');
+    const token = iamStore.getState().token || '';
     if (!config.protocol && !config.agentSpecId) {
         throw new Error('Agent protocol is required. Provide config.protocol from the selected spec/config.');
     }
@@ -83,7 +121,10 @@ async function createAgentOnRuntime(agentBaseUrl, agentId, config = {}) {
     }
     const response = await fetch(`${agentBaseUrl}/api/v1/agents`, {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
+        headers: {
+            'Content-Type': 'application/json',
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
         body: JSON.stringify(payload),
     });
     if (response.ok || response.status === 400 || response.status === 409) {
@@ -101,6 +142,8 @@ const initialRuntimeState = {
     status: 'idle',
     error: null,
     isLaunching: false,
+    historyVersion: 0,
+    toolDecisionRequest: null,
 };
 const initialWsState = {
     wsState: 'closed',
@@ -295,10 +338,10 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
         if (!baseUrl) {
             throw new Error('connectAgent requires either jupyterBaseUrl or serviceManager');
         }
-        const agentBaseUrl = baseUrl.replace('/jupyter/server/', '/agent-runtimes/');
+        const agentBaseUrl = toAgentRuntimeBaseUrl(baseUrl);
         set({
             runtime: {
-                podName: connection.podName,
+                runtimeName: connection.runtimeName,
                 environmentName: connection.environmentName,
                 jupyterBaseUrl: baseUrl,
                 agentBaseUrl,
@@ -321,7 +364,7 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
                 });
             }
             const { runtimesUrl: _runtimesUrl, ...runtimeOptions } = config;
-            const runtimePod = await createRuntime({
+            const runtimeRecord = await createRuntime({
                 environmentName: runtimeOptions.environmentName,
                 creditsLimit: runtimeOptions.creditsLimit,
                 type: runtimeOptions.type || 'notebook',
@@ -330,11 +373,11 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
                 snapshot: runtimeOptions.snapshot,
             });
             set({ status: 'connecting' });
-            const jupyterBaseUrl = runtimePod.ingress;
-            const agentBaseUrl = jupyterBaseUrl.replace('/jupyter/server/', '/agent-runtimes/');
+            const jupyterBaseUrl = runtimeRecord.ingress;
+            const agentBaseUrl = toAgentRuntimeBaseUrl(jupyterBaseUrl);
             const conn = {
-                podName: runtimePod.pod_name,
-                environmentName: runtimePod.environment.name,
+                runtimeName: runtimeRecord.runtime_name,
+                environmentName: runtimeRecord.environment.name,
                 jupyterBaseUrl,
                 agentBaseUrl,
                 status: 'ready',
@@ -354,7 +397,7 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
             throw new Error('No runtime connected. Launch or connect to a runtime first.');
         }
         try {
-            const agentId = config.name || runtime.podName;
+            const agentId = config.name || runtime.runtimeName;
             const agentConnection = await createAgentOnRuntime(runtime.agentBaseUrl, agentId, config);
             set({
                 runtime: {
@@ -405,6 +448,12 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
     appendSubagentEvent: event => set(state => {
         const key = event.toolCallId ?? event.subagentName;
         const existing = state.subagentActivity[key] ?? [];
+        // A run the person stopped is over. The server's last words —
+        // a delta in flight, its own "Stopped." — arrive a moment later
+        // and would read as a second ending under the first.
+        if (existing.some(entry => entry.phase === 'error' && entry.error === SUBAGENT_STOPPED)) {
+            return {};
+        }
         return {
             subagentActivity: {
                 ...state.subagentActivity,
@@ -413,6 +462,35 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
         };
     }),
     clearSubagentActivity: () => set({ subagentActivity: {} }),
+    stopSubagentActivity: () => set(state => {
+        let changed = false;
+        const next = {};
+        for (const [key, events] of Object.entries(state.subagentActivity)) {
+            if (events.length === 0 || isSubagentRunOver(events)) {
+                next[key] = events;
+                continue;
+            }
+            changed = true;
+            next[key] = [
+                ...events,
+                {
+                    subagentName: events[0].subagentName,
+                    toolCallId: events[0].toolCallId ?? key,
+                    phase: 'error',
+                    error: SUBAGENT_STOPPED,
+                    transport: events[0].transport,
+                },
+            ];
+        }
+        return changed ? { subagentActivity: next } : {};
+    }),
+    requestHistoryReload: () => set(state => ({ historyVersion: state.historyVersion + 1 })),
+    requestToolDecision: decision => set(state => ({
+        toolDecisionRequest: {
+            seq: (state.toolDecisionRequest?.seq ?? 0) + 1,
+            ...decision,
+        },
+    })),
     setCompaction: payload => set({ compaction: payload }),
     upsertApproval: approval => set(state => {
         const filtered = state.approvals.filter(a => a.id !== approval.id);
@@ -700,6 +778,10 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
             ephemeralNotebookModels: state.ephemeralNotebookModels,
             ephemeralDocumentModels: state.ephemeralDocumentModels,
             editorModeByRuntime: state.editorModeByRuntime,
+            // And the delegations already streamed: they are part of the
+            // transcript — the boxes under the tool cards — not of the socket
+            // session, and a reconnect used to blank every one of them.
+            subagentActivity: state.subagentActivity,
         }));
     },
 }), {
@@ -794,12 +876,19 @@ export const useAgentRuntimeActiveSubagentToolCallId = () => useAgentRuntimeStor
     for (const [key, events] of Object.entries(s.subagentActivity)) {
         if (events.length === 0)
             continue;
-        const done = events.some(e => e.phase === 'end' || e.phase === 'error');
-        if (!done)
+        if (!isSubagentRunOver(events))
             activeKey = key;
     }
     return activeKey;
 });
+/**
+ * Names of the subagents with a run still going, for a roster to badge.
+ * Compared element by element, so a store update that changes nothing about
+ * who is running does not re-render the roster.
+ */
+export const useAgentRuntimeRunningSubagentNames = () => useAgentRuntimeStore(useShallow(s => runningSubagentNames(s.subagentActivity)));
+/** Bumped each time the chat is asked to reload its transcript. */
+export const useAgentRuntimeHistoryVersion = () => useAgentRuntimeStore(s => s.historyVersion);
 /** Latest history-compaction activity for the connected agent. */
 export const useAgentRuntimeCompaction = () => useAgentRuntimeStore(s => s.compaction);
 // ---------------------------------------------------------------------------

package/lib/stores/index.d.ts

@@ -3,6 +3,6 @@
  *
  * @module store
  */
-export { agentRuntimeStore, useAgentRuntimeStore, useAgentRuntimeConnection, useAgentRuntimeStatus, useAgentRuntimeError, useAgentRuntimeIsLaunching, useAgentRuntimeApprovals, useAgentRuntimePendingCount, useAgentRuntimeMcpStatus, useAgentRuntimeFullContext, useAgentRuntimeContextSnapshot, useAgentRuntimeCostUsage, useAgentRuntimeCodemodeStatus, useAgentRuntimeWsState, useAgentRuntimeLoadedSkills, useAgentRuntimeActiveSubagentToolCallId, useAgentRuntimeSubagentActivity, useAgentRuntimeSubagentActivityByToolCall, useAgentRuntimeCompaction, getAgentRuntimeState, subscribeToAgentRuntime, type AgentRegistryEntry, type AgentRuntimeWsState, type AgentRuntimeStoreState, type AgentRuntimeStoreActions, type AgentRuntimeStore, } from './agentRuntimeStore';
+export { agentRuntimeStore, useAgentRuntimeStore, useAgentRuntimeConnection, useAgentRuntimeStatus, useAgentRuntimeError, useAgentRuntimeIsLaunching, useAgentRuntimeApprovals, useAgentRuntimePendingCount, useAgentRuntimeMcpStatus, useAgentRuntimeFullContext, useAgentRuntimeContextSnapshot, useAgentRuntimeCostUsage, useAgentRuntimeCodemodeStatus, useAgentRuntimeWsState, useAgentRuntimeLoadedSkills, useAgentRuntimeActiveSubagentToolCallId, useAgentRuntimeRunningSubagentNames, runningSubagentNames, isSubagentRunOver, useAgentRuntimeSubagentActivity, useAgentRuntimeSubagentActivityByToolCall, useAgentRuntimeCompaction, useAgentRuntimeHistoryVersion, getAgentRuntimeState, subscribeToAgentRuntime, type AgentRegistryEntry, type AgentRuntimeWsState, type AgentRuntimeStoreState, type AgentRuntimeStoreActions, type AgentRuntimeStore, } from './agentRuntimeStore';
 export { useChatStore, useChatMessages, useChatLoading, useChatStreaming, useChatError, useChatTools, useChatOpen, useChatConfig, useChatReady, useChatInferenceProvider, useChatExtensionRegistry, defaultChatConfig, type ChatStore, type ChatState, type ChatActions, type ChatConfig, type ToolCallState, } from './chatStore';
 export { useConversationStore, useConversationMessages, useNeedsFetch, useIsFetching, type ConversationStore, type ConversationData, } from './conversationStore';

package/lib/stores/index.js

@@ -7,6 +7,6 @@
  *
  * @module store
  */
-export { agentRuntimeStore, useAgentRuntimeStore, useAgentRuntimeConnection, useAgentRuntimeStatus, useAgentRuntimeError, useAgentRuntimeIsLaunching, useAgentRuntimeApprovals, useAgentRuntimePendingCount, useAgentRuntimeMcpStatus, useAgentRuntimeFullContext, useAgentRuntimeContextSnapshot, useAgentRuntimeCostUsage, useAgentRuntimeCodemodeStatus, useAgentRuntimeWsState, useAgentRuntimeLoadedSkills, useAgentRuntimeActiveSubagentToolCallId, useAgentRuntimeSubagentActivity, useAgentRuntimeSubagentActivityByToolCall, useAgentRuntimeCompaction, getAgentRuntimeState, subscribeToAgentRuntime, } from './agentRuntimeStore';
+export { agentRuntimeStore, useAgentRuntimeStore, useAgentRuntimeConnection, useAgentRuntimeStatus, useAgentRuntimeError, useAgentRuntimeIsLaunching, useAgentRuntimeApprovals, useAgentRuntimePendingCount, useAgentRuntimeMcpStatus, useAgentRuntimeFullContext, useAgentRuntimeContextSnapshot, useAgentRuntimeCostUsage, useAgentRuntimeCodemodeStatus, useAgentRuntimeWsState, useAgentRuntimeLoadedSkills, useAgentRuntimeActiveSubagentToolCallId, useAgentRuntimeRunningSubagentNames, runningSubagentNames, isSubagentRunOver, useAgentRuntimeSubagentActivity, useAgentRuntimeSubagentActivityByToolCall, useAgentRuntimeCompaction, useAgentRuntimeHistoryVersion, getAgentRuntimeState, subscribeToAgentRuntime, } from './agentRuntimeStore';
 export { useChatStore, useChatMessages, useChatLoading, useChatStreaming, useChatError, useChatTools, useChatOpen, useChatConfig, useChatReady, useChatInferenceProvider, useChatExtensionRegistry, defaultChatConfig, } from './chatStore';
 export { useConversationStore, useConversationMessages, useNeedsFetch, useIsFetching, } from './conversationStore';

package/lib/stories/Button.d.ts

@@ -12,4 +12,4 @@ export interface ButtonProps {
     onClick?: () => void;
 }
 /** Primary UI component for user interaction */
-export declare const Button: ({ primary, size, backgroundColor, label, ...props }: ButtonProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Button: ({ primary, size, backgroundColor, label, ...props }: ButtonProps) => import("react").JSX.Element;

package/lib/stories/Button.stories.d.ts

@@ -1,7 +1,7 @@
 import type { StoryObj } from '@storybook/react-vite';
 declare const meta: {
     title: string;
-    component: ({ primary, size, backgroundColor, label, ...props }: import("./Button").ButtonProps) => import("react/jsx-runtime").JSX.Element;
+    component: ({ primary, size, backgroundColor, label, ...props }: import("./Button").ButtonProps) => import("react").JSX.Element;
     parameters: {
         layout: string;
     };

package/lib/stories/Header.d.ts

@@ -8,5 +8,5 @@ export interface HeaderProps {
     onLogout?: () => void;
     onCreateAccount?: () => void;
 }
-export declare const Header: ({ user, onLogin, onLogout, onCreateAccount, }: HeaderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Header: ({ user, onLogin, onLogout, onCreateAccount, }: HeaderProps) => import("react").JSX.Element;
 export {};

package/lib/stories/Header.stories.d.ts

@@ -1,7 +1,7 @@
 import type { StoryObj } from '@storybook/react-vite';
 declare const meta: {
     title: string;
-    component: ({ user, onLogin, onLogout, onCreateAccount, }: import("./Header").HeaderProps) => import("react/jsx-runtime").JSX.Element;
+    component: ({ user, onLogin, onLogout, onCreateAccount, }: import("./Header").HeaderProps) => import("react").JSX.Element;
     tags: string[];
     parameters: {
         layout: string;

package/lib/test-setup.js

@@ -10,6 +10,39 @@ global.__webpack_public_path__ = '';
 // Native FormData and fetch should work in Node.js 20+
 // Define other globals that might be needed
 global.global = globalThis;
+/*
+ * Primer announces through `@primer/live-region-element`, whose `<live-region>`
+ * custom element it expects the document to define.
+ *
+ * jsdom defines no custom elements, and the package's Node build — the one
+ * Vitest loads, because Primer is externalised and Node takes the `node` export
+ * condition — assumes the element is already there. Primer therefore finds a
+ * plain `HTMLElement`, `announceFromElement` is undefined, and every
+ * announcement throws. Tests that assert a clean console then fail on an error
+ * raised nowhere near what they are testing.
+ *
+ * Nothing here has a screen reader, so the element only has to exist and do
+ * nothing. Defined rather than mocked so Primer's own code path runs unchanged.
+ */
+if (typeof customElements !== 'undefined' &&
+    !customElements.get('live-region')) {
+    class LiveRegionStub extends HTMLElement {
+        // Both announce methods hand back a handle Primer keeps and cancels when
+        // the announcement is superseded, so returning nothing moves the failure
+        // rather than removing it.
+        announce() {
+            return { cancel() { } };
+        }
+        announceFromElement() {
+            return { cancel() { } };
+        }
+        clear() { }
+        getMessage() {
+            return '';
+        }
+    }
+    customElements.define('live-region', LiveRegionStub);
+}
 // Mock DragEvent and other DOM APIs not available in jsdom
 class MockDragEvent extends Event {
     dataTransfer = null;
@@ -52,6 +85,20 @@ Object.defineProperty(window, 'matchMedia', {
 // Mock Simple-related modules to prevent import errors
 import { vi } from 'vitest';
 vi.mock('@datalayer/jupyter-react', () => ({
+    createLiteServiceManager: async () => ({
+        sessions: {
+            startNew: async () => ({
+                kernel: {
+                    id: 'test-kernel',
+                    requestExecute: () => ({ done: Promise.resolve(), onIOPub: null }),
+                    shutdown: async () => { },
+                },
+            }),
+        },
+    }),
+    jupyterReactStore: {
+        getState: () => ({ setServiceManager: () => { } }),
+    },
     useJupyter: () => ({
         defaultKernel: null,
         serviceManager: null,
@@ -75,6 +122,25 @@ vi.mock('@datalayer/jupyter-react', () => ({
         CONNECTED: 'connected',
         DISCONNECTED: 'disconnected',
     },
+    // Reads JupyterLab's page config off the document. `AgentNotebook` and
+    // `AgentDocument` call it at module scope, so the mock has to answer even
+    // for a test that never renders either.
+    loadJupyterConfig: () => ({}),
+    /*
+     * What turns a tool definition into something callable.
+     *
+     * `createAgentRuntimesTool` builds one per tool, so any test that asks the
+     * adapters for a tool list constructs it — and a missing export here is not
+     * a mock returning nothing, it is a TypeError at construction. The real one
+     * calls the operation and formats the result; this does the first half and
+     * returns the result as it comes, which is what a test asserting on tool
+     * behaviour rather than on wire format wants.
+     */
+    OperationRunner: class OperationRunner {
+        async execute(operation, params, context) {
+            return operation.execute(params, context);
+        }
+    },
 }));
 vi.mock('@jupyter/web-components', () => ({}));
 vi.mock('@jupyter/ydoc', () => ({

package/lib/tools/adapters/agent-runtimes/lexicalHooks.d.ts

@@ -1,3 +1,10 @@
+/**
+ * React hooks for agent-runtimes lexical tool registration.
+ * Provides: useLexicalTools hook for ChatFloating integration.
+ *
+ * @module tools/adapters/agent-runtimes/lexicalHooks
+ */
+import '@datalayer/jupyter-react/lib/css/PrismCss';
 import type { ToolExecutionContext } from '@datalayer/jupyter-react';
 import type { FrontendToolDefinition } from '../../../types/tools';
 /**
@@ -30,5 +37,13 @@ import type { FrontendToolDefinition } from '../../../types/tools';
  * />
  * ```
  */
+/**
+ * The document's frontend tools, built without React.
+ *
+ * The plain twin of `useLexicalTools`, for the document plugin contributing
+ * to the chat's `LoopFrontendTool` point. The executor reads the lexical
+ * store's live state through its methods; no reactivity needed.
+ */
+export declare function createLexicalTools(documentId: string, contextOverrides?: Partial<Omit<ToolExecutionContext, 'executor' | 'documentId'>>): FrontendToolDefinition[];
 export declare function useLexicalTools(documentId: string, contextOverrides?: Partial<Omit<ToolExecutionContext, 'executor' | 'documentId'>>): FrontendToolDefinition[];
 export type { FrontendToolDefinition };