@datalayer/agent-runtimes 1.3.15 → 1.3.17

package/lib/loop/shell/LoopWorkspace.d.ts

@@ -103,6 +103,20 @@ export type LoopWorkspaceProps = {
      * through `LoopSlots.header`.
      */
     headerActions?: ReactNode;
+    /**
+     * Where the header's controls go, when not in a row of their own.
+     *
+     * A host that already draws a bar above the workspace — a window's title
+     * bar, a frame with its own tabs — hands over an element in it, and the
+     * controls the header would have carried (the host's `headerActions`, every
+     * plugin's `LoopSlots.header` contribution, the view switcher) are rendered
+     * there instead, and the workspace draws no header row. They stay inside
+     * the workspace's React tree, so they keep their context and their state.
+     *
+     * `null` while the host's element is not mounted yet: nothing is rendered,
+     * and no row is drawn in its place.
+     */
+    headerContainer?: HTMLElement | null;
 };
 /** Build the platform for a set of plugins. */
 export declare function buildLoopReactor(extensions: PluginRef[]): ReactorPlatform;

package/lib/loop/shell/LoopWorkspace.js

@@ -1,5 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
 import { Box } from '@primer/react';
 import { buildReactorFromPlugins, onView, } from '@datalayer/reactor';
 import { ReactorSlot, ReactorViewHost, useContributions, useReactorEvent, useSlotComponents, useReactor, } from '@datalayer/reactor/react';
@@ -11,21 +12,21 @@ export function buildLoopReactor(extensions) {
     return buildReactorFromPlugins(extensions);
 }
 export function LoopWorkspace(props) {
-    const { serverUrl, agentId, conversationId, model, sandbox = { state: 'idle' }, extensions = [], reactor: providedReactor, manageReactor = true, initialViewType, onSend, layout = 'page', showViewSelector = true, showHeader = true, chatHeaderActions, headerActions, } = props;
+    const { serverUrl, agentId, conversationId, model, sandbox = { state: 'idle' }, extensions = [], reactor: providedReactor, manageReactor = true, initialViewType, onSend, layout = 'page', showViewSelector = true, showHeader = true, chatHeaderActions, headerActions, headerContainer, } = props;
     // Building the platform is a one-time act: rebuilding it on every render
     // would restart every plugin.
     const reactor = useMemo(() => providedReactor ?? buildLoopReactor(extensions), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [providedReactor]);
     useReactor(reactor, { autoStart: manageReactor });
-    return (_jsx(WorkspaceBody, { serverUrl: serverUrl, agentId: agentId, conversationId: conversationId, model: model, initialSandbox: sandbox, initialViewType: initialViewType, onSend: onSend, layout: layout, showViewSelector: showViewSelector, showHeader: showHeader, chatHeaderActions: chatHeaderActions, headerActions: headerActions }));
+    return (_jsx(WorkspaceBody, { serverUrl: serverUrl, agentId: agentId, conversationId: conversationId, model: model, initialSandbox: sandbox, initialViewType: initialViewType, onSend: onSend, layout: layout, showViewSelector: showViewSelector, showHeader: showHeader, chatHeaderActions: chatHeaderActions, headerActions: headerActions, headerContainer: headerContainer }));
 }
 /**
  * Split from `LoopWorkspace` so the hooks below run with the platform already
  * registered — `useContributions` needs a reactor in the store, and `useReactor`
  * registers it during the parent's render.
  */
-function WorkspaceBody({ serverUrl, agentId: initialAgentId, conversationId, model, initialSandbox, initialViewType, onSend, layout = 'page', showViewSelector = true, showHeader = true, chatHeaderActions, headerActions, }) {
+function WorkspaceBody({ serverUrl, agentId: initialAgentId, conversationId, model, initialSandbox, initialViewType, onSend, layout = 'page', showViewSelector = true, showHeader = true, chatHeaderActions, headerActions, headerContainer, }) {
     /*
      * Which agent the session is talking to.
      *
@@ -146,6 +147,12 @@ function WorkspaceBody({ serverUrl, agentId: initialAgentId, conversationId, mod
     // activates whatever was waiting for it. A plugin that declares neither is
     // untouched, so this costs nothing until somebody uses it.
     useReactorEvent(effectiveViewType ? onView(effectiveViewType) : undefined);
+    /*
+     * The header's controls: the host's first, then the plugins', then the
+     * view switcher on the trailing edge. Drawn in the header row, or in the
+     * host's own bar when it handed one over (`headerContainer`).
+     */
+    const headerControls = (_jsxs(_Fragment, { children: [headerActions, _jsx(ReactorSlot, { slot: LoopSlots.header, props: { workspace } }), showViewSelector ? (_jsx(ViewSwitcher, { views: views, workspace: workspace, compact: compact })) : null] }));
     return (_jsxs(Box
     /*
       Marked so a plugin inside can find the workspace it is part of.
@@ -169,7 +176,14 @@ function WorkspaceBody({ serverUrl, agentId: initialAgentId, conversationId, mod
             position: 'relative',
             bg: 'canvas.default',
             color: 'fg.default',
-        }, children: [showHeader ? (_jsxs(Box, { as: "header", sx: {
+        }, children: [showHeader && headerContainer
+                ? createPortal(_jsx(Box, { sx: {
+                        display: 'flex',
+                        alignItems: 'center',
+                        flexWrap: 'wrap',
+                        gap: 2,
+                    }, children: headerControls }), headerContainer)
+                : null, showHeader && headerContainer === undefined ? (_jsx(Box, { as: "header", sx: {
                     display: 'flex',
                     alignItems: 'center',
                     // In a column there is no room for a row: the header wraps rather
@@ -191,7 +205,7 @@ function WorkspaceBody({ serverUrl, agentId: initialAgentId, conversationId, mod
                     borderBottom: '1px solid',
                     borderColor: 'border.default',
                     flex: '0 0 auto',
-                }, children: [headerActions, _jsx(ReactorSlot, { slot: LoopSlots.header, props: { workspace } }), showViewSelector ? (_jsx(ViewSwitcher, { views: views, workspace: workspace, compact: compact })) : null] })) : null, _jsxs(Box, { sx: { flex: '1 1 auto', minHeight: 0, display: 'flex' }, children: [_jsx(Box, { sx: {
+                }, children: headerControls })) : null, _jsxs(Box, { sx: { flex: '1 1 auto', minHeight: 0, display: 'flex' }, children: [_jsx(Box, { sx: {
                             flex: '1 1 auto',
                             minWidth: 0,
                             minHeight: 0,

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

@@ -6,5 +6,5 @@
 export { LoopWorkspace, buildLoopReactor, type LoopWorkspaceProps, } from './LoopWorkspace';
 export { ViewSwitcher, type ViewSwitcherProps } from './ViewSwitcher';
 export { PluginToggles, type PluginTogglesProps } from './PluginToggles';
-export { useWorkspaceFullScreen, type WorkspaceFullScreen, } from './useWorkspaceFullScreen';
+export { fullScreenNode, useWorkspaceFullScreen, type WorkspaceFullScreen, } from './useWorkspaceFullScreen';
 export { WorkspaceFullScreenAction } from './WorkspaceFullScreenAction';

package/lib/loop/shell/index.js

@@ -10,5 +10,5 @@
 export { LoopWorkspace, buildLoopReactor, } from './LoopWorkspace';
 export { ViewSwitcher } from './ViewSwitcher';
 export { PluginToggles } from './PluginToggles';
-export { useWorkspaceFullScreen, } from './useWorkspaceFullScreen';
+export { fullScreenNode, useWorkspaceFullScreen, } from './useWorkspaceFullScreen';
 export { WorkspaceFullScreenAction } from './WorkspaceFullScreenAction';

package/lib/loop/shell/useWorkspaceFullScreen.d.ts

@@ -79,15 +79,28 @@ export type WorkspaceFullScreenOptions = {
      */
     topOffset?: number | string;
 };
+/**
+ * What full screen promotes, found from the control that asked.
+ *
+ * The workspace (`[data-loop-workspace]`) — unless a host marked something
+ * around it with `data-loop-fullscreen-root`. A host that draws its own bar
+ * above the workspace and has the header's controls rendered in it
+ * (`LoopWorkspace`'s `headerContainer`) marks the element holding both: the
+ * controls are then outside the workspace, and promoting the workspace alone
+ * would leave them — the one that leaves full screen included — under the
+ * overlay. The anchor itself when there is neither.
+ */
+export declare function fullScreenNode(anchor: HTMLElement | null): HTMLElement | null;
 /**
  * Full-screen state and the toggle, anchored by any element inside the
  * workspace.
  *
  * The element promoted is the whole workspace — the nearest
- * `[data-loop-workspace]` above the anchor — so the header's controls come
- * along instead of being left on the page underneath. With no workspace
- * around it, the anchor's own element is promoted, which is what a view
- * mounted without a shell would want.
+ * `[data-loop-workspace]` above the anchor, or the host's
+ * `[data-loop-fullscreen-root]` around it (see `fullScreenNode`) — so the
+ * header's controls come along instead of being left on the page underneath.
+ * With neither around it, the anchor's own element is promoted, which is what
+ * a view mounted without a shell would want.
  */
 export declare function useWorkspaceFullScreen(anchorRef: RefObject<HTMLElement | null>, options?: WorkspaceFullScreenOptions): WorkspaceFullScreen;
 export default useWorkspaceFullScreen;

package/lib/loop/shell/useWorkspaceFullScreen.js

@@ -21,15 +21,32 @@ export function resolveTopOffset(offset) {
         ? Math.max(0, Math.round(element.getBoundingClientRect().bottom))
         : 0;
 }
+/**
+ * What full screen promotes, found from the control that asked.
+ *
+ * The workspace (`[data-loop-workspace]`) — unless a host marked something
+ * around it with `data-loop-fullscreen-root`. A host that draws its own bar
+ * above the workspace and has the header's controls rendered in it
+ * (`LoopWorkspace`'s `headerContainer`) marks the element holding both: the
+ * controls are then outside the workspace, and promoting the workspace alone
+ * would leave them — the one that leaves full screen included — under the
+ * overlay. The anchor itself when there is neither.
+ */
+export function fullScreenNode(anchor) {
+    return (anchor?.closest('[data-loop-fullscreen-root]') ??
+        anchor?.closest('[data-loop-workspace]') ??
+        anchor);
+}
 /**
  * Full-screen state and the toggle, anchored by any element inside the
  * workspace.
  *
  * The element promoted is the whole workspace — the nearest
- * `[data-loop-workspace]` above the anchor — so the header's controls come
- * along instead of being left on the page underneath. With no workspace
- * around it, the anchor's own element is promoted, which is what a view
- * mounted without a shell would want.
+ * `[data-loop-workspace]` above the anchor, or the host's
+ * `[data-loop-fullscreen-root]` around it (see `fullScreenNode`) — so the
+ * header's controls come along instead of being left on the page underneath.
+ * With neither around it, the anchor's own element is promoted, which is what
+ * a view mounted without a shell would want.
  */
 export function useWorkspaceFullScreen(anchorRef, options = {}) {
     const { forceOverlay = false, paintOverlay = false, topOffset = 0 } = options;
@@ -66,7 +83,7 @@ export function useWorkspaceFullScreen(anchorRef, options = {}) {
          * runs — so at full screen a reader would lose the two controls most
          * worth having room for.
          */
-        const node = anchorRef.current?.closest('[data-loop-workspace]') ?? anchorRef.current;
+        const node = fullScreenNode(anchorRef.current);
         if (fullScreen) {
             if (usingApi.current && document.fullscreenElement) {
                 void document.exitFullscreen();
@@ -116,7 +133,7 @@ export function useWorkspaceFullScreen(anchorRef, options = {}) {
         if (!paintOverlay || !fullScreen || usingApi.current) {
             return undefined;
         }
-        const node = anchorRef.current?.closest('[data-loop-workspace]') ?? anchorRef.current;
+        const node = fullScreenNode(anchorRef.current);
         if (!node) {
             return undefined;
         }

package/lib/specs/actions.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Action Classes.
+ *
+ * What every tool does to the world: read, write, send, buy, delete, publish.
+ * A tool with no class is unknown, and unknown is the most restricted.
+ *
+ * This file is AUTO-GENERATED from YAML specifications.
+ * DO NOT EDIT MANUALLY - run 'make specs' to regenerate.
+ */
+import type { ActionClass, AppBehaviour, AppEscalation, ServerActionsSpec } from '../types/agentspecs';
+/** The classes of action, from the one that changes nothing. */
+export declare const ACTION_CLASSES: ActionClass[];
+/** What each tool of the tools catalogue does, by id. */
+export declare const TOOL_ACTIONS: Record<string, ActionClass[]>;
+/**
+ * What each MCP server's tools do, by server id. `checked` is the day the
+ * names were read off the running server; absent when nobody looked.
+ */
+export declare const SERVER_ACTIONS: Record<string, ServerActionsSpec>;
+/**
+ * What each application of the catalogue does about each classed tool of the
+ * servers it connects to, as agentspecs decides it. What the rules engine has
+ * to reproduce.
+ */
+export declare const APP_BEHAVIOURS: Record<string, Record<string, AppBehaviour>>;
+/**
+ * Where what a tool is asked changes what an application does about it: by
+ * application and tool, each condition and the behaviour when it holds.
+ */
+export declare const APP_ESCALATIONS: Record<string, Record<string, AppEscalation[]>>;