@dxos/plugin-script 0.8.4-main.406dc2a → 0.8.4-main.52d7546f51

package/src/components/Settings/ScriptPluginSettings.tsx

@@ -6,14 +6,19 @@ import React from 'react';
 
 import { useClient } from '@dxos/react-client';
 import { Button, Select, useTranslation } from '@dxos/react-ui';
-import { type EditorInputMode, EditorInputModes } from '@dxos/react-ui-editor';
-import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from '@dxos/react-ui-form';
+import { Settings } from '@dxos/react-ui-form';
+import { type EditorInputMode, EditorInputModes } from '@dxos/ui-editor';
 
 import { meta } from '../../meta';
 import { type ScriptSettings } from '../../types';
 import { getAccessCredential } from '../../util';
 
-export const ScriptPluginSettings = ({ settings }: { settings: ScriptSettings }) => {
+export type ScriptPluginSettingsComponentProps = {
+  settings: ScriptSettings;
+  onSettingsChange: (fn: (current: ScriptSettings) => ScriptSettings) => void;
+};
+
+export const ScriptPluginSettings = ({ settings, onSettingsChange }: ScriptPluginSettingsComponentProps) => {
   const { t } = useTranslation(meta.id);
   const client = useClient();
 
@@ -24,19 +29,19 @@ export const ScriptPluginSettings = ({ settings }: { settings: ScriptSettings })
   };
 
   return (
-    <ControlPage>
-      <ControlSection title={t('settings title', { ns: meta.id })}>
-        <ControlGroup>
+    <Settings.Root>
+      <Settings.Section title={t('settings title', { ns: meta.id })}>
+        <Settings.Group>
           {/* TODO(wittjosiah): Hide outside of dev environments. */}
-          <ControlItemInput title={t('authenticate action label')}>
+          <Settings.ItemInput title={t('authenticate action label')}>
             <Button onClick={handleAuthenticate}>{t('authenticate button label')}</Button>
-          </ControlItemInput>
+          </Settings.ItemInput>
 
-          <ControlItemInput title={t('editor input mode label')}>
+          <Settings.ItemInput title={t('editor input mode label')}>
             <Select.Root
               value={settings.editorInputMode ?? 'default'}
               onValueChange={(value) => {
-                settings.editorInputMode = value as EditorInputMode;
+                onSettingsChange((s) => ({ ...s, editorInputMode: value as EditorInputMode }));
               }}
             >
               <Select.TriggerButton placeholder={t('select editor input mode placeholder')} />
@@ -53,9 +58,9 @@ export const ScriptPluginSettings = ({ settings }: { settings: ScriptSettings })
                 </Select.Content>
               </Select.Portal>
             </Select.Root>
-          </ControlItemInput>
-        </ControlGroup>
-      </ControlSection>
-    </ControlPage>
+          </Settings.ItemInput>
+        </Settings.Group>
+      </Settings.Section>
+    </Settings.Root>
   );
 };

package/src/components/TestPanel/TestContainer.tsx

@@ -4,8 +4,8 @@
 
 import React from 'react';
 
-import { type ScriptType } from '@dxos/functions';
-import { StackItem } from '@dxos/react-ui-stack';
+import { type Script } from '@dxos/functions';
+import { Layout } from '@dxos/react-ui';
 
 import { useDeployState, useToolbarState } from '../../hooks';
 
@@ -13,15 +13,15 @@ import { TestPanel } from './TestPanel';
 
 export type TestContainerProps = {
   role: string;
-  script: ScriptType;
+  script: Script.Script;
 };
 
-export const TestContainer = ({ script }: TestContainerProps) => {
+export const TestContainer = ({ role, script }: TestContainerProps) => {
   const state = useToolbarState();
   useDeployState({ state, script });
   return (
-    <StackItem.Content>
-      <TestPanel functionUrl={state.functionUrl} />
-    </StackItem.Content>
+    <Layout.Main role={role}>
+      <TestPanel functionUrl={state.value.functionUrl} />
+    </Layout.Main>
   );
 };

package/src/components/TestPanel/TestPanel.tsx

@@ -5,9 +5,9 @@
 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 { Avatar, Icon, Input, ScrollArea, type ThemedClassName, Toolbar, useTranslation } from '@dxos/react-ui';
 import { SyntaxHighlighter } from '@dxos/react-ui-syntax-highlighter';
-import { errorText, mx } from '@dxos/react-ui-theme';
+import { errorText, mx } from '@dxos/ui-theme';
 
 import { meta } from '../../meta';
 
@@ -16,7 +16,12 @@ type State = 'pending' | 'responding';
 /**
  * Request or response.
  */
-type Message = { type: 'request' | 'response'; text?: string; data?: any; error?: Error };
+type Message = {
+  type: 'request' | 'response';
+  text?: string;
+  data?: any;
+  error?: Error;
+};
 
 export type TestPanelProps = ThemedClassName<{
   functionUrl?: string;
@@ -61,7 +66,15 @@ export const TestPanel = ({ classNames, functionUrl }: TestPanelProps) => {
     inputRef.current?.focus();
   };
 
-  const handleResponse = ({ text, data, error }: { text?: string; data?: any; error?: Error } = {}) => {
+  const handleResponse = ({
+    text,
+    data,
+    error,
+  }: {
+    text?: string;
+    data?: any;
+    error?: Error;
+  } = {}) => {
     controller.current = null;
     setHistory((history) => [...history, { type: 'response', text, data, error } satisfies Message]);
     setResult('');
@@ -108,7 +121,9 @@ export const TestPanel = ({ classNames, functionUrl }: TestPanelProps) => {
       // Check for error.
       if (!response.ok) {
         const text = await response.text();
-        handleResponse({ error: new Error(text || response.statusText || String(response.status)) });
+        handleResponse({
+          error: new Error(text || response.statusText || String(response.status)),
+        });
         return;
       }
 
@@ -159,11 +174,11 @@ export const TestPanel = ({ classNames, functionUrl }: TestPanelProps) => {
   };
 
   return (
-    <div className={mx('flex flex-col h-full overflow-hidden', classNames)}>
+    <div className={mx('flex flex-col bs-full overflow-hidden', classNames)}>
       {/* TODO(burdon): Replace with Thread. */}
       <MessageThread ref={scrollerRef} state={state} result={result} history={history} />
       {/* TODO(burdon): Replace with Form based on the function's input schema. */}
-      <Toolbar.Root classNames='p-2'>
+      <Toolbar.Root>
         <Input.Root>
           <Input.TextInput
             ref={inputRef}
@@ -174,12 +189,20 @@ export const TestPanel = ({ classNames, functionUrl }: TestPanelProps) => {
             onKeyDown={(ev) => ev.key === 'Enter' && handleRequest(input)}
           />
         </Input.Root>
-        <Toolbar.Button onClick={() => handleRequest(input)}>
-          <Icon icon='ph--play--regular' size={4} />
-        </Toolbar.Button>
-        <Toolbar.Button onClick={() => (state ? handleStop() : handleClear())}>
-          <Icon icon={state ? 'ph--stop--regular' : 'ph--trash--regular'} size={4} />
-        </Toolbar.Button>
+        <Toolbar.IconButton
+          icon='ph--play--regular'
+          size={4}
+          label='Execute'
+          iconOnly
+          onClick={() => handleRequest(input)}
+        />
+        <Toolbar.IconButton
+          icon={state ? 'ph--stop--regular' : 'ph--trash--regular'}
+          size={4}
+          label={state ? 'Stop' : 'Clear'}
+          iconOnly
+          onClick={() => (state ? handleStop() : handleClear())}
+        />
       </Toolbar.Root>
     </div>
   );
@@ -196,36 +219,38 @@ type MessageThreadProps = {
 const MessageThread = forwardRef<HTMLDivElement, MessageThreadProps>(
   ({ state, history, result }: MessageThreadProps, forwardedRef) => {
     return (
-      <div ref={forwardedRef} className='flex flex-col gap-6 h-full p-2 overflow-x-hidden overflow-y-auto'>
-        {history.map((message, i) => (
-          <div key={i} className='grid grid-cols-[2rem_1fr_2rem]'>
-            <div className='p-1'>{message.type === 'response' && <RobotAvatar />}</div>
-            <div className='overflow-auto'>
-              <MessageItem message={message} />
-            </div>
-          </div>
-        ))}
-
-        {result?.length > 0 && (
-          <div className='grid grid-cols-[2rem_1fr_2rem]'>
-            <div className='p-1'>
-              {(state === 'pending' && <Icon icon='ph--spinner--regular' size={6} classNames='animate-spin' />) || (
-                <Icon icon='ph--robot--regular' size={6} classNames='animate-[pulse_1s_ease-in-out_infinite]' />
-              )}
+      <ScrollArea.Root orientation='vertical' classNames='bs-full' ref={forwardedRef}>
+        <ScrollArea.Viewport classNames='gap-6 p-2'>
+          {history.map((message, i) => (
+            <div key={i} className='grid grid-cols-[2rem_1fr_2rem]'>
+              <div className='p-1'>{message.type === 'response' && <RobotAvatar />}</div>
+              <div className='overflow-auto'>
+                <MessageItem message={message} />
+              </div>
             </div>
-            <div className='overflow-auto'>
-              <MessageItem message={{ type: 'response', text: result }} />
+          ))}
+
+          {result?.length > 0 && (
+            <div className='grid grid-cols-[2rem_1fr_2rem]'>
+              <div className='p-1'>
+                {(state === 'pending' && <Icon icon='ph--spinner--regular' size={6} classNames='animate-spin' />) || (
+                  <Icon icon='ph--robot--regular' size={6} classNames='animate-[pulse_1s_ease-in-out_infinite]' />
+                )}
+              </div>
+              <div className='overflow-auto'>
+                <MessageItem message={{ type: 'response', text: result }} />
+              </div>
             </div>
-          </div>
-        )}
-      </div>
+          )}
+        </ScrollArea.Viewport>
+      </ScrollArea.Root>
     );
   },
 );
 
 const MessageItem = ({ classNames, message }: ThemedClassName<{ message: Message }>) => {
   const { type, text, data, error } = message;
-  const wrapper = 'p-1 px-2 rounded-md bg-hoverSurface overflow-auto';
+  const wrapper = 'p-1 pli-2 rounded-md 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', errorText)}>{String(error)}</div>}

package/src/components/TypescriptEditor/TypescriptEditor.stories.tsx

@@ -5,13 +5,13 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useCallback, useMemo, useState } from 'react';
 
-import { createDocAccessor } from '@dxos/react-client/echo';
+import { createDocAccessor } from '@dxos/echo-db';
 import { createObject } from '@dxos/react-client/echo';
 import { Toolbar } from '@dxos/react-ui';
+import { Layout } from '@dxos/react-ui';
 import { withLayout, withTheme } from '@dxos/react-ui/testing';
-import { createDataExtensions } from '@dxos/react-ui-editor';
-import { StackItem } from '@dxos/react-ui-stack';
 import { Json } from '@dxos/react-ui-syntax-highlighter';
+import { createDataExtensions } from '@dxos/ui-editor';
 import { trim } from '@dxos/util';
 
 import { TypescriptEditor, type TypescriptEditorProps } from './TypescriptEditor';
@@ -25,7 +25,7 @@ const DefaultStory = (props: TypescriptEditorProps) => {
   const [result, setResult] = useState<object | undefined>({});
 
   // TODO(burdon): Make this work.
-  // const object = useMemo(() => DataType.makeText(templates[1].source), []);
+  // const object = useMemo(() => Text.make(templates[1].source), []);
   // const script = useMemo(
   //   () =>
   //     Obj.make(ScriptType, {
@@ -35,7 +35,12 @@ const DefaultStory = (props: TypescriptEditorProps) => {
   // );
 
   const extensions = useMemo(
-    () => [createDataExtensions({ id: object.id, text: createDocAccessor(object, ['content']) })],
+    () => [
+      createDataExtensions({
+        id: object.id,
+        text: createDocAccessor(object, ['content']),
+      }),
+    ],
     [],
   );
 
@@ -61,16 +66,16 @@ const DefaultStory = (props: TypescriptEditorProps) => {
   }, [object]);
 
   return (
-    <StackItem.Content toolbar>
+    <Layout.Main toolbar>
       {/* <ScriptToolbar script={script} state={{}} /> */}
       <Toolbar.Root>
         <Toolbar.Button onClick={handleRun}>Run</Toolbar.Button>
       </Toolbar.Root>
       <div role='none' className='grid grid-rows-[1fr_min-content] bs-full overflow-hidden text-sm'>
         <TypescriptEditor {...props} initialValue={object.content} extensions={extensions} />
-        <Json data={result} classNames='shrink-0 p-2 border-t border-subduedSeparator' />
+        <Json data={result} classNames='shrink-0 p-2 border-bs border-subduedSeparator' />
       </div>
-    </StackItem.Content>
+    </Layout.Main>
   );
 };
 
@@ -78,7 +83,7 @@ const meta = {
   title: 'plugins/plugin-script/TypescriptEditor',
   component: TypescriptEditor,
   render: DefaultStory,
-  decorators: [withTheme, withLayout({ container: 'column', classNames: 'is-prose' })],
+  decorators: [withTheme(), withLayout({ layout: 'column', classNames: 'is-proseMaxWidth' })],
 } satisfies Meta<typeof DefaultStory>;
 
 export default meta;

package/src/components/TypescriptEditor/TypescriptEditor.tsx

@@ -12,20 +12,20 @@ import { tags } from '@lezer/highlight';
 import { type VirtualTypeScriptEnvironment } from '@typescript/vfs';
 import { continueKeymap } from '@valtown/codemirror-continue';
 import { type HoverInfo, tsAutocomplete, tsFacet, tsHover, tsLinter, tsSync } from '@valtown/codemirror-ts';
-import React from 'react';
+import React, { memo } from 'react';
 
-import { Domino, type ThemeMode, type ThemedClassName, useThemeContext } from '@dxos/react-ui';
+import { type ThemeMode, type ThemedClassName, useThemeContext } from '@dxos/react-ui';
+import { type UseTextEditorProps, useTextEditor } from '@dxos/react-ui-editor';
+import { Domino } from '@dxos/ui';
 import {
   type BasicExtensionsOptions,
   type EditorInputMode,
   InputModeExtensions,
-  type UseTextEditorProps,
   createBasicExtensions,
   createThemeExtensions,
   defaultStyles,
-  useTextEditor,
-} from '@dxos/react-ui-editor';
-import { mx } from '@dxos/react-ui-theme';
+} from '@dxos/ui-editor';
+import { mx } from '@dxos/ui-theme';
 import { isNonNullable } from '@dxos/util';
 
 export type TypescriptEditorProps = ThemedClassName<
@@ -39,71 +39,68 @@ export type TypescriptEditorProps = ThemedClassName<
   } & Pick<UseTextEditorProps, 'initialValue' | 'extensions' | 'scrollTo' | 'selection'>
 >;
 
-export const TypescriptEditor = ({
-  classNames,
-  id,
-  role = 'article',
-  inputMode = 'vscode',
-  toolbar,
-  env,
-  options,
-  initialValue,
-  extensions,
-  scrollTo,
-  selection,
-}: TypescriptEditorProps) => {
-  const { themeMode } = useThemeContext();
-  const { parentRef, focusAttributes } = useTextEditor(
-    () => ({
-      id,
-      initialValue,
-      selection,
-      scrollTo,
-      extensions: [
-        extensions,
-        createBasicExtensions({
-          highlightActiveLine: true,
-          indentWithTab: true,
-          lineNumbers: true,
-          lineWrapping: false,
-          monospace: true,
-          scrollPastEnd: role !== 'section',
-          search: true,
-          ...options,
-        }),
-        createThemeExtensions({ themeMode, syntaxHighlighting: true }),
-        InputModeExtensions[inputMode],
+export const TypescriptEditor = memo(
+  ({
+    classNames,
+    id,
+    role = 'article',
+    inputMode = 'vscode',
+    env,
+    options,
+    initialValue,
+    extensions,
+    scrollTo,
+    selection,
+  }: TypescriptEditorProps) => {
+    const { themeMode } = useThemeContext();
+    const { parentRef, focusAttributes } = useTextEditor(
+      () => ({
+        id,
+        initialValue,
+        selection,
+        scrollTo,
+        extensions: [
+          extensions,
+          createBasicExtensions({
+            highlightActiveLine: true,
+            indentWithTab: true,
+            lineNumbers: true,
+            lineWrapping: false,
+            scrollPastEnd: role !== 'section',
+            search: true,
+            ...options,
+          }),
+          createThemeExtensions({
+            monospace: true,
+            themeMode,
+            syntaxHighlighting: true,
+          }),
 
-        javascript({ typescript: true }),
-        autocompletion({ override: env ? [tsAutocomplete()] : undefined }),
+          InputModeExtensions[inputMode],
+          javascript({ typescript: true }),
+          autocompletion({ override: env ? [tsAutocomplete()] : undefined }),
 
-        // Continues block comments when pressing Enter.
-        Prec.high(keymap.of(continueKeymap)),
-        keymap.of(completionKeymap),
-        keymap.of(lintKeymap),
+          // Continues block comments when pressing Enter.
+          Prec.high(keymap.of(continueKeymap)),
+          keymap.of(completionKeymap),
+          keymap.of(lintKeymap),
 
-        // https://github.com/val-town/codemirror-ts
-        env && [
-          tsFacet.of({ env, path: `/src/${id}.ts` }),
-          tsSync(),
-          tsLinter(),
-          tsHover({ renderTooltip: createTooltipRenderer(themeMode) }),
-        ],
-      ].filter(isNonNullable),
-    }),
-    [id, extensions, themeMode, inputMode, selection, scrollTo],
-  );
+          // https://github.com/val-town/codemirror-ts
+          env && [
+            // TODO(burdon): Fix type.
+            tsFacet.of({ env: env as any, path: `./src/${id}.ts` }),
+            tsSync(),
+            tsLinter(),
+            tsHover({ renderTooltip: createTooltipRenderer(themeMode) }),
+          ],
+        ].filter(isNonNullable),
+      }),
+      [themeMode, id, extensions, inputMode, selection, scrollTo, env],
+    );
 
-  // TODO(brudon): Use react-ui-editor's Editor component.
-  return (
-    <div
-      ref={parentRef}
-      data-toolbar={toolbar ? 'enabled' : 'disabled'}
-      className={mx(classNames)}
-      {...focusAttributes}
-    />
-  );
-};
+    return <div ref={parentRef} className={mx(classNames)} {...focusAttributes} />;
+  },
+);
 
 // TODO(burdon): Factor out (react-ui-editor).
 const createTooltipRenderer = (themeMode: ThemeMode) => {
@@ -126,15 +123,14 @@ const createTooltipRenderer = (themeMode: ThemeMode) => {
   };
 
   return (info: HoverInfo) => {
+    const children =
+      info.quickInfo?.displayParts?.map(({ kind, text }) =>
+        Domino.of('span').classNames(classFromKind(kind)).text(text),
+      ) ?? [];
     return {
       dom: Domino.of('div')
         .classNames('xs:max-is-80 max-is-lg p-1 bg-baseSurface rounded border border-separator')
-        .children(
-          ...(info.quickInfo?.displayParts?.map(({ kind, text }) =>
-            Domino.of('span').classNames(classFromKind(kind)).text(text),
-          ) ?? []),
-        )
-        .build(),
+        .children(...children).root,
     };
   };
 };

package/src/e2e/ai.test.ts

@@ -0,0 +1,92 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe } from '@effect/vitest';
+import { test } from 'vitest';
+
+import { Client } from '@dxos/client';
+import { type Space } from '@dxos/client-protocol';
+import { configPreset } from '@dxos/config';
+import { Function } from '@dxos/functions';
+import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
+import { bundleFunction } from '@dxos/functions-runtime/native';
+import { FunctionRuntimeKind } from '@dxos/protocols';
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+
+// To heavy to run in CI.
+describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e')).skip('Function', () => {
+  const config = configPreset({ edge: 'local' });
+
+  test('bundle anthropic function', { timeout: 120_000 }, async () => {
+    await bundleFunction({
+      entryPoint: new URL('../templates/anthropic.ts', import.meta.url).pathname,
+      verbose: true,
+    });
+  });
+
+  test('deploy empty function', { timeout: 120_000 }, async () => {
+    const { space, functionsServiceClient } = await setup();
+
+    await sync(space);
+    const func = await deployFunction(
+      space,
+      functionsServiceClient,
+      new URL('../templates/ping.ts', import.meta.url).pathname,
+    );
+    console.log(func);
+    throw new Error('test');
+  });
+
+  test('deploy and invoke anthropic function', { timeout: 120_000 }, async () => {
+    const { space, functionsServiceClient } = await setup();
+    await sync(space);
+    const func = await deployFunction(
+      space,
+      functionsServiceClient,
+      new URL('../templates/anthropic.ts', import.meta.url).pathname,
+    );
+
+    const result = await functionsServiceClient.invoke(func, {
+      message: 'Hello, world!',
+    });
+    console.log(result);
+  });
+
+  const setup = async () => {
+    const client = await new Client({ config, types: [Function.Function] }).initialize();
+    await client.halo.createIdentity();
+
+    const space = await client.spaces.create();
+    await space.waitUntilReady();
+    await space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED);
+
+    const functionsServiceClient = FunctionsServiceClient.fromClient(client);
+    return { client, space, functionsServiceClient };
+  };
+
+  const sync = async (space: Space) => {
+    await space.db.flush({ indexes: true });
+    await space.internal.syncToEdge({
+      onProgress: (state) =>
+        console.log(state ? `${state.unsyncedDocumentCount} documents syncing...` : 'connecting to edge...'),
+    });
+  };
+
+  const deployFunction = async (space: Space, functionsServiceClient: FunctionsServiceClient, entryPoint: string) => {
+    const artifact = await bundleFunction({
+      entryPoint,
+      verbose: true,
+    });
+    const func = await functionsServiceClient.deploy({
+      version: '0.0.1',
+      ownerPublicKey: space.key,
+      entryPoint: artifact.entryPoint,
+      assets: artifact.assets,
+      runtime: FunctionRuntimeKind.enums.WORKER_LOADER,
+    });
+
+    space.db.add(func);
+    return func;
+  };
+});

package/src/e2e/deploy.test.ts

@@ -0,0 +1,64 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { readFile } from 'node:fs/promises';
+
+import { describe, expect, test } from 'vitest';
+
+import { Client, type Config } from '@dxos/client';
+import { createEdgeIdentity } from '@dxos/client/edge';
+import { configPreset } from '@dxos/config';
+import { bundleFunction } from '@dxos/functions-runtime/bundler';
+import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+
+describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('Functions deployment', () => {
+  test('deploys FOREX (effect) function and invokes it via EDGE (main)', { timeout: 120_000 }, async () => {
+    const config = configPreset({ edge: 'main' });
+    await testDeploy(config);
+  });
+
+  test('deploys FOREX (effect) function and invokes it via EDGE (production)', { timeout: 120_000 }, async () => {
+    const config = configPreset({ edge: 'production' });
+    await testDeploy(config);
+  });
+
+  const testDeploy = async (config: Config) => {
+    await using client = await new Client({ config }).initialize();
+    await client.halo.createIdentity();
+
+    const space = await client.spaces.create();
+    await space.waitUntilReady();
+
+    // Inline echo function source.
+    const source = await readFile(new URL('../templates/forex-effect.ts', import.meta.url), 'utf-8');
+
+    // Bundle and upload.
+    const buildResult = await bundleFunction({ source });
+    if ('error' in buildResult) {
+      throw buildResult.error ?? new Error('Bundle creation failed');
+    }
+    const functionsServiceClient = FunctionsServiceClient.fromClient(client);
+
+    const func = await functionsServiceClient.deploy({
+      ownerPublicKey: space.key,
+      version: '0.0.1',
+      entryPoint: buildResult.entryPoint,
+      assets: buildResult.assets,
+    });
+
+    // Invoke deployed function via EDGE directly.
+    const edgeClient = client.edge;
+    invariant(edgeClient, 'edgeClient is required');
+    edgeClient.setIdentity(createEdgeIdentity(client));
+
+    const input = { from: 'USD', to: 'EUR' };
+    const result = await functionsServiceClient.invoke(func, input);
+    log.info('>>> result', { result, func });
+    const resultNumber = Number(result);
+    expect(resultNumber).toBeGreaterThan(0);
+    expect(resultNumber).toBeLessThan(100);
+  };
+});