@datalayer/agent-runtimes 1.3.74 → 1.3.78

package/lib/chat/assistant/assistantDetails.js

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The statuses of a sandbox that has something to read. */
+const LIVE = new Set(['running', 'idle', 'busy', 'starting']);
+/** Whether a sandbox is up: one with no status is taken to be. */
+export function sandboxIsLive(sandbox) {
+    return sandbox.status === undefined || LIVE.has(sandbox.status);
+}
+/** What the dialog says of a sandbox that is not running yet. */
+export const NO_SANDBOX_YET = 'No sandbox is running yet: run a cell or ask the agent to execute code.';
+/** What each kind is called. */
+export const SANDBOX_KIND_LABELS = {
+    browser: 'Python in your browser (Pyodide)',
+    local: 'Local Jupyter server',
+    jupyter: 'Jupyter server',
+    cloud: 'Datalayer cloud runtime',
+    runtime: 'In the agent runtime',
+};
+/** Whether a URL is on this machine. */
+export function isLocalUrl(url) {
+    if (!url) {
+        return false;
+    }
+    try {
+        const host = new URL(url).hostname;
+        return (host === 'localhost' ||
+            host === '127.0.0.1' ||
+            host === '::1' ||
+            host === '[::1]' ||
+            host.endsWith('.localhost'));
+    }
+    catch {
+        return false;
+    }
+}
+/** Query parameters that carry a secret. */
+const SECRET_PARAMS = /^(token|access_token|api_key|apikey|key|auth|password|secret|signature|sig|jwt)$/i;
+/** A URL fit to show: no credentials, no token in its query. */
+export function displayUrl(url) {
+    if (!url) {
+        return undefined;
+    }
+    try {
+        const parsed = new URL(url);
+        parsed.username = '';
+        parsed.password = '';
+        for (const name of [...parsed.searchParams.keys()]) {
+            if (SECRET_PARAMS.test(name)) {
+                parsed.searchParams.delete(name);
+            }
+        }
+        return parsed.toString();
+    }
+    catch {
+        // Not a URL: shown up to its query, which is where a token would be.
+        return url.split('?')[0];
+    }
+}
+const text = (value) => typeof value === 'string' && value ? value : undefined;
+/**
+ * A sandbox from the status its server reports — the Loop's sandbox
+ * service, or the agent's codemode status — and what the host adds.
+ */
+export function assistantSandboxOf(status, options = {}) {
+    if (!status) {
+        return undefined;
+    }
+    const variant = text(status.variant);
+    const url = text(status.jupyter_url) ?? text(status.agent_base_url);
+    const running = status.sandbox_running === true || status.jupyter_connected === true;
+    if (!variant && !running) {
+        return undefined;
+    }
+    const kind = variant === 'datalayer'
+        ? 'cloud'
+        : variant === 'jupyter-server' || variant === 'jupyter'
+            ? isLocalUrl(text(status.jupyter_url))
+                ? 'local'
+                : 'jupyter'
+            : 'runtime';
+    return {
+        kind,
+        status: options.state ?? (running ? 'running' : 'stopped'),
+        variant,
+        url,
+        token: text(status.jupyter_token),
+        kernelId: text(status.kernel_id),
+        agentId: options.agentId,
+        environment: text(status.environment_name),
+        serverUrl: options.serverUrl,
+    };
+}
+/**
+ * Run code in an agent's sandbox through its agent-runtimes server
+ * (`POST /api/v1/sandbox/execute`), whatever the variant: what a page with
+ * no kernel connection to the sandbox lists its variables with.
+ */
+export function sandboxExecuteOverHttp(serverUrl, agentId) {
+    const base = serverUrl.replace(/\/+$/, '').replace(/\/api\/v1$/, '');
+    return async (code) => {
+        const response = await fetch(`${base}/api/v1/sandbox/execute`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ code, agent_id: agentId }),
+        });
+        if (!response.ok) {
+            return {
+                stdout: '',
+                error: `The sandbox did not run the code (HTTP ${response.status}).`,
+            };
+        }
+        const payload = (await response.json());
+        return { stdout: payload.stdout ?? '', error: payload.error ?? undefined };
+    };
+}
+/** How long until a moment, for a reader: `1 h 20 min`, `never`. */
+export function timeLeft(expiresAt, now = Date.now()) {
+    if (expiresAt === null) {
+        return 'never';
+    }
+    if (expiresAt === undefined || expiresAt === '') {
+        return undefined;
+    }
+    const at = typeof expiresAt === 'number'
+        ? expiresAt < 1e12
+            ? expiresAt * 1000
+            : expiresAt
+        : Date.parse(expiresAt);
+    if (!Number.isFinite(at)) {
+        return undefined;
+    }
+    const minutes = Math.round((at - now) / 60000);
+    if (minutes <= 0) {
+        return 'ended';
+    }
+    const hours = Math.floor(minutes / 60);
+    return hours ? `${hours} h ${minutes % 60} min` : `${minutes} min`;
+}

package/lib/chat/assistant/formats/files.d.ts

@@ -0,0 +1,23 @@
+import { type AssistantCharacterData } from './types';
+/** What a file picker for a character accepts. */
+export declare const CHARACTER_FILES_ACCEPT = ".acs,.js,.png,.gif,.webp,.jpg,.jpeg";
+/** The sentence for a pick that is not a character. */
+export declare const CHARACTER_FILES_EXPECTED = "Pick one .acs file, or a clippy.js character: its agent.js and its map image (and a sounds file if you have one).";
+/** A picked file, as much of `File` as the reader needs. */
+export type PickedFile = Blob & {
+    name: string;
+};
+/** Which of the picked files make the character, or why none do. */
+export declare function characterFilesOf(files: ReadonlyArray<PickedFile>): {
+    kind: 'acs';
+    acs: PickedFile;
+} | {
+    kind: 'clippy';
+    agentJs: PickedFile;
+    map: PickedFile;
+    sounds?: PickedFile;
+} | {
+    problem: string;
+};
+/** Read the picked files as a character; refuses in a sentence. */
+export declare function readCharacterFiles(files: ReadonlyArray<PickedFile>): Promise<AssistantCharacterData>;

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The files a person picked, read as one character (LOOP T-26): one
+ * Microsoft Agent `.acs`, or a clippy.js character's `agent.js` and map
+ * image (and its sounds file, if there is one). Read in the page; nothing is
+ * sent anywhere.
+ *
+ * @module chat/assistant/formats/files
+ */
+import { readAcsCharacter } from './acs';
+import { readClippyCharacter } from './clippy';
+import { AssistantCharacterFormatError, } from './types';
+/** What a file picker for a character accepts. */
+export const CHARACTER_FILES_ACCEPT = '.acs,.js,.png,.gif,.webp,.jpg,.jpeg';
+/** The sentence for a pick that is not a character. */
+export const CHARACTER_FILES_EXPECTED = 'Pick one .acs file, or a clippy.js character: its agent.js and its map image (and a sounds file if you have one).';
+/** Which of the picked files make the character, or why none do. */
+export function characterFilesOf(files) {
+    const acs = files.find(file => file.name.toLowerCase().endsWith('.acs'));
+    if (acs) {
+        return { kind: 'acs', acs };
+    }
+    const agentJs = files.find(file => file.name.toLowerCase() === 'agent.js');
+    const map = files.find(file => /\.(png|gif|webp|jpe?g)$/i.test(file.name));
+    const sounds = files.find(file => /^sounds-.*\.js$/i.test(file.name));
+    if (!agentJs || !map) {
+        return { problem: CHARACTER_FILES_EXPECTED };
+    }
+    return { kind: 'clippy', agentJs, map, ...(sounds ? { sounds } : {}) };
+}
+/** Read the picked files as a character; refuses in a sentence. */
+export async function readCharacterFiles(files) {
+    const picked = characterFilesOf(files);
+    if ('problem' in picked) {
+        throw new AssistantCharacterFormatError(picked.problem);
+    }
+    if (picked.kind === 'acs') {
+        return readAcsCharacter(await picked.acs.arrayBuffer());
+    }
+    return readClippyCharacter({
+        agentJs: await picked.agentJs.text(),
+        mapPng: picked.map,
+        soundsJs: picked.sounds ? await picked.sounds.text() : undefined,
+    });
+}

package/lib/chat/assistant/formats/index.d.ts

@@ -11,3 +11,5 @@ export { readAcsCharacter, parseAcs, decodeAcsImage, layoutAcsSprite, composeAcs
 export type { AcsFile, AcsAnimation, AcsFrame, AcsImage } from './acs';
 export { decompressAgentData } from './agentCompression';
 export { stateAnimations } from './stateAnimations';
+export { CHARACTER_FILES_ACCEPT, CHARACTER_FILES_EXPECTED, characterFilesOf, readCharacterFiles, } from './files';
+export type { PickedFile } from './files';

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

@@ -13,3 +13,4 @@ export { readClippyCharacter, readClippyAgent, readClippySounds, } from './clipp
 export { readAcsCharacter, parseAcs, decodeAcsImage, layoutAcsSprite, composeAcsCell, } from './acs';
 export { decompressAgentData } from './agentCompression';
 export { stateAnimations } from './stateAnimations';
+export { CHARACTER_FILES_ACCEPT, CHARACTER_FILES_EXPECTED, characterFilesOf, readCharacterFiles, } from './files';

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

@@ -76,6 +76,11 @@ export interface AssistantSaying {
     text: string;
     /** Whether there was more than the balloon holds. */
     more: boolean;
+    /**
+     * Its words as written, markdown and all: what the `current` balloon
+     * draws, through the chat's markdown.
+     */
+    markdown: string;
 }
 /** How much of a message is kept as the agent's saying before it is cut. */
 export declare const SAYING_LIMIT = 220;
@@ -84,20 +89,8 @@ export declare const SAYING_LIMIT = 220;
  * code blocks left out, links and Markdown read as plain words.
  */
 export declare function plainWordsOf(content: unknown): string;
-/** A message of the conversation, as the `history` balloon lists it. */
-export interface BalloonHistoryMessage {
-    id: string;
-    /** Who said it: the person, or the agent. */
-    role: 'user' | 'assistant';
-    /** Its words, plain. */
-    text: string;
-}
-/**
- * The conversation as the `history` balloon lists it (T-23): the person's
- * and the agent's messages with words, in order — not the tool calls, not
- * an empty message — the same messages its header counts.
- */
-export declare function balloonHistoryOf(items: readonly unknown[]): BalloonHistoryMessage[];
+/** A message's text parts as written, markdown and all. */
+export declare function markdownOf(content: unknown): string;
 /**
  * The newest thing the agent said, as the Office Assistant said it: in the
  * balloon, while the conversation is closed (T-23). Only its own messages

package/lib/chat/assistant/state.js

@@ -75,25 +75,19 @@ export function plainWordsOf(content) {
         .replace(/\s+/g, ' ')
         .trim();
 }
-/**
- * The conversation as the `history` balloon lists it (T-23): the person's
- * and the agent's messages with words, in order — not the tool calls, not
- * an empty message — the same messages its header counts.
- */
-export function balloonHistoryOf(items) {
-    const history = [];
-    items.forEach((entry, index) => {
-        const item = entry;
-        if ((item.role !== 'user' && item.role !== 'assistant') ||
-            typeof item.toolName === 'string') {
-            return;
-        }
-        const text = plainWordsOf(item.content);
-        if (text) {
-            history.push({ id: String(item.id ?? index), role: item.role, text });
-        }
-    });
-    return history;
+/** A message's text parts as written, markdown and all. */
+export function markdownOf(content) {
+    return typeof content === 'string'
+        ? content
+        : Array.isArray(content)
+            ? content
+                .map(part => part &&
+                typeof part === 'object' &&
+                part.type === 'text'
+                ? String(part.text ?? '')
+                : '')
+                .join('\n\n')
+            : '';
 }
 /**
  * The newest thing the agent said, as the Office Assistant said it: in the
@@ -111,8 +105,14 @@ export function latestSaying(items) {
         if (!plain) {
             continue;
         }
+        const markdown = markdownOf(item.content);
         if (plain.length <= SAYING_LIMIT) {
-            return { id: String(item.id ?? index), text: plain, more: false };
+            return {
+                id: String(item.id ?? index),
+                text: plain,
+                more: false,
+                markdown,
+            };
         }
         const cut = plain.slice(0, SAYING_LIMIT);
         const atWord = cut.slice(0, Math.max(cut.lastIndexOf(' '), SAYING_LIMIT * 0.6));
@@ -120,6 +120,7 @@ export function latestSaying(items) {
             id: String(item.id ?? index),
             text: `${atWord.trimEnd()}…`,
             more: true,
+            markdown,
         };
     }
     return undefined;

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

@@ -1,3 +1,4 @@
+import type { DisplayItem, ToolCallMessage } from '../../types/chat';
 /**
  * How the balloon shows the conversation: `history`, every message,
  * scrolled, the composer last; `current`, only what it says or does now, in
@@ -67,3 +68,18 @@ export declare function toolAnnouncement(line: BalloonToolLine | undefined, prev
  * header counts them: the person's and the agent's, not the tool calls.
  */
 export declare function conversationCount(items: readonly unknown[]): number;
+/**
+ * A tool line as the chat holds it: a tool call (`ToolCallMessage`), drawn
+ * by the chat's own tool card in the balloon, its runtime's own words
+ * (`Asking Accounting…`) as its summary; or, when it names no tool — what
+ * the agent is doing, in its own words only — the agent's message saying
+ * so.
+ */
+export declare function displayItemOfLine(line: BalloonToolLine): DisplayItem;
+/** A tool line as the chat's own tool call (`ToolCallMessage`). */
+export declare function toolCallOfLine(line: BalloonToolLine): ToolCallMessage;
+/**
+ * The conversation with the tool being called, when the conversation does
+ * not hold that call already: what the history balloon lists.
+ */
+export declare function withToolCall(items: readonly DisplayItem[], line: BalloonToolLine | undefined): readonly DisplayItem[];

package/lib/chat/assistant/toolLine.js

@@ -116,3 +116,49 @@ export function conversationCount(items) {
             typeof message.toolName !== 'string');
     }).length;
 }
+/**
+ * A tool line as the chat holds it: a tool call (`ToolCallMessage`), drawn
+ * by the chat's own tool card in the balloon, its runtime's own words
+ * (`Asking Accounting…`) as its summary; or, when it names no tool — what
+ * the agent is doing, in its own words only — the agent's message saying
+ * so.
+ */
+export function displayItemOfLine(line) {
+    if (!line.tool && !line.name) {
+        return {
+            id: `balloon-activity:${line.id}`,
+            role: 'assistant',
+            content: line.words ?? '',
+            createdAt: new Date(0),
+        };
+    }
+    return toolCallOfLine(line);
+}
+/** A tool line as the chat's own tool call (`ToolCallMessage`). */
+export function toolCallOfLine(line) {
+    return {
+        id: `balloon-tool:${line.id}`,
+        type: 'tool-call',
+        toolCallId: line.id,
+        toolName: line.tool || line.name,
+        args: {},
+        status: line.phase === 'failed'
+            ? 'error'
+            : line.phase === 'done'
+                ? 'complete'
+                : 'executing',
+        ...(line.words ? { summary: line.words } : {}),
+    };
+}
+/**
+ * The conversation with the tool being called, when the conversation does
+ * not hold that call already: what the history balloon lists.
+ */
+export function withToolCall(items, line) {
+    if (!line ||
+        items.some(item => item.toolCallId === line.id ||
+            item.id === line.id)) {
+        return items;
+    }
+    return [...items, displayItemOfLine(line)];
+}

package/lib/chat/base/ChatBase.js

@@ -58,6 +58,9 @@ const EphemeralDocument = React.lazy(() => import('../document/EphemeralDocument
     default: m.EphemeralDocument,
 })));
 import { useNotebookTools } from '../../tools/adapters/agent-runtimes/notebookHooks';
+import { useAgentInspectorSink } from '../../components/inspector/agentInspector';
+import { chatInspectorRecorder, } from '../../components/inspector/chatInspect';
+import { loopMessageChange, speakerOf, withLoopMessage } from './loopMessage';
 // Tracks pending prompts already auto-sent for a given conversation scope.
 // This prevents layout-driven unmount/remount cycles from re-sending prompts.
 const sentPendingPromptKeys = new Set();
@@ -513,7 +516,7 @@ useStore: useStoreMode = true, protocol: protocolRaw, onSendMessage, onSendReady
 // Extended props
 brandIcon, avatarConfig, headerButtons, showPoweredBy = false, poweredByProps, emptyState, renderToolResult, renderHeader, showTurnFooter = true, notebookToolSurfacesId, footerContent, welcome, trailingContent, voice, voiceSpeaking = false, onStopSpeaking, showInformation = false, onInformationClick, headerContent, children, borderRadius, backgroundColor, border, boxShadow, compact = false, placeholder, description = 'Start a conversation with the AI agent.', onStateUpdate, onNewChat, onClear, onMessagesChange, onItemsChange, onDisplayItemsChange, autoFocus = false, suggestions, submitOnSuggestionClick = true, hideMessagesAfterToolUI = false, focusTrigger, frontendTools: frontendToolsProp, enableEphemeralNotebook = false, initialEphemeralNotebookOpen = true, onEphemeralNotebookOpenChange, enableEphemeralDocument = false, initialEphemeralSurfaceMode, onEphemeralSurfaceModeChange, collapsed = false, onExpandFromCollapsed, ephemeralNotebookToolbar, ephemeralNotebookToolbarExtraItems, ephemeralDocumentToolbarExtraItems, ephemeralNotebookCollaborationProvider, ephemeralNotebookCollaborationDocumentId, ephemeralDocumentCollaboration, ephemeralRuntimeOverride, 
 // Tool invocation hooks
-onToolCallStart, onToolCallComplete, 
+onToolCallStart, onToolCallComplete, inspector: inspectorGiven, 
 // Identity/Authorization props
 onAuthorizationRequired: _onAuthorizationRequired, connectedIdentities, 
 // Conversation persistence
@@ -1589,6 +1592,25 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
     onToolCallStartRef.current = onToolCallStart;
     const onToolCallCompleteRef = useRef(onToolCallComplete);
     onToolCallCompleteRef.current = onToolCallComplete;
+    // The Agent Inspector: the turns and tool calls, recorded as they happen.
+    const inspectorFromContext = useAgentInspectorSink();
+    const inspectorSink = inspectorGiven ?? inspectorFromContext;
+    const inspectorActorRef = useRef('Agent');
+    inspectorActorRef.current =
+        (typeof title === 'string' && title) || activeAgentId || 'Agent';
+    const recorderRef = useRef(null);
+    if (inspectorSink && recorderRef.current?.sink !== inspectorSink) {
+        recorderRef.current = {
+            sink: inspectorSink,
+            recorder: chatInspectorRecorder(inspectorSink, () => inspectorActorRef.current, {
+                frontendTools: () => (frontendToolsRef.current ?? []).map(tool => tool.name),
+            }),
+        };
+    }
+    else if (!inspectorSink) {
+        recorderRef.current = null;
+    }
+    const inspectAnswerRef = useRef('');
     const handleRespondRef = useRef(null);
     // A decision made outside the chat — a host page's own approval banner —
     // is answered exactly as the tool card's buttons answer it: through the
@@ -2415,6 +2437,9 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
                             const sanitizedContent = typeof rawContent === 'string'
                                 ? sanitizeAssistantContent(rawContent)
                                 : (rawContent ?? '');
+                            if (typeof sanitizedContent === 'string' && sanitizedContent) {
+                                inspectAnswerRef.current = sanitizedContent;
+                            }
                             setDisplayItems(prev => {
                                 const newItems = [...prev];
                                 const idx = newItems.findIndex(item => !isToolCallMessage(item) && item.id === currentId);
@@ -2520,6 +2545,11 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
                                 toolCallId,
                                 args,
                             });
+                            recorderRef.current?.recorder.toolStarted({
+                                id: toolCallId,
+                                name: toolName,
+                                args,
+                            });
                             const frontendTool = frontendToolsRef.current?.find(t => t.name === toolName);
                             const toolHandler = frontendTool?.handler;
                             // Execute when the args are complete. The protocol says so
@@ -2604,6 +2634,13 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
                                 setDisplayItems(prev => prev.map(item => isToolCallMessage(item) && item.toolCallId === toolCallId
                                     ? updatedToolCall
                                     : item));
+                                recorderRef.current?.recorder.toolEnded(toolCallId, {
+                                    result: event.toolResult.result,
+                                    error: event.toolResult.error ??
+                                        (updatedToolCall.status === 'error'
+                                            ? (executionError ?? 'failed')
+                                            : undefined),
+                                });
                                 // Fire post-hook for tool results
                                 onToolCallCompleteRef.current?.({
                                     toolName: existingToolCall.toolName,
@@ -2646,6 +2683,25 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
                         }
                     }
                     break;
+                case 'activity': {
+                    // An application's code changed a message it sent: its author
+                    // said, or the message taken away (LOOP P-15).
+                    const change = loopMessageChange(event.activity);
+                    if (!change)
+                        break;
+                    setDisplayItems(prev => withLoopMessage(prev, change));
+                    if (useStoreMode) {
+                        if ('removed' in change) {
+                            useChatStore.getState().deleteMessage(change.id);
+                        }
+                        else {
+                            useChatStore.getState().updateMessage(change.id, {
+                                speaker: speakerOf(change.author),
+                            });
+                        }
+                    }
+                    break;
+                }
                 case 'done':
                     /*
                      * What the turn cost, when nobody else is counting.
@@ -2657,6 +2713,11 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
                      * The bar and its ring simply never appeared for a browser agent.
                      */
                     {
+                        recorderRef.current?.recorder.turnEnded({
+                            text: inspectAnswerRef.current || undefined,
+                            usage: event.usage,
+                        });
+                        inspectAnswerRef.current = '';
                         const turnInput = event.usage?.promptTokens ?? 0;
                         const turnOutput = event.usage?.completionTokens ?? 0;
                         // The parts sum to the total when the harness did not send one:
@@ -2710,6 +2771,9 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
                     break;
                 case 'error':
                     console.error('[ChatBase] Protocol error:', event.error);
+                    recorderRef.current?.recorder.turnEnded({
+                        error: event.error?.message ?? 'error',
+                    });
                     if (event.error?.message &&
                         /exceeded maximum retries/i.test(event.error.message) &&
                         hideMessagesAfterToolUIRef.current) {
@@ -2777,6 +2841,7 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
                     result,
                     status: 'complete',
                 };
+                recorderRef.current?.recorder.toolEnded(toolCallId, { result });
                 toolCallsRef.current.set(toolCallId, completedToolCall);
                 setDisplayItems(prev => prev.map(item => isToolCallMessage(item) && item.toolCallId === toolCallId
                     ? completedToolCall
@@ -2789,6 +2854,9 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
                     status: 'error',
                     error: err.message,
                 };
+                recorderRef.current?.recorder.toolEnded(toolCallId, {
+                    error: err.message,
+                });
                 toolCallsRef.current.set(toolCallId, errorToolCall);
                 setDisplayItems(prev => prev.map(item => isToolCallMessage(item) && item.toolCallId === toolCallId
                     ? errorToolCall
@@ -2838,6 +2906,8 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
         if (!adapterRef.current && !onSendMessage)
             return;
         stoppedRef.current = false;
+        inspectAnswerRef.current = '';
+        recorderRef.current?.recorder.turnStarted(messageContent, selectedModel || undefined);
         suppressAssistantTextForToolOnlyRef.current =
             isToolCallOnlyPrompt(messageContent);
         // Said, then sent: by the microphone at once, or from the composer it

package/lib/chat/base/loopMessage.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A message of an application's code that changed after it was sent
+ * (LOOP P-15).
+ *
+ * The session API says a message's author, or that it was taken away, with a
+ * `CUSTOM` event named `loop.message` — `{id, author}` or `{id, removed: true}`
+ * — which the AG-UI adapter hands on as an `activity`. A message whose text
+ * changed needs nothing here: it is written again under its id, and the chat
+ * draws it in place.
+ */
+import type { MessageSpeaker } from '../../types/messages';
+/** The `CUSTOM` event's name. */
+export declare const LOOP_MESSAGE = "loop.message";
+/** What changed about a message already in the conversation. */
+export type LoopMessageChange = {
+    id: string;
+    removed: true;
+} | {
+    id: string;
+    author: string;
+};
+/** The change an activity says, or `null` when it says none. */
+export declare function loopMessageChange(activity: {
+    type: string;
+    data: unknown;
+} | undefined): LoopMessageChange | null;
+/** Who a message is by, as the chat draws a named voice. */
+export declare function speakerOf(author: string): MessageSpeaker;
+/**
+ * The conversation with the change made: the message taken away, or given its
+ * author. Items that are not that message — tool calls among them — are left
+ * as they are.
+ */
+export declare function withLoopMessage<T extends {
+    id?: string;
+    speaker?: MessageSpeaker;
+}>(items: T[], change: LoopMessageChange): T[];

package/lib/chat/base/loopMessage.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The `CUSTOM` event's name. */
+export const LOOP_MESSAGE = 'loop.message';
+/** The change an activity says, or `null` when it says none. */
+export function loopMessageChange(activity) {
+    if (!activity || activity.type !== LOOP_MESSAGE)
+        return null;
+    const data = activity.data;
+    if (!data || typeof data.id !== 'string' || !data.id)
+        return null;
+    if (data.removed === true)
+        return { id: data.id, removed: true };
+    if (typeof data.author === 'string' && data.author.trim()) {
+        return { id: data.id, author: data.author.trim() };
+    }
+    return null;
+}
+/** Who a message is by, as the chat draws a named voice. */
+export function speakerOf(author) {
+    return { id: `author:${author}`, name: author };
+}
+/**
+ * The conversation with the change made: the message taken away, or given its
+ * author. Items that are not that message — tool calls among them — are left
+ * as they are.
+ */
+export function withLoopMessage(items, change) {
+    if ('removed' in change) {
+        return items.filter(item => item.id !== change.id);
+    }
+    return items.map(item => item.id === change.id
+        ? { ...item, speaker: speakerOf(change.author) }
+        : item);
+}

package/lib/chat/indicators/TypingDots.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Three pulsing dots: a speaker is still at work and has not written yet —
+ * the chat's waiting indicator, and the assistant's balloon's. Still, but
+ * shown, for a reader who asks for reduced motion. Hidden from a screen
+ * reader: the live region beside it says the state.
+ *
+ * @module chat/indicators/TypingDots
+ */
+import type { ReactElement } from 'react';
+export declare function TypingDots({ size }: {
+    size?: number;
+}): ReactElement;
+export default TypingDots;

package/lib/chat/indicators/TypingDots.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from '@datalayer/primer-addons';
+export function TypingDots({ size = 8 }) {
+    return (_jsx(Box, { "aria-hidden": "true", "data-typing-dots": "", sx: { display: 'inline-flex', alignItems: 'center', gap: '4px' }, children: [0, 0.2, 0.4].map((delay, index) => (_jsx(Box, { sx: {
+                width: size,
+                height: size,
+                borderRadius: '50%',
+                bg: 'fg.muted',
+                animation: 'typingPulse 1.4s ease-in-out infinite',
+                animationDelay: `${delay}s`,
+                '@keyframes typingPulse': {
+                    '0%, 60%, 100%': { transform: 'scale(0.6)', opacity: 0.4 },
+                    '30%': { transform: 'scale(1)', opacity: 1 },
+                },
+                '@media (prefers-reduced-motion: reduce)': {
+                    animation: 'none',
+                    opacity: 0.7,
+                },
+            } }, index))) }));
+}
+export default TypingDots;