@datalayer/agent-runtimes 1.0.28 → 1.3.10

package/lib/loop/plugins/agents/plugin.js

@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The Agents plugin: where the agent runs, and the sandbox that comes with it.
+ *
+ * It was the "code sandbox" plugin, and the rename follows what the choice
+ * came to mean. Picking a target used to say only where *code* ran; now it
+ * decides where the *agent* runs too — in this page with the Vercel AI SDK, or
+ * on a server with pydantic-ai — because the location is what a harness can
+ * be, whatever a spec asks for. One control, one answer.
+ *
+ * It owns the sandbox and publishes it as a service; the notebook and document
+ * plugins depend on this plugin rather than on a connection of their own.
+ *
+ * Which agentspec the session runs is a different question, and belongs to
+ * `@datalayer/loop-plugin-agentspecs`.
+ *
+ * @module loop/plugins/agents/plugin
+ */
+import { ServerIcon } from '@primer/octicons-react';
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { LoopAgentBlueprint, LoopAgentGate, LoopCommand, LoopSlots, LoopViewType, } from '../../core';
+import { SandboxStatusBridge } from './SandboxStatusBridge';
+import { DatalayerAgentMount } from './DatalayerAgentMount';
+import { AgentSummaryPanel } from './AgentSummaryPanel';
+import { AnonymousKeyBadge, AnonymousKeyHeaderBadge, } from './AnonymousKeyBadge';
+import { SandboxSelector } from './SandboxSelector';
+import { TeamMemberPicker } from './TeamMemberPicker';
+import { createTeamSelection } from './team';
+import { createSwitchableSandboxService, TARGET_SPECS, targetHasAgent, } from './switchable';
+export const AGENTS_PLUGIN_NAME = '@datalayer/loop-plugin-agents';
+export const AgentsPlugin = definePlugin({
+    name: AGENTS_PLUGIN_NAME,
+    displayName: 'Agents',
+    description: 'Where the agent and its code run: this page, a local server, or a Datalayer runtime.',
+    octicon: 'container',
+    emoji: '\u{1F4E6}',
+    config: { serverUrl: '', target: 'local' },
+    // The capacity plugins' opening: what the Local agent is created from.
+    contributionPoints: [LoopAgentBlueprint],
+    // This plugin owns a sandbox — a kernel, a WebSocket, an execution history.
+    // Rebuilding it on enable would hand every view a fresh service while the
+    // old one kept the connection: toggling the checkbox would silently detach
+    // the notebook from the kernel it is showing.
+    preserveOutput: true,
+    build({ config, reactor }) {
+        // Read once: it decides both what is offered and where the sandbox starts,
+        // and those two must not be able to disagree.
+        const showVariants = config.showAgentVariants ?? true;
+        // Undefined for a workspace with no team, or a team id that names nothing:
+        // a picker is worth having only when there is a choice to make.
+        const team = config.teamId ? createTeamSelection(config.teamId) : undefined;
+        return {
+            team,
+            sandbox: createSwitchableSandboxService({
+                serverUrl: config.serverUrl,
+                // Pinned when there is no choice to make: a host that hid the control
+                // must not be started on a target the reader cannot move off.
+                initialTarget: showVariants ? config.target : 'browser',
+                kernelSource: config.kernelSource,
+                localAgent: config.localAgent,
+                // The capacity plugins' say, read at switch time — lazily, because a
+                // blueprint is a contribution and its plugin may register after this
+                // build runs.
+                blueprint: () => {
+                    const entry = reactor.getContributions(LoopAgentBlueprint)[0]?.value;
+                    if (!entry) {
+                        return undefined;
+                    }
+                    return {
+                        ...(entry.specId ? { agent_spec_id: entry.specId } : null),
+                        ...entry.createPayload,
+                    };
+                },
+            }),
+            // In a slot rather than inside the sandbox view: the sandbox does not
+            // stop existing when someone switches to the chat tab, and neither
+            // should the connection that tracks it.
+            components: [
+                {
+                    slot: LoopSlots.status,
+                    id: 'sandbox-status',
+                    Component: SandboxStatusBridge,
+                },
+                {
+                    // Renders nothing; it launches the Datalayer target's agent and
+                    // reports the runtime. In the status slot because that is where the
+                    // things that keep the workspace informed live. It reads the spec
+                    // from this plugin's config itself, so no closure is needed here,
+                    // and it is loaded lazily so the runtime stack it needs stays out
+                    // of every host's module graph.
+                    slot: LoopSlots.status,
+                    id: 'datalayer-agent',
+                    Component: DatalayerAgentMount,
+                },
+                // In the header, where the reader can see where their code is running
+                // and move it. Left out entirely rather than disabled when the host
+                // gave no choice: a control with one option is furniture.
+                // Beside the sandbox control: one says where the agent runs, the
+                // other which agent it is, and a person reads them together. The
+                // footer under the prompt offers the same choice for a workspace
+                // mounted without a header.
+                ...(team && config.showTeamPicker !== false
+                    ? [
+                        {
+                            slot: LoopSlots.header,
+                            id: 'team-member-picker',
+                            Component: TeamMemberPicker,
+                        },
+                    ]
+                    : []),
+                ...(showVariants
+                    ? [
+                        {
+                            slot: LoopSlots.header,
+                            id: 'sandbox-selector',
+                            Component: SandboxSelector,
+                        },
+                    ]
+                    : []),
+                // What the workspace is talking to. Contributed here rather than drawn
+                // by whichever page embeds the workspace: the agent is chosen inside
+                // it, by this plugin, so this plugin is the only thing that can
+                // describe it without going stale. Left out entirely when the host
+                // has said no — an unmounted component costs nothing.
+                ...(config.showAgentSummary === false
+                    ? []
+                    : [
+                        {
+                            slot: LoopSlots.header,
+                            id: 'agent-summary',
+                            Component: AgentSummaryPanel,
+                        },
+                    ]),
+                // How long a visitor with no account has left. In both headers,
+                // because a host shows at most one of them and the clock must survive
+                // either choice: the landing page used to hide the workspace header
+                // and keep the chat's, and now does the opposite. The badge renders
+                // nothing without an anonymous key, so the workspace that shows both
+                // rows costs a duplicate only in the one anonymous case.
+                {
+                    slot: LoopSlots.chatHeader,
+                    id: 'anonymous-key',
+                    Component: AnonymousKeyBadge,
+                },
+                {
+                    slot: LoopSlots.header,
+                    id: 'anonymous-key-header',
+                    // The ordered variant: in the trailing cluster, just before the
+                    // full-screen icon — see `AnonymousKeyHeaderBadge`.
+                    Component: AnonymousKeyHeaderBadge,
+                },
+            ],
+        };
+    },
+    /**
+     * Tell the chat whether there is anything to talk to.
+     *
+     * Through `ctx.contribute` rather than the declarative `contributes` list,
+     * because the answer depends on the service this plugin *built* — the target
+     * it is currently on. This is the whole of the coupling between the two
+     * plugins: the chat imports no sandbox, the sandbox imports no chat, and the
+     * reactor carries the one fact that has to cross.
+     */
+    register({ contribute, state }) {
+        const sandbox = state.getOutput()?.sandbox;
+        if (!sandbox) {
+            return;
+        }
+        return contribute(LoopAgentGate, {
+            // Read from the workspace, not from the signal: this is called during
+            // the chat's render, and the workspace is what React re-runs it for.
+            check: workspace => {
+                const target = workspace.sandbox.target ??
+                    sandbox.target.peek();
+                return targetHasAgent(target) || TARGET_SPECS[target].noAgentReason;
+            },
+        }, { id: 'sandbox-target' });
+    },
+    contributes: [
+        contribution(LoopViewType, {
+            viewType: 'sandbox',
+            title: 'Sandbox',
+            icon: ServerIcon,
+            order: 40,
+            load: () => import('./SandboxView'),
+        }, { id: 'sandbox', order: 40 }),
+        contribution(LoopCommand, {
+            name: 'sandbox',
+            aliases: ['code-sandbox'],
+            description: 'Show the code sandbox: variant, kernel, Jupyter server',
+            group: 'Capabilities',
+            run: async ({ workspace }) => {
+                workspace.setActiveViewType('sandbox');
+            },
+        }, { id: 'sandbox' }),
+    ],
+});
+export default AgentsPlugin;

package/lib/loop/plugins/agents/service.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The sandbox, owned in one place.
+ *
+ * Nothing else in LOOP talks to a sandbox directly. The notebook and the
+ * document ask this service whether there is a kernel to bind to; the A2UI
+ * plugin asks it what executed. That is the point of a base plugin: one owner
+ * for a fact that several views need, rather than four components each opening
+ * their own connection and each disposing it differently.
+ *
+ * State lives in reactor signals rather than React state, because the owner is
+ * an extension and not a component — a view can unmount without the sandbox
+ * forgetting what it is doing.
+ *
+ * @module loop/plugins/agents/service
+ */
+import { type ReadonlySignal } from '@datalayer/reactor';
+import type { SandboxSnapshot, SandboxState } from '../../core';
+/** Status as the server reports it over the configure WebSocket. */
+export type SandboxStatusPayload = {
+    variant?: string;
+    sandbox_running?: boolean;
+    jupyter_connected?: boolean;
+    jupyter_url?: string;
+    kernel_id?: string;
+    kernel_name?: string;
+    execution_state?: string;
+    is_executing?: boolean;
+    jupyter_token?: string;
+    /**
+     * The agent-runtimes server backing this sandbox, when it is not the host's.
+     *
+     * Reported by whichever plugin allocated it rather than read from a server's
+     * status: a Datalayer runtime brings its own agent, and the workspace has no
+     * other way to learn where it is.
+     */
+    agent_base_url?: string;
+};
+export type SandboxService = {
+    /**
+     * What backs this sandbox.
+     *
+     * `'server'` has an agent-runtimes server behind it and can therefore reach
+     * server-side facilities — the A2UI converter, snapshots. `'browser'` runs in
+     * the page and cannot. A caller that needs one should ask, rather than
+     * discover it from a failed request.
+     */
+    readonly kind: 'server' | 'browser';
+    /** The sandbox as last reported. */
+    readonly snapshot: ReadonlySignal<SandboxSnapshot>;
+    /** Raw status, for views that need more than the summary. */
+    readonly status: ReadonlySignal<SandboxStatusPayload | null>;
+    /** Whether code can be executed right now. */
+    readonly ready: ReadonlySignal<boolean>;
+    /** Feed in a status update (the WebSocket bridge calls this). */
+    report: (status: SandboxStatusPayload | null) => void;
+    /**
+     * Note that a lifecycle operation is under way.
+     *
+     * `reason` belongs with `error` and nowhere else: a failure a reader cannot
+     * see the cause of is one they can only guess at.
+     */
+    setState: (state: SandboxState, reason?: string) => void;
+    /** Execute code in the sandbox and return what it produced. */
+    execute: (code: string) => Promise<SandboxExecution>;
+    /** The most recent execution, for whoever wants to render it. */
+    readonly lastExecution: ReadonlySignal<SandboxExecution | null>;
+    /** Where this service talks to. */
+    readonly serverUrl: string;
+    /**
+     * Start listening to the server's sandbox status.
+     *
+     * Returns a stop function. Plain TypeScript rather than a React hook on
+     * purpose: the owner of a sandbox is an extension, not a component, and
+     * pulling `useSandbox` in here would drag Jupyter and Lumino — which touch
+     * the DOM at import time — into every module that imports this plugin.
+     */
+    connect: (agentId?: string) => () => void;
+};
+/** One execution, in the shape the server returns it. */
+export type SandboxExecution = {
+    code: string;
+    success: boolean;
+    stdout?: string;
+    stderr?: string;
+    error?: string;
+    /** Raw Jupyter outputs, when the variant produces them. */
+    outputs?: unknown[];
+    startedAt: number;
+    finishedAt: number;
+};
+/**
+ * Derive the summary from a raw status.
+ *
+ * A Jupyter sandbox reports readiness as `jupyter_connected` rather than
+ * `sandbox_running`; both mean the same thing to a caller deciding whether it
+ * can execute, so the difference is resolved here rather than in every view.
+ */
+export declare function summarize(status: SandboxStatusPayload | null, fallback: SandboxState): SandboxSnapshot;
+export declare function createServerSandboxService(serverUrl: string): SandboxService;

package/lib/loop/plugins/agents/service.js

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The sandbox, owned in one place.
+ *
+ * Nothing else in LOOP talks to a sandbox directly. The notebook and the
+ * document ask this service whether there is a kernel to bind to; the A2UI
+ * plugin asks it what executed. That is the point of a base plugin: one owner
+ * for a fact that several views need, rather than four components each opening
+ * their own connection and each disposing it differently.
+ *
+ * State lives in reactor signals rather than React state, because the owner is
+ * an extension and not a component — a view can unmount without the sandbox
+ * forgetting what it is doing.
+ *
+ * @module loop/plugins/agents/service
+ */
+import { computed, signal, } from '@datalayer/reactor';
+/**
+ * Derive the summary from a raw status.
+ *
+ * A Jupyter sandbox reports readiness as `jupyter_connected` rather than
+ * `sandbox_running`; both mean the same thing to a caller deciding whether it
+ * can execute, so the difference is resolved here rather than in every view.
+ */
+export function summarize(status, fallback) {
+    if (!status) {
+        return { state: fallback };
+    }
+    /*
+     * Running, by either account.
+     *
+     * `sandbox_running` is the manager's own answer. The second clause is for
+     * the variants reached over a Jupyter server, where the manager can be
+     * between sandboxes while the server itself is perfectly alive — and it has
+     * to name every such variant. It named only `jupyter-server`, so a Datalayer
+     * runtime showed as idle whatever it was doing, which is what left the
+     * notebook and the document with nothing to connect to.
+     */
+    const overJupyter = status.variant === 'jupyter-server' || status.variant === 'datalayer';
+    const running = Boolean(status.sandbox_running) ||
+        (overJupyter && Boolean(status.jupyter_connected));
+    return {
+        state: running ? 'running' : fallback === 'running' ? 'idle' : fallback,
+        variant: status.variant,
+        kernelId: status.kernel_id,
+        jupyterUrl: status.jupyter_url,
+        jupyterToken: status.jupyter_token,
+        agentBaseUrl: status.agent_base_url,
+    };
+}
+/** Reconnect backoff, so a server that is down is not hammered. */
+const RECONNECT_BASE_MS = 1000;
+const RECONNECT_MAX_MS = 30000;
+export function createServerSandboxService(serverUrl) {
+    const status = signal(null);
+    const lifecycle = signal('idle');
+    /* Set beside `lifecycle`, and only meaningful while it says `error`. */
+    const lifecycleReason = signal(undefined);
+    const lastExecution = signal(null);
+    const snapshot = computed(() => ({
+        ...summarize(status.value, lifecycle.value),
+        errorReason: lifecycle.value === 'error' ? lifecycleReason.value : undefined,
+    }));
+    const ready = computed(() => snapshot.value.state === 'running');
+    return {
+        kind: 'server',
+        connect(agentId) {
+            if (typeof WebSocket === 'undefined') {
+                return () => { };
+            }
+            let socket = null;
+            let retry = null;
+            let attempts = 0;
+            let stopped = false;
+            const open = () => {
+                if (stopped) {
+                    return;
+                }
+                const base = serverUrl.replace(/^http/, 'ws');
+                const query = agentId ? `?agent_id=${encodeURIComponent(agentId)}` : '';
+                socket = new WebSocket(`${base}/api/v1/configure/sandbox/ws${query}`);
+                socket.onopen = () => {
+                    attempts = 0;
+                };
+                socket.onmessage = event => {
+                    try {
+                        status.value = JSON.parse(String(event.data));
+                    }
+                    catch {
+                        // A message we cannot read is not a reason to drop the connection.
+                    }
+                };
+                socket.onclose = () => {
+                    if (stopped) {
+                        return;
+                    }
+                    status.value = null;
+                    attempts += 1;
+                    const delay = Math.min(RECONNECT_BASE_MS * 2 ** (attempts - 1), RECONNECT_MAX_MS);
+                    retry = setTimeout(open, delay);
+                };
+            };
+            open();
+            return () => {
+                stopped = true;
+                if (retry) {
+                    clearTimeout(retry);
+                }
+                socket?.close();
+                socket = null;
+            };
+        },
+        snapshot,
+        status,
+        ready,
+        lastExecution,
+        serverUrl,
+        report(next) {
+            status.value = next;
+        },
+        setState(state, reason) {
+            lifecycle.value = state;
+            // Cleared on any other state, so a reason cannot outlive the failure it
+            // describes and reappear beside a healthy sandbox.
+            lifecycleReason.value = state === 'error' ? reason : undefined;
+        },
+        async execute(code) {
+            const startedAt = Date.now();
+            try {
+                const response = await fetch(`${serverUrl}/api/v1/sandbox/execute`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({ code }),
+                });
+                const payload = response.ok ? await response.json() : null;
+                const execution = {
+                    code,
+                    success: response.ok && !payload?.error,
+                    stdout: payload?.stdout,
+                    stderr: payload?.stderr,
+                    error: response.ok
+                        ? payload?.error
+                        : `Execution failed: ${response.status}`,
+                    outputs: payload?.outputs,
+                    startedAt,
+                    finishedAt: Date.now(),
+                };
+                lastExecution.value = execution;
+                return execution;
+            }
+            catch (error) {
+                const execution = {
+                    code,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    startedAt,
+                    finishedAt: Date.now(),
+                };
+                lastExecution.value = execution;
+                return execution;
+            }
+        },
+    };
+}

package/lib/loop/plugins/agents/specSubagents.d.ts

@@ -0,0 +1,18 @@
+/**
+ * An agentspec's own subagents, as agents the in-page loop can hand work to.
+ *
+ * A spec such as `example-subagents` declares a researcher and a writer under
+ * `subagents`; on a server the pydantic-ai harness turns those into delegation
+ * tools. In the page the loop turns with the Vercel AI SDK, and until now it
+ * read subagents from a *team* only — so the same spec, run in the browser,
+ * had nobody to delegate to and the example that exists to show delegation
+ * showed none. This is the spec's list in the shape the browser runtime wants,
+ * with a general-purpose helper when the spec asks for one.
+ *
+ * @module loop/plugins/agents/specSubagents
+ */
+import type { BrowserSubagent } from '../../../runtimes/browser';
+import type { Agentspec } from '../../../types';
+/** The subagents an agentspec declares, or none. */
+export declare function specSubagents(spec: Agentspec | undefined): BrowserSubagent[];
+export default specSubagents;

package/lib/loop/plugins/agents/specSubagents.js

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { getAgentspecs } from '../../../specs/agents';
+const GENERAL_PURPOSE = {
+    name: 'general-purpose',
+    description: 'A capable generalist for a task none of the specialists covers: research, ' +
+        'reasoning, drafting, checking.',
+    instructions: 'You are a capable general-purpose assistant. Carry out the task you are ' +
+        'given completely and report the result plainly, saying what you could not do.',
+};
+/** The subagents an agentspec declares, or none. */
+export function specSubagents(spec) {
+    const config = spec?.subagents;
+    if (!config) {
+        return [];
+    }
+    const own = (config.subagents ?? []).map((entry) => {
+        // A `ref` names an agentspec the subagent *is*: its prompt, model and
+        // icon come from there, and the entry's own words win where it has any.
+        const referenced = entry.ref ? getAgentspecs(entry.ref) : undefined;
+        return {
+            name: entry.name,
+            description: entry.description || referenced?.description || entry.name,
+            instructions: entry.instructions ?? referenced?.systemPrompt,
+            model: entry.model ?? referenced?.model ?? config.defaultModel,
+            icon: referenced?.icon,
+        };
+    });
+    return config.includeGeneralPurpose ? [...own, GENERAL_PURPOSE] : own;
+}
+export default specSubagents;

package/lib/loop/plugins/agents/switchable.d.ts

@@ -0,0 +1,107 @@
+/**
+ * One sandbox, four places it can run.
+ *
+ * `browser` is Pyodide in the page. The other three are server-backed and
+ * differ in what the server is asked to run: a Jupyter server beside you, an
+ * anonymous one anybody can reach, or a Datalayer runtime. A workspace should
+ * not care which; the notebook binds to whatever kernel is there, and the
+ * switch is one control.
+ *
+ * Local and `datalayer` bring an agent with them. Browser and anonymous
+ * Jupyter are sandbox-only, which is why `hasAgent` is part of the target's
+ * description rather than something each caller works out.
+ *
+ * The composite owns both implementations and delegates to the active one, so
+ * switching is a real swap rather than a flag: the old backing is disconnected
+ * before the new one starts, and every signal a view reads follows across.
+ *
+ * @module loop/plugins/agents/switchable
+ */
+import { type ReadonlySignal } from '@datalayer/reactor';
+import { type ServiceManagerSource } from './browserService';
+import { type SandboxService } from './service';
+/** Where the sandbox runs. */
+export type SandboxTarget = 'browser' | 'local' | 'jupyter' | 'datalayer';
+/**
+ * The anonymous Jupyter server the `jupyter` target uses.
+ *
+ * The same one the jupyter-react examples point at: a real server, reachable
+ * without an account, so a workspace can execute code with nothing installed
+ * and nobody signed in.
+ */
+export declare const ANONYMOUS_JUPYTER_URL = "https://prod1.datalayer.run/api/jupyter-server";
+export declare const ANONYMOUS_JUPYTER_TOKEN = "60c1661cc408f978c309d04157af55c9588ff9557c9380e4fb50785750703da6";
+/** What a target is, and what it can do. */
+export type SandboxTargetSpec = {
+    label: string;
+    hint: string;
+    /**
+     * Whether an agent runs alongside the sandbox.
+     *
+     * True in the browser as well now, though not the same kind: there the loop
+     * turns in the page rather than on a server. {@link targetRunsAgentInPage}
+     * is the question a chat asks to know which of the two it is talking to.
+     */
+    hasAgent: boolean;
+    /** Why there is nothing to chat with. Empty when there is. */
+    noAgentReason: string;
+    /** What the server is asked to run. Absent for the in-page target. */
+    configure?: {
+        variant: string;
+        jupyter_url?: string;
+        jupyter_token?: string;
+    };
+};
+/** The four, in the order the control shows them: nearest first. */
+export declare const SANDBOX_TARGETS: readonly SandboxTarget[];
+export declare const TARGET_SPECS: Record<SandboxTarget, SandboxTargetSpec>;
+/** Whether an agent runs on this target — the question the chat asks. */
+export declare function targetHasAgent(target: SandboxTarget): boolean;
+/**
+ * Whether that agent's loop turns in this page rather than on a server.
+ *
+ * The other half of {@link targetHasAgent}, and the one that decides which
+ * protocol a chat speaks: an in-page agent is reached by calling it, not by
+ * addressing it.
+ */
+export declare function targetRunsAgentInPage(target: SandboxTarget): boolean;
+export type SwitchableSandboxService = SandboxService & {
+    /** Where the sandbox currently runs. */
+    readonly target: ReadonlySignal<SandboxTarget>;
+    /** Move it. Disconnects the old backing before starting the new one. */
+    setTarget: (target: SandboxTarget) => Promise<void>;
+    /** The in-browser services, when the browser is the active target. */
+    getServiceManager: () => unknown | null;
+};
+export type SwitchableConfig = {
+    serverUrl: string;
+    initialTarget?: SandboxTarget;
+    /**
+     * Agent to create when Local is selected.
+     *
+     * A local agent owns its Jupyter sandbox. Supplying this payload makes the
+     * Local transition create/reuse that agent instead of starting the server's
+     * unrelated global sandbox.
+     */
+    localAgent?: {
+        createPayload: Record<string, unknown>;
+    };
+    /**
+     * The capacity plugins' account of the agent, read at switch time.
+     *
+     * A lazy getter rather than a value: blueprints are contributions, and the
+     * plugin that contributes one may register after this service is built.
+     * When it returns a payload it wins over `localAgent` — a mounted capacity
+     * plugin is the more specific statement about what this workspace runs.
+     */
+    blueprint?: () => Record<string, unknown> | undefined;
+    /**
+     * Where the in-page kernel comes from.
+     *
+     * Defaults to JupyterLite. A JupyterLab host supplies the application's own
+     * services instead, so the agent runs in the kernel the user is already
+     * looking at rather than a second one beside it.
+     */
+    kernelSource?: ServiceManagerSource;
+};
+export declare function createSwitchableSandboxService({ serverUrl, initialTarget, kernelSource, localAgent, blueprint, }: SwitchableConfig): SwitchableSandboxService;