@datalayer/agent-runtimes 1.3.52 → 1.3.54

package/lib/chat/ChatFloating.d.ts

@@ -31,7 +31,7 @@ import type { ChatCommonProps, ChatViewMode, ThemeOverrides } from '../types';
 export type FloatingConversation = {
     /** What the window holds, under its header (the face, the title, close). */
     body: React.ReactNode;
-    /** What it is doing: idle, thinking, working, waiting for the person. */
+    /** What it is doing: idle, thinking, working, waiting for the person, paused. */
     presence: PresenceState;
     /** Its newest words, said in the balloon until heard. */
     saying?: AssistantSaying;

package/lib/chat/ChatFloating.js

@@ -33,7 +33,7 @@ import { disabledChatViewModes, resolveMountPoint } from './viewModes';
 import { AssistantStage } from './assistant/AssistantStage';
 import { SpeechBalloon } from './assistant/SpeechBalloon';
 import { DEFAULT_ASSISTANT_CHARACTER, } from './assistant/characters';
-import { assistantStateOf, latestSaying, newestIsAnswer, keepAway, keptAway, } from './assistant/state';
+import { assistantStateOf, latestSaying, newestIsAnswer, keepAway, keptAway, ASSISTANT_WORDS, } from './assistant/state';
 import { presenceState, presenceToolOf, } from './presence/presenceStatus';
 import { useChatOpen, useChatMessages, useChatStore, } from '../stores/chatStore';
 import { useChatKeyboardShortcuts, getShortcutDisplay, } from '@datalayer/core/lib/hooks';
@@ -172,13 +172,40 @@ export function ChatFloating({ endpoint, protocol: protocolProp, useStore: useSt
         speaking: answering,
     });
     const unheard = !!saying && saying.id !== heardId;
-    const assistantBalloon = assistantState === 'waiting'
-        ? { text: 'Waiting for you — open the conversation to answer.' }
-        : unheard && saying
-            ? { text: saying.text, more: saying.more }
-            : { text: description };
+    /*
+     * The approval it waits on, answered in the balloon (T-23) by the chat's
+     * own answers to its approvals — those its tool-approval banner sends.
+     */
+    const [deciding, setDeciding] = useState(false);
+    const firstPending = pendingApprovals?.[0];
+    const balloonApproval = firstPending && onApproveApproval && onRejectApproval
+        ? {
+            id: firstPending.id,
+            asks: firstPending.toolDescription || firstPending.toolName,
+            others: (pendingApprovals?.length ?? 1) - 1,
+            deciding,
+            onApprove: () => {
+                setDeciding(true);
+                void Promise.resolve(onApproveApproval(firstPending.id)).finally(() => setDeciding(false));
+            },
+            onDeny: () => {
+                setDeciding(true);
+                void Promise.resolve(onRejectApproval(firstPending.id)).finally(() => setDeciding(false));
+            },
+        }
+        : undefined;
+    const assistantBalloon = assistantState === 'paused'
+        ? { text: ASSISTANT_WORDS.paused }
+        : balloonApproval
+            ? { text: ASSISTANT_WORDS.approval, approval: balloonApproval }
+            : assistantState === 'waiting'
+                ? { text: ASSISTANT_WORDS.waiting }
+                : unheard && saying
+                    ? { text: saying.text, more: saying.more }
+                    : { text: description };
     const balloonInsists = assistantState === 'greeting' ||
         assistantState === 'waiting' ||
+        !!balloonApproval ||
         (unheard && (assistantState === 'speaking' || freshSaying));
     const panelOnLoadingChange = panelProps?.onLoadingChange;
     const panelOnDisplayItemsChange = panelProps?.onDisplayItemsChange;

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

@@ -17,7 +17,7 @@
 import type { JSX, RefObject } from 'react';
 import { type AssistantCharacter } from './characters';
 import type { AssistantCharacterData } from './formats/types';
-import { type AssistantAway, type AssistantState } from './state';
+import { type AssistantAway, type AssistantState, type BalloonApproval } from './state';
 /**
  * Where the balloon goes so that it stays inside the window (T-23): toward
  * the middle of the page from whichever half the character stands in, and
@@ -69,11 +69,13 @@ export interface AssistantStageProps {
     /**
      * What the balloon says while the conversation is closed: the agent's
      * newest words, as the Office Assistant said them (T-23), or a welcome.
-     * `more` adds *Open the conversation* for the rest.
+     * `more` adds *Open the conversation* for the rest; `approval`, an
+     * approval to answer there, with *Approve* and *Deny*.
      */
     balloon?: {
         text: string;
         more?: boolean;
+        approval?: BalloonApproval;
     };
     /** Show the balloon without being hovered: something new to say. */
     insist?: boolean;

package/lib/chat/assistant/AssistantStage.js

@@ -41,6 +41,10 @@ const MOTIONS = {
         '0%, 100%': { transform: 'scaleY(1)' },
         '50%': { transform: 'scaleY(2.2)' },
     },
+    '@keyframes assistantDoze': {
+        '0%, 100%': { transform: 'translateY(2px) scale(1, 0.97)' },
+        '50%': { transform: 'translateY(3px) scale(1.02, 0.95)' },
+    },
     '@keyframes assistantLeave': {
         from: { transform: 'scale(1)', opacity: 1 },
         to: { transform: 'scale(0.2) translateY(20px)', opacity: 0 },
@@ -255,6 +259,17 @@ export function AssistantStage({ character, state, size = 88, place, stageRef, o
             '&[data-assistant-state="speaking"] .assistant-body': {
                 animation: 'assistantFloat 1.6s ease-in-out infinite',
             },
+            // Paused (R-17): it dozes — its eyes shut, its breath slow, a little
+            // greyed — and, still, it is asleep: the shut eyes are not a motion.
+            '&[data-assistant-state="paused"] .assistant-body': {
+                animation: 'assistantDoze 4.8s ease-in-out infinite',
+                filter: 'grayscale(0.5)',
+                opacity: 0.8,
+            },
+            '&[data-assistant-state="paused"] .assistant-lids ellipse': {
+                animation: 'none',
+                transform: 'scaleY(1)',
+            },
             '&[data-assistant-state="goodbye"] .assistant-body': {
                 animation: 'assistantLeave 0.6s ease-in forwards',
             },
@@ -262,7 +277,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, 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, 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/SpeechBalloon.d.ts

@@ -2,11 +2,13 @@
  * A speech balloon over something that stands for the agent — the floating
  * 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.
+ * (LOOP T-23), with *Open the conversation* when there is more — and an
+ * approval it waits on, answered there with *Approve* or *Deny*.
  *
  * @module chat/assistant/SpeechBalloon
  */
 import type { JSX } from 'react';
+import { type BalloonApproval } from './state';
 export interface SpeechBalloonProps {
     text: string;
     /** There is more than the balloon holds. */
@@ -21,6 +23,8 @@ export interface SpeechBalloonProps {
     align: 'left' | 'right';
     /** Where the tail points, from that edge, in pixels. */
     tailAt: number;
+    /** An approval it waits on: what is asked, and the two answers. */
+    approval?: BalloonApproval;
 }
-export declare function SpeechBalloon({ text, more, onOpen, above, side, align, tailAt, }: SpeechBalloonProps): JSX.Element;
+export declare function SpeechBalloon({ text, more, onOpen, above, side, align, tailAt, approval, }: SpeechBalloonProps): JSX.Element;
 export default SpeechBalloon;

package/lib/chat/assistant/SpeechBalloon.js

@@ -1,7 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Text } from '@primer/react';
+import { Button, Text } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
-export function SpeechBalloon({ text, more = false, onOpen, above, side = 'above', align, tailAt, }) {
+import { ASSISTANT_WORDS } from './state';
+export function SpeechBalloon({ text, more = false, onOpen, above, side = 'above', align, tailAt, approval, }) {
     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
@@ -36,7 +37,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 }), 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] })), more && (_jsx(Box, { as: "button", type: "button", onClick: onOpen, sx: {
                     mt: 1,
                     p: 0,
                     border: 0,

package/lib/chat/assistant/formats/stateAnimations.js

@@ -33,6 +33,7 @@ const NAMES = {
         'GestureDown',
         'Acknowledge',
     ],
+    paused: ['IdleSnooze', 'Sleep', 'Sleeping', 'Snooze', 'Rest', 'RestPose'],
     greeting: ['Greeting', 'Greet', 'Show', 'Wave'],
     speaking: [
         'Explain',
@@ -50,6 +51,7 @@ const AUTHORED = {
     thinking: [],
     working: [],
     waiting: ['Listening'],
+    paused: [],
     greeting: ['Showing'],
     speaking: ['Speaking'],
     goodbye: ['Hiding'],
@@ -60,6 +62,7 @@ const STATES = [
     'thinking',
     'working',
     'waiting',
+    'paused',
     'greeting',
     'speaking',
     'goodbye',

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

@@ -1,13 +1,14 @@
 /**
  * What the floating assistant acts out (LOOP T-22): the presence of the
- * application (T-08), and three moments of its own — greeting when it
+ * application (T-08) — paused among them, when its owner paused it — and
+ * three moments of its own — greeting when it
  * arrives, speaking while an answer streams in, goodbye when it is sent away.
  *
  * @module chat/assistant/state
  */
 import type { PresenceState } from '../presence/presenceStatus';
 /** The states a character has an animation for. */
-export type AssistantState = 'idle' | 'thinking' | 'working' | 'waiting' | 'greeting' | 'speaking' | 'goodbye';
+export type AssistantState = 'idle' | 'thinking' | 'working' | 'waiting' | 'paused' | 'greeting' | 'speaking' | 'goodbye';
 /** What a character is doing, beyond what the application is doing. */
 export interface AssistantMoment {
     /** It has just appeared, and says hello once. */
@@ -20,9 +21,10 @@ export interface AssistantMoment {
 /**
  * The state to act, from the application's presence and the moment.
  *
- * Leaving and arriving win, being short; then waiting for the person, which
- * must never be missed; then speaking over thinking, since words arriving
- * are what the person watches; then the presence as it is.
+ * Leaving wins, being short; then paused — a paused application neither
+ * greets nor speaks, it dozes; then arriving; then waiting for the person,
+ * which must never be missed; then speaking over thinking, since words
+ * arriving are what the person watches; then the presence as it is.
  */
 export declare function assistantStateOf(presence: PresenceState, moment?: AssistantMoment): AssistantState;
 /**
@@ -30,6 +32,36 @@ export declare function assistantStateOf(presence: PresenceState, moment?: Assis
  * assistant's own message, not a tool call. Read with `busy`, it is speaking.
  */
 export declare function newestIsAnswer(items: readonly unknown[]): boolean;
+/** What the balloon says for a state, when the agent has said nothing newer. */
+export declare const ASSISTANT_WORDS: {
+    /** An approval waits and cannot be answered in the balloon itself. */
+    readonly waiting: "Waiting for you — open the conversation to answer.";
+    /** It waits on the person's yes: Approve or Deny, in the balloon (T-23). */
+    readonly approval: "Waiting for you";
+    readonly approve: "Approve";
+    readonly deny: "Deny";
+    /** Its deployment is paused (R-17). */
+    readonly paused: "Paused — it answers again once it is resumed.";
+};
+/**
+ * An approval asked of the person, answered in the balloon (T-23): what is
+ * asked, under which rule, and the two answers, sent where every approval is
+ * answered (U-19).
+ */
+export interface BalloonApproval {
+    /** Its id: a new one is a new question. */
+    id: string;
+    /** What it asks to do: the tool it would call. */
+    asks: string;
+    /** The rule or check it was asked under, when the runtime said. */
+    why?: string;
+    /** How many more wait after this one. */
+    others: number;
+    /** An answer is being sent. */
+    deciding?: boolean;
+    onApprove: () => void;
+    onDeny: () => void;
+}
 /** A word from the agent, for the character's balloon. */
 export interface AssistantSaying {
     /** The message it comes from: a new id is a new thing said. */

package/lib/chat/assistant/state.js

@@ -5,14 +5,18 @@
 /**
  * The state to act, from the application's presence and the moment.
  *
- * Leaving and arriving win, being short; then waiting for the person, which
- * must never be missed; then speaking over thinking, since words arriving
- * are what the person watches; then the presence as it is.
+ * Leaving wins, being short; then paused — a paused application neither
+ * greets nor speaks, it dozes; then arriving; then waiting for the person,
+ * which must never be missed; then speaking over thinking, since words
+ * arriving are what the person watches; then the presence as it is.
  */
 export function assistantStateOf(presence, moment = {}) {
     if (moment.leaving) {
         return 'goodbye';
     }
+    if (presence === 'paused') {
+        return 'paused';
+    }
     if (moment.arriving) {
         return 'greeting';
     }
@@ -34,6 +38,17 @@ export function newestIsAnswer(items) {
         newest.role === 'assistant' &&
         typeof newest.toolName !== 'string');
 }
+/** What the balloon says for a state, when the agent has said nothing newer. */
+export const ASSISTANT_WORDS = {
+    /** An approval waits and cannot be answered in the balloon itself. */
+    waiting: 'Waiting for you — open the conversation to answer.',
+    /** It waits on the person's yes: Approve or Deny, in the balloon (T-23). */
+    approval: 'Waiting for you',
+    approve: 'Approve',
+    deny: 'Deny',
+    /** Its deployment is paused (R-17). */
+    paused: 'Paused — it answers again once it is resumed.',
+};
 /** How much of a message the balloon says before *Open the conversation*. */
 export const SAYING_LIMIT = 220;
 /**

package/lib/chat/presence/Presence.d.ts

@@ -3,7 +3,8 @@
  * motion around it while it thinks or works, and one line saying what it is
  * doing. The face is never redrawn; the motion is a soft ring in the accent,
  * still under `prefers-reduced-motion`, and the line changes at the theme's
- * status pace (T-10).
+ * status pace (T-10). Paused, the ring is a still, muted dashed circle and
+ * the face is dimmed: nothing moves around something that does nothing.
  *
  * @module chat/presence/Presence
  */

package/lib/chat/presence/Presence.js

@@ -13,6 +13,7 @@ export function FaceDrawing({ face, size }) {
 }
 export function PresenceFace({ face, size, state, }) {
     const active = state === 'thinking' || state === 'working';
+    const paused = state === 'paused';
     return (_jsxs(Box, { as: "span", "aria-hidden": true, "data-presence": state, sx: {
             position: 'relative',
             display: 'inline-flex',
@@ -27,8 +28,10 @@ export function PresenceFace({ face, size, state, }) {
                     position: 'absolute',
                     inset: 0,
                     borderRadius: '50%',
-                    boxShadow: `0 0 0 2px ${ACCENT}`,
-                    opacity: active ? 0.9 : state === 'waiting' ? 0.9 : 0,
+                    boxShadow: paused ? 'none' : `0 0 0 2px ${ACCENT}`,
+                    border: paused ? '2px dashed' : 'none',
+                    borderColor: 'border.default',
+                    opacity: active || state === 'waiting' || paused ? 0.9 : 0,
                     transition: 'opacity var(--theme-motion-status, 0ms) var(--theme-motion-easing, ease)',
                     animation: active
                         ? 'loopPresenceBreath 1.8s ease-in-out infinite'
@@ -40,7 +43,12 @@ export function PresenceFace({ face, size, state, }) {
                     '@media (prefers-reduced-motion: reduce)': {
                         animation: 'none',
                     },
-                } }), _jsx(FaceDrawing, { face: face, size: size })] }));
+                } }), _jsx(Box, { as: "span", sx: {
+                    display: 'inline-flex',
+                    opacity: paused ? 0.55 : 1,
+                    filter: paused ? 'grayscale(0.6)' : 'none',
+                    transition: 'opacity var(--theme-motion-status, 0ms) var(--theme-motion-easing, ease)',
+                }, children: _jsx(FaceDrawing, { face: face, size: size }) })] }));
 }
 export function PresenceLine({ state }) {
     return (_jsx(Text, { role: "status", "aria-live": "polite", "data-presence-line": state, sx: {

package/lib/chat/presence/presenceStatus.d.ts

@@ -4,8 +4,11 @@
  *
  * @module chat/presence/presenceStatus
  */
-/** The states a person is told about. Paused waits for a pause to exist. */
-export type PresenceState = 'idle' | 'thinking' | 'working' | 'waiting';
+/**
+ * The states a person is told about. Paused is its deployment's: its owner
+ * paused it (LOOP R-17), and it answers nobody until it is resumed.
+ */
+export type PresenceState = 'idle' | 'thinking' | 'working' | 'waiting' | 'paused';
 /** The line each state is said by. */
 export declare const PRESENCE_LINES: Record<PresenceState, string>;
 /** The newest tool call of the conversation, as far as presence reads it. */
@@ -16,14 +19,17 @@ export interface PresenceTool {
     pendingApproval: boolean;
 }
 /**
- * The state, from whether a turn is running and the newest tool call.
+ * The state, from whether a turn is running, the newest tool call, and
+ * whether its deployment is paused.
  *
+ * Paused wins: a paused application does nothing, whatever its last turn
+ * left behind.
  * Waiting for an approval is said whether or not the turn is still
  * streaming — the stream may end while the approval is asked. A tool that
  * has not returned counts as work only during a turn: a stopped turn can
  * leave one open, and the application is not working then.
  */
-export declare function presenceState(busy: boolean, tool?: PresenceTool): PresenceState;
+export declare function presenceState(busy: boolean, tool?: PresenceTool, paused?: boolean): PresenceState;
 /**
  * The newest tool call of the conversation: whether it has not returned, and
  * whether it waits on a person's approval. A tool call is an item with a

package/lib/chat/presence/presenceStatus.js

@@ -8,16 +8,23 @@ export const PRESENCE_LINES = {
     thinking: 'Thinking…',
     working: 'Working…',
     waiting: 'Waiting for you',
+    paused: 'Paused',
 };
 /**
- * The state, from whether a turn is running and the newest tool call.
+ * The state, from whether a turn is running, the newest tool call, and
+ * whether its deployment is paused.
  *
+ * Paused wins: a paused application does nothing, whatever its last turn
+ * left behind.
  * Waiting for an approval is said whether or not the turn is still
  * streaming — the stream may end while the approval is asked. A tool that
  * has not returned counts as work only during a turn: a stopped turn can
  * leave one open, and the application is not working then.
  */
-export function presenceState(busy, tool) {
+export function presenceState(busy, tool, paused = false) {
+    if (paused) {
+        return 'paused';
+    }
     if (tool?.open && tool.pendingApproval) {
         return 'waiting';
     }

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

@@ -89,6 +89,11 @@ export type AppRendererProps = Omit<LoopEmbedProps, 'agentId'> & {
      * stable function, such as a state setter.
      */
     onPresence?: (state: PresenceState) => void;
+    /**
+     * Its deployment is paused (LOOP R-17), as its host knows it: its chat
+     * says *Paused* beside its face and its assistant dozes (T-08, T-22).
+     */
+    paused?: boolean;
     /**
      * Told what the application last said, and whether its newest words are
      * an answer — for a host that says them outside the conversation: the
@@ -195,5 +200,5 @@ export declare const DATALAYER_BOOTSTRAP_AGENTSPEC = "example-simple";
  * what the page around it set does not reach in.
  */
 export declare function appThemeOverrides(app: AppSpec): ThemeOverrides | undefined;
-export declare function AppRenderer({ app, plugins, instance, onPresence, onSaying, sidebar, frame, page, pluginsOff, ...embed }: AppRendererProps): React.JSX.Element;
+export declare function AppRenderer({ app, plugins, instance, onPresence, onSaying, paused, sidebar, frame, page, pluginsOff, ...embed }: AppRendererProps): React.JSX.Element;
 export default AppRenderer;

package/lib/loop/apps/AppRenderer.js

@@ -252,7 +252,7 @@ export function appThemeOverrides(app) {
         }
         : undefined;
 }
-export function AppRenderer({ app, plugins = NO_PLUGINS, instance, onPresence, onSaying, sidebar = false, frame = false, page, pluginsOff, ...embed }) {
+export function AppRenderer({ app, plugins = NO_PLUGINS, instance, onPresence, onSaying, paused = false, sidebar = false, frame = false, page, pluginsOff, ...embed }) {
     /*
      * The kind's plugins, made once per application. `LoopEmbed` rebuilds its
      * whole reactor when its plugins change, so a new plugin on every render
@@ -325,6 +325,7 @@ export function AppRenderer({ app, plugins = NO_PLUGINS, instance, onPresence, o
             name: app.name,
             face: app.emoji,
             welcome: app.interface.welcome || app.description,
+            paused,
             onPresence,
             onSaying,
         }, showTokenUsage: false, datalayerCreatePayload: datalayerCreatePayload, ...embed, plugins: allPlugins }));

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

@@ -0,0 +1,35 @@
+/** Where a conversation without an account runs: the visitors' runtime, and what it is for. */
+export type DatalayerVisitors = {
+    /** The visitors' runtime, as the chat addresses it. */
+    url: string;
+    /** The application the visitor's token is for: an example's id, or `at:<slug>`. */
+    app: string;
+    /** ai-inference, which mints the visitor's token. */
+    inferenceUrl: string;
+};
+/** A visitor's id: what ai-inference accepts (8 to 64 letters, digits or dashes). */
+export declare function isVisitorId(value: string | null | undefined): value is string;
+/** The id this tab keeps for its visitor, or `''` until ai-inference made one. */
+export declare function keptVisitorId(): string;
+/** A visitor's token, and when it is to be minted again. */
+export type VisitorToken = {
+    token: string;
+    visitor: string;
+    /** Epoch milliseconds: the token's own lifetime from now. */
+    renewAt: number;
+};
+/** The body ai-inference is asked with. */
+export declare function visitorTokenRequest(app: string, visitor: string): {
+    app: string;
+    visitor?: string;
+};
+/** Mint a visitor's token for an application; throws with ai-inference's sentence. */
+export declare function fetchVisitorToken(inferenceUrl: string, app: string, visitor?: string, fetcher?: typeof fetch): Promise<VisitorToken>;
+/**
+ * The visitor's token for an application while `visitors` is set: minted at
+ * once and again before it runs out. `error` says why none could be had.
+ */
+export declare function useVisitorToken(visitors: DatalayerVisitors | undefined): {
+    token?: string;
+    error?: string;
+};

package/lib/loop/apps/visitorToken.js

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * A visitor's token, for a conversation without an account on the visitors'
+ * runtime (LOOP R-30).
+ *
+ * ai-inference mints it (`POST /anonymous/token`) naming the visitor — the id
+ * this tab keeps for them, so that a new token is the same visitor, whose
+ * session, turns and rate it does not reset — and the one application it is
+ * for: an example's id, or `at:<slug>` for an application at its address.
+ * It lives minutes, so it is minted again before it runs out: what limits a
+ * visitor is on the servers (turns a day, a session's minutes, a rate and a
+ * ceiling for the day), not the life of a key.
+ *
+ * @module loop/apps/visitorToken
+ */
+import { useEffect, useState } from 'react';
+/** The id this tab keeps for its visitor. */
+const VISITOR_KEY = 'datalayer-loop-visitor';
+/** Minted again this long before the token runs out. */
+const MARGIN_MS = 30_000;
+/** A visitor's id: what ai-inference accepts (8 to 64 letters, digits or dashes). */
+export function isVisitorId(value) {
+    return typeof value === 'string' && /^[A-Za-z0-9-]{8,64}$/.test(value);
+}
+/** The id this tab keeps for its visitor, or `''` until ai-inference made one. */
+export function keptVisitorId() {
+    try {
+        const kept = window.sessionStorage.getItem(VISITOR_KEY);
+        return isVisitorId(kept) ? kept : '';
+    }
+    catch {
+        return '';
+    }
+}
+function keepVisitorId(visitor) {
+    try {
+        window.sessionStorage.setItem(VISITOR_KEY, visitor);
+    }
+    catch {
+        // A tab that keeps nothing is a new visitor at each token.
+    }
+}
+/** The body ai-inference is asked with. */
+export function visitorTokenRequest(app, visitor) {
+    return isVisitorId(visitor) ? { app, visitor } : { app };
+}
+/** Mint a visitor's token for an application; throws with ai-inference's sentence. */
+export async function fetchVisitorToken(inferenceUrl, app, visitor = keptVisitorId(), fetcher = fetch) {
+    const base = inferenceUrl.replace(/\/+$/, '');
+    const response = await fetcher(`${base}/api/ai-inference/v1/anonymous/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(visitorTokenRequest(app, visitor)),
+    });
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok || !body.token) {
+        throw new Error(body.detail ||
+            `A visitor's token was refused by ${base} (HTTP ${response.status}).`);
+    }
+    if (isVisitorId(body.visitor)) {
+        keepVisitorId(body.visitor);
+    }
+    const lifetimeMs = Math.max(60_000, (body.expires_in ?? 300) * 1000);
+    return {
+        token: body.token,
+        visitor: body.visitor ?? visitor,
+        renewAt: Date.now() + lifetimeMs - MARGIN_MS,
+    };
+}
+/**
+ * The visitor's token for an application while `visitors` is set: minted at
+ * once and again before it runs out. `error` says why none could be had.
+ */
+export function useVisitorToken(visitors) {
+    const [state, setState] = useState({});
+    const app = visitors?.app;
+    const inferenceUrl = visitors?.inferenceUrl;
+    useEffect(() => {
+        if (!app || !inferenceUrl) {
+            setState({});
+            return;
+        }
+        let cancelled = false;
+        let timer;
+        const mint = () => {
+            fetchVisitorToken(inferenceUrl, app)
+                .then(minted => {
+                if (cancelled) {
+                    return;
+                }
+                setState({ token: minted.token });
+                timer = setTimeout(mint, Math.max(5_000, minted.renewAt - Date.now()));
+            })
+                .catch((error) => {
+                if (!cancelled) {
+                    setState({
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            });
+        };
+        mint();
+        return () => {
+            cancelled = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+        };
+    }, [app, inferenceUrl]);
+    return state;
+}

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

@@ -6,6 +6,7 @@ import type { FrontendToolDefinition } from '../../types/tools';
 import type { ContextSnapshotData } from '../../types/context';
 import type { AssistantCharacter } from '../../chat/assistant/characters';
 import type { AssistantCharacterData } from '../../chat/assistant/formats/types';
+import type { PresenceState } from '../../chat/presence/presenceStatus';
 /** Lifecycle of the sandbox a workspace is attached to. */
 export type SandboxState = 'idle' | 'starting' | 'running' | 'stopping' | 'error';
 /** What the workspace knows about the sandbox behind it. */
@@ -983,5 +984,12 @@ export type ChatTurnContribution = {
      * reply as it streams included; empty again when the chat starts over.
      */
     conversation: ReadonlySignal<ConversationEntry[]>;
+    /**
+     * What the application is doing, as its chat says it beside its face
+     * (LOOP T-08) — waiting for the person on an approval, paused when its
+     * deployment is — for whoever acts it out away from the chat: the
+     * floating assistant (T-22).
+     */
+    presence: ReadonlySignal<PresenceState>;
 };
 export declare const LoopChatTurn: import("@datalayer/reactor").ContributionPoint<ChatTurnContribution>;

package/lib/loop/embed/LoopEmbed.js

@@ -72,9 +72,11 @@ export function LoopEmbed({ agentId = '', showHeader = false, chatHeaderActions,
         preset.presence?.name,
         preset.presence?.face,
         preset.presence?.welcome,
+        preset.presence?.paused,
         preset.showTokenUsage,
         // By its content: an application's spec written inline is a new object each render.
         JSON.stringify(preset.datalayerCreatePayload ?? null),
+        JSON.stringify(preset.datalayerVisitors ?? null),
         preset.defaultEditor,
         preset.showViewSelector,
         preset.hideChatHeader,

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

@@ -22,6 +22,9 @@ export function DatalayerAgentBridge() {
     const agentsConfig = reactor.getConfig(AGENTS_PLUGIN_NAME);
     const agentSpecId = agentsConfig?.datalayerAgentSpecId ?? DEFAULT_DATALAYER_AGENTSPEC;
     const createPayload = agentsConfig?.datalayerCreatePayload;
+    // A conversation without an account (LOOP R-30): the agent is already on
+    // the visitors' runtime, kept warm there; nothing is allocated or made.
+    const visitors = agentsConfig?.datalayerVisitors;
     const service = useOptionalSandboxService();
     const target = useSignalValue(service?.target ?? IDLE_SANDBOX_TARGET_SIGNAL);
     const onDatalayer = target === 'datalayer';
@@ -65,13 +68,22 @@ export function DatalayerAgentBridge() {
         agentSpecId,
         agentConfig,
         variant: 'cloud-pydanticai',
-        autoStart: onDatalayer,
-        autoCreateAgent: onDatalayer,
+        autoStart: onDatalayer && !visitors,
+        autoCreateAgent: onDatalayer && !visitors,
     });
     useEffect(() => {
         if (!service || !onDatalayer) {
             return;
         }
+        if (visitors) {
+            service.report({
+                variant: 'datalayer',
+                // No sandbox: a visitor's application runs no code.
+                sandbox_running: false,
+                agent_base_url: visitors.url,
+            });
+            return;
+        }
         if (error) {
             // The reason travels with the state. "connected-dead" and a column of
             // "unknown" is what a reader saw before, which names the symptom and
@@ -106,7 +118,7 @@ export function DatalayerAgentBridge() {
             // host's server for an agent that is not on it.
             agent_base_url: runtime.agentBaseUrl,
         });
-    }, [service, onDatalayer, runtime, status, error]);
+    }, [service, onDatalayer, runtime, status, error, visitors]);
     return null;
 }
 export default DatalayerAgentBridge;

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

@@ -1,3 +1,21 @@
+/**
+ * The Agents plugin: where the agent runs, and the sandbox that comes with it.
+ *
+ * It was the "code sandbox" plugin, and the rename follows what the choice
+ * came to mean. Picking a target used to say only where *code* ran; now it
+ * decides where the *agent* runs too — in this page with the Vercel AI SDK, or
+ * on a server with pydantic-ai — because the location is what a harness can
+ * be, whatever a spec asks for. One control, one answer.
+ *
+ * It owns the sandbox and publishes it as a service; the notebook and document
+ * plugins depend on this plugin rather than on a connection of their own.
+ *
+ * Which agentspec the session runs is a different question, and belongs to
+ * `@datalayer/loop-plugin-agentspecs`.
+ *
+ * @module loop/plugins/agents/plugin
+ */
+import type { DatalayerVisitors } from '../../apps/visitorToken';
 import type { ReactorSlotComponent } from '@datalayer/reactor/react';
 import type { ServiceManagerSource } from './browserService';
 import { type TeamSelection } from './team';
@@ -79,6 +97,12 @@ export type AgentsConfig = {
      * decides its tool calls by its rules (LOOP R-05, R-03).
      */
     datalayerCreatePayload?: Record<string, unknown>;
+    /**
+     * A conversation without an account (LOOP R-30): the application's agent
+     * is already on the visitors' runtime, so nothing is allocated or created,
+     * and the chat speaks to it with a visitor's token for the application.
+     */
+    datalayerVisitors?: DatalayerVisitors;
     /**
      * The target is the host's decision, not the reader's: started there even
      * with the control hidden. For an application that runs where it is

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

@@ -2,23 +2,6 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/**
- * The Agents plugin: where the agent runs, and the sandbox that comes with it.
- *
- * It was the "code sandbox" plugin, and the rename follows what the choice
- * came to mean. Picking a target used to say only where *code* ran; now it
- * decides where the *agent* runs too — in this page with the Vercel AI SDK, or
- * on a server with pydantic-ai — because the location is what a harness can
- * be, whatever a spec asks for. One control, one answer.
- *
- * It owns the sandbox and publishes it as a service; the notebook and document
- * plugins depend on this plugin rather than on a connection of their own.
- *
- * Which agentspec the session runs is a different question, and belongs to
- * `@datalayer/loop-plugin-agentspecs`.
- *
- * @module loop/plugins/agents/plugin
- */
 import { ServerIcon } from '@primer/octicons-react';
 import { contribution, definePlugin } from '@datalayer/reactor';
 import { LoopAgentBlueprint, LoopAgentGate, LoopCommand, LoopSlots, LoopViewType, } from '../../core';

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

@@ -3,10 +3,13 @@
  * page draws over its workspace, chosen from what the enabled plugins
  * contribute to `loop.assistant.character` — the application's own
  * (`interface.assistant`) when its Appspec names one, else the person's
- * choice from their settings, else the paper clip. It acts out the chat's
- * turn (T-22), says the agent's newest words in its balloon while the
- * conversation is out of sight (T-23), opens the conversation when clicked,
- * is dragged about and sent away as the chat's own assistant is (T-27).
+ * choice from their settings, else the paper clip. It acts out what the
+ * application is doing as its chat says it — paused too, when its deployment
+ * is — and the turn (T-22), says the agent's newest words in its balloon
+ * while the conversation is out of sight, holds there the approval it waits
+ * on, answered with *Approve* or *Deny* on the path every approval of it is
+ * answered on (T-23, U-19), opens the conversation when clicked, and is
+ * dragged about and sent away as the chat's own assistant is (T-27).
  *
  * The workspace's chat is the conversation: on a page layout, its side panel
  * is opened and closed; where the conversation is always on screen, a click
@@ -16,6 +19,7 @@
  */
 import type { JSX } from 'react';
 import { type AssistantState } from '../../../chat/assistant/state';
+import type { PresenceState } from '../../../chat/presence/presenceStatus';
 import { type ChatTurnSnapshot } from '../../core';
 export declare const LOOP_ASSISTANT_PLUGIN_NAME = "@datalayer/loop-plugin-assistant";
 export type LoopAssistantConfig = {
@@ -23,16 +27,22 @@ export type LoopAssistantConfig = {
     app?: string;
     /** The character the person chose in their settings. */
     person?: string;
+    /**
+     * The application's id: the approvals it waits on are read and answered
+     * in the balloon (T-23), as its rules card reads them (U-19). Without it,
+     * the balloon says an approval waits and the conversation answers it.
+     */
+    appId?: string;
 };
 /**
- * What the character acts out, from the workspace's chat turn (T-22): it
- * thinks while the agent thinks, works while a tool runs (the turn's
- * `activity`), speaks while the answer is written, and idles otherwise.
+ * What the character acts out (T-22), from what the application is doing as
+ * its chat says it — idle, thinking, working, waiting for the person, paused
+ * — and the turn: it speaks while the answer is written.
  */
-export declare function assistantStateOfTurn(turn: ChatTurnSnapshot, moment?: {
+export declare function assistantStateOfTurn(turn: ChatTurnSnapshot, presence: PresenceState, moment?: {
     arriving?: boolean;
     leaving?: boolean;
 }): AssistantState;
-export declare function LoopAssistant({ app, person, }: LoopAssistantConfig): JSX.Element | null;
+export declare function LoopAssistant({ app, person, appId, }: LoopAssistantConfig): JSX.Element | null;
 export declare const LoopAssistantPlugin: import("@datalayer/reactor").ReactorPlugin<LoopAssistantConfig, unknown, unknown>;
 export default LoopAssistantPlugin;

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

@@ -1,47 +1,80 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useRef, useState } from 'react';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { definePlugin, signal } from '@datalayer/reactor';
 import { useContributions, useSignalValue } from '@datalayer/reactor/react';
 import { Text } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
+import { useIAMStore } from '@datalayer/core/lib/state/substates/IAMState';
 import { pageLayoutPanelOpen, togglePagePanel, } from '@datalayer/primer-addons/lib/reactor';
 import { AssistantStage } from '../../../chat/assistant/AssistantStage';
-import { assistantStateOf, keepAway, keptAway, latestSaying, } from '../../../chat/assistant/state';
+import { ASSISTANT_WORDS, assistantStateOf, keepAway, keptAway, latestSaying, } from '../../../chat/assistant/state';
+import { useApproveToolRequest, useRejectToolRequest, useToolApprovalsQuery, } from '../../../hooks/useToolApprovals';
+import { approvalsOfApp, ruleOfApproval } from '../app-rules/AppRulesCard';
 import { useViewportDrag } from '../../../chat/useViewportDrag';
 import { LoopAssistantCharacter, LoopChatLayout, LoopChatTurn, LoopSlots, } from '../../core';
 import { assistantCharacterFor } from '../assistant-characters';
 export const LOOP_ASSISTANT_PLUGIN_NAME = '@datalayer/loop-plugin-assistant';
 /** The character's size, in pixels, as the chat's own assistant. */
 const SIZE = 88;
-/* A signal to read when no chat contributed a turn: the hook needs one. */
+/* Signals to read when no chat contributed a turn: the hooks need one. */
 const NO_TURN = signal({ id: 0, status: 'idle' });
+const NO_PRESENCE = signal('idle');
 /**
- * What the character acts out, from the workspace's chat turn (T-22): it
- * thinks while the agent thinks, works while a tool runs (the turn's
- * `activity`), speaks while the answer is written, and idles otherwise.
+ * What the character acts out (T-22), from what the application is doing as
+ * its chat says it — idle, thinking, working, waiting for the person, paused
+ * — and the turn: it speaks while the answer is written.
  */
-export function assistantStateOfTurn(turn, moment = {}) {
-    const busy = turn.status === 'thinking' || turn.status === 'streaming';
-    const presence = !busy
-        ? 'idle'
-        : turn.activity
-            ? 'working'
-            : 'thinking';
+export function assistantStateOfTurn(turn, presence, moment = {}) {
     return assistantStateOf(presence, {
         ...moment,
         speaking: turn.status === 'streaming' && !turn.activity,
     });
 }
+const PENDING = { status: 'pending' };
+/**
+ * The approvals an application waits on, read and answered as its rules
+ * card does (U-19): over the ai-agents `/ws`, where every decision is
+ * broadcast, so one answered here leaves every list. The first is offered
+ * to the balloon; none, once all are answered.
+ */
+function WaitingApprovals({ appId, onWaiting, }) {
+    const query = useToolApprovalsQuery(PENDING);
+    const approve = useApproveToolRequest();
+    const reject = useRejectToolRequest();
+    const waiting = useMemo(() => approvalsOfApp(query.data?.approvals ?? [], appId), [query.data, appId]);
+    const first = waiting[0];
+    const deciding = approve.isPending || reject.isPending;
+    useEffect(() => {
+        onWaiting(first
+            ? {
+                id: first.id,
+                asks: first.tool_name,
+                why: ruleOfApproval(first) || undefined,
+                others: waiting.length - 1,
+                deciding,
+                onApprove: () => approve.mutate({ id: first.id }),
+                onDeny: () => reject.mutate({ id: first.id }),
+            }
+            : undefined);
+        // The mutations are new objects each render; the decision they send is not.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [first?.id, waiting.length, deciding, onWaiting]);
+    useEffect(() => () => onWaiting(undefined), [onWaiting]);
+    return null;
+}
 /** Take the person to the workspace's composer. */
 function focusComposer() {
     const composer = document.querySelector('[data-chat-composer] textarea, [data-chat-composer] [contenteditable="true"]');
     composer?.focus();
 }
-export function LoopAssistant({ app, person, }) {
+export function LoopAssistant({ app, person, appId, }) {
     const contributed = useContributions(LoopAssistantCharacter).map(entry => entry.value);
     const chosen = assistantCharacterFor(contributed, { app, person });
     const turnEntries = useContributions(LoopChatTurn);
     const turn = useSignalValue(turnEntries[0]?.value.turn ?? NO_TURN);
+    const presence = useSignalValue(turnEntries[0]?.value.presence ?? NO_PRESENCE);
+    const signedIn = Boolean(useIAMStore(state => state.token));
+    const [approval, setApproval] = useState();
     // On a page layout the conversation is its side panel; elsewhere it is
     // always on screen.
     const onPageLayout = useContributions(LoopChatLayout).some(entry => entry.value.id === 'page-layout');
@@ -96,12 +129,21 @@ export function LoopAssistant({ app, person, }) {
                 boxShadow: 'shadow.medium',
             }, children: _jsx(Text, { sx: { fontSize: 1 }, children: chosen.problem }) }));
     }
-    const state = assistantStateOfTurn(turn, { arriving, leaving });
+    const state = assistantStateOfTurn(turn, presence, { arriving, leaving });
     const unheard = !!saying && saying.id !== heardId;
-    const balloon = unheard && saying
-        ? { text: saying.text, more: saying.more }
-        : { text: 'Click me to open the conversation.' };
-    const insist = state === 'greeting' || (unheard && (state === 'speaking' || fresh));
+    const balloon = state === 'paused'
+        ? { text: ASSISTANT_WORDS.paused }
+        : approval
+            ? { text: ASSISTANT_WORDS.approval, approval }
+            : presence === 'waiting'
+                ? { text: ASSISTANT_WORDS.waiting }
+                : unheard && saying
+                    ? { text: saying.text, more: saying.more }
+                    : { text: 'Click me to open the conversation.' };
+    const insist = state === 'greeting' ||
+        presence === 'waiting' ||
+        (!!approval && state !== 'paused') ||
+        (unheard && (state === 'speaking' || fresh));
     const onToggle = () => {
         if (onPageLayout) {
             togglePagePanel();
@@ -118,18 +160,18 @@ export function LoopAssistant({ app, person, }) {
             setAway(next);
         }, 600);
     };
-    return (_jsx(AssistantStage, { character: chosen.character, state: state, size: SIZE, place: drag.position
-            ? { left: `${drag.position.left}px`, top: `${drag.position.top}px` }
-            : { right: '24px', bottom: '24px' }, stageRef: stageRef, onDragStart: drag.onHandlePointerDown, open: open, onToggle: onToggle, balloon: balloon, insist: insist, onDismiss: onDismiss }));
+    return (_jsxs(_Fragment, { children: [appId && signedIn ? (_jsx(WaitingApprovals, { appId: appId, onWaiting: setApproval })) : null, _jsx(AssistantStage, { character: chosen.character, state: state, size: SIZE, place: drag.position
+                    ? { left: `${drag.position.left}px`, top: `${drag.position.top}px` }
+                    : { right: '24px', bottom: '24px' }, stageRef: stageRef, onDragStart: drag.onHandlePointerDown, open: open, onToggle: onToggle, balloon: balloon, insist: insist, onDismiss: onDismiss })] }));
 }
 export const LoopAssistantPlugin = definePlugin({
     name: LOOP_ASSISTANT_PLUGIN_NAME,
-    config: { app: undefined, person: undefined },
+    config: { app: undefined, person: undefined, appId: undefined },
     displayName: 'Floating assistant',
     description: 'The chat as a character on the page: the application’s own, or the one the person chose, from the characters the enabled plugins contribute.',
     octicon: 'paperclip',
     build: ({ config }) => {
-        const Configured = () => (_jsx(LoopAssistant, { app: config.app, person: config.person }));
+        const Configured = () => (_jsx(LoopAssistant, { app: config.app, person: config.person, appId: config.appId }));
         return {
             components: [
                 { id: 'loop-assistant', slot: LoopSlots.root, Component: Configured },

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

@@ -36,6 +36,8 @@ import { CHAT_PLUGIN_NAME } from './index';
 import { INPUT_PROMPT_PLUGIN_NAME, } from '../input-prompt';
 import { agentRuntimeStore, useAgentRuntimeContextSnapshot, } from '../../../stores';
 import { useIAMStore } from '../../../state';
+import { useVisitorToken } from '../../apps/visitorToken';
+import { AGENTS_PLUGIN_NAME } from '../agents/plugin';
 import { useConfig } from '../../../hooks/useConfig';
 import { useSkills, useSkillActions } from '../../../hooks/useSkills';
 import { AI_MODEL_CATALOGUE, isChatModel } from '../../../specs/models';
@@ -199,11 +201,13 @@ export default function ChatView({ workspace }) {
         open: false,
         pendingApproval: false,
     });
-    const presenceNow = presenceState(busy, presenceTool);
+    const presenceNow = presenceState(busy, presenceTool, config?.presence?.paused === true);
     const onPresence = config?.presence?.onPresence;
-    // A host drawing the face in a frame of its own is told as it changes.
+    // A host drawing the face in a frame of its own is told as it changes, and
+    // so is whoever reads the turn: the floating assistant acts it out (T-22).
     useEffect(() => {
         onPresence?.(presenceNow);
+        turnFeedRef.current?.setPresence(presenceNow);
     }, [onPresence, presenceNow]);
     // What it last said, for a host that says it outside the conversation —
     // the embed's floating chrome (LOOP R-01): its balloon and its blink.
@@ -1135,7 +1139,14 @@ export default function ChatView({ workspace }) {
      * chat says so with the person's token. The embed hands its own.
      */
     const runsApp = Boolean(blueprintTurn?.createPayload?.app_spec);
-    const iamToken = useIAMStore(state => state.token);
+    const memberToken = useIAMStore(state => state.token);
+    /*
+     * Without an account (LOOP R-30) the application runs on the visitors'
+     * runtime, which answers a visitor's token for it and nobody signed in.
+     */
+    const visitors = reactor.getConfig(AGENTS_PLUGIN_NAME)?.datalayerVisitors;
+    const visitor = useVisitorToken(visitors);
+    const iamToken = visitors ? visitor.token : memberToken;
     const protocol = useMemo(() => inPage
         ? browserProtocolConfig({
             agentId: member?.specId ?? agentId,

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

@@ -9,9 +9,14 @@ export interface ChatPresence {
     face?: string;
     /** What it says before anyone writes. */
     welcome?: string;
+    /**
+     * Its deployment is paused (LOOP R-17): it says so beside its face, and
+     * its assistant dozes (T-08, T-22), whatever its last turn left behind.
+     */
+    paused?: boolean;
     /**
      * Told what it is doing as it changes — idle, thinking, working, waiting
-     * for you — for a host that draws the face itself, in a frame of its own.
+     * for you, paused — for a host that draws the face itself, in a frame of its own.
      * Read once, when the workspace is built: pass a stable function, such as
      * a state setter.
      */

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

@@ -86,6 +86,7 @@ export const ChatPlugin = definePlugin({
             id: 'chat-turn',
             turn: feed.turn,
             conversation: feed.conversation,
+            presence: feed.presence,
             ...feedWriters(feed),
         }, { id: 'chat-turn' });
         return {};

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

@@ -17,6 +17,7 @@ import { type ReadonlySignal } from '@datalayer/reactor';
 import type { ContextSnapshotData } from '../../../types';
 import type { DisplayItem } from '../../../types/chat';
 import type { ChatMessage } from '../../../types/messages';
+import type { PresenceState } from '../../../chat/presence/presenceStatus';
 import type { ChatTurnSnapshot, ChatTurnStatus, ConversationEntry } from '../../core';
 export type TurnFeed = {
     /** The turn, for readers. */
@@ -38,6 +39,10 @@ export type TurnFeed = {
     conversation: ReadonlySignal<ConversationEntry[]>;
     /** The chat's items as they now stand, streaming included. */
     items: (items: DisplayItem[]) => void;
+    /** What the application is doing, as its chat says it (T-08), for readers. */
+    presence: ReadonlySignal<PresenceState>;
+    /** What the application is doing now. */
+    setPresence: (state: PresenceState) => void;
 };
 /** A message's words, whether its content is a string or parts. */
 export declare function messageText(message: ChatMessage): string;

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

@@ -65,9 +65,16 @@ const IDLE = { id: 0, status: 'idle' };
 export function createTurnFeed() {
     const turn = signal(IDLE);
     const conversation = signal([]);
+    const presence = signal('idle');
     return {
         turn,
         conversation,
+        presence,
+        setPresence: state => {
+            if (presence.value !== state) {
+                presence.value = state;
+            }
+        },
         items: items => {
             const next = conversationOf(items);
             // Nothing new: readers do not re-render for an identical conversation.

package/lib/loop/presets.d.ts

@@ -137,6 +137,8 @@ export type LoopPresetOptions = {
     datalayerAgentSpecId?: string;
     /** What the agent on that runtime is created with besides its spec — an `app_spec`. */
     datalayerCreatePayload?: Record<string, unknown>;
+    /** A conversation without an account, on the visitors' runtime (LOOP R-30). */
+    datalayerVisitors?: AgentsConfig['datalayerVisitors'];
     /** The target is the host's to fix, even with the agent control hidden. */
     targetFixed?: boolean;
     /** The theme the conversation wears, by name; the person's unless said. */

package/lib/loop/presets.js

@@ -52,7 +52,7 @@ import { LoopPageLayoutPlugin } from './plugins/page-layout';
  * be installed or signed into, and the switches a demonstration wants are off.
  */
 export function loopPlugins(options = {}) {
-    const { serverUrl, target = 'browser', defaultEditor: askedEditor, showViewSelector = true, hideChatHeader = false, chatHeaderButtons = false, promptPlacement, autoFocusPrompt = true, suggestionLabels = true, fullScreenTopOffset = 0, showAgentVariants = false, agentSummary = true, teamId, teamPicker = true, pageLayout = false, pageLayoutArrangement = 'page', pageLayoutTurnPanel = 'below', pageLayoutPrompt = 'docked', pageLayoutPromptAnchor = 'top', pageLayoutSize, pageLayoutTurnPanelFooter = 'full', localAgent, localAgentSpec, datalayerAgentSpecId, datalayerCreatePayload, targetFixed, themeVariant, themeOverrides, colorMode, presence, showTokenUsage, floatingPrompt = false, editorSelector = false, editors = true, conversation = true, graph = false, commandPalette = false, pluginsPanel = false, windowFrame = false, firstPromptHook, } = options;
+    const { serverUrl, target = 'browser', defaultEditor: askedEditor, showViewSelector = true, hideChatHeader = false, chatHeaderButtons = false, promptPlacement, autoFocusPrompt = true, suggestionLabels = true, fullScreenTopOffset = 0, showAgentVariants = false, agentSummary = true, teamId, teamPicker = true, pageLayout = false, pageLayoutArrangement = 'page', pageLayoutTurnPanel = 'below', pageLayoutPrompt = 'docked', pageLayoutPromptAnchor = 'top', pageLayoutSize, pageLayoutTurnPanelFooter = 'full', localAgent, localAgentSpec, datalayerAgentSpecId, datalayerCreatePayload, datalayerVisitors, targetFixed, themeVariant, themeOverrides, colorMode, presence, showTokenUsage, floatingPrompt = false, editorSelector = false, editors = true, conversation = true, graph = false, commandPalette = false, pluginsPanel = false, windowFrame = false, firstPromptHook, } = options;
     const defaultEditor = askedEditor ?? (editors ? 'notebook' : 'none');
     // A workspace without a conversation: the theme, the shell's points, and
     // the host's chrome; its view is a host's plugin's.
@@ -111,6 +111,7 @@ export function loopPlugins(options = {}) {
             target,
             datalayerAgentSpecId,
             datalayerCreatePayload,
+            datalayerVisitors,
             targetFixed,
             showAgentVariants,
             showAgentSummary: agentSummary,

package/lib/stories/loop/ReferenceScreens.d.ts

@@ -4,7 +4,7 @@ import { type ThemeVariant } from '@datalayer/primer-addons';
 export declare const REFERENCE_SCREENS: readonly ["conversation", "beside-work", "worker-activity", "approval"];
 export type ReferenceScreen = (typeof REFERENCE_SCREENS)[number];
 /** The floating assistant's pictures (T-27): its states, and stepped aside. */
-export declare const ASSISTANT_PICTURES: readonly ["idle", "thinking", "working", "waiting", "speaking", "aside"];
+export declare const ASSISTANT_PICTURES: readonly ["idle", "thinking", "working", "waiting", "paused", "speaking", "aside"];
 export type AssistantPicture = (typeof ASSISTANT_PICTURES)[number];
 /**
  * The characters pictured idle, each in light and dark (T-25, T-24):

package/lib/stories/loop/ReferenceScreens.js

@@ -26,7 +26,8 @@ import { ChatBaseHeader } from '../../chat/header/ChatHeaderBase';
 import { ChatMessageList } from '../../chat/messages/ChatMessageList';
 import { InputPrompt } from '../../chat/prompt/InputPrompt';
 import { PresenceFace, PresenceLine } from '../../chat/presence/Presence';
-import { AssistantStage } from '../../chat/assistant/AssistantStage';
+import { AssistantStage, } from '../../chat/assistant/AssistantStage';
+import { ASSISTANT_WORDS, } from '../../chat/assistant/state';
 import { buildReactorFromPlugins } from '@datalayer/reactor';
 import { AssistantCharactersPlugin, assistantCharacterNamed, } from '../../loop/plugins/assistant-characters';
 import { OwlCharacterPlugin } from '../../examples/utils/owlCharacterPlugin';
@@ -43,6 +44,7 @@ export const ASSISTANT_PICTURES = [
     'thinking',
     'working',
     'waiting',
+    'paused',
     'speaking',
     'aside',
 ];
@@ -210,7 +212,19 @@ const BALLOONS = {
         text: 'Three customers wrote about late deliveries this week: Ada, Grace and Alan.',
         more: true,
     },
-    waiting: { text: 'Waiting for you: send the reply to Ada?' },
+    // An approval it waits on, answered in the balloon (T-23).
+    waiting: {
+        text: ASSISTANT_WORDS.approval,
+        approval: {
+            id: 'picture',
+            asks: 'send_reply',
+            why: 'Send a reply to a customer: ask me first',
+            others: 1,
+            onApprove: () => undefined,
+            onDeny: () => undefined,
+        },
+    },
+    paused: { text: ASSISTANT_WORDS.paused },
 };
 /**
  * The paper clip in one state, in the page's corner. `aside` puts a dialog

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datalayer/agent-runtimes",
-    "version": "1.3.52",
+    "version": "1.3.54",
     "type": "module",
     "workspaces": [
         ".",
@@ -147,7 +147,7 @@
         "@datalayer/agent-teams": "^1.0.0",
         "@datalayer/core": "^1.2.14",
         "@datalayer/decks": "^1.0.4",
-        "@datalayer/icons-react": "^1.0.14",
+        "@datalayer/icons-react": "^1.0.16",
         "@datalayer/jupyter-lexical": "^2.0.18",
         "@datalayer/jupyter-react": "^2.0.18",
         "@datalayer/jupyter-server-nbmodel": "^0.2.8",