@datalayer/agent-runtimes 1.3.29 → 1.3.30

package/lib/loop/plugins/app-page/appPage.js

@@ -0,0 +1,443 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The id of the editor surface an application's page is drawn in. */
+export const APP_PAGE_SURFACE = 'app-page';
+/** The id of the A2UI surface itself, inside it. */
+export const APP_PAGE_SURFACE_ID = 'app';
+const APP = {
+    path: '/app',
+    meaning: "The application's name.",
+    words: 'Its name',
+};
+const STATUS = {
+    path: '/status',
+    meaning: 'Where its answer stands, in a word: Ready, Thinking, Answering, Answered or Stopped.',
+    words: 'Where its answer stands',
+};
+const DRAFT = {
+    path: '/draft',
+    meaning: 'A message written on the page, which a Send button sends.',
+    words: 'A message to send',
+};
+const SEND = {
+    name: 'send',
+    meaning: 'Send a message to the application: the context’s message, or what is written at /draft.',
+    words: 'Send the message',
+    context: ['message'],
+    asks: { message: 'The message it sends' },
+};
+const STOP = {
+    name: 'stop',
+    meaning: 'Stop the answer being written.',
+    words: 'Stop the answer',
+    context: [],
+    asks: {},
+};
+/**
+ * What each kind publishes to its page and takes from it, by path — the
+ * least that is real today, read from the conversation it runs as.
+ */
+export const APP_KIND_PATHS = {
+    chat: {
+        publishes: [
+            APP,
+            {
+                path: '/question',
+                meaning: 'The question last asked.',
+                words: 'The question last asked',
+            },
+            {
+                path: '/answer',
+                meaning: 'Its answer to it, as it is written.',
+                words: 'Its answer',
+            },
+            STATUS,
+        ],
+        accepts: [DRAFT],
+        actions: [
+            SEND,
+            STOP,
+            {
+                name: 'new',
+                meaning: 'Start the conversation over.',
+                words: 'Start over',
+                context: [],
+                asks: {},
+            },
+        ],
+        inputs: true,
+    },
+    widget: {
+        publishes: [
+            APP,
+            {
+                path: '/output',
+                meaning: 'What it gave for the inputs last run, as it is written.',
+                words: 'What it gave',
+            },
+            STATUS,
+        ],
+        accepts: [],
+        actions: [
+            {
+                name: 'run',
+                meaning: 'Run it on its inputs: every value written under /inputs is sent, with the context’s message when there is one.',
+                words: 'Run it on its inputs',
+                context: ['message'],
+                asks: { message: 'What it says before the inputs' },
+            },
+            STOP,
+        ],
+        inputs: true,
+    },
+    worker: {
+        publishes: [
+            APP,
+            {
+                path: '/goal',
+                meaning: 'What it works toward.',
+                words: 'What it works toward',
+            },
+            {
+                path: '/activity',
+                meaning: 'What it is doing right now, in a short line, or nothing.',
+                words: 'What it is doing now',
+            },
+            {
+                path: '/report',
+                meaning: 'What it last said, as it is written.',
+                words: 'What it last said',
+            },
+            STATUS,
+        ],
+        accepts: [DRAFT],
+        actions: [SEND, STOP],
+        inputs: false,
+    },
+};
+/** Whether a kind runs as its conversation and has its paths here. */
+export const isAppPageKind = (kind) => Object.prototype.hasOwnProperty.call(APP_KIND_PATHS, kind);
+/** The path a setting, an input of the page, is kept at. */
+export const inputPath = (id) => `/inputs/${id}`;
+/**
+ * What an application publishes and takes, with its own settings: the kind's
+ * list, and for a kind that has inputs each setting at `/inputs/<id>`, both
+ * shown and written. Empty lists for a decision, or a kind not known.
+ */
+export function appKindPaths(app) {
+    if (!isAppPageKind(app.kind)) {
+        return { publishes: [], accepts: [], actions: [], inputs: false };
+    }
+    const kind = APP_KIND_PATHS[app.kind];
+    if (!kind.inputs) {
+        return kind;
+    }
+    const inputs = app.interface.settings.map(setting => ({
+        path: inputPath(setting.id),
+        meaning: `The setting “${setting.label || setting.id}”.`,
+        words: setting.label || setting.id,
+    }));
+    return {
+        ...kind,
+        publishes: [...kind.publishes, ...inputs],
+        accepts: [...kind.accepts, ...inputs],
+    };
+}
+/** The components its surface has, or none. */
+const surfaceComponents = (app) => app.interface.surface?.components ?? [];
+/**
+ * Whether the workspace draws the application's page: a chat, a widget or a
+ * worker whose layout has one (`page`, `split`). A `chat` layout is the
+ * conversation alone: a surface composed for it is not drawn, which
+ * `surfaceUnshown` says in a sentence.
+ */
+export function hasAppPage(app) {
+    if (!app.agent || !isAppPageKind(app.kind)) {
+        return false;
+    }
+    return app.interface.layout !== 'chat';
+}
+/**
+ * Why a composed surface is not drawn, or `null` when it is (or there is
+ * none): the application's layout is `chat`, the conversation alone.
+ */
+export function surfaceUnshown(app) {
+    if (!app.agent ||
+        !isAppPageKind(app.kind) ||
+        app.interface.layout !== 'chat' ||
+        surfaceComponents(app).length === 0) {
+        return null;
+    }
+    return 'Its page is composed but its layout is chat, the conversation alone: choose page or split to show it.';
+}
+const STATUS_WORDS = {
+    idle: 'Ready',
+    thinking: 'Thinking',
+    streaming: 'Answering',
+    done: 'Answered',
+    error: 'Stopped',
+};
+/** A setting's first value, as its input holds it. */
+export function initialInput(setting) {
+    switch (setting.type) {
+        case 'toggle':
+            return Boolean(setting.default ?? false);
+        case 'select':
+            // A ChoicePicker holds a list of the values chosen.
+            return setting.default === undefined ? [] : [String(setting.default)];
+        case 'slider':
+            return Number(setting.default ?? setting.min ?? 0);
+        case 'number':
+            return setting.max === undefined
+                ? String(setting.default ?? '')
+                : Number(setting.default ?? setting.min ?? 0);
+        default:
+            return String(setting.default ?? '');
+    }
+}
+/** What the conversation publishes to the page, by path, now. */
+export function appPageData(app, turn) {
+    const data = {
+        '/app': app.name,
+        '/status': STATUS_WORDS[turn.status] ?? '',
+    };
+    switch (app.kind) {
+        case 'chat':
+            data['/question'] = turn.user ?? '';
+            data['/answer'] = turn.assistant ?? '';
+            break;
+        case 'widget':
+            data['/output'] = turn.assistant ?? '';
+            break;
+        case 'worker':
+            data['/goal'] = app.goal;
+            data['/activity'] = turn.activity ?? '';
+            data['/report'] = turn.assistant ?? '';
+            break;
+        default:
+            break;
+    }
+    return data;
+}
+/** The page's data model when it is drawn: what is published, the inputs, the draft. */
+export function appPageInitialData(app) {
+    const tree = {};
+    for (const [path, value] of Object.entries(appPageData(app, { id: 0, status: 'idle' }))) {
+        tree[path.slice(1)] = value;
+    }
+    const paths = appKindPaths(app);
+    if (paths.inputs) {
+        tree.inputs = Object.fromEntries(app.interface.settings.map(setting => [
+            setting.id,
+            initialInput(setting),
+        ]));
+    }
+    if (paths.accepts.some(entry => entry.path === DRAFT.path)) {
+        tree.draft = '';
+    }
+    return tree;
+}
+/** One input in words: `Plan: Team`; nothing for an empty one. */
+function inputWords(label, value) {
+    const shown = Array.isArray(value)
+        ? value.map(String).join(', ')
+        : typeof value === 'boolean'
+            ? value
+                ? 'yes'
+                : 'no'
+            : value === undefined || value === null
+                ? ''
+                : String(value);
+    return shown.trim() ? `${label}: ${shown}` : '';
+}
+/**
+ * The inputs written on the page, in words, one per line: each setting by
+ * its label, then any other value a block wrote under `/inputs` by its id.
+ */
+export function inputsInWords(app, inputs) {
+    const values = inputs && typeof inputs === 'object'
+        ? inputs
+        : {};
+    const lines = [];
+    const seen = new Set();
+    for (const setting of app.interface.settings) {
+        seen.add(setting.id);
+        lines.push(inputWords(setting.label || setting.id, values[setting.id]));
+    }
+    for (const [id, value] of Object.entries(values)) {
+        if (!seen.has(id)) {
+            lines.push(inputWords(id, value));
+        }
+    }
+    return lines.filter(Boolean).join('\n');
+}
+/**
+ * What a button pressed on the page does.
+ *
+ * `read` gives what is in the surface's data model at a path; `lastInputs`
+ * is the inputs in words as last sent, so that a chat's message carries its
+ * settings only when they changed.
+ */
+export function appPageAction(app, event, read, lastInputs = '') {
+    const paths = appKindPaths(app);
+    if (!paths.actions.some(action => action.name === event.name)) {
+        const offered = paths.actions.map(action => action.name).join(', ');
+        return {
+            refused: offered
+                ? `“${event.name}” is not something ${app.name} does: it does ${offered}.`
+                : `${app.name} handles no button.`,
+        };
+    }
+    const given = event.context?.message;
+    const message = typeof given === 'string' ? given.trim() : '';
+    const inputs = paths.inputs ? inputsInWords(app, read('/inputs')) : '';
+    switch (event.name) {
+        case 'stop':
+            return { stop: true };
+        case 'new':
+            return { newChat: true };
+        case 'run': {
+            const text = [message, inputs].filter(Boolean).join('\n');
+            return text
+                ? { send: text, inputs, clear: [] }
+                : { refused: `${app.name} has no inputs to run on: set one first.` };
+        }
+        default: {
+            const draft = read(DRAFT.path);
+            const written = message || (typeof draft === 'string' ? draft.trim() : '');
+            if (!written) {
+                return { refused: 'Nothing to send: write a message first.' };
+            }
+            const changed = inputs && inputs !== lastInputs;
+            return {
+                send: changed ? `${written}\n\n${inputs}` : written,
+                inputs,
+                clear: message ? [] : [DRAFT.path],
+            };
+        }
+    }
+}
+const text = (id, path, variant) => ({
+    id,
+    component: 'Text',
+    text: { path },
+    ...(variant ? { variant } : {}),
+});
+const button = (id, label, name, primary = false) => [
+    {
+        id,
+        component: 'Button',
+        child: `${id}-label`,
+        ...(primary ? { variant: 'primary' } : {}),
+        action: { event: { name } },
+    },
+    { id: `${id}-label`, component: 'Text', text: label },
+];
+/** A setting as the input of the catalog that holds its value. */
+function settingInput(setting) {
+    const base = {
+        id: `input-${setting.id}`,
+        label: setting.label || setting.id,
+        value: { path: inputPath(setting.id) },
+    };
+    switch (setting.type) {
+        case 'toggle':
+            return { ...base, component: 'CheckBox' };
+        case 'select':
+            return {
+                ...base,
+                component: 'ChoicePicker',
+                options: setting.options.map(option => ({
+                    label: option,
+                    value: option,
+                })),
+            };
+        case 'slider':
+            return {
+                ...base,
+                component: 'Slider',
+                min: setting.min ?? 0,
+                max: setting.max ?? 100,
+            };
+        case 'number':
+            return setting.max === undefined
+                ? { ...base, component: 'TextField', variant: 'number' }
+                : {
+                    ...base,
+                    component: 'Slider',
+                    min: setting.min ?? 0,
+                    max: setting.max,
+                };
+        default:
+            return { ...base, component: 'TextField' };
+    }
+}
+/**
+ * The page drawn when the application has a page layout and no surface
+ * composed: what its kind publishes, its settings as inputs, and the
+ * buttons its kind handles that the conversation does not already give.
+ */
+export function defaultAppSurface(app) {
+    const inputs = appKindPaths(app).inputs
+        ? app.interface.settings.map(settingInput)
+        : [];
+    const body = [];
+    switch (app.kind) {
+        case 'chat':
+            body.push(text('question', '/question', 'h3'), text('answer', '/answer'), text('status', '/status', 'caption'), ...inputs);
+            break;
+        case 'widget':
+            body.push(...inputs, { id: 'actions', component: 'Row', children: ['run', 'stop'] }, ...button('run', 'Run', 'run', true), ...button('stop', 'Stop', 'stop'), text('status', '/status', 'caption'), text('output', '/output'));
+            break;
+        case 'worker':
+            body.push(text('goal', '/goal', 'h3'), text('status', '/status', 'caption'), text('activity', '/activity', 'caption'), text('report', '/report'));
+            break;
+        default:
+            break;
+    }
+    // The root's children: what is not inside a Row or a Button.
+    const inner = new Set(body.flatMap(component => [
+        ...(Array.isArray(component.children) ? component.children : []),
+        component.child,
+    ].filter((id) => typeof id === 'string')));
+    return [
+        {
+            id: 'root',
+            component: 'Column',
+            children: body
+                .map(component => component.id)
+                .filter(id => !inner.has(id)),
+        },
+        ...body,
+    ];
+}
+/**
+ * The A2UI messages that draw the application's page: its surface composed,
+ * or the default page of its kind, fed its first data.
+ */
+export function appPageMessages(app, catalogId) {
+    const composed = surfaceComponents(app);
+    return [
+        {
+            version: 'v0.9',
+            createSurface: { surfaceId: APP_PAGE_SURFACE_ID, catalogId },
+        },
+        {
+            version: 'v0.9',
+            updateComponents: {
+                surfaceId: APP_PAGE_SURFACE_ID,
+                components: composed.length > 0 ? composed : defaultAppSurface(app),
+            },
+        },
+        {
+            version: 'v0.9',
+            updateDataModel: {
+                surfaceId: APP_PAGE_SURFACE_ID,
+                path: '/',
+                value: appPageInitialData(app),
+            },
+        },
+    ];
+}

package/lib/loop/plugins/app-page/index.d.ts

@@ -0,0 +1,8 @@
+import { type ReactorPlugin } from '@datalayer/reactor';
+import type { AppSpec } from '../../../types/agentspecs';
+export declare const APP_PAGE_PLUGIN_NAME = "@datalayer/loop-plugin-app-page";
+/** The plugin that draws an application's page beside its conversation. */
+export declare function defineAppPagePlugin(app: AppSpec): ReactorPlugin<Record<string, never>, unknown, unknown>;
+export { AppPage, type AppPageProps } from './AppPage';
+export * from './appPage';
+export default defineAppPagePlugin;

package/lib/loop/plugins/app-page/index.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BrowserIcon } from '@primer/octicons-react';
+import { contribution, definePlugin, } from '@datalayer/reactor';
+import { LoopEditorView } from '../../core';
+import { AppPage } from './AppPage';
+import { APP_PAGE_SURFACE } from './appPage';
+export const APP_PAGE_PLUGIN_NAME = '@datalayer/loop-plugin-app-page';
+/** The plugin that draws an application's page beside its conversation. */
+export function defineAppPagePlugin(app) {
+    // One component per plugin: the editor keeps it, and the application with it.
+    function Page({ workspace }) {
+        return _jsx(AppPage, { app: app, workspace: workspace });
+    }
+    const plugin = definePlugin({
+        name: `${APP_PAGE_PLUGIN_NAME}-${app.id}`,
+        displayName: `${app.name}: its page`,
+        description: `The page of ${app.name}, drawn beside its conversation.`,
+        octicon: 'browser',
+        emoji: app.emoji || undefined,
+        contributes: [
+            contribution(LoopEditorView, {
+                surfaceId: APP_PAGE_SURFACE,
+                title: app.name,
+                icon: BrowserIcon,
+                order: -10,
+                load: async () => ({ default: Page }),
+            }, { id: APP_PAGE_SURFACE, order: -10 }),
+        ],
+    });
+    return plugin;
+}
+export { AppPage } from './AppPage';
+export * from './appPage';
+export default defineAppPagePlugin;

package/lib/loop/plugins/chat/ChatView.js

@@ -8,13 +8,13 @@ import { computed, signal } from '@datalayer/reactor';
 const NO_STANCE = signal(undefined);
 import { useContributions, useSignalValue, useGate, useReactorPlatform, ReactorLazy, ReactorSlot, useSlotComponents, } from '@datalayer/reactor/react';
 import { ChatBase } from '../../../chat/base/ChatBase';
-import { readServerCatalogue } from '../../../chat/base/modelChoice';
+import { offeredModels as offeredModelsFor, readServerCatalogue, } from '../../../chat/base/modelChoice';
 import { SUGGESTION_CHIP_WIDTH } from '../../../chat/display/EmptyState';
 import { AnonymousKeyExpired } from '@datalayer/core/lib/components/anonymous/AnonymousKeyExpired';
 import { useAnonymousSessionStore } from '../../../runtimes/browser/anonymousToken';
 import { browserProtocolConfig } from '../../../runtimes/browser';
 import { useBrowserInference } from '../../../hooks/useBrowserInference';
-import { getAgentspecs } from '../../../specs/agents';
+import { agentInstructions, inPageAgentRefusal, resolveAgentspec, } from '../../apps/agent';
 import { targetRunsAgentInPage, } from '../agents/switchable';
 import { agentIcon } from '../agents/agentIcons';
 import { specSubagents } from '../agents/specSubagents';
@@ -655,9 +655,23 @@ export default function ChatView({ workspace }) {
      * icon for want of this lookup — it used the document tools and called
      * nobody.
      */
-    const blueprintSpecId = useContributions(LoopAgentBlueprint)[0]?.value.specId;
-    const spec = getAgentspecs(member?.specId ?? agentId) ??
-        (blueprintSpecId ? getAgentspecs(blueprintSpecId) : undefined);
+    const blueprint = useContributions(LoopAgentBlueprint)[0]?.value;
+    const blueprintSpecId = blueprint?.specId;
+    /*
+     * An agent of the catalogue or a Cog's, as a runtime resolves it: an
+     * application on a Cog looked up among the agentspecs alone was turned in
+     * the page with no instructions at all (LOOP H-01).
+     */
+    const spec = resolveAgentspec(member?.specId ?? agentId) ??
+        (blueprintSpecId ? resolveAgentspec(blueprintSpecId) : undefined);
+    /*
+     * The blueprint's words and model — an application's — on top of its
+     * spec's, for the agent it contributes; never for a team's member.
+     */
+    const blueprintTurn = member ? undefined : blueprint;
+    // Turned in the page, an agent that resolves to nothing is refused rather
+    // than run bare.
+    const inPageRefusal = inPage && !member ? inPageAgentRefusal(blueprintSpecId, spec) : undefined;
     /*
      * The team's name for a member first, then the spec's own.
      *
@@ -945,12 +959,12 @@ export default function ChatView({ workspace }) {
      * for something that was never theirs.
      */
     const expiredKeyIsTemporary = !signedInUser;
-    const chatDisabled = gateBlocked || keyExpired;
+    const chatDisabled = gateBlocked || keyExpired || Boolean(inPageRefusal);
     const disabledReason = keyExpired
         ? expiredKeyIsTemporary
             ? 'This demo runs on a shared key, and its time is up. Sign in to keep going.'
             : 'Your key has expired. Sign in to keep going.'
-        : gateReason;
+        : (inPageRefusal ?? gateReason);
     /*
      * The prompt's text, held here rather than inside `InputPrompt`.
      *
@@ -981,7 +995,7 @@ export default function ChatView({ workspace }) {
      * the member being addressed changes.
      */
     const [pickedModel, setPickedModel] = useState();
-    const activeModel = pickedModel ?? spec?.model ?? workspace.model ?? '';
+    const activeModel = pickedModel ?? blueprintTurn?.model ?? spec?.model ?? workspace.model ?? '';
     /*
      * The team, in the shape the footer asks for.
      *
@@ -1071,7 +1085,7 @@ export default function ChatView({ workspace }) {
     const protocol = useMemo(() => inPage
         ? browserProtocolConfig({
             agentId: member?.specId ?? agentId,
-            instructions: spec?.systemPrompt,
+            instructions: agentInstructions(spec, blueprintTurn?.instructions),
             model: activeModel || undefined,
             inference,
             // Who this member may hand work to, and what they are told. Both
@@ -1111,6 +1125,7 @@ export default function ChatView({ workspace }) {
         agentTools,
         team,
         spec,
+        blueprintTurn,
         activeModel,
         agentServerUrl,
     ]);
@@ -1128,7 +1143,8 @@ export default function ChatView({ workspace }) {
     const configQuery = useConfig(!inPage, protocol.type === 'ag-ui' ? protocol.configEndpoint : undefined, undefined, agentId);
     const skillsQuery = useSkills(true);
     const skillActions = useSkillActions(agentId);
-    const [catalogModels, setCatalogModels] = useState([]);
+    // `undefined` until the runtime answers: its answer is then the list.
+    const [catalogModels, setCatalogModels] = useState(undefined);
     useEffect(() => {
         /*
          * Only where there is a server to ask.
@@ -1143,23 +1159,31 @@ export default function ChatView({ workspace }) {
             return undefined;
         }
         let cancelled = false;
-        void fetch(`${agentServerUrl}/api/v1/configure/models`)
-            .then(response => (response.ok ? response.json() : { models: [] }))
+        // The agent's own models (its model and model_additionals), each saying
+        // whether its inference serves it.
+        void fetch(`${agentServerUrl}/api/v1/configure/models?agent_id=${encodeURIComponent(agentId)}`)
+            .then(response => (response.ok ? response.json() : null))
             .then(payload => {
             if (!cancelled) {
                 // In the chat's shape: the route says `available`, the menu and
                 // the opening pick read `isAvailable`, and an unmapped row passes
                 // for usable. See `readServerCatalogue`.
-                setCatalogModels(readServerCatalogue(payload));
+                // A runtime that did not answer offers nothing: the agentspecs
+                // catalogue is not its answer.
+                setCatalogModels(payload ? readServerCatalogue(payload) : []);
             }
         })
             // No catalogue is not an error worth a banner: the menu simply has
             // nothing to offer, and the agent answers on whatever it was given.
-            .catch(() => undefined);
+            .catch(() => {
+            if (!cancelled) {
+                setCatalogModels([]);
+            }
+        });
         return () => {
             cancelled = true;
         };
-    }, [agentServerUrl, inPage]);
+    }, [agentServerUrl, agentId, inPage]);
     /*
      * What to offer when the server has no catalogue of its own.
      *
@@ -1168,16 +1192,14 @@ export default function ChatView({ workspace }) {
      * with nothing in it is a control that opens onto an empty list — so the
      * agentspecs catalogue stands in, filtered to the models marked available.
      */
-    const offeredModels = useMemo(() => catalogModels.length > 0
-        ? catalogModels
-        : Object.values(AI_MODEL_CATALOGUE)
-            // A typed-judgment model answers typed questions, not a chat.
-            .filter(model => model.available && isChatModel(model))
-            .map(model => ({
-            id: model.id,
-            name: model.name,
-            provider: model.provider,
-        })), [catalogModels]);
+    const offeredModels = useMemo(() => offeredModelsFor(catalogModels, () => Object.values(AI_MODEL_CATALOGUE)
+        // A typed-judgment model answers typed questions, not a chat.
+        .filter(model => model.available && isChatModel(model))
+        .map(model => ({
+        id: model.id,
+        name: model.name,
+        provider: model.provider,
+    }))), [catalogModels]);
     /*
      * The tools the agent can call, from both sides.
      *

package/lib/loop/plugins/page-layout/SplitLayout.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The split: the conversation and the work side by side, one hairline
+ * between them that a person drags (LOOP T-07, an Appspec's `layout: split`).
+ *
+ * The page layout's other arrangement. Where `page` puts the work on a sheet
+ * and the conversation in a panel that opens when wanted, `split` keeps both
+ * on screen: the conversation on the left — its transcript with the composer
+ * under it — and the work on the right, the way the reference screens show a
+ * mail, a document or the agent's computer beside the chat.
+ *
+ * The hairline is a separator a person can move with the pointer or the
+ * keyboard (arrows by a step, Home and End to the bounds); the share it
+ * leaves the conversation is kept while the workspace is mounted.
+ *
+ * @module loop/plugins/page-layout/SplitLayout
+ */
+import type { JSX } from 'react';
+import type { ChatLayoutParts } from '../../core';
+/** The conversation's share of the width when the split opens. */
+export declare const SPLIT_DEFAULT_SHARE = 0.4;
+/** The narrowest and widest the conversation may be made. */
+export declare const SPLIT_MIN_SHARE = 0.2;
+export declare const SPLIT_MAX_SHARE = 0.8;
+/** How far an arrow key moves the hairline. */
+export declare const SPLIT_KEY_STEP = 0.05;
+/** A share, held within the bounds. */
+export declare function clampSplitShare(share: number): number;
+/** Where a key moves the hairline, or `null` for a key it ignores. */
+export declare function splitShareForKey(share: number, key: string): number | null;
+export declare function SplitLayout({ editors, hasEditor, transcript, prompt, chips, picker, transient, }: ChatLayoutParts): JSX.Element;
+export default SplitLayout;