@dxos/plugin-script 0.8.4-main.c4373fc → 0.8.4-main.d9fc60f731

package/src/templates/anthropic.ts

@@ -0,0 +1,50 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import * as Chunk from 'effect/Chunk';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import * as Stream from 'effect/Stream';
+
+import { AiService } from '@dxos/ai';
+import { Operation } from '@dxos/compute';
+import { DXN } from '@dxos/keys';
+
+const Anthropic = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.script.anthropic'),
+    name: 'Anthropic Chat',
+    description: 'Chat with Anthropic',
+  },
+  input: Schema.Struct({
+    message: Schema.String,
+  }),
+  output: Schema.Any,
+  services: [AiService.AiService],
+});
+
+export default Anthropic.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ message }) {
+      const model = (yield* AiService.AiService).model('@anthropic/claude-sonnet-4-5');
+
+      //
+      // Basic example.
+      //
+      const { text } = yield* LanguageModel.generateText({ prompt: message }).pipe(Effect.provide(model));
+
+      //
+      // Streaming example.
+      //
+      const parts = yield* LanguageModel.streamText({
+        prompt: 'Count from 1 to 5, one number per line.',
+      }).pipe(Stream.runCollect, Effect.map(Chunk.toArray), Effect.provide(model));
+      const textDeltas = parts.filter((p) => p.type === 'text-delta');
+      const fullText = textDeltas.map((p) => (p as { delta: string }).delta).join('');
+
+      return { response: text, streamText: fullText };
+    }),
+  ),
+);

package/src/templates/chess-bot.ts

@@ -0,0 +1,63 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Chess as ChessJS } from 'chess.js';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Operation } from '@dxos/compute';
+import { Database, Obj, DXN } from '@dxos/echo';
+import { Chess } from '@dxos/plugin-chess';
+import { GameRef, Game, loadGame } from '@dxos/plugin-game';
+
+const ChessBot = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.script.chessBot'),
+    name: 'Chess Bot',
+    description: 'Plays a random move in a chess game.',
+  },
+  input: Schema.Struct({
+    game: GameRef(Chess.State).annotations({
+      description: 'The chess game to comment on.',
+    }),
+    player: Schema.optional(Schema.Literal('white', 'black')).annotations({
+      description: 'The player to play the game as.',
+    }),
+  }),
+  output: Schema.Struct({
+    state: Schema.String.annotations({
+      description: 'The state of the game as an ASCII art board.',
+    }),
+  }),
+  types: [Game, Chess.State],
+  services: [Database.Service],
+});
+
+export default ChessBot.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ game, player = 'black' }) {
+      const { variant } = yield* loadGame(game, Chess.State);
+      const chess = new ChessJS();
+      chess.loadPgn(variant.pgn ?? '');
+      if (chess.turn() !== (player === 'white' ? 'w' : 'b')) {
+        return { state: chess.ascii() };
+      }
+
+      const moves = chess.moves({ verbose: true });
+      const move = moves[Math.floor(Math.random() * moves.length)];
+      if (!move) {
+        return { state: chess.ascii() };
+      }
+
+      chess.move(move.san);
+      const newPgn = chess.pgn();
+      Obj.update(variant, (variant) => {
+        const mutable = variant as Obj.Mutable<typeof variant>;
+        mutable.pgn = newPgn;
+      });
+      yield* Database.flush();
+      return { state: chess.ascii() };
+    }),
+  ),
+);

package/src/templates/commentary.ts

@@ -0,0 +1,251 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as A from '@automerge/automerge';
+import { Chess as ChessJS } from 'chess.js';
+import * as Array from 'effect/Array';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+
+import { AiService, ConsolePrinter, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { RootCollectionAnnotation } from '@dxos/app-toolkit';
+import { AiRequest, GenerationObserver } from '@dxos/assistant';
+import { Trace, Operation, OperationRegistry } from '@dxos/compute';
+import { Annotation, Collection, Database, DXN, Filter, Obj, Ref, Relation, URI } from '@dxos/echo';
+import { createDocAccessor } from '@dxos/echo-db';
+import { log } from '@dxos/log';
+import { Chess } from '@dxos/plugin-chess';
+import { Game, GameRef, loadGame } from '@dxos/plugin-game';
+import { Markdown } from '@dxos/plugin-markdown';
+import { Text } from '@dxos/schema';
+import { HasSubject } from '@dxos/types';
+import { trim } from '@dxos/util';
+
+const Commentary = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.chess.commentary'),
+    name: 'Commentary',
+    description: 'Adds commentary about the most recent move to a markdown document associated with the chess game.',
+  },
+  input: Schema.Struct({
+    game: GameRef(Chess.State).annotations({
+      description: 'The chess game to comment on.',
+    }),
+  }),
+  output: Schema.Union(
+    Schema.Struct({
+      documentId: URI.Schema.annotations({
+        description: 'The ID of the markdown document that was updated or created.',
+      }),
+      commentary: Schema.String.annotations({
+        description: 'The commentary that was added.',
+      }),
+    }),
+    Schema.Void.annotations({
+      description: 'Function did not find anything to comment on.',
+    }),
+  ),
+  types: [Game, Chess.State, Markdown.Document, Text.Text, HasSubject.HasSubject, Collection.Collection],
+  services: [AiService.AiService, Database.Service],
+});
+
+export default Commentary.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* ({ game: gameRef }) {
+        // Load the game and its Chess variant state.
+        log.info('load game', { gameRef });
+        const { game: chessGame, variant: chessState } = yield* loadGame(gameRef, Chess.State);
+
+        // Load the chess position from PGN or FEN.
+        const chess = new ChessJS();
+        if (chessState.pgn) {
+          chess.loadPgn(chessState.pgn);
+        } else if (chessState.fen) {
+          chess.load(chessState.fen);
+        } else {
+          log.info('Early return: no pgn or fen');
+          return;
+        }
+
+        // Get the most recent move
+        const history = chess.history({ verbose: true });
+        if (history.length === 0) {
+          throw new Error('No moves have been played yet');
+        }
+        const lastMove = history[history.length - 1];
+        const moveNumber = Math.ceil(history.length / 2);
+        const isWhiteMove = history.length % 2 === 1;
+        const player = isWhiteMove ? 'White' : 'Black';
+        const moveNotation = lastMove.san;
+
+        // Generate AI commentary about the move
+        const result = yield* new AiRequest.Request({
+          observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'chess-commentary' })),
+        }).run({
+          prompt:
+            `Comment on this chess move as if you're commentating a live match for an audience:\n\n` +
+            `Move ${moveNumber}: ${player} plays ${moveNotation} (${lastMove.from} to ${lastMove.to})${lastMove.captured ? `, capturing ${lastMove.captured}` : ''}\n` +
+            `Current position: ${chess.fen()}\n` +
+            `${chess.isCheck() ? 'The king is in check! ' : ''}` +
+            `${chess.isCheckmate() ? 'CHECKMATE! ' : ''}` +
+            `${chess.isStalemate() ? 'STALEMATE! ' : ''}` +
+            `\nGame so far:\n${chess.pgn()}`,
+          system: COMMENTARY_SYSTEM_PROMPT,
+          history: [],
+        });
+
+        const commentaryText = Function.pipe(
+          result,
+          Array.findLast((msg) => msg.sender.role === 'assistant' && msg.blocks.some((block) => block._tag === 'text')),
+          Option.flatMap((msg) =>
+            Function.pipe(
+              msg.blocks,
+              Array.findLast((block) => block._tag === 'text'),
+              Option.map((block) => block.text),
+            ),
+          ),
+          Option.getOrThrowWith(() => new Error('No commentary generated')),
+        );
+
+        const commentary = `## Move ${moveNumber}: ${player} plays ${moveNotation}\n\n${commentaryText}\n\n`;
+        log.info('commentary', { commentary });
+
+        // TODO(wittjosiah): Functions currently don't support traversals.
+        // const docs = yield* Database.runQuery(
+        //   Query.select(Filter.id(chessGame.id)).targetOf(HasSubject.HasSubject).source(),
+        // ).pipe(Effect.map((objects) => objects.filter((object) => Obj.instanceOf(Markdown.Document, object))));
+        const docs = yield* Database.runQuery(Filter.type(HasSubject.HasSubject)).pipe(
+          Effect.map((relations) =>
+            relations.filter((relation) => {
+              // TODO(wittjosiah): This is a workaround for getTarget not handling deleted objects.
+              try {
+                log.info('relation', {
+                  source: Obj.getURI(Relation.getTarget(relation)),
+                  game: Obj.getURI(chessGame),
+                });
+                return Obj.getURI(Relation.getTarget(relation)) === Obj.getURI(chessGame);
+              } catch {
+                return false;
+              }
+            }),
+          ),
+          Effect.map((relations) =>
+            relations
+              .map((relation) => {
+                // TODO(wittjosiah): This is a workaround for getSource not handling deleted objects.
+                try {
+                  return Relation.getSource(relation);
+                } catch {
+                  return undefined;
+                }
+              })
+              .filter((source) => source !== undefined),
+          ),
+          Effect.map((sources) => {
+            const docs = sources.filter((source) => Obj.instanceOf(Markdown.Document, source));
+            log.info('docs', { sources, docs });
+            return docs;
+          }),
+        );
+        log.info('docs', { count: docs.length });
+
+        let document: Markdown.Document;
+        if (docs.length === 0) {
+          // TODO(wittjosiah): Deploy fails if `SpaceProperties` schema is imported because its from `client-protocol`.
+          const [properties] = yield* Database.runQuery(Filter.typename('org.dxos.type.spaceProperties'));
+          const rootCollectionRef = Annotation.get(properties, RootCollectionAnnotation).pipe(Option.getOrUndefined);
+          const rootCollection = rootCollectionRef
+            ? yield* Database.load<Collection.Collection>(rootCollectionRef)
+            : undefined;
+
+          log.info('rootCollection', { rootCollection });
+
+          // Create a new markdown document
+          const gameName = chessGame.name || 'Chess Game';
+          document = yield* Database.add(
+            Markdown.make({
+              name: `${gameName} Commentary`,
+              content: `# ${gameName} Commentary\n\n${commentary}`,
+            }),
+          );
+
+          const documentRef = Ref.make(document);
+          if (rootCollection) {
+            Obj.update(rootCollection, (rootCollection) => {
+              rootCollection.objects.push(documentRef);
+            });
+          }
+
+          // Create the HasSubject relation
+          yield* Database.add(
+            Relation.make(HasSubject.HasSubject, {
+              [Relation.Source]: document,
+              [Relation.Target]: chessGame,
+              completedAt: new Date().toISOString(),
+            }),
+          );
+        } else {
+          document = docs[0];
+
+          // Load the text content and append the commentary
+          const text = yield* Database.load(document.content);
+          const accessor = createDocAccessor(text, ['content']);
+          accessor.handle.change((doc: A.Doc<Text.Text>) => {
+            A.splice(doc, accessor.path.slice(), text.content.length, 0, commentary);
+          });
+        }
+
+        log.info('result', { documentId: Obj.getURI(document), commentary });
+
+        yield* Database.flush();
+
+        return {
+          documentId: Obj.getURI(document),
+          commentary,
+        };
+      },
+      Effect.provide(
+        Layer.mergeAll(
+          AiService.model('@anthropic/claude-haiku-4-5'),
+          ToolResolverService.layerEmpty,
+          ToolExecutionService.layerEmpty,
+          Trace.writerLayerNoop,
+          Database.notAvailable,
+          Layer.succeed(Operation.Service, {
+            invoke: () => Effect.die('Not available.'),
+            schedule: () => Effect.die('Not available.'),
+            invokePromise: async () => ({ error: new Error('Not available.') }),
+          } as any),
+          Layer.succeed(OperationRegistry.Service, { resolve: () => Effect.succeed(undefined) } as any),
+        ),
+      ),
+    ),
+  ),
+);
+
+const COMMENTARY_SYSTEM_PROMPT = trim`
+  You are a professional chess commentator providing live commentary for a chess match.
+
+  # Style
+  - Write in an engaging, enthusiastic style as if commentating for a live audience
+  - Be concise but informative (2-4 sentences)
+  - Explain the strategic implications of the move
+  - Note any tactical elements (captures, threats, checks)
+  - Comment on the position and what it means for the game
+
+  # Format
+  - Write in plain text (no markdown formatting in the commentary itself)
+  - Be natural and conversational
+  - Use chess terminology appropriately but keep it accessible
+
+  # Special Situations
+  - If it's checkmate, express excitement about the conclusion
+  - If it's check, note the pressure on the king
+  - If a piece is captured, mention the material exchange
+  - Comment on the development of pieces and control of key squares when relevant
+`;

package/src/templates/data-generator.ts

@@ -8,7 +8,7 @@ import { Expando, S, create, defineFunction } from 'dxos:functions';
 import { randText } from 'https://esm.sh/@ngneat/falso@7.1.1?bundle=false';
 
 export default defineFunction({
-  key: 'dxos.org/script/data-generator',
+  key: 'org.dxos.script.data-generator',
   name: 'Data Generator',
   inputSchema: S.Struct({
     documentAmount: S.optional(S.Number),
@@ -23,7 +23,7 @@ export default defineFunction({
     data: { documentAmount = 1, textSize = 10, mutationAmount = 0, waitAfterCreation = 10_000 },
     context: { space },
   }: any) => {
-    await space.db.graph.schemaRegistry.addSchema([Expando]);
+    space.db.graph.registry.add([Expando]);
     const result: Record<string, any> = {};
     const objects: Expando[] = [];
 

package/src/templates/discord.ts

@@ -3,7 +3,7 @@
 //
 
 // @ts-ignore
-import { DXN, EchoObject, Filter, ObjectId, S, create, defineFunction } from 'dxos:functions';
+import { DXN, EchoObject, Filter, EntityId, S, create, defineFunction } from 'dxos:functions';
 // @ts-ignore
 import { FetchHttpClient } from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
 import {
@@ -22,14 +22,14 @@ import * as Redacted from 'https://esm.sh/effect@3.17.0/Redacted?bundle=false';
 import * as Ref from 'https://esm.sh/effect@3.17.0/Ref?bundle=false';
 
 const MessageSchema = S.Struct({
-  id: ObjectId,
+  id: EntityId,
   foreignId: S.Any, // bigint?
   from: S.String,
   created: S.String,
   content: S.String,
 }).pipe(
   EchoObject({
-    typename: 'example.com/type/Message',
+    typename: 'com.example.type.message',
     version: '0.1.0',
   }),
 );
@@ -42,7 +42,7 @@ const generateSnowflake = (unixTimestamp: number): bigint => {
 };
 
 export default defineFunction({
-  key: 'dxos.org/script/discord',
+  key: 'org.dxos.script.discord',
   name: 'Discord',
   inputSchema: S.Struct({
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
@@ -60,11 +60,11 @@ export default defineFunction({
   handler: ({ data: { channelId, queueId, after = DEFAULT_AFTER, pageSize = 5 }, context: { space } }: any) =>
     Effect.gen(function* () {
       const { token } = yield* Effect.tryPromise({
-        try: () => space.db.query(Filter.typename('dxos.org/type/AccessToken', { source: 'discord.com' })).first(),
+        try: () => space.db.query(Filter.typename('org.dxos.type.accessToken', { source: 'discord.com' })).first(),
         catch: (e: any) => e,
       });
       const { objects } = yield* Effect.tryPromise({
-        try: () => space.queues.queryQueue(DXN.parse(queueId)),
+        try: () => space.queues.queryQueue(DXN.tryMake(queueId)!),
         catch: (e: any) => e,
       });
       const backfill = objects.length === 0;
@@ -84,7 +84,7 @@ export default defineFunction({
           const queueMessages = messages
             .map((message: any) =>
               create(MessageSchema, {
-                id: ObjectId.random(),
+                id: EntityId.random(),
                 foreignId: message.id,
                 from: message.author.username,
                 created: message.timestamp,
@@ -94,7 +94,7 @@ export default defineFunction({
             .toReversed();
           if (queueMessages.length > 0) {
             yield* Effect.tryPromise({
-              try: () => space.queues.insertIntoQueue(DXN.parse(queueId), queueMessages),
+              try: () => space.queues.insertIntoQueue(DXN.tryMake(queueId)!, queueMessages),
               catch: (e: any) => e,
             });
             yield* Ref.update(newMessages, (n: any) => n + queueMessages.length);

package/src/templates/forex-effect.ts

@@ -2,41 +2,48 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
-import {
-  FetchHttpClient,
-  HttpClient,
-  HttpClientRequest,
-  // @ts-ignore
-} from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
-// @ts-ignore
-import * as Effect from 'https://esm.sh/effect@3.17.0/Effect?bundle=false';
-// @ts-ignore
-import * as Schedule from 'https://esm.sh/effect@3.17.0/Schedule?bundle=false';
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import * as Effect from 'effect/Effect';
+import * as Schedule from 'effect/Schedule';
+import * as Schema from 'effect/Schema';
 
-export default defineFunction({
-  key: 'dxos.org/script/forex-effect',
-  name: 'Forex Effect',
-  description: 'Returns the exchange rate between two currencies.',
+import { Operation } from '@dxos/compute';
+import { DXN } from '@dxos/keys';
 
-  inputSchema: S.Struct({
-    from: S.String.annotations({ description: 'The source currency' }),
-    to: S.String.annotations({ description: 'The target currency' }),
+const ForexEffect = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.script.forexEffect'),
+    name: 'Forex Effect',
+    description: 'Returns the exchange rate between two currencies.',
+  },
+  input: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
   }),
+  output: Schema.Any,
+});
 
-  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
-
-  handler: async ({ data: { from, to } }: any) =>
-    Effect.gen(function* () {
-      const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
+export default ForexEffect.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ from: rawFrom, to: rawTo }) {
+      const from = rawFrom.toUpperCase();
+      const to = rawTo.toUpperCase();
+      const json: any = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
         HttpClient.execute,
-        Effect.flatMap((res: any) => res.json),
-        Effect.timeout('1 second'),
+        Effect.flatMap((response) => response.json),
+        Effect.timeout('5 seconds'),
         Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
         Effect.scoped,
       );
 
-      return res.data.rates[to].toString();
-    }).pipe(Effect.provide(FetchHttpClient.layer)),
-});
+      const rate = json?.data?.rates?.[to];
+      if (rate == null) {
+        return yield* Effect.fail(new Error(`No rate found for ${from} -> ${to}`));
+      }
+
+      return rate.toString();
+    }, Effect.provide(FetchHttpClient.layer)),
+  ),
+);

package/src/templates/forex.ts

@@ -2,25 +2,36 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
-export default defineFunction({
-  key: 'dxos.org/script/forex',
-  name: 'Forex',
-  description: 'Returns the exchange rate between two currencies.',
+import { Operation } from '@dxos/compute';
+import { DXN } from '@dxos/keys';
 
-  inputSchema: S.Struct({
-    from: S.String.annotations({ description: 'The source currency' }),
-    to: S.String.annotations({ description: 'The target currency' }),
+const Forex = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.script.forex'),
+    name: 'Forex',
+    description: 'Returns the exchange rate between two currencies.',
+  },
+  input: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
   }),
+  output: Schema.Any,
+});
 
-  handler: async ({ data: { from, to } }: any) => {
-    const res = await fetch(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`);
-    const {
-      data: { rates },
-    } = await res.json();
+export default Forex.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ from: rawFrom, to: rawTo }) {
+      const from = rawFrom.toUpperCase();
+      const to = rawTo.toUpperCase();
+      const res = yield* Effect.promise(() => fetch(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`));
+      const {
+        data: { rates },
+      } = yield* Effect.promise(() => res.json());
 
-    return rates[to].toString();
-  },
-});
+      return rates[to].toString();
+    }),
+  ),
+);

package/src/templates/gmail.ts

@@ -3,7 +3,7 @@
 //
 
 // @ts-ignore
-import { EchoObject, Filter, ObjectId, S, create, defineFunction } from 'dxos:functions';
+import { EchoObject, Filter, EntityId, S, create, defineFunction } from 'dxos:functions';
 // @ts-ignore
 import {
   FetchHttpClient,
@@ -27,7 +27,7 @@ import * as Schedule from 'https://esm.sh/effect@3.17.0/Schedule?bundle=false';
 import * as Stream from 'https://esm.sh/effect@3.17.0/Stream?bundle=false';
 
 export default defineFunction({
-  key: 'dxos.org/script/gmail',
+  key: 'org.dxos.script.gmail',
   name: 'Gmail',
   inputSchema: S.Struct({
     mailboxId: S.String,
@@ -47,7 +47,7 @@ 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,
       });
 
@@ -74,7 +74,7 @@ export default defineFunction({
         catch: (e: any) => e,
       });
       const { objects } = yield* Effect.tryPromise({
-        try: () => space.queues.queryQueue(mailbox.queue.dxn),
+        try: () => space.queues.queryQueue(mailbox.queue.uri),
         catch: (e: any) => e,
       });
       const newMessages = yield* Ref.make([]);
@@ -105,7 +105,7 @@ export default defineFunction({
           }
           const subject = messageDetails.payload.headers.find((h: any) => h.name === 'Subject')?.value;
           const object = create(MessageType, {
-            id: ObjectId.random(),
+            id: EntityId.random(),
             created,
             sender,
             blocks: [
@@ -132,7 +132,7 @@ export default defineFunction({
           Stream.grouped(10),
           Stream.flatMap((batch: any) =>
             Effect.tryPromise({
-              try: () => space.queues.insertIntoQueue(mailbox.queue.dxn, Chunk.toReadonlyArray(batch)),
+              try: () => space.queues.insertIntoQueue(mailbox.queue.uri, Chunk.toReadonlyArray(batch)),
               catch: (e: any) => e,
             }),
           ),
@@ -175,8 +175,7 @@ const parseFromHeader = (value: string): { name?: string; email: string } | unde
 // 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({
@@ -198,7 +197,7 @@ const Text = S.TaggedStruct('text', {
 interface Text extends S.Schema.Type<typeof Text> {}
 
 const MessageType = S.Struct({
-  id: ObjectId,
+  id: EntityId,
   created: S.String.annotations({
     description: 'ISO date string when the message was sent.',
   }),
@@ -217,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>;