@datalayer/agent-runtimes 1.3.58 → 1.3.60

package/lib/chat/ChatFloating.d.ts

@@ -110,6 +110,16 @@ export interface ChatFloatingProps extends ChatCommonProps {
      * @default 'paperclip'
      */
     assistantCharacter?: string | AssistantCharacter | AssistantCharacterData;
+    /**
+     * The runtime the floating assistant asks typed decisions at — its
+     * `/api/v1/configure/inference/decisions`, as the `decide` tool asks — and
+     * the token to ask with, if it needs one: its balloon offers *Ask a
+     * decision*, answered there in plain words with its confidence.
+     */
+    decisions?: {
+        serverUrl: string;
+        token?: string;
+    };
     /**
      * Callback when the user switches view mode via the header toggle.
      * The parent component receives the new ChatViewMode value.
@@ -144,5 +154,5 @@ export interface ChatFloatingProps extends ChatCommonProps {
  * ChatFloating component
  * A floating chat window built on ChatBase
  */
-export declare function ChatFloating({ endpoint, protocol: protocolProp, useStore: useStoreMode, title, description, position, defaultOpen, width, height, showHeader, showButton, showNewChatButton, showClearButton, showSettingsButton, enableKeyboardShortcuts, toggleShortcut, showPoweredBy, promptVariant, mentionableAgents, poweredByProps, clickOutsideToClose, escapeToClose, className, onSettingsClick, onNewChat, onOpen, onClose, onStateUpdate, children, brandIcon, buttonIcon, buttonTooltip, brandColor, buttonGlow, offset, animationDuration, renderToolResult, frontendTools, initialState: _initialState, suggestions, submitOnSuggestionClick, hideMessagesAfterToolUI, defaultViewMode, onViewModeChange, sidebarMountPoint, showPanelBackdrop, availableModels, showModelSelector, showToolsMenu, showSkillsMenu, showTokenUsage, showContextRing, themeVariant, themeOverrides, colorMode, runtimeId, historyEndpoint, authToken, historyAuthToken, pendingPrompt, showInformation, onInformationClick, onToolCallStart, onToolCallComplete, showToolApprovalBanner, pendingApprovals, onApproveApproval, onRejectApproval, panelProps, launching, launchingMessage, assistantCharacter, conversation, }: ChatFloatingProps): React.JSX.Element;
+export declare function ChatFloating({ endpoint, protocol: protocolProp, useStore: useStoreMode, title, description, position, defaultOpen, width, height, showHeader, showButton, showNewChatButton, showClearButton, showSettingsButton, enableKeyboardShortcuts, toggleShortcut, showPoweredBy, promptVariant, mentionableAgents, poweredByProps, clickOutsideToClose, escapeToClose, className, onSettingsClick, onNewChat, onOpen, onClose, onStateUpdate, children, brandIcon, buttonIcon, buttonTooltip, brandColor, buttonGlow, offset, animationDuration, renderToolResult, frontendTools, initialState: _initialState, suggestions, submitOnSuggestionClick, hideMessagesAfterToolUI, defaultViewMode, onViewModeChange, sidebarMountPoint, showPanelBackdrop, availableModels, showModelSelector, showToolsMenu, showSkillsMenu, showTokenUsage, showContextRing, themeVariant, themeOverrides, colorMode, runtimeId, historyEndpoint, authToken, historyAuthToken, pendingPrompt, showInformation, onInformationClick, onToolCallStart, onToolCallComplete, showToolApprovalBanner, pendingApprovals, onApproveApproval, onRejectApproval, panelProps, launching, launchingMessage, assistantCharacter, conversation, decisions, }: ChatFloatingProps): React.JSX.Element;
 export default ChatFloating;

package/lib/chat/ChatFloating.js

@@ -31,6 +31,7 @@ import { ButtonGlow } from './display/ButtonGlow';
 import { useViewportDrag } from './useViewportDrag';
 import { disabledChatViewModes, resolveMountPoint } from './viewModes';
 import { AssistantStage } from './assistant/AssistantStage';
+import { decisionsAskerAt } from './assistant/decisions';
 import { SpeechBalloon } from './assistant/SpeechBalloon';
 import { DEFAULT_ASSISTANT_CHARACTER, } from './assistant/characters';
 import { assistantStateOf, latestSaying, newestIsAnswer, keepAway, keptAway, ASSISTANT_WORDS, } from './assistant/state';
@@ -63,7 +64,7 @@ const clamp = (value, max) => Math.max(8, Math.min(value, Math.max(8, max)));
  * ChatFloating component
  * A floating chat window built on ChatBase
  */
-export function ChatFloating({ endpoint, protocol: protocolProp, useStore: useStoreMode = true, title = 'Chat', description = 'Start a conversation with the AI agent.', position = 'bottom-right', defaultOpen = false, width = 400, height = 550, showHeader = true, showButton = true, showNewChatButton = true, showClearButton = true, showSettingsButton = false, enableKeyboardShortcuts = true, toggleShortcut = '/', showPoweredBy = true, promptVariant, mentionableAgents, poweredByProps, clickOutsideToClose = false, escapeToClose = true, className, onSettingsClick, onNewChat, onOpen, onClose, onStateUpdate, children, brandIcon, buttonIcon, buttonTooltip = 'Chat with AI', brandColor, buttonGlow = true, offset = 20, animationDuration = 200, renderToolResult, frontendTools, initialState: _initialState, suggestions, submitOnSuggestionClick = true, hideMessagesAfterToolUI = false, defaultViewMode = 'floating', onViewModeChange, sidebarMountPoint = null, showPanelBackdrop = false, availableModels, showModelSelector = false, showToolsMenu = false, showSkillsMenu = false, showTokenUsage = true, showContextRing = false, themeVariant, themeOverrides, colorMode, runtimeId, historyEndpoint, authToken, historyAuthToken, pendingPrompt, showInformation = false, onInformationClick, onToolCallStart, onToolCallComplete, showToolApprovalBanner, pendingApprovals, onApproveApproval, onRejectApproval, panelProps, launching = false, launchingMessage, assistantCharacter = DEFAULT_ASSISTANT_CHARACTER, conversation, }) {
+export function ChatFloating({ endpoint, protocol: protocolProp, useStore: useStoreMode = true, title = 'Chat', description = 'Start a conversation with the AI agent.', position = 'bottom-right', defaultOpen = false, width = 400, height = 550, showHeader = true, showButton = true, showNewChatButton = true, showClearButton = true, showSettingsButton = false, enableKeyboardShortcuts = true, toggleShortcut = '/', showPoweredBy = true, promptVariant, mentionableAgents, poweredByProps, clickOutsideToClose = false, escapeToClose = true, className, onSettingsClick, onNewChat, onOpen, onClose, onStateUpdate, children, brandIcon, buttonIcon, buttonTooltip = 'Chat with AI', brandColor, buttonGlow = true, offset = 20, animationDuration = 200, renderToolResult, frontendTools, initialState: _initialState, suggestions, submitOnSuggestionClick = true, hideMessagesAfterToolUI = false, defaultViewMode = 'floating', onViewModeChange, sidebarMountPoint = null, showPanelBackdrop = false, availableModels, showModelSelector = false, showToolsMenu = false, showSkillsMenu = false, showTokenUsage = true, showContextRing = false, themeVariant, themeOverrides, colorMode, runtimeId, historyEndpoint, authToken, historyAuthToken, pendingPrompt, showInformation = false, onInformationClick, onToolCallStart, onToolCallComplete, showToolApprovalBanner, pendingApprovals, onApproveApproval, onRejectApproval, panelProps, launching = false, launchingMessage, assistantCharacter = DEFAULT_ASSISTANT_CHARACTER, conversation, decisions, }) {
     // Store-based state
     const storeIsOpen = useChatOpen();
     const storeMessages = useChatMessages();
@@ -194,6 +195,9 @@ export function ChatFloating({ endpoint, protocol: protocolProp, useStore: useSt
             },
         }
         : undefined;
+    const assistantDecide = useMemo(() => decisions?.serverUrl
+        ? decisionsAskerAt(decisions.serverUrl, decisions.token)
+        : undefined, [decisions?.serverUrl, decisions?.token]);
     const assistantBalloon = assistantState === 'paused'
         ? { text: ASSISTANT_WORDS.paused }
         : balloonApproval
@@ -835,7 +839,7 @@ export function ChatFloating({ endpoint, protocol: protocolProp, useStore: useSt
                         left: px(stageDrag.position.left),
                         top: px(stageDrag.position.top),
                     }
-                    : getPositionStyles(), stageRef: stageRef, onDragStart: stageDrag.onHandlePointerDown, open: isOpen, onToggle: handleToggle, balloon: assistantBalloon, insist: balloonInsists, onDismiss: dismissAssistant, ownRef: popupRef })), showButton && !isOpen && !assistantShown && (_jsx(Box, { sx: {
+                    : getPositionStyles(), stageRef: stageRef, onDragStart: stageDrag.onHandlePointerDown, open: isOpen, onToggle: handleToggle, balloon: assistantBalloon, insist: balloonInsists, onDismiss: dismissAssistant, ownRef: popupRef, decide: assistantDecide })), showButton && !isOpen && !assistantShown && (_jsx(Box, { sx: {
                     ...getPositionStyles(),
                 }, children: _jsxs(Box, { sx: {
                         position: 'relative',

package/lib/chat/assistant/AssistantStage.d.ts

@@ -17,6 +17,7 @@
 import type { JSX, RefObject } from 'react';
 import { type AssistantCharacter } from './characters';
 import type { AssistantCharacterData } from './formats/types';
+import type { DecisionAsker } from './decisions';
 import { type AssistantAway, type AssistantState, type BalloonApproval } from './state';
 /**
  * Where the balloon goes so that it stays inside the window (T-23): toward
@@ -86,6 +87,11 @@ export interface AssistantStageProps {
      * steps aside for, nor is the pointer working there (T-27).
      */
     ownRef?: RefObject<HTMLElement | null>;
+    /**
+     * Asks a typed decision of the runtime: the balloon offers *Ask a
+     * decision*, and stays while its form or its answer is on screen.
+     */
+    decide?: DecisionAsker;
 }
-export declare function AssistantStage({ character, state, size, place, stageRef, onDragStart, open, onToggle, balloon, insist, onDismiss, ownRef, }: AssistantStageProps): JSX.Element;
+export declare function AssistantStage({ character, state, size, place, stageRef, onDragStart, open, onToggle, balloon, insist, onDismiss, ownRef, decide, }: AssistantStageProps): JSX.Element;
 export default AssistantStage;

package/lib/chat/assistant/AssistantStage.js

@@ -180,7 +180,7 @@ export function useKeepClear(stageRef, own, paused) {
     }, [stageRef, own, paused]);
     return obstructed ? 'obstacle' : pointerBusy ? 'pointer' : undefined;
 }
-export function AssistantStage({ character, state, size = 88, place, stageRef, onDragStart, open, onToggle, balloon, insist = false, onDismiss, ownRef, }) {
+export function AssistantStage({ character, state, size = 88, place, stageRef, onDragStart, open, onToggle, balloon, insist = false, onDismiss, ownRef, decide, }) {
     // A shipped one by id, a drawing contributed by a plugin (T-24), or a
     // character read from a file (T-26).
     const shipped = typeof character === 'string'
@@ -199,7 +199,9 @@ export function AssistantStage({ character, state, size = 88, place, stageRef, o
     // Where the press began: a press that moves is a drag, not a click.
     const pressedAt = useRef(null);
     const aside = useKeepClear(stageRef, ownRef, menuOpen);
-    const showBalloon = !aside && !open && !!balloon && (hovered || insist);
+    // A decision being asked, or its answer, keeps the balloon up.
+    const [deciding, setDeciding] = useState(false);
+    const showBalloon = !aside && !open && !!balloon && (hovered || insist || deciding);
     return (_jsxs(Box, { ref: stageRef, "data-assistant-state": state, "data-assistant-aside": aside, sx: {
             position: 'fixed',
             zIndex: 1002,
@@ -277,7 +279,7 @@ export function AssistantStage({ character, state, size = 88, place, stageRef, o
             '@media (prefers-reduced-motion: reduce)': {
                 '& *': { animation: 'none !important' },
             },
-        }, onMouseEnter: () => setHovered(true), onMouseLeave: () => setHovered(false), children: [showBalloon && balloon && (_jsx(SpeechBalloon, { text: balloon.text, more: balloon.more, approval: balloon.approval, onOpen: onToggle, above: size + 8, side: balloonSide(place).side, align: balloonSide(place).align, tailAt: size / 2 })), _jsx(Box, { as: "button", type: "button", "aria-label": open ? `Close the conversation with ${name}` : `Talk to ${name}`, "aria-expanded": open, onPointerDown: (event) => {
+        }, onMouseEnter: () => setHovered(true), onMouseLeave: () => setHovered(false), children: [showBalloon && balloon && (_jsx(SpeechBalloon, { text: balloon.text, more: balloon.more, approval: balloon.approval, decide: decide, onDecisionActive: setDeciding, wide: deciding, onOpen: onToggle, above: size + 8, side: balloonSide(place).side, align: balloonSide(place).align, tailAt: size / 2 })), _jsx(Box, { as: "button", type: "button", "aria-label": open ? `Close the conversation with ${name}` : `Talk to ${name}`, "aria-expanded": open, onPointerDown: (event) => {
                     pressedAt.current = { x: event.clientX, y: event.clientY };
                     onDragStart(event);
                 }, onClick: (event) => {

package/lib/chat/assistant/DecisionAsk.d.ts

@@ -0,0 +1,31 @@
+/**
+ * *Ask a decision* in the floating assistant's balloon: a small form — the
+ * situation, the question, its type (yes or no; a choice with its options
+ * listed; a score with its range) — asked of Jev through the runtime, and
+ * the answer said back in the balloon in plain words with its confidence.
+ *
+ * @module chat/assistant/DecisionAsk
+ */
+import type { JSX } from 'react';
+import { type DecisionAsker } from './decisions';
+/** The balloon's words for a decision. */
+export declare const DECISION_WORDS: {
+    readonly ask: "Ask a decision";
+    readonly asking: "Asking…";
+    readonly submit: "Ask";
+    readonly cancel: "Cancel";
+    readonly again: "Ask another";
+    readonly types: {
+        noul: string;
+        choice: string;
+        score: string;
+    };
+};
+export interface DecisionAskProps {
+    /** Asks the runtime. */
+    ask: DecisionAsker;
+    /** The form or its answer is on screen: the balloon must stay. */
+    onActiveChange?: (active: boolean) => void;
+}
+export declare function DecisionAsk({ ask, onActiveChange, }: DecisionAskProps): JSX.Element;
+export default DecisionAsk;

package/lib/chat/assistant/DecisionAsk.js

@@ -0,0 +1,96 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Button, FormControl, Select, Text, Textarea, TextInput, } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { DEFAULT_SCORE_RANGE, decisionAskProblem, decisionRequest, decisionResponseWords, } from './decisions';
+/** The balloon's words for a decision. */
+export const DECISION_WORDS = {
+    ask: 'Ask a decision',
+    asking: 'Asking…',
+    submit: 'Ask',
+    cancel: 'Cancel',
+    again: 'Ask another',
+    types: {
+        noul: 'Yes or no',
+        choice: 'A choice',
+        score: 'A score',
+    },
+};
+const LINK_SX = {
+    mt: 1,
+    p: 0,
+    border: 0,
+    bg: 'transparent',
+    color: 'accent.fg',
+    textDecoration: 'underline',
+    cursor: 'pointer',
+    fontSize: 1,
+};
+export function DecisionAsk({ ask, onActiveChange, }) {
+    const [open, setOpen] = useState(false);
+    const [situation, setSituation] = useState('');
+    const [question, setQuestion] = useState('');
+    const [name, setName] = useState('');
+    const [type, setType] = useState('noul');
+    const [options, setOptions] = useState('');
+    const [from, setFrom] = useState(String(DEFAULT_SCORE_RANGE.from));
+    const [to, setTo] = useState(String(DEFAULT_SCORE_RANGE.to));
+    const [problem, setProblem] = useState();
+    const [asking, setAsking] = useState(false);
+    const [answer, setAnswer] = useState();
+    // Gone from the screen — the conversation opened, the balloon closed — it
+    // no longer holds the balloon up.
+    const activeChange = useRef(onActiveChange);
+    activeChange.current = onActiveChange;
+    useEffect(() => () => activeChange.current?.(false), []);
+    const show = (active) => {
+        setOpen(active);
+        onActiveChange?.(active);
+    };
+    const close = () => {
+        setAnswer(undefined);
+        setProblem(undefined);
+        show(false);
+    };
+    if (!open) {
+        return (_jsx(Box, { as: "button", type: "button", "data-balloon-ask-decision": "", onClick: () => show(true), sx: { ...LINK_SX, display: 'block' }, children: DECISION_WORDS.ask }));
+    }
+    if (answer !== undefined) {
+        return (_jsxs(Box, { "data-balloon-decision": "answered", sx: { mt: 2 }, children: [_jsx(Text, { as: "p", "data-decision-answer": "", sx: { m: 0, fontWeight: 'semibold' }, children: answer }), _jsxs(Box, { sx: { display: 'flex', gap: 2, mt: 2 }, children: [_jsx(Button, { size: "small", onClick: () => setAnswer(undefined), children: DECISION_WORDS.again }), _jsx(Button, { size: "small", variant: "invisible", onClick: close, children: DECISION_WORDS.cancel })] })] }));
+    }
+    const submit = async () => {
+        const asked = {
+            situation,
+            question,
+            type,
+            name,
+            options: options.split('\n'),
+            range: { from: Number(from), to: Number(to) },
+        };
+        const refused = decisionAskProblem(asked);
+        setProblem(refused);
+        if (refused) {
+            return;
+        }
+        const request = decisionRequest(asked);
+        setAsking(true);
+        try {
+            setAnswer(decisionResponseWords(request, await ask(request)));
+        }
+        catch (error) {
+            setAnswer(`Nothing was decided: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            setAsking(false);
+        }
+    };
+    return (_jsxs(Box, { as: "form", "data-balloon-decision": "asking", "aria-label": DECISION_WORDS.ask, onSubmit: (event) => {
+            event.preventDefault();
+            void submit();
+        }, onKeyDown: (event) => {
+            if (event.key === 'Escape') {
+                close();
+            }
+        }, sx: { mt: 2, display: 'flex', flexDirection: 'column', gap: 2 }, children: [_jsxs(FormControl, { children: [_jsx(FormControl.Label, { children: "Situation" }), _jsx(Textarea, { block: true, rows: 3, resize: "vertical", name: "situation", placeholder: "Help! My payouts have been failing for 3 days.", value: situation, onChange: event => setSituation(event.target.value) })] }), _jsxs(FormControl, { children: [_jsx(FormControl.Label, { children: "Question" }), _jsx(TextInput, { block: true, size: "small", name: "question", placeholder: "Is it urgent?", value: question, onChange: event => setQuestion(event.target.value) })] }), _jsxs(Box, { sx: { display: 'flex', gap: 2 }, children: [_jsxs(FormControl, { sx: { flex: 1 }, children: [_jsx(FormControl.Label, { children: "Type" }), _jsx(Select, { block: true, size: "small", name: "type", value: type, onChange: event => setType(event.target.value), children: Object.keys(DECISION_WORDS.types).map(option => (_jsx(Select.Option, { value: option, children: DECISION_WORDS.types[option] }, option))) })] }), _jsxs(FormControl, { sx: { flex: 1 }, children: [_jsx(FormControl.Label, { children: "Name" }), _jsx(TextInput, { block: true, size: "small", name: "name", placeholder: "Answer", value: name, onChange: event => setName(event.target.value) })] })] }), type === 'choice' && (_jsxs(FormControl, { children: [_jsx(FormControl.Label, { children: "Options, one per line" }), _jsx(Textarea, { block: true, rows: 3, resize: "vertical", name: "options", placeholder: 'Billing\nTech\nSales', value: options, onChange: event => setOptions(event.target.value) })] })), type === 'score' && (_jsxs(Box, { sx: { display: 'flex', gap: 2 }, children: [_jsxs(FormControl, { sx: { flex: 1 }, children: [_jsx(FormControl.Label, { children: "From" }), _jsx(TextInput, { block: true, size: "small", type: "number", name: "from", value: from, onChange: event => setFrom(event.target.value) })] }), _jsxs(FormControl, { sx: { flex: 1 }, children: [_jsx(FormControl.Label, { children: "To" }), _jsx(TextInput, { block: true, size: "small", type: "number", name: "to", value: to, onChange: event => setTo(event.target.value) })] })] })), problem ? (_jsx(Text, { as: "p", role: "alert", sx: { m: 0, color: 'danger.fg', fontSize: 0 }, children: problem })) : null, _jsxs(Box, { sx: { display: 'flex', gap: 2 }, children: [_jsx(Button, { size: "small", variant: "primary", type: "submit", disabled: asking, children: asking ? DECISION_WORDS.asking : DECISION_WORDS.submit }), _jsx(Button, { size: "small", type: "button", onClick: close, disabled: asking, children: DECISION_WORDS.cancel })] })] }));
+}
+export default DecisionAsk;

package/lib/chat/assistant/SpeechBalloon.d.ts

@@ -3,12 +3,15 @@
  * assistant's character, or the floating popup's button while the chat is
  * closed: the agent's newest words, as the Office Assistant said them
  * (LOOP T-23), with *Open the conversation* when there is more — and an
- * approval it waits on, answered there with *Approve* or *Deny*.
+ * approval it waits on, answered there with *Approve* or *Deny* — and, where
+ * the runtime can be asked, *Ask a decision*: a typed decision asked of Jev,
+ * its answer said back in the balloon.
  *
  * @module chat/assistant/SpeechBalloon
  */
 import type { JSX } from 'react';
 import { type BalloonApproval } from './state';
+import type { DecisionAsker } from './decisions';
 export interface SpeechBalloonProps {
     text: string;
     /** There is more than the balloon holds. */
@@ -25,6 +28,12 @@ export interface SpeechBalloonProps {
     tailAt: number;
     /** An approval it waits on: what is asked, and the two answers. */
     approval?: BalloonApproval;
+    /** Asks a typed decision of the runtime: offers *Ask a decision*. */
+    decide?: DecisionAsker;
+    /** The decision's form or answer is on screen: it stays, and is wider. */
+    onDecisionActive?: (active: boolean) => void;
+    /** Wider, for the decision's form. */
+    wide?: boolean;
 }
-export declare function SpeechBalloon({ text, more, onOpen, above, side, align, tailAt, approval, }: SpeechBalloonProps): JSX.Element;
+export declare function SpeechBalloon({ text, more, onOpen, above, side, align, tailAt, approval, decide, onDecisionActive, wide, }: SpeechBalloonProps): JSX.Element;
 export default SpeechBalloon;

package/lib/chat/assistant/SpeechBalloon.js

@@ -2,7 +2,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Button, Text } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
 import { ASSISTANT_WORDS } from './state';
-export function SpeechBalloon({ text, more = false, onOpen, above, side = 'above', align, tailAt, approval, }) {
+import { DecisionAsk } from './DecisionAsk';
+export function SpeechBalloon({ text, more = false, onOpen, above, side = 'above', align, tailAt, approval, decide, onDecisionActive, wide = false, }) {
     return (_jsxs(Box, { role: "status", "aria-live": "polite", "data-speech-balloon": "", sx: {
             position: 'absolute',
             // Pixels, as strings: a number here is read as the theme's space
@@ -11,8 +12,8 @@ export function SpeechBalloon({ text, more = false, onOpen, above, side = 'above
                 ? { bottom: `${above}px` }
                 : { top: `${above}px` }),
             [align]: 0,
-            maxWidth: 280,
-            width: 'max-content',
+            maxWidth: wide ? 300 : 280,
+            width: wide ? 300 : 'max-content',
             px: 3,
             py: 2,
             bg: 'canvas.default',
@@ -37,7 +38,7 @@ export function SpeechBalloon({ text, more = false, onOpen, above, side = 'above
                 borderColor: 'border.default',
                 transform: side === 'above' ? 'rotate(45deg)' : 'rotate(225deg)',
             },
-        }, children: [_jsx(Text, { as: "p", sx: { m: 0 }, children: text }), approval && (_jsxs(Box, { "data-balloon-approval": approval.id, sx: { mt: 1 }, children: [_jsx(Text, { as: "p", sx: { m: 0, fontWeight: 'semibold' }, children: approval.asks }), approval.why ? (_jsx(Text, { as: "p", sx: { m: 0, color: 'fg.muted', fontSize: 0 }, children: approval.why })) : null, _jsxs(Box, { sx: { display: 'flex', gap: 2, mt: 2 }, children: [_jsx(Button, { size: "small", variant: "primary", disabled: approval.deciding, onClick: approval.onApprove, children: ASSISTANT_WORDS.approve }), _jsx(Button, { size: "small", disabled: approval.deciding, onClick: approval.onDeny, children: ASSISTANT_WORDS.deny })] }), approval.others > 0 ? (_jsx(Text, { as: "p", sx: { m: 0, mt: 1, color: 'fg.muted', fontSize: 0 }, children: `${approval.others} more waiting.` })) : null] })), more && (_jsx(Box, { as: "button", type: "button", onClick: onOpen, sx: {
+        }, children: [_jsx(Text, { as: "p", sx: { m: 0 }, children: text }), approval && (_jsxs(Box, { "data-balloon-approval": approval.id, sx: { mt: 1 }, children: [_jsx(Text, { as: "p", sx: { m: 0, fontWeight: 'semibold' }, children: approval.asks }), approval.why ? (_jsx(Text, { as: "p", sx: { m: 0, color: 'fg.muted', fontSize: 0 }, children: approval.why })) : null, _jsxs(Box, { sx: { display: 'flex', gap: 2, mt: 2 }, children: [_jsx(Button, { size: "small", variant: "primary", disabled: approval.deciding, onClick: approval.onApprove, children: ASSISTANT_WORDS.approve }), _jsx(Button, { size: "small", disabled: approval.deciding, onClick: approval.onDeny, children: ASSISTANT_WORDS.deny })] }), approval.others > 0 ? (_jsx(Text, { as: "p", sx: { m: 0, mt: 1, color: 'fg.muted', fontSize: 0 }, children: `${approval.others} more waiting.` })) : null] })), decide && _jsx(DecisionAsk, { ask: decide, onActiveChange: onDecisionActive }), more && (_jsx(Box, { as: "button", type: "button", onClick: onOpen, sx: {
                     mt: 1,
                     p: 0,
                     border: 0,

package/lib/chat/assistant/decisions.d.ts

@@ -0,0 +1,104 @@
+/**
+ * A decision asked from the floating assistant's balloon: a situation, a
+ * question about it and its type — yes or no, a choice among options, a score
+ * on a range — asked of Jev, the typed-decision model, through the runtime's
+ * `POST /api/v1/configure/inference/decisions`: the route that asks as the
+ * `decide` tool does, with the token the runtime calls its models with.
+ *
+ * The answer comes back in plain words with its confidence: "Urgent: yes
+ * (0.87)", "Team: Billing (0.94)", "Score: 4 of 5 (0.5)".
+ *
+ * @module chat/assistant/decisions
+ */
+/** The three types of a question, as ai-inference names them. */
+export type DecisionType = 'noul' | 'choice' | 'score';
+/** What the balloon's form asks. */
+export interface DecisionAsk {
+    /** The text the question is about: a ticket, a message, a review. */
+    situation: string;
+    /** The question: a statement (yes or no) or a question (choice, score). */
+    question: string;
+    /** Its type. */
+    type: DecisionType;
+    /** A short name the answer is said under ("Urgent", "Team"). */
+    name?: string;
+    /** A choice's options, at least two. */
+    options?: string[];
+    /** A score's range, lowest first: from 1 to 5 by default. */
+    range?: {
+        from: number;
+        to: number;
+    };
+}
+/** One question as the runtime's route takes it (`DecisionQuestion`). */
+export interface DecisionQuestionBody {
+    name: string;
+    type: DecisionType;
+    instructions: string;
+    options: string[];
+}
+/** The body of `POST /configure/inference/decisions`. */
+export interface DecisionsRequestBody {
+    state: string;
+    questions: DecisionQuestionBody[];
+}
+/** One typed answer, as ai-inference gives it. */
+export interface DecisionAnswer {
+    type?: DecisionType;
+    /** noul: the probability that the statement holds. */
+    probability?: number;
+    /** choice: the option chosen. */
+    choice?: string;
+    /** score: the step, from 0. */
+    score?: number;
+    confidence?: number;
+    probabilities?: Record<string, number>;
+    /** score: each step's label, by its index. */
+    legend?: Record<string, string>;
+}
+/** What the route answers: the answers by name, or why nothing was decided. */
+export interface DecisionsResponseBody {
+    model?: string;
+    answers?: Record<string, DecisionAnswer>;
+    refusal?: string;
+}
+/** The balloon's asker: a request in, the route's answer out. */
+export type DecisionAsker = (body: DecisionsRequestBody) => Promise<DecisionsResponseBody>;
+/** The name an answer is said under when the form gave none. */
+export declare const DEFAULT_DECISION_NAME = "Answer";
+/** The default range of a score. */
+export declare const DEFAULT_SCORE_RANGE: {
+    readonly from: 1;
+    readonly to: 5;
+};
+/** The steps of a score's range, lowest first: `1..5` is `["1", …, "5"]`. */
+export declare function scoreSteps(range: {
+    from: number;
+    to: number;
+}): string[];
+/**
+ * Why the form cannot be asked as it is, in a sentence, or `undefined`.
+ */
+export declare function decisionAskProblem(ask: DecisionAsk): string | undefined;
+/** The form's ask as the runtime's route takes it: one named question. */
+export declare function decisionRequest(ask: DecisionAsk): DecisionsRequestBody;
+/** A probability or a confidence as said: two places at most, `0.5`, `0.87`. */
+export declare function confidenceWords(value: number): string;
+/**
+ * One answer in plain words with its confidence: "Urgent: yes (0.87)" — a
+ * no is said with the probability that it does not hold — "Team: Billing
+ * (0.94)", "Score: 4 of 5 (0.5)" — a rubric of words by its step,
+ * "Severity: blocking (0.7)".
+ */
+export declare function decisionAnswerWords(name: string, answer: DecisionAnswer, options?: readonly string[]): string;
+/**
+ * What the route answered, in the balloon's words: the one answer, or the
+ * sentence saying why nothing was decided.
+ */
+export declare function decisionResponseWords(request: DecisionsRequestBody, response: DecisionsResponseBody): string;
+/**
+ * Ask at a runtime: `POST {serverUrl}/api/v1/configure/inference/decisions`,
+ * with the person's token when there is one. A refusal of the route itself
+ * comes back as a sentence, never a throw.
+ */
+export declare function decisionsAskerAt(serverUrl: string, token?: string): DecisionAsker;

package/lib/chat/assistant/decisions.js

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The name an answer is said under when the form gave none. */
+export const DEFAULT_DECISION_NAME = 'Answer';
+/** The default range of a score. */
+export const DEFAULT_SCORE_RANGE = { from: 1, to: 5 };
+/** The longest range a score may have, in steps. */
+const MAX_SCORE_STEPS = 11;
+/** The steps of a score's range, lowest first: `1..5` is `["1", …, "5"]`. */
+export function scoreSteps(range) {
+    const steps = [];
+    for (let step = range.from; step <= range.to; step += 1) {
+        steps.push(String(step));
+    }
+    return steps;
+}
+/**
+ * Why the form cannot be asked as it is, in a sentence, or `undefined`.
+ */
+export function decisionAskProblem(ask) {
+    if (!ask.situation.trim()) {
+        return 'Say the situation the question is about.';
+    }
+    if (!ask.question.trim()) {
+        return 'Ask a question.';
+    }
+    if (ask.type === 'choice') {
+        const options = (ask.options ?? []).filter(option => option.trim());
+        if (options.length < 2) {
+            return 'A choice needs at least two options.';
+        }
+        if (new Set(options.map(option => option.trim())).size !== options.length) {
+            return 'Two options are the same.';
+        }
+    }
+    if (ask.type === 'score') {
+        const range = ask.range ?? DEFAULT_SCORE_RANGE;
+        if (!Number.isInteger(range.from) || !Number.isInteger(range.to)) {
+            return 'A score goes from a whole number to another.';
+        }
+        if (range.to <= range.from) {
+            return 'A score goes from a lower number to a higher one.';
+        }
+        if (range.to - range.from + 1 > MAX_SCORE_STEPS) {
+            return `A score has at most ${MAX_SCORE_STEPS} steps.`;
+        }
+    }
+    return undefined;
+}
+/** The form's ask as the runtime's route takes it: one named question. */
+export function decisionRequest(ask) {
+    const options = ask.type === 'choice'
+        ? (ask.options ?? []).map(option => option.trim()).filter(Boolean)
+        : ask.type === 'score'
+            ? scoreSteps(ask.range ?? DEFAULT_SCORE_RANGE)
+            : [];
+    return {
+        state: ask.situation.trim(),
+        questions: [
+            {
+                name: ask.name?.trim() || DEFAULT_DECISION_NAME,
+                type: ask.type,
+                instructions: ask.question.trim(),
+                options,
+            },
+        ],
+    };
+}
+/** A probability or a confidence as said: two places at most, `0.5`, `0.87`. */
+export function confidenceWords(value) {
+    return String(Number(value.toFixed(2)));
+}
+/**
+ * One answer in plain words with its confidence: "Urgent: yes (0.87)" — a
+ * no is said with the probability that it does not hold — "Team: Billing
+ * (0.94)", "Score: 4 of 5 (0.5)" — a rubric of words by its step,
+ * "Severity: blocking (0.7)".
+ */
+export function decisionAnswerWords(name, answer, options = []) {
+    if (typeof answer.probability === 'number' && answer.choice === undefined) {
+        const holds = answer.probability >= 0.5;
+        return `${name}: ${holds ? 'yes' : 'no'} (${confidenceWords(holds ? answer.probability : 1 - answer.probability)})`;
+    }
+    const confidence = typeof answer.confidence === 'number'
+        ? ` (${confidenceWords(answer.confidence)})`
+        : '';
+    if (typeof answer.score === 'number') {
+        const steps = options.length
+            ? options
+            : Object.keys(answer.legend ?? {})
+                .sort((a, b) => Number(a) - Number(b))
+                .map(key => answer.legend?.[key] ?? key);
+        const said = answer.legend?.[String(answer.score)] ?? steps[answer.score];
+        const last = steps[steps.length - 1];
+        // A range of numbers says where on it ("4 of 5"); a rubric of words says
+        // its step ("blocking").
+        const numeric = steps.length > 0 && steps.every(step => /^-?\d+$/.test(step.trim()));
+        return `${name}: ${said ?? answer.score + 1}${numeric && last !== undefined ? ` of ${last}` : ''}${confidence}`;
+    }
+    if (typeof answer.choice === 'string') {
+        return `${name}: ${answer.choice}${confidence}`;
+    }
+    return `${name}: no answer`;
+}
+/**
+ * What the route answered, in the balloon's words: the one answer, or the
+ * sentence saying why nothing was decided.
+ */
+export function decisionResponseWords(request, response) {
+    if (response.refusal) {
+        return response.refusal;
+    }
+    const [question] = request.questions;
+    const answer = response.answers?.[question.name];
+    if (!answer) {
+        return 'Nothing was decided: the answer did not come back.';
+    }
+    return decisionAnswerWords(question.name, answer, question.options);
+}
+/**
+ * Ask at a runtime: `POST {serverUrl}/api/v1/configure/inference/decisions`,
+ * with the person's token when there is one. A refusal of the route itself
+ * comes back as a sentence, never a throw.
+ */
+export function decisionsAskerAt(serverUrl, token) {
+    const base = serverUrl.replace(/\/+$/, '');
+    return async (body) => {
+        let response;
+        try {
+            response = await fetch(`${base}/api/v1/configure/inference/decisions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch {
+            return {
+                refusal: 'Nothing was decided: the runtime could not be reached.',
+            };
+        }
+        if (!response.ok) {
+            let detail = '';
+            try {
+                const said = (await response.json());
+                detail = typeof said.detail === 'string' ? said.detail : '';
+            }
+            catch {
+                // No body worth saying.
+            }
+            return {
+                refusal: `Nothing was decided: the runtime refused it (${response.status})${detail ? `: ${detail}` : '.'}`,
+            };
+        }
+        return (await response.json());
+    };
+}

package/lib/chat/marks/toolMarks.js

@@ -16,7 +16,7 @@
 import { MCP_SERVER_LIBRARY } from '../../specs/mcpServers';
 import { SKILLS_CATALOG } from '../../specs/skills';
 import { FRONTEND_TOOL_CATALOG } from '../../specs/frontendTools';
-import { TOOL_CATALOG } from '../../specs/tools';
+import { BACKEND_TOOL_CATALOG } from '../../specs/backendTools';
 /** The tools the skills area runs a skill through. */
 export const SKILL_TOOLS = new Set([
     'run_skill_script',
@@ -57,7 +57,7 @@ function frontendTools() {
 function runtimeTools() {
     if (!runtimeIndex) {
         runtimeIndex = new Map();
-        for (const spec of Object.values(TOOL_CATALOG)) {
+        for (const spec of Object.values(BACKEND_TOOL_CATALOG)) {
             const method = spec.runtime?.method;
             if (method && !runtimeIndex.has(method)) {
                 runtimeIndex.set(method, { id: spec.id, ...marksOf(spec) });

package/lib/config/AgentConfiguration.d.ts

@@ -19,7 +19,8 @@ export interface LibraryAgentspec {
     icon?: string | null;
     color?: string | null;
     skills: string[];
-    tools?: string[];
+    /** Backend tools (agentspecs/backend-tools), as the runtime serves them. */
+    backendTools?: string[];
     systemPrompt?: string | null;
     systemPromptCodemodeAddons?: string | null;
     suggestions: string[];

package/lib/config/AgentConfiguration.js

@@ -477,10 +477,10 @@ export const AgentConfiguration = ({ agentLibrary, protocol: transport, extensio
             .map(selection => normalizeMcpServerId(selection.id));
     }, [selectedMcpServers, catalogServerIdSet]);
     const resolvedSpecTools = useMemo(() => {
-        if (!activeSpec || !Array.isArray(activeSpec.tools)) {
+        if (!activeSpec || !Array.isArray(activeSpec.backendTools)) {
             return [];
         }
-        return activeSpec.tools
+        return activeSpec.backendTools
             .map(tool => normalizeToolLabel(tool))
             .filter((tool) => !!tool);
     }, [activeSpec]);

package/lib/examples/AgentDecideExample.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Decide: typed decisions asked of Jev (`cloudflare:wrk/typesafe/jev`), the
+ * typed-decision model, from the chat and from the floating assistant.
+ *
+ * The *Decide* application of the catalogue (agentspecs `apps/decide.yaml`)
+ * in the LOOP workspace, on the Local target: its agent — `example-simple`
+ * with the `decide` tool — runs on the local agent-runtimes server, and
+ * answers a question about a text by asking a typed decision. The floating
+ * assistant beside it offers *Ask a decision* in its balloon: the situation,
+ * the question and its type, asked through the same server's
+ * `/api/v1/configure/inference/decisions`, the route that asks as `decide`
+ * does, with the same token.
+ *
+ * The server needs ai-inference: start it with
+ * `AGENT_RUNTIMES_INFERENCE_PROVIDER_OVERRIDE=datalayer`,
+ * `DATALAYER_AI_INFERENCE_URL=https://r1.datalayer.run` and
+ * `DATALAYER_AI_INFERENCE_API_KEY` set from `DATALAYER_API_KEY`. Another
+ * server than `http://localhost:8765` is named with `?agentRuntimesUrl=`.
+ *
+ * @module examples/AgentDecideExample
+ */
+import React from 'react';
+declare const AgentDecideExample: React.FC;
+export default AgentDecideExample;