@datalayer/agent-runtimes 1.3.10 → 1.3.13

package/lib/chat/header/ChatViewModeToggle.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Tooltip } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { CommentDiscussionIcon, DeviceMobileIcon, GrabberIcon, SidebarExpandIcon, } from '@primer/octicons-react';
+import { CHAT_VIEW_MODES, SIDEBAR_NEEDS_MOUNT_POINT } from '../viewModes';
+/** The drawing of each mode. */
+export const VIEW_MODE_ICONS = {
+    floating: CommentDiscussionIcon,
+    'floating-small': DeviceMobileIcon,
+    'floating-draggable': GrabberIcon,
+    sidebar: SidebarExpandIcon,
+};
+export function ChatViewModeToggle({ value, onChange, disabledModes = [], tooltipDirection = 'n', }) {
+    return (_jsx(Box, { role: "group", "aria-label": "Display mode", "data-chat-view-mode-toggle": "", sx: {
+            display: 'inline-flex',
+            alignItems: 'center',
+            bg: 'neutral.muted',
+            borderRadius: '6px',
+            p: '2px',
+            gap: '1px',
+        }, children: CHAT_VIEW_MODES.map(({ mode, label }) => {
+            const ModeIcon = VIEW_MODE_ICONS[mode];
+            const selected = value === mode;
+            /* Greyed rather than left out: the person sees the mode exists, and
+               that this page has no place for it. */
+            const disabled = disabledModes.includes(mode);
+            return (_jsx(Tooltip, { text: disabled && mode === 'sidebar'
+                    ? `${label} — ${SIDEBAR_NEEDS_MOUNT_POINT}`
+                    : label, direction: tooltipDirection, children: _jsx(Box, { as: "button", type: "button", "aria-label": label, "aria-pressed": selected, "aria-disabled": disabled || undefined, onClick: () => {
+                        if (!disabled) {
+                            onChange(mode);
+                        }
+                    }, sx: {
+                        display: 'inline-flex',
+                        alignItems: 'center',
+                        justifyContent: 'center',
+                        width: 26,
+                        height: 24,
+                        borderRadius: '4px',
+                        border: 'none',
+                        cursor: disabled ? 'not-allowed' : 'pointer',
+                        opacity: disabled ? 0.45 : 1,
+                        bg: selected ? 'canvas.default' : 'transparent',
+                        boxShadow: selected ? 'shadow.small' : 'none',
+                        color: selected ? 'fg.default' : 'fg.muted',
+                        transition: 'all 0.15s ease',
+                        '&:hover': disabled
+                            ? {}
+                            : {
+                                color: 'fg.default',
+                                bg: selected ? 'canvas.default' : 'neutral.subtle',
+                            },
+                    }, children: _jsx(ModeIcon, { size: 14 }) }) }, mode));
+        }) }));
+}

package/lib/chat/index.d.ts

@@ -59,6 +59,7 @@ export { McpStatusIndicator, type McpStatusIndicatorProps, type McpServerStatus,
 export { PoweredByTag, type PoweredByTagProps } from './display/PoweredByTag';
 export { FloatingBrandButton, type FloatingBrandButtonProps, } from './display/FloatingBrandButton';
 export { ChatHeader, type ChatHeaderProps } from './header/ChatHeader';
+export { ChatViewModeToggle, VIEW_MODE_ICONS, type ChatViewModeToggleProps, } from './header/ChatViewModeToggle';
 export { MessagePart, type MessagePartProps, TextPart, type TextPartProps, ReasoningPart, type ReasoningPartProps, ToolPart, type ToolPartProps, DynamicToolPart, type DynamicToolPartProps, } from './parts';
 export { ToolCallDisplay, type ToolCallDisplayProps } from './tools';
 export { ToolApprovalDialog, useToolApprovalDialog, type ToolApprovalDialogProps, } from './tools/ToolApprovalDialog';

package/lib/chat/index.js

@@ -68,6 +68,7 @@ export { McpStatusIndicator, SandboxStatusIndicator, } from './indicators';
 export { PoweredByTag } from './display/PoweredByTag';
 export { FloatingBrandButton, } from './display/FloatingBrandButton';
 export { ChatHeader } from './header/ChatHeader';
+export { ChatViewModeToggle, VIEW_MODE_ICONS, } from './header/ChatViewModeToggle';
 // Components - Message part renderers
 export { MessagePart, TextPart, ReasoningPart, ToolPart, DynamicToolPart, } from './parts';
 // Components - Tool UI

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)

package/lib/components/a2ui/A2uiMarkdownProvider.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+/**
+ * Provides the A2UI v0.9 markdown renderer to every `A2uiSurface` beneath
+ * it. Without it, `Text` components fall back to the raw markdown string
+ * (`## Title` instead of a rendered heading).
+ *
+ * In the library rather than the examples: the loop's own surface plugin
+ * draws surfaces, and needs the same context the examples had.
+ */
+export declare const A2uiMarkdownProvider: React.FC<React.PropsWithChildren>;
+export default A2uiMarkdownProvider;

package/lib/components/a2ui/A2uiMarkdownProvider.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { MarkdownContext } from '@a2ui/react/v0_9';
+import { renderMarkdown } from '@a2ui/markdown-it';
+/**
+ * Provides the A2UI v0.9 markdown renderer to every `A2uiSurface` beneath
+ * it. Without it, `Text` components fall back to the raw markdown string
+ * (`## Title` instead of a rendered heading).
+ *
+ * In the library rather than the examples: the loop's own surface plugin
+ * draws surfaces, and needs the same context the examples had.
+ */
+export const A2uiMarkdownProvider = ({ children, }) => (_jsx(MarkdownContext.Provider, { value: renderMarkdown, children: children }));
+export default A2uiMarkdownProvider;

package/lib/components/a2ui/index.d.ts

@@ -1,2 +1,3 @@
+export * from './A2uiMarkdownProvider';
 export * from './A2uiSurfaceComposed';
 export * from './styles';

package/lib/components/a2ui/index.js

@@ -2,5 +2,6 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
+export * from './A2uiMarkdownProvider';
 export * from './A2uiSurfaceComposed';
 export * from './styles';

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

@@ -62,6 +62,14 @@ export interface ICodeSandboxLauncherProps {
      * Optional submit button label override.
      */
     submitLabel?: string;
+    /**
+     * A published environment to offer and select: the version uid of its
+     * publication, as the Library page that sent the reader here names it.
+     * Nobody's listing holds another account's environment, so it is read from
+     * the publication, offered under *Library* and priced by the rate the
+     * publication carries (D-12, E2-19).
+     */
+    libraryVersionUid?: string;
 }
 /**
  * The launcher of a new code sandbox.

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

@@ -10,7 +10,8 @@ import { NO_RUNTIME_AVAILABLE_LABEL } from '@datalayer/core/lib/i18n';
 import { isCodeSandboxProviderAvailable } from './codeSandboxProviders';
 import { CodeSandboxVariant, codeSandboxVariantOf, codeSandboxVariantTitle, } from '../../models/CodeSandboxVariant';
 import { CodeSandboxEnvironmentSelect, } from './CodeSandboxEnvironmentSelect';
-import { codeSandboxEnvironmentOptions, codeSandboxEnvironmentVersion, firstLaunchableCodeSandboxEnvironment, } from './codeSandboxEnvironments';
+import { codeSandboxEnvironmentOptions, codeSandboxEnvironmentVersion, firstLaunchableCodeSandboxEnvironment, libraryEnvironmentOf, } from './codeSandboxEnvironments';
+import { getEnvironmentPublication } from '../../api/runtimes/environments';
 import { getCodeSandboxGivenName, listCodeSandboxGivenNames, nextCodeSandboxGivenName, setCodeSandboxGivenName, } from './CodeSandboxNames';
 import { iamStore, runtimesStore, useCoreStore, useIAMStore, } from '../../state/substates';
 import { createRuntime as createRuntimeRecord } from '../../runtimes/actions';
@@ -42,7 +43,7 @@ const NOT_AVAILABLE_RETRIES = 5;
  * The launcher of a new code sandbox.
  */
 export function CodeSandboxLauncher(props) {
-    const { dialogTitle, kernelSnapshot, manager, onSubmit, markdownParser, sanitizer, upgradeSubscription, usageRoute = '/plans', submitLabel, startRuntime = true, } = props;
+    const { dialogTitle, kernelSnapshot, manager, onSubmit, markdownParser, sanitizer, upgradeSubscription, usageRoute = '/plans', submitLabel, startRuntime = true, libraryVersionUid, } = props;
     const hasExample = startRuntime === 'with-example';
     const shouldStartRuntime = startRuntime !== 'defer';
     const user = iamStore.getState().user;
@@ -56,7 +57,45 @@ export function CodeSandboxLauncher(props) {
      * below.
      */
     const jupyterAvailable = isCodeSandboxProviderAvailable('local', runtimesStore.getState().multiServiceManager);
-    const environments = manager.environments.get();
+    const listed = manager.environments.get();
+    /*
+     * A publication somebody else owns, which no listing of the viewer's holds
+     * (D-12, E2-19): read by its version uid, offered under *Library* beside
+     * the rest, priced by the rate the publication carries, and selected below,
+     * since it is what the reader came here to launch.
+     */
+    const [libraryEntry, setLibraryEntry] = useState();
+    const [libraryRefusal, setLibraryRefusal] = useState('');
+    useEffect(() => {
+        if (!libraryVersionUid) {
+            return undefined;
+        }
+        let current = true;
+        getEnvironmentPublication(iamStore.getState().token ?? '', libraryVersionUid, {}, runtimesStore.getState().runtimesUrl)
+            .then(publication => {
+            if (!current) {
+                return;
+            }
+            const entry = libraryEnvironmentOf(publication);
+            if (entry) {
+                setLibraryEntry(entry);
+            }
+            else {
+                setLibraryRefusal('This environment is no longer published, so it cannot be launched from the Library.');
+            }
+        })
+            .catch(() => {
+            if (current) {
+                setLibraryRefusal('This published environment could not be read, so it cannot be launched from here.');
+            }
+        });
+        return () => {
+            current = false;
+        };
+    }, [libraryVersionUid]);
+    const environments = useMemo(() => libraryEntry && !listed.some(entry => entry.name === libraryEntry.name)
+        ? [...listed, libraryEntry]
+        : listed, [listed, libraryEntry]);
     /*
      * The sandboxes of this Jupyter Server, offered beside those of the platform.
      *
@@ -168,6 +207,17 @@ export function CodeSandboxLauncher(props) {
     const [runtimeName, setRuntimeName] = useState(() => givenNameFor(firstLaunchableCodeSandboxEnvironment(environments)));
     // Whether the runtim name has been changed by the user or not
     const [hasCustomRuntimeName, setHasCustomRuntimeName] = useState(false);
+    // The publication the reader came to launch, selected once it is read.
+    useEffect(() => {
+        if (!libraryEntry) {
+            return;
+        }
+        setSelection(libraryEntry.name);
+        if (!hasCustomRuntimeName) {
+            setRuntimeName(givenNameFor(libraryEntry));
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [libraryEntry]);
     const [homeFolder, setHomeFolder] = useState(false);
     const [openExample, setOpenExample] = useState(false);
     const [waitingForRuntime, setWaitingForRuntime] = useState(false);
@@ -294,7 +344,6 @@ export function CodeSandboxLauncher(props) {
                 }
             }
             else if (shouldStartRuntime) {
-                success = false;
                 let availableTrial = 1;
                 let retryDelay = NOT_AVAILABLE_INIT_RETRY;
                 // Should return success status.
@@ -437,7 +486,7 @@ export function CodeSandboxLauncher(props) {
                     event.preventDefault();
                     handleSubmitRuntime();
                 }
-            }, children: [_jsxs(FormControl, { disabled: !!kernelSnapshot?.environment || environments.length === 0, children: [_jsx(FormControl.Label, { children: "Environment" }), _jsx(CodeSandboxEnvironmentSelect, { disabled: !!kernelSnapshot?.environment || environments.length === 0, options: environmentOptions, selectedKey: selection, onSelect: handleSelectionChange }), _jsx(FormControl.Caption, { children: _jsx(_Fragment, { children: markdownParser ? (_jsx(Box, { sx: { img: { maxWidth: '100%' } }, children: _jsx(Markdown, { text: description, markdownParser: markdownParser, sanitizer: sanitizer }) })) : sanitizer ? (
+            }, children: [libraryRefusal ? (_jsx(Text, { as: "p", sx: { color: 'attention.fg' }, "data-testid": "library-refusal", children: libraryRefusal })) : null, _jsxs(FormControl, { disabled: !!kernelSnapshot?.environment || environments.length === 0, children: [_jsx(FormControl.Label, { children: "Environment" }), _jsx(CodeSandboxEnvironmentSelect, { disabled: !!kernelSnapshot?.environment || environments.length === 0, options: environmentOptions, selectedKey: selection, onSelect: handleSelectionChange }), _jsx(FormControl.Caption, { children: _jsx(_Fragment, { children: markdownParser ? (_jsx(Box, { sx: { img: { maxWidth: '100%' } }, children: _jsx(Markdown, { text: description, markdownParser: markdownParser, sanitizer: sanitizer }) })) : sanitizer ? (
                                 // The description of an environment carries markup. With no
                                 // parser to render it, the sanitizer of the application is
                                 // enough to show it as what it is rather than as its tags.

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

@@ -14,7 +14,7 @@
  *
  * @module components/code-sandboxes/codeSandboxEnvironments
  */
-import type { IDatalayerEnvironment } from '../../models';
+import type { IDatalayerEnvironment, IEnvironmentPublicationRecord } from '../../models';
 import type { ICodeSandboxEnvironmentOption } from './CodeSandboxEnvironmentSelect';
 /**
  * The variant a sandbox of THIS platform starts on.
@@ -84,3 +84,14 @@ export declare function codeSandboxEnvironmentOption(environment: IDatalayerEnvi
 export declare function codeSandboxEnvironmentOptions(environments: readonly IDatalayerEnvironment[], viewer?: ICodeSandboxEnvironmentViewer, decorate?: (environment: IDatalayerEnvironment) => Partial<ICodeSandboxEnvironmentOption>): ICodeSandboxEnvironmentOption[];
 /** The first entry a launcher may open on: never one that cannot be launched. */
 export declare function firstLaunchableCodeSandboxEnvironment(environments: readonly IDatalayerEnvironment[]): IDatalayerEnvironment | undefined;
+/**
+ * A publication, as the picker offers it to somebody who does not own it
+ * (D-12, E2-19).
+ *
+ * Nobody's listing holds another account's environment, so a reader who came
+ * from its Library page is offered it from the publication itself: launched by
+ * its environment uid and the version the publication froze, listed under
+ * *Library*, and priced by the rate the publication carries. `undefined` for a
+ * publication that has been withdrawn, which is no longer anyone's to launch.
+ */
+export declare function libraryEnvironmentOf(publication: IEnvironmentPublicationRecord): IDatalayerEnvironment | undefined;