@datalayer/agent-runtimes 1.3.74 → 1.3.78

package/lib/chat/messages/ChatMarkdown.d.ts

@@ -0,0 +1,16 @@
+/**
+ * An agent's words, as markdown: what the chat's messages draw them with
+ * (`ChatMessageList`), and what the floating assistant's balloon draws its
+ * current line with — one renderer, so a code block, a table or a list
+ * looks the same wherever the words are read.
+ *
+ * @module chat/messages/ChatMarkdown
+ */
+import type { JSX } from 'react';
+/** How dense the chat's components draw: the chat's own, or the balloon's. */
+export type ChatDensity = 'comfortable' | 'compact';
+export declare function ChatMarkdown({ text, density, }: {
+    text: string;
+    density?: ChatDensity;
+}): JSX.Element;
+export default ChatMarkdown;

package/lib/chat/messages/ChatMarkdown.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from '@datalayer/primer-addons';
+import { Streamdown } from 'streamdown';
+import { streamdownMarkdownStyles } from '../styles/streamdownStyles';
+import { normalizeAssistantMarkdown } from './assistantMarkdown';
+export function ChatMarkdown({ text, density = 'comfortable', }) {
+    return (_jsx(Box, { "data-chat-markdown": "", sx: {
+            ...streamdownMarkdownStyles,
+            ...(density === 'compact'
+                ? {
+                    lineHeight: 1.4,
+                    '& p': { marginTop: 0, marginBottom: '0.4em' },
+                    '& p:last-child': { marginBottom: 0 },
+                }
+                : {}),
+        }, children: _jsx(Streamdown, { children: normalizeAssistantMarkdown(text) }) }));
+}
+export default ChatMarkdown;

package/lib/chat/messages/ChatMessageList.d.ts

@@ -1,4 +1,5 @@
 import { type ReactNode, type RefObject } from 'react';
+import { type ChatDensity } from './ChatMarkdown';
 import { type MarkedMcpServer } from '../marks';
 import type { DisplayItem, AvatarConfig, RenderToolResult } from '../../types/chat';
 import type { ChatMessage } from '../../types/messages';
@@ -67,6 +68,12 @@ export interface ChatMessageListProps {
      * and runtime tools are found in the catalogues.
      */
     mcpServers?: readonly MarkedMcpServer[];
+    /**
+     * How dense it draws: the chat's own (`comfortable`), or the floating
+     * assistant's balloon (`compact`: no avatars, smaller bubbles and tool
+     * rows, no turn footers). The same components either way.
+     */
+    density?: ChatDensity;
 }
 type SubagentAvatarConfig = Required<Pick<AvatarConfig, 'userAvatar' | 'assistantAvatar' | 'showAvatars' | 'avatarSize' | 'userAvatarBg' | 'assistantAvatarBg'>>;
 export interface SubagentChatPanelProps {
@@ -86,5 +93,5 @@ export interface SubagentChatPanelProps {
  * approval decisions are sent over the shared monitoring socket.
  */
 export declare function SubagentChatPanel({ toolCallId, subagentName: subagentNameHint, height, avatarConfig, }: SubagentChatPanelProps): React.ReactElement | null;
-export declare function ChatMessageList({ displayItems, isLoading, isStreaming, showLoadingIndicator, hideMessagesAfterToolUI, avatarConfig, padding, renderToolResult, emptyContent, messagesEndRef, onRespond, approvalConfig, showTurnFooters, agentUsage, onRemoveItems, renderMessageFooter, mcpServers, }: ChatMessageListProps): import("react").JSX.Element;
+export declare function ChatMessageList({ displayItems, isLoading, isStreaming, showLoadingIndicator, hideMessagesAfterToolUI, avatarConfig, padding, renderToolResult, emptyContent, messagesEndRef, onRespond, approvalConfig, showTurnFooters, agentUsage, onRemoveItems, renderMessageFooter, mcpServers, density, }: ChatMessageListProps): import("react").JSX.Element;
 export {};

package/lib/chat/messages/ChatMessageList.js

@@ -14,12 +14,12 @@ import { Fragment, useState, useCallback, useEffect, useMemo, useRef, } from 're
 import { Text, Spinner, Link, Label, RelativeTime } from '@primer/react';
 import { ArrowRightIcon, BroadcastIcon, ClockIcon, DependabotIcon, PersonIcon, SkipIcon, ToolsIcon, XCircleFillIcon, } from '@primer/octicons-react';
 import { Box } from '@datalayer/primer-addons';
-import { Streamdown } from 'streamdown';
-import { streamdownMarkdownStyles, streamdownCodeBlockStyles, } from '../styles/streamdownStyles';
+import { streamdownCodeBlockStyles } from '../styles/streamdownStyles';
+import { ChatMarkdown } from './ChatMarkdown';
 import { ToolCallDisplay } from '../tools/ToolCallDisplay';
 import { marksOfToolCall, skillIdOfCall } from '../marks';
+import { TypingDots } from '../indicators/TypingDots';
 import { TurnFooter } from './TurnFooter';
-import { normalizeAssistantMarkdown } from './assistantMarkdown';
 import { parseFormSubmission } from './formSubmission';
 import { FormSubmissionMessage } from './FormSubmissionMessage';
 import { isToolCallMessage, getMessageText } from '../../utils';
@@ -62,21 +62,6 @@ function toneColorsOf(tone) {
         fg: `${tone}.fg`,
     };
 }
-/** Three pulsing dots: a speaker is still writing and has not settled yet. */
-function TypingDots({ size = 8 }) {
-    return (_jsx(Box, { sx: { display: '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 },
-                },
-            } }, index))) }));
-}
 const SUBAGENT_AVATAR_CONFIG = {
     userAvatar: _jsx(PersonIcon, { size: 14 }),
     assistantAvatar: _jsx(DependabotIcon, { size: 14 }),
@@ -277,7 +262,7 @@ export function SubagentChatPanel({ toolCallId, subagentName: subagentNameHint,
 // DefaultToolCallRenderer — reads approvals from the Zustand store,
 // sends decisions over the shared WebSocket (no REST polling).
 // ---------------------------------------------------------------------------
-function DefaultToolCallRenderer({ item, onRespond, mcpServers, }) {
+function DefaultToolCallRenderer({ item, onRespond, mcpServers, density, }) {
     const resultObject = item.result && typeof item.result === 'object'
         ? item.result
         : undefined;
@@ -393,12 +378,18 @@ function DefaultToolCallRenderer({ item, onRespond, mcpServers, }) {
                     ? () => makeDecision('approve')
                     : undefined, onDeny: effectiveApprovalId && !decision && !externalDecision
                     ? () => makeDecision('reject')
-                    : undefined, approvalLoading: false, marks: marks }), isSubagentDelegation && (_jsx(SubagentChatPanel, { toolCallId: item.toolCallId, subagentName: delegatedSubagentName }))] }));
+                    : undefined, approvalLoading: false, marks: marks, summary: item.summary, density: density }), isSubagentDelegation && (_jsx(SubagentChatPanel, { toolCallId: item.toolCallId, subagentName: delegatedSubagentName }))] }));
 }
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
-export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoadingIndicator, hideMessagesAfterToolUI, avatarConfig, padding, renderToolResult, emptyContent, messagesEndRef, onRespond, approvalConfig, showTurnFooters = false, agentUsage, onRemoveItems, renderMessageFooter, mcpServers, }) {
+export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoadingIndicator, hideMessagesAfterToolUI, avatarConfig, padding, renderToolResult, emptyContent, messagesEndRef, onRespond, approvalConfig, showTurnFooters = false, agentUsage, onRemoveItems, renderMessageFooter, mcpServers, density = 'comfortable', }) {
+    const compact = density === 'compact';
+    if (compact) {
+        // The balloon's: no avatars, no turn footers.
+        avatarConfig = { ...avatarConfig, showAvatars: false };
+        showTurnFooters = false;
+    }
     if (displayItems.length === 0) {
         return _jsx(_Fragment, { children: emptyContent });
     }
@@ -500,7 +491,7 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                   not care about hid those tools entirely. Offering the default as a
                   node lets it compose instead of choosing.
                 */
-            const defaultUI = (_jsx(DefaultToolCallRenderer, { item: item, approvalConfig: approvalConfig, onRespond: createRespondCallback(item.toolCallId), mcpServers: mcpServers }));
+            const defaultUI = (_jsx(DefaultToolCallRenderer, { item: item, approvalConfig: approvalConfig, onRespond: createRespondCallback(item.toolCallId), mcpServers: mcpServers, density: density }));
             const toolUI = renderToolResult
                 ? renderToolResult({
                     toolCallId: item.toolCallId,
@@ -516,7 +507,7 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                 : defaultUI;
             if (toolUI === null || toolUI === undefined)
                 return null;
-            return (_jsx(Box, { sx: {
+            return (_jsx(Box, { "data-chat-tool-row": item.toolName, sx: {
                     display: 'flex',
                     flexDirection: 'column',
                     alignItems: 'flex-start',
@@ -531,7 +522,7 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                         */
                     width: '100%',
                     px: padding,
-                    py: 1,
+                    py: compact ? '2px' : 1,
                 }, children: toolUI }, item.id));
         }
         // ---- Chat message item ----
@@ -600,12 +591,12 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                 }
             }
         }
-        return (_jsx(Box, { sx: {
+        return (_jsx(Box, { "data-chat-message": message.role, sx: {
                 display: 'flex',
                 flexDirection: 'column',
                 alignItems: isUser ? 'flex-end' : 'flex-start',
                 px: padding,
-                py: 1,
+                py: compact ? '2px' : 1,
             }, children: _jsxs(Box, { sx: {
                     display: 'flex',
                     gap: 2,
@@ -649,7 +640,7 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                             ? speaker.initials || '?'
                             : isUser
                                 ? avatarConfig.userAvatar
-                                : avatarConfig.assistantAvatar })), _jsxs(Box, { sx: { maxWidth: '85%', minWidth: 0 }, children: [speaker ? (_jsxs(Box, { sx: {
+                                : avatarConfig.assistantAvatar })), _jsxs(Box, { sx: { maxWidth: compact ? '92%' : '85%', minWidth: 0 }, children: [speaker ? (_jsxs(Box, { sx: {
                                     display: 'flex',
                                     gap: 2,
                                     alignItems: 'baseline',
@@ -671,7 +662,8 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                                                     fontSize: 1,
                                                     color: toneColorsOf(message.directedTo.tone).fg,
                                                 }, children: message.directedTo.name })] })) : speaker.role ? (_jsx(Label, { size: "small", children: speaker.role })) : null, message.createdAt ? (_jsx(RelativeTime, { datetime: message.createdAt.toISOString(), sx: { fontSize: 0, color: 'fg.muted' } })) : null] })) : null, _jsxs(Box, { sx: {
-                                    p: 2,
+                                    p: compact ? 1 : 2,
+                                    px: compact ? 2 : 2,
                                     overflowX: 'auto',
                                     // The theme's bubble (LOOP T-03, T-06): today's 6px elsewhere.
                                     borderRadius: 'var(--theme-radius-bubble, 6px)',
@@ -710,7 +702,7 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                                         const text = getMessageText(message);
                                         const submission = parseFormSubmission(text);
                                         return submission ? (_jsx(FormSubmissionMessage, { submission: submission })) : (_jsxs(Text, { sx: {
-                                                fontSize: 1,
+                                                fontSize: compact ? 0 : 1,
                                                 whiteSpace: 'pre-wrap',
                                                 wordBreak: 'break-word',
                                             }, children: [message.metadata?.input === 'voice' ? (_jsx(Box, { as: "span", "data-spoken": "", title: "Said aloud", "aria-label": "Said aloud:", sx: {
@@ -719,7 +711,7 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                                                         mr: 1,
                                                         opacity: 0.85,
                                                     }, children: _jsx(MicrophoneIcon, { size: 14, "aria-hidden": "true" }) })) : null, text] }));
-                                    })()) : message.live && !getMessageText(message) ? (_jsx(TypingDots, { size: 6 })) : (_jsx(Box, { sx: streamdownMarkdownStyles, children: _jsx(Streamdown, { children: normalizeAssistantMarkdown(getMessageText(message) || (isStreaming ? '...' : '')) }) }))] }), renderMessageFooter ? (_jsx(Box, { sx: {
+                                    })()) : message.live && !getMessageText(message) ? (_jsx(TypingDots, { size: 6 })) : (_jsx(ChatMarkdown, { density: density, text: getMessageText(message) || (isStreaming ? '...' : '') }))] }), renderMessageFooter ? (_jsx(Box, { sx: {
                                     display: 'flex',
                                     gap: 2,
                                     alignItems: 'center',
@@ -735,7 +727,7 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                     return null;
                 }
                 return (_jsxs(Fragment, { children: [itemUI, footer] }, item.id));
-            }), showLoadingIndicator && (isLoading || isStreaming) && (_jsx(Box, { sx: {
+            }), showLoadingIndicator && (isLoading || isStreaming) && (_jsx(Box, { "data-chat-typing": "", sx: {
                     display: 'flex',
                     alignItems: 'flex-start',
                     px: padding,
@@ -757,9 +749,9 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                             }, children: avatarConfig.assistantAvatar })), _jsx(Box, { sx: {
                                 display: 'flex',
                                 alignItems: 'center',
-                                p: 2,
+                                p: compact ? 1 : 2,
                                 borderRadius: 'var(--theme-radius-bubble, 6px)',
                                 bg: 'canvas.subtle',
-                                minHeight: '32px',
+                                minHeight: compact ? '20px' : '32px',
                             }, children: _jsx(TypingDots, {}) })] }) })), _jsx("div", { ref: messagesEndRef })] }));
 }

package/lib/chat/styles/streamdownStyles.js

@@ -215,8 +215,10 @@ export const streamdownMarkdownStyles = {
         marginRight: 0,
         color: 'fg.muted',
     },
+    // A link reads as its theme says (LOOP T-06): in the accent, or plain —
+    // the colour of the words around it — and underlined in every theme.
     '& a': {
-        color: 'accent.fg',
+        color: 'var(--theme-message-link, var(--fgColor-accent, #0969da))',
         textDecoration: 'underline',
     },
     '& table': {

package/lib/chat/tools/ToolCallDisplay.d.ts

@@ -50,6 +50,13 @@ export interface ToolCallDisplayProps {
      * icon, else the emoji, else nothing.
      */
     marks?: Marks | null;
+    /** What it does in its runtime's words: shown in place of the arguments. */
+    summary?: string;
+    /**
+     * How dense: the chat's (`comfortable`), or the floating assistant's
+     * balloon (`compact`: a smaller header, the same card).
+     */
+    density?: 'comfortable' | 'compact';
 }
 /**
  * ToolCallDisplay component - Default display for tool calls in chat
@@ -61,5 +68,5 @@ export interface ToolCallDisplayProps {
  * - Color-coded status indicators
  * - Rich error display distinguishing execution errors from code errors
  */
-export declare function ToolCallDisplay({ toolCallId, toolName, args, result, status, error, executionResult, codeError, exitCode, executionError, approvalRequired, approvalState, approvalDecisionSource, onApprove, onDeny, approvalLoading, marks, }: ToolCallDisplayProps): React.JSX.Element;
+export declare function ToolCallDisplay({ toolCallId, toolName, args, result, status, error, executionResult, codeError, exitCode, executionError, approvalRequired, approvalState, approvalDecisionSource, onApprove, onDeny, approvalLoading, marks, summary, density, }: ToolCallDisplayProps): React.JSX.Element;
 export default ToolCallDisplay;

package/lib/chat/tools/ToolCallDisplay.js

@@ -125,7 +125,8 @@ function getArgsSummary(args) {
  * - Color-coded status indicators
  * - Rich error display distinguishing execution errors from code errors
  */
-export function ToolCallDisplay({ toolCallId, toolName, args, result, status, error, executionResult, codeError, exitCode, executionError, approvalRequired = false, approvalState, approvalDecisionSource, onApprove, onDeny, approvalLoading = false, marks, }) {
+export function ToolCallDisplay({ toolCallId, toolName, args, result, status, error, executionResult, codeError, exitCode, executionError, approvalRequired = false, approvalState, approvalDecisionSource, onApprove, onDeny, approvalLoading = false, marks, summary, density = 'comfortable', }) {
+    const compact = density === 'compact';
     const [isExpanded, setIsExpanded] = useState(false);
     // Determine effective exit code from props or execution result
     const effectiveExitCode = exitCode ?? executionResult?.exit_code;
@@ -143,7 +144,7 @@ export function ToolCallDisplay({ toolCallId, toolName, args, result, status, er
         : undefined;
     const statusDisplay = getStatusDisplay(status, errorType);
     const displayName = formatToolName(toolName);
-    const argsSummary = getArgsSummary(args);
+    const argsSummary = summary || getArgsSummary(args);
     const resultObject = result && typeof result === 'object'
         ? result
         : undefined;
@@ -168,19 +169,19 @@ export function ToolCallDisplay({ toolCallId, toolName, args, result, status, er
                     result.stderr ??
                     undefined)
                 : undefined);
-    return (_jsxs(Box, { sx: {
+    return (_jsxs(Box, { "data-tool-call": toolName, "data-tool-call-status": status, sx: {
             width: '100%',
             border: '1px solid',
             borderColor: 'border.default',
-            borderRadius: '12px',
+            borderRadius: compact ? '8px' : '12px',
             overflow: 'hidden',
             backgroundColor: 'canvas.default',
         }, children: [_jsxs(Box, { as: "button", onClick: () => setIsExpanded(!isExpanded), sx: {
                     width: '100%',
                     display: 'flex',
                     alignItems: 'center',
-                    gap: 2,
-                    padding: 2,
+                    gap: compact ? 1 : 2,
+                    padding: compact ? 1 : 2,
                     backgroundColor: 'canvas.subtle',
                     border: 'none',
                     borderBottom: isExpanded ? '1px solid' : 'none',
@@ -192,7 +193,7 @@ export function ToolCallDisplay({ toolCallId, toolName, args, result, status, er
                     },
                 }, children: [_jsx(Box, { sx: { color: 'fg.muted', flexShrink: 0 }, children: isExpanded ? (_jsx(ChevronDownIcon, { size: 16 })) : (_jsx(ChevronRightIcon, { size: 16 })) }), hasMark(marks) && (_jsx(Box, { sx: { color: 'fg.muted', flexShrink: 0, display: 'flex' }, children: _jsx(SpecMark, { icon: marks?.icon, emoji: marks?.emoji, size: 16 }) })), _jsx(Text, { sx: {
                             fontWeight: 'semibold',
-                            fontSize: 1,
+                            fontSize: compact ? 0 : 1,
                             color: 'fg.default',
                             flexShrink: 0,
                         }, children: displayName }), _jsxs(Box, { sx: {

package/lib/components/code-sandboxes/CodeSandboxCellVariablesDialog.js

@@ -3,8 +3,9 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { Dialog } from '@primer/react/experimental';
 import { nullTranslator } from '@jupyterlab/translation';
 import { JSONExt } from '@lumino/coreutils';
-import { KernelExecutor } from '@datalayer/jupyter-react';
+import { kernelConnectionExecutor, listKernelVariables, } from '@datalayer/jupyter-react';
 import { RuntimeSnippetsFacade } from '../../jupyter';
+import { transferableVariables } from './CodeSandboxVariables';
 import { CodeSandboxCellVariables } from './CodeSandboxCellVariables';
 /**
  * Dialog to define the runtime cell variables to transfer
@@ -53,16 +54,9 @@ export function CodeSandboxCellVariablesDialog(props) {
         }
         const connection = sessionContext.session.kernel;
         const spec = sessionContext.specsManager.specs.kernelspecs[connection.model.name];
-        const snippets = new RuntimeSnippetsFacade(spec.language);
-        const outputs = await new KernelExecutor({ connection }).execute(snippets.listVariables());
-        const content = outputs.get(0).data['text/plain'];
-        if (content) {
-            const runtimeVariables = JSON.parse(
-            // We need to remove the quotes prior to parsing
-            content.slice(1, content.length - 1));
-            return Object.keys(runtimeVariables ?? {});
-        }
-        return [];
+        return Object.keys(transferableVariables(await listKernelVariables(kernelConnectionExecutor(connection), {
+            language: spec.language,
+        })));
     }, [preference, sessionContext]);
     const getOutputCandidates = useCallback(async () => {
         // TODO this is only valid for python - using cell mimetype?

package/lib/components/code-sandboxes/CodeSandboxVariables.d.ts

@@ -1,7 +1,15 @@
 import { ReactElement } from 'react';
 import { ISessionContext } from '@jupyterlab/apputils';
 import { ITranslator } from '@jupyterlab/translation';
+import { type KernelVariable } from '@datalayer/jupyter-react';
 import type { IRuntimeDesc } from '../../models';
+/**
+ * The variables that can be carried to another sandbox, by name and type:
+ * values, not the modules, functions and classes code defines again.
+ */
+export declare function transferableVariables(variables: readonly KernelVariable[]): {
+    [name: string]: string;
+};
 /** What {@link useCodeSandboxVariablesTransfer} answers. */
 export interface ICodeSandboxVariablesTransfer {
     /**

package/lib/components/code-sandboxes/CodeSandboxVariables.js

@@ -10,8 +10,19 @@ import { Blankslate, DataTable, Table } from '@primer/react/experimental';
 import { nullTranslator } from '@jupyterlab/translation';
 import { checkIcon } from '@jupyterlab/ui-components';
 import { JSONExt } from '@lumino/coreutils';
-import { KernelExecutor } from '@datalayer/jupyter-react';
+import { kernelConnectionExecutor, listKernelVariables, } from '@datalayer/jupyter-react';
 import { RuntimeSnippetsFacade } from '../../jupyter';
+/**
+ * The variables that can be carried to another sandbox, by name and type:
+ * values, not the modules, functions and classes code defines again.
+ */
+export function transferableVariables(variables) {
+    return Object.fromEntries(variables
+        .filter(variable => variable.kind !== 'module' &&
+        variable.kind !== 'function' &&
+        variable.kind !== 'class')
+        .map(variable => [variable.name, variable.type]));
+}
 /**
  * The variables of the current sandbox, and which of them to carry over.
  *
@@ -45,18 +56,13 @@ export function useCodeSandboxVariablesTransfer(sessionContext, target, enabled
             setVariables({});
             return;
         }
-        const snippets = new RuntimeSnippetsFacade(spec.language);
-        const outputs = await new KernelExecutor({ connection }).execute(snippets.listVariables());
-        const content = outputs.get(0).data['text/plain'];
-        if (!content) {
-            setVariables({});
-            return;
-        }
-        // The payload comes quoted, as the representation of a string.
-        const listedVariables = JSON.parse(content.slice(1, content.length - 1));
+        // jupyter-react's snippet, run silently: the variables, typed.
+        const listedVariables = transferableVariables(await listKernelVariables(kernelConnectionExecutor(connection), {
+            language: spec.language,
+        }));
         setVariables(listedVariables);
         // Everything is carried over unless the user says otherwise.
-        setSelectedState(Object.keys(listedVariables ?? {}));
+        setSelectedState(Object.keys(listedVariables));
     }, [listed, sessionContext]);
     const setSelected = useCallback((names) => {
         setSelectedState(current => JSONExt.deepEqual(current, names) ? current : names);

package/lib/components/inspector/AgentInspector.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The Agent Inspector: what agents do, one row a thing, newest last — the
+ * time (to the millisecond, and since the first), who did it and toward
+ * whom, its source and kind, its name with its mark, its status and
+ * duration, and a line that says it. A row unfolds to its payload as a JSON
+ * tree (a call's arguments and its result), and to what was made of it.
+ *
+ * Filters by source, kind and actor; *Pause* holds the rows still while the
+ * record goes on, *Clear* empties it, *Export* saves the session as JSON. A
+ * large payload (a notebook) says its size and stays folded until asked.
+ *
+ * Fed by a sink (`useAgentInspector`) or given its entries.
+ *
+ * @module components/inspector/AgentInspector
+ */
+import type { JSX } from 'react';
+import { type AgentInspectorEntry, type AgentInspectorExport, type AgentInspectorSink, type AgentInspectorSource } from './agentInspector';
+export type AgentInspectorProps = {
+    /** The record to show, kept current. */
+    sink?: AgentInspectorSink | null;
+    /** Or its entries, as given. */
+    entries?: readonly AgentInspectorEntry[];
+    /** How tall the rows grow before they scroll. */
+    maxHeight?: number | string;
+    /** Payloads larger than this, in bytes, stay folded until asked. */
+    largeBytes?: number;
+    /** What is said while nothing is recorded. */
+    emptyText?: string;
+    /** The file name the session is exported as, without `.json`. */
+    exportName?: string;
+    /**
+     * One agent's own record: what it did (`actor`), and the A2A messages it
+     * sent or received — one message shows in the sender's and in the
+     * receiver's, the same entry, as sent in one and received in the other.
+     */
+    agent?: string;
+};
+/** Whether an entry is one agent's: done by it, or sent to or by it. */
+export declare function isAgentsEntry(entry: AgentInspectorEntry, agent: string): boolean;
+/** Which way an entry went, from one agent's side: `→ Accounting`, `← Accounting`. */
+export declare function directionFrom(entry: AgentInspectorEntry, agent: string | undefined): string;
+/** A time of day, to the millisecond: `15:44:31.299`. */
+export declare function clockTime(at: number): string;
+/** Time since the first entry: `+1.204s`. */
+export declare function sinceFirst(at: number, first: number): string;
+/** How long a call took: `412 ms`, `3.4 s`. */
+export declare function durationText(ms: number): string;
+export type AgentInspectorFilter = {
+    sources: ReadonlySet<AgentInspectorSource>;
+    kinds: ReadonlySet<string>;
+    actors: ReadonlySet<string>;
+};
+/** The entries a filter keeps: an empty set keeps every value. */
+export declare function filterEntries(entries: readonly AgentInspectorEntry[], filter: AgentInspectorFilter): AgentInspectorEntry[];
+/** A session, as JSON. */
+export declare function exportEntries(entries: readonly AgentInspectorEntry[]): AgentInspectorExport;
+/** The Agent Inspector. */
+export declare function AgentInspector({ sink, entries: given, maxHeight, largeBytes, emptyText, exportName, agent, }: AgentInspectorProps): JSX.Element;
+export default AgentInspector;