@dxos/plugin-script 0.8.4-main.67995b8 → 0.8.4-main.69d29f4

package/src/templates/anthropic.ts

@@ -0,0 +1,42 @@
+//
+// 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 { defineFunction } from '@dxos/functions';
+
+export default defineFunction({
+  key: 'dxos.org/script/anthropic',
+  name: 'Anthropic Chat',
+  description: 'Chat with Anthropic',
+  inputSchema: Schema.Struct({
+    message: Schema.String,
+  }),
+  services: [AiService.AiService],
+  handler: ({ data }) => {
+    return Effect.gen(function* () {
+      const model = (yield* AiService.AiService).model('@anthropic/claude-sonnet-4-5');
+      //
+      // Basic example.
+      //
+      const { text } = yield* LanguageModel.generateText({ prompt: data.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,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Chess as ChessJS } from 'chess.js';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Database, Obj, Type } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+import { Chess } from '@dxos/plugin-chess/types';
+
+export default defineFunction({
+  key: 'dxos.org/script/chess-bot',
+  name: 'Chess Bot',
+  description: 'Plays a random move in a chess game.',
+
+  inputSchema: Schema.Struct({
+    game: Type.Ref(Chess.Game).annotations({
+      description: 'The chess game to comment on.',
+    }),
+    player: Schema.optional(Schema.Literal('white', 'black')).annotations({
+      description: 'The player to play the game as.',
+    }),
+  }),
+
+  outputSchema: Schema.Struct({
+    state: Schema.String.annotations({
+      description: 'The state of the game as an ASCII art board.',
+    }),
+  }),
+
+  types: [Chess.Game],
+  services: [Database.Service],
+
+  handler: Effect.fnUntraced(function* ({ data: { game, player = 'black' } }) {
+    const loadedGame = yield* Database.Service.load(game);
+    const chess = new ChessJS();
+    chess.loadPgn(loadedGame.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.change(loadedGame, (g) => {
+      g.pgn = newPgn;
+    });
+    yield* Database.Service.flush();
+    return { state: chess.ascii() };
+  }),
+});

package/src/templates/commentary.ts

@@ -0,0 +1,232 @@
+//
+// 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 { AiSession, GenerationObserver } from '@dxos/assistant';
+import { ArtifactId } from '@dxos/assistant';
+import { Database, Filter, Obj, Ref, Relation, Type } from '@dxos/echo';
+import { createDocAccessor } from '@dxos/echo-db';
+import { TracingService, defineFunction } from '@dxos/functions';
+import { log } from '@dxos/log';
+import { Chess } from '@dxos/plugin-chess/types';
+import { Markdown } from '@dxos/plugin-markdown/types';
+import { Collection, Text } from '@dxos/schema';
+import { HasSubject } from '@dxos/types';
+import { trim } from '@dxos/util';
+
+export default defineFunction({
+  key: 'dxos.org/function/chess/commentary',
+  name: 'Commentary',
+  description: 'Adds commentary about the most recent move to a markdown document associated with the chess game.',
+  inputSchema: Schema.Struct({
+    game: Type.Ref(Chess.Game).annotations({
+      description: 'The chess game to comment on.',
+    }),
+  }),
+  outputSchema: Schema.Union(
+    Schema.Struct({
+      documentId: ArtifactId.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: [Chess.Game, Markdown.Document, Text.Text, HasSubject.HasSubject, Collection.Collection],
+  services: [AiService.AiService, Database.Service],
+  handler: Effect.fnUntraced(
+    function* ({ data: { game: gameRef } }) {
+      // Load the chess game
+      log.info('load game', { gameRef });
+      const chessGame = yield* Database.Service.load(gameRef);
+
+      // Load the chess position from PGN or FEN
+      const chess = new ChessJS();
+      if (chessGame.pgn) {
+        chess.loadPgn(chessGame.pgn);
+      } else if (chessGame.fen) {
+        chess.load(chessGame.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 AiSession().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: [],
+        observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'chess-commentary' })),
+      });
+
+      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.Service.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.Service.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.getDXN(Relation.getTarget(relation)).toString(),
+                game: Obj.getDXN(chessGame).toString(),
+              });
+              return Obj.getDXN(Relation.getTarget(relation)).toString() === Obj.getDXN(chessGame).toString();
+            } 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.Service.runQuery(Filter.typename('dxos.org/type/Properties'));
+        const rootCollection = yield* Database.Service.load<Collection.Collection>(
+          properties[Collection.Collection.typename],
+        );
+
+        log.info('rootCollection', { rootCollection });
+
+        // Create a new markdown document
+        const gameName = chessGame.name || 'Chess Game';
+        document = yield* Database.Service.add(
+          Markdown.make({
+            name: `${gameName} Commentary`,
+            content: `# ${gameName} Commentary\n\n${commentary}`,
+          }),
+        );
+
+        const documentRef = Ref.make(document);
+        Obj.change(rootCollection, (c) => {
+          c.objects.push(documentRef);
+        });
+
+        // Create the HasSubject relation
+        yield* Database.Service.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.Service.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.getDXN(document).toString(), commentary });
+
+      yield* Database.Service.flush();
+
+      return {
+        documentId: Obj.getDXN(document).toString(),
+        commentary,
+      };
+    },
+    Effect.provide(
+      Layer.mergeAll(
+        AiService.model('@anthropic/claude-haiku-4-5'),
+        ToolResolverService.layerEmpty,
+        ToolExecutionService.layerEmpty,
+        TracingService.layerNoop,
+      ),
+    ),
+  ),
+});
+
+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

@@ -3,21 +3,27 @@
 //
 
 // @ts-ignore
-import { defineFunction, S, create, Expando } from 'dxos:functions';
+import { Expando, S, create, defineFunction } from 'dxos:functions';
 // @ts-ignore
 import { randText } from 'https://esm.sh/@ngneat/falso@7.1.1?bundle=false';
 
 export default defineFunction({
+  key: 'dxos.org/script/data-generator',
+  name: 'Data Generator',
   inputSchema: S.Struct({
     documentAmount: S.optional(S.Number),
     textSize: S.optional(S.Number),
     mutationAmount: S.optional(S.Number),
+    waitAfterCreation: S.optional(S.Number),
   }),
 
   outputSchema: S.Struct({}),
 
-  handler: async ({ data: { documentAmount = 1, textSize = 10, mutationAmount = 0 }, context: { space } }: any) => {
-    await space.db.graph.schemaRegistry.addSchema([Expando]);
+  handler: async ({
+    data: { documentAmount = 1, textSize = 10, mutationAmount = 0, waitAfterCreation = 10_000 },
+    context: { space },
+  }: any) => {
+    await space.db.graph.schemaRegistry.register([Expando]);
     const result: Record<string, any> = {};
     const objects: Expando[] = [];
 
@@ -42,7 +48,7 @@ export default defineFunction({
 
     // Flush and wait for data to propagate.
     await space.db.flush();
-    await new Promise((resolve) => setTimeout(resolve, 10_000));
+    await new Promise((resolve) => setTimeout(resolve, waitAfterCreation));
     return { createdObjects: objects.length };
   },
 });

package/src/templates/discord.ts

@@ -3,17 +3,23 @@
 //
 
 // @ts-ignore
-import { create, defineFunction, DXN, EchoObject, Filter, ObjectId, S } from 'dxos:functions';
+import { DXN, EchoObject, Filter, ObjectId, S, create, defineFunction } from 'dxos:functions';
 // @ts-ignore
-import { FetchHttpClient } from 'https://esm.sh/@effect/platform@0.77.2?deps=effect@3.14.21&bundle=false';
+import { FetchHttpClient } from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
 import {
   DiscordConfig,
   DiscordREST,
   DiscordRESTMemoryLive,
   // @ts-ignore
-} from 'https://esm.sh/dfx@0.113.0?deps=effect@3.14.21&bundle=false';
+} from 'https://esm.sh/dfx@0.113.0?deps=effect@3.17.0&bundle=false';
 // @ts-ignore
-import { Effect, Config, Redacted, Ref } from 'https://esm.sh/effect@3.14.21?bundle=false';
+import * as Config from 'https://esm.sh/effect@3.17.0/Config?bundle=false';
+// @ts-ignore
+import * as Effect from 'https://esm.sh/effect@3.17.0/Effect?bundle=false';
+// @ts-ignore
+import * as Redacted from 'https://esm.sh/effect@3.17.0/Redacted?bundle=false';
+// @ts-ignore
+import * as Ref from 'https://esm.sh/effect@3.17.0/Ref?bundle=false';
 
 const MessageSchema = S.Struct({
   id: ObjectId,
@@ -36,6 +42,8 @@ const generateSnowflake = (unixTimestamp: number): bigint => {
 };
 
 export default defineFunction({
+  key: 'dxos.org/script/discord',
+  name: 'Discord',
   inputSchema: S.Struct({
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
     tick: S.optional(S.String),

package/src/templates/forex-effect.ts

@@ -2,37 +2,36 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
-import {
-  HttpClient,
-  HttpClientRequest,
-  FetchHttpClient,
-  // @ts-ignore
-} from 'https://esm.sh/@effect/platform@0.77.2?deps=effect@3.14.21&bundle=false';
-// @ts-ignore
-import { Effect, Schedule } from 'https://esm.sh/effect@3.14.21?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';
+
+import { defineFunction } from '@dxos/functions';
 
 export default defineFunction({
+  key: 'dxos.org/script/forex-effect',
+  name: 'Forex Effect',
   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' }),
+  inputSchema: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
   }),
 
-  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
+  outputSchema: Schema.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(
-        HttpClient.execute,
-        Effect.flatMap((res: any) => res.json),
-        Effect.timeout('1 second'),
-        Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
-        Effect.scoped,
-      );
+  handler: Effect.fnUntraced(function* ({ data: { from, to } }) {
+    const res = 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.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
+      Effect.scoped,
+    );
 
-      return res.data.rates[to].toString();
-    }).pipe(Effect.provide(FetchHttpClient.layer)),
+    return (res as any).data.rates[to].toString();
+  }, Effect.provide(FetchHttpClient.layer)),
 });

package/src/templates/forex.ts

@@ -2,18 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { defineFunction, S } from 'dxos:functions';
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
 
 export default defineFunction({
+  key: 'dxos.org/script/forex',
+  name: 'Forex',
   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' }),
+  inputSchema: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
   }),
 
-  handler: async ({ data: { from, to } }: any) => {
+  handler: async ({ data: { from, to } }) => {
     const res = await fetch(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`);
     const {
       data: { rates },

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: 'dxos.org/script/gmail',
+  name: 'Gmail',
   inputSchema: S.Struct({
     mailboxId: S.String,
     userId: S.optional(S.String).pipe(S.withDecodingDefault(() => 'me')),
@@ -41,7 +53,7 @@ export default defineFunction({
 
       // 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,17 +157,17 @@ 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;
 };
 
 //
@@ -163,8 +175,7 @@ const parseEmailString = (emailString: string): { name?: string; email: string }
 // 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(