@datalayer/agent-runtimes 1.3.80 → 1.3.81

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

@@ -0,0 +1,40 @@
+/**
+ * A step of an application's code, shown in the conversation as it runs
+ * (LOOP P-16): the chain of thought.
+ *
+ * AG-UI's `STEP_STARTED` and `STEP_FINISHED` carry a step's name only; the
+ * session API says the step whole beside them, with a `CUSTOM` event named
+ * `loop.step` — `{id, name, kind, parent_id, input, output, error,
+ * started_at, ended_at}` — which the AG-UI adapter hands on as an
+ * `activity`. A step is drawn as the chat draws a tool call: one row,
+ * collapsed, its input and output inside, running until it ends; a nested
+ * step says the step it is in.
+ */
+import type { DisplayItem, ToolCallMessage } from '../../types/chat';
+/** The `CUSTOM` event's name. */
+export declare const LOOP_STEP = "loop.step";
+/** A step, as the event says it. */
+export type LoopStep = {
+    id: string;
+    name: string;
+    kind: string;
+    parentId: string | null;
+    input: unknown;
+    output: unknown;
+    error: string;
+    ended: boolean;
+};
+/** The step an activity says, or `null` when it says none. */
+export declare function loopStepOf(activity: {
+    type: string;
+    data: unknown;
+} | undefined): LoopStep | null;
+/** The id of the row a step is drawn as. */
+export declare const stepCallId: (id: string) => string;
+/** A step as the row the chat draws a tool call as. */
+export declare function stepItem(step: LoopStep, inside?: string): ToolCallMessage;
+/**
+ * The conversation with the step drawn: its row changed in place when it is
+ * there (a step ending), else added after the rest.
+ */
+export declare function withLoopStep(items: DisplayItem[], step: LoopStep): DisplayItem[];

package/lib/chat/base/loopStep.js

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The `CUSTOM` event's name. */
+export const LOOP_STEP = 'loop.step';
+/** The step an activity says, or `null` when it says none. */
+export function loopStepOf(activity) {
+    if (!activity || activity.type !== LOOP_STEP)
+        return null;
+    const data = activity.data;
+    if (!data ||
+        typeof data.id !== 'string' ||
+        !data.id ||
+        typeof data.name !== 'string') {
+        return null;
+    }
+    return {
+        id: data.id,
+        name: data.name,
+        kind: typeof data.kind === 'string' ? data.kind : 'run',
+        parentId: typeof data.parent_id === 'string' && data.parent_id
+            ? data.parent_id
+            : null,
+        input: data.input ?? null,
+        output: data.output ?? null,
+        error: typeof data.error === 'string' ? data.error : '',
+        ended: typeof data.ended_at === 'string' && data.ended_at !== '',
+    };
+}
+/** The id of the row a step is drawn as. */
+export const stepCallId = (id) => `step-${id}`;
+/** A step as the row the chat draws a tool call as. */
+export function stepItem(step, inside) {
+    const callId = stepCallId(step.id);
+    const kind = `${step.kind} step`;
+    return {
+        id: callId,
+        type: 'tool-call',
+        toolCallId: callId,
+        toolName: step.name,
+        args: {
+            kind: step.kind,
+            ...(step.input !== null ? { input: step.input } : {}),
+        },
+        ...(step.ended && !step.error && step.output !== null
+            ? { result: step.output }
+            : {}),
+        status: !step.ended ? 'executing' : step.error ? 'error' : 'complete',
+        ...(step.error ? { error: step.error } : {}),
+        summary: inside ? `${kind}, inside ${inside}` : kind,
+    };
+}
+/**
+ * The conversation with the step drawn: its row changed in place when it is
+ * there (a step ending), else added after the rest.
+ */
+export function withLoopStep(items, step) {
+    const parent = step.parentId
+        ? items.find(item => 'toolCallId' in item &&
+            item.toolCallId === stepCallId(step.parentId))
+        : undefined;
+    const row = stepItem(step, parent && 'toolName' in parent ? parent.toolName : undefined);
+    let found = false;
+    const changed = items.map(item => {
+        if ('toolCallId' in item && item.toolCallId === row.toolCallId) {
+            found = true;
+            return row;
+        }
+        return item;
+    });
+    return found ? changed : [...items, row];
+}

package/lib/loop/apps/appspec.js

@@ -58,6 +58,8 @@ const DEFAULT_READY_AT = 0.8;
 const DEFAULT_PROTOCOL = 'a2ui/v0.9';
 const DEFAULT_ICON = 'apps';
 const DEFAULT_VERSION = '0.0.1';
+/** A host function's arguments when it names none: an empty object. */
+const NO_HOST_PARAMETERS = { type: 'object', properties: {} };
 const isData = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 const text = (value, otherwise = '') => typeof value === 'string' ? value : otherwise;
 const flag = (value, otherwise) => typeof value === 'boolean' ? value : otherwise;
@@ -290,12 +292,27 @@ function parseDeployment(data) {
         deployment.hosted = {
             visibility: oneOf(data.hosted.visibility, ['private', 'invited', 'organization', 'link', 'public'], 'private'),
             slug: text(data.hosted.slug),
+            ...(data.hosted.character_alone === true ? { characterAlone: true } : {}),
         };
     }
     if (isData(data.embedded)) {
         deployment.embedded = {
             mode: oneOf(data.embedded.mode, APP_EMBED_MODES, 'inline'),
             origins: texts(data.embedded.origins),
+            ...(isData(data.embedded.host)
+                ? {
+                    host: {
+                        context: texts(data.embedded.host.context),
+                        functions: records(data.embedded.host.functions).map(fn => ({
+                            name: text(fn.name),
+                            description: text(fn.description),
+                            parameters: isData(fn.parameters)
+                                ? fn.parameters
+                                : { ...NO_HOST_PARAMETERS },
+                        })),
+                    },
+                }
+                : {}),
         };
     }
     return deployment;
@@ -628,11 +645,24 @@ export function dumpAppspec(app) {
         .present('hosted', app.deployment.hosted &&
         new Writer()
             .value('visibility', app.deployment.hosted.visibility, 'private')
-            .text('slug', app.deployment.hosted.slug).data)
+            .text('slug', app.deployment.hosted.slug)
+            .value('character_alone', app.deployment.hosted.characterAlone === true, false).data)
         .present('embedded', app.deployment.embedded &&
         new Writer()
             .value('mode', app.deployment.embedded.mode, 'inline')
-            .list('origins', app.deployment.embedded.origins).data).data)
+            .list('origins', app.deployment.embedded.origins)
+            .present('host', app.deployment.embedded.host &&
+            new Writer()
+                .list('context', app.deployment.embedded.host.context)
+                .list('functions', app.deployment.embedded.host.functions.map(fn => ({
+                name: fn.name,
+                description: fn.description,
+                // No arguments is what it is unless said.
+                ...(JSON.stringify(fn.parameters) ===
+                    JSON.stringify(NO_HOST_PARAMETERS)
+                    ? {}
+                    : { parameters: fn.parameters }),
+            }))).data).data).data)
         .text('goal', app.goal)
         .list('triggers', app.triggers.map(trigger => new Writer()
         .text('type', trigger.type, '\u0000')

package/lib/loop/apps/checks.js

@@ -41,6 +41,7 @@ import { getTrack } from '../../specs/tracks';
 import { pluginsOffSetupNotes } from '../plugins/canvas-blocks';
 import { isAssistantCharacterId, parseAppspec } from './appspec';
 import { classesOf, splitRef, toolBehaviours } from './rules';
+import { HOST_NAME, hostToolsOf } from './hostTools';
 export const NOT_READY = 'Not ready';
 export const NEEDS_ATTENTION = 'Needs attention';
 export const PASSES = 'Passes the instant checks';
@@ -110,6 +111,40 @@ function shapeProblems(app) {
     else if (app.triggers.length > 0) {
         problems.push(`A ${app.kind} application starts when somebody opens it: \`triggers\` are a worker's.`);
     }
+    // What the host page passes and offers (D-10): named once each, in words
+    // its agent's tools can carry, each function saying what it does.
+    const host = app.deployment.embedded?.host;
+    if (host) {
+        for (const name of host.context) {
+            if (!HOST_NAME.test(name)) {
+                problems.push(`Cannot use “${name}” as a value of the host: lower-case letters, digits and \`_\`.`);
+            }
+        }
+        if (new Set(host.context).size !== host.context.length) {
+            problems.push('The host’s values are named once each.');
+        }
+        for (const fn of host.functions) {
+            if (!HOST_NAME.test(fn.name)) {
+                problems.push(`Cannot use “${fn.name}” as a host function: lower-case letters, digits and \`_\`.`);
+            }
+            if (!fn.description.trim()) {
+                problems.push(`The host function “${fn.name}” says what it does.`);
+            }
+            if (fn.parameters.type !== 'object') {
+                problems.push(`The host function “${fn.name}” takes its arguments as a JSON Schema of \`type: object\`.`);
+            }
+        }
+        const names = host.functions.map(fn => fn.name);
+        if (new Set(names).size !== names.length) {
+            problems.push('The host’s functions are named once each.');
+        }
+        const named = new Set(app.rules.flatMap(rule => rule.appliesTo));
+        for (const tool of hostToolsOf(host)) {
+            if (!named.has(tool)) {
+                problems.push(`No rule names “${tool}”, which the host page offers it: it is left to the person until a rule decides it.`);
+            }
+        }
+    }
     const servers = app.connections.map(connection => idOf(connection.server));
     if (new Set(servers).size !== servers.length) {
         problems.push('The application connects to the same server twice.');
@@ -274,12 +309,16 @@ function referenceProblems(app, organizationFrames) {
             problems.push(`The application may write through “${connection.server}”, whose tools nobody has classed: every one of them is left to the person until they are.`);
         }
     }
+    // The tools of the host page are the application's own (D-10).
+    const hostTools = hostToolsOf(app.deployment.embedded?.host);
     for (const rule of app.rules) {
         for (const target of rule.appliesTo) {
             if (CLASS_NAMES.has(target))
                 continue;
             const [server, name] = splitRef(target);
             if (server === undefined) {
+                if (hostTools.includes(target))
+                    continue;
                 if (!getBackendToolSpec(name)) {
                     problems.push(`The rule “${rule.action}” names the tool “${target}”, which the catalogue does not have.`);
                 }
@@ -628,6 +667,10 @@ export function documentShapeProblems(document) {
                         !/^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/.test(hosted.slug)))) {
                 at('deployment.hosted.slug', 'is lower-case letters, digits and hyphens');
             }
+            if (hosted.character_alone !== undefined &&
+                typeof hosted.character_alone !== 'boolean') {
+                at('deployment.hosted.character_alone', 'is true or false');
+            }
         });
         mapping(deployment.embedded, 'deployment.embedded', embedded => {
             oneOf(embedded.mode, ENUMS.mode, 'deployment.embedded.mode');
@@ -640,6 +683,16 @@ export function documentShapeProblems(document) {
                     }
                 });
             }
+            mapping(embedded.host, 'deployment.embedded.host', host => {
+                texts(host.context, 'deployment.embedded.host.context');
+                records(host.functions, 'deployment.embedded.host.functions', (item, where) => {
+                    required(item, 'name', where);
+                    required(item, 'description', where);
+                    text(item.name, `${where}.name`);
+                    text(item.description, `${where}.description`);
+                    mapping(item.parameters, `${where}.parameters`, () => undefined);
+                });
+            });
         });
     });
     records(d.triggers, 'triggers', (item, where) => {

package/lib/loop/apps/hostTools.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The tools an embedded application is given for its host page (LOOP D-10),
+ * by name: `host_context` for the values the page passes, `host_<name>` for
+ * each function it offers. Apart from `embed/hostBridge`, which calls the
+ * page, so that the checks read them as a pure module.
+ *
+ * @module loop/apps/hostTools
+ */
+import type { AppHostBridgeSpec } from '../../types/agentspecs';
+/** The tool its agent reads what the page passes it with. */
+export declare const HOST_CONTEXT_TOOL = "host_context";
+/** The tool its agent calls a function of the page with. */
+export declare const hostTool: (name: string) => string;
+/** How a value or a function of the host is named. */
+export declare const HOST_NAME: RegExp;
+/** The tools its agent is given for the host. */
+export declare function hostToolsOf(bridge: AppHostBridgeSpec | undefined): string[];

package/lib/loop/apps/hostTools.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The tool its agent reads what the page passes it with. */
+export const HOST_CONTEXT_TOOL = 'host_context';
+/** The tool its agent calls a function of the page with. */
+export const hostTool = (name) => `host_${name}`;
+/** How a value or a function of the host is named. */
+export const HOST_NAME = /^[a-z][a-z0-9_]{0,62}$/;
+/** The tools its agent is given for the host. */
+export function hostToolsOf(bridge) {
+    if (!bridge) {
+        return [];
+    }
+    return [
+        ...(bridge.context.length > 0 ? [HOST_CONTEXT_TOOL] : []),
+        ...bridge.functions.map(fn => hostTool(fn.name)),
+    ];
+}

package/lib/loop/apps/rules.d.ts

@@ -28,11 +28,32 @@ export declare function matchesPattern(name: string, pattern: string): boolean;
 export declare const isComparable: (value: unknown) => boolean;
 /** Whether the arguments of a call make a condition true. */
 export declare function conditionHolds(condition: ActionConditionSpec, args: ToolArguments): boolean;
+/** Where a call of a tool that forwards mail says what it forwards, from where, and to whom. */
+export type Forwarding = {
+    /** The argument naming the message forwarded; a call without it does not forward. */
+    message: string;
+    /** The argument holding the address of the mailbox it sends from. */
+    mailbox: string;
+    /** The arguments holding its recipients. */
+    recipients: string[];
+};
+/** The tools that forward a message, by `server.tool` — as `agentspecs.actions.FORWARDING`. */
+export declare const FORWARDING: Record<string, Forwarding>;
+/** The mail addresses an argument holds — one, several separated by commas, or a list — in lower case. */
+export declare function addresses(value: unknown): string[];
+/**
+ * Whether a call forwards a message to somebody outside the organization
+ * (LOOP W-04): the domain of the mailbox it sends from. Fails closed: a
+ * forward that does not say its mailbox is outside. A reply is not a forward.
+ */
+export declare function forwardsOutside(server: string, name: string, args: ToolArguments): boolean;
 /**
  * The classes of a tool, by reference; empty when nobody classed it.
  *
  * With the arguments of a call, the classes of that call. Without them,
- * everything the tool can do: nobody said what it is asked.
+ * everything the tool can do: nobody said what it is asked. A forward
+ * outside the organization is told from the call (`forwardsOutside`): it
+ * publishes besides sending.
  */
 export declare function classesOf(ref: string, args?: ToolArguments): ActionClass[];
 /** Whether a tool only reads. An unknown tool — no class — does not. */

package/lib/loop/apps/rules.js

@@ -129,11 +129,53 @@ function entryOf(server, name) {
     }
     return [[...actions.default], []];
 }
+/** The tools that forward a message, by `server.tool` — as `agentspecs.actions.FORWARDING`. */
+export const FORWARDING = {
+    'google-workspace.send_gmail_message': {
+        message: 'forward_message_id',
+        mailbox: 'user_google_email',
+        recipients: ['to', 'cc', 'bcc'],
+    },
+};
+/** The mail addresses an argument holds — one, several separated by commas, or a list — in lower case. */
+export function addresses(value) {
+    const items = Array.isArray(value) ? value : [value];
+    return items
+        .filter((item) => typeof item === 'string')
+        .flatMap(item => item.split(','))
+        .map(part => {
+        const angled = /<([^>]*)>/.exec(part);
+        return (angled ? angled[1] : part).trim().toLowerCase();
+    })
+        .filter(address => address.includes('@'));
+}
+const domainOf = (address) => address.slice(address.lastIndexOf('@') + 1).trim();
+/**
+ * Whether a call forwards a message to somebody outside the organization
+ * (LOOP W-04): the domain of the mailbox it sends from. Fails closed: a
+ * forward that does not say its mailbox is outside. A reply is not a forward.
+ */
+export function forwardsOutside(server, name, args) {
+    const forwarding = own(FORWARDING, `${server}.${name}`);
+    const message = forwarding ? args[forwarding.message] : undefined;
+    if (!forwarding || typeof message !== 'string' || !message.trim()) {
+        return false;
+    }
+    const [home] = addresses(args[forwarding.mailbox]);
+    if (!home) {
+        return true;
+    }
+    return forwarding.recipients
+        .flatMap(field => addresses(args[field]))
+        .some(address => domainOf(address) !== domainOf(home));
+}
 /**
  * The classes of a tool, by reference; empty when nobody classed it.
  *
  * With the arguments of a call, the classes of that call. Without them,
- * everything the tool can do: nobody said what it is asked.
+ * everything the tool can do: nobody said what it is asked. A forward
+ * outside the organization is told from the call (`forwardsOutside`): it
+ * publishes besides sending.
  */
 export function classesOf(ref, args) {
     const [server, name] = splitRef(ref);
@@ -150,6 +192,12 @@ export function classesOf(ref, args) {
             }
         }
     }
+    if (args !== undefined &&
+        classes.length > 0 &&
+        !classes.includes('publish') &&
+        forwardsOutside(server, name, args)) {
+        classes.push('publish');
+    }
     return classes;
 }
 /** Whether a tool only reads. An unknown tool — no class — does not. */

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

@@ -1,9 +1,15 @@
 import type { CSSProperties, JSX, ReactNode } from 'react';
 import type { PluginRef } from '@datalayer/reactor';
 import type { AppAccent, AppEmbedMode, AppSpec } from '../../types/agentspecs';
-import { type AppInstance } from '../apps/AppRenderer';
+import type { ThemeOverrides } from '../../types/chat';
+import type { AssistantCharacter } from '../../chat/assistant/characters';
+import type { AssistantCharacterData } from '../../chat/assistant/formats/types';
+import type { PresenceState } from '../../chat/presence/presenceStatus';
+import { type AppInstance, type AppRendererProps } from '../apps/AppRenderer';
+import type { ChatSaid } from '../plugins/chat';
 import { type AssistantCharacterChosen } from '../plugins/assistant-characters';
 import { type EmbedColorMode } from './embedConfig';
+import { type AppEmbedHost } from './hostBridge';
 export type AppEmbedProps = {
     /** The application. */
     app: AppSpec;
@@ -44,6 +50,23 @@ export type AppEmbedProps = {
      * element passes none.
      */
     plugins?: PluginRef[];
+    /**
+     * What the page gives the application (LOOP D-10): the values it passes,
+     * its functions, and what it is told — read for the names the Appspec
+     * gives under `deployment.embedded.host`.
+     */
+    host?: AppEmbedHost;
+};
+/**
+ * The page and the application talking (LOOP D-10): the tools of the host
+ * the Appspec names, given to its agent through a chat-extras plugin made
+ * once — the page's newest values and functions read at each call — and
+ * `message` said to the page when an answer is done.
+ */
+export declare function useHostBridge(app: AppSpec, host: AppEmbedHost | undefined): {
+    plugins: PluginRef[];
+    onPresence: (state: PresenceState) => void;
+    onSaying: (said: ChatSaid) => void;
 };
 /**
  * The character the assistant mode draws (T-24, D-07): the application's own
@@ -54,6 +77,38 @@ export type AppEmbedProps = {
 export declare function embedAssistantCharacter(app: AppSpec, plugins?: PluginRef[]): AssistantCharacterChosen;
 /** What a floating application says to a visitor Datalayer does not know. */
 export declare const signedOutSentence: (app: Pick<AppSpec, "name">) => string;
+export type AppFloatingProps = {
+    app: AppSpec;
+    view: 'floating-small' | 'panel' | 'assistant';
+    colorMode: 'light' | 'dark';
+    /** The accent and face inside the conversation. */
+    themeOverrides: ThemeOverrides;
+    /** The assistant's character, in the assistant mode. */
+    character?: AssistantCharacter | AssistantCharacterData;
+    /** The host's agent-runtimes server, when it names one. */
+    serverUrl?: string;
+    instance?: AppInstance;
+    /** The visit's embed token, on the host's server (R-20). */
+    embedToken?: string;
+    /**
+     * What else the host gives the application's `AppRenderer`: Datalayer's
+     * own page at an application's address (T-21) passes the UI plugins its
+     * organization turned off, the visitors' runtime and the one kept on.
+     */
+    renderer?: Partial<Pick<AppRendererProps, 'pluginsOff' | 'datalayerVisitors' | 'datalayerKept'>>;
+    /** What the page gives the application (D-10). */
+    host?: AppEmbedHost;
+};
+/**
+ * The bubble, the panel and the assistant: `ChatFloating`'s chrome in that
+ * mode — the button, its blink and its balloon, the panel at the edge, the
+ * character dragged about and sent away — holding the application as
+ * `AppRenderer` draws it inline (R-01): its kind's preset, its layout, its
+ * agent created with its spec and spoken to at its session endpoint (R-04).
+ * The workspace tells the chrome what the application is doing and what it
+ * last said (`onPresence`, `onSaying`).
+ */
+export declare function AppFloating({ app, view, colorMode, themeOverrides, character, serverUrl, instance, embedToken, renderer, host, }: AppFloatingProps): JSX.Element;
 /** The `loop` theme, with the application's (or the host's) accent and face. */
 export declare function EmbedThemed({ accent, colorMode, font, children, style, }: {
     accent: AppAccent;
@@ -62,5 +117,5 @@ export declare function EmbedThemed({ accent, colorMode, font, children, style,
     children: ReactNode;
     style?: CSSProperties;
 }): JSX.Element;
-export declare function AppEmbed({ app, mode, accent, colorMode, font, serverUrl, instance, embedToken, height, ownPortal, plugins, }: AppEmbedProps): JSX.Element;
+export declare function AppEmbed({ app, mode, accent, colorMode, font, serverUrl, instance, embedToken, height, ownPortal, plugins, host, }: AppEmbedProps): JSX.Element;
 export default AppEmbed;

package/lib/loop/embed/AppEmbed.js

@@ -35,16 +35,66 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  *
  * @module loop/embed/AppEmbed
  */
-import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
 import { Text, registerPortalRoot } from '@primer/react';
 import { useIAMStore } from '@datalayer/core/lib/state/substates/IAMState';
 import { FluentEmoji } from '@datalayer/core/lib/components/emoji';
 import { DatalayerThemeProvider, loopTheme } from '@datalayer/primer-addons';
 import { ChatFloating } from '../../chat/ChatFloating';
-import { AppRenderer } from '../apps/AppRenderer';
+import { AppRenderer, } from '../apps/AppRenderer';
 import { AssistantCharactersPlugin, assistantCharacterFor, assistantCharactersFrom, } from '../plugins/assistant-characters';
 import { floatingViewOf } from './embedConfig';
+import { createChatExtrasPlugin } from '../plugins/chat-extras';
+import { hostFrontendTools } from './hostBridge';
 import { embedThemeOverrides, embedThemeStyles } from './embedTheme';
+/** No plugins for the renderer: one array, so that it never reads as a change. */
+const NO_HOST_PLUGINS = [];
+/**
+ * The page and the application talking (LOOP D-10): the tools of the host
+ * the Appspec names, given to its agent through a chat-extras plugin made
+ * once — the page's newest values and functions read at each call — and
+ * `message` said to the page when an answer is done.
+ */
+export function useHostBridge(app, host) {
+    const hostRef = useRef(host);
+    hostRef.current = host;
+    const handle = useMemo(() => createChatExtrasPlugin(), []);
+    const bridge = app.deployment.embedded?.host;
+    const key = JSON.stringify([bridge ?? null, app.rules, app.connections]);
+    useEffect(() => {
+        handle.setExtras({
+            frontendTools: hostFrontendTools(app, () => hostRef.current ?? {}),
+        });
+        // The tools change with what the Appspec names, and the rules that decide them.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [handle, key]);
+    const plugins = useMemo(() => (bridge ? [handle.plugin] : NO_HOST_PLUGINS), [bridge, handle]);
+    const said = useRef({ answering: false });
+    const before = useRef('idle');
+    const told = useRef('');
+    const onSaying = useCallback((next) => {
+        said.current = next;
+    }, []);
+    const onPresence = useCallback((state) => {
+        const was = before.current;
+        before.current = state;
+        const done = state === 'idle' || state === 'waiting';
+        const saying = said.current.saying;
+        if (done &&
+            was !== 'idle' &&
+            was !== 'waiting' &&
+            said.current.answering &&
+            saying &&
+            saying.id !== told.current) {
+            told.current = saying.id;
+            hostRef.current?.onEvent?.({
+                type: 'message',
+                detail: { id: saying.id, text: saying.markdown || saying.text },
+            });
+        }
+    }, []);
+    return { plugins, onPresence, onSaying };
+}
 /** No host plugins: one array, so that it never reads as a change. */
 const NO_PLUGINS = [];
 /**
@@ -72,14 +122,24 @@ function Face({ emoji }) {
  * The workspace tells the chrome what the application is doing and what it
  * last said (`onPresence`, `onSaying`).
  */
-function FloatingApp({ app, view, colorMode, themeOverrides, character, serverUrl, instance, embedToken, }) {
+export function AppFloating({ app, view, colorMode, themeOverrides, character, serverUrl, instance, embedToken, renderer, host, }) {
     const [presence, setPresence] = useState('idle');
     const [said, setSaid] = useState({ answering: false });
+    const bridge = useHostBridge(app, host);
+    const onPresence = useCallback((state) => {
+        setPresence(state);
+        bridge.onPresence(state);
+    }, [bridge.onPresence]);
+    const onSaying = useCallback((next) => {
+        setSaid(next);
+        bridge.onSaying(next);
+    }, [bridge.onSaying]);
     const welcome = app.interface.welcome || app.description;
     // A runtime is somebody's to pay for: on Datalayer, only for a visitor
     // Datalayer knows — said, and nothing launched, for one it does not.
     const token = useIAMStore(state => state.token);
-    const signedOut = !serverUrl && !token;
+    // Signed out on the visitors' runtime (R-30) is somebody's too.
+    const signedOut = !serverUrl && !token && !renderer?.datalayerVisitors;
     return (_jsx(ChatFloating, { defaultViewMode: view, ...(character ? { assistantCharacter: character } : {}), ...(app.interface.balloon
             ? { balloonDisplay: app.interface.balloon }
             : {}), title: app.name, description: welcome, brandIcon: _jsx(Face, { emoji: app.emoji }), buttonIcon: _jsx(Face, { emoji: app.emoji }), buttonTooltip: `Talk to ${app.name}`, colorMode: colorMode, useStore: false, conversation: {
@@ -90,7 +150,7 @@ function FloatingApp({ app, view, colorMode, themeOverrides, character, serverUr
                 // The window draws its face, its name and close.
                 hideChatHeader: true, 
                 // Mounted closed: the caret goes in when the window opens.
-                autoFocusPrompt: false, onPresence: setPresence, onSaying: setSaid })),
+                autoFocusPrompt: false, onPresence: onPresence, onSaying: onSaying, plugins: bridge.plugins, ...renderer })),
             presence,
             saying: said.saying,
             answering: said.answering,
@@ -139,7 +199,8 @@ export function EmbedThemed({ accent, colorMode, font, children, style, }) {
      */
     _jsx("div", { "data-color-mode": colorMode, style: { display: 'contents' }, children: _jsx(DatalayerThemeProvider, { colorMode: colorMode, theme: loopTheme, themeStyles: themeStyles, baseStyles: style, children: children }) }));
 }
-export function AppEmbed({ app, mode, accent, colorMode = 'auto', font, serverUrl, instance, embedToken, height = 640, ownPortal = false, plugins = NO_PLUGINS, }) {
+export function AppEmbed({ app, mode, accent, colorMode = 'auto', font, serverUrl, instance, embedToken, height = 640, ownPortal = false, plugins = NO_PLUGINS, host, }) {
+    const bridge = useHostBridge(app, host);
     const system = useSystemMode();
     const resolvedMode = colorMode === 'auto' ? system : colorMode;
     const shownAs = mode ?? app.deployment.embedded?.mode ?? 'inline';
@@ -157,10 +218,12 @@ export function AppEmbed({ app, mode, accent, colorMode = 'auto', font, serverUr
     return (_jsxs(EmbedThemed, { accent: worn, colorMode: resolvedMode, font: font, style: view
             ? // Floating: nothing in the page's flow, nothing painted behind.
                 { backgroundColor: 'transparent' }
-            : { height, display: 'flex', flexDirection: 'column' }, children: [ownPortal ? _jsx(OwnPortalRoot, {}) : null, view ? (_jsx(FloatingApp, { app: app, view: view, serverUrl: serverUrl, instance: instance, embedToken: embedToken, colorMode: resolvedMode, themeOverrides: themeOverrides, character: character })) : (_jsx(AppRenderer, { app: app, target: serverUrl ? 'local' : 'datalayer', ...(serverUrl ? { serverUrl } : {}), ...(serverUrl && embedToken ? { embedToken } : {}), instance: instance, 
+            : { height, display: 'flex', flexDirection: 'column' }, children: [ownPortal ? _jsx(OwnPortalRoot, {}) : null, view ? (_jsx(AppFloating, { app: app, view: view, serverUrl: serverUrl, instance: instance, embedToken: embedToken, colorMode: resolvedMode, themeOverrides: themeOverrides, character: character, host: host })) : (_jsx(AppRenderer, { app: app, target: serverUrl ? 'local' : 'datalayer', ...(serverUrl ? { serverUrl } : {}), ...(serverUrl && embedToken ? { embedToken } : {}), instance: instance, 
                 // The host's accent and face over the application's own, inside
                 // its conversation too, in the embed's mode: the host's or its
                 // visitor's system's, not a Datalayer setting.
-                themeOverrides: themeOverrides, colorMode: resolvedMode }))] }));
+                themeOverrides: themeOverrides, colorMode: resolvedMode, 
+                // What the page gives it, and what it tells the page (D-10).
+                plugins: bridge.plugins, onPresence: bridge.onPresence, onSaying: bridge.onSaying }))] }));
 }
 export default AppEmbed;