@datalayer/agent-runtimes 1.3.30 → 1.3.32

package/lib/examples/ChatAssistantExample.js

@@ -7,14 +7,31 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * The floating assistant (LOOP T-21 to T-27): the chat as a character on the
  * page, after the Office Assistant — Datalayer's own characters, chosen
  * here, acting out what the agent does and speaking in a balloon.
+ *
+ * The characters offered are what the enabled plugins contribute to
+ * `loop.assistant.character` (T-24): Datalayer's four, and an owl from a
+ * small example plugin (`utils/owlCharacterPlugin`).
  */
 import { useState } from 'react';
+import { buildReactorFromPlugins } from '@datalayer/reactor';
 import { Button, Heading, Text } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
 import { ThemedProvider } from './utils/themedProvider';
 import { ChatFloating } from '../chat';
-import { ASSISTANT_CHARACTERS } from '../chat/assistant/characters';
+import { AssistantCharactersPlugin, assistantCharacterNamed, assistantCharactersOf, } from '../loop/plugins/assistant-characters';
+import { OwlCharacterPlugin } from './utils/owlCharacterPlugin';
 import { readAcsCharacter, readClippyCharacter, } from '../chat/assistant/formats';
+/** The plugins this page enables: Datalayer's characters and the owl's. */
+const reactor = buildReactorFromPlugins([
+    AssistantCharactersPlugin,
+    OwlCharacterPlugin,
+]);
+reactor.start();
+/** The catalogue: what the enabled plugins contribute. */
+const CATALOGUE = assistantCharactersOf(reactor).map(entry => ({
+    id: entry.id,
+    name: entry.character.name,
+}));
 /**
  * A character file a person picked, read in the page (T-26): one `.acs`, or
  * a clippy.js character's `agent.js` and `map.png` (and its sounds file).
@@ -37,12 +54,16 @@ async function readPicked(files) {
     });
 }
 const ChatAssistantExample = () => {
-    const [character, setCharacter] = useState(ASSISTANT_CHARACTERS[0].id);
+    const [character, setCharacter] = useState('paperclip');
+    // A character chosen by id is the one its plugin contributes.
+    const drawn = typeof character === 'string'
+        ? assistantCharacterNamed(reactor, character)
+        : character;
     const [loadError, setLoadError] = useState();
-    return (_jsx(ThemedProvider, { children: _jsxs(Box, { sx: { minHeight: '100vh', bg: 'canvas.default', p: 4 }, children: [_jsxs(Box, { sx: { maxWidth: 720, mx: 'auto' }, children: [_jsx(Heading, { as: "h1", sx: { mb: 2 }, children: "Floating assistant" }), _jsx(Text, { as: "p", sx: { color: 'fg.muted', mb: 3 }, children: "The chat as a character on the page. It greets you, acts out what the agent is doing, and says the agent\u2019s words in a balloon while the conversation is closed. Click it to talk, drag it to move it, hover it to send it away." }), _jsx(Box, { sx: { display: 'flex', gap: 2, flexWrap: 'wrap' }, children: ASSISTANT_CHARACTERS.map(option => (_jsx(Button, { variant: option.id === character ? 'primary' : 'default', onClick: () => {
+    return (_jsx(ThemedProvider, { children: _jsxs(Box, { sx: { minHeight: '100vh', bg: 'canvas.default', p: 4 }, children: [_jsxs(Box, { sx: { maxWidth: 720, mx: 'auto' }, children: [_jsx(Heading, { as: "h1", sx: { mb: 2 }, children: "Floating assistant" }), _jsx(Text, { as: "p", sx: { color: 'fg.muted', mb: 3 }, children: "The chat as a character on the page. It greets you, acts out what the agent is doing, and says the agent\u2019s words in a balloon while the conversation is closed. Click it to talk, drag it to move it, hover it to send it away." }), _jsx(Box, { sx: { display: 'flex', gap: 2, flexWrap: 'wrap' }, children: CATALOGUE.map(option => (_jsx(Button, { variant: option.id === character ? 'primary' : 'default', onClick: () => {
                                     setCharacter(option.id);
                                     setLoadError(undefined);
-                                }, "aria-pressed": option.id === character, children: option.name }, option.id))) }), _jsxs(Box, { as: "section", sx: { mt: 4 }, children: [_jsx(Heading, { as: "h2", sx: { fontSize: 2, mb: 1 }, children: "A character you bring" }), _jsxs(Text, { as: "p", sx: { color: 'fg.muted', mb: 2 }, children: ["The characters of Microsoft Office \u2014 Clippy, Merlin, Links and the others \u2014 are Microsoft\u2019s. Load only a character file you have the right to use: a Microsoft Agent ", _jsx("code", { children: ".acs" }), " file, or a clippy.js character\u2019s ", _jsx("code", { children: "agent.js" }), " and map image. It is read in this page and sent nowhere."] }), _jsx("input", { type: "file", multiple: true, accept: ".acs,.js,.png,.gif,.webp,.jpg,.jpeg", "aria-label": "Character files", onChange: async (event) => {
+                                }, "aria-pressed": option.id === character, "data-assistant-character": option.id, children: option.name }, option.id))) }), _jsxs(Box, { as: "section", sx: { mt: 4 }, children: [_jsx(Heading, { as: "h2", sx: { fontSize: 2, mb: 1 }, children: "A character you bring" }), _jsxs(Text, { as: "p", sx: { color: 'fg.muted', mb: 2 }, children: ["The characters of Microsoft Office \u2014 Clippy, Merlin, Links and the others \u2014 are Microsoft\u2019s. Load only a character file you have the right to use: a Microsoft Agent ", _jsx("code", { children: ".acs" }), " file, or a clippy.js character\u2019s ", _jsx("code", { children: "agent.js" }), " and map image. It is read in this page and sent nowhere."] }), _jsx("input", { type: "file", multiple: true, accept: ".acs,.js,.png,.gif,.webp,.jpg,.jpeg", "aria-label": "Character files", onChange: async (event) => {
                                         const files = Array.from(event.target.files ?? []);
                                         if (!files.length) {
                                             return;
@@ -54,6 +75,6 @@ const ChatAssistantExample = () => {
                                         catch (error) {
                                             setLoadError(error instanceof Error ? error.message : String(error));
                                         }
-                                    } }), loadError && (_jsx(Text, { as: "p", role: "alert", sx: { color: 'danger.fg', mt: 2 }, children: loadError })), typeof character !== 'string' && (_jsxs(Text, { as: "p", sx: { mt: 2 }, children: ["Playing ", character.name, "."] }))] })] }), _jsx(ChatFloating, { defaultViewMode: "assistant", assistantCharacter: character, protocol: "vercel-ai", endpoint: "http://127.0.0.1:8765/api/v1/vercel-ai/assistant", title: "Assistant", description: "Hello! Ask me anything about this page.", position: "bottom-right", useStore: false }, typeof character === 'string' ? character : character.sprite)] }) }));
+                                    } }), loadError && (_jsx(Text, { as: "p", role: "alert", sx: { color: 'danger.fg', mt: 2 }, children: loadError })), typeof character !== 'string' && (_jsxs(Text, { as: "p", sx: { mt: 2 }, children: ["Playing ", character.name, "."] }))] })] }), _jsx(ChatFloating, { defaultViewMode: "assistant", assistantCharacter: drawn, protocol: "vercel-ai", endpoint: "http://127.0.0.1:8765/api/v1/vercel-ai/assistant", title: "Assistant", description: "Hello! Ask me anything about this page.", position: "bottom-right", useStore: false }, typeof character === 'string' ? character : character.sprite)] }) }));
 };
 export default ChatAssistantExample;

package/lib/examples/utils/owlCharacterPlugin.d.ts

@@ -0,0 +1,7 @@
+import type { AssistantCharacter } from '../../chat/assistant/characters';
+/** The owl, as the example plugin contributes it. */
+export declare const OWL_CHARACTER: AssistantCharacter;
+export declare const OWL_CHARACTER_PLUGIN_NAME = "@datalayer/example-plugin-owl-character";
+/** The example plugin: one character, contributed to the point. */
+export declare const OwlCharacterPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;
+export default OwlCharacterPlugin;

package/lib/examples/utils/owlCharacterPlugin.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { LoopAssistantCharacter } from '../../loop/core';
+const OWL = {
+    light: {
+        feathers: '#8A5A3C',
+        belly: '#E9D3B8',
+        tufts: '#6B4329',
+        beak: '#E0A54A',
+        eye: '#FFFFFF',
+        ring: '#1D1D1F',
+        pupil: '#1D1D1F',
+    },
+    dark: {
+        feathers: '#C08B66',
+        belly: '#F1E1CC',
+        tufts: '#D9A57F',
+        beak: '#F8D469',
+        eye: '#F5F5F7',
+        ring: '#1D1D1F',
+        pupil: '#131314',
+    },
+};
+function Owl({ size, mode = 'light', }) {
+    const c = OWL[mode];
+    return (_jsx("svg", { width: size, height: size, viewBox: "0 0 96 96", role: "img", "aria-label": "Owl", "data-assistant-mode": mode, children: _jsxs("g", { className: "assistant-body", children: [_jsx("path", { d: "M26 30 L22 10 L40 22 Z", fill: c.tufts }), _jsx("path", { d: "M70 30 L74 10 L56 22 Z", fill: c.tufts }), _jsx("ellipse", { cx: 48, cy: 54, rx: 28, ry: 34, fill: c.feathers }), _jsx("ellipse", { cx: 48, cy: 66, rx: 17, ry: 20, fill: c.belly }), [34, 62].map(x => (_jsx("circle", { cx: x, cy: 40, r: 11, fill: c.eye, stroke: c.ring, strokeWidth: 1.5 }, x))), _jsxs("g", { className: "assistant-pupils", children: [_jsx("circle", { cx: 35, cy: 41, r: 5, fill: c.pupil }), _jsx("circle", { cx: 63, cy: 41, r: 5, fill: c.pupil })] }), _jsxs("g", { className: "assistant-lids", children: [_jsx("ellipse", { cx: 34, cy: 40, rx: 11.5, ry: 11.5, fill: c.feathers }), _jsx("ellipse", { cx: 62, cy: 40, rx: 11.5, ry: 11.5, fill: c.feathers })] }), _jsx("path", { className: "assistant-mouth", d: "M44 50 L52 50 L48 58 Z", fill: c.beak })] }) }));
+}
+/** The owl, as the example plugin contributes it. */
+export const OWL_CHARACTER = {
+    id: 'owl',
+    name: 'Owl',
+    Drawing: Owl,
+};
+export const OWL_CHARACTER_PLUGIN_NAME = '@datalayer/example-plugin-owl-character';
+/** The example plugin: one character, contributed to the point. */
+export const OwlCharacterPlugin = definePlugin({
+    name: OWL_CHARACTER_PLUGIN_NAME,
+    displayName: 'Owl character (example)',
+    description: 'An owl for the floating assistant, contributed by a plugin.',
+    contributes: [
+        contribution(LoopAssistantCharacter, { id: OWL_CHARACTER.id, character: OWL_CHARACTER }, { id: OWL_CHARACTER.id }),
+    ],
+});
+export default OwlCharacterPlugin;

package/lib/loop/apps/AppFeedback.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The feedback strip above an application's prompt (LOOP V-18): once an
+ * answer is in, a thumb up or down and a comment, kept in the application's
+ * record under the conversation it was about.
+ *
+ * Read through what the workspace offers, not around it: the chat keeps the
+ * current turn — the question, the answer, the conversation's thread — in
+ * `LoopChatTurn`, and the composer hangs what is contributed to
+ * `LoopPromptPanel` beside the prompt. `AppRenderer` adds the plugin for an
+ * application whose record keeps feedback, in the Studio's Preview and on
+ * the hosted page alike.
+ *
+ * @module loop/apps/AppFeedback
+ */
+import type { JSX } from 'react';
+import type { AppSpec } from '../../types/agentspecs';
+import { type LoopWorkspaceContext } from '../core';
+export declare const APP_FEEDBACK_PLUGIN_NAME = "@datalayer/loop-plugin-app-feedback";
+export declare function AppFeedback({ app, workspace, }: {
+    app: Pick<AppSpec, 'name'>;
+    workspace: LoopWorkspaceContext;
+}): JSX.Element | null;
+/**
+ * The plugin, for one application: the strip above its prompt. Made once per
+ * application — a new plugin rebuilds the workspace.
+ */
+export declare function defineAppFeedbackPlugin(app: AppSpec): import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;

package/lib/loop/apps/AppFeedback.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Button, IconButton, Text, Textarea } from '@primer/react';
+import { ThumbsdownIcon, ThumbsupIcon } from '@primer/octicons-react';
+import { contribution, definePlugin, signal } from '@datalayer/reactor';
+import { useContributions, useSignalValue } from '@datalayer/reactor/react';
+import { useIAMStore } from '../../state';
+import { LoopChatTurn, LoopPromptPanel, } from '../core';
+import { FEEDBACK_WORDS, sendFeedback } from './feedback';
+export const APP_FEEDBACK_PLUGIN_NAME = '@datalayer/loop-plugin-app-feedback';
+/* A signal to read when no chat contributed a turn: the hook needs one. */
+const NO_TURN = signal({ id: 0, status: 'idle' });
+export function AppFeedback({ app, workspace, }) {
+    const turns = useContributions(LoopChatTurn);
+    const turn = useSignalValue(turns[0]?.value.turn ?? NO_TURN);
+    const token = useIAMStore(state => state.token);
+    const [liked, setLiked] = useState(null);
+    const [comment, setComment] = useState('');
+    const [said, setSaid] = useState(null);
+    // Only under an answer that is in, in a conversation the runtime named.
+    if (turn.status !== 'done' || !turn.assistant || !turn.thread) {
+        return null;
+    }
+    const thread = turn.thread;
+    const choice = liked?.turn === turn.id ? liked.liked : null;
+    const done = said?.turn === turn.id ? said : null;
+    const agentBaseUrl = workspace.sandbox.agentBaseUrl || workspace.serverUrl || '';
+    const send = async () => {
+        if (choice === null) {
+            return;
+        }
+        setSaid({ turn: turn.id, state: 'sending', says: '' });
+        try {
+            await sendFeedback({ session: thread, liked: choice, comment }, { agentBaseUrl, token });
+            setSaid({
+                turn: turn.id,
+                state: 'kept',
+                says: FEEDBACK_WORDS.kept(app.name),
+            });
+            setComment('');
+        }
+        catch (error) {
+            setSaid({
+                turn: turn.id,
+                state: 'refused',
+                says: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+    if (done?.state === 'kept') {
+        return (_jsx("div", { style: { padding: '4px 8px' }, children: _jsx(Text, { sx: { fontSize: 0, color: 'fg.muted' }, children: done.says }) }));
+    }
+    return (_jsxs("div", { role: "group", "aria-label": FEEDBACK_WORDS.ask, style: {
+            display: 'flex',
+            flexDirection: 'column',
+            gap: 4,
+            padding: '4px 8px',
+        }, children: [_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 4 }, children: [_jsx(Text, { sx: { fontSize: 0, color: 'fg.muted' }, children: FEEDBACK_WORDS.ask }), _jsx(IconButton, { size: "small", variant: choice === true ? 'primary' : 'invisible', icon: ThumbsupIcon, "aria-label": FEEDBACK_WORDS.liked, "aria-pressed": choice === true, onClick: () => setLiked({ turn: turn.id, liked: true }) }), _jsx(IconButton, { size: "small", variant: choice === false ? 'danger' : 'invisible', icon: ThumbsdownIcon, "aria-label": FEEDBACK_WORDS.disliked, "aria-pressed": choice === false, onClick: () => setLiked({ turn: turn.id, liked: false }) })] }), choice !== null ? (_jsxs(_Fragment, { children: [_jsx(Textarea, { "aria-label": FEEDBACK_WORDS.comment, placeholder: FEEDBACK_WORDS.comment, value: comment, rows: 2, resize: "vertical", block: true, onChange: event => setComment(event.target.value) }), _jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 8 }, children: [_jsx(Button, { size: "small", variant: "primary", disabled: done?.state === 'sending', onClick: () => void send(), children: FEEDBACK_WORDS.send }), _jsx(Text, { sx: { fontSize: 0, color: 'fg.muted' }, children: FEEDBACK_WORDS.where(app.name) })] })] })) : null, done?.state === 'refused' ? (_jsx(Text, { sx: { fontSize: 0, color: 'danger.fg' }, children: done.says })) : null] }));
+}
+/**
+ * The plugin, for one application: the strip above its prompt. Made once per
+ * application — a new plugin rebuilds the workspace.
+ */
+export function defineAppFeedbackPlugin(app) {
+    function Panel({ workspace, }) {
+        return _jsx(AppFeedback, { app: app, workspace: workspace });
+    }
+    return definePlugin({
+        name: `${APP_FEEDBACK_PLUGIN_NAME}-${app.id}`,
+        displayName: `${app.name}: feedback`,
+        description: `A thumb and a comment on each answer of ${app.name}, kept in its record.`,
+        octicon: 'thumbsup',
+        emoji: '\u{1F44D}',
+        contributes: [
+            contribution(LoopPromptPanel, { id: 'app-feedback', placement: 'above', order: 20, Component: Panel }, { id: 'app-feedback' }),
+        ],
+    });
+}

package/lib/loop/apps/AppRenderer.js

@@ -38,6 +38,8 @@ import { defineAgentCapacityPlugin } from '../plugins/agent-capacity';
 import { APP_PAGE_SURFACE, defineAppPagePlugin, hasAppPage, } from '../plugins/app-page';
 import { LoopEmbed } from '../embed/LoopEmbed';
 import { dumpAppspec } from './appspec';
+import { defineAppFeedbackPlugin } from './AppFeedback';
+import { keepsFeedback } from './feedback';
 /** The id of an agent or a Cog, without its version. */
 export const agentIdOf = (app) => {
     const reference = app.agent || app.team;
@@ -171,9 +173,22 @@ export function AppRenderer({ app, plugins = NO_PLUGINS, instance, onPresence, f
     const pagePlugin = useMemo(() => (withPage ? defineAppPagePlugin(app) : null), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [source, withPage]);
+    /*
+     * A thumb and a comment on each answer, kept in its record (LOOP V-18):
+     * only for an application whose record keeps feedback.
+     */
+    const keeps = keepsFeedback(app);
+    const feedbackPlugin = useMemo(() => (keeps ? defineAppFeedbackPlugin(app) : null), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [source, keeps]);
     const allPlugins = useMemo(() => appPlugin
-        ? [appPlugin, ...(pagePlugin ? [pagePlugin] : []), ...plugins]
-        : plugins, [appPlugin, pagePlugin, plugins]);
+        ? [
+            appPlugin,
+            ...(pagePlugin ? [pagePlugin] : []),
+            ...(feedbackPlugin ? [feedbackPlugin] : []),
+            ...plugins,
+        ]
+        : plugins, [appPlugin, pagePlugin, feedbackPlugin, plugins]);
     /*
      * On Datalayer, the application runs on a runtime: allocated with a plain
      * agentspec, its agent created there with the application's spec — so that

package/lib/loop/apps/appspec.js

@@ -105,6 +105,7 @@ export function emptyAppspec(kind = 'chat') {
             keepFor: DEFAULT_KEEP_FOR,
             retentionDays: retentionDays(DEFAULT_KEEP_FOR),
             include: [...DEFAULT_RECORD_INCLUDE],
+            suggestTests: false,
         },
         checks: { guards: [], gates: [], track: '' },
         deployment: {},
@@ -243,7 +244,7 @@ function parseDecision(data) {
             name: text(scenario.name),
             weights: Object.fromEntries(Object.entries(isData(scenario.weights) ? scenario.weights : {}).filter((entry) => typeof entry[1] === 'number')),
         })),
-        judgmentModel: text(data.judgment_model),
+        decisionModel: text(data.decision_model),
     };
 }
 function parseDeployment(data) {
@@ -359,6 +360,7 @@ export function parseAppspec(document) {
             include: Array.isArray(record.include)
                 ? texts(record.include)
                 : [...DEFAULT_RECORD_INCLUDE],
+            suggestTests: record.suggest_tests === true,
         },
         checks: {
             guards: texts(checks.guards),
@@ -493,7 +495,7 @@ function dumpDecision(decision) {
         .text('name', scenario.name, '\u0000')
         // By criterion name, in alphabetical order: the spec declares no order.
         .part('weights', sorted(scenario.weights)).data))
-        .text('judgment_model', decision.judgmentModel).data;
+        .text('decision_model', decision.decisionModel).data;
 }
 /**
  * An application as the document its file holds.
@@ -554,7 +556,8 @@ export function dumpAppspec(app) {
     }))).data)
         .part('record', new Writer()
         .text('keep_for', app.record.keepFor, DEFAULT_KEEP_FOR)
-        .list('include', app.record.include, DEFAULT_RECORD_INCLUDE).data)
+        .list('include', app.record.include, DEFAULT_RECORD_INCLUDE)
+        .value('suggest_tests', app.record.suggestTests, false).data)
         .part('checks', new Writer()
         .list('guards', app.checks.guards)
         .list('gates', app.checks.gates)

package/lib/loop/apps/checks.d.ts

@@ -16,8 +16,16 @@ export interface AppCheck {
 export declare const componentNamed: (name: string) => ComponentSpec | undefined;
 /** The Guards the runtime executes (agent-runtimes `loop/apps/guards.py`). */
 export declare const EXECUTED_GUARDS: readonly string[];
+/**
+ * Where an application is checked: the plugins its organization has turned
+ * off (catalogue ids, `plugins_off` in IAM), none when it has decided nothing
+ * or the checks run with no organization.
+ */
+export interface CheckContext {
+    pluginsOff: readonly string[];
+}
 /** The instant checks of an application as an editor holds it. */
-export declare function checkApp(app: AppSpec, read?: string[]): AppCheck;
+export declare function checkApp(app: AppSpec, read?: string[], context?: CheckContext): AppCheck;
 /**
  * What the document says in a shape the spec refuses — a list where a list is
  * not, a word where a choice is — which the tolerant reader replaces with a
@@ -25,4 +33,4 @@ export declare function checkApp(app: AppSpec, read?: string[]): AppCheck;
  */
 export declare function documentShapeProblems(document: unknown): string[];
 /** The instant checks of an application's document, what reading it found included. */
-export declare function checkAppspec(document: unknown): AppCheck;
+export declare function checkAppspec(document: unknown, context?: CheckContext): AppCheck;

package/lib/loop/apps/checks.js

@@ -38,6 +38,7 @@ import { getSkillSpec } from '../../specs/skills';
 import { getTeamSpec } from '../../specs/teams';
 import { getToolSpec } from '../../specs/tools';
 import { getTrack } from '../../specs/tracks';
+import { pluginsOffSetupNotes } from '../plugins/canvas-blocks';
 import { parseAppspec } from './appspec';
 import { classesOf, splitRef, toolBehaviours } from './rules';
 export const NOT_READY = 'Not ready';
@@ -192,14 +193,14 @@ function referenceProblems(app) {
             problems.push(`The surface's “${String(node.id)}” is a “${String(node.component)}”, which the catalog does not have.`);
         }
     }
-    const judge = app.decision?.judgmentModel;
-    if (judge) {
-        const model = getModel(judge);
+    const decider = app.decision?.decisionModel;
+    if (decider) {
+        const model = getModel(decider);
         if (!model) {
-            problems.push(`There is no model named “${judge}” to judge with.`);
+            problems.push(`There is no model named “${decider}” to decide with.`);
         }
-        else if (!(model.capabilities ?? []).includes('judgments')) {
-            problems.push(`The model “${judge}” does not answer typed judgments.`);
+        else if (!(model.capabilities ?? []).includes('decisions')) {
+            problems.push(`The model “${decider}” does not answer typed decisions.`);
         }
     }
     const run = new Set(app.checks.guards.map(idOf));
@@ -336,10 +337,16 @@ function setupNotes(app) {
         note('notification', ref, getNotificationSpec(idOf(ref)));
     return setup;
 }
+const NO_ORGANIZATION = { pluginsOff: [] };
 /** The instant checks of an application as an editor holds it. */
-export function checkApp(app, read = []) {
+export function checkApp(app, read = [], context = NO_ORGANIZATION) {
     const problems = [...read, ...shapeProblems(app), ...referenceProblems(app)];
-    const setup = setupNotes(app);
+    // A block its page uses from a plugin its organization turned off is said
+    // with the rest of what is not enabled today (C-12).
+    const setup = [
+        ...setupNotes(app),
+        ...pluginsOffSetupNotes(app, context.pluginsOff),
+    ];
     if (problems.length > 0) {
         return { verdict: NOT_READY, problems, attention: [], setup };
     }
@@ -540,6 +547,10 @@ export function documentShapeProblems(document) {
             else
                 record.include.forEach((item, index) => oneOf(item, ENUMS.record, `record.include.${index}`));
         }
+        if (record.suggest_tests !== undefined &&
+            typeof record.suggest_tests !== 'boolean') {
+            at('record.suggest_tests', 'is true or false');
+        }
     });
     mapping(d.checks, 'checks', checks => {
         texts(checks.guards, 'checks.guards');
@@ -596,7 +607,7 @@ export function documentShapeProblems(document) {
     return problems;
 }
 /** The instant checks of an application's document, what reading it found included. */
-export function checkAppspec(document) {
+export function checkAppspec(document, context = NO_ORGANIZATION) {
     const { app, problems } = parseAppspec(document);
-    return checkApp(app, [...problems, ...documentShapeProblems(document)]);
+    return checkApp(app, [...problems, ...documentShapeProblems(document)], context);
 }

package/lib/loop/apps/feedback.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Feedback from the people who use an application (LOOP V-18): a thumb up or
+ * down on an answer, and a comment, kept in the application's record.
+ *
+ * Kept only when the application's `record.include` names `feedback` — its
+ * builder says what its record keeps, and the chat offers nothing it would
+ * not keep. Sent to the runtime the conversation runs on
+ * (`POST /api/v1/apps/feedback`), which writes it through the recorder of
+ * that conversation, under its session: the conversation's AG-UI thread.
+ *
+ * Pure: no React; the network is the `fetch` it is handed.
+ *
+ * @module loop/apps/feedback
+ */
+import type { AppSpec } from '../../types/agentspecs';
+/** The longest comment kept, as the runtime holds it (`COMMENT_LIMIT`). */
+export declare const FEEDBACK_COMMENT_LIMIT = 2000;
+/** What a person says of an answer. */
+export type Feedback = {
+    /** The conversation, as the runtime knows it. */
+    session: string;
+    liked: boolean;
+    comment: string;
+};
+/** What the feedback strip says, in a person's words. */
+export declare const FEEDBACK_WORDS: {
+    readonly ask: "Was this answer useful?";
+    readonly liked: "Useful";
+    readonly disliked: "Not useful";
+    readonly comment: "Anything to add? (optional)";
+    readonly send: "Send";
+    readonly kept: (app: string) => string;
+    readonly where: (app: string) => string;
+    readonly tooLong: "A comment is at most 2000 characters.";
+    readonly noSession: "This conversation has no name the application knows yet: send a message first.";
+};
+/** Whether an application keeps feedback: its record names it. */
+export declare const keepsFeedback: (app: Pick<AppSpec, "record">) => boolean;
+/** Where feedback is sent, on the runtime an application runs on. */
+export declare const feedbackEndpoint: (agentBaseUrl: string) => string;
+/** Why feedback cannot be sent as it is; nothing when it can. */
+export declare function feedbackProblems(feedback: Feedback): string[];
+/**
+ * Send feedback to the runtime, and say what it kept: the entry, in a
+ * sentence. A refusal throws the runtime's own sentence.
+ */
+export declare function sendFeedback(feedback: Feedback, { agentBaseUrl, token, fetcher, }: {
+    agentBaseUrl: string;
+    token?: string | null;
+    fetcher?: typeof fetch;
+}): Promise<string>;

package/lib/loop/apps/feedback.js

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The longest comment kept, as the runtime holds it (`COMMENT_LIMIT`). */
+export const FEEDBACK_COMMENT_LIMIT = 2000;
+/** What the feedback strip says, in a person's words. */
+export const FEEDBACK_WORDS = {
+    ask: 'Was this answer useful?',
+    liked: 'Useful',
+    disliked: 'Not useful',
+    comment: 'Anything to add? (optional)',
+    send: 'Send',
+    kept: (app) => `Thank you. Kept in ${app}’s record.`,
+    where: (app) => `What you say is kept with this conversation in ${app}’s record, for its builder to read.`,
+    tooLong: `A comment is at most ${FEEDBACK_COMMENT_LIMIT} characters.`,
+    noSession: 'This conversation has no name the application knows yet: send a message first.',
+};
+/** Whether an application keeps feedback: its record names it. */
+export const keepsFeedback = (app) => (app.record?.include ?? []).includes('feedback');
+/** Where feedback is sent, on the runtime an application runs on. */
+export const feedbackEndpoint = (agentBaseUrl) => `${agentBaseUrl.replace(/\/+$/, '')}/api/v1/apps/feedback`;
+/** Why feedback cannot be sent as it is; nothing when it can. */
+export function feedbackProblems(feedback) {
+    const problems = [];
+    if (!feedback.session.trim()) {
+        problems.push(FEEDBACK_WORDS.noSession);
+    }
+    if (feedback.comment.trim().length > FEEDBACK_COMMENT_LIMIT) {
+        problems.push(FEEDBACK_WORDS.tooLong);
+    }
+    return problems;
+}
+/**
+ * Send feedback to the runtime, and say what it kept: the entry, in a
+ * sentence. A refusal throws the runtime's own sentence.
+ */
+export async function sendFeedback(feedback, { agentBaseUrl, token, fetcher = fetch, }) {
+    const problems = feedbackProblems(feedback);
+    if (problems.length) {
+        throw new Error(problems.join(' '));
+    }
+    const response = await fetcher(feedbackEndpoint(agentBaseUrl), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+        body: JSON.stringify({
+            session: feedback.session,
+            liked: feedback.liked,
+            comment: feedback.comment.trim(),
+        }),
+    });
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        const detail = typeof body.detail === 'string' ? body.detail : `${response.status}`;
+        throw new Error(`The feedback was not kept: ${detail}`);
+    }
+    return String(body.summary ?? '');
+}

package/lib/loop/apps/index.d.ts

@@ -4,8 +4,10 @@
  * @module loop/apps
  */
 export * from './agent';
+export * from './AppFeedback';
 export * from './AppRenderer';
 export * from './appspec';
 export * from './checks';
+export * from './feedback';
 export * from './rules';
 export * from './yaml';

package/lib/loop/apps/index.js

@@ -8,8 +8,10 @@
  * @module loop/apps
  */
 export * from './agent';
+export * from './AppFeedback';
 export * from './AppRenderer';
 export * from './appspec';
 export * from './checks';
+export * from './feedback';
 export * from './rules';
 export * from './yaml';

package/lib/loop/apps/rules.d.ts

@@ -39,6 +39,20 @@ export declare function classesOf(ref: string, args?: ToolArguments): ActionClas
 export declare const isReadOnly: (classes: ActionClass[]) => boolean;
 /** The most restricted of several behaviours. */
 export declare const strictest: (behaviours: AppBehaviour[]) => AppBehaviour;
+/**
+ * Whether the application is given a tool of a server: its connection's
+ * level (LOOP U-15). A connection gives the tools of its server it reaches
+ * (`only`); one that only reads gives only the tools that only read — a tool
+ * nobody classed is taken to write, so a read connection does not give it.
+ * A tool of a server the application is not connected to is not given.
+ *
+ * The runtime gives its agent only these (`AppRulesCapability.prepare_tools`,
+ * through `agent_runtimes.loop.apps.rules.gives`, its Python twin).
+ *
+ * @throws When `tool` names no server: a catalogue tool is given by the
+ *   spec's `tools`, not by a connection.
+ */
+export declare function gives(app: Pick<AppSpec, 'connections'>, tool: string): boolean;
 /** What `behaviourFor` may be told about the call. */
 export interface BehaviourOptions {
     /** The arguments of the call; without them the decision is for the worst the tool can do. */

package/lib/loop/apps/rules.js

@@ -161,6 +161,30 @@ export const strictest = (behaviours) => behaviours.reduce((worst, behaviour) =>
 const connectionTo = (app, server) => app.connections.find(connection => idOf(connection.server) === server);
 const reaches = (connection, tool) => connection.only.length === 0 ||
     connection.only.some(pattern => matchesPattern(tool, pattern));
+/**
+ * Whether the application is given a tool of a server: its connection's
+ * level (LOOP U-15). A connection gives the tools of its server it reaches
+ * (`only`); one that only reads gives only the tools that only read — a tool
+ * nobody classed is taken to write, so a read connection does not give it.
+ * A tool of a server the application is not connected to is not given.
+ *
+ * The runtime gives its agent only these (`AppRulesCapability.prepare_tools`,
+ * through `agent_runtimes.loop.apps.rules.gives`, its Python twin).
+ *
+ * @throws When `tool` names no server: a catalogue tool is given by the
+ *   spec's `tools`, not by a connection.
+ */
+export function gives(app, tool) {
+    const [server, name] = splitRef(tool);
+    if (server === undefined) {
+        throw new Error(`\`${tool}\` is not a tool of a server (\`server.tool\`).`);
+    }
+    const connection = connectionTo(app, server);
+    if (!connection || !reaches(connection, name)) {
+        return false;
+    }
+    return (connection.access !== 'read' || isReadOnly(classesOf(`${server}.${name}`)));
+}
 const isClass = (target) => Object.prototype.hasOwnProperty.call(DEFAULT_BEHAVIOURS, target);
 /** What a rule applies to, versions aside. */
 const normal = (target) => {

package/lib/loop/core/canvasBlocks.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentSpec } from '../../types/agentspecs';
+/**
+ * A block the Canvas may place (LOOP C-12): one component of the catalog of
+ * visual components (C-13), contributed by the plugin of the UI plugin that
+ * renders it. The Canvas's palette is what the enabled plugins contribute
+ * here, and nothing else: a plugin disabled takes its blocks off it, and an
+ * application that uses one of them says so in its setup notes.
+ */
+export type CanvasBlockContribution = {
+    /** The name a surface gives it, the component's id (e.g. 'Table'). */
+    id: string;
+    /** The UI plugin of the catalogue that renders it (e.g. 'a2ui'). */
+    uiPlugin: string;
+    component: ComponentSpec;
+};
+export declare const LoopCanvasBlock: import("@datalayer/reactor").ContributionPoint<CanvasBlockContribution>;

package/lib/loop/core/canvasBlocks.js

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The Canvas's palette as a contribution point (LOOP C-12), re-exported by
+ * `loop/core`: kept apart so that reading the palette loads the reactor and
+ * the catalogue, and nothing of the workspace.
+ *
+ * @module loop/core/canvasBlocks
+ */
+import { defineContributionPoint } from '@datalayer/reactor';
+export const LoopCanvasBlock = defineContributionPoint('loop.canvas.block');

package/lib/loop/core/index.d.ts

@@ -526,6 +526,7 @@ export type AssistantCharacterContribution = {
     character: AssistantCharacter | AssistantCharacterData;
 };
 export declare const LoopAssistantCharacter: import("@datalayer/reactor").ContributionPoint<AssistantCharacterContribution>;
+export { LoopCanvasBlock, type CanvasBlockContribution } from './canvasBlocks';
 /**
  * The per-example chat extras a host feeds the loop's conversation live.
  *
@@ -935,6 +936,12 @@ export type ChatTurnSnapshot = {
     user?: string;
     /** What the agent has said so far. */
     assistant?: string;
+    /**
+     * The conversation the turn belongs to, as the runtime knows it (AG-UI's
+     * thread) — what an application's record keeps its session under, and
+     * what feedback on it names (LOOP V-18). Absent when the chat does not say.
+     */
+    thread?: string;
     status: ChatTurnStatus;
     /**
      * The context window as the agent last reported it — what a turn footer