@dxos/plugin-script 0.7.5-labs.a279d8c → 0.7.5-labs.a8b535d

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/intent-resolver.ts

@@ -15,29 +15,32 @@ import { ScriptAction } from '../types';
 export default () =>
   contributes(
     Capabilities.IntentResolver,
-    createResolver(ScriptAction.Create, async ({ name, gistUrl, space }) => {
-      let content = templates[0].source;
-      const gistId = gistUrl?.split('/').at(-1);
-      if (gistId) {
-        // TODO(wittjosiah): Capability which contributes Octokit?
-        // NOTE: AccessToken not needed to read public gists.
-        const octokit = new Octokit();
-        const response = await octokit.request('GET /gists/{gist_id}', {
-          gist_id: gistId,
-        });
-        const gistContent = Object.values(response.data.files ?? {})[0]?.content;
-        if (gistContent) {
-          content = gistContent;
+    createResolver({
+      intent: ScriptAction.Create,
+      resolve: async ({ name, gistUrl }) => {
+        let content = templates[0].source;
+        const gistId = gistUrl?.split('/').at(-1);
+        if (gistId) {
+          // TODO(wittjosiah): Capability which contributes Octokit?
+          // NOTE: AccessToken not needed to read public gists.
+          const octokit = new Octokit();
+          const response = await octokit.request('GET /gists/{gist_id}', {
+            gist_id: gistId,
+          });
+          const gistContent = Object.values(response.data.files ?? {})[0]?.content;
+          if (gistContent) {
+            content = gistContent;
+          }
         }
-      }
 
-      return {
-        data: {
-          object: create(ScriptType, {
-            name,
-            source: makeRef(create(TextType, { content })),
-          }),
-        },
-      };
+        return {
+          data: {
+            object: create(ScriptType, {
+              name,
+              source: makeRef(create(TextType, { content })),
+            }),
+          },
+        };
+      },
     }),
   );

package/src/capabilities/react-surface.tsx

@@ -6,10 +6,12 @@ import React from 'react';
 
 import { Capabilities, contributes, createSurface, useCapability } from '@dxos/app-framework';
 import { ScriptType } from '@dxos/functions';
+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';
 
@@ -17,12 +19,10 @@ export default () =>
   contributes(Capabilities.ReactSurface, [
     createSurface({
       id: `${SCRIPT_PLUGIN}/settings`,
-      role: 'settings',
-      filter: (data): data is any => data.subject === SCRIPT_PLUGIN,
-      component: () => {
-        const settings = useCapability(Capabilities.SettingsStore).getStore<ScriptSettingsProps>(SCRIPT_PLUGIN)!.value;
-        return <ScriptSettings settings={settings} />;
-      },
+      role: 'article',
+      filter: (data): data is { subject: SettingsStore<ScriptSettingsProps> } =>
+        data.subject instanceof SettingsStore && data.subject.prefix === SCRIPT_PLUGIN,
+      component: ({ data: { subject } }) => <ScriptSettings settings={subject.value} />,
     }),
     createSurface({
       id: `${SCRIPT_PLUGIN}/article`,
@@ -30,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',
-      disposition: 'hoist',
+      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/ScriptSettings/ScriptSettings.tsx

@@ -8,7 +8,7 @@ import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { useClient } from '@dxos/react-client';
 import { Button, Select, useTranslation } from '@dxos/react-ui';
 import { type EditorInputMode, EditorInputModes } from '@dxos/react-ui-editor';
-import { DeprecatedFormInput } from '@dxos/react-ui-form';
+import { DeprecatedFormContainer, DeprecatedFormInput } from '@dxos/react-ui-form';
 
 import { SCRIPT_PLUGIN } from '../../meta';
 import { type ScriptSettingsProps } from '../../types';
@@ -39,7 +39,7 @@ export const ScriptSettings = ({ settings }: { settings: ScriptSettingsProps })
   };
 
   return (
-    <>
+    <DeprecatedFormContainer>
       {/* TODO(wittjosiah): Hide outside of dev environments. */}
       <DeprecatedFormInput label={t('authenticate action label')}>
         <Button onClick={handleAuthenticate}>{t('authenticate button label')}</Button>
@@ -66,6 +66,6 @@ export const ScriptSettings = ({ settings }: { settings: ScriptSettingsProps })
           </Select.Portal>
         </Select.Root>
       </DeprecatedFormInput>
-    </>
+    </DeprecatedFormContainer>
   );
 };

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);
@@ -114,6 +114,20 @@ export const ScriptSettingsPanel = ({ script }: ScriptSettingsPanelProps) => {
 
   return (
     <>
+      <div role='form' className='flex flex-col w-full p-2 gap-4'>
+        <Input.Root>
+          <div role='none' className='flex flex-col gap-1'>
+            <Input.Label>{t('description label')}</Input.Label>
+            <Input.TextInput
+              placeholder={t('description placeholder')}
+              value={script.description ?? ''}
+              onChange={(event) => {
+                script.description = event.target.value;
+              }}
+            />
+          </div>
+        </Input.Root>
+      </div>
       {fn && functionUrl && (
         <>
           <Separator />

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,
     }),
@@ -127,7 +127,7 @@ const createTooltipRenderer = (themeMode: ThemeMode) => {
 
   return (info: HoverInfo) => {
     const div = document.createElement('div');
-    div.className = 'p-1 rounded border border-separator bg-base xs:max-w-80 max-w-lg';
+    div.className = 'p-1 rounded border border-separator bg-baseSurface xs:max-w-80 max-w-lg';
 
     if (info.quickInfo?.displayParts) {
       for (const part of info.quickInfo.displayParts) {

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,12 +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;
+      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' };