@datalayer/agent-runtimes 1.3.80 → 1.3.82

package/lib/loop/embed/embedSession.d.ts

@@ -0,0 +1,79 @@
+/**
+ * An embedded application's conversation, picked up again after the host's
+ * page reloads (LOOP D-13).
+ *
+ * The session an embed opened is kept by its uid in the host page's own
+ * storage, under the application and the visit its embed token names —
+ * the host's server issues the reloaded page a token for the same visit.
+ * After the reload, the session is asked for its conversation on the
+ * agent-runtimes server that holds it, with that token, and the chat draws
+ * it again and goes on with it. A session that is gone, or refused, is
+ * forgotten and said once; a new one starts.
+ *
+ * Kept in memory as well, for as long as the page lives: a token renewed
+ * for the visit redraws the application, which goes on with its session
+ * even when the host keeps nothing (`resume="false"`).
+ *
+ * Pure but for the storage and the request, each given or guarded: the page
+ * works without storage.
+ *
+ * @module loop/embed/embedSession
+ */
+import type { ChatMessage } from '../../types/messages';
+/** Where a visit's session is kept in the host's storage: `<prefix>:<app>:<visit>`. */
+export declare const EMBED_SESSION_KEY_PREFIX = "datalayer-app:session";
+/**
+ * The visit an embed token was issued for: its `visit` claim, read without
+ * checking the signature — the runtime checks the token; the page only
+ * needs the name to keep the session under.
+ */
+export declare function visitOfToken(token: string | undefined): string | undefined;
+/** The key a visit's session is kept under. */
+export declare function embedSessionKey(app: string, visit: string): string;
+/** What keeps a visit's session uid. */
+export type SessionKeeper = {
+    read: (key: string) => string | undefined;
+    keep: (key: string, uid: string) => void;
+    forget: (key: string) => void;
+};
+/**
+ * The keeper of a visit's session: in memory, and — unless the host opted
+ * out — in its storage too, read first. Every access to the storage is
+ * guarded: a page whose storage is blocked, full or absent keeps the
+ * session in memory and resumes nothing after a reload.
+ */
+export declare function sessionKeeper({ persist, storage, }: {
+    persist: boolean;
+    storage?: () => Storage | undefined;
+}): SessionKeeper;
+/** Forget what this page holds in memory (a test). */
+export declare function forgetSessionsInMemory(): void;
+/**
+ * A session's conversation as the chat draws it, from the AG-UI messages
+ * the runtime says (`GET …/sessions/{uid}/messages`): what was said and
+ * answered, in words. A page an answer drew is not drawn again here.
+ */
+export declare function messagesOfThread(messages: unknown): ChatMessage[];
+/** What asking for a kept session found. */
+export type Reattached = {
+    kind: 'resumed';
+    uid: string;
+    messages: ChatMessage[];
+} | {
+    kind: 'gone';
+    uid: string;
+};
+/**
+ * Ask the server that runs the application for a session's conversation,
+ * with the visit's token. Anything but an answer — a session the runtime
+ * let go, another visit's, a token refused, a server out of reach — is
+ * `gone`: a new session starts.
+ */
+export declare function reattachSession({ serverUrl, uid, token, fetcher, }: {
+    serverUrl: string;
+    uid: string;
+    token: string;
+    fetcher?: typeof fetch;
+}): Promise<Reattached>;
+/** What the page says, once, when the conversation it kept is gone. */
+export declare const sessionGoneSentence: (name: string) => string;

package/lib/loop/embed/embedSession.js

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** Where a visit's session is kept in the host's storage: `<prefix>:<app>:<visit>`. */
+export const EMBED_SESSION_KEY_PREFIX = 'datalayer-app:session';
+/**
+ * The visit an embed token was issued for: its `visit` claim, read without
+ * checking the signature — the runtime checks the token; the page only
+ * needs the name to keep the session under.
+ */
+export function visitOfToken(token) {
+    const payload = token?.split('.')[1];
+    if (!payload) {
+        return undefined;
+    }
+    try {
+        const base64 = payload.replace(/-/g, '+').replace(/_/g, '/');
+        const padded = base64 + '='.repeat((4 - (base64.length % 4)) % 4);
+        const claims = JSON.parse(atob(padded));
+        return typeof claims.visit === 'string' && claims.visit
+            ? claims.visit
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The key a visit's session is kept under. */
+export function embedSessionKey(app, visit) {
+    return `${EMBED_SESSION_KEY_PREFIX}:${app}:${visit}`;
+}
+/** The sessions of this page, while it lives. */
+const IN_MEMORY = new Map();
+/** The host's `localStorage`, when there is one the page may use. */
+function hostStorage() {
+    try {
+        return typeof window !== 'undefined' ? window.localStorage : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The keeper of a visit's session: in memory, and — unless the host opted
+ * out — in its storage too, read first. Every access to the storage is
+ * guarded: a page whose storage is blocked, full or absent keeps the
+ * session in memory and resumes nothing after a reload.
+ */
+export function sessionKeeper({ persist, storage = hostStorage, }) {
+    return {
+        read: key => {
+            if (persist) {
+                try {
+                    const kept = storage()?.getItem(key);
+                    if (kept) {
+                        return kept;
+                    }
+                }
+                catch {
+                    // No storage: what the page holds in memory.
+                }
+            }
+            return IN_MEMORY.get(key);
+        },
+        keep: (key, uid) => {
+            IN_MEMORY.set(key, uid);
+            if (persist) {
+                try {
+                    storage()?.setItem(key, uid);
+                }
+                catch {
+                    // Kept in memory only.
+                }
+            }
+        },
+        forget: key => {
+            IN_MEMORY.delete(key);
+            try {
+                storage()?.removeItem(key);
+            }
+            catch {
+                // Nothing kept there to forget.
+            }
+        },
+    };
+}
+/** Forget what this page holds in memory (a test). */
+export function forgetSessionsInMemory() {
+    IN_MEMORY.clear();
+}
+/**
+ * A session's conversation as the chat draws it, from the AG-UI messages
+ * the runtime says (`GET …/sessions/{uid}/messages`): what was said and
+ * answered, in words. A page an answer drew is not drawn again here.
+ */
+export function messagesOfThread(messages) {
+    if (!Array.isArray(messages)) {
+        return [];
+    }
+    const drawn = [];
+    for (const message of messages) {
+        if (!message || typeof message !== 'object') {
+            continue;
+        }
+        const { id, role, content } = message;
+        if ((role === 'user' || role === 'assistant') &&
+            typeof id === 'string' &&
+            typeof content === 'string' &&
+            content.trim()) {
+            drawn.push({ id, role, content, createdAt: new Date() });
+        }
+    }
+    return drawn;
+}
+/**
+ * Ask the server that runs the application for a session's conversation,
+ * with the visit's token. Anything but an answer — a session the runtime
+ * let go, another visit's, a token refused, a server out of reach — is
+ * `gone`: a new session starts.
+ */
+export async function reattachSession({ serverUrl, uid, token, fetcher = fetch, }) {
+    try {
+        const response = await fetcher(`${serverUrl.replace(/\/+$/, '')}/api/v1/apps/sessions/${encodeURIComponent(uid)}/messages`, { headers: { Authorization: `Bearer ${token}` } });
+        if (!response.ok) {
+            return { kind: 'gone', uid };
+        }
+        const body = (await response.json());
+        return { kind: 'resumed', uid, messages: messagesOfThread(body.messages) };
+    }
+    catch {
+        return { kind: 'gone', uid };
+    }
+}
+/** What the page says, once, when the conversation it kept is gone. */
+export const sessionGoneSentence = (name) => `Your earlier conversation with ${name} has ended, so this is a new one.`;

package/lib/loop/embed/embedTheme.d.ts

@@ -1,24 +1,27 @@
 import { type ThemeStyles } from '@datalayer/primer-addons';
-import type { AppAccent } from '../../types/agentspecs';
+import type { AppAccent, AppThemeVariant } from '../../types/agentspecs';
 import type { ThemeOverrides } from '../../types/chat';
 /**
- * The `loop` theme as the embed wears it: the application's accent over it
- * in both modes (T-05), and the host's face when it named one.
+ * The theme as the embed wears it — `loop`, or the one the application
+ * names (T-30) — with the application's accent over `loop` in both modes
+ * (T-05), and the host's face when it named one.
  */
-export declare function embedThemeStyles({ accent, font, }: {
+export declare function embedThemeStyles({ accent, font, variant, }: {
     accent: AppAccent;
     font?: string;
+    variant?: AppThemeVariant;
 }): ThemeStyles;
 /**
  * The same accent and face laid over the conversation's own theme (T-05,
- * D-11): the chat sets the `loop` theme again inside it, which would put the
- * theme's mint and face back over what the embed set around it. The
- * accent's properties in each mode, and, when the host named a face, every
- * property of the theme that names its own.
+ * D-11): the chat sets its theme again inside it, which would put the
+ * theme's colours and face back over what the embed set around it. The
+ * accent's properties in each mode (over `loop` only), and, when the host
+ * named a face, every property of the theme that names its own.
  */
-export declare function embedThemeOverrides({ accent, font, }: {
+export declare function embedThemeOverrides({ accent, font, variant, }: {
     accent: AppAccent;
     font?: string;
+    variant?: AppThemeVariant;
 }): ThemeOverrides;
 /**
  * The element's own stylesheet, written into its shadow root.

package/lib/loop/embed/embedTheme.js

@@ -2,46 +2,56 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { loopAccentStyles, loopFontFamily, loopThemeStyles, scopeThemeCss, THEME_SCOPE_ATTRIBUTE, } from '@datalayer/primer-addons';
+import { getThemeConfig, loopAccentStyles, loopFontFamily, scopeThemeCss, THEME_SCOPE_ATTRIBUTE, } from '@datalayer/primer-addons';
 /** One mode's properties, with the theme's face replaced by the host's. */
-function withFace(styles, font) {
-    if (!font) {
+function withFace(styles, font, own) {
+    if (!font || !own) {
         return styles;
     }
     return Object.fromEntries(Object.entries(styles).map(([name, value]) => [
         name,
-        typeof value === 'string'
-            ? value.split(loopFontFamily).join(font)
-            : value,
+        typeof value === 'string' ? value.split(own).join(font) : value,
     ]));
 }
+/** The face a theme names in a mode: `loop`'s own, or the theme's `fontFamily`. */
+function faceOf(variant, styles) {
+    if (variant === 'loop') {
+        return loopFontFamily;
+    }
+    return typeof styles.fontFamily === 'string' ? styles.fontFamily : '';
+}
+/** The accent over a theme: `loop`'s colours, over `loop` only (T-30). */
+const accentOver = (variant, accent, which) => variant === 'loop' ? loopAccentStyles(accent, which) : {};
 /**
- * The `loop` theme as the embed wears it: the application's accent over it
- * in both modes (T-05), and the host's face when it named one.
+ * The theme as the embed wears it — `loop`, or the one the application
+ * names (T-30) — with the application's accent over `loop` in both modes
+ * (T-05), and the host's face when it named one.
  */
-export function embedThemeStyles({ accent, font = '', }) {
-    const mode = (which) => withFace({
-        ...loopThemeStyles[which],
-        ...loopAccentStyles(accent, which),
-    }, font);
+export function embedThemeStyles({ accent, font = '', variant = 'loop', }) {
+    const base = getThemeConfig(variant).themeStyles;
+    const mode = (which) => {
+        const theme = base[which];
+        return withFace({ ...theme, ...accentOver(variant, accent, which) }, font, faceOf(variant, theme));
+    };
     return {
-        ...loopThemeStyles,
+        ...base,
         light: mode('light'),
         dark: mode('dark'),
     };
 }
 /**
  * The same accent and face laid over the conversation's own theme (T-05,
- * D-11): the chat sets the `loop` theme again inside it, which would put the
- * theme's mint and face back over what the embed set around it. The
- * accent's properties in each mode, and, when the host named a face, every
- * property of the theme that names its own.
+ * D-11): the chat sets its theme again inside it, which would put the
+ * theme's colours and face back over what the embed set around it. The
+ * accent's properties in each mode (over `loop` only), and, when the host
+ * named a face, every property of the theme that names its own.
  */
-export function embedThemeOverrides({ accent, font = '', }) {
+export function embedThemeOverrides({ accent, font = '', variant = 'loop', }) {
+    const base = getThemeConfig(variant).themeStyles;
     const mode = (which) => {
-        const theme = loopThemeStyles[which];
-        const faced = Object.fromEntries(Object.entries(withFace(theme, font)).filter(([name, value]) => typeof value === 'string' && value !== theme[name]));
-        return { ...faced, ...loopAccentStyles(accent, which) };
+        const theme = base[which];
+        const faced = Object.fromEntries(Object.entries(withFace(theme, font, faceOf(variant, theme))).filter(([name, value]) => typeof value === 'string' && value !== theme[name]));
+        return { ...faced, ...accentOver(variant, accent, which) };
     };
     return { light: mode('light'), dark: mode('dark') };
 }

package/lib/loop/embed/hostBridge.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The host page and an embedded application, talking (LOOP D-10).
+ *
+ * In: the values the page passes — `user`, `page`, or names of its own —
+ * read by the application's agent with the tool `host_context`, only those
+ * its Appspec names (`deployment.embedded.host.context`).
+ *
+ * Out: what the application does, as events — `message` when it has said
+ * something, `action` when it called a function of the page — beside the
+ * `decision` and `token-expired` the element raises already.
+ *
+ * Offered: the functions of the page its Appspec names
+ * (`deployment.embedded.host.functions`), each called by its agent as the
+ * tool `host_<name>`. Every one of these tools is decided in the page by
+ * the rule that names it (`behaviourFor`), before the page is called: one no
+ * rule names, or *leave it to me*, is refused; *ask me first* and *do it if
+ * I asked* ask the person on the page (`ask`, else the browser's `confirm`),
+ * and a call they do not allow is refused; *do it* is done.
+ *
+ * Pure: the tools call the page, and ask, through what they are given.
+ *
+ * @module loop/embed/hostBridge
+ */
+import type { AppSpec } from '../../types/agentspecs';
+import type { FrontendToolDefinition } from '../../types/tools';
+import { HOST_CONTEXT_TOOL, HOST_NAME, hostTool, hostToolsOf } from '../apps/hostTools';
+export { HOST_CONTEXT_TOOL, HOST_NAME, hostTool, hostToolsOf };
+/** What the application tells the page it sits in. */
+export type HostEvent = {
+    type: 'message';
+    /** What it said, as written. */
+    detail: {
+        id: string;
+        text: string;
+    };
+} | {
+    type: 'action';
+    /** A function of the page it called, with what came back or why not. */
+    detail: {
+        function: string;
+        arguments: Record<string, unknown>;
+        result?: unknown;
+        error?: string;
+    };
+};
+/** A function of the page, as the page gives it. */
+export type HostFunction = (args: Record<string, unknown>) => unknown | Promise<unknown>;
+/** What the page gives an embedded application (LOOP D-10). */
+export type AppEmbedHost = {
+    /** What the page passes now: its visitor (`user`), itself (`page`), values of its own. */
+    context?: () => Record<string, unknown>;
+    /** The page's functions, by the names the Appspec gives them. */
+    functions?: Record<string, HostFunction>;
+    /** Told what the application does: `message`, `action`. */
+    onEvent?: (event: HostEvent) => void;
+    /**
+     * Asks the person on the page whether a call its rule says to ask first
+     * may be made; the browser's `confirm` when the page gives none.
+     */
+    ask?: (question: HostQuestion) => boolean | Promise<boolean>;
+};
+/** What the person is asked before a call of the page is made. */
+export type HostQuestion = {
+    /** The function, as the Appspec names it. */
+    function: string;
+    arguments: Record<string, unknown>;
+    /** The question, in a sentence. */
+    sentence: string;
+};
+/** The sentence a call is refused with when no rule names its tool. */
+export declare const hostRefused: (tool: string) => string;
+/** The sentence a call is refused with when the person did not allow it. */
+export declare const hostNotAllowed: (tool: string) => string;
+/**
+ * The frontend tools its agent is given for the page: `host_context` when
+ * the Appspec names values, and `host_<name>` for each function it names.
+ * `host` is read at each call, so that what the page passes is the newest.
+ */
+export declare function hostFrontendTools(app: Pick<AppSpec, 'connections' | 'rules' | 'deployment'>, host: () => AppEmbedHost): FrontendToolDefinition[];

package/lib/loop/embed/hostBridge.js

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { behaviourFor } from '../apps/rules';
+import { HOST_CONTEXT_TOOL, HOST_NAME, hostTool, hostToolsOf, } from '../apps/hostTools';
+export { HOST_CONTEXT_TOOL, HOST_NAME, hostTool, hostToolsOf };
+/** The sentence a call is refused with when no rule names its tool. */
+export const hostRefused = (tool) => `No rule of this application names ${tool}: it is left to the person, and the page was not called.`;
+/** The sentence a call is refused with when the person did not allow it. */
+export const hostNotAllowed = (tool) => `The person did not allow ${tool}: the page was not called.`;
+/** Asks with the browser's `confirm`, where there is one; refuses where not. */
+const confirmOnPage = (question) => typeof window !== 'undefined' && typeof window.confirm === 'function'
+    ? window.confirm(question.sentence)
+    : false;
+/** The words of the rule that names the tool, for the question. */
+const actionOf = (app, tool) => app.rules.find(rule => rule.appliesTo.includes(tool))?.action;
+/**
+ * The frontend tools its agent is given for the page: `host_context` when
+ * the Appspec names values, and `host_<name>` for each function it names.
+ * `host` is read at each call, so that what the page passes is the newest.
+ */
+export function hostFrontendTools(app, host) {
+    const bridge = app.deployment.embedded?.host;
+    if (!bridge) {
+        return [];
+    }
+    const behaviour = (tool) => behaviourFor(app, tool);
+    const ruled = (tool) => behaviour(tool) !== 'leave_to_me';
+    const tools = [];
+    if (bridge.context.length > 0) {
+        tools.push({
+            name: HOST_CONTEXT_TOOL,
+            description: `What the page you are embedded in says of its visitor and of itself: ${bridge.context.join(', ')}. Read it before answering what depends on them.`,
+            parameters: { type: 'object', properties: {} },
+            location: 'frontend',
+            handler: async () => {
+                if (!ruled(HOST_CONTEXT_TOOL)) {
+                    return { error: hostRefused(HOST_CONTEXT_TOOL) };
+                }
+                const passed = host().context?.() ?? {};
+                const values = {};
+                const unsaid = [];
+                for (const name of bridge.context) {
+                    if (passed[name] === undefined) {
+                        unsaid.push(name);
+                    }
+                    else {
+                        values[name] = passed[name];
+                    }
+                }
+                return { values, ...(unsaid.length > 0 ? { unsaid } : {}) };
+            },
+        });
+    }
+    for (const fn of bridge.functions) {
+        const tool = hostTool(fn.name);
+        tools.push({
+            name: tool,
+            description: fn.description,
+            parameters: fn.parameters,
+            location: 'frontend',
+            handler: async (args) => {
+                const said = (detail) => {
+                    host().onEvent?.({
+                        type: 'action',
+                        detail: { function: fn.name, arguments: args, ...detail },
+                    });
+                    return detail;
+                };
+                if (!ruled(tool)) {
+                    return said({ error: hostRefused(tool) });
+                }
+                if (behaviour(tool) !== 'do_it') {
+                    const action = actionOf(app, tool) ?? fn.description;
+                    const ask = host().ask ?? confirmOnPage;
+                    const allowed = await ask({
+                        function: fn.name,
+                        arguments: args,
+                        sentence: `${action}? (${fn.name} with ${JSON.stringify(args)})`,
+                    });
+                    if (!allowed) {
+                        return said({ error: hostNotAllowed(tool) });
+                    }
+                }
+                const call = host().functions?.[fn.name];
+                if (!call) {
+                    return said({
+                        error: `The page offers no function ${fn.name}: it was not called.`,
+                    });
+                }
+                try {
+                    return said({ result: await call(args) });
+                }
+                catch (error) {
+                    return said({
+                        error: `The page's ${fn.name} failed: ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                }
+            },
+        });
+    }
+    return tools;
+}

package/lib/loop/index.d.ts

@@ -6,7 +6,7 @@
  *
  * @module loop
  */
-export { LoopCommand, LoopDocumentToolbar, LoopMention, LoopNotebookToolbar, LoopSlots, LoopViewType, canOpenView, createPromptChannel, parseCommand, type CommandArgSpec, type CommandContribution, type CommandResult, type EditorToolbarContext, type EditorToolbarContribution, type LoopCommandContext, type LoopViewProps, type LoopWorkspaceContext, type MentionCandidate, type MentionContribution, type PromptChannel, type SandboxSnapshot, type SandboxState, type ViewControls, type ViewTypeContribution, useLoopPromptStore, suggestLoopPrompt, focusPrompt, onPromptFocusRequest, type LoopPromptState, type SuggestedPrompt, } from './core';
+export { LoopCommand, LoopDocumentToolbar, LoopMention, LoopNotebookToolbar, LoopRunProps, LoopSlots, LoopViewType, canOpenView, createPromptChannel, parseCommand, runForwardedProps, type CommandArgSpec, type CommandContribution, type CommandResult, type EditorToolbarContext, type EditorToolbarContribution, type LoopCommandContext, type LoopViewProps, type LoopWorkspaceContext, type MentionCandidate, type MentionContribution, type PromptChannel, type RunPropsContribution, type SandboxSnapshot, type SandboxState, type ViewControls, type ViewTypeContribution, useLoopPromptStore, suggestLoopPrompt, focusPrompt, onPromptFocusRequest, type LoopPromptState, type SuggestedPrompt, } from './core';
 export { useEditorToolbar } from './core/toolbar';
 export { LoopWorkspace, PluginToggles, ViewSwitcher, WorkspaceFullScreenAction, buildLoopReactor, useWorkspaceFullScreen, type LoopWorkspaceProps, type PluginTogglesProps, type ViewSwitcherProps, } from './shell';
 export { A2uiPlugin, A2UI_PLUGIN_NAME } from './plugins/a2ui';
@@ -67,9 +67,11 @@ export { WindowFrame, WindowFramePlugin, WINDOW_ACTIONS_SLOT, WINDOW_CONTROLS_SL
 export { LoopCommandsPlugin, COMMANDS_PLUGIN_NAME } from './plugins/commands';
 export { PromptPlugin, PROMPT_PLUGIN_NAME } from './plugins/prompt';
 export { LoopEmbed, type LoopEmbedProps } from './embed/LoopEmbed';
-export { AppEmbed, type AppEmbedProps } from './embed/AppEmbed';
+export { AppEmbed, AppFloating, embedAssistantCharacter, type AppEmbedProps, type AppFloatingProps, type EmbedSession, useEmbedSession, useHostBridge, } from './embed/AppEmbed';
+export { EMBED_SESSION_KEY_PREFIX, embedSessionKey, visitOfToken, } from './embed/embedSession';
+export { HOST_CONTEXT_TOOL, hostFrontendTools, hostNotAllowed, hostRefused, hostTool, hostToolsOf, type AppEmbedHost, type HostEvent, type HostFunction, type HostQuestion, } from './embed/hostBridge';
 export { defineDatalayerAppElement, type DatalayerAppElementOptions, } from './embed/element';
-export { EMBED_ATTRIBUTES, EMBED_HOST_VARIABLES, EMBED_TAG, embedLookOf, embedSnippetOf, floatingViewOf, type EmbedLook, type EmbedSnippetOptions, } from './embed/embedConfig';
+export { EMBED_ATTRIBUTES, EMBED_HOST_VARIABLES, EMBED_TAG, embedLookOf, embedSnippetOf, floatingViewOf, resumeOf, type EmbedLook, type EmbedSnippetOptions, } from './embed/embedConfig';
 export { SubagentActivityPlugin, SubagentPulse, SUBAGENT_ACTIVITY_PLUGIN_NAME, } from './plugins/subagent-activity';
 export { loopPlugins, type LoopPresetOptions } from './presets';
 export { DocumentExtension, NotebookExtension } from './extensions';

package/lib/loop/index.js

@@ -11,7 +11,7 @@
  * @module loop
  */
 // The contracts. A plugin depends on these and on the reactor, never on the shell.
-export { LoopCommand, LoopDocumentToolbar, LoopMention, LoopNotebookToolbar, LoopSlots, LoopViewType, canOpenView, createPromptChannel, parseCommand, useLoopPromptStore, suggestLoopPrompt, focusPrompt, onPromptFocusRequest, } from './core';
+export { LoopCommand, LoopDocumentToolbar, LoopMention, LoopNotebookToolbar, LoopRunProps, LoopSlots, LoopViewType, canOpenView, createPromptChannel, parseCommand, runForwardedProps, useLoopPromptStore, suggestLoopPrompt, focusPrompt, onPromptFocusRequest, } from './core';
 export { useEditorToolbar } from './core/toolbar';
 // The shell.
 export { LoopWorkspace, PluginToggles, ViewSwitcher, WorkspaceFullScreenAction, buildLoopReactor, useWorkspaceFullScreen, } from './shell';
@@ -87,9 +87,12 @@ export { PromptPlugin, PROMPT_PLUGIN_NAME } from './plugins/prompt';
 export { LoopEmbed } from './embed/LoopEmbed';
 // An application in another product's page: the React component, the
 // `<datalayer-app>` element, and the snippet a host pastes (LOOP D-07 to D-09).
-export { AppEmbed } from './embed/AppEmbed';
+export { AppEmbed, AppFloating, embedAssistantCharacter, useEmbedSession, useHostBridge, } from './embed/AppEmbed';
+export { EMBED_SESSION_KEY_PREFIX, embedSessionKey, visitOfToken, } from './embed/embedSession';
+// The host page and an embedded application, talking (LOOP D-10).
+export { HOST_CONTEXT_TOOL, hostFrontendTools, hostNotAllowed, hostRefused, hostTool, hostToolsOf, } from './embed/hostBridge';
 export { defineDatalayerAppElement, } from './embed/element';
-export { EMBED_ATTRIBUTES, EMBED_HOST_VARIABLES, EMBED_TAG, embedLookOf, embedSnippetOf, floatingViewOf, } from './embed/embedConfig';
+export { EMBED_ATTRIBUTES, EMBED_HOST_VARIABLES, EMBED_TAG, embedLookOf, embedSnippetOf, floatingViewOf, resumeOf, } from './embed/embedConfig';
 export { SubagentActivityPlugin, SubagentPulse, SUBAGENT_ACTIVITY_PLUGIN_NAME, } from './plugins/subagent-activity';
 // The set a workspace normally has, so a host starts from a working Loop
 // rather than assembling one — and never from the example.

package/lib/loop/plugins/a2ui-surface/SurfaceToolResult.d.ts

@@ -29,8 +29,11 @@ export type SurfaceSubmitted = {
 };
 export type SurfaceToolResultProps = {
     context: ToolCallRenderContext;
-    /** Say something as the reader; `false` when the chat cannot take it. */
-    send: (message: string) => boolean;
+    /**
+     * Say something as the reader, with what goes with the run besides it;
+     * `false` when the chat cannot take it.
+     */
+    send: (message: string, forwardedProps?: Record<string, unknown>) => boolean;
     onRendered?: (rendered: SurfaceRendered) => void;
     onSubmitted?: (submitted: SurfaceSubmitted) => void;
 };

package/lib/loop/plugins/a2ui-surface/SurfaceToolResult.js

@@ -4,7 +4,7 @@ import { Spinner, Text } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
 import { encodeFormSubmission } from '../../../chat/messages/formSubmission';
 import { InlineSurface, SURFACE_CATALOG_ID } from './InlineSurface';
-import { readA2uiToolResult, validateA2uiSubmission, } from './toolResult';
+import { answerAction, readA2uiToolResult, validateA2uiSubmission, } from './toolResult';
 export function SurfaceToolResult({ context, send, onRendered, onSubmitted, }) {
     const parsed = useMemo(() => context.status === 'complete'
         ? readA2uiToolResult(context.result, SURFACE_CATALOG_ID)
@@ -27,6 +27,12 @@ export function SurfaceToolResult({ context, send, onRendered, onSubmitted, }) {
     }, [parsed, context.toolCallId]);
     const handleAction = useCallback((action) => {
         if (action.name !== 'submit_a2ui_form') {
+            // A button of what an application's answer shows: its action goes to
+            // the application, as a button of its page does (LOOP P-04).
+            const pressed = answerAction(action);
+            if (pressed && !send(pressed.message, pressed.forwardedProps)) {
+                setValidationError('The chat is not ready to take it yet.');
+            }
             return;
         }
         const values = (action.context ?? {});

package/lib/loop/plugins/a2ui-surface/index.d.ts

@@ -30,5 +30,5 @@ export declare function createA2uiSurfacePlugin(options?: A2uiSurfacePluginOptio
 /** The instance the preset mounts: no host callbacks. */
 export declare const A2uiSurfacePlugin: ReactorPlugin<Record<string, never>, unknown, unknown>;
 export type { SurfaceRendered, SurfaceSubmitted } from './SurfaceToolResult';
-export { readA2uiToolResult, validateA2uiField, validateA2uiSubmission, type A2uiFieldRule, type A2uiToolResult, } from './toolResult';
+export { answerAction, readA2uiToolResult, validateA2uiField, validateA2uiSubmission, type A2uiFieldRule, type A2uiToolResult, } from './toolResult';
 export default A2uiSurfacePlugin;

package/lib/loop/plugins/a2ui-surface/index.js

@@ -38,12 +38,12 @@ let counter = 0;
 export function createA2uiSurfacePlugin(options = {}) {
     const id = `a2ui-surface-${(counter += 1)}`;
     let currentSend;
-    const send = (message) => {
+    const send = (message, forwardedProps) => {
         if (!currentSend) {
             return false;
         }
-        currentSend(message);
-        return true;
+        // The chat answers why it could not send, when it could not.
+        return !currentSend(message, forwardedProps);
     };
     function Capture({ workspace, }) {
         const workspaceSend = workspace?.viewControls.send;
@@ -87,5 +87,5 @@ export function createA2uiSurfacePlugin(options = {}) {
 }
 /** The instance the preset mounts: no host callbacks. */
 export const A2uiSurfacePlugin = createA2uiSurfacePlugin();
-export { readA2uiToolResult, validateA2uiField, validateA2uiSubmission, } from './toolResult';
+export { answerAction, readA2uiToolResult, validateA2uiField, validateA2uiSubmission, } from './toolResult';
 export default A2uiSurfacePlugin;