@datalayer/agent-runtimes 1.3.11 → 1.3.14

package/README.md

@@ -10,8 +10,7 @@
 
 # 🤖 🚀 Agent Runtimes
 
-[![Github Actions Status](https://github.com/datalayer/agent-runtimes/actions/workflows/build.yml/badge.svg)](https://github.com/datalayer/agent-runtimes/actions/workflows/build.yml)
-[![Netlify Status](https://api.netlify.com/api/v1/badges/f7f9e08a-884f-4f76-b20d-666d5873716c/deploy-status)](https://app.netlify.com/projects/agent-runtimes/deploys)
+[![Github Actions Status](https://github.com/datalayer/agent-runtimes/actions/workflows/build.yaml/badge.svg)](https://github.com/datalayer/agent-runtimes/actions/workflows/build.yaml)
 [![PyPI - Version](https://img.shields.io/pypi/v/agent-runtimes)](https://pypi.org/project/agent-runtimes)
 
 **Agent Runtimes** is a unified library for deploying, managing, and interacting with AI agents across multiple protocols and frameworks. It provides both a Python server for hosting agents and React components for seamless integration into web and desktop applications.

package/lib/AgentNode.js

@@ -819,8 +819,8 @@ export function AgentNode() {
             const aiAgentsUrl = getConfigUrlFromDocument('aiAgentsUrl') ||
                 import.meta.env?.VITE_DATALAYER_AI_AGENTS_URL ||
                 'https://r1.datalayer.run';
-            const jupyterMcpServerUrl = getConfigUrlFromDocument('jupyterMcpServerUrl') ||
-                import.meta.env?.VITE_DATALAYER_JUPYTER_MCP_SERVER_URL ||
+            const datalayerMcpServerUrl = getConfigUrlFromDocument('datalayerMcpServerUrl') ||
+                import.meta.env?.VITE_DATALAYER_MCP_SERVER_URL ||
                 'https://mcp.datalayer.run/mcp';
             // Seed all per-service URLs to match the main UI login behavior.
             const coreApi = coreStore.getState();
@@ -832,7 +832,7 @@ export function AgentNode() {
                 libraryUrl: iamUrl,
                 aiAgentsUrl,
                 aiInferenceUrl: aiInferenceUrl,
-                jupyterMcpServerUrl,
+                datalayerMcpServerUrl,
                 otelUrl: iamUrl,
                 growthUrl: iamUrl,
                 successUrl: iamUrl,

package/lib/api/runtimes/healthz.js

@@ -36,9 +36,11 @@ export const ping = async (baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
         // Check if it's a response error with status code information
         if (error.response) {
             const status = error.response.status;
-            throw new Error(`Health check failed: Service unhealthy (status ${status}) - ${error.message}`);
+            throw new Error(`Health check failed: Service unhealthy (status ${status}) - ${error.message}`, { cause: error });
         }
         // Re-throw other errors (network errors, etc.)
-        throw new Error(`Health check failed: ${error.message}`);
+        throw new Error(`Health check failed: ${error.message}`, {
+            cause: error,
+        });
     }
 };

package/lib/api/spacer/healthz.js

@@ -36,9 +36,11 @@ export const ping = async (baseUrl = DEFAULT_SERVICE_URLS.SPACER) => {
         // Check if it's a response error with status code information
         if (error.response) {
             const status = error.response.status;
-            throw new Error(`Health check failed: Service unhealthy (status ${status}) - ${error.message}`);
+            throw new Error(`Health check failed: Service unhealthy (status ${status}) - ${error.message}`, { cause: error });
         }
         // Re-throw other errors (network errors, etc.)
-        throw new Error(`Health check failed: ${error.message}`);
+        throw new Error(`Health check failed: ${error.message}`, {
+            cause: error,
+        });
     }
 };

package/lib/chat/base/ChatBase.js

@@ -31,7 +31,7 @@ import { useChatStore } from '../../stores/chatStore';
 import { useConversationStore } from '../../stores/conversationStore';
 import { generateMessageId, createUserMessage, createAssistantMessage, } from '../../types/messages';
 import { AgentDetails } from '../../agents/AgentDetails';
-import { AI_MODEL_CATALOGUE } from '../../specs/models';
+import { AI_MODEL_CATALOGUE, DEFAULT_MODEL } from '../../specs/models';
 import { internalQueryClient, isToolCallMessage, convertHistoryToDisplayItems, createProtocolAdapter, getApiBaseFromConfig, sanitizeAssistantContent, } from '../../utils';
 import { useConfig, useSkills, useSkillActions, useContextSnapshot, useSandbox, } from '../../hooks';
 import { useAgentRuntimeWebSocket } from '../../hooks/useAgentRuntimes';
@@ -48,6 +48,7 @@ import { InputPrompt } from '../prompt/InputPrompt';
 import { isFloatingChatViewMode } from '../viewModes';
 import { ToolApprovalBanner, ToolApprovalDialog, } from '../tools';
 import { EphemeralNotebook } from '../notebook/EphemeralNotebook';
+import { initialModelId, isOffered, usableModels } from './modelChoice';
 // EphemeralDocument statically imports `@datalayer/jupyter-lexical` (which
 // initialises Lumino-backed nodes on load). Lazy-load it so notebook-only chats
 // never pull lexical into the bundle or trigger its module side effects.
@@ -1378,9 +1379,10 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
         ? (protocol?.options).model
         : undefined;
     const offeredModels = useMemo(() => {
+        // Only what can actually be called — see `modelChoice` for the rule.
         const fromConfig = availableModels || configQuery.data?.models;
         if (fromConfig?.length) {
-            return fromConfig;
+            return usableModels(fromConfig);
         }
         /*
          * The catalogue, filtered to what is worth offering.
@@ -1402,7 +1404,7 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
             provider: model.provider,
         }));
         if (catalogued.length > 0) {
-            return catalogued;
+            return usableModels(catalogued);
         }
         return browserModel
             ? [{ id: browserModel, name: browserModel, provider: 'inference' }]
@@ -1721,7 +1723,7 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
         const timer = setTimeout(adjustTextareaHeight, 0);
         return () => clearTimeout(timer);
     }, [adjustTextareaHeight]);
-    // ---- Initialize model and tools when config is available ----
+    // ---- The model, whenever what is offered changes ----
     useEffect(() => {
         /*
          * `offeredModels`, not the two sources it is built from.
@@ -1731,28 +1733,40 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
          * sources, so that model was offered by the menu and never selected. The
          * menu draws nothing without a selection, so a browser agent had a model
          * list of one and no model control at all.
+         *
+         * Re-picked, not picked once. Before the server has answered, the offer
+         * is the browser's catalogue, and the chat chose from it — the first row,
+         * Alibaba, which the catalogue marks available because the platform is
+         * entitled to it. The server then answered with the one model this
+         * process can call, the guess was not in it, and nothing looked again:
+         * the trigger read "none selected" while every turn was still sent to
+         * Alibaba and came back asking for its key. A selection stands only while
+         * it is offered and usable; otherwise the preferred model — the agent's
+         * own, from the server — or the first usable one takes its place.
          */
-        if (offeredModels.length > 0 && !selectedModel) {
-            const modelsList = offeredModels;
-            const preferredModel = initialModel || configQuery.data?.defaultModel;
-            if (preferredModel) {
-                const modelExists = modelsList.some(m => m.id === preferredModel);
-                if (modelExists) {
-                    setSelectedModel(preferredModel);
-                }
-                else {
-                    const firstAvailableModel = modelsList.find(m => m.isAvailable !== false);
-                    const firstModel = firstAvailableModel || modelsList[0];
-                    if (firstModel)
-                        setSelectedModel(firstModel.id);
-                }
-            }
-            else {
-                const firstAvailableModel = modelsList.find(m => m.isAvailable !== false);
-                const firstModel = firstAvailableModel || modelsList[0];
-                if (firstModel)
-                    setSelectedModel(firstModel.id);
-            }
+        if (offeredModels.length === 0 || isOffered(offeredModels, selectedModel)) {
+            return;
+        }
+        // The host's word first, then the server's default, then the platform's:
+        // the first row of a catalogue is an order of listing, not a choice, and
+        // opening on it sent the first message to Alibaba while the footer —
+        // drawn from the host's own model — said Claude.
+        const opening = initialModelId(offeredModels, initialModel || configQuery.data?.defaultModel || DEFAULT_MODEL);
+        if (opening && opening !== selectedModel) {
+            setSelectedModel(opening);
+        }
+    }, [
+        offeredModels,
+        selectedModel,
+        initialModel,
+        configQuery.data?.defaultModel,
+    ]);
+    // ---- Initialize tools when config is available ----
+    const toolsInitializedRef = useRef(false);
+    useEffect(() => {
+        // Once: a later change to the offer must not undo what the reader toggled.
+        if (offeredModels.length > 0 && !toolsInitializedRef.current) {
+            toolsInitializedRef.current = true;
             const allToolIds = configQuery.data?.builtinTools?.map(tool => tool.id) || [];
             setEnabledTools(allToolIds);
             if (configQuery.data?.mcpServers) {

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

@@ -0,0 +1,62 @@
+/**
+ * Which models a chat offers, and which one it opens on.
+ *
+ * Two rules, kept out of `ChatBase` so they can be read and tested without
+ * rendering a chat:
+ *
+ * - **Only what can be called is offered.** A server answers with its whole
+ *   catalogue and a flag per model, and the menu used to draw all of it, most
+ *   rows greyed out with a reason. Thirty models to choose two from reads as
+ *   a broken menu, and the one thing it guarantees is that a reader's first
+ *   click lands on something that cannot answer.
+ * - **The default has to be one of them.** A default naming a model this
+ *   deployment cannot use — a spec claiming the default while marked
+ *   unavailable — opened every chat on it, and the first message came back
+ *   as the provider's complaint about a missing key.
+ *
+ * @module chat/base/modelChoice
+ */
+import type { ModelConfig } from '../../types/chat';
+/** Whether a model can be picked: the flag says no, or says nothing. */
+export declare const isUsable: (model: ModelConfig) => boolean;
+/**
+ * The models to offer: the usable ones.
+ *
+ * When none is usable the list is kept whole. An empty menu says nothing,
+ * while the rows and their reasons say which key is missing.
+ */
+export declare function usableModels(models: ModelConfig[]): ModelConfig[];
+/** Whether `id` is on offer and usable — the selection may stand. */
+export declare const isOffered: (offered: ModelConfig[], id?: string) => boolean;
+/**
+ * The model a chat opens on.
+ *
+ * The preferred one when it is offered *and* usable; otherwise the first
+ * usable one; otherwise the first there is. `undefined` when there is none.
+ */
+export declare function initialModelId(offered: ModelConfig[], preferred?: string | null): string | undefined;
+/**
+ * One row of `/api/v1/configure/models`, as the server writes it.
+ *
+ * Snake case and its own flag names: the route is read by more than this
+ * chat, and its shape is the server's to keep.
+ */
+export type ServerCatalogueModel = {
+    id: string;
+    name?: string;
+    available?: boolean;
+    missing_env_vars?: string[];
+    reason?: string;
+    warning?: string | null;
+};
+/**
+ * The server's catalogue in the chat's shape.
+ *
+ * The route says `available`; the chat, the menu and the rules above read
+ * `isAvailable`. Handed over unmapped, every row looked usable, the menu
+ * offered all thirty-one, and the first message of a chat that opened before
+ * its spec was known went to the first row — Alibaba, and its missing key.
+ */
+export declare function readServerCatalogue(payload: {
+    models?: ServerCatalogueModel[];
+} | null | undefined): ModelConfig[];

package/lib/chat/base/modelChoice.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** Whether a model can be picked: the flag says no, or says nothing. */
+export const isUsable = (model) => model.isAvailable !== false;
+/**
+ * The models to offer: the usable ones.
+ *
+ * When none is usable the list is kept whole. An empty menu says nothing,
+ * while the rows and their reasons say which key is missing.
+ */
+export function usableModels(models) {
+    const usable = models.filter(isUsable);
+    return usable.length > 0 ? usable : models;
+}
+/** Whether `id` is on offer and usable — the selection may stand. */
+export const isOffered = (offered, id) => Boolean(id) && offered.some(m => m.id === id && isUsable(m));
+/**
+ * The model a chat opens on.
+ *
+ * The preferred one when it is offered *and* usable; otherwise the first
+ * usable one; otherwise the first there is. `undefined` when there is none.
+ */
+export function initialModelId(offered, preferred) {
+    if (preferred && offered.some(m => m.id === preferred && isUsable(m))) {
+        return preferred;
+    }
+    const first = offered.find(isUsable) ?? offered[0];
+    return first?.id;
+}
+/**
+ * The server's catalogue in the chat's shape.
+ *
+ * The route says `available`; the chat, the menu and the rules above read
+ * `isAvailable`. Handed over unmapped, every row looked usable, the menu
+ * offered all thirty-one, and the first message of a chat that opened before
+ * its spec was known went to the first row — Alibaba, and its missing key.
+ */
+export function readServerCatalogue(payload) {
+    return (payload?.models ?? []).map(model => {
+        const missing = model.missing_env_vars ?? [];
+        const reason = model.reason ??
+            (missing.length > 0 ? `Set ${missing.join(', ')}` : undefined) ??
+            model.warning ??
+            undefined;
+        return {
+            id: model.id,
+            name: model.name ?? model.id,
+            isAvailable: model.available !== false,
+            ...(reason && model.available === false
+                ? { unavailableReason: reason }
+                : {}),
+        };
+    });
+}

package/lib/chat/messages/ChatMessageList.js

@@ -18,6 +18,8 @@ import { streamdownMarkdownStyles, streamdownCodeBlockStyles, } from '../styles/
 import { ToolCallDisplay } from '../tools/ToolCallDisplay';
 import { TurnFooter } from './TurnFooter';
 import { normalizeAssistantMarkdown } from './assistantMarkdown';
+import { parseFormSubmission } from './formSubmission';
+import { FormSubmissionMessage } from './FormSubmissionMessage';
 import { isToolCallMessage, getMessageText } from '../../utils';
 import { A2AAgentDialog, a2aAgentDetails } from '../tools/A2AAgentDialog';
 import { SUBAGENT_STOPPED } from '../../types/stream';
@@ -697,11 +699,17 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                                                     display: 'inline-flex',
                                                     gap: 1,
                                                     alignItems: 'center',
-                                                }, children: [_jsx(ToolsIcon, { size: 10 }), " ", label] }) }, `${label}-${chipIndex}`))) })) : null, isUser ? (_jsx(Text, { sx: {
-                                            fontSize: 1,
-                                            whiteSpace: 'pre-wrap',
-                                            wordBreak: 'break-word',
-                                        }, children: getMessageText(message) })) : message.live && !getMessageText(message) ? (_jsx(TypingDots, { size: 6 })) : (_jsx(Box, { sx: streamdownMarkdownStyles, children: _jsx(Streamdown, { children: normalizeAssistantMarkdown(getMessageText(message) || (isStreaming ? '...' : '')) }) }))] }), renderMessageFooter ? (_jsx(Box, { sx: {
+                                                }, children: [_jsx(ToolsIcon, { size: 10 }), " ", label] }) }, `${label}-${chipIndex}`))) })) : null, isUser ? ((() => {
+                                        // A submitted form is drawn as the form, not as the JSON
+                                        // the agent reads — see `formSubmission`.
+                                        const text = getMessageText(message);
+                                        const submission = parseFormSubmission(text);
+                                        return submission ? (_jsx(FormSubmissionMessage, { submission: submission })) : (_jsx(Text, { sx: {
+                                                fontSize: 1,
+                                                whiteSpace: 'pre-wrap',
+                                                wordBreak: 'break-word',
+                                            }, children: 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: {
                                     display: 'flex',
                                     gap: 2,
                                     alignItems: 'center',

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

@@ -0,0 +1,17 @@
+/**
+ * A submitted form, as a card in the transcript.
+ *
+ * Drawn where the reader's turn would be, in the shape a tool call has: a
+ * header that names the form and says how many fields it carried, a chevron
+ * that opens it, and the fields as a two-column table underneath. The JSON
+ * the agent reads stays in the turn's text; the reader sees the form they
+ * filled in.
+ *
+ * @module chat/messages/FormSubmissionMessage
+ */
+import type { JSX } from 'react';
+import { type FormSubmission } from './formSubmission';
+export declare function FormSubmissionMessage({ submission, }: {
+    submission: FormSubmission;
+}): JSX.Element;
+export default FormSubmissionMessage;

package/lib/chat/messages/FormSubmissionMessage.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Text } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { ChecklistIcon, ChevronDownIcon, ChevronRightIcon, } from '@primer/octicons-react';
+import { displayValue, labelOfFieldId, } from './formSubmission';
+export function FormSubmissionMessage({ submission, }) {
+    const [expanded, setExpanded] = useState(true);
+    const entries = Object.entries(submission.values);
+    const count = entries.length;
+    return (_jsxs(Box, { sx: {
+            width: '100%',
+            minWidth: 280,
+            border: '1px solid',
+            borderColor: 'border.default',
+            borderRadius: '12px',
+            overflow: 'hidden',
+            backgroundColor: 'canvas.default',
+            color: 'fg.default',
+        }, children: [_jsxs(Box, { as: "button", type: "button", "aria-expanded": expanded, onClick: () => setExpanded(value => !value), sx: {
+                    width: '100%',
+                    display: 'flex',
+                    alignItems: 'center',
+                    gap: 2,
+                    padding: 2,
+                    backgroundColor: 'canvas.subtle',
+                    border: 'none',
+                    borderBottom: expanded ? '1px solid' : 'none',
+                    borderColor: 'border.default',
+                    cursor: 'pointer',
+                    textAlign: 'left',
+                    color: 'fg.default',
+                    '&:hover': { backgroundColor: 'neutral.muted' },
+                }, children: [_jsx(Box, { sx: { color: 'fg.muted', flexShrink: 0 }, children: expanded ? (_jsx(ChevronDownIcon, { size: 16 })) : (_jsx(ChevronRightIcon, { size: 16 })) }), _jsx(Box, { sx: { color: 'fg.muted', flexShrink: 0 }, children: _jsx(ChecklistIcon, { size: 16 }) }), _jsxs(Text, { sx: { fontWeight: 'semibold', fontSize: 1 }, children: ["Submitted ", submission.title] }), _jsxs(Text, { sx: { fontSize: 0, color: 'fg.muted', ml: 'auto' }, children: [count, " field", count === 1 ? '' : 's'] })] }), expanded ? (_jsx(Box, { as: "table", sx: { width: '100%', borderCollapse: 'collapse' }, children: _jsx(Box, { as: "tbody", children: entries.map(([id, value]) => (_jsxs(Box, { as: "tr", sx: {
+                            '& + tr td': {
+                                borderTop: '1px solid',
+                                borderColor: 'border.muted',
+                            },
+                        }, children: [_jsx(Box, { as: "td", sx: {
+                                    px: 3,
+                                    py: 1,
+                                    fontSize: 0,
+                                    color: 'fg.muted',
+                                    whiteSpace: 'nowrap',
+                                    verticalAlign: 'top',
+                                    width: '40%',
+                                }, children: labelOfFieldId(id) }), _jsx(Box, { as: "td", sx: { px: 3, py: 1, fontSize: 1, wordBreak: 'break-word' }, children: displayValue(value) })] }, id))) }) })) : null] }));
+}
+export default FormSubmissionMessage;

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

@@ -0,0 +1,41 @@
+/**
+ * A form submission as a chat turn: written for the agent, drawn for the
+ * reader.
+ *
+ * When a reader submits a surface the agent drew, the values go back to the
+ * agent as the reader's next turn — that is how the confirmation lands in
+ * the conversation. But a turn is text, and the reader was shown that text:
+ * a JSON blob under "here are the values", which is the agent's reading and
+ * nobody else's. So the turn carries the submission in a fenced block of its
+ * own language, `a2ui-submission`. The agent reads the JSON inside it as
+ * before; the transcript recognises the fence and draws a card instead —
+ * the form's name and its fields, the way a tool call is drawn.
+ *
+ * Pure, so the two halves — the sender's writing, the transcript's reading —
+ * are tested together without a chat.
+ *
+ * @module chat/messages/formSubmission
+ */
+/** The fence's language: what marks a turn as a submission. */
+export declare const FORM_SUBMISSION_LANGUAGE = "a2ui-submission";
+export type FormSubmission = {
+    /** The form's title, as the surface named it. */
+    title: string;
+    /** The surface the values came from, when known. */
+    surfaceId?: string;
+    /** The values, by field id. */
+    values: Record<string, unknown>;
+};
+/** The turn to send: a sentence, the fenced submission, the ask. */
+export declare function encodeFormSubmission(submission: FormSubmission): string;
+/** The submission a turn carries, or `null` for any other turn. */
+export declare function parseFormSubmission(text: string): FormSubmission | null;
+/**
+ * A field id as a label: `party-size` → `Party size`.
+ *
+ * The turn carries ids, not labels — the values are keyed by them — and an
+ * id is a readable enough label once its dashes and underscores are spaces.
+ */
+export declare function labelOfFieldId(id: string): string;
+/** A value as a reader would write it; `—` for nothing. */
+export declare function displayValue(value: unknown): string;

package/lib/chat/messages/formSubmission.js

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * A form submission as a chat turn: written for the agent, drawn for the
+ * reader.
+ *
+ * When a reader submits a surface the agent drew, the values go back to the
+ * agent as the reader's next turn — that is how the confirmation lands in
+ * the conversation. But a turn is text, and the reader was shown that text:
+ * a JSON blob under "here are the values", which is the agent's reading and
+ * nobody else's. So the turn carries the submission in a fenced block of its
+ * own language, `a2ui-submission`. The agent reads the JSON inside it as
+ * before; the transcript recognises the fence and draws a card instead —
+ * the form's name and its fields, the way a tool call is drawn.
+ *
+ * Pure, so the two halves — the sender's writing, the transcript's reading —
+ * are tested together without a chat.
+ *
+ * @module chat/messages/formSubmission
+ */
+/** The fence's language: what marks a turn as a submission. */
+export const FORM_SUBMISSION_LANGUAGE = 'a2ui-submission';
+const FENCE = new RegExp('```' + FORM_SUBMISSION_LANGUAGE + '\\s*\\n([\\s\\S]*?)\\n```');
+/** The turn to send: a sentence, the fenced submission, the ask. */
+export function encodeFormSubmission(submission) {
+    const json = JSON.stringify(submission, null, 2);
+    return (`I just submitted "${submission.title}".\n\n` +
+        '```' +
+        FORM_SUBMISSION_LANGUAGE +
+        '\n' +
+        json +
+        '\n```\n\n' +
+        'Please confirm you received it and briefly say what happens next.');
+}
+/** The submission a turn carries, or `null` for any other turn. */
+export function parseFormSubmission(text) {
+    const match = FENCE.exec(text);
+    if (!match) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(match[1]);
+        if (!parsed ||
+            typeof parsed !== 'object' ||
+            typeof parsed.title !== 'string' ||
+            !parsed.values ||
+            typeof parsed.values !== 'object') {
+            return null;
+        }
+        return {
+            title: parsed.title,
+            ...(parsed.surfaceId ? { surfaceId: String(parsed.surfaceId) } : {}),
+            values: parsed.values,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * A field id as a label: `party-size` → `Party size`.
+ *
+ * The turn carries ids, not labels — the values are keyed by them — and an
+ * id is a readable enough label once its dashes and underscores are spaces.
+ */
+export function labelOfFieldId(id) {
+    const words = id.replace(/[-_]+/g, ' ').trim();
+    return words ? words[0].toUpperCase() + words.slice(1) : id;
+}
+/** A value as a reader would write it; `—` for nothing. */
+export function displayValue(value) {
+    if (value === null || value === undefined) {
+        return '—';
+    }
+    if (typeof value === 'string') {
+        return value.trim() === '' ? '—' : value;
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0 ? '—' : value.map(displayValue).join(', ');
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'Yes' : 'No';
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    return JSON.stringify(value);
+}

package/lib/chat/prompt/menus/ModelSelector.js

@@ -13,15 +13,22 @@ import { Box } from '@datalayer/primer-addons';
 import { AiModelIcon } from '@primer/octicons-react';
 export function ModelSelector({ models, selectedModel, onModelSelect, isA2AProtocol, }) {
     const active = models.find(model => model.id === selectedModel);
+    /*
+     * A count, not a name — the same trigger as tools, skills, agents and
+     * suggestions beside it. The name is the longest label on the row and it
+     * changes width as the model changes, which pushed everything beside it
+     * about; the tooltip says which one, and how many there are to choose from.
+     */
+    const summary = isA2AProtocol
+        ? 'set by the agent config'
+        : `${active?.name ?? 'none selected'} · ${models.length} to choose from`;
     return (_jsxs(Box, { sx: {
             display: 'flex',
             flexDirection: 'column',
             alignItems: 'flex-end',
-        }, children: [_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Anchor, { children: _jsx(Tooltip, { text: isA2AProtocol
-                                ? 'This protocol does not take a model override'
-                                : `Model — ${active?.name ?? 'none selected'}`, direction: "n", children: _jsx(Button, { type: "button", variant: "invisible", size: "small", "aria-label": `Model — ${active?.name ?? 'none selected'}`, leadingVisual: AiModelIcon, disabled: isA2AProtocol, sx: isA2AProtocol
+        }, children: [_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Anchor, { children: _jsx(Tooltip, { text: `Model — ${summary}`, direction: "n", children: _jsx(Button, { type: "button", variant: "invisible", size: "small", "aria-label": `Model — ${summary}`, leadingVisual: AiModelIcon, disabled: isA2AProtocol, sx: isA2AProtocol
                                     ? { opacity: 0.5, cursor: 'not-allowed' }
-                                    : undefined }) }) }), _jsx(ActionMenu.Overlay, { side: "outside-top", align: "end", children: _jsx(ActionList, { selectionVariant: "single", children: models.map(modelItem => (_jsxs(ActionList.Item, { selected: selectedModel === modelItem.id, onSelect: () => onModelSelect(modelItem.id), disabled: modelItem.isAvailable === false || isA2AProtocol, sx: modelItem.isAvailable === false
+                                    : undefined, children: _jsx(Text, { sx: { fontSize: 0 }, children: models.length }) }) }) }), _jsx(ActionMenu.Overlay, { side: "outside-top", align: "end", children: _jsx(ActionList, { selectionVariant: "single", children: models.map(modelItem => (_jsxs(ActionList.Item, { selected: selectedModel === modelItem.id, onSelect: () => onModelSelect(modelItem.id), disabled: modelItem.isAvailable === false || isA2AProtocol, sx: modelItem.isAvailable === false
                                     ? { color: 'fg.muted' }
                                     : undefined, children: [modelItem.name, modelItem.isAvailable === false && (_jsx(ActionList.Description, { variant: "block", children: modelItem.unavailableReason ?? 'Missing API key' }))] }, modelItem.id))) }) })] }), isA2AProtocol && (_jsx(Text, { sx: { fontSize: 0, color: 'attention.fg', mt: 1 }, children: "A2A: Model set by agent config" }))] }));
 }

package/lib/chat/styles/streamdownStyles.js

@@ -250,6 +250,46 @@ export const streamdownMarkdownStyles = {
         marginTop: '1em',
         marginBottom: '1em',
     },
+    /*
+     * The controls Streamdown draws over a table, an image and a diagram: copy
+     * and download, and the download's own menu.
+     *
+     * They are plain `<button>`s with Tailwind classes, and Tailwind's preflight
+     * — which we do not load — is what strips a button of its default chrome.
+     * Without it the browser drew them as it draws any button: a grey face and
+     * a bevelled border, in a message whose ground is the theme's. The reset
+     * here is the one the code block's header already has, and the colours are
+     * Primer's, so the row reads as part of the message in either colour mode.
+     */
+    '& [data-streamdown="table-wrapper"] button, & [data-streamdown="image-wrapper"] button, & [data-streamdown="mermaid-block"] button': {
+        background: 'transparent',
+        border: 'none',
+        font: 'inherit',
+        cursor: 'pointer',
+        color: 'fg.muted',
+        borderRadius: '4px',
+        '&:hover': {
+            backgroundColor: 'neutral.muted',
+            color: 'fg.default',
+        },
+        '&:disabled': { cursor: 'not-allowed', opacity: 0.5 },
+    },
+    '& [data-streamdown="table-wrapper"] > .flex': {
+        marginBottom: '4px',
+    },
+    // The download menu, and its rows: the popover's own ground and rule, not
+    // the button reset above.
+    '& [data-streamdown="table-wrapper"] .bg-background, & [data-streamdown="mermaid-block"] .bg-background': {
+        backgroundColor: 'canvas.overlay',
+        borderColor: 'border.default',
+        color: 'fg.default',
+        boxShadow: 'shadow.medium',
+    },
+    '& [data-streamdown="table-wrapper"] .bg-background button, & [data-streamdown="mermaid-block"] .bg-background button': {
+        color: 'fg.default',
+        borderRadius: 0,
+        '&:hover': { backgroundColor: 'neutral.muted' },
+    },
     // Include Tailwind utilities for Streamdown output
     ...tailwindUtilities,
 };

package/lib/client/mixins/RuntimesMixin.js

@@ -246,7 +246,7 @@ export function RuntimesMixin(Base) {
         async checkRuntimesHealth() {
             const startTime = Date.now();
             const errors = [];
-            let status = 'unknown';
+            let status;
             let healthy = false;
             try {
                 // Test basic connectivity by listing environments (lightweight operation)

package/lib/client/mixins/SpacerMixin.js

@@ -244,9 +244,9 @@ export function SpacerMixin(Base) {
                 // If getItem throws (e.g., 404), wrap in descriptive error
                 if (error.message?.includes('404') ||
                     error.message?.includes('not found')) {
-                    throw new Error(`Failed to delete space item '${itemId}': Item not found`);
+                    throw new Error(`Failed to delete space item '${itemId}': Item not found`, { cause: error });
                 }
-                throw new Error(`Failed to delete space item '${itemId}': ${error.message}`);
+                throw new Error(`Failed to delete space item '${itemId}': ${error.message}`, { cause: error });
             }
             // Item exists, proceed with deletion
             const response = await items.deleteItem(token, itemId, spacerUrl);
@@ -291,7 +291,7 @@ export function SpacerMixin(Base) {
         async checkSpacerHealth() {
             const startTime = Date.now();
             const errors = [];
-            let status = 'unknown';
+            let status;
             let healthy = false;
             try {
                 // Test basic connectivity by getting user spaces (lightweight operation)