@datalayer/agent-runtimes 1.0.10 → 1.0.17

package/lib/state/substates/RuntimesState.js

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useStore } from 'zustand';
+import { createStore } from 'zustand/vanilla';
+import { JSONExt } from '@lumino/coreutils';
+import { Poll } from '@lumino/polling';
+import { getRuntimes } from '../../runtimes';
+import { coreStore } from '@datalayer/core/lib/state/substates/CoreState';
+import { iamStore } from '@datalayer/core/lib/state/substates/IAMState';
+/**
+ * Kernel store
+ */
+export const runtimesStore = createStore((set, get) => {
+    return {
+        configuration: {
+            maxNotebookRuntimes: 5,
+            maxCellRuntimes: 3,
+        },
+        setConfiguration: (configuration) => {
+            set(state => JSONExt.deepEqual(state.configuration, configuration)
+                ? {}
+                : { configuration: { ...configuration } });
+        },
+        runtimesUrl: coreStore.getState().configuration?.runtimesUrl,
+        tab: 0.0,
+        getIntTab: () => Math.floor(get().tab),
+        setTab: (tab) => set(state => ({ tab })),
+        /**
+         * Remote runtime pods.
+         */
+        runtimePods: [],
+        /**
+         * Refresh the runtime pods.
+         */
+        refreshRuntimePods: async () => {
+            const servers = await getRuntimes();
+            // Update the state with the Remote Kernels.
+            if (!JSONExt.deepEqual(get().runtimePods, servers)) {
+                set({ runtimePods: [...servers] });
+            }
+        },
+        /**
+         * Remove a runtime pod by its pod name.
+         */
+        removeRuntimePod: (podName) => {
+            if (!podName) {
+                return;
+            }
+            const current = get().runtimePods;
+            const next = current.filter(pod => pod.pod_name !== podName);
+            if (next.length !== current.length) {
+                set({ runtimePods: next });
+            }
+        },
+        /**
+         * Cached runtime models.
+         */
+        runtimeModels: [],
+        /**
+         * Add a runtime model
+         */
+        addRuntimeModel: (model) => {
+            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.
+            const index = kernels.findIndex(m => (model.id && model.id === m.id) ||
+                (!!model.uid && model.uid === m.uid));
+            if (index < 0) {
+                set({ runtimeModels: [...kernels, model] });
+            }
+        },
+        /**
+         * Remove a runtime model by ID.
+         */
+        removeRuntimeModel: (id) => {
+            const kernels = [...get().runtimeModels];
+            const index = kernels?.findIndex(model => id === model.id) ?? -1;
+            if (index >= 0) {
+                kernels.splice(index, 1);
+                set({ runtimeModels: kernels });
+            }
+        },
+        setRuntimeModels: (models) => {
+            if (!JSONExt.deepEqual(get().runtimeModels, models)) {
+                set({ runtimeModels: [...models] });
+            }
+        },
+        multiServiceManager: undefined,
+        setMultiServiceManager: multiServiceManager => {
+            set(state => ({ multiServiceManager }));
+        },
+        showDisclaimer: false,
+        setShowDisclaimer: showDisclaimer => {
+            set(state => ({ showDisclaimer }));
+        },
+        /**
+         * Kernel Snapshots.
+         */
+        runtimeSnapshots: [],
+        /**
+         * Add a Kernel Snapshot
+         */
+        addSandboxSnapshot: (snapshot) => {
+            const snapshots = get().runtimeSnapshots;
+            const index = snapshots.findIndex(s => s.id === snapshot.id);
+            if (index < 0) {
+                const kernelSnapshots = [...snapshots, snapshot];
+                set({ runtimeSnapshots: kernelSnapshots });
+            }
+            else if (!JSONExt.deepEqual(snapshots[index], snapshot)) {
+                const kernelSnapshots = [...snapshots];
+                kernelSnapshots.splice(index, 1, snapshot);
+                set({ runtimeSnapshots: kernelSnapshots });
+            }
+        },
+        /**
+         * Remove a Kernel Snapshot.
+         */
+        removeSandboxSnapshot: (id) => {
+            const snapshots = get().runtimeSnapshots;
+            const index = snapshots.findIndex(s => s.id === id);
+            if (index >= 0) {
+                const kernelSnapshots = [...snapshots];
+                kernelSnapshots.splice(index, 1);
+                set({ runtimeSnapshots: kernelSnapshots });
+            }
+        },
+        /**
+         * Set Kernel Snapshots.
+         */
+        setSandboxSnapshots: (snapshots) => {
+            if (!JSONExt.deepEqual(get().runtimeSnapshots, snapshots)) {
+                set({ runtimeSnapshots: [...snapshots] });
+            }
+        },
+        version: '',
+        setVersion: version => {
+            if (version && !get().version) {
+                set(state => ({ version }));
+            }
+        },
+    };
+});
+// Poll remote kernels
+const kernelsPoll = new Poll({
+    auto: true,
+    factory: () => runtimesStore.getState().refreshRuntimePods(),
+    frequency: {
+        interval: 61 * 1000,
+        backoff: true,
+        max: 300 * 1000,
+    },
+    name: '@datalayer/jupyter-kernels:KernelsManager#kernels',
+    standby: () => iamStore.getState().token || runtimesStore.getState().runtimesUrl
+        ? 'when-hidden'
+        : true,
+});
+// Force refresh at expiration date if next tick is after it.
+runtimesStore.subscribe((state, prevState) => {
+    if (!JSONExt.deepEqual(state.runtimePods, prevState.runtimePods)) {
+        const now = Date.now();
+        const minExpiredAt = Math.min(...state.runtimePods.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) {
+            setTimeout(() => {
+                kernelsPoll.refresh();
+            }, minExpiredAt + 2_000 - now);
+        }
+    }
+});
+coreStore.subscribe((state, prevState) => {
+    if (state.configuration.runtimesUrl &&
+        state.configuration.runtimesUrl !== prevState.configuration.runtimesUrl) {
+        const runtimesUrl = state.configuration.runtimesUrl;
+        console.log(`Updating runtimesUrl with new value ${runtimesUrl}`);
+        runtimesStore.setState({ runtimesUrl });
+        kernelsPoll
+            .refresh()
+            .then(() => kernelsPoll.tick)
+            .catch(reason => {
+            console.error('Failed to refresh kernel servers list following service URL changed.', reason);
+        });
+    }
+});
+export function useRuntimesStore(selector) {
+    return useStore(runtimesStore, selector);
+}
+export default useRuntimesStore;

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

@@ -0,0 +1,11 @@
+type IBaseSpace = Record<string, any>;
+export type ISpaceState = {
+    spaces: IBaseSpace[];
+};
+export type SpaceState = ISpaceState & {
+    updateSpaces: (spaces: IBaseSpace[]) => void;
+};
+export declare const spaceStore: import("zustand").StoreApi<SpaceState>;
+export declare function useSpaceStore(): SpaceState;
+export declare function useSpaceStore<T>(selector: (state: SpaceState) => T): T;
+export default useSpaceStore;

package/lib/state/substates/SpaceState.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { createStore } from 'zustand/vanilla';
+import { useStore } from 'zustand';
+export const spaceStore = createStore((set, get) => ({
+    spaces: [],
+    updateSpaces: (spaces) => set((state) => ({
+        spaces,
+    })),
+}));
+export function useSpaceStore(selector) {
+    return useStore(spaceStore, selector);
+}
+export default useSpaceStore;

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

@@ -0,0 +1,8 @@
+export * from './CellState';
+export * from './DocumentState';
+export * from './GradeState';
+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';

package/lib/state/substates/index.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+// Moved runtime + content substates (owned by agent-runtimes).
+export * from './CellState';
+export * from './DocumentState';
+export * from './GradeState';
+export * from './NbformatState';
+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';

package/lib/stores/agentRuntimeStore.d.ts

@@ -1,10 +1,12 @@
 import type { ServiceManager } from '@jupyterlab/services';
-import type { IRuntimeOptions } from '@datalayer/core/lib/stateful/runtimes/apis';
+import type { INotebookContent } from '@jupyterlab/nbformat';
+import type { IRuntimeOptions } from '../runtimes/apis';
 import type { AgentStatus, AgentConnection, AgentConfig, Protocol } from '../types';
 import type { AgentStreamSnapshotPayload, AgentStreamToolApprovalPayload, CodemodeStatusData } from '../types/stream';
 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 URL-addressable agent that has been previously connected.
  * May originate from an agent runtime pod OR from the stable agents service.
@@ -59,6 +61,19 @@ export interface AgentRuntimeStoreState {
     fullContext: Record<string, unknown> | null;
     monitoringCache: Record<string, MonitoringCacheEntry>;
     loadedSkillsByAgentId: Record<string, LoadedSkillInfo[]>;
+    ephemeralNotebookModels: Record<string, INotebookContent>;
+    /**
+     * Persisted in-memory ephemeral document (Lexical) editor states, keyed by
+     * document id. The value is a serialized Lexical editor state (JSON string)
+     * so the document survives navigation away from and back to a runtime page.
+     */
+    ephemeralDocumentModels: Record<string, string>;
+    /**
+     * Persisted companion editor choice (`none` | `notebook` | `document`) keyed
+     * by runtime id, so the chosen editor is restored when navigating away from
+     * and back to a runtime page.
+     */
+    editorModeByRuntime: Record<string, EphemeralSurfaceMode>;
 }
 export interface AgentRuntimeStoreActions {
     upsertAgent: (agent: Partial<AgentRegistryEntry> & {
@@ -75,6 +90,14 @@ export interface AgentRuntimeStoreActions {
     setLoadedSkillsForAgent: (agentId: string, skills: LoadedSkillInfo[]) => void;
     getLoadedSkillsForAgent: (agentId: string) => LoadedSkillInfo[];
     clearLoadedSkillsForAgent: (agentId: string) => void;
+    setEphemeralNotebookModel: (notebookId: string, model: INotebookContent) => void;
+    getEphemeralNotebookModel: (notebookId: string) => INotebookContent | null;
+    clearEphemeralNotebookModel: (notebookId: string) => void;
+    setEphemeralDocumentModel: (documentId: string, model: string) => void;
+    getEphemeralDocumentModel: (documentId: string) => string | null;
+    clearEphemeralDocumentModel: (documentId: string) => void;
+    setEditorMode: (runtimeId: string, mode: EphemeralSurfaceMode) => void;
+    getEditorMode: (runtimeId: string) => EphemeralSurfaceMode | null;
     launchAgent: (options: LaunchAgentOptions) => Promise<AgentConnection>;
     connectAgent: (connection: {
         podName: string;
@@ -136,7 +159,7 @@ export interface AgentRuntimeStoreActions {
 export type AgentRuntimeStore = AgentRuntimeStoreState & AgentRuntimeStoreActions;
 export interface LaunchAgentOptions extends IRuntimeOptions {
     /** Optional runtimes API base URL override for runtime creation. */
-    runtimesRunUrl?: string;
+    runtimesUrl?: string;
 }
 export declare const agentRuntimeStore: Omit<Omit<import("zustand").StoreApi<AgentRuntimeStore>, "subscribe"> & {
     subscribe: {

package/lib/stores/agentRuntimeStore.js

@@ -42,26 +42,51 @@ function getTransportEndpoint(baseUrl, transport, agentId) {
     }
 }
 async function createAgentOnRuntime(agentBaseUrl, agentId, config = {}) {
-    if (!config.protocol) {
+    if (!config.protocol && !config.agentSpecId) {
         throw new Error('Agent protocol is required. Provide config.protocol from the selected spec/config.');
     }
-    const transport = config.protocol;
-    if (!config.model) {
+    const transport = config.protocol || 'vercel-ai';
+    if (!config.model && !config.agentSpecId) {
         throw new Error('Agent model is required. Provide config.model from the selected spec/config.');
     }
+    const payload = {
+        name: config.name || agentId,
+        description: config.description || 'AI assistant',
+        agent_library: config.agentLibrary || 'pydantic-ai',
+        transport,
+        model: config.model,
+        system_prompt: config.systemPrompt || 'You are a helpful AI assistant.',
+    };
+    if (config.agentSpecId) {
+        payload.agent_spec_id = config.agentSpecId;
+    }
+    if (typeof config.enableSkills === 'boolean') {
+        payload.enable_skills = config.enableSkills;
+    }
+    if (Array.isArray(config.tools)) {
+        payload.tools = config.tools;
+    }
+    if (config.inferenceProvider) {
+        payload.inferenceProvider = config.inferenceProvider;
+    }
+    if (typeof config.enableCodemode === 'boolean') {
+        payload.enable_codemode = config.enableCodemode;
+    }
+    if (config.sandboxVariant) {
+        payload.sandbox_variant = config.sandboxVariant;
+    }
+    if (config.jupyterSandbox) {
+        payload.jupyter_sandbox = config.jupyterSandbox;
+    }
+    if (config.createPayload && typeof config.createPayload === 'object') {
+        Object.assign(payload, config.createPayload);
+    }
     const response = await fetch(`${agentBaseUrl}/api/v1/agents`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            name: config.name || agentId,
-            description: config.description || 'AI assistant',
-            agent_library: config.agentLibrary || 'pydantic-ai',
-            transport,
-            model: config.model,
-            system_prompt: config.systemPrompt || 'You are a helpful AI assistant.',
-        }),
+        body: JSON.stringify(payload),
     });
-    if (response.ok || response.status === 400) {
+    if (response.ok || response.status === 400 || response.status === 409) {
         const endpoint = getTransportEndpoint(agentBaseUrl, transport, agentId);
         return { agentId, endpoint, isReady: true };
     }
@@ -89,6 +114,11 @@ const initialWsState = {
     monitoringCache: {},
     loadedSkillsByAgentId: {},
 };
+const initialNotebookState = {
+    ephemeralNotebookModels: {},
+    ephemeralDocumentModels: {},
+    editorModeByRuntime: {},
+};
 const countPendingApprovals = (approvals) => approvals.filter(approval => approval.status === 'pending').length;
 // ---------------------------------------------------------------------------
 // Store
@@ -207,6 +237,54 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
             return { loadedSkillsByAgentId: remaining };
         });
     },
+    setEphemeralNotebookModel: (notebookId, model) => {
+        set(state => ({
+            ephemeralNotebookModels: {
+                ...state.ephemeralNotebookModels,
+                [notebookId]: model,
+            },
+        }));
+    },
+    getEphemeralNotebookModel: notebookId => get().ephemeralNotebookModels[notebookId] ?? null,
+    clearEphemeralNotebookModel: notebookId => {
+        set(state => {
+            if (!(notebookId in state.ephemeralNotebookModels)) {
+                return {};
+            }
+            const { [notebookId]: _removed, ...remaining } = state.ephemeralNotebookModels;
+            return { ephemeralNotebookModels: remaining };
+        });
+    },
+    setEphemeralDocumentModel: (documentId, model) => {
+        set(state => ({
+            ephemeralDocumentModels: {
+                ...state.ephemeralDocumentModels,
+                [documentId]: model,
+            },
+        }));
+    },
+    getEphemeralDocumentModel: documentId => get().ephemeralDocumentModels[documentId] ?? null,
+    clearEphemeralDocumentModel: documentId => {
+        set(state => {
+            if (!(documentId in state.ephemeralDocumentModels)) {
+                return {};
+            }
+            const { [documentId]: _removed, ...remaining } = state.ephemeralDocumentModels;
+            return { ephemeralDocumentModels: remaining };
+        });
+    },
+    setEditorMode: (runtimeId, mode) => {
+        if (!runtimeId) {
+            return;
+        }
+        set(state => ({
+            editorModeByRuntime: {
+                ...state.editorModeByRuntime,
+                [runtimeId]: mode,
+            },
+        }));
+    },
+    getEditorMode: runtimeId => get().editorModeByRuntime[runtimeId] ?? null,
     // ── Runtime connection ────────────────────────────────────────
     ...initialRuntimeState,
     connectAgent: connection => {
@@ -233,14 +311,14 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
     launchAgent: async (config) => {
         set({ status: 'launching', error: null, isLaunching: true });
         try {
-            const { createRuntime } = await import('@datalayer/core/lib/api');
-            const { runtimesStore } = await import('@datalayer/core/lib/state');
-            if (config.runtimesRunUrl) {
+            const { createRuntime } = await import('../runtimes/actions');
+            const { runtimesStore } = await import('../state/substates');
+            if (config.runtimesUrl) {
                 runtimesStore.setState({
-                    runtimesRunUrl: config.runtimesRunUrl,
+                    runtimesUrl: config.runtimesUrl,
                 });
             }
-            const { runtimesRunUrl: _runtimesRunUrl, ...runtimeOptions } = config;
+            const { runtimesUrl: _runtimesUrl, ...runtimeOptions } = config;
             const runtimePod = await createRuntime({
                 environmentName: runtimeOptions.environmentName,
                 creditsLimit: runtimeOptions.creditsLimit,
@@ -299,6 +377,7 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
     setError: error => set({ error, status: 'error' }),
     // ── WebSocket stream ──────────────────────────────────────────
     ...initialWsState,
+    ...initialNotebookState,
     setWsState: wsState => set({ wsState }),
     setWs: (ws, agentId) => {
         _ws = ws;
@@ -581,7 +660,14 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
         }
         _ws = null;
         _wsByAgentId.clear();
-        set({ ...initialRuntimeState, ...initialWsState });
+        set(state => ({
+            ...initialRuntimeState,
+            ...initialWsState,
+            // Keep persisted notebook models across navigation/reset cycles.
+            ephemeralNotebookModels: state.ephemeralNotebookModels,
+            ephemeralDocumentModels: state.ephemeralDocumentModels,
+            editorModeByRuntime: state.editorModeByRuntime,
+        }));
     },
     resetWs: () => {
         if (_ws) {
@@ -594,7 +680,13 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
         }
         _ws = null;
         _wsByAgentId.clear();
-        set(initialWsState);
+        set(state => ({
+            ...initialWsState,
+            // Preserve notebook models when the chat websocket reconnects.
+            ephemeralNotebookModels: state.ephemeralNotebookModels,
+            ephemeralDocumentModels: state.ephemeralDocumentModels,
+            editorModeByRuntime: state.editorModeByRuntime,
+        }));
     },
 }), {
     name: 'agent-runtimes-storage',
@@ -613,6 +705,9 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
         })),
         monitoringCache: state.monitoringCache,
         loadedSkillsByAgentId: state.loadedSkillsByAgentId,
+        ephemeralNotebookModels: state.ephemeralNotebookModels,
+        ephemeralDocumentModels: state.ephemeralDocumentModels,
+        editorModeByRuntime: state.editorModeByRuntime,
     }),
 })));
 export function useAgentRuntimeStore(selector) {

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

@@ -12,7 +12,7 @@ declare const meta: {
         };
     };
     args: {
-        onClick: import("vitest").Mock<(...args: any[]) => any>;
+        onClick: import("storybook/test").Mock<(...args: any[]) => any>;
     };
 };
 export default meta;

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

@@ -7,9 +7,9 @@ declare const meta: {
         layout: string;
     };
     args: {
-        onLogin: import("vitest").Mock<(...args: any[]) => any>;
-        onLogout: import("vitest").Mock<(...args: any[]) => any>;
-        onCreateAccount: import("vitest").Mock<(...args: any[]) => any>;
+        onLogin: import("storybook/test").Mock<(...args: any[]) => any>;
+        onLogout: import("storybook/test").Mock<(...args: any[]) => any>;
+        onCreateAccount: import("storybook/test").Mock<(...args: any[]) => any>;
     };
 };
 export default meta;

package/lib/test-setup.js

@@ -57,6 +57,16 @@ vi.mock('@datalayer/jupyter-react', () => ({
         serviceManager: null,
     }),
     JupyterReactTheme: ({ children }) => children,
+    Notebook: () => null,
+    NotebookToolbar: () => null,
+    CellSidebarExtension: class CellSidebarExtension {
+    },
+    CellSidebarButton: () => null,
+    notebookStore: { getState: () => ({}) },
+    DefaultExecutor: class DefaultExecutor {
+    },
+    notebookToolDefinitions: {},
+    notebookToolOperations: {},
     CollaborationProviderBase: class CollaborationProviderBase {
     },
     CollaborationStatus: {

package/lib/types/agents-lifecycle.d.ts

@@ -19,17 +19,17 @@ export type CreateAgentRuntimeRequest = {
     /** Full agent spec payload to propagate to backend services */
     agentSpec?: Record<string, any>;
     /** Account UID (user or organization) charged for runtime costs */
-    billableAccountUid?: string;
+    billingEntityUid?: string;
     /** User account handle used for user home mount path. */
     userAccountHandle?: string;
     /** Account kind charged for runtime costs. */
-    billableAccountType?: 'user' | 'organization' | 'team';
+    billingEntityType?: 'user' | 'organization' | 'team';
     /** Account handle charged for runtime costs. */
-    billableAccountHandle?: string;
+    billingEntityHandle?: string;
     /** Source organization UID for team-billed runtimes. */
-    billableSourceOrganizationUid?: string;
+    billingSourceOrganizationUid?: string;
     /** Source organization handle for team-billed runtimes. */
-    billableSourceOrganizationHandle?: string;
+    billingSourceOrganizationHandle?: string;
     /** Mount account home folder into runtime. */
     mountHomeFolder?: boolean;
     /** Optional volume UID to mount into runtime. */

package/lib/types/agents.d.ts

@@ -53,9 +53,9 @@ export type AgentRuntimeData = {
     token?: string;
     agentSpec?: Agentspec;
     agent_spec_id?: string;
-    billable_account_uid?: string;
-    billable_account_type?: 'user' | 'organization' | 'team';
-    billable_account_handle?: string;
+    billing_entity_uid?: string;
+    billing_entity_type?: 'user' | 'organization' | 'team';
+    billing_entity_handle?: string;
     mount_home_folder?: boolean;
     volume_uid?: string;
     volume_uids?: string[];

package/lib/types/agentspecs.d.ts

@@ -1,6 +1,6 @@
 import type { SkillSpec } from './skills';
 import type { MCPServer, AgentMCPServerToolConfig } from './mcp';
-import type { ToolSpec, FrontendToolSpec } from './tools';
+import type { ToolSpec, FrontendToolSpec, FrontendRenderToolSpec } from './tools';
 import type { AgentTriggerConfig } from './triggers';
 import type { AgentModelConfig } from './models';
 import type { AgentOutputConfig } from './outputs';
@@ -45,6 +45,8 @@ export interface Agentspec {
     disableToolApprovals?: boolean;
     /** Frontend tool sets available to this agent */
     frontendTools?: FrontendToolSpec[];
+    /** Bindings of backend tools to frontend renderers (tool name + css) */
+    frontendRenderTools?: FrontendRenderToolSpec[];
     /** Runtime environment name for this agent */
     environmentName: string;
     /** Icon identifier or URL for the agent */