@datalayer/agent-runtimes 1.3.75 → 1.3.78

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

@@ -0,0 +1,84 @@
+/**
+ * What the assistant's menu knows of its agent and of its code sandbox, for
+ * *Agent Details…* and *Code Sandbox Details…*.
+ *
+ * Light on purpose: types and pure helpers only. The dialogs that draw them
+ * — `AgentDetails`, jupyter-react's `KernelVariables` — are loaded when one
+ * is opened, never with the character.
+ *
+ * @module chat/assistant/assistantDetails
+ */
+import type { Kernel } from '@jupyterlab/services';
+import type { KernelVariablesExecution } from '@datalayer/jupyter-react';
+/** Where a sandbox runs. */
+export type AssistantSandboxKind = 
+/** Pyodide, in this page. */
+'browser'
+/** A Jupyter server on this machine, the agent's own. */
+ | 'local'
+/** A Jupyter server elsewhere. */
+ | 'jupyter'
+/** A Datalayer cloud runtime. */
+ | 'cloud'
+/** In the agent runtime's process, or at a provider (`eval`, `e2b`, …). */
+ | 'runtime';
+/** A code sandbox, as much of it as its host knows. */
+export type AssistantSandbox = {
+    kind: AssistantSandboxKind;
+    /** `running`, `starting`, `idle`, `stopped`, `error`. */
+    status?: string;
+    /** The sandbox manager's variant: `jupyter-server`, `eval`, `datalayer`, a provider. */
+    variant?: string;
+    /** The Jupyter server, or the base the sandbox is reached at. Shown without its tokens. */
+    url?: string;
+    /** The token the Jupyter server wants: used to connect, never shown. */
+    token?: string;
+    /** The kernel the sandbox runs, on that server. */
+    kernelId?: string;
+    /** The agent whose sandbox it is (a local server's per-agent sandbox). */
+    agentId?: string;
+    /** The environment it runs in. */
+    environment?: string;
+    /** A cloud runtime's identity: its uid, never its pod's name. */
+    runtimeUid?: string;
+    /** When a cloud runtime ends; `null` when it is not metered. */
+    expiresAt?: string | number | null;
+    /** What a cloud runtime burns, in credits per hour. */
+    burningRate?: number;
+    startedAt?: string | number;
+    lastActivity?: string | number;
+    /** The kernel, when the page talks to it: listed live, widgets drawn. */
+    connection?: Kernel.IKernelConnection | null;
+    /**
+     * The agent-runtimes server whose `/api/v1/sandbox/execute` runs code in
+     * the agent's sandbox, when the page has no kernel connection to it.
+     */
+    serverUrl?: string;
+};
+/** Whether a sandbox is up: one with no status is taken to be. */
+export declare function sandboxIsLive(sandbox: AssistantSandbox): boolean;
+/** What the dialog says of a sandbox that is not running yet. */
+export declare 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 declare const SANDBOX_KIND_LABELS: Record<AssistantSandboxKind, string>;
+/** Whether a URL is on this machine. */
+export declare function isLocalUrl(url: string | undefined): boolean;
+/** A URL fit to show: no credentials, no token in its query. */
+export declare function displayUrl(url: string | undefined): string | 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 declare function assistantSandboxOf(status: Record<string, unknown> | null | undefined, options?: {
+    agentId?: string;
+    serverUrl?: string;
+    state?: string;
+}): AssistantSandbox | undefined;
+/**
+ * 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 declare function sandboxExecuteOverHttp(serverUrl: string, agentId?: string): (code: string) => Promise<KernelVariablesExecution>;
+/** How long until a moment, for a reader: `1 h 20 min`, `never`. */
+export declare function timeLeft(expiresAt: string | number | null | undefined, now?: number): string | undefined;

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

@@ -60,6 +60,7 @@ const EphemeralDocument = React.lazy(() => import('../document/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();
@@ -2682,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.

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/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 {};