@datalayer/agent-runtimes 1.3.36 → 1.3.38

package/lib/loop/core/index.d.ts

@@ -955,10 +955,29 @@ export type ChatTurnSnapshot = {
      */
     activity?: string;
 };
+/**
+ * One message of the conversation, as a page shows it (LOOP R-01, C-18): a
+ * person's or the assistant's words, or a tool the assistant called — what
+ * the Chat component draws, bound to a chat application's `/messages`.
+ */
+export type ConversationEntry = {
+    role: 'user' | 'assistant';
+    text: string;
+} | {
+    role: 'tool';
+    name: string;
+    args: Record<string, unknown>;
+    result?: unknown;
+};
 export type ChatTurnContribution = {
     /** Stable id, for the registry and the graph. */
     id: string;
     /** The turn, live. */
     turn: ReadonlySignal<ChatTurnSnapshot>;
+    /**
+     * The whole conversation, live: every message and tool call in order, the
+     * reply as it streams included; empty again when the chat starts over.
+     */
+    conversation: ReadonlySignal<ConversationEntry[]>;
 };
 export declare const LoopChatTurn: import("@datalayer/reactor").ContributionPoint<ChatTurnContribution>;

package/lib/loop/index.d.ts

@@ -15,7 +15,7 @@ export { ChatPlugin, CHAT_PLUGIN_NAME, type ChatPluginConfig, } from './plugins/
 export { ChatHeaderPlugin, CHAT_HEADER_PLUGIN_NAME, } from './plugins/chat-header';
 export { InputPromptPlugin, INPUT_PROMPT_PLUGIN_NAME, type InputPromptPluginConfig, } from './plugins/input-prompt';
 export { createChatExtrasPlugin, CHAT_EXTRAS_PLUGIN_NAME, type ChatExtrasHandle, } from './plugins/chat-extras';
-export { LoopChatExtras, LoopChatLayout, LoopChatTurn, LoopOpeningDocument, LoopOpeningNotebook, LoopPromptPanel, type ChatLayoutContribution, type ChatLayoutParts, type ChatTurnContribution, type ChatTurnSnapshot, type ChatTurnStatus, type LoopChatExtrasValue, type OpeningDocumentContribution, type OpeningNotebookContribution, type PromptPanelContribution, } from './core';
+export { LoopChatExtras, LoopChatLayout, LoopChatTurn, LoopOpeningDocument, LoopOpeningNotebook, LoopPromptPanel, type ChatLayoutContribution, type ChatLayoutParts, type ChatTurnContribution, type ConversationEntry, type ChatTurnSnapshot, type ChatTurnStatus, type LoopChatExtrasValue, type OpeningDocumentContribution, type OpeningNotebookContribution, type PromptPanelContribution, } from './core';
 export { LoopPageLayoutPlugin, LOOP_PAGE_LAYOUT_PLUGIN_NAME, openConversationPanel, pageLayoutSheet, pageLayoutPanelOpen, setPageLayoutChatMode, SplitLayout, type LoopPageLayoutConfig, } from './plugins/page-layout';
 export { useOptionalTeamSelection } from './plugins/agents/useTeamSelection';
 export type { TeamMember, TeamSelection } from './plugins/agents/team';

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

@@ -1,7 +1,8 @@
 /**
  * An application's page, drawn beside its conversation: its A2UI surface on
  * the workspace's own renderer (`InlineSurface`), fed by the chat's current
- * turn, its buttons answered through the chat's controls.
+ * turn and its conversation, its buttons — and a Chat block's message, a File
+ * upload's files — answered through the chat's controls.
  *
  * @module loop/plugins/app-page/AppPage
  */

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

@@ -8,11 +8,13 @@ import { InlineSurface, SURFACE_CATALOG_ID, } from '../a2ui-surface/InlineSurfac
 import { appPageAction, appPageData, appPageMessages } from './appPageModel';
 /** No chat in the workspace: the page reads a turn that never starts. */
 const NO_TURN = signal({ id: 0, status: 'idle' });
+const NO_CONVERSATION = signal([]);
 export function AppPage({ app, workspace }) {
     const entries = useContributions(LoopChatTurn);
     const turn = useSignalValue(entries[0]?.value.turn ?? NO_TURN);
+    const conversation = useSignalValue(entries[0]?.value.conversation ?? NO_CONVERSATION);
     const messages = useMemo(() => appPageMessages(app, SURFACE_CATALOG_ID), [app]);
-    const data = useMemo(() => appPageData(app, turn), [app, turn]);
+    const data = useMemo(() => appPageData(app, turn, conversation), [app, turn, conversation]);
     const [refusal, setRefusal] = useState(null);
     // The workspace changes as the chat reports itself; the handler reads the latest.
     const workspaceRef = useRef(workspace);

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

@@ -6,12 +6,13 @@
  * 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).
+ * sent with, until the session API carries a settings change (R-04), and so
+ * does a text file given to a widget, its contents in the message (E-01).
  *
  * 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 +22,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 +95,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 +107,22 @@ 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 most of a file's text a message carries: about thirty thousand
+ * tokens. A larger file is refused in a sentence rather than sent for the
+ * model to refuse.
+ */
+export declare const MAX_FILE_CHARACTERS = 120000;
+/**
+ * The files given on the page with their contents, for the message a widget
+ * is run with — or why one cannot go: it is not a file as File upload gives
+ * it, not text, or too long for a message.
+ */
+export declare function filesInWords(files: unknown): {
+    words: string;
+} | {
+    refused: string;
+};
 /** What a button asked, as the surface hands it over. */
 export type AppPageEvent = {
     name: string;

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}: a text file’s contents go with the next run.',
+    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 text 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,83 @@ export function inputsInWords(app, inputs) {
     }
     return lines.filter(Boolean).join('\n');
 }
+/**
+ * The most of a file's text a message carries: about thirty thousand
+ * tokens. A larger file is refused in a sentence rather than sent for the
+ * model to refuse.
+ */
+export const MAX_FILE_CHARACTERS = 120_000;
+/** The kinds of file read as text, besides `text/*`. */
+const TEXT_TYPES = new Set([
+    'application/json',
+    'application/xml',
+    'application/yaml',
+    'application/x-yaml',
+    'application/csv',
+]);
+/** The extensions read as text whatever type the browser gives. */
+const TEXT_EXTENSIONS = /\.(csv|tsv|txt|md|json|jsonl|xml|ya?ml|log)$/i;
+/** The words of a data URL, decoded as UTF-8. */
+function dataUrlText(dataUrl) {
+    const comma = dataUrl.indexOf(',');
+    if (!dataUrl.startsWith('data:') || comma < 0) {
+        throw new Error('it is not a data URL');
+    }
+    const body = dataUrl.slice(comma + 1);
+    if (!dataUrl.slice(0, comma).endsWith(';base64')) {
+        return decodeURIComponent(body);
+    }
+    const bytes = Uint8Array.from(atob(body), char => char.charCodeAt(0));
+    return new TextDecoder('utf-8').decode(bytes);
+}
+/**
+ * The files given on the page with their contents, for the message a widget
+ * is run with — or why one cannot go: it is not a file as File upload gives
+ * it, not text, or too long for a message.
+ */
+export function filesInWords(files) {
+    if (files === undefined || files === null) {
+        return { words: '' };
+    }
+    if (!Array.isArray(files)) {
+        return { refused: 'What was given as files is not a list of files.' };
+    }
+    const parts = [];
+    for (const [index, file] of files.entries()) {
+        const given = (file ?? {});
+        if (typeof given.name !== 'string' || typeof given.data_url !== 'string') {
+            return {
+                refused: `File ${index + 1} is not a file as File upload gives it ({name, type, size, data_url}).`,
+            };
+        }
+        const name = given.name;
+        const type = typeof given.type === 'string' ? given.type : '';
+        if (!type.startsWith('text/') &&
+            !TEXT_TYPES.has(type) &&
+            !TEXT_EXTENSIONS.test(name)) {
+            return {
+                refused: `${name} is not a text file: the page hands its application a file's text, in its message.`,
+            };
+        }
+        let text;
+        try {
+            text = dataUrlText(given.data_url);
+        }
+        catch (error) {
+            return {
+                refused: `${name} could not be read: ${error.message}.`,
+            };
+        }
+        if (text.length > MAX_FILE_CHARACTERS) {
+            return {
+                refused: `${name} is too long to send in a message: ${text.length.toLocaleString('en')} characters, at most ${MAX_FILE_CHARACTERS.toLocaleString('en')}.`,
+            };
+        }
+        const fence = text.includes('```') ? '~~~~' : '```';
+        parts.push(`The file ${name} (${type || 'text'}):\n${fence}\n${text.replace(/\n$/, '')}\n${fence}`);
+    }
+    return { words: parts.join('\n\n') };
+}
 /**
  * What a button pressed on the page does.
  *
@@ -298,8 +402,21 @@ export function appPageAction(app, event, read, lastInputs = '') {
             return { stop: true };
         case 'new':
             return { newChat: true };
-        case 'run': {
-            const text = [message, inputs].filter(Boolean).join('\n');
+        case 'run':
+        case 'upload': {
+            const given = event.context?.files;
+            const files = filesInWords(event.name === 'upload' && given !== undefined
+                ? given
+                : read(FILES.path));
+            if ('refused' in files) {
+                return files;
+            }
+            if (event.name === 'upload' && !files.words) {
+                return { refused: 'No file was given: choose one first.' };
+            }
+            const text = [[message, inputs].filter(Boolean).join('\n'), files.words]
+                .filter(Boolean)
+                .join('\n\n');
             return text
                 ? { send: text, inputs, clear: [] }
                 : { refused: `${app.name} has no inputs to run on: set one first.` };

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,31 @@ 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([]);
+    /*
+     * 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.
+     */
+    const sendNow = useCallback((message) => {
+        // 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);
+            return;
+        }
+        send(message);
+    }, []);
     // One writer, so neither fact can erase the other.
     useEffect(() => {
         setViewControls(sendReady
@@ -340,10 +349,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,15 +367,7 @@ 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) {
@@ -397,8 +398,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) {
             /*

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.

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

@@ -11,14 +11,70 @@
  * 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 { signal } from '@datalayer/reactor';
+/** A message's words, whether its content is a string or parts. */
+export function messageText(message) {
+    const content = message.content;
+    return typeof content === 'string'
+        ? content
+        : content
+            .map(part => typeof part === 'string'
+            ? part
+            : (part.text ?? ''))
+            .join('');
+}
+const isToolCall = (item) => item.type === 'tool-call';
+/**
+ * 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 function conversationOf(items) {
+    const entries = [];
+    for (const item of items) {
+        if (isToolCall(item)) {
+            entries.push({
+                role: 'tool',
+                name: item.toolName,
+                args: item.args ?? {},
+                ...(item.result === undefined ? {} : { result: item.result }),
+            });
+            continue;
+        }
+        if (item.role !== 'user' && item.role !== 'assistant') {
+            continue;
+        }
+        const text = messageText(item);
+        if (text.trim()) {
+            entries.push({ role: item.role, text });
+        }
+    }
+    return entries;
+}
+/** Whether two conversations say the same, entry by entry. */
+const sameConversation = (one, other) => one.length === other.length &&
+    one.every((entry, index) => JSON.stringify(entry) === JSON.stringify(other[index]));
 const IDLE = { id: 0, status: 'idle' };
 export function createTurnFeed() {
     const turn = signal(IDLE);
+    const conversation = signal([]);
     return {
         turn,
+        conversation,
+        items: items => {
+            const next = conversationOf(items);
+            // Nothing new: readers do not re-render for an identical conversation.
+            if (!sameConversation(conversation.value, next)) {
+                conversation.value = next;
+            }
+        },
         begin: (user, thread) => {
             // The window's fill carries over: it is the conversation's, not the
             // turn's, and the footer under a fresh turn should not read empty

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datalayer/agent-runtimes",
-    "version": "1.3.36",
+    "version": "1.3.38",
     "type": "module",
     "workspaces": [
         ".",