@datalayer/agent-runtimes 1.3.37 → 1.3.39

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

@@ -6,12 +6,15 @@
  * A chat, a widget or a worker runs as its conversation. Its page is its
  * A2UI surface (`interface.surface`) drawn beside that conversation, fed from
  * it: the question last asked, the answer as it streams, where the turn
- * stands. What a block writes — an input's `value` — stays in the surface's
+ * stands, a chat's whole conversation. What a block writes — an input's `value` — stays in the surface's
  * data model at a path the application takes, and what a button does reaches
  * the application through the chat's own channels: a message sent, the
  * answer stopped, the conversation started over. Nothing here is a server
- * API; a setting reaches the application in the words of the message it is
- * sent with, until the session API carries a settings change (R-04).
+ * API: what a button did besides its message — the block's action, the files
+ * given, the settings — goes with the chat's own run to the application's
+ * session (LOOP R-04, `forwardedProps.loop`), which puts a file where the
+ * application reads it; a setting also reaches a written application in the
+ * words of its message.
  *
  * A decision is not here: its page is drawn by the Studio's run page, with
  * its own paths (`INTERFACE_PATHS`), until it moves onto the workspace (R-02).
@@ -21,7 +24,7 @@
  * @module loop/plugins/app-page/appPageModel
  */
 import type { AppSettingSpec, AppSpec } from '../../../types/agentspecs';
-import type { ChatTurnSnapshot } from '../../core';
+import type { ChatTurnSnapshot, ConversationEntry } from '../../core';
 /** The id of the editor surface an application's page is drawn in. */
 export declare const APP_PAGE_SURFACE = "app-page";
 /** The id of the A2UI surface itself, inside it. */
@@ -94,8 +97,11 @@ export declare function hasAppPage(app: Pick<AppSpec, 'kind' | 'interface' | 'ag
 export declare function surfaceUnshown(app: Pick<AppSpec, 'kind' | 'interface' | 'agent'>): string | null;
 /** A setting's first value, as its input holds it. */
 export declare function initialInput(setting: AppSettingSpec): unknown;
-/** What the conversation publishes to the page, by path, now. */
-export declare function appPageData(app: Pick<AppSpec, 'kind' | 'name' | 'goal'>, turn: ChatTurnSnapshot): Record<string, unknown>;
+/**
+ * What the conversation publishes to the page, by path, now: from its
+ * current turn, and for a chat its whole conversation.
+ */
+export declare function appPageData(app: Pick<AppSpec, 'kind' | 'name' | 'goal'>, turn: ChatTurnSnapshot, conversation: ConversationEntry[]): Record<string, unknown>;
 /** The page's data model when it is drawn: what is published, the inputs, the draft. */
 export declare function appPageInitialData(app: Pick<AppSpec, 'kind' | 'name' | 'goal' | 'interface'>): Record<string, unknown>;
 /**
@@ -103,6 +109,51 @@ export declare function appPageInitialData(app: Pick<AppSpec, 'kind' | 'name' |
  * its label, then any other value a block wrote under `/inputs` by its id.
  */
 export declare function inputsInWords(app: Pick<AppSpec, 'interface'>, inputs: unknown): string;
+/**
+ * The largest file a session takes: what the session API refuses above
+ * (`agent_runtimes.loop.apps.sessions.MAX_FILE_BYTES`), said here before
+ * the file is sent.
+ */
+export declare const MAX_FILE_BYTES: number;
+/** A file as File upload gives it, and as the session API takes it. */
+export type GivenFile = {
+    name: string;
+    type: string;
+    size: number;
+    data_url: string;
+};
+/**
+ * The files given on the page, as the session API takes them — or why they
+ * cannot go: what was given is not files as File upload gives them, or one
+ * is larger than a session takes. What becomes of each — put in the
+ * application's sandbox, or its text in the message — is the session's to
+ * decide (LOOP R-04).
+ */
+export declare function givenFiles(files: unknown): {
+    files: GivenFile[];
+} | {
+    refused: string;
+};
+/**
+ * The application's settings as the page holds them, as the session API
+ * takes them: a choice as the option chosen, a number as a number, a toggle
+ * as on or off — each setting the page has a value for.
+ */
+export declare function settingsOf(app: Pick<AppSpec, 'interface'>, inputs: unknown): Record<string, unknown>;
+/**
+ * What the page did besides its message, for the session API: the action of
+ * the block pressed, the files given with it, the settings it holds. Sent
+ * with the chat's own run (AG-UI's `forwardedProps.loop`), so that what it
+ * answers streams in the conversation (LOOP R-04).
+ */
+export type AppPageLoop = {
+    action: {
+        name: string;
+        payload: Record<string, unknown>;
+    };
+    files?: GivenFile[];
+    settings?: Record<string, unknown>;
+};
 /** What a button asked, as the surface hands it over. */
 export type AppPageEvent = {
     name: string;
@@ -112,6 +163,8 @@ export type AppPageEvent = {
 export type AppPageOutcome = {
     /** A message for the application, sent as the person's next turn. */
     send: string;
+    /** What the page did besides, for the session it is sent in. */
+    loop: AppPageLoop;
     /** The inputs in words as sent, to tell a change next time. */
     inputs: string;
     /** Paths to empty once it is sent. */

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

@@ -28,6 +28,18 @@ const SEND = {
     context: ['message'],
     asks: { message: 'The message it sends' },
 };
+const MESSAGES = {
+    path: '/messages',
+    meaning: 'The conversation so far, in order: each message {role: user or assistant, text}, each tool called {role: tool, name, args, result}.',
+    words: 'The conversation',
+    list: true,
+};
+const FILES = {
+    path: '/files',
+    meaning: 'The files given on the page, each {name, type, size, data_url}: they go to the application’s session with the next run, put in its sandbox when it has a shell, a text file in the message when it has none.',
+    words: 'The files given',
+    list: true,
+};
 const STOP = {
     name: 'stop',
     meaning: 'Stop the answer being written.',
@@ -54,6 +66,7 @@ export const APP_KIND_PATHS = {
                 words: 'Its answer',
             },
             STATUS,
+            MESSAGES,
         ],
         accepts: [DRAFT],
         actions: [
@@ -79,15 +92,22 @@ export const APP_KIND_PATHS = {
             },
             STATUS,
         ],
-        accepts: [],
+        accepts: [FILES],
         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.',
+                meaning: 'Run it on its inputs: every value written under /inputs is sent, and each file at /files, 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' },
             },
+            {
+                name: 'upload',
+                meaning: 'Run it on the files just given — the context’s files, else those at /files — with its inputs.',
+                words: 'Run it on the files given',
+                context: ['files'],
+                asks: { files: 'The files it runs on' },
+            },
             STOP,
         ],
         inputs: true,
@@ -197,8 +217,11 @@ export function initialInput(setting) {
             return String(setting.default ?? '');
     }
 }
-/** What the conversation publishes to the page, by path, now. */
-export function appPageData(app, turn) {
+/**
+ * What the conversation publishes to the page, by path, now: from its
+ * current turn, and for a chat its whole conversation.
+ */
+export function appPageData(app, turn, conversation) {
     const data = {
         '/app': app.name,
         '/status': STATUS_WORDS[turn.status] ?? '',
@@ -207,6 +230,7 @@ export function appPageData(app, turn) {
         case 'chat':
             data['/question'] = turn.user ?? '';
             data['/answer'] = turn.assistant ?? '';
+            data['/messages'] = conversation;
             break;
         case 'widget':
             data['/output'] = turn.assistant ?? '';
@@ -224,7 +248,7 @@ export function appPageData(app, turn) {
 /** 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' }))) {
+    for (const [path, value] of Object.entries(appPageData(app, { id: 0, status: 'idle' }, []))) {
         tree[path.slice(1)] = value;
     }
     const paths = appKindPaths(app);
@@ -237,6 +261,9 @@ export function appPageInitialData(app) {
     if (paths.accepts.some(entry => entry.path === DRAFT.path)) {
         tree.draft = '';
     }
+    if (paths.accepts.some(entry => entry.path === FILES.path)) {
+        tree.files = [];
+    }
     return tree;
 }
 /** One input in words: `Plan: Team`; nothing for an empty one. */
@@ -273,6 +300,87 @@ export function inputsInWords(app, inputs) {
     }
     return lines.filter(Boolean).join('\n');
 }
+/**
+ * The largest file a session takes: what the session API refuses above
+ * (`agent_runtimes.loop.apps.sessions.MAX_FILE_BYTES`), said here before
+ * the file is sent.
+ */
+export const MAX_FILE_BYTES = 25 * 1024 * 1024;
+/**
+ * The files given on the page, as the session API takes them — or why they
+ * cannot go: what was given is not files as File upload gives them, or one
+ * is larger than a session takes. What becomes of each — put in the
+ * application's sandbox, or its text in the message — is the session's to
+ * decide (LOOP R-04).
+ */
+export function givenFiles(files) {
+    if (files === undefined || files === null) {
+        return { files: [] };
+    }
+    if (!Array.isArray(files)) {
+        return { refused: 'What was given as files is not a list of files.' };
+    }
+    const given = [];
+    for (const [index, file] of files.entries()) {
+        const item = (file ?? {});
+        if (typeof item.name !== 'string' || typeof item.data_url !== 'string') {
+            return {
+                refused: `File ${index + 1} is not a file as File upload gives it ({name, type, size, data_url}).`,
+            };
+        }
+        const size = typeof item.size === 'number' ? item.size : 0;
+        if (size > MAX_FILE_BYTES) {
+            return {
+                refused: `${item.name} is ${size.toLocaleString('en')} bytes: a session takes files of at most ${MAX_FILE_BYTES.toLocaleString('en')}.`,
+            };
+        }
+        given.push({
+            name: item.name,
+            type: typeof item.type === 'string' ? item.type : '',
+            size,
+            data_url: item.data_url,
+        });
+    }
+    return { files: given };
+}
+/**
+ * The application's settings as the page holds them, as the session API
+ * takes them: a choice as the option chosen, a number as a number, a toggle
+ * as on or off — each setting the page has a value for.
+ */
+export function settingsOf(app, inputs) {
+    const values = inputs && typeof inputs === 'object'
+        ? inputs
+        : {};
+    const settings = {};
+    for (const setting of app.interface.settings) {
+        const value = values[setting.id];
+        if (value === undefined || value === null) {
+            continue;
+        }
+        switch (setting.type) {
+            case 'select': {
+                const chosen = Array.isArray(value) ? value[0] : value;
+                if (chosen !== undefined && chosen !== '') {
+                    settings[setting.id] = String(chosen);
+                }
+                break;
+            }
+            case 'toggle':
+                settings[setting.id] = Boolean(value);
+                break;
+            case 'slider':
+            case 'number':
+                if (value !== '' && !Number.isNaN(Number(value))) {
+                    settings[setting.id] = Number(value);
+                }
+                break;
+            default:
+                settings[setting.id] = String(value);
+        }
+    }
+    return settings;
+}
 /**
  * What a button pressed on the page does.
  *
@@ -293,15 +401,35 @@ export function appPageAction(app, event, read, lastInputs = '') {
     const given = event.context?.message;
     const message = typeof given === 'string' ? given.trim() : '';
     const inputs = paths.inputs ? inputsInWords(app, read('/inputs')) : '';
+    const settings = paths.inputs ? settingsOf(app, read('/inputs')) : undefined;
+    const payload = Object.fromEntries(Object.entries(event.context ?? {}).filter(([key]) => key !== 'message' && key !== 'files'));
+    const loop = (files) => ({
+        action: { name: event.name, payload },
+        ...(files && files.length > 0 ? { files } : {}),
+        ...(settings ? { settings } : {}),
+    });
     switch (event.name) {
         case 'stop':
             return { stop: true };
         case 'new':
             return { newChat: true };
-        case 'run': {
-            const text = [message, inputs].filter(Boolean).join('\n');
+        case 'run':
+        case 'upload': {
+            const context = event.context?.files;
+            const files = givenFiles(event.name === 'upload' && context !== undefined
+                ? context
+                : read(FILES.path));
+            if ('refused' in files) {
+                return files;
+            }
+            if (event.name === 'upload' && files.files.length === 0) {
+                return { refused: 'No file was given: choose one first.' };
+            }
+            const names = files.files.map(file => file.name).join(', ');
+            const text = [message, inputs].filter(Boolean).join('\n') ||
+                (names ? `Run on ${names}.` : '');
             return text
-                ? { send: text, inputs, clear: [] }
+                ? { send: text, inputs, clear: [], loop: loop(files.files) }
                 : { refused: `${app.name} has no inputs to run on: set one first.` };
         }
         default: {
@@ -315,6 +443,7 @@ export function appPageAction(app, event, read, lastInputs = '') {
                 send: changed ? `${written}\n\n${inputs}` : written,
                 inputs,
                 clear: message ? [] : [DRAFT.path],
+                loop: loop(),
             };
         }
     }

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

@@ -1,8 +1,44 @@
+/**
+ * `@datalayer/loop-plugin-app-page` — an application's page, as a plugin
+ * (LOOP R-01, R-01b).
+ *
+ * A chat, a widget or a worker runs as its conversation; its page — its
+ * A2UI surface, or the default page of its kind when none is composed — is
+ * contributed as the editor beside the chat (`LoopEditorView`), the place a
+ * notebook or a document takes in other workspaces. `AppRenderer` mounts it
+ * for an application that has one (`hasAppPage`) and opens the chat on it.
+ *
+ * What the page shows and takes, by kind, is `APP_KIND_PATHS`.
+ *
+ * A page the workspace does not draw itself — a decision's, whose page is
+ * its host's (the Studio's run page, its hosted address, its embed) — is
+ * contributed by the host through `defineAppHostPagePlugin`, as the
+ * workspace's one view (`LoopViewType`), in a workspace without a
+ * conversation (LOOP R-02).
+ *
+ * @module loop/plugins/app-page
+ */
+import type { ComponentType } from 'react';
 import { type ReactorPlugin } from '@datalayer/reactor';
 import type { AppSpec } from '../../../types/agentspecs';
+import { type LoopWorkspaceContext } from '../../core';
 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>;
+/** The view an application's page is, when its host draws it. */
+export declare const APP_HOST_PAGE_VIEW = "app-page";
+/** What a host's page is given: the application, and the workspace it is the view of. */
+export type AppHostPageProps = {
+    app: AppSpec;
+    workspace: LoopWorkspaceContext;
+};
+/**
+ * The plugin that makes a host's page the workspace's view (LOOP R-02): the
+ * page a host draws for an application whose kind the workspace has no page
+ * for — a decision's. The workspace opens on it; it is ordered before every
+ * other view.
+ */
+export declare function defineAppHostPagePlugin(app: AppSpec, Page: ComponentType<AppHostPageProps>): ReactorPlugin<Record<string, never>, unknown, unknown>;
 export { AppPage, type AppPageProps } from './AppPage';
 export * from './appPageModel';
 export default defineAppPagePlugin;

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

@@ -1,7 +1,7 @@
 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 { LoopEditorView, LoopViewType, } from '../../core';
 import { AppPage } from './AppPage';
 import { APP_PAGE_SURFACE } from './appPageModel';
 export const APP_PAGE_PLUGIN_NAME = '@datalayer/loop-plugin-app-page';
@@ -29,6 +29,37 @@ export function defineAppPagePlugin(app) {
     });
     return plugin;
 }
+/** The view an application's page is, when its host draws it. */
+export const APP_HOST_PAGE_VIEW = 'app-page';
+/**
+ * The plugin that makes a host's page the workspace's view (LOOP R-02): the
+ * page a host draws for an application whose kind the workspace has no page
+ * for — a decision's. The workspace opens on it; it is ordered before every
+ * other view.
+ */
+export function defineAppHostPagePlugin(app, Page) {
+    // One component per plugin: the view host keeps it, and the application with it.
+    function View({ workspace, }) {
+        return _jsx(Page, { 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 by its host.`,
+        octicon: 'browser',
+        emoji: app.emoji || undefined,
+        contributes: [
+            contribution(LoopViewType, {
+                viewType: APP_HOST_PAGE_VIEW,
+                title: app.name,
+                icon: BrowserIcon,
+                order: -10,
+                load: async () => ({ default: View }),
+            }, { id: APP_HOST_PAGE_VIEW, order: -10 }),
+        ],
+    });
+    return plugin;
+}
 export { AppPage } from './AppPage';
 export * from './appPageModel';
 export default defineAppPagePlugin;

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

@@ -39,7 +39,7 @@ import { useConfig } from '../../../hooks/useConfig';
 import { useSkills, useSkillActions } from '../../../hooks/useSkills';
 import { AI_MODEL_CATALOGUE, isChatModel } from '../../../specs/models';
 import { LoopAgentBlueprint, LoopAgentGate, LoopChatComposer, LoopChatExtras, LoopChatHeader, LoopChatLayout, LoopChatSuggestion, LoopChatSurface, LoopChatTurn, LoopFrontendTool, LoopSlots, canOpenView, onPromptFocusRequest, onSurfaceRequest, useLoopPromptStore, } from '../../core';
-import { turnWritersOf } from './turnState';
+import { messageText, turnWritersOf } from './turnState';
 import { isInactiveSurfaceContribution, orderToolContributions, toolsForChatView, } from './chatViewTools';
 import { useAgentCommandTools } from '../../../tools/adapters/commands';
 import { NONE_EDITOR, seedEditorChoice, setEditorOptions, } from '../shell/editorChoice';
@@ -225,6 +225,8 @@ export default function ChatView({ workspace }) {
         if (!feed) {
             return;
         }
+        // The whole conversation, for a page that shows it (a Chat block).
+        feed.items(items);
         const SETTLED = new Set([
             'complete',
             'completed',
@@ -315,24 +317,42 @@ export default function ChatView({ workspace }) {
                 break;
             }
         }
-        const textOf = (message) => {
-            const content = message.content;
-            return typeof content === 'string'
-                ? content
-                : content
-                    .map(part => typeof part === 'string'
-                    ? part
-                    : (part.text ?? ''))
-                    .join('');
-        };
         const reply = messages
             .slice(lastUser + 1)
             .filter(message => message.role === 'assistant')
-            .map(textOf)
+            .map(messageText)
             .filter(text => text.trim().length > 0)
             .join('\n\n');
         feed.assistant(reply);
     }, []);
+    const heldForAdapter = useRef([]);
+    /** Whether the agent is turned in this page: read by `sendNow`, set below. */
+    const inPageRef = useRef(false);
+    /*
+     * Every message that goes to the agent goes through here: the composer's
+     * (through the workspace's dispatch and the prompt channel), a host's, and
+     * one sent from the application's page (`viewControls.send`) — so each
+     * begins its turn, and a page reading the turn sees it asked and answered.
+     *
+     * What the page did besides the message goes with it as AG-UI's
+     * `forwardedProps` (`loop`, LOOP R-04): the application's session takes a
+     * file there. An agent turned in this page has no session, and no file is
+     * handed to it: said, rather than dropped.
+     */
+    const sendNow = useCallback((message, forwardedProps) => {
+        const loop = forwardedProps?.loop;
+        if (inPageRef.current && loop?.files && loop.files.length > 0) {
+            return 'A file is given to an application running on a runtime: run it on Datalayer or on your machine to give it one.';
+        }
+        // A new turn: whatever the panel showed is gone, this message is it.
+        turnFeedRef.current?.begin(message, controlsRef.current?.thread());
+        const send = controlsRef.current?.send;
+        if (!send) {
+            heldForAdapter.current.push([message, forwardedProps]);
+            return;
+        }
+        send(message, forwardedProps);
+    }, []);
     // One writer, so neither fact can erase the other.
     useEffect(() => {
         setViewControls(sendReady
@@ -340,10 +360,10 @@ export default function ChatView({ workspace }) {
                 busy,
                 stop: controlsRef.current?.stop,
                 newChat: controlsRef.current?.newChat,
-                send: controlsRef.current?.send,
+                send: sendNow,
             }
             : null);
-    }, [busy, sendReady, setViewControls]);
+    }, [busy, sendReady, setViewControls, sendNow]);
     // Stop reporting when the view goes away, or the shell would keep a stop
     // button for something that is no longer there.
     useEffect(() => () => setViewControls(null), [setViewControls]);
@@ -358,23 +378,15 @@ export default function ChatView({ workspace }) {
      * again. Held instead, and sent the moment the adapter is ready, which is
      * the next second or two rather than minutes.
      */
-    const heldForAdapter = useRef([]);
-    useEffect(() => workspace.prompts.subscribe(message => {
-        const send = controlsRef.current?.send;
-        if (!send) {
-            heldForAdapter.current.push(message);
-            return;
-        }
-        send(message);
-    }), [workspace.prompts]);
+    useEffect(() => workspace.prompts.subscribe(sendNow), [workspace.prompts, sendNow]);
     // The adapter arrived: whatever was said while it was starting goes now.
     useEffect(() => {
         if (!sendReady || heldForAdapter.current.length === 0) {
             return;
         }
         const held = heldForAdapter.current.splice(0, heldForAdapter.current.length);
-        for (const message of held) {
-            controlsRef.current?.send(message);
+        for (const [message, forwardedProps] of held) {
+            controlsRef.current?.send(message, forwardedProps);
         }
     }, [sendReady]);
     /*
@@ -397,8 +409,8 @@ export default function ChatView({ workspace }) {
             inputPromptConfig?.firstPromptHook?.();
         }
         setTransient(null);
-        // A new turn: whatever the panel showed is gone, this message is it.
-        turnFeedRef.current?.begin(message, controlsRef.current?.thread());
+        // The turn begins where the message goes out (`sendNow`): a command
+        // the workspace runs is not one.
         const outcome = await workspace.submit(message);
         if (!outcome.handled) {
             /*
@@ -628,6 +640,7 @@ export default function ChatView({ workspace }) {
      * for — so the location wins, which is the same rule the examples follow.
      */
     const inPage = targetRunsAgentInPage(workspace.sandbox.target ?? 'local');
+    inPageRef.current = inPage;
     /*
      * Who is being addressed, when this workspace runs a team.
      *
@@ -1115,7 +1128,13 @@ export default function ChatView({ workspace }) {
         })
         : {
             type: 'ag-ui',
-            endpoint: `${agentServerUrl}/api/v1/ag-ui/${agentId}/`,
+            // An application's agent is spoken to through its session API
+            // (LOOP R-04): each thread a session, recorded under its uid,
+            // run in the name the application runs in, and taking what the
+            // page did besides the message — the same AG-UI events back.
+            endpoint: blueprintTurn?.createPayload?.app_spec
+                ? `${agentServerUrl}/api/v1/apps/agents/${encodeURIComponent(agentId)}/ag-ui/`
+                : `${agentServerUrl}/api/v1/ag-ui/${agentId}/`,
             agentId,
             // `/api/v1/configure`, not `/api/v1/configure/config`: the hooks
             // strip one trailing `config`/`configure` segment to find the API

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

@@ -82,7 +82,12 @@ export const ChatPlugin = definePlugin({
      */
     build: ctx => {
         const feed = createTurnFeed();
-        ctx.contribute(LoopChatTurn, { id: 'chat-turn', turn: feed.turn, ...feedWriters(feed) }, { id: 'chat-turn' });
+        ctx.contribute(LoopChatTurn, {
+            id: 'chat-turn',
+            turn: feed.turn,
+            conversation: feed.conversation,
+            ...feedWriters(feed),
+        }, { id: 'chat-turn' });
         return {};
     },
     contributes: [

package/lib/loop/plugins/chat/turnState.d.ts

@@ -7,11 +7,17 @@
  * previous turn), `assistant` as the reply arrives, `end` when the agent
  * stops. Readers hold the signal.
  *
+ * Beside the turn, the whole conversation (`conversation`), for a page that
+ * shows it as the Chat component does: the chat view hands it every change
+ * of its items, streaming included.
+ *
  * @module loop/plugins/chat/turnState
  */
 import { type ReadonlySignal } from '@datalayer/reactor';
 import type { ContextSnapshotData } from '../../../types';
-import type { ChatTurnSnapshot, ChatTurnStatus } from '../../core';
+import type { DisplayItem } from '../../../types/chat';
+import type { ChatMessage } from '../../../types/messages';
+import type { ChatTurnSnapshot, ChatTurnStatus, ConversationEntry } from '../../core';
 export type TurnFeed = {
     /** The turn, for readers. */
     turn: ReadonlySignal<ChatTurnSnapshot>;
@@ -28,7 +34,20 @@ export type TurnFeed = {
     usage: (snapshot: ContextSnapshotData | undefined) => void;
     /** What the agent is doing now, or nothing. */
     activity: (label: string | undefined) => void;
+    /** The conversation, for readers. */
+    conversation: ReadonlySignal<ConversationEntry[]>;
+    /** The chat's items as they now stand, streaming included. */
+    items: (items: DisplayItem[]) => void;
 };
+/** A message's words, whether its content is a string or parts. */
+export declare function messageText(message: ChatMessage): string;
+/**
+ * The conversation as a page shows it: each person's and assistant's
+ * message with words in it, and each tool call by its name, its arguments
+ * and its result once it has one. A system message is the chat's own and is
+ * left out.
+ */
+export declare function conversationOf(items: DisplayItem[]): ConversationEntry[];
 export declare function createTurnFeed(): TurnFeed;
 /**
  * The writers, as extra fields on the contribution.