@dxos/plugin-script 0.8.4-main.7ace549 → 0.8.4-main.8baae0fced

package/src/notebook/vfs-parser.ts

@@ -42,6 +42,7 @@ export class VirtualTypeScriptParser {
   protected compilerOptions: ts.CompilerOptions = {
     target: ts.ScriptTarget.ES2020,
     module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
     strict: true,
     esModuleInterop: true,
     skipLibCheck: true,
@@ -91,7 +92,9 @@ export class VirtualTypeScriptParser {
     // Analyze each file.
     files.forEach((file) => {
       const sourceFile = env.getSourceFile(file.filename);
-      if (!sourceFile || !typeChecker) return;
+      if (!sourceFile || !typeChecker) {
+        return;
+      }
 
       const fileResults = this.analyzeSourceFile(sourceFile, typeChecker);
       results.push(...fileResults);
@@ -207,7 +210,9 @@ export class VirtualTypeScriptParser {
     signature: ts.Signature | undefined,
     typeChecker: ts.TypeChecker,
   ): Array<{ name: string; type: string }> {
-    if (!signature) return [];
+    if (!signature) {
+      return [];
+    }
 
     return signature.parameters.map((param) => ({
       name: param.getName(),
@@ -429,7 +434,9 @@ export class NotebookVirtualParser extends VirtualTypeScriptParser {
         const previousExports = new Set<string>();
         for (const [_prevCellId, prevAnalysis] of cellAnalysis) {
           prevAnalysis.exports.forEach((exp) => {
-            if (exp.name) previousExports.add(exp.name);
+            if (exp.name) {
+              previousExports.add(exp.name);
+            }
           });
         }
 

package/src/operations/create-script.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Octokit } from '@octokit/core';
+import * as Effect from 'effect/Effect';
+
+import { Script, Operation } from '@dxos/compute';
+
+import { templates } from '../templates';
+import { ScriptOperation } from '../types';
+
+const handler: Operation.WithHandler<typeof ScriptOperation.CreateScript> = ScriptOperation.CreateScript.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ name, gistUrl, initialTemplateId }) {
+      let source = templates[0].source;
+      let scriptName = name;
+
+      const gistId = gistUrl?.split('/').at(-1);
+      if (gistId) {
+        const octokit = new Octokit();
+        const response = yield* Effect.promise(() =>
+          octokit.request('GET /gists/{gist_id}', {
+            gist_id: gistId,
+          }),
+        );
+        const gistContent = Object.values(response.data.files ?? {})[0]?.content;
+        if (gistContent) {
+          source = gistContent;
+        }
+      }
+
+      if (initialTemplateId) {
+        const template = templates.find((template) => template.id === initialTemplateId);
+        if (template) {
+          source = template.source;
+          scriptName = scriptName || template.name;
+        }
+      }
+
+      return { object: Script.make({ name: scriptName, source }) };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const ScriptOperationHandlerSet = OperationHandlerSet.lazy(() => import('./create-script'));

package/src/plugin.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const ScriptPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
+export { ScriptOperationHandlerSet } from './operations';

package/src/templates/anthropic.ts

@@ -0,0 +1,49 @@
+//
+// 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';
+
+const Anthropic = Operation.make({
+  meta: {
+    key: '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/chat.ts

@@ -76,7 +76,7 @@ export default async ({ data: { bodyText }, context: { space, ai } }: any) => {
 
 const getContext = async ({ space }: any) => {
   let context = '';
-  const { objects: docs } = await space.crud.query({ __typename: 'dxos.org/type/Document' }).run();
+  const { objects: docs } = await space.crud.query({ __typename: 'org.dxos.type.document' }).run();
   for (const doc of docs) {
     const { content } = await space.crud.query({ id: doc.content }).first();
     context += content + '\n\n';

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 } from '@dxos/echo';
+import { Chess } from '@dxos/plugin-chess';
+import { GameRef, Game, loadGame } from '@dxos/plugin-game';
+
+const ChessBot = Operation.make({
+  meta: {
+    key: 'org.dxos.script.chess-bot',
+    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,248 @@
+//
+// 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 { AiRequest, GenerationObserver } from '@dxos/assistant';
+import { ArtifactId } from '@dxos/assistant';
+import { Trace, Operation, OperationRegistry } from '@dxos/compute';
+import { Collection, Database, Filter, Obj, Ref, Relation } 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: '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: 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: [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.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.runQuery(Filter.typename('org.dxos.type.spaceProperties'));
+          const rootCollection = yield* Database.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.add(
+            Markdown.make({
+              name: `${gameName} Commentary`,
+              content: `# ${gameName} Commentary\n\n${commentary}`,
+            }),
+          );
+
+          const documentRef = Ref.make(document);
+          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.getDXN(document).toString(), commentary });
+
+        yield* Database.flush();
+
+        return {
+          documentId: Obj.getDXN(document).toString(),
+          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]);
+    await space.db.graph.schemaRegistry.register([Expando]);
     const result: Record<string, any> = {};
     const objects: Expando[] = [];
 

package/src/templates/discord.ts

@@ -29,7 +29,7 @@ const MessageSchema = S.Struct({
   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,7 +60,7 @@ 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({

package/src/templates/forex-effect.ts

@@ -2,41 +2,47 @@
 // 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';
 
-  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: 'org.dxos.script.forex-effect',
+    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,35 @@
 // 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';
 
-  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: '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();
+    }),
+  ),
+);