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

package/src/notebook/vfs-parser.ts

@@ -6,7 +6,18 @@ import { createSystem, createVirtualTypeScriptEnvironment } from '@typescript/vf
 import ts from 'typescript';
 
 import { invariant } from '@dxos/invariant';
-import { trim } from '@dxos/util';
+
+import { builtIns, systemDefinitions } from './eval';
+
+/**
+ * Default system definitions.
+ */
+const systemFiles: VirtualFile[] = [
+  {
+    filename: '/lib.d.ts',
+    content: systemDefinitions,
+  },
+];
 
 export type ParsedExpression = {
   name?: string;
@@ -50,7 +61,7 @@ export class VirtualTypeScriptParser {
     // If no declarations found, check for standalone expression references.
     if (analysis.length === 0) {
       const sourcefilename = '/temp.ts';
-      const env = this.createEnvironment([{ filename: sourcefilename, content: input }, ...systemFiles]);
+      const env = this.createEnvironment([{ filename: sourcefilename, content: input }]);
       const sourceFile = env.getSourceFile(sourcefilename);
       const typeChecker = env.languageService.getProgram()?.getTypeChecker();
 
@@ -73,7 +84,7 @@ export class VirtualTypeScriptParser {
    * Analyze multiple files with full type information.
    */
   analyzeFiles(files: VirtualFile[]): ParsedExpression[] {
-    const env = this.createEnvironment([...files, ...systemFiles]);
+    const env = this.createEnvironment(files);
     const results: ParsedExpression[] = [];
     const typeChecker = env.languageService.getProgram()?.getTypeChecker();
 
@@ -96,7 +107,7 @@ export class VirtualTypeScriptParser {
     const results: ParsedExpression[] = [];
 
     const visit = (node: ts.Node) => {
-      // Function declarations
+      // Function declarations.
       if (ts.isFunctionDeclaration(node) && node.name) {
         const symbol = typeChecker.getSymbolAtLocation(node.name);
         const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, node);
@@ -123,7 +134,7 @@ export class VirtualTypeScriptParser {
             let returnType: string | undefined;
             let value: any;
 
-            // Get the type string
+            // Get the type string.
             const typeString = type ? typeChecker.typeToString(type) : 'any';
 
             // Check if it's a function.
@@ -146,7 +157,7 @@ export class VirtualTypeScriptParser {
               }
             }
 
-            // Find references in the initializer only
+            // Find references in the initializer only.
             const refs = declaration.initializer
               ? this.findReferences(declaration.initializer, sourceFile, typeChecker)
               : [];
@@ -164,7 +175,7 @@ export class VirtualTypeScriptParser {
         });
       }
 
-      // Class declarations
+      // Class declarations.
       else if (ts.isClassDeclaration(node) && node.name) {
         results.push({
           name: node.name.text,
@@ -212,42 +223,42 @@ export class VirtualTypeScriptParser {
     const localSymbols = new Set<string>();
 
     // First, collect local symbols (parameters, local variables).
-    const collectLocalSymbols = (n: ts.Node) => {
-      if (ts.isFunctionDeclaration(n) || ts.isArrowFunction(n) || ts.isFunctionExpression(n)) {
-        n.parameters.forEach((param) => {
+    const collectLocalSymbols = (node: ts.Node) => {
+      if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        node.parameters.forEach((param) => {
           if (ts.isIdentifier(param.name)) {
             localSymbols.add(param.name.text);
           }
         });
       }
 
-      if (ts.isVariableDeclaration(n) && ts.isIdentifier(n.name)) {
-        localSymbols.add(n.name.text);
+      if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+        localSymbols.add(node.name.text);
       }
 
-      ts.forEachChild(n, collectLocalSymbols);
+      ts.forEachChild(node, collectLocalSymbols);
     };
 
     collectLocalSymbols(node);
 
     // Then find all identifier references.
-    const findRefs = (n: ts.Node) => {
-      if (ts.isIdentifier(n)) {
-        // Skip if it's a local symbol
-        if (!localSymbols.has(n.text)) {
+    const findRefs = (node: ts.Node) => {
+      if (ts.isIdentifier(node)) {
+        // Skip if it's a local symbol.
+        if (!localSymbols.has(node.text)) {
           // Check if it's a reference (not a declaration).
-          const parent = n.parent;
+          const parent = node.parent;
           const isDeclaration =
-            (ts.isVariableDeclaration(parent) && parent.name === n) ||
-            (ts.isFunctionDeclaration(parent) && parent.name === n) ||
-            (ts.isParameter(parent) && parent.name === n);
+            (ts.isVariableDeclaration(parent) && parent.name === node) ||
+            (ts.isFunctionDeclaration(parent) && parent.name === node) ||
+            (ts.isParameter(parent) && parent.name === node);
 
-          if (!isDeclaration && !this.isBuiltIn(n.text)) {
-            references.add(n.text);
+          if (!isDeclaration && !this.isBuiltIn(node.text)) {
+            references.add(node.text);
           }
         }
       }
-      ts.forEachChild(n, findRefs);
+      ts.forEachChild(node, findRefs);
     };
 
     findRefs(node);
@@ -274,7 +285,7 @@ export class VirtualTypeScriptParser {
           const type = typeChecker.getTypeAtLocation(expr.right);
           const typeString = typeChecker.typeToString(type);
 
-          // Get the literal value if it's a literal
+          // Get the literal value if it's a literal.
           let value: any;
           if (ts.isNumericLiteral(expr.right)) {
             value = Number(expr.right.text);
@@ -282,7 +293,7 @@ export class VirtualTypeScriptParser {
             value = expr.right.text;
           }
 
-          // Find references in the right-hand side
+          // Find references in the right-hand side.
           const references = this.findReferences(expr.right, sourceFile, typeChecker);
 
           result = {
@@ -336,15 +347,17 @@ export class VirtualTypeScriptParser {
   }
 
   protected createEnvironment(files: VirtualFile[]) {
+    const allFiles = [...systemFiles, ...files];
+
     const fileMap = new Map<string, string>();
-    files.forEach(({ filename, content }) => {
+    allFiles.forEach(({ filename, content }) => {
       fileMap.set(filename, content);
     });
 
     const system = createSystem(fileMap);
     return createVirtualTypeScriptEnvironment(
       system,
-      files.map(({ filename }) => filename),
+      allFiles.map(({ filename }) => filename),
       ts,
       this.compilerOptions,
     );
@@ -359,7 +372,7 @@ export class NotebookVirtualParser extends VirtualTypeScriptParser {
    * Analyze notebook cells with full type checking.
    */
   analyzeNotebook(cells: Array<{ id: string; code: string }>) {
-    // Create cumulative environment where each cell can see previous cells
+    // Create cumulative environment where each cell can see previous cells.
     const cumulativeCode: string[] = [];
     const cellAnalysis: Map<
       string,
@@ -390,7 +403,7 @@ export class NotebookVirtualParser extends VirtualTypeScriptParser {
       });
 
       // Create environment.
-      const env = this.createEnvironment([...files, ...systemFiles]);
+      const env = this.createEnvironment(files);
 
       // Get diagnostics (errors).
       const diagnostics = env.languageService.getSemanticDiagnostics(filename);
@@ -436,55 +449,3 @@ export class NotebookVirtualParser extends VirtualTypeScriptParser {
     return cellAnalysis;
   }
 }
-
-/**
- * Globals.
- */
-const builtIns = new Set([
-  // Types.
-  'Array',
-  'Date',
-  'Error',
-  'JSON',
-  'Map',
-  'Math',
-  'Number',
-  'Promise',
-  'Object',
-  'RegExp',
-  'Set',
-  'String',
-
-  // Functions.
-  'console',
-  'document',
-  'global',
-  'isFinite',
-  'isNaN',
-  'parseFloat',
-  'parseInt',
-  'process',
-  'window',
-]);
-
-/**
- * Default system definitions.
- */
-const systemFiles: VirtualFile[] = [
-  {
-    filename: '/lib.d.ts',
-    content: trim`
-      interface Array<T> { length: number; [n: number]: T; }
-      interface Boolean {}
-      interface Function {}
-      interface IArguments {}
-      interface Number {}
-      interface Object {}
-      interface RegExp {}
-      interface String { length: number; }
-      interface CallableFunction extends Function {}
-      interface NewableFunction extends Function {}
-      declare var console: { log(...args: any[]): void };
-    `,
-  },
-];

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, Ref } 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: Ref.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.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.flush();
+    return { state: chess.ascii() };
+  }),
+});

package/src/templates/commentary.ts

@@ -0,0 +1,231 @@
+//
+// 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 } from '@dxos/echo';
+import { Collection } 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 { 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: Ref.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.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.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('dxos.org/type/Properties'));
+        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.change(rootCollection, (c) => {
+          c.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,
+        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

@@ -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/forex-effect.ts

@@ -2,41 +2,36 @@
 // 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';
+
+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('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)),
+    return (res as any).data.rates[to].toString();
+  }, Effect.provide(FetchHttpClient.layer)),
 });

package/src/templates/forex.ts

@@ -2,20 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } 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 },