@datalayer/agent-runtimes 1.3.54 → 1.3.56

package/lib/chat/prompt/menus/ToolsMenu.d.ts

@@ -1,5 +1,5 @@
 import type { BuiltinTool, MCPServerConfig } from '../../../types';
-export declare function ToolsMenu({ codemodeEnabled, onToggleCodemode, mcpServers, enabledMcpTools, enabledMcpToolCount, onToggleMcpTool, onToggleAllMcpServerTools, approvedMcpTools, onToggleMcpToolApproval, availableTools, }: {
+export declare function ToolsMenu({ codemodeEnabled, onToggleCodemode, mcpServers, enabledMcpTools, enabledMcpToolCount, onToggleMcpTool, onToggleAllMcpServerTools, approvedMcpTools, onToggleMcpToolApproval, availableTools, availableFrontendTools, }: {
     codemodeEnabled: boolean;
     onToggleCodemode?: (enabled: boolean) => void | Promise<void>;
     mcpServers: MCPServerConfig[];
@@ -10,4 +10,6 @@ export declare function ToolsMenu({ codemodeEnabled, onToggleCodemode, mcpServer
     approvedMcpTools: Map<string, Set<string>>;
     onToggleMcpToolApproval: (serverId: string, toolName: string) => void;
     availableTools: BuiltinTool[];
+    /** The frontend tools: the ones the page runs for the agent. */
+    availableFrontendTools?: BuiltinTool[];
 }): import("react").JSX.Element;

package/lib/chat/prompt/menus/ToolsMenu.js

@@ -4,14 +4,20 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * Distributed under the terms of the Modified BSD License.
  */
 /**
- * What the agent may call: builtin tools, MCP servers, and codemode.
+ * What the agent may call: the runtime's tools, the frontend tools (the ones
+ * the page runs), MCP servers, and codemode — each drawn with its mark.
  *
  * @module chat/prompt/menus/ToolsMenu
  */
 import { Text, Button, ActionMenu, ActionList, ToggleSwitch, Tooltip, } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
 import { ToolsIcon } from '@primer/octicons-react';
-export function ToolsMenu({ codemodeEnabled, onToggleCodemode, mcpServers, enabledMcpTools, enabledMcpToolCount, onToggleMcpTool, onToggleAllMcpServerTools, approvedMcpTools, onToggleMcpToolApproval, availableTools, }) {
+import { SpecMark, hasMark, marksOfFrontendTool, marksOfMcpServer, marksOfRuntimeTool, } from '../../marks';
+/** A tool's mark, as the leading visual of its row. */
+function LeadingMark({ marks }) {
+    return hasMark(marks) ? (_jsx(ActionList.LeadingVisual, { children: _jsx(SpecMark, { icon: marks.icon, emoji: marks.emoji, size: 16 }) })) : null;
+}
+export function ToolsMenu({ codemodeEnabled, onToggleCodemode, mcpServers, enabledMcpTools, enabledMcpToolCount, onToggleMcpTool, onToggleAllMcpServerTools, approvedMcpTools, onToggleMcpToolApproval, availableTools, availableFrontendTools = [], }) {
     const hasUsableMcpServers = mcpServers.some(server => server.isAvailable);
     /*
      * A count, not a word.
@@ -23,12 +29,17 @@ export function ToolsMenu({ codemodeEnabled, onToggleCodemode, mcpServers, enabl
      */
     const summary = [
         `${availableTools.length} tool${availableTools.length === 1 ? '' : 's'}`,
+        availableFrontendTools.length > 0
+            ? `${availableFrontendTools.length} frontend tool${availableFrontendTools.length === 1 ? '' : 's'}`
+            : null,
         enabledMcpToolCount > 0 ? `${enabledMcpToolCount} MCP enabled` : null,
         hasUsableMcpServers ? null : 'no MCP server available',
     ]
         .filter(Boolean)
         .join(' · ');
-    return (_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Anchor, { children: _jsx(Tooltip, { text: `Tools — ${summary}`, direction: "n", children: _jsx(Button, { type: "button", variant: "invisible", size: "small", "aria-label": `Tools — ${summary}`, leadingVisual: ToolsIcon, children: _jsx(Text, { sx: { fontSize: 0 }, children: availableTools.length + enabledMcpToolCount }) }) }) }), _jsx(ActionMenu.Overlay, { side: "outside-top", align: "start", width: "large", children: _jsx(Box, { sx: { maxHeight: '60vh', overflowY: 'auto' }, children: _jsxs(ActionList, { children: [_jsx(ActionList.Group, { title: "Codemode", children: _jsxs(Box, { sx: {
+    return (_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Anchor, { children: _jsx(Tooltip, { text: `Tools — ${summary}`, direction: "n", children: _jsx(Button, { type: "button", variant: "invisible", size: "small", "aria-label": `Tools — ${summary}`, leadingVisual: ToolsIcon, children: _jsx(Text, { sx: { fontSize: 0 }, children: availableTools.length +
+                                availableFrontendTools.length +
+                                enabledMcpToolCount }) }) }) }), _jsx(ActionMenu.Overlay, { side: "outside-top", align: "start", width: "large", children: _jsx(Box, { sx: { maxHeight: '60vh', overflowY: 'auto' }, children: _jsxs(ActionList, { children: [_jsx(ActionList.Group, { title: "Codemode", children: _jsxs(Box, { sx: {
                                         display: 'flex',
                                         alignItems: 'center',
                                         justifyContent: 'space-between',
@@ -43,12 +54,13 @@ export function ToolsMenu({ codemodeEnabled, onToggleCodemode, mcpServers, enabl
                                                 if (onToggleCodemode) {
                                                     void onToggleCodemode(!codemodeEnabled);
                                                 }
-                                            }, "aria-labelledby": "toggle-codemode" })] }) }), availableTools.length > 0 ? (_jsx(ActionList.Group, { title: "Tools", children: availableTools.map(tool => (_jsx(ActionList.Item, { disabled: true, children: tool.name }, tool.id))) })) : null, mcpServers.length > 0 && hasUsableMcpServers ? (mcpServers.map(server => {
+                                            }, "aria-labelledby": "toggle-codemode" })] }) }), availableTools.length > 0 ? (_jsx(ActionList.Group, { title: "Tools", children: availableTools.map(tool => (_jsxs(ActionList.Item, { disabled: true, children: [_jsx(LeadingMark, { marks: marksOfRuntimeTool(tool.name) }), tool.name] }, tool.id))) })) : null, availableFrontendTools.length > 0 ? (_jsx(ActionList.Group, { title: "Frontend tools", children: availableFrontendTools.map(tool => (_jsxs(ActionList.Item, { disabled: true, children: [_jsx(LeadingMark, { marks: marksOfFrontendTool(tool.name) }), tool.name] }, tool.id))) })) : null, mcpServers.length > 0 && hasUsableMcpServers ? (mcpServers.map(server => {
                                 const serverTools = enabledMcpTools.get(server.id);
                                 const allToolNames = server.tools.map(t => t.name);
                                 const enabledCount = serverTools?.size ?? 0;
                                 const allEnabled = enabledCount === allToolNames.length &&
                                     allToolNames.length > 0;
+                                const serverMarks = marksOfMcpServer(server);
                                 return (_jsxs(ActionList.Group, { title: `${server.name}${server.isAvailable ? '' : ' (unavailable)'}`, children: [server.isAvailable && server.tools.length > 0 && (_jsxs(Box, { sx: {
                                                 display: 'flex',
                                                 alignItems: 'center',
@@ -57,11 +69,15 @@ export function ToolsMenu({ codemodeEnabled, onToggleCodemode, mcpServers, enabl
                                                 py: 2,
                                                 borderBottom: '1px solid',
                                                 borderColor: 'border.muted',
-                                            }, children: [_jsxs(Text, { id: `toggle-all-${server.id}`, sx: {
-                                                        fontSize: 0,
-                                                        fontWeight: 'semibold',
-                                                        color: 'fg.muted',
-                                                    }, children: ["Enable all (", enabledCount, "/", allToolNames.length, ")"] }), _jsx(ToggleSwitch, { size: "small", checked: allEnabled, onClick: () => onToggleAllMcpServerTools(server.id, allToolNames, !allEnabled), "aria-labelledby": `toggle-all-${server.id}` })] })), server.isAvailable && server.tools.length > 0 ? (server.tools.map(tool => {
+                                            }, children: [_jsxs(Box, { sx: {
+                                                        display: 'flex',
+                                                        alignItems: 'center',
+                                                        gap: 2,
+                                                    }, children: [hasMark(serverMarks) && (_jsx(SpecMark, { icon: serverMarks.icon, emoji: serverMarks.emoji, size: 16 })), _jsxs(Text, { id: `toggle-all-${server.id}`, sx: {
+                                                                fontSize: 0,
+                                                                fontWeight: 'semibold',
+                                                                color: 'fg.muted',
+                                                            }, children: ["Enable all (", enabledCount, "/", allToolNames.length, ")"] })] }), _jsx(ToggleSwitch, { size: "small", checked: allEnabled, onClick: () => onToggleAllMcpServerTools(server.id, allToolNames, !allEnabled), "aria-labelledby": `toggle-all-${server.id}` })] })), server.isAvailable && server.tools.length > 0 ? (server.tools.map(tool => {
                                             const isEnabled = serverTools?.has(tool.name) ?? false;
                                             const serverApproved = approvedMcpTools.get(server.id);
                                             // Tools default to NOT approved — user must explicitly

package/lib/chat/tools/ToolCallDisplay.d.ts

@@ -6,6 +6,7 @@
  */
 import React from 'react';
 import type { CodeError, ExecutionResult, DisplayToolCallStatus } from '../../types';
+import { type Marks } from '../marks';
 /**
  * Error type classification for display purposes
  */
@@ -43,6 +44,12 @@ export interface ToolCallDisplayProps {
     onDeny?: () => void;
     /** Loading state for approval actions */
     approvalLoading?: boolean;
+    /**
+     * The marks of whoever the tool belongs to — its MCP server, skill,
+     * frontend tool set or runtime tool spec — drawn before its name: the
+     * icon, else the emoji, else nothing.
+     */
+    marks?: Marks | null;
 }
 /**
  * ToolCallDisplay component - Default display for tool calls in chat
@@ -54,5 +61,5 @@ export interface ToolCallDisplayProps {
  * - Color-coded status indicators
  * - Rich error display distinguishing execution errors from code errors
  */
-export declare function ToolCallDisplay({ toolCallId, toolName, args, result, status, error, executionResult, codeError, exitCode, executionError, approvalRequired, approvalState, approvalDecisionSource, onApprove, onDeny, approvalLoading, }: ToolCallDisplayProps): React.JSX.Element;
+export declare function ToolCallDisplay({ toolCallId, toolName, args, result, status, error, executionResult, codeError, exitCode, executionError, approvalRequired, approvalState, approvalDecisionSource, onApprove, onDeny, approvalLoading, marks, }: ToolCallDisplayProps): React.JSX.Element;
 export default ToolCallDisplay;

package/lib/chat/tools/ToolCallDisplay.js

@@ -13,6 +13,7 @@ import { useEffect, useState } from 'react';
 import { Button, Text } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
 import { ChevronDownIcon, ChevronRightIcon, ToolsIcon, CheckCircleIcon, XCircleIcon, ClockIcon, AlertIcon, } from '@primer/octicons-react';
+import { SpecMark, hasMark } from '../marks';
 /**
  * Get status icon and color based on tool call status
  */
@@ -124,7 +125,7 @@ function getArgsSummary(args) {
  * - Color-coded status indicators
  * - Rich error display distinguishing execution errors from code errors
  */
-export function ToolCallDisplay({ toolCallId, toolName, args, result, status, error, executionResult, codeError, exitCode, executionError, approvalRequired = false, approvalState, approvalDecisionSource, onApprove, onDeny, approvalLoading = false, }) {
+export function ToolCallDisplay({ toolCallId, toolName, args, result, status, error, executionResult, codeError, exitCode, executionError, approvalRequired = false, approvalState, approvalDecisionSource, onApprove, onDeny, approvalLoading = false, marks, }) {
     const [isExpanded, setIsExpanded] = useState(false);
     // Determine effective exit code from props or execution result
     const effectiveExitCode = exitCode ?? executionResult?.exit_code;
@@ -189,7 +190,7 @@ export function ToolCallDisplay({ toolCallId, toolName, args, result, status, er
                     '&:hover': {
                         backgroundColor: 'neutral.muted',
                     },
-                }, children: [_jsx(Box, { sx: { color: 'fg.muted', flexShrink: 0 }, children: isExpanded ? (_jsx(ChevronDownIcon, { size: 16 })) : (_jsx(ChevronRightIcon, { size: 16 })) }), _jsx(Box, { sx: { color: 'fg.muted', flexShrink: 0 }, children: _jsx(ToolsIcon, { size: 16 }) }), _jsx(Text, { sx: {
+                }, children: [_jsx(Box, { sx: { color: 'fg.muted', flexShrink: 0 }, children: isExpanded ? (_jsx(ChevronDownIcon, { size: 16 })) : (_jsx(ChevronRightIcon, { size: 16 })) }), hasMark(marks) && (_jsx(Box, { sx: { color: 'fg.muted', flexShrink: 0, display: 'flex' }, children: _jsx(SpecMark, { icon: marks?.icon, emoji: marks?.emoji, size: 16 }) })), _jsx(Text, { sx: {
                             fontWeight: 'semibold',
                             fontSize: 1,
                             color: 'fg.default',

package/lib/examples/AgentStrategyExample.d.ts

@@ -0,0 +1,12 @@
+import { ServiceManager } from '@jupyterlab/services';
+interface AgentStrategyExampleInnerProps {
+    serviceManager?: ServiceManager.IManager;
+}
+export declare function AgentStrategyExampleInner({ serviceManager, }: AgentStrategyExampleInnerProps): import("react").JSX.Element;
+/**
+ * Main example component with Jupyter provider wrapper.
+ */
+export declare function AgentStrategyExample({ serviceManager, }: {
+    serviceManager?: ServiceManager.IManager;
+}): import("react").JSX.Element;
+export default AgentStrategyExample;

package/lib/examples/{AgentLoopExample.js → AgentStrategyExample.js}

@@ -4,27 +4,27 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * Distributed under the terms of the Modified BSD License.
  */
 /**
- * AgentLoopExample - Define and launch an agent execution *loop*.
+ * AgentStrategyExample - Define and launch an agent reasoning *strategy*.
  *
- * This example demonstrates the "loop" paradigm (observe → think → act →
+ * This example demonstrates the control-loop paradigm (observe → think → act →
  * evaluate) instead of one-shot prompting. It is fully driven by the generic
- * loop specifications defined in agentspecs (`src/specs/loops.ts`):
+ * strategy specifications defined in agentspecs (`src/specs/strategies.ts`):
  *
- * - Pick any loop spec (Data Analysis, Plan/Execute/Critic, OODA,
- *   Human-in-the-Loop). The list is read from the loop catalogue, so adding a
- *   new YAML loop spec automatically makes it available here.
- * - The agent's system prompt is composed generically from the selected loop's
+ * - Pick any strategy spec (Data Analysis, Plan/Execute/Critic, OODA,
+ *   Human-in-the-Loop). The list is read from the strategy catalogue, so adding a
+ *   new YAML strategy spec automatically makes it available here.
+ * - The agent's system prompt is composed generically from the selected strategy's
  *   objective, phases, constraints, termination policy and human settings — no
- *   loop-specific code.
- * - The agent then runs the loop against a live Jupyter notebook, where the
- *   loop state (dataframes, charts, intermediate results) lives outside the
+ *   strategy-specific code.
+ * - The agent then runs the strategy against a live Jupyter notebook, where the
+ *   strategy state (dataframes, charts, intermediate results) lives outside the
  *   model so each iteration stays small and focused.
  *
  * To run this example:
  * 1. Start the agent-runtimes server.
  * 2. Select this example from the header dropdown (Agent group).
  *
- * @module examples/AgentLoopExample
+ * @module examples/AgentStrategyExample
  */
 import { useMemo, useState } from 'react';
 import { Box } from '@datalayer/primer-addons';
@@ -32,40 +32,40 @@ import { Notebook } from '@datalayer/jupyter-react';
 import { useNotebookTools } from '../tools/adapters/agent-runtimes/notebookHooks';
 import { ThemedJupyterProvider, ThemedProvider } from './utils/themedProvider';
 import { ChatSidebar } from '../chat';
-import { listLoops, getLoop, DEFAULT_LOOP } from '../specs';
+import { listStrategies, getStrategy, DEFAULT_STRATEGY } from '../specs';
 import { useExampleJupyterAgent } from './hooks/useExampleJupyterAgent';
 import MatplotlibNotebook from './utils/notebooks/Matplotlib.ipynb.json';
 import { ExampleNotebookToolbar } from './utils/notebookToolbarItems';
 // Fixed notebook ID
-const NOTEBOOK_ID = 'agent-loop-example';
-// Use the imported Matplotlib notebook as the working surface for the loop.
+const NOTEBOOK_ID = 'agent-strategy-example';
+// Use the imported Matplotlib notebook as the working surface for the strategy.
 const NOTEBOOK_CONTENT = MatplotlibNotebook;
 // Default configuration
-const DEFAULT_AGENT_ID = import.meta.env.VITE_AGENT_ID || 'loop-agent-runtime-example';
+const DEFAULT_AGENT_ID = import.meta.env.VITE_AGENT_ID || 'strategy-agent-runtime-example';
 /**
- * Compose an agent system prompt generically from a loop specification.
+ * Compose an agent system prompt generically from a strategy specification.
  *
- * This is intentionally spec-driven: every field comes from the loop YAML, so
- * the same code drives any loop (data analysis, plan/execute/critic, OODA, ...).
+ * This is intentionally spec-driven: every field comes from the strategy YAML, so
+ * the same code drives any strategy (data analysis, plan/execute/critic, OODA, ...).
  */
-function buildLoopSystemPrompt(loop) {
+function buildStrategySystemPrompt(strategy) {
     const lines = [];
-    lines.push(`You are an agent that operates as a control LOOP rather than answering in a single prompt.`);
-    lines.push(`Loop: ${loop.name} (${loop.strategy}).`);
-    if (loop.objective) {
-        lines.push(`Objective: ${loop.objective}`);
+    lines.push(`You are an agent that operates as a control loop rather than answering in a single prompt.`);
+    lines.push(`Strategy: ${strategy.name} (${strategy.strategy}).`);
+    if (strategy.objective) {
+        lines.push(`Objective: ${strategy.objective}`);
     }
-    if (loop.phases?.length) {
-        lines.push(`Each iteration, execute these phases in order: ${loop.phases.join(' → ')}. ` +
+    if (strategy.phases?.length) {
+        lines.push(`Each iteration, execute these phases in order: ${strategy.phases.join(' → ')}. ` +
             `Decide the single best next action each iteration; do not try to solve everything at once.`);
     }
-    if (loop.constraints?.length) {
-        lines.push(`Constraints you must respect:\n${loop.constraints
+    if (strategy.constraints?.length) {
+        lines.push(`Constraints you must respect:\n${strategy.constraints
             .map(c => `- ${c}`)
             .join('\n')}`);
     }
-    if (loop.termination) {
-        const t = loop.termination;
+    if (strategy.termination) {
+        const t = strategy.termination;
         lines.push(`Termination: stop after at most ${t.maxIterations} iterations, or when the goal is reached.`);
         if (t.successCriteria?.length) {
             lines.push(`Success criteria:\n${t.successCriteria.map(s => `- ${s}`).join('\n')}`);
@@ -74,13 +74,13 @@ function buildLoopSystemPrompt(loop) {
             lines.push(`If blocked: ${t.onBlocked}.`);
         }
     }
-    if (loop.human && loop.human.mode !== 'none') {
-        lines.push(`Human-in-the-loop: mode "${loop.human.mode}"` +
-            (loop.human.approvalRequired
-                ? `; request explicit approval before: ${loop.human.approvalFor.join(', ') || 'sensitive actions'}.`
+    if (strategy.human && strategy.human.mode !== 'none') {
+        lines.push(`Human-in-the-loop: mode "${strategy.human.mode}"` +
+            (strategy.human.approvalRequired
+                ? `; request explicit approval before: ${strategy.human.approvalFor.join(', ') || 'sensitive actions'}.`
                 : '.'));
     }
-    lines.push(`Keep loop state (dataframes, charts, intermediate results) in the notebook/runtime, not in the prompt. ` +
+    lines.push(`Keep strategy state (dataframes, charts, intermediate results) in the notebook/runtime, not in the prompt. ` +
         `For notebook operations, always use the notebook frontend tools (runCell, readAllCells, readCell, insertCell, updateCell, deleteCells) so actions happen in the live notebook UI. ` +
         `Use executeCodeInNotebook only for temporary inspection code that should not modify notebook cells.`);
     return lines.join('\n\n');
@@ -108,9 +108,9 @@ function NotebookUI({ serviceManager }) {
     return (_jsx(ThemedJupyterProvider, { children: _jsx(Notebook, { nbformat: NOTEBOOK_CONTENT, id: NOTEBOOK_ID, Toolbar: ExampleNotebookToolbar, serviceManager: serviceManager, height: "100%", cellSidebarMargin: 120, startDefaultKernel: true }) }));
 }
 /**
- * A compact, read-only summary of the selected loop specification.
+ * A compact, read-only summary of the selected strategy specification.
  */
-function LoopSummary({ loop }) {
+function StrategySummary({ strategy }) {
     return (_jsxs(Box, { sx: {
             mt: 2,
             p: 2,
@@ -119,7 +119,7 @@ function LoopSummary({ loop }) {
             borderRadius: 2,
             bg: 'canvas.default',
             fontSize: 0,
-        }, children: [_jsx(Box, { sx: { display: 'flex', flexWrap: 'wrap', gap: 2, mb: 1 }, children: loop.phases.map((phase, index) => (_jsxs(Box, { sx: {
+        }, children: [_jsx(Box, { sx: { display: 'flex', flexWrap: 'wrap', gap: 2, mb: 1 }, children: strategy.phases.map((phase, index) => (_jsxs(Box, { sx: {
                         display: 'flex',
                         alignItems: 'center',
                         gap: 1,
@@ -129,21 +129,21 @@ function LoopSummary({ loop }) {
                         bg: 'neutral.muted',
                         color: 'fg.default',
                         fontWeight: 'bold',
-                    }, children: [index + 1, ". ", phase] }, phase))) }), loop.objective && (_jsxs(Box, { sx: { color: 'fg.muted' }, children: [_jsx("strong", { children: "Objective:" }), " ", loop.objective] })), loop.termination && (_jsxs(Box, { sx: { color: 'fg.muted', mt: 1 }, children: [_jsx("strong", { children: "Max iterations:" }), " ", loop.termination.maxIterations, " \u00B7", ' ', _jsx("strong", { children: "On blocked:" }), " ", loop.termination.onBlocked] }))] }));
+                    }, children: [index + 1, ". ", phase] }, phase))) }), strategy.objective && (_jsxs(Box, { sx: { color: 'fg.muted' }, children: [_jsx("strong", { children: "Objective:" }), " ", strategy.objective] })), strategy.termination && (_jsxs(Box, { sx: { color: 'fg.muted', mt: 1 }, children: [_jsx("strong", { children: "Max iterations:" }), " ", strategy.termination.maxIterations, ' ', "\u00B7 ", _jsx("strong", { children: "On blocked:" }), " ", strategy.termination.onBlocked] }))] }));
 }
-export function AgentLoopExampleInner({ serviceManager, }) {
-    // All available loops come from the generated loop catalogue.
-    const loops = useMemo(() => listLoops(), []);
-    const [selectedLoopId, setSelectedLoopId] = useState(DEFAULT_LOOP);
-    const selectedLoop = useMemo(() => getLoop(selectedLoopId) ?? loops[0], [selectedLoopId, loops]);
-    const systemPrompt = useMemo(() => buildLoopSystemPrompt(selectedLoop), [selectedLoop]);
+export function AgentStrategyExampleInner({ serviceManager, }) {
+    // All available strategies come from the generated strategy catalogue.
+    const strategies = useMemo(() => listStrategies(), []);
+    const [selectedStrategyId, setSelectedStrategyId] = useState(DEFAULT_STRATEGY);
+    const selectedStrategy = useMemo(() => getStrategy(selectedStrategyId) ?? strategies[0], [selectedStrategyId, strategies]);
+    const systemPrompt = useMemo(() => buildStrategySystemPrompt(selectedStrategy), [selectedStrategy]);
     // The tools. Which of the chat and the harness runs them depends on
-    // where the loop turns, and the hook decides that.
+    // where the strategy turns, and the hook decides that.
     const tools = useNotebookTools(NOTEBOOK_ID);
     const { agentReady, protocol: protocolConfig, chatFrontendTools, error, unavailableReason, createAttempted, } = useExampleJupyterAgent({
-        exampleId: 'AgentLoopExample',
+        exampleId: 'AgentStrategyExample',
         agentName: DEFAULT_AGENT_ID,
-        description: `Loop agent (${selectedLoop.name}) for AgentLoopExample`,
+        description: `Strategy agent (${selectedStrategy.name}) for AgentStrategyExample`,
         systemPrompt,
         serviceManager,
         frontendTools: tools,
@@ -153,16 +153,16 @@ export function AgentLoopExampleInner({ serviceManager, }) {
     // The example's own agent, not merely the runtime: on the cloud target the
     // runtime is ready before this agent has been registered on it.
     const effectiveReady = agentReady;
-    const isLoopSelectorDisabled = createAttempted;
+    const isStrategySelectorDisabled = createAttempted;
     // Get notebook tools for ChatSidebar
     // Build Vercel AI protocol config
-    // Chat suggestions derived from the selected loop.
+    // Chat suggestions derived from the selected strategy.
     const suggestions = useMemo(() => [
         {
-            title: `${selectedLoop.emoji} Run the loop`,
-            message: selectedLoop.objective
-                ? `Run the ${selectedLoop.name}. ${selectedLoop.objective}`
-                : `Run the ${selectedLoop.name} against the data in this notebook.`,
+            title: `${selectedStrategy.emoji} Run the strategy`,
+            message: selectedStrategy.objective
+                ? `Run the ${selectedStrategy.name}. ${selectedStrategy.objective}`
+                : `Run the ${selectedStrategy.name} against the data in this notebook.`,
         },
         {
             title: '🔁 Next iteration',
@@ -176,7 +176,7 @@ export function AgentLoopExampleInner({ serviceManager, }) {
             title: '📊 Summarize findings',
             message: 'Summarize the key findings and produce a final, decision-oriented report.',
         },
-    ], [selectedLoop]);
+    ], [selectedStrategy]);
     return (_jsx(_Fragment, { children: _jsxs(Box, { sx: {
                 // The wrapper is the viewport, not the window: it sits below the
                 // header and beside the sidebar, so viewport units size this box to
@@ -204,9 +204,9 @@ export function AgentLoopExampleInner({ serviceManager, }) {
                                         justifyContent: 'space-between',
                                         gap: 3,
                                         flexWrap: 'wrap',
-                                    }, children: [_jsxs(Box, { children: [_jsxs("h1", { style: { margin: 0, fontSize: '1.5rem' }, children: [selectedLoop.emoji, " Agent Loop Example"] }), _jsx("p", { style: { margin: '8px 0 0', color: 'var(--fgColor-muted)' }, children: "Define and launch an agent execution loop \u2014 observe, think, act, evaluate \u2014 over a live notebook." })] }), _jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 2 }, title: isLoopSelectorDisabled
-                                                ? 'Loop selector is temporarily disabled while launching the agent'
-                                                : 'Choose a loop', children: [_jsx(Box, { as: "label", sx: { fontSize: 1, fontWeight: 'bold' }, children: "Loop" }), _jsx(Box, { as: "select", value: selectedLoopId, onChange: (e) => setSelectedLoopId(e.target.value), disabled: isLoopSelectorDisabled, "aria-label": "Loop specification", sx: {
+                                    }, children: [_jsxs(Box, { children: [_jsxs("h1", { style: { margin: 0, fontSize: '1.5rem' }, children: [selectedStrategy.emoji, " Agent Strategy Example"] }), _jsx("p", { style: { margin: '8px 0 0', color: 'var(--fgColor-muted)' }, children: "Define and launch an agent reasoning strategy \u2014 observe, think, act, evaluate \u2014 over a live notebook." })] }), _jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 2 }, title: isStrategySelectorDisabled
+                                                ? 'Strategy selector is temporarily disabled while launching the agent'
+                                                : 'Choose a strategy', children: [_jsx(Box, { as: "label", sx: { fontSize: 1, fontWeight: 'bold' }, children: "Strategy" }), _jsx(Box, { as: "select", value: selectedStrategyId, onChange: (e) => setSelectedStrategyId(e.target.value), disabled: isStrategySelectorDisabled, "aria-label": "Strategy specification", sx: {
                                                         px: 2,
                                                         py: '6px',
                                                         fontSize: 1,
@@ -215,7 +215,7 @@ export function AgentLoopExampleInner({ serviceManager, }) {
                                                         borderColor: 'border.default',
                                                         bg: 'canvas.default',
                                                         color: 'fg.default',
-                                                    }, children: loops.map(loop => (_jsxs("option", { value: loop.id, children: [loop.emoji, " ", loop.name] }, loop.id))) })] })] }), _jsx(LoopSummary, { loop: selectedLoop })] }), _jsx(Box, { sx: {
+                                                    }, children: strategies.map(strategy => (_jsxs("option", { value: strategy.id, children: [strategy.emoji, " ", strategy.name] }, strategy.id))) })] })] }), _jsx(StrategySummary, { strategy: selectedStrategy })] }), _jsx(Box, { sx: {
                                 flex: 1,
                                 display: 'flex',
                                 overflow: 'hidden',
@@ -227,7 +227,7 @@ export function AgentLoopExampleInner({ serviceManager, }) {
                                     borderColor: 'border.default',
                                     borderRadius: 2,
                                     overflow: 'hidden',
-                                }, children: _jsx(NotebookUI, { serviceManager: serviceManager }) }) })] }), effectiveReady && (_jsx(ChatSidebar, { title: `${selectedLoop.emoji} ${selectedLoop.name}`, protocol: protocolConfig, position: "right", width: 400, clickOutsideToClose: false, showNewChatButton: true, showClearButton: true, showSettingsButton: true, defaultOpen: true, panelProps: {
+                                }, children: _jsx(NotebookUI, { serviceManager: serviceManager }) }) })] }), effectiveReady && (_jsx(ChatSidebar, { title: `${selectedStrategy.emoji} ${selectedStrategy.name}`, protocol: protocolConfig, position: "right", width: 400, clickOutsideToClose: false, showNewChatButton: true, showClearButton: true, showSettingsButton: true, defaultOpen: true, panelProps: {
                         protocol: protocolConfig,
                         frontendTools: chatFrontendTools,
                         useStore: false,
@@ -250,7 +250,7 @@ export function AgentLoopExampleInner({ serviceManager, }) {
 /**
  * Main example component with Jupyter provider wrapper.
  */
-export function AgentLoopExample({ serviceManager, }) {
-    return (_jsx(ThemedProvider, { children: _jsx(AgentLoopExampleInner, { serviceManager: serviceManager }) }));
+export function AgentStrategyExample({ serviceManager, }) {
+    return (_jsx(ThemedProvider, { children: _jsx(AgentStrategyExampleInner, { serviceManager: serviceManager }) }));
 }
-export default AgentLoopExample;
+export default AgentStrategyExample;

package/lib/examples/example-selector.js

@@ -111,7 +111,7 @@ export const EXAMPLE_ENTRIES = [
     // `owns-sandbox-control`: the shell is pinned to the browser sandbox, so
     // the page's selector would offer three targets it cannot move to.
     ['example', 'loop', 'shell', 'prompt', 'editors', 'owns-sandbox-control']),
-    makeEntry('AgentLoopExample', () => import('./AgentLoopExample'), 'Define and launch an agent execution loop (observe/think/act/evaluate) over a live notebook, driven by generic loop specs.', ['example', 'agent', 'loop', 'notebook', 'agentspecs']),
+    makeEntry('AgentStrategyExample', () => import('./AgentStrategyExample'), 'Define and launch an agent reasoning strategy (a control loop: observe/think/act/evaluate) over a live notebook, driven by generic strategy specs.', ['example', 'agent', 'strategy', 'notebook', 'agentspecs']),
     makeEntry('AgentToolApprovalsExample', () => import('./AgentToolApprovalsExample'), 'Tool approval workflows and manual decisions.'),
     makeEntry('AgentMemoryExample', () => import('./AgentMemoryExample'), 'Memory-aware conversation and retrieval example.'),
     makeEntry('AgentSkillsExample', () => import('./AgentSkillsExample'), 'Skills discovery, execution, and monitoring example.'),

package/lib/examples/index.d.ts

@@ -28,7 +28,7 @@ export { default as AgentEvalsExample } from './AgentEvalsExample';
 export { default as AgentGuardrailsExample } from './AgentGuardrailsExample';
 export { default as AgentHooksExample } from './AgentHooksExample';
 export { default as AgentInferenceProviderExample } from './AgentInferenceProviderExample';
-export { default as AgentLoopExample } from './AgentLoopExample';
+export { default as AgentStrategyExample } from './AgentStrategyExample';
 export { default as AgentToolApprovalsExample } from './AgentToolApprovalsExample';
 export { default as AgentMemoryExample } from './AgentMemoryExample';
 export { default as AgentOtelExample } from './AgentOtelExample';

package/lib/examples/index.js

@@ -34,7 +34,7 @@ export { default as AgentEvalsExample } from './AgentEvalsExample';
 export { default as AgentGuardrailsExample } from './AgentGuardrailsExample';
 export { default as AgentHooksExample } from './AgentHooksExample';
 export { default as AgentInferenceProviderExample } from './AgentInferenceProviderExample';
-export { default as AgentLoopExample } from './AgentLoopExample';
+export { default as AgentStrategyExample } from './AgentStrategyExample';
 export { default as AgentToolApprovalsExample } from './AgentToolApprovalsExample';
 export { default as AgentMemoryExample } from './AgentMemoryExample';
 export { default as AgentOtelExample } from './AgentOtelExample';

package/lib/examples/main.js

@@ -86,7 +86,7 @@ const ANONYMOUS_EXAMPLES = new Set([
 ]);
 const getExampleGroup = (id) => {
     if (id === 'AgentspecsExample' ||
-        id === 'AgentLoopExample' ||
+        id === 'AgentStrategyExample' ||
         id === 'LoopWorkspaceExample' ||
         id === 'LoopShellExample' ||
         id === 'DecksAgent') {
@@ -1068,12 +1068,12 @@ const ExampleAppThemed = ({ selectedExample, isChangingExample, error, ExampleCo
         for (const [groupName, examples] of groups) {
             examples.sort((left, right) => {
                 if (groupName === 'Loop') {
-                    // The shells first, most naked first; then the loop that drives a
+                    // The shells first, most naked first; then the strategy that drives a
                     // notebook; then the library of specs behind them all.
                     const LOOP_ORDER = [
                         'LoopShellExample',
                         'LoopWorkspaceExample',
-                        'AgentLoopExample',
+                        'AgentStrategyExample',
                         'AgentspecsExample',
                     ];
                     const loopOrder = (id) => {

package/lib/loop/plugins/chat/ChatView.js

@@ -1288,12 +1288,13 @@ export default function ChatView({ workspace }) {
     const offeredTools = useMemo(() => {
         const fromServer = configQuery.data?.builtinTools ?? [];
         const seen = new Set(fromServer.map(tool => tool.name));
-        return [
-            ...fromServer,
-            ...agentTools
+        // The runtime's, and the frontend tools this page runs: named apart.
+        return {
+            runtime: fromServer,
+            frontend: agentTools
                 .filter(tool => !seen.has(tool.name))
                 .map(tool => ({ id: tool.name, name: tool.name })),
-        ];
+        };
     }, [configQuery.data?.builtinTools, agentTools]);
     /* Which skills are on, as the runtime last reported them. Derived rather
        than held: the source of truth is the agent, and a local copy would drift
@@ -1423,7 +1424,8 @@ export default function ChatView({ workspace }) {
         selectedModel: activeModel,
         onModelSelect: model => void selectModel(model),
         showToolsMenu: !presence,
-        availableTools: offeredTools,
+        availableTools: offeredTools.runtime,
+        availableFrontendTools: offeredTools.frontend,
         mcpServers: configQuery.data?.mcpServers ?? [],
         // Live from the host example, when one feeds it: the footer's MCP status
         // indicator. (Codemode surfaces through the toggle below, not a blob.)

package/lib/specs/actions.js

@@ -547,6 +547,62 @@ export const SERVER_ACTIONS = {
         tools: {},
         conditions: {},
     },
+    'odoo-accounting': {
+        checked: '2026-10-05',
+        default: [],
+        tools: {
+            odoo_accounting_list_invoices: ['read'],
+            odoo_accounting_get_invoice: ['read'],
+            odoo_accounting_list_journal_entries: ['read'],
+            odoo_accounting_list_open_balances: ['read'],
+            odoo_accounting_list_accounts: ['read'],
+            odoo_accounting_list_journals: ['read'],
+            odoo_accounting_get_journal_entry: ['read'],
+            odoo_accounting_trial_balance: ['read'],
+            odoo_accounting_general_ledger: ['read'],
+            odoo_accounting_create_draft_invoice: ['write'],
+            odoo_accounting_post_invoice: ['write'],
+            odoo_accounting_create_draft_journal_entry: ['write'],
+            odoo_accounting_post_journal_entry: ['write'],
+            odoo_accounting_list_partners: ['read'],
+            odoo_accounting_partner_ledger: ['read'],
+            odoo_accounting_aged_balance: ['read'],
+            odoo_accounting_list_taxes: ['read'],
+            odoo_accounting_list_assets: ['read'],
+            odoo_accounting_get_asset: ['read'],
+            odoo_accounting_reconcile_lines: ['write'],
+            odoo_accounting_unreconcile_lines: ['write'],
+            odoo_accounting_bank_status: ['read'],
+            odoo_accounting_list_bank_lines: ['read'],
+            odoo_accounting_get_bank_line: ['read'],
+            odoo_accounting_suggest_bank_matches: ['read'],
+            odoo_accounting_suggest_reconciliations: ['read'],
+            odoo_accounting_explain_account_balance: ['read'],
+            odoo_accounting_list_bank_feeds: ['read'],
+            odoo_accounting_list_currency_rates: ['read'],
+            odoo_accounting_get_lock_dates: ['read'],
+            odoo_accounting_book_bank_line: ['write'],
+            odoo_accounting_match_bank_line: ['write'],
+            odoo_accounting_reset_bank_line: ['write'],
+            odoo_accounting_remove_duplicate_bank_lines: ['delete'],
+            odoo_accounting_link_bank_feed: ['write'],
+            odoo_accounting_create_vendor_bill: ['write'],
+            odoo_accounting_create_customer_invoice: ['write'],
+            odoo_accounting_set_currency_rates: ['write'],
+            odoo_accounting_set_lock_date: ['write'],
+            odoo_accounting_create_matching_model: ['write'],
+            odoo_accounting_get_tax_settings: ['read'],
+            odoo_accounting_list_tax_returns: ['read'],
+            odoo_accounting_get_tax_return: ['read'],
+            odoo_accounting_tax_grids: ['read'],
+            odoo_accounting_list_tax_grid_lines: ['read'],
+            odoo_accounting_check_tax_period: ['read'],
+            odoo_accounting_list_untagged_tax_lines: ['read'],
+            odoo_accounting_set_tax_periodicity: ['write'],
+            odoo_accounting_set_tax_grids: ['write'],
+        },
+        conditions: {},
+    },
     salesforce: {
         default: [],
         tools: {},

package/lib/specs/frontendTools.js

@@ -32,7 +32,7 @@ export const DECKS_FRONTEND_TOOL_SPEC_0_0_1 = {
         'decks_present',
         'decks_print',
     ],
-    icon: 'project',
+    icon: '@primer/octicons-react:project',
     emoji: '🃏',
 };
 export const JUPYTER_NOTEBOOK_EDIT_FRONTEND_TOOL_SPEC_0_0_1 = {
@@ -50,7 +50,7 @@ export const JUPYTER_NOTEBOOK_EDIT_FRONTEND_TOOL_SPEC_0_0_1 = {
         'runCell',
         'executeCode',
     ],
-    icon: 'notebook',
+    icon: '@datalayer/icons-react:jupyter',
     emoji: '📓',
 };
 export const JUPYTER_NOTEBOOK_PROPOSE_FRONTEND_TOOL_SPEC_0_0_1 = {
@@ -61,7 +61,7 @@ export const JUPYTER_NOTEBOOK_PROPOSE_FRONTEND_TOOL_SPEC_0_0_1 = {
     tags: ['frontend', 'notebook', 'propose'],
     enabled: true,
     toolset: ['readCell', 'readAllCells', 'proposeCellUpdate', 'runCell'],
-    icon: 'notebook',
+    icon: '@datalayer/icons-react:jupyter',
     emoji: '📓',
 };
 export const JUPYTER_NOTEBOOK_READ_FRONTEND_TOOL_SPEC_0_0_1 = {
@@ -72,7 +72,7 @@ export const JUPYTER_NOTEBOOK_READ_FRONTEND_TOOL_SPEC_0_0_1 = {
     tags: ['frontend', 'notebook', 'read'],
     enabled: true,
     toolset: ['readCell', 'readAllCells'],
-    icon: 'notebook',
+    icon: '@datalayer/icons-react:jupyter',
     emoji: '📓',
 };
 export const JUPYTER_NOTEBOOK_FRONTEND_TOOL_SPEC_0_0_1 = {
@@ -83,7 +83,7 @@ export const JUPYTER_NOTEBOOK_FRONTEND_TOOL_SPEC_0_0_1 = {
     tags: ['frontend', 'notebook', 'jupyter-server'],
     enabled: true,
     toolset: 'all',
-    icon: 'notebook',
+    icon: '@datalayer/icons-react:jupyter',
     emoji: '📓',
 };
 export const LEXICAL_DOCUMENT_FRONTEND_TOOL_SPEC_0_0_1 = {
@@ -94,7 +94,7 @@ export const LEXICAL_DOCUMENT_FRONTEND_TOOL_SPEC_0_0_1 = {
     tags: ['frontend', 'document', 'lexical', 'drawing', 'diagram'],
     enabled: true,
     toolset: 'all',
-    icon: 'file',
+    icon: '@primer/octicons-react:file',
     emoji: '📄',
 };
 // ============================================================================