@dxos/plugin-script 0.8.4-main.406dc2a → 0.8.4-main.548089c

package/src/components/NotebookContainer.tsx

@@ -2,15 +2,28 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useCallback, useMemo } from 'react';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import React, { useCallback, useMemo, useState } from 'react';
 
-import { Ref } from '@dxos/echo';
+import { Agent } from '@dxos/assistant-toolkit';
+import { Blueprint, Prompt } from '@dxos/blueprints';
+import { Filter, Obj, Query, Ref } from '@dxos/echo';
+import { QueryBuilder } from '@dxos/echo-query';
+import { type FunctionDefinition, FunctionInvocationService } from '@dxos/functions';
+import { InvocationTracer } from '@dxos/functions-runtime';
+import { TracingServiceExt } from '@dxos/functions-runtime';
 import { invariant } from '@dxos/invariant';
-import { Assistant } from '@dxos/plugin-assistant';
+import { log } from '@dxos/log';
+import { useComputeRuntimeCallback } from '@dxos/plugin-automation';
+import { Graph } from '@dxos/plugin-explorer/types';
 import { getSpace } from '@dxos/react-client/echo';
 import { DropdownMenu, IconButton, Toolbar, useTranslation } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
 import { StackItem } from '@dxos/react-ui-stack';
-import { DataType } from '@dxos/schema';
+import { Text } from '@dxos/schema';
+import { isNonNullable } from '@dxos/util';
 
 import { meta } from '../meta';
 import { ComputeGraph } from '../notebook';
@@ -19,6 +32,8 @@ import { type Notebook } from '../types';
 import { NotebookMenu, NotebookStack, type NotebookStackProps } from './NotebookStack';
 import { type TypescriptEditorProps } from './TypescriptEditor';
 
+const INCLUDE_BLUEPRINTS = ['dxos.org/blueprint/assistant', 'dxos.org/blueprint/markdown'];
+
 // TODO(burdon): Support calling named deployed functions (as with sheet).
 
 export type NotebookContainerProps = {
@@ -29,12 +44,85 @@ export type NotebookContainerProps = {
 export const NotebookContainer = ({ notebook, env }: NotebookContainerProps) => {
   const { t } = useTranslation(meta.id);
   const space = getSpace(notebook);
+  const attendableId = notebook ? Obj.getDXN(notebook).toString() : '';
+  const { hasAttention } = useAttention(attendableId);
+
+  // TODO(burdon): Consolidate execution and state (with graph).
+  //  Generalize ComputeGraph evaluation function (using effects).
   const graph = useMemo(() => notebook && new ComputeGraph(notebook), [notebook]);
 
+  const [queryValues, setQueryValues] = useState<Record<string, any>>({});
+  const handleExecQueries = useCallback(async () => {
+    invariant(space);
+
+    const builder = new QueryBuilder();
+    for (const cell of notebook?.cells ?? []) {
+      if (cell.type === 'query') {
+        if (cell.source?.target) {
+          const source = cell.source.target.content;
+          const { name, filter } = builder.build(source);
+          if (filter) {
+            const ast = Query.select(filter).ast;
+            const view = cell.view?.target;
+            if (!view) {
+              const graph = Graph.make({ query: { ast } });
+              const { view } = await Graph.makeView({
+                space,
+                presentation: graph,
+              });
+              cell.view = Ref.make(view);
+              cell.name = name;
+            } else {
+              view.query.ast = ast;
+            }
+          }
+        }
+
+        if (cell.name && cell.view?.target) {
+          const view = Obj.getSnapshot(cell.view?.target);
+          const query = Query.fromAst(view.query.ast);
+          const result = await space?.db.query(query).run();
+          const objectIds = result?.objects?.map((obj) => obj.id);
+          setQueryValues((prev) => ({ ...prev, [cell.name!]: objectIds }));
+        }
+      }
+    }
+  }, [space, notebook, graph]);
+
+  const [promptResults, setPromptResults] = useState<Record<string, string>>({});
+  const handleExecPrompts = useComputeRuntimeCallback(
+    space,
+    Effect.fnUntraced(function* () {
+      invariant(graph);
+
+      const prompts =
+        notebook?.cells
+          .filter((cell) => cell.type === 'prompt')
+          .map((cell) => cell.prompt)
+          .filter(isNonNullable) ?? [];
+
+      for (const prompt of prompts) {
+        yield* runPrompt({
+          prompt,
+          input: { ...queryValues, ...graph.valuesByName.value },
+          onResult: (result) =>
+            setPromptResults((prev) => ({
+              ...prev,
+              [prompt.dxn.toString()]: result,
+            })),
+        });
+      }
+    }),
+    [notebook, graph, queryValues],
+  );
+
   // TODO(burdon): Cache values in context (preserve when switched).
-  const handleCompute = useCallback(() => {
-    graph?.evaluate();
-  }, [graph]);
+  const handleCompute = useCallback(async () => {
+    // TODO(burdon): Generalize executors (dependencies).
+    await graph?.evaluate();
+    await handleExecQueries();
+    await handleExecPrompts();
+  }, [graph, handleExecQueries, handleExecPrompts]);
 
   const handleRearrange = useCallback<NonNullable<NotebookStackProps['onRearrange']>>(
     (source, target) => {
@@ -52,20 +140,24 @@ export const NotebookContainer = ({ notebook, env }: NotebookContainerProps) =>
   );
 
   const handleCellInsert = useCallback<NonNullable<NotebookStackProps['onCellInsert']>>(
-    (type, after) => {
+    async (type, after) => {
       invariant(notebook);
       const cell: Notebook.Cell = { id: crypto.randomUUID(), type };
       switch (type) {
         case 'markdown':
         case 'script':
         case 'query': {
-          cell.script = Ref.make(DataType.makeText());
+          cell.source = Ref.make(Text.make());
           break;
         }
 
         case 'prompt': {
           if (space) {
-            cell.chat = Ref.make(Assistant.makeChat({ queue: space.queues.create() }));
+            const result = await space.db.query(Query.select(Filter.type(Blueprint.Blueprint))).run();
+            const blueprints = result.objects
+              .filter((blueprint) => INCLUDE_BLUEPRINTS.includes(blueprint.key))
+              .map((blueprint) => Ref.make(blueprint));
+            cell.prompt = Ref.make(Prompt.make({ instructions: '', blueprints }));
           }
           break;
         }
@@ -90,7 +182,7 @@ export const NotebookContainer = ({ notebook, env }: NotebookContainerProps) =>
 
   return (
     <StackItem.Content toolbar>
-      <Toolbar.Root textBlockWidth>
+      <Toolbar.Root disabled={!hasAttention} textBlockWidth>
         <DropdownMenu.Root>
           <DropdownMenu.Trigger asChild>
             <IconButton icon='ph--plus--regular' iconOnly label={t('notebook cell insert label')} />
@@ -112,6 +204,7 @@ export const NotebookContainer = ({ notebook, env }: NotebookContainerProps) =>
           notebook={notebook}
           graph={graph}
           env={env}
+          promptResults={promptResults}
           onRearrange={handleRearrange}
           onCellInsert={handleCellInsert}
           onCellDelete={handleCellDelete}
@@ -122,3 +215,49 @@ export const NotebookContainer = ({ notebook, env }: NotebookContainerProps) =>
 };
 
 export default NotebookContainer;
+
+// TODO(wittjosiah): Factor out. Copied from PromptArticle in plugin-assistant.
+const runPrompt = Effect.fn(function* ({
+  prompt,
+  input,
+  onResult,
+}: {
+  prompt: Ref.Ref<Prompt.Prompt>;
+  input: Record<string, any>;
+  onResult: (result: string) => void;
+}) {
+  const inputData: FunctionDefinition.Input<typeof Agent.prompt> = {
+    prompt,
+    input,
+  };
+  const tracer = yield* InvocationTracer;
+  const trace = yield* tracer.traceInvocationStart({
+    target: undefined,
+    payload: {
+      data: {},
+    },
+  });
+
+  // Invoke the function.
+  const result = yield* FunctionInvocationService.invokeFunction(Agent.prompt, inputData).pipe(
+    Effect.provide(TracingServiceExt.layerQueue(trace.invocationTraceQueue)),
+    Effect.exit,
+  );
+
+  Exit.match(result, {
+    onFailure: (cause) => {
+      const error = Cause.prettyErrors(cause)[0];
+      log.error(error.message, error.cause ?? error.stack);
+      onResult(error.message);
+    },
+    onSuccess: (result: any) => {
+      onResult(result.note);
+    },
+  });
+
+  yield* tracer.traceInvocationEnd({
+    trace,
+    // TODO(dmaretskyi): Might miss errors.
+    exception: Exit.isFailure(result) ? Cause.prettyErrors(result.cause)[0] : undefined,
+  });
+});

package/src/components/NotebookStack/NotebookCell.tsx

@@ -4,18 +4,15 @@
 
 import React, { useCallback, useMemo } from 'react';
 
-import { Surface } from '@dxos/app-framework';
-import { Query, Ref } from '@dxos/echo';
-import { QueryBuilder } from '@dxos/echo-query';
+import { Surface } from '@dxos/app-framework/react';
 import { invariant } from '@dxos/invariant';
-import { useChatProcessor, useChatServices } from '@dxos/plugin-assistant';
-import { Chat } from '@dxos/plugin-assistant';
-import { Graph } from '@dxos/plugin-explorer/types';
+import { TemplateEditor } from '@dxos/plugin-assistant';
 import { createDocAccessor } from '@dxos/react-client/echo';
 import { type Space } from '@dxos/react-client/echo';
-import { useAsyncEffect, useThemeContext, useTranslation } from '@dxos/react-ui';
+import { useThemeContext, useTranslation } from '@dxos/react-ui';
 import { QueryEditor, type QueryEditorProps } from '@dxos/react-ui-components';
 import {
+  type BasicExtensionsOptions,
   Editor,
   type EditorProps,
   createBasicExtensions,
@@ -42,82 +39,51 @@ export type NotebookCellProps = {
   graph?: ComputeGraph;
   dragging?: boolean;
   cell: Notebook.Cell;
+  promptResults?: Record<string, string>;
 } & (Pick<NotebookMenuProps, 'onCellInsert' | 'onCellDelete'> & Pick<TypescriptEditorProps, 'env'>);
 
-// TODO(burdon): Display errors.
-export const NotebookCell = ({ space, graph, dragging, cell, env }: NotebookCellProps) => {
+// TODO(burdon): Show evaluation errors.
+export const NotebookCell = ({ space, graph, dragging, cell, promptResults, env }: NotebookCellProps) => {
   const { t } = useTranslation(meta.id);
 
-  //
-  // Common.
-  //
   const extensions = useMemo(() => {
-    return cell.script?.target
-      ? [createDataExtensions({ id: cell.id, text: createDocAccessor(cell.script.target, ['content']) })].filter(
-          isNonNullable,
-        )
+    return cell.source?.target
+      ? [
+          createDataExtensions({
+            id: cell.id,
+            text: createDocAccessor(cell.source.target, ['content']),
+          }),
+        ].filter(isNonNullable)
       : [];
-  }, [cell.script?.target]);
+  }, [cell.source?.target]);
 
-  //
-  // Query.
-  //
   const view = cell.view?.target;
-  const builder = useMemo(() => new QueryBuilder(), []);
-  useAsyncEffect(async () => {
-    if (!space || !cell.script?.target) {
-      return;
-    }
-
-    if (cell.type === 'query') {
-      const query = cell.script.target.content;
-      const filter = builder.build(query);
-      if (filter) {
-        const ast = Query.select(filter).ast;
-        const view = cell.view?.target;
-        if (!view) {
-          const graph = Graph.make({ query: { ast } });
-          const { view } = await Graph.makeView({ space, presentation: graph });
-          cell.view = Ref.make(view);
-        } else {
-          view.query.ast = ast;
-        }
-      }
-    }
-  }, [space, builder, cell, cell.script?.target?.content]);
 
   const handleQueryChange = useCallback<NonNullable<QueryEditorProps['onChange']>>(
     (value: string) => {
-      invariant(cell.script?.target);
-      cell.script.target.content = value;
+      invariant(cell.source?.target);
+      cell.source.target.content = value;
     },
     [cell],
   );
 
-  //
-  // Prompt.
-  // TODO(burdon): Add values to context or system message (via blueprint?).
-  //
-  const services = useChatServices({ space, chat: cell.chat?.target });
-  const processor = useChatProcessor({ chat: cell.chat?.target, services });
-
   switch (cell.type) {
     case 'markdown':
-      if (!cell.script?.target) {
+      if (!cell.source?.target) {
         return null;
       }
 
       return (
-        <MarkdownEditor
+        <NotebookTextEditor
           id={cell.id}
           classNames={editorStyles}
-          initialValue={cell.script.target.content}
+          initialValue={cell.source.target.content}
           extensions={extensions}
         />
       );
 
     case 'script':
-      if (!cell.script?.target) {
+      if (!cell.source?.target) {
         return null;
       }
 
@@ -127,7 +93,7 @@ export const NotebookCell = ({ space, graph, dragging, cell, env }: NotebookCell
             id={cell.id}
             role='section'
             classNames={editorStyles}
-            initialValue={cell.script.target.content}
+            initialValue={cell.source.target.content}
             extensions={extensions}
             env={env}
             options={{
@@ -141,33 +107,40 @@ export const NotebookCell = ({ space, graph, dragging, cell, env }: NotebookCell
       );
 
     case 'query':
-      if (!cell.script?.target) {
+      if (!cell.source?.target) {
         return null;
       }
 
+      // TODO(burdon): Remove app-framework deps (via render prop).
       return (
         <div className={mx('bs-full overflow-hidden grid', view && !dragging && 'grid-rows-[min-content_1fr]')}>
           <QueryEditor
             id={cell.id}
             classNames={[editorStyles, 'border-b border-subduedSeparator']}
             db={space?.db}
-            value={cell.script.target.content}
+            value={cell.source.target.content}
             onChange={handleQueryChange}
           />
           {view && !dragging && <Surface role='section' limit={1} data={{ subject: view }} />}
         </div>
       );
 
+    // TODO(burdon): Use streaming response from Chat.
     case 'prompt':
-      if (!cell.chat?.target || !processor) {
+      if (!cell.prompt?.target) {
         return null;
       }
 
       return (
-        <Chat.Root chat={cell.chat.target} processor={processor}>
-          <Chat.Thread overscroll={0} />
-          <Chat.Prompt settings={false} classNames='p-2 border-t border-subduedSeparator' />
-        </Chat.Root>
+        <>
+          <TemplateEditor
+            id={cell.id}
+            template={cell.prompt.target.instructions}
+            lineNumbers={false}
+            classNames={editorStyles}
+          />
+          <NotebookPromptResult cell={cell} promptResults={promptResults} />
+        </>
       );
 
     default:
@@ -177,7 +150,7 @@ export const NotebookCell = ({ space, graph, dragging, cell, env }: NotebookCell
 
 const NotebookCellValue = ({ cell, graph }: NotebookCellProps) => {
   const name = graph?.expressions.value[cell.id]?.name;
-  const value = graph?.values.value[cell.id];
+  const value = graph?.getValue(cell.id);
   if (value == null) {
     return null;
   }
@@ -200,12 +173,36 @@ const NotebookCellValue = ({ cell, graph }: NotebookCellProps) => {
   );
 };
 
-const MarkdownEditor = ({ extensions: extensionsParam, ...props }: EditorProps) => {
+const NotebookPromptResult = ({ cell, promptResults }: NotebookCellProps) => {
+  if (!cell.prompt) {
+    return null;
+  }
+
+  const value = promptResults?.[cell.prompt.dxn.toString()];
+  if (value == null) {
+    return null;
+  }
+
+  return (
+    <div className={mx('flex is-full bg-groupSurface text-description border-t border-subduedSeparator', valueStyles)}>
+      <NotebookTextEditor readOnly value={value} />
+    </div>
+  );
+};
+
+const NotebookTextEditor = ({
+  extensions: extensionsParam,
+  readOnly,
+  ...props
+}: EditorProps & Pick<BasicExtensionsOptions, 'readOnly'>) => {
   const { t } = useTranslation(meta.id);
   const { themeMode } = useThemeContext();
   const extensions = useMemo(() => {
     return [
-      createBasicExtensions({ placeholder: t('notebook markdown placeholder') }),
+      createBasicExtensions({
+        placeholder: t('notebook markdown placeholder'),
+        readOnly,
+      }),
       createThemeExtensions({ themeMode, syntaxHighlighting: true }),
       createMarkdownExtensions(),
       decorateMarkdown(),

package/src/components/NotebookStack/NotebookStack.stories.tsx

@@ -4,7 +4,11 @@
 
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 
-import { withClientProvider } from '@dxos/react-client/testing';
+import { IntentPlugin, SettingsPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AutomationPlugin } from '@dxos/plugin-automation';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { SpacePlugin } from '@dxos/plugin-space';
 import { withLayout, withTheme } from '@dxos/react-ui/testing';
 
 import { createNotebook } from '../../testing';
@@ -15,7 +19,25 @@ import { NotebookStack } from './NotebookStack';
 const meta = {
   title: 'plugins/plugin-script/NotebookStack',
   component: NotebookStack,
-  decorators: [withTheme, withLayout({ container: 'column', classNames: 'is-prose' }), withClientProvider()],
+  decorators: [
+    withTheme,
+    withLayout({ container: 'column', classNames: 'is-prose' }),
+    // TODO(burdon): Factor out Surface to avoid dependency on app-framework.
+    withPluginManager({
+      plugins: [
+        ClientPlugin({
+          onClientInitialized: async ({ client }) => {
+            await client.halo.createIdentity();
+            await client.spaces.waitUntilReady();
+          },
+        }),
+        SpacePlugin({}),
+        SettingsPlugin(),
+        IntentPlugin(),
+        AutomationPlugin(),
+      ],
+    }),
+  ],
   parameters: {
     translations,
   },

package/src/components/NotebookStack/NotebookStack.tsx

@@ -20,7 +20,7 @@ export type NotebookStackProps = ThemedClassName<
   {
     notebook?: Notebook.Notebook;
     onRearrange?: StackProps['onRearrange'];
-  } & (Pick<NotebookSectionProps, 'space' | 'graph' | 'onCellInsert' | 'onCellDelete'> &
+  } & (Pick<NotebookSectionProps, 'space' | 'graph' | 'promptResults' | 'onCellInsert' | 'onCellDelete'> &
     Pick<TypescriptEditorProps, 'env'>)
 >;
 
@@ -37,11 +37,18 @@ export const NotebookStack = ({ classNames, notebook, onRearrange, ...props }: N
 
 type NotebookSectionProps = NotebookCellProps;
 
-const NotebookSection = ({ cell, space, env, onCellInsert, onCellDelete, ...props }: NotebookSectionProps) => {
+const NotebookSection = ({
+  cell,
+  space,
+  env,
+  promptResults,
+  onCellInsert,
+  onCellDelete,
+  ...props
+}: NotebookSectionProps) => {
   const { t } = useTranslation(meta.id);
-  const resizable = cell.type === 'query' || cell.type === 'prompt';
+  const resizable = cell.type === 'query';
 
-  // TOOD(burdon): Set size if no extrinsic size (provider).
   return (
     <StackItem.Root role='section' item={cell} draggable classNames={resizable && minSectionHeight}>
       <StackItem.Heading classNames='bs-full p-1 justify-between attention-surface'>
@@ -72,7 +79,7 @@ const NotebookSection = ({ cell, space, env, onCellInsert, onCellDelete, ...prop
       </StackItem.DragPreview>
 
       <StackItem.Content classNames='overflow-visible'>
-        <NotebookCell space={space} cell={cell} env={env} {...props} />
+        <NotebookCell space={space} cell={cell} env={env} promptResults={promptResults} {...props} />
       </StackItem.Content>
     </StackItem.Root>
   );

package/src/components/ScriptContainer.tsx

@@ -4,7 +4,7 @@
 
 import React, { useMemo } from 'react';
 
-import { type ScriptType } from '@dxos/functions';
+import { type Script } from '@dxos/functions';
 import { createDocAccessor, getSpace } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { createDataExtensions, listener, stackItemContentEditorClassNames } from '@dxos/react-ui-editor';
@@ -18,7 +18,7 @@ import { TypescriptEditor, type TypescriptEditorProps } from './TypescriptEditor
 
 export type ScriptEditorProps = {
   role: string;
-  script: ScriptType;
+  script: Script.Script;
   settings?: ScriptSettings;
 } & Pick<TypescriptEditorProps, 'env'>;
 
@@ -33,7 +33,7 @@ export const ScriptContainer = ({ role, script, settings = { editorInputMode: 'v
       script.source.target
         ? [
             listener({
-              onChange: (text) => {
+              onChange: ({ text }) => {
                 if (script.source.target?.content !== text) {
                   script.changed = true;
                 }

package/src/components/ScriptToolbar/ScriptToolbar.stories.tsx

@@ -6,11 +6,9 @@ import { type Meta, type StoryObj } from '@storybook/react-vite';
 
 import { IntentPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
-import { Obj, Ref } from '@dxos/echo';
-import { ScriptType } from '@dxos/functions';
+import { Script } from '@dxos/functions';
 import { ClientPlugin } from '@dxos/plugin-client';
 import { withLayout, withTheme } from '@dxos/react-ui/testing';
-import { DataType } from '@dxos/schema';
 
 import { translations } from '../../translations';
 
@@ -23,7 +21,9 @@ const meta = {
   decorators: [
     withTheme,
     withLayout({ classNames: 'is-prose' }),
-    withPluginManager({ plugins: [IntentPlugin(), ClientPlugin({})] }),
+    withPluginManager({
+      plugins: [IntentPlugin(), ClientPlugin({})],
+    }),
   ],
   parameters: {
     layout: 'centered',
@@ -38,10 +38,10 @@ type Story = StoryObj<typeof meta>;
 export const Default: Story = {
   args: {
     state: {},
-    script: Obj.make(ScriptType, {
+    script: Script.make({
       name: 'test',
       description: 'test',
-      source: Ref.make(DataType.makeText('test')),
+      source: 'test',
     }),
   },
 };

package/src/components/ScriptToolbar/ScriptToolbar.tsx

@@ -2,12 +2,12 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
+import { Atom } from '@effect-atom/atom-react';
 import React, { useMemo } from 'react';
 
-import { type ScriptType } from '@dxos/functions';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
-import { ElevationProvider, type ThemedClassName, useTranslation } from '@dxos/react-ui';
+import { Obj } from '@dxos/echo';
+import { type Script } from '@dxos/functions';
+import { ElevationProvider, useTranslation } from '@dxos/react-ui';
 import {
   type ActionGraphProps,
   MenuProvider,
@@ -27,13 +27,13 @@ import {
 } from '../../hooks';
 import { meta } from '../../meta';
 
-export type ScriptToolbarProps = ThemedClassName<{
+export type ScriptToolbarProps = {
   role?: string;
-  script: ScriptType;
+  script: Script.Script;
   state: ScriptToolbarState;
-}>;
+};
 
-export const ScriptToolbar = ({ script, role, state, classNames }: ScriptToolbarProps) => {
+export const ScriptToolbar = ({ script, role, state }: ScriptToolbarProps) => {
   const { t } = useTranslation(meta.id);
   const options = useDeployDeps({ script });
   const menu = useMemo(() => createToolbarActions({ state, script, t, ...options }), [state, script, options, t]);
@@ -41,15 +41,15 @@ export const ScriptToolbar = ({ script, role, state, classNames }: ScriptToolbar
 
   return (
     <ElevationProvider elevation={role === 'section' ? 'positioned' : 'base'}>
-      <MenuProvider {...actions} attendableId={fullyQualifiedId(script)}>
-        <ToolbarMenu classNames={classNames} />
+      <MenuProvider {...actions} attendableId={Obj.getDXN(script).toString()}>
+        <ToolbarMenu />
       </MenuProvider>
     </ElevationProvider>
   );
 };
 
-const createToolbarActions = ({ state, script, ...options }: CreateDeployOptions): Rx.Rx<ActionGraphProps> =>
-  Rx.make((get) =>
+const createToolbarActions = ({ state, script, ...options }: CreateDeployOptions): Atom.Atom<ActionGraphProps> =>
+  Atom.make((get) =>
     get(
       rxFromSignal(() => {
         const templateSelect = createTemplateSelect(script);