@datalayer/agent-runtimes 1.0.28 → 1.3.10

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

@@ -0,0 +1,10 @@
+import type { TeamSelection } from './team';
+/**
+ * The team selection, or `undefined`.
+ *
+ * Optional by design rather than by oversight: most workspaces run a single
+ * agent and have no team at all, and a hook that threw for them would make
+ * teams a requirement instead of a feature.
+ */
+export declare function useOptionalTeamSelection(): TeamSelection | undefined;
+export default useOptionalTeamSelection;

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Reading the team selection from anywhere in the workspace.
+ *
+ * The same shape as `useSandboxService`: the plugin publishes it as output,
+ * and whoever needs it asks the reactor rather than being handed it down a
+ * prop chain that would have to pass through views that do not care.
+ *
+ * @module loop/plugins/agents/useTeamSelection
+ */
+import { useReactorPlatform } from '@datalayer/reactor/react';
+import { AGENTS_PLUGIN_NAME } from './plugin';
+/**
+ * The team selection, or `undefined`.
+ *
+ * Optional by design rather than by oversight: most workspaces run a single
+ * agent and have no team at all, and a hook that threw for them would make
+ * teams a requirement instead of a feature.
+ */
+export function useOptionalTeamSelection() {
+    const reactor = useReactorPlatform();
+    return reactor.getOutput(AGENTS_PLUGIN_NAME)?.team;
+}
+export default useOptionalTeamSelection;

package/lib/loop/plugins/agentspecs/AgentspecPicker.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The agent picker: which specialist this session is talking to.
+ *
+ * The browser half of `/agents use`. Both go through the same endpoint, which
+ * goes through `configure-from-spec` — one way to reconfigure a running agent
+ * rather than two that can disagree.
+ *
+ * @module loop/plugins/agents/AgentspecPicker
+ */
+import type { JSX } from 'react';
+import type { LoopWorkspaceContext } from '../../core';
+export declare function AgentspecPicker({ workspace, }: {
+    workspace: LoopWorkspaceContext;
+}): JSX.Element | null;
+export default AgentspecPicker;

package/lib/loop/plugins/agentspecs/AgentspecPicker.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from 'react';
+import { ActionList, ActionMenu, Box, Spinner } from '@primer/react';
+import { getAgentspecs } from '../../../specs/agents';
+export function AgentspecPicker({ workspace, }) {
+    const [agents, setAgents] = useState([]);
+    const [switching, setSwitching] = useState(false);
+    const [active, setActive] = useState(workspace.agentId);
+    // Re-read when the sandbox moves, not only once on mount.
+    //
+    // Choosing a target can *create* an agent — the Local target brings up the
+    // agent whose own Jupyter sandbox backs it — and a list fetched before that
+    // happened does not contain it. The indicator then names an agent that is no
+    // longer the one in use, which reads as the switch having done nothing.
+    const sandboxTarget = workspace.sandbox.target;
+    const sandboxState = workspace.sandbox.state;
+    useEffect(() => {
+        let cancelled = false;
+        void fetch(`${workspace.serverUrl}/api/v1/agents`)
+            .then(response => (response.ok ? response.json() : { agents: [] }))
+            .then(payload => {
+            if (!cancelled) {
+                setAgents(payload.agents ?? []);
+            }
+        })
+            .catch(() => {
+            // A picker that cannot list agents shows the current one and no menu,
+            // which is more useful than an error where a name should be.
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [workspace.serverUrl, sandboxTarget, sandboxState]);
+    // The workspace can be pointed at a different agent while this is mounted —
+    // the host re-renders it with a new `agentId` — and a name captured once at
+    // mount would go on showing the old one.
+    useEffect(() => {
+        setActive(workspace.agentId);
+    }, [workspace.agentId]);
+    const choose = useCallback(async (agentId) => {
+        setSwitching(true);
+        try {
+            const response = await fetch(`${workspace.serverUrl}/api/v1/loop/sessions/${encodeURIComponent(workspace.conversationId || workspace.agentId || 'session')}/agent`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ agent_id: agentId }),
+            });
+            if (response.ok) {
+                // The workspace, not just this control. Everything that follows the
+                // agent — the chat's endpoint, the sandbox connection, the
+                // notebook's id — reads it from there, so setting only the local
+                // label changed the name in the header and nothing else.
+                setActive(agentId);
+                workspace.setAgentId(agentId);
+            }
+        }
+        finally {
+            setSwitching(false);
+        }
+    }, [
+        workspace.agentId,
+        workspace.conversationId,
+        workspace.serverUrl,
+        workspace.setAgentId,
+    ]);
+    const current = agents.find(agent => agent.id === active);
+    /*
+     * Named, never the raw id.
+     *
+     * The active agent is not always in the server's catalogue — the Loop
+     * Shell runs `loop-shell`, created locally from a spec the server never
+     * listed — and the fallback used to be the bare id, printed beside an
+     * agent summary that had just named the same agent properly. The local
+     * spec catalogue knows the name; the id is the last resort, not the first.
+     */
+    const label = current?.name || getAgentspecs(active)?.name || active || 'Agent';
+    if (agents.length === 0) {
+        /*
+         * Nothing, rather than the raw id.
+    
+         * With no catalogue to choose from — an in-page agent has no server to
+         * ask — this used to print the bare agent id ("loop-shell") beside the
+         * agent summary, which already names the agent properly. A picker with
+         * nothing to pick is furniture, and a spec id is not a label.
+         */
+        return null;
+    }
+    return (_jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 1 }, children: [switching ? _jsx(Spinner, { size: "small" }) : null, _jsxs(ActionMenu, { children: [_jsxs(ActionMenu.Button, { variant: "invisible", size: "small", children: [current?.emoji ? `${current.emoji} ` : '', label] }), _jsx(ActionMenu.Overlay, { width: "medium", children: _jsx(ActionList, { selectionVariant: "single", children: agents.map(agent => (_jsxs(ActionList.Item, { selected: agent.id === active, onSelect: () => void choose(agent.id), children: [agent.emoji ? `${agent.emoji} ` : '', agent.name || agent.id, agent.description ? (_jsx(ActionList.Description, { variant: "block", children: agent.description })) : null] }, agent.id))) }) })] })] }));
+}
+export default AgentspecPicker;

package/lib/loop/plugins/agentspecs/index.d.ts

@@ -0,0 +1,6 @@
+import type { ReactorSlotComponent } from '@datalayer/reactor/react';
+export declare const AGENTSPECS_PLUGIN_NAME = "@datalayer/loop-plugin-agentspecs";
+export declare const AgentspecsPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, {
+    components: ReactorSlotComponent[];
+}>;
+export default AgentspecsPlugin;

package/lib/loop/plugins/agentspecs/index.js

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-agentspecs` — which agentspec the session runs.
+ *
+ * The other half of the question `@datalayer/loop-plugin-agents` answers: that
+ * one says *where* the agent runs, this one says *what* it is.
+ *
+ * @module loop/plugins/agents
+ */
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { LoopCommand, LoopSlots } from '../../core';
+import { AgentspecPicker } from './AgentspecPicker';
+export const AGENTSPECS_PLUGIN_NAME = '@datalayer/loop-plugin-agentspecs';
+export const AgentspecsPlugin = definePlugin({
+    name: AGENTSPECS_PLUGIN_NAME,
+    displayName: 'Agentspecs',
+    description: 'Pick the agentspec this session runs.',
+    octicon: 'people',
+    emoji: '\u{1F916}',
+    build() {
+        return {
+            components: [
+                {
+                    slot: LoopSlots.header,
+                    id: 'agent-picker',
+                    Component: AgentspecPicker,
+                },
+            ],
+        };
+    },
+    contributes: [
+        contribution(LoopCommand, {
+            name: 'agents',
+            aliases: ['agent'],
+            description: 'Switch the agent this session is using',
+            group: 'Agents',
+            keybinding: 'Mod+Alt+A',
+            args: [{ name: 'agent-id', description: 'Agent to switch to' }],
+            run: async ({ workspace, argv }) => {
+                const agentId = argv.trim();
+                if (!agentId) {
+                    return {
+                        content: 'Pick an agent from the header, or /agents <id>.',
+                    };
+                }
+                const response = await fetch(`${workspace.serverUrl}/api/v1/loop/sessions/${encodeURIComponent(workspace.conversationId || workspace.agentId || 'session')}/agent`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({ agent_id: agentId }),
+                });
+                if (!response.ok) {
+                    return { content: `Unknown agent: ${agentId}` };
+                }
+                const payload = await response.json();
+                return { content: `Now using ${payload.name ?? payload.agent_id}.` };
+            },
+        }, { id: 'agents' }),
+    ],
+});
+export default AgentspecsPlugin;

package/lib/loop/plugins/chat/ChatView.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The chat view: a conversation, a prompt, and whatever editors plugins add.
+ *
+ * The prompt lives here rather than in the shell. It is the chat's input — a
+ * workspace with no chat plugin should have no input box — and putting it in
+ * the base meant every workspace carried one whether or not anything answered
+ * it. Slash commands still work, because dispatch stayed with the workspace:
+ * `workspace.submit` sees every command every plugin contributed, which no
+ * single plugin can.
+ *
+ * The editors beside the conversation are contributed, not built in. A notebook
+ * and a document are what the conversation is *about*, so they belong next to
+ * the reply rather than one tab away — and this view holds the point they
+ * arrive through without knowing what either of them is.
+ *
+ * @module loop/plugins/chat/ChatView
+ */
+import type { JSX } from 'react';
+import { type LoopViewProps } from '../../core';
+export default function ChatView({ workspace }: LoopViewProps): JSX.Element;