@dxos/plugin-script 0.8.3 → 0.8.4-main.1c7ec43d41

package/src/templates/gmail.ts

@@ -3,20 +3,32 @@
 //
 
 // @ts-ignore
-import { create, defineFunction, EchoObject, Filter, ObjectId, S } from 'dxos:functions';
+import { EchoObject, Filter, ObjectId, S, create, defineFunction } from 'dxos:functions';
 // @ts-ignore
 import {
+  FetchHttpClient,
   HttpClient,
   HttpClientRequest,
-  FetchHttpClient,
   // @ts-ignore
-} from 'https://esm.sh/@effect/platform@0.77.2?deps=effect@3.14.21&bundle=false';
+} from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
 // @ts-ignore
 import { format, subDays } from 'https://esm.sh/date-fns@3.3.1?bundle=false';
 // @ts-ignore
-import { pipe, Chunk, Effect, Ref, Schedule, Stream } from 'https://esm.sh/effect@3.14.21?bundle=false';
+import * as Chunk from 'https://esm.sh/effect@3.17.0/Chunk?bundle=false';
+// @ts-ignore
+import * as Effect from 'https://esm.sh/effect@3.17.0/Effect?bundle=false';
+// @ts-ignore
+import * as Function from 'https://esm.sh/effect@3.17.0/Function?bundle=false';
+// @ts-ignore
+import * as Ref from 'https://esm.sh/effect@3.17.0/Ref?bundle=false';
+// @ts-ignore
+import * as Schedule from 'https://esm.sh/effect@3.17.0/Schedule?bundle=false';
+// @ts-ignore
+import * as Stream from 'https://esm.sh/effect@3.17.0/Stream?bundle=false';
 
 export default defineFunction({
+  key: 'org.dxos.script.gmail',
+  name: 'Gmail',
   inputSchema: S.Struct({
     mailboxId: S.String,
     userId: S.optional(S.String).pipe(S.withDecodingDefault(() => 'me')),
@@ -35,13 +47,13 @@ export default defineFunction({
   handler: ({ context: { space }, data: { mailboxId, userId, after, pageSize } }: any) =>
     Effect.gen(function* () {
       const { token } = yield* Effect.tryPromise({
-        try: () => space.db.query(Filter.typename('dxos.org/type/AccessToken', { source: 'gmail.com' })).first(),
+        try: () => space.db.query(Filter.typename('org.dxos.type.accessToken', { source: 'gmail.com' })).first(),
         catch: (e: any) => e,
       });
 
       // NOTE: Google API bundles size is v. large and caused runtime issues.
       const makeRequest = (url: string) =>
-        pipe(
+        Function.pipe(
           url,
           HttpClientRequest.get,
           HttpClientRequest.setHeaders({ Authorization: `Bearer ${token}`, Accept: 'application/json' }),
@@ -80,7 +92,7 @@ export default defineFunction({
           const messageDetails = yield* getMessage(userId, message.id);
           const created = new Date(parseInt(messageDetails.internalDate)).toISOString();
           const from = messageDetails.payload.headers.find((h: any) => h.name === 'From');
-          const sender = from && parseEmailString(from.value);
+          const sender = from && parseFromHeader(from.value);
           // TODO(wittjosiah): Improve parsing of email contents.
           const content =
             messageDetails.payload.body?.data ??
@@ -98,7 +110,7 @@ export default defineFunction({
             sender,
             blocks: [
               {
-                type: 'text',
+                _tag: 'text',
                 text: Buffer.from(content, 'base64').toString('utf-8'),
               },
             ],
@@ -114,7 +126,7 @@ export default defineFunction({
 
       const queueMessages = yield* Ref.get(newMessages);
       if (queueMessages.length > 0) {
-        yield* pipe(
+        yield* Function.pipe(
           queueMessages,
           Stream.fromIterable,
           Stream.grouped(10),
@@ -145,26 +157,25 @@ const getUrl = (userId: string, messageId?: string, params?: Record<string, any>
 /**
  * Parses an email string in the format "Name <email@example.com>" into separate name and email components.
  */
-const parseEmailString = (emailString: string): { name?: string; email: string } | undefined => {
-  const match = emailString.match(/^([^<]+?)\s*<([^>]+@[^>]+)>$/);
+const parseFromHeader = (value: string): { name?: string; email: string } | undefined => {
+  const EMAIL_REGEX = /^([^<]+?)\s*<([^>]+@[^>]+)>$/;
+  const removeOuterQuotes = (str: string) => str.replace(/^['"]|['"]$/g, '');
+  const match = value.match(EMAIL_REGEX);
   if (match) {
     const [, name, email] = match;
     return {
-      name: name.trim(),
+      name: removeOuterQuotes(name.trim()),
       email: email.trim(),
     };
   }
-
-  return undefined;
 };
 
 //
 // Schemas
-// TODO(wittjosiah): These schemas should be imported from @dxos/S.
+// TODO(wittjosiah): These schemas should be imported from @dxos/schema.
 //
 
-const ActorRoles = ['user', 'assistant'] as const;
-const ActorRole = S.Literal(...ActorRoles);
+const ActorRole = S.Literal('user', 'assistant');
 type ActorRole = S.Schema.Type<typeof ActorRole>;
 
 const ActorSchema = S.Struct({
@@ -174,57 +185,16 @@ const ActorSchema = S.Struct({
   role: S.optional(ActorRole),
 });
 
-const AbstractContentBlock = S.Struct({
+const Base = S.Struct({
   pending: S.optional(S.Boolean),
 });
-type AbstractContentBlock = S.Schema.Type<typeof AbstractContentBlock>;
-const TextContentBlock = S.extend(
-  AbstractContentBlock,
-  S.Struct({
-    type: S.Literal('text'),
-    disposition: S.optional(S.String),
-    text: S.String,
-  }),
-).pipe(S.mutable);
-type TextContentBlock = S.Schema.Type<typeof TextContentBlock>;
-const JsonContentBlock = S.extend(
-  AbstractContentBlock,
-  S.Struct({
-    type: S.Literal('json'),
-    disposition: S.optional(S.String),
-    data: S.String,
-  }),
-).pipe(S.mutable);
-type JsonContentBlock = S.Schema.Type<typeof JsonContentBlock>;
-const Base64ImageSource = S.Struct({
-  type: S.Literal('base64'),
-  mediaType: S.String,
-  data: S.String,
+type Base = S.Schema.Type<typeof Base>;
+const Text = S.TaggedStruct('text', {
+  mimeType: S.optional(S.String),
+  text: S.String,
+  ...Base.fields,
 }).pipe(S.mutable);
-const HttpImageSource = S.Struct({
-  type: S.Literal('http'),
-  url: S.String,
-}).pipe(S.mutable);
-const ImageSource = S.Union(Base64ImageSource, HttpImageSource);
-type ImageSource = S.Schema.Type<typeof ImageSource>;
-const ImageContentBlock = S.extend(
-  AbstractContentBlock,
-  S.Struct({
-    type: S.Literal('image'),
-    id: S.optional(S.String),
-    source: S.optional(ImageSource),
-  }),
-).pipe(S.mutable);
-type ImageContentBlock = S.Schema.Type<typeof ImageContentBlock>;
-const ReferenceContentBlock = S.extend(
-  AbstractContentBlock,
-  S.Struct({
-    type: S.Literal('reference'),
-    reference: S.Any,
-  }),
-).pipe(S.mutable);
-type ReferenceContentBlock = S.Schema.Type<typeof ReferenceContentBlock>;
-const MessageContentBlock = S.Union(TextContentBlock, JsonContentBlock, ImageContentBlock, ReferenceContentBlock);
+interface Text extends S.Schema.Type<typeof Text> {}
 
 const MessageType = S.Struct({
   id: ObjectId,
@@ -234,7 +204,7 @@ const MessageType = S.Struct({
   sender: ActorSchema.annotations({
     description: 'Identity of the message sender.',
   }),
-  blocks: S.Array(MessageContentBlock).annotations({
+  blocks: S.Array(Text).annotations({
     description: 'Contents of the message.',
   }),
   properties: S.optional(
@@ -246,8 +216,8 @@ const MessageType = S.Struct({
   ),
 }).pipe(
   EchoObject({
-    typename: 'dxos.org/type/Message',
-    version: '0.2.0',
+    typename: 'org.dxos.type.message',
+    version: '0.1.0',
   }),
 );
 type MessageType = S.Schema.Type<typeof MessageType>;

package/src/templates/index.ts

@@ -2,18 +2,22 @@
 // Copyright 2024 DXOS.org
 //
 
+import anthropic from './anthropic.ts?raw';
 import chat from './chat.ts?raw';
-import chess from './chess.ts?raw';
+import chessBot from './chess-bot.ts?raw';
+import commentary from './commentary.ts?raw';
 import dataGenerator from './data-generator.ts?raw';
 import discord from './discord.ts?raw';
-import echo from './echo.ts?raw';
 import email from './email.ts?raw';
 import forexEffect from './forex-effect.ts?raw';
 import forex from './forex.ts?raw';
 import gmail from './gmail.ts?raw';
+import ping from './ping.ts?raw';
 
 const removeHeader = (str: string) => str.split('\n').slice(4).join('\n');
 
+export { dataGenerator };
+
 export type Template = {
   id: string;
   name: string;
@@ -21,56 +25,67 @@ export type Template = {
   presetId?: string;
 };
 
-export const templates: Template[] = [
+export const templates = [
   {
-    id: 'dxos.org/script/echo',
-    name: 'Echo',
-    source: removeHeader(echo),
+    id: 'org.dxos.script.ping',
+    name: 'Ping',
+    source: removeHeader(ping),
   },
   {
-    id: 'dxos.org/script/forex',
+    id: 'org.dxos.script.forex',
     name: 'Forex',
     source: removeHeader(forex),
   },
   {
-    id: 'dxos.org/script/forex-effect',
+    id: 'org.dxos.script.forex-effect',
     name: 'Forex (Effect)',
     source: removeHeader(forexEffect),
   },
   {
-    id: 'dxos.org/script/gpt',
+    id: 'org.dxos.script.gpt',
     name: 'Gpt',
     source: removeHeader(chat),
-    presetId: 'dxos.org/function/gpt',
+    presetId: 'org.dxos.function.gpt',
   },
   {
-    id: 'dxos.org/script/chess',
-    name: 'Chess',
-    source: removeHeader(chess),
-    presetId: 'dxos.org/function/chess',
+    id: 'org.dxos.script.chess-bot',
+    name: 'Chess Bot',
+    source: removeHeader(chessBot),
+    presetId: 'org.dxos.function.chess-bot',
   },
   {
-    id: 'dxos.org/script/email',
+    id: 'org.dxos.script.email',
     name: 'Email',
     source: removeHeader(email),
-    presetId: 'dxos.org/function/email',
+    presetId: 'org.dxos.function.email',
   },
   {
-    id: 'dxos.org/script/discord',
+    id: 'org.dxos.script.discord',
     name: 'Discord',
     source: removeHeader(discord),
-    presetId: 'dxos.org/function/discord',
+    presetId: 'org.dxos.function.discord',
   },
   {
-    id: 'dxos.org/script/gmail',
+    id: 'org.dxos.script.gmail',
     name: 'Gmail',
     source: removeHeader(gmail),
-    presetId: 'dxos.org/function/gmail',
+    presetId: 'org.dxos.function.gmail',
   },
   {
-    id: 'dxos.org/script/data-generator',
+    id: 'org.dxos.script.data-generator',
     name: 'Data Generator',
     source: removeHeader(dataGenerator),
-    presetId: 'dxos.org/function/data-generator',
+    presetId: 'org.dxos.function.data-generator',
+  },
+  {
+    id: 'org.dxos.script.anthropic',
+    name: 'Anthropic',
+    source: removeHeader(anthropic),
+  },
+  {
+    id: 'org.dxos.script.commentary',
+    name: 'Commentary',
+    source: removeHeader(commentary),
+    presetId: 'org.dxos.function.chess.commentary',
   },
-];
+] as const;

package/src/templates/ping.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Operation } from '@dxos/compute';
+
+const Ping = Operation.make({
+  meta: {
+    key: 'org.dxos.script.ping',
+    name: 'Ping',
+  },
+  input: Schema.Any,
+  output: Schema.Any,
+});
+
+export default Ping.pipe(
+  Operation.withHandler(
+    Effect.fn(function* (data) {
+      return data;
+    }),
+  ),
+);

package/src/testing/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './test-script';
+export * from './test-notebook';

package/src/testing/simulator.test.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Record from 'effect/Record';
+import { readFile } from 'node:fs/promises';
+import { describe, expect, test } from 'vitest';
+
+import { bundleFunction } from '@dxos/functions-runtime/bundler';
+import { FunctionWorker } from '@dxos/functions-simulator-cloudflare';
+import { ErrorCodec } from '@dxos/protocols';
+
+// Requires downloading assets from R2.
+describe('Run script in sumulator', { tags: ['functions-e2e'] }, () => {
+  test('forex-effect', { timeout: 120_000 }, async () => {
+    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 worker = new FunctionWorker({
+      mainModule: buildResult.entryPoint,
+      modules: Record.map(buildResult.assets, (contents, filename) => ({
+        contents: contents as Uint8Array<ArrayBuffer>,
+        contentType: filename.endsWith('.wasm') ? 'application/wasm' : 'application/javascript',
+      })),
+    });
+
+    const result = await worker.invoke({ from: 'USD', to: 'EUR' });
+    console.log(result);
+    if (result._kind === 'error') {
+      throw ErrorCodec.decode(result.error);
+    }
+    expect(Number(result.result)).toBeGreaterThan(0);
+  });
+});

package/src/testing/test-notebook.ts

@@ -0,0 +1,71 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Routine } from '@dxos/compute';
+import { Ref } from '@dxos/echo';
+import { createObject } from '@dxos/echo-db';
+import { PublicKey } from '@dxos/keys';
+import { Markdown } from '@dxos/plugin-markdown/types';
+import { Text } from '@dxos/schema';
+
+import { Notebook } from '#types';
+
+// TODO(burdon): NOTE: createObject is required for tests.
+export const createNotebook = (): Notebook.Notebook =>
+  Notebook.make({
+    cells: [
+      {
+        id: PublicKey.random().toString(),
+        type: 'script',
+        source: Ref.make(createObject(Text.make({ content: 'c = a() + b' }))),
+      },
+      {
+        id: PublicKey.random().toString(),
+        type: 'script',
+        source: Ref.make(createObject(Text.make({ content: 'a = () => 100' }))),
+      },
+      {
+        id: PublicKey.random().toString(),
+        type: 'script',
+        source: Ref.make(createObject(Text.make({ content: 'b = 200' }))),
+      },
+      {
+        id: PublicKey.random().toString(),
+        type: 'script',
+        source: Ref.make(createObject(Text.make({ content: 'd = a() * 2' }))),
+      },
+      {
+        id: PublicKey.random().toString(),
+        type: 'script',
+        source: Ref.make(createObject(Text.make({ content: 'c + d' }))),
+      },
+      {
+        id: PublicKey.random().toString(),
+        type: 'prompt',
+        prompt: Ref.make(
+          createObject(
+            Routine.make({
+              instructions: 'Very briefly, what colors are associated with the numbers {{a}} and {{b}}.',
+            }),
+          ),
+        ),
+      },
+      {
+        id: PublicKey.random().toString(),
+        type: 'query',
+        source: Ref.make(createObject(Text.make({ content: `docs = (type: ${Markdown.Document.typename})` }))),
+      },
+      {
+        id: PublicKey.random().toString(),
+        type: 'prompt',
+        prompt: Ref.make(
+          createObject(
+            Routine.make({
+              instructions: 'Very briefly, summarize the documents: {{docs}}',
+            }),
+          ),
+        ),
+      },
+    ],
+  });

package/src/testing/test-script.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Script, Operation } from '@dxos/compute';
+import { Obj, Ref } from '@dxos/echo';
+import { type Space } from '@dxos/react-client/echo';
+
+/**
+ * Seeds a script and linked persistent operation for Storybook stories.
+ */
+export const createScript = (space: Space): Script.Script => {
+  const script = Script.make({
+    name: 'Test',
+    source: 'export default () => 42;',
+  });
+
+  space.db.add(script);
+  space.db.add(
+    Obj.make(Operation.PersistentOperation, {
+      key: 'org.dxos.script.story-fn',
+      name: 'Test',
+      version: '0.1.0',
+      source: Ref.make(script),
+    }),
+  );
+
+  return script;
+};