@datalayer/agent-runtimes 1.3.55 → 1.3.57

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/loop/apps/appspec.js

@@ -106,7 +106,12 @@ export function emptyAppspec(kind = 'chat') {
             settings: [],
             components: [],
         },
-        tests: { readyAt: DEFAULT_READY_AT, evalset: '', cases: [] },
+        tests: {
+            readyAt: DEFAULT_READY_AT,
+            evalset: '',
+            cases: [],
+            verified: { live: [], recorded: [], unverified: [] },
+        },
         record: {
             keepFor: DEFAULT_KEEP_FOR,
             retentionDays: retentionDays(DEFAULT_KEEP_FOR),
@@ -315,6 +320,7 @@ export function parseAppspec(document) {
     const permissions = isData(data.permissions) ? data.permissions : {};
     const computer = isData(permissions.computer) ? permissions.computer : {};
     const tests = isData(data.tests) ? data.tests : {};
+    const verified = isData(tests.verified) ? tests.verified : {};
     const record = isData(data.record) ? data.record : {};
     const checks = isData(data.checks) ? data.checks : {};
     const keepFor = text(record.keep_for, DEFAULT_KEEP_FOR);
@@ -359,6 +365,11 @@ export function parseAppspec(document) {
                 ask: text(testCase.ask),
                 expect: text(testCase.expect),
             })),
+            verified: {
+                live: texts(verified.live),
+                recorded: texts(verified.recorded),
+                unverified: texts(verified.unverified),
+            },
         },
         record: {
             keepFor,
@@ -559,7 +570,11 @@ export function dumpAppspec(app) {
         .list('cases', app.tests.cases.map(testCase => ({
         ask: testCase.ask,
         expect: testCase.expect,
-    }))).data)
+    })))
+        .part('verified', new Writer()
+        .list('live', app.tests.verified.live)
+        .list('recorded', app.tests.verified.recorded)
+        .list('unverified', app.tests.verified.unverified).data).data)
         .part('record', new Writer()
         .text('keep_for', app.record.keepFor, DEFAULT_KEEP_FOR)
         .list('include', app.record.include, DEFAULT_RECORD_INCLUDE)

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: {},