@dxos/plugin-script 0.7.5-labs.e27f9b9 → 0.7.5-labs.f400bbc

package/src/capabilities/artifact-definition.ts

@@ -0,0 +1,224 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes, createIntent, type PromiseIntentDispatcher } from '@dxos/app-framework';
+import { defineArtifact, defineTool, ToolResult } from '@dxos/artifact';
+import { createArtifactElement } from '@dxos/assistant';
+import { ObjectId, S } from '@dxos/echo-schema';
+import { ScriptType } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { SpaceAction } from '@dxos/plugin-space/types';
+import { create, makeRef, type Space } from '@dxos/react-client/echo';
+import { TextType } from '@dxos/schema';
+
+import { meta } from '../meta';
+// TODO(burdon): Factor out.
+declare global {
+  interface ToolContextExtensions {
+    space?: Space;
+    dispatch?: PromiseIntentDispatcher;
+  }
+}
+
+export default () => {
+  const definition = defineArtifact({
+    id: meta.id,
+    name: meta.name,
+    // TODO(dmaretskyi): Since writing scripts requires a lot of domain knowledge,
+    //  we should offload the work of synthesizing the code to a separate model.
+    //  The main reasoning model will give it a concrete task and the script model will synthesize the code, knowing all the docs.
+    instructions: `
+      If the user explicitly requests you to write a script, you can create one.
+      If the user requests you to change one of the existing script, you can update it.
+      Scripts are short code pieces of executable code that can be used to perform computations, integrate with external systems, and perform automated tasks.
+      Each script must follow as strict shape for the definition but the body can contain any valid executable code.
+      Scripts are written in JavaScript or TypeScript.
+      Each script must define an input schema and output schema.
+      Each script must have its own detailed description.
+
+      Important: You cannot execute scripts. Scripts are only available as tools after the user deploys them. You must only call the available tools.
+
+      Description:
+        The description is a detailed description of the script.
+        It is used to describe the script's purpose, input, and output.
+        The description is used to generate the script's documentation.
+        The description is also goes into the script metadata.
+        The description is used by AI to understand the script and its purpose.
+        The description must provide cases on when the script should be used.
+
+      Schema: 
+        The schema is defined using a schema-DSL library called Effect Schema.
+        The input schema describes the arguments that the script accepts.
+        The output schema describes the result that the script produces.
+        The schema is used to validate the script's input and output.
+        The schema is also goes into the script metadata.
+        The properties in the schema must have valid descriptions.
+        The input and output schemas must both be a struct of fields.
+
+      Restricts:
+        The scripts can only import code from "dxos:functions" module. No other modules are allowed.
+        Some web APIs are available - like fetch.
+
+      Reasoning:
+        Before writing a script, synthesize the following information:
+        - Description
+        - What APIs will be used.
+        - Detailed input schema
+        - Detailed output schema
+
+      <apis>
+        export function defineFunction(params: { 
+          description: string, 
+          inputSchema: S.Schema, 
+          outputSchema: S.Schema, 
+          handler: (params: { event: { data: TInput } }) => Promise<TOutput> 
+        }): FunctionDefinition
+        /**
+         * Effect Schema
+         */
+        export const S; 
+
+        // Examples: 
+
+        S.String
+        S.Number
+        S.Boolean
+        S.Struct({
+          from: S.String.annotations({ description: 'The source currency' }),
+          to: S.String.annotations({ description: 'The target currency' }),
+        })
+        S.Array(S.String)
+        S.Union(S.String, S.Number)
+        S.optional(S.String)
+        S.String.annotations({ description: 'The source currency' })
+      </apis>
+
+      <handler_function>
+        Async function that takes the argument in the form of:
+
+        type HandlerFunctionParam = {
+          event: {
+            data: T // The input schema
+          },
+        }
+
+        The function must return the result that matches the output schema.
+      </handler_function>
+      
+      <example>
+        import { defineFunction, S } from 'dxos:functions';
+
+        export default defineFunction({
+          description: 'Returns the exchange rate between two currencies.',
+
+          inputSchema: S.Struct({
+            from: S.String.annotations({ description: 'The source currency' }),
+            to: S.String.annotations({ description: 'The target currency' }),
+          }),
+
+          outputSchema: S.Struct({
+            rate: S.String.annotations({ description: 'The exchange rate' }),
+          }),
+
+          handler: async ({
+            event: {
+              data: { from, to },
+            },
+          }: any) => {
+            const res = await fetch(\`https://free.ratesdb.com/v1/rates?from=\${from}&to=\${to}\`);
+            const {
+              data: { rates },
+            } = await res.json();
+
+            return { rate: rates[to].toString() };
+          },
+        });
+      </example>
+  `,
+    schema: ScriptType,
+    tools: [
+      defineTool(meta.id, {
+        name: 'create',
+        description: 'Create a new script. Returns the artifact definition for the script',
+        caption: 'Creating script...',
+        schema: S.Struct({
+          name: S.String.annotations({ description: 'The name of the script' }),
+          code: S.String.annotations({
+            description: 'The full code of the script in JavaScript or TypeScript. Must be valid executable code.',
+          }),
+        }),
+        execute: async ({ name, code }, { extensions }) => {
+          invariant(extensions?.space, 'No space');
+          invariant(extensions?.dispatch, 'No intent dispatcher');
+          const script = create(ScriptType, {
+            name,
+            source: makeRef(
+              create(TextType, {
+                content: code,
+              }),
+            ),
+          });
+          extensions.space.db.add(script);
+          await extensions.space.db.flush();
+
+          const intent = createIntent(SpaceAction.AddObject, { target: extensions.space, object: script });
+          const { data, error } = await extensions.dispatch(intent);
+          if (!data || error) {
+            return ToolResult.Error(error?.message ?? 'Failed to create chess game');
+          }
+
+          return ToolResult.Success(createArtifactElement(script.id));
+        },
+      }),
+      defineTool(meta.id, {
+        name: 'inspect',
+        description: 'Inspect a script. Returns the artifact definition for the script',
+        caption: 'Inspecting script...',
+        schema: S.Struct({
+          id: ObjectId,
+        }),
+        execute: async ({ id }, { extensions }) => {
+          invariant(extensions?.space, 'No space');
+
+          const script = (await extensions.space.db.query({ id }).first()) as ScriptType;
+          const { content } = await script.source.load();
+
+          return ToolResult.Success({
+            name: script.name,
+            code: content,
+          });
+        },
+      }),
+      defineTool(meta.id, {
+        name: 'update',
+        description: 'Update a script. Returns the artifact definition for the script',
+        caption: 'Updating script...',
+        schema: S.Struct({
+          id: ObjectId,
+          code: S.String.annotations({
+            description: 'The full code of the script in JavaScript or TypeScript. Must be valid executable code.',
+          }),
+        }),
+        execute: async ({ id, code }, { extensions }) => {
+          invariant(extensions?.space, 'No space');
+
+          const script = (await extensions.space.db.query({ id }).first()) as ScriptType;
+          const source = await script.source.load();
+          if (!source) {
+            return ToolResult.Error('Script not found');
+          }
+
+          source.content = code;
+          await extensions.space?.db.flush();
+
+          return ToolResult.Success({
+            name: script.name,
+          });
+        },
+      }),
+    ],
+  });
+
+  return contributes(Capabilities.ArtifactDefinition, definition);
+};

package/src/capabilities/compiler.ts

@@ -6,9 +6,9 @@
 import wasmUrl from 'esbuild-wasm/esbuild.wasm?url';
 
 import { contributes } from '@dxos/app-framework';
+import { initializeBundler } from '@dxos/functions/bundler';
 
 import { ScriptCapabilities } from './capabilities';
-import { initializeBundler } from '../bundler';
 import { Compiler } from '../compiler';
 
 export default async () => {

package/src/capabilities/index.ts

@@ -8,5 +8,6 @@ export const Compiler = lazy(() => import('./compiler'));
 export const IntentResolver = lazy(() => import('./intent-resolver'));
 export const ReactSurface = lazy(() => import('./react-surface'));
 export const ScriptSettings = lazy(() => import('./settings'));
+export const ArtifactDefinition = lazy(() => import('./artifact-definition'));
 
 export * from './capabilities';

package/src/capabilities/react-surface.tsx

@@ -10,7 +10,8 @@ import { SettingsStore } from '@dxos/local-storage';
 import { Clipboard } from '@dxos/react-ui';
 
 import { ScriptCapabilities } from './capabilities';
-import { AutomationPanel, ScriptSettings, ScriptContainer, ScriptSettingsPanel } from '../components';
+import { DebugPanel, ScriptSettings, ScriptContainer, ScriptSettingsPanel } from '../components';
+import { useDeployState, useToolbarState } from '../hooks';
 import { SCRIPT_PLUGIN } from '../meta';
 import { type ScriptSettingsProps } from '../types';
 
@@ -29,16 +30,22 @@ export default () =>
       filter: (data): data is { subject: ScriptType } => data.subject instanceof ScriptType,
       component: ({ data, role }) => {
         const compiler = useCapability(ScriptCapabilities.Compiler);
-        const settings = useCapability(Capabilities.SettingsStore).getStore<ScriptSettingsProps>(SCRIPT_PLUGIN)!.value;
+        // TODO(dmaretskyi): Since settings store is not reactive, this would break on the script plugin being enabled without a page reload.
+        const settings = useCapability(Capabilities.SettingsStore).getStore<ScriptSettingsProps>(SCRIPT_PLUGIN)?.value;
         return <ScriptContainer role={role} script={data.subject} settings={settings} env={compiler.environment} />;
       },
     }),
     createSurface({
       id: `${SCRIPT_PLUGIN}/automation`,
-      role: 'complementary--automation',
+      role: 'complementary--function',
       position: 'hoist',
       filter: (data): data is { subject: ScriptType } => data.subject instanceof ScriptType,
-      component: ({ data }) => <AutomationPanel subject={data.subject} />,
+      component: ({ data }) => {
+        // TODO(wittjosiah): Decouple hooks from toolbar state.
+        const state = useToolbarState({ view: 'editor' });
+        useDeployState({ state, script: data.subject });
+        return <DebugPanel functionUrl={state.functionUrl} />;
+      },
     }),
     createSurface({
       id: `${SCRIPT_PLUGIN}/settings-panel`,

package/src/components/DebugPanel/DebugPanel.tsx

@@ -7,7 +7,7 @@ import React, { forwardRef, useEffect, useRef, useState } from 'react';
 import { log } from '@dxos/log';
 import { Avatar, Icon, Input, type ThemedClassName, Toolbar, useTranslation } from '@dxos/react-ui';
 import { SyntaxHighlighter } from '@dxos/react-ui-syntax-highlighter';
-import { mx } from '@dxos/react-ui-theme';
+import { errorText, mx } from '@dxos/react-ui-theme';
 
 import { SCRIPT_PLUGIN } from '../../meta';
 
@@ -232,7 +232,7 @@ const MessageItem = ({ classNames, message }: ThemedClassName<{ message: Message
   const wrapper = 'p-1 px-2 rounded-lg bg-hoverSurface overflow-auto';
   return (
     <div className={mx('flex', type === 'request' ? 'ml-[1rem] justify-end' : 'mr-[1rem]', classNames)}>
-      {error && <div className={mx(wrapper, 'whitespace-pre text-error')}>{String(error)}</div>}
+      {error && <div className={mx(wrapper, 'whitespace-pre', errorText)}>{String(error)}</div>}
 
       {text !== undefined && (
         <div className={mx(wrapper, type === 'request' && 'bg-primary-400 dark:bg-primary-600')}>

package/src/components/FrameContainer/FrameContainer.tsx

@@ -5,17 +5,17 @@
 import React, { useEffect, useRef } from 'react';
 
 import { clientServiceBundle } from '@dxos/client-protocol';
+import { type BundleResult } from '@dxos/functions/bundler';
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { useClient } from '@dxos/react-client';
 import { baseSurface, mx } from '@dxos/react-ui-theme';
 import { createProtoRpcPeer } from '@dxos/rpc';
 import { createIFramePort } from '@dxos/rpc-tunnel';
 
-import { type BundlerResult } from '../../bundler';
-
 export type FrameContainerProps = {
   containerUrl: string;
-  result: BundlerResult;
+  result: BundleResult;
   debug?: boolean;
 };
 
@@ -46,6 +46,7 @@ export const FrameContainer = ({ containerUrl, result, debug = true }: FrameCont
   }, [iframeRef]);
 
   // Encodes compiled code via URL.
+  invariant(result.sourceHash, 'Source hash is required.');
   const sourceHash = Buffer.from(result.sourceHash).toString('hex');
   const src = result.bundle && `${containerUrl}?ts=${sourceHash}#code=${encodeURIComponent(result.bundle)}`;
 
@@ -58,7 +59,7 @@ export const FrameContainer = ({ containerUrl, result, debug = true }: FrameCont
           <div
             className={mx(
               baseSurface,
-              'flex absolute right-2 bottom-2 w-[400px] h-[200px] ring rounded',
+              'flex absolute right-2 bottom-2 w-[30rem] h-[200px] ring rounded',
               'z-20 overflow-x-hidden overflow-y-auto',
             )}
           >

package/src/components/ScriptContainer.tsx

@@ -14,19 +14,24 @@ import { mx } from '@dxos/react-ui-theme';
 
 import { DebugPanel } from './DebugPanel';
 import { ScriptToolbar } from './ScriptToolbar';
-import { useDeployState } from './ScriptToolbar/deploy';
-import { useToolbarState } from './ScriptToolbar/useToolbarState';
 import { TypescriptEditor, type TypescriptEditorProps } from './TypescriptEditor';
+import { useDeployState, useToolbarState } from '../hooks';
 import { type ScriptSettingsProps } from '../types';
 
 export type ScriptEditorProps = ThemedClassName<{
   script: ScriptType;
-  settings: ScriptSettingsProps;
+  settings?: ScriptSettingsProps;
   role?: string;
 }> &
   Pick<TypescriptEditorProps, 'env'>;
 
-export const ScriptContainer = ({ role, classNames, script, settings, env }: ScriptEditorProps) => {
+export const ScriptContainer = ({
+  role,
+  classNames,
+  script,
+  settings = { editorInputMode: 'vscode' },
+  env,
+}: ScriptEditorProps) => {
   const identity = useIdentity();
   const space = getSpace(script);
 
@@ -49,7 +54,7 @@ export const ScriptContainer = ({ role, classNames, script, settings, env }: Scr
     [script, script.source.target, space, identity],
   );
 
-  const state = useToolbarState({ view: 'split' });
+  const state = useToolbarState({ view: 'editor' });
   useDeployState({ state, script });
 
   return (

package/src/components/ScriptSettingsPanel.tsx

@@ -10,7 +10,7 @@ import { FunctionType, type ScriptType, getInvocationUrl, getUserFunctionUrlInMe
 import { log } from '@dxos/log';
 import { useClient } from '@dxos/react-client';
 import { Filter, getMeta, getSpace, useQuery } from '@dxos/react-client/echo';
-import { Button, Clipboard, Input, Separator, useControlledValue, useTranslation } from '@dxos/react-ui';
+import { Button, Clipboard, Input, Separator, useControlledState, useTranslation } from '@dxos/react-ui';
 import { AccessTokenType } from '@dxos/schema';
 
 import { SCRIPT_PLUGIN } from '../meta';
@@ -57,7 +57,7 @@ export const ScriptSettingsPanel = ({ script }: ScriptSettingsPanelProps) => {
     return () => clearTimeout(timeout);
   }, [githubToken, gistKey]);
 
-  const [binding, setBinding] = useControlledValue(fn?.binding ?? '');
+  const [binding, setBinding] = useControlledState(fn?.binding ?? '');
   const handleBindingChange = useCallback(
     (event: ChangeEvent<HTMLInputElement>) => {
       setBinding(event.target.value);

package/src/components/ScriptToolbar/ScriptToolbar.tsx

@@ -10,12 +10,14 @@ import { ElevationProvider, type ThemedClassName } from '@dxos/react-ui';
 import { stackItemContentToolbarClassNames } from '@dxos/react-ui-editor';
 import { createGapSeparator, MenuProvider, ToolbarMenu, useMenuActions } from '@dxos/react-ui-menu';
 
-import { createDeploy } from './deploy';
-import { createFormat } from './format';
-import { createTemplateSelect } from './templateSelect';
-import { useToolbarAction } from './useToolbarAction';
-import { type ScriptToolbarState } from './useToolbarState';
-import { createView } from './view';
+import {
+  type ScriptToolbarState,
+  createDeploy,
+  createFormat,
+  createTemplateSelect,
+  createView,
+  useToolbarAction,
+} from '../../hooks';
 
 export type ScriptToolbarProps = ThemedClassName<{
   role?: string;

package/src/components/TypescriptEditor/TypescriptEditor.tsx

@@ -27,7 +27,7 @@ import {
   useTextEditor,
   type UseTextEditorProps,
 } from '@dxos/react-ui-editor';
-import { nonNullable } from '@dxos/util';
+import { isNonNullable } from '@dxos/util';
 
 export type TypescriptEditorProps = {
   id: string;
@@ -94,7 +94,7 @@ export const TypescriptEditor = ({
               ]
             : [],
         ],
-      ].filter(nonNullable),
+      ].filter(isNonNullable),
       selection,
       scrollTo,
     }),

package/src/components/index.ts

@@ -4,8 +4,8 @@
 
 import { lazy } from 'react';
 
+export * from './DebugPanel';
 export * from './ScriptSettings';
 export * from './ScriptSettingsPanel';
 
-export const AutomationPanel = lazy(() => import('./AutomationPanel'));
 export const ScriptContainer = lazy(() => import('./ScriptContainer'));

package/src/events.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { defineEvent } from '@dxos/app-framework';
+
+import { SCRIPT_PLUGIN } from './meta';
+
+export namespace ScriptEvents {
+  export const SetupCompiler = defineEvent(`${SCRIPT_PLUGIN}/event/setup-compiler`);
+}

package/src/{components/ScriptToolbar → hooks}/deploy.ts

@@ -6,13 +6,14 @@ import { useCallback, useEffect, useMemo } from 'react';
 
 import {
   FunctionType,
+  type ScriptType,
   getInvocationUrl,
   getUserFunctionUrlInMetadata,
   incrementSemverPatch,
-  type ScriptType,
   setUserFunctionUrlInMetadata,
   uploadWorkerFunction,
 } from '@dxos/functions';
+import { Bundler } from '@dxos/functions/bundler';
 import { log } from '@dxos/log';
 import { useClient } from '@dxos/react-client';
 import { Filter, create, getMeta, getSpace, makeRef, useQuery } from '@dxos/react-client/echo';
@@ -20,8 +21,7 @@ import { useTranslation } from '@dxos/react-ui';
 import { createMenuAction } from '@dxos/react-ui-menu';
 
 import { type ViewState } from './view';
-import { Bundler } from '../../bundler';
-import { SCRIPT_PLUGIN } from '../../meta';
+import { SCRIPT_PLUGIN } from '../meta';
 
 export type DeployActionProperties = { type: 'deploy' } | { type: 'copy' };
 
@@ -105,7 +105,7 @@ export const useDeployHandler = ({ state, script }: { state: Partial<DeployState
       const existingFunctionId = existingFunctionUrl?.split('/').at(-1);
 
       const bundler = new Bundler({ platform: 'browser', sandboxedModules: [], remoteModules: {} });
-      const buildResult = await bundler.bundle(script.source.target!.content);
+      const buildResult = await bundler.bundle({ source: script.source.target!.content });
       if (buildResult.error || !buildResult.bundle) {
         throw buildResult.error;
       }
@@ -130,13 +130,24 @@ export const useDeployHandler = ({ state, script }: { state: Partial<DeployState
         fn ?? space.db.add(create(FunctionType, { name: functionId, version, source: makeRef(script) }));
 
       script.changed = false;
-      deployedFunction.description = script.description;
+      if (script.description !== undefined && script.description.trim() !== '') {
+        deployedFunction.description = script.description;
+      } else if (meta.description) {
+        deployedFunction.description = meta.description;
+      } else {
+        log.verbose('no description in function metadata', { functionId });
+      }
 
       if (meta.inputSchema) {
         deployedFunction.inputSchema = meta.inputSchema;
       } else {
         log.verbose('no input schema in function metadata', { functionId });
       }
+      if (meta.outputSchema) {
+        deployedFunction.outputSchema = meta.outputSchema;
+      } else {
+        log.verbose('no output schema in function metadata', { functionId });
+      }
 
       setUserFunctionUrlInMetadata(getMeta(deployedFunction), `/${space.id}/${functionId}`);
 

package/src/{components/ScriptToolbar → hooks}/format.ts

@@ -11,7 +11,7 @@ import { type ScriptType } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { createMenuAction } from '@dxos/react-ui-menu';
 
-import { SCRIPT_PLUGIN } from '../../meta';
+import { SCRIPT_PLUGIN } from '../meta';
 
 export type FormatActionProperties = { type: 'format' };
 

package/src/hooks/index.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './deploy';
+export * from './format';
+export * from './template';
+export * from './view';
+
+export * from './useToolbarAction';
+export * from './useToolbarState';

package/src/{components/ScriptToolbar/templateSelect.ts → hooks/template.ts}

@@ -8,8 +8,8 @@ import { FUNCTIONS_PRESET_META_KEY, type ScriptType } from '@dxos/functions';
 import { getMeta } from '@dxos/live-object';
 import { createMenuItemGroup, createMenuAction } from '@dxos/react-ui-menu';
 
-import { SCRIPT_PLUGIN } from '../../meta';
-import { templates } from '../../templates';
+import { SCRIPT_PLUGIN } from '../meta';
+import { templates } from '../templates';
 
 export type TemplateActionProperties = { type: 'template'; value: string };
 

package/src/{components/ScriptToolbar → hooks}/useToolbarAction.ts

@@ -10,7 +10,7 @@ import { type MenuAction, type MenuActionHandler } from '@dxos/react-ui-menu';
 
 import { type DeployActionProperties, useDeployHandler, useCopyHandler } from './deploy';
 import { type FormatActionProperties, useFormatHandler } from './format';
-import { type TemplateActionProperties, useTemplateSelectHandler } from './templateSelect';
+import { type TemplateActionProperties, useTemplateSelectHandler } from './template';
 import { type ScriptToolbarState } from './useToolbarState';
 import { type ViewActionProperties } from './view';
 

package/src/{components/ScriptToolbar → hooks}/view.ts

@@ -4,9 +4,10 @@
 
 import { createMenuAction, createMenuItemGroup } from '@dxos/react-ui-menu';
 
-import { SCRIPT_PLUGIN } from '../../meta';
+import { SCRIPT_PLUGIN } from '../meta';
 
-export type ViewType = 'editor' | 'split' | 'debug';
+// TODO(wittjosiah): Replace debug with logs.
+export type ViewType = 'editor' | 'split' | 'debug'; // 'logs';
 
 export type ViewState = { view: ViewType };
 
@@ -16,6 +17,8 @@ const views: Record<ViewType, string> = {
   editor: 'ph--code--regular',
   split: 'ph--square-split-vertical--regular',
   debug: 'ph--bug--regular',
+  // TODO(wittjosiah): Replace debug with logs.
+  // logs: 'ph--clock-counter-clockwise--regular',
 };
 
 const createViewGroupItem = (state: Partial<ViewState>) => {

package/src/index.ts

@@ -2,7 +2,6 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './bundler';
 export { ScriptCapabilities } from './capabilities';
 export * from './components';
 export * from './meta';

package/src/meta.ts

@@ -9,8 +9,10 @@ export const SCRIPT_PLUGIN = 'dxos.org/plugin/script';
 export const meta = {
   id: SCRIPT_PLUGIN,
   name: 'Scripts',
-  description: 'Distributed functions.',
+  description:
+    'Scripts in Composer allow you to deploy custom functions that run on the edge. These functions can be referenced by your AI agent and called inside of cells in any Sheet. Use scripts to interact with API’s or external data inside of Composer.',
   icon: 'ph--code--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/experimental/plugin-explorer',
   tags: ['experimental'],
+  screenshots: ['https://dxos.network/plugin-details-scripts-dark.png'],
 } satisfies PluginMeta;

package/src/templates/chat.ts

@@ -57,11 +57,11 @@ export default async ({
   let prompt = promptObject.template;
   for (const input of promptObject.inputs) {
     let value: string | null = null;
-    if (input.type === ChainInputType.VALUE) {
+    if (input.type === TemplateInputType.VALUE) {
       value = String(input.value);
-    } else if (input.type === ChainInputType.RETRIEVER) {
+    } else if (input.type === TemplateInputType.RETRIEVER) {
       value = await getContext({ space });
-    } else if (input.type === ChainInputType.PASS_THROUGH) {
+    } else if (input.type === TemplateInputType.PASS_THROUGH) {
       value = message.text;
     }
     if (value) {
@@ -90,7 +90,7 @@ const getContext = async ({ space }: any) => {
   return context;
 };
 
-enum ChainInputType {
+enum TemplateInputType {
   VALUE = 0,
   PASS_THROUGH = 1,
   RETRIEVER = 2,