@datalayer/agent-runtimes 1.3.53 → 1.3.55

package/lib/examples/AgentStrategyExample.d.ts

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

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

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

package/lib/examples/example-selector.js

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

package/lib/examples/index.d.ts

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

package/lib/examples/index.js

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

package/lib/examples/main.js

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

package/lib/loop/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/embed/LoopEmbed.js

@@ -76,6 +76,7 @@ export function LoopEmbed({ agentId = '', showHeader = false, chatHeaderActions,
         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/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';
@@ -1137,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/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,