@dxos/assistant 0.8.4-main.b97322e → 0.8.4-main.bc674ce

package/src/extraction/extraction-ner-function/extraction-ner-function.test.ts

@@ -2,39 +2,42 @@
 // Copyright 2025 DXOS.org
 //
 
-import { describe, test, beforeAll } from 'vitest';
+import { beforeAll, describe, test } from 'vitest';
 
-import { type EchoDatabase } from '@dxos/echo-db';
+import { type Database } from '@dxos/echo';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
-import { FunctionExecutor, ServiceContainer } from '@dxos/functions';
+import { FunctionExecutor, ServiceContainer } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
-import { createTestData, Testing } from '@dxos/schema/testing';
+import { TestSchema } from '@dxos/schema/testing';
+import { type Message, Organization, Person } from '@dxos/types';
+import { createTestData } from '@dxos/types/testing';
 import { range } from '@dxos/util';
 
-import { extractionNerFn } from './extraction-ner-function';
 import { processTranscriptMessage } from '../extraction';
 
+import { extractionNerFunction } from './extraction-ner-function';
+
 describe.skip('NER EntityExtraction', () => {
   let builder: EchoTestBuilder;
-  let db: EchoDatabase;
+  let db: Database.Database;
   let executor: FunctionExecutor;
   let testData: {
-    transcriptJosiah: DataType.Message[];
-    transcriptWoflram: DataType.Message[];
-    transcriptMessages: DataType.Message[];
-    documents: Testing.DocumentType[];
-    contacts: Record<string, DataType.Person>;
-    organizations: Record<string, DataType.Organization>;
+    transcriptJosiah: Message.Message[];
+    transcriptWoflram: Message.Message[];
+    transcriptMessages: Message.Message[];
+    documents: TestSchema.DocumentType[];
+    contacts: Record<string, Person.Person>;
+    organizations: Record<string, Organization.Organization>;
   };
-  const TYPES = [DataType.Organization, DataType.Person, Testing.Contact, Testing.DocumentType];
+
+  const TYPES = [Organization.Organization, Person.Person, TestSchema.Person, TestSchema.DocumentType];
 
   beforeAll(async () => {
     // TODO(dmaretskyi): Helper to scaffold this from a config.
     builder = await new EchoTestBuilder().open();
     const { db: db1 } = await builder.createDatabase({ indexing: { vector: true } });
     db = db1;
-    db.graph.schemaRegistry.addSchema(TYPES);
+    await db.graph.schemaRegistry.register(TYPES);
     const data = createTestData();
     testData = {
       transcriptJosiah: data.transcriptJosiah,
@@ -44,8 +47,8 @@ describe.skip('NER EntityExtraction', () => {
       contacts: Object.fromEntries(Object.entries(data.contacts).map(([key, value]) => [key, db.add(value)])),
       organizations: Object.fromEntries(Object.entries(data.organizations).map(([key, value]) => [key, db.add(value)])),
     };
-    await db.flush();
 
+    await db.flush();
     executor = new FunctionExecutor(
       new ServiceContainer().setServices({
         database: { db },
@@ -64,7 +67,7 @@ describe.skip('NER EntityExtraction', () => {
           message,
           objects: [...documents, ...Object.values(contacts)],
         },
-        function: extractionNerFn,
+        function: extractionNerFunction,
         executor,
       });
       log.info('output', enhancedMessage);
@@ -73,7 +76,6 @@ describe.skip('NER EntityExtraction', () => {
 
   test('computational irreducibility', async () => {
     const { transcriptWoflram, documents, contacts } = testData;
-
     log.info('context', { documents, contacts });
     const message = transcriptWoflram[0];
     log.info('input', message);
@@ -85,7 +87,7 @@ describe.skip('NER EntityExtraction', () => {
             message,
             objects: [...documents, ...Object.values(contacts)],
           },
-          function: extractionNerFn,
+          function: extractionNerFunction,
           executor,
         });
         log.info('output', { message: enhancedMessage.blocks[0], timeElapsed });
@@ -95,7 +97,6 @@ describe.skip('NER EntityExtraction', () => {
 
   test('org and document linking', async () => {
     const { transcriptJosiah, documents, contacts, organizations } = testData;
-
     log.info('context', { contacts, organizations, documents });
 
     for (const message of transcriptJosiah) {
@@ -106,7 +107,7 @@ describe.skip('NER EntityExtraction', () => {
           message,
           objects: [...documents, ...Object.values(contacts), ...Object.values(organizations)],
         },
-        function: extractionNerFn,
+        function: extractionNerFunction,
         executor,
       });
       log.info('output', enhancedMessage);

package/src/extraction/extraction-ner-function/extraction-ner-function.ts

@@ -2,56 +2,55 @@
 // Copyright 2025 DXOS.org
 //
 
-// TODO(burdon): Fix.
-// @ts-nocheck
+import { defineFunction } from '@dxos/functions';
 
-import { asyncTimeout } from '@dxos/async';
-import { create } from '@dxos/echo-schema';
-import { DatabaseService, defineFunction } from '@dxos/functions';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
-
-import { extractFullEntities } from './named-entity-recognition';
 import { ExtractionInput, ExtractionOutput } from '../extraction';
-import { findQuotes, insertReferences } from '../quotes';
 
+/**
+ * Named Entity Recognition model
+ */
 // TODO(mykola): Make it use vector index to query objects and not pass objects as input.
-export const extractionNerFn = defineFunction({
+export const extractionNerFunction = defineFunction({
+  key: 'dxos.org/function/extraction/extract-entities',
+  name: 'Extract Entities',
   description: 'Extracts named entities from a text',
   inputSchema: ExtractionInput,
   outputSchema: ExtractionOutput,
   handler: async ({ data: { message, options }, context }) => {
-    log.info('input', { message, options });
-    const startTime = performance.now();
-    const { db } = context.getService(DatabaseService);
-
-    const entitiesPromise = Promise.all(
-      message.blocks.map(async (block) => {
-        invariant(block._tag === 'transcript' || block._tag === 'text', 'Block must have text');
-        return extractFullEntities(block.text);
-      }),
-    ).then((entities) => entities.flat());
-    const entities = options?.timeout ? await asyncTimeout(entitiesPromise, options.timeout) : await entitiesPromise;
-    log.info('entities', { entities });
-    const quoteReferences = await findQuotes(
-      entities.map((entity) => entity.word),
-      db,
-    );
-    const blocksWithReferences = message.blocks.map((block, i) => {
-      invariant(block._tag === 'transcript' || block._tag === 'text', 'Block must have text');
-      return { ...block, text: insertReferences(block._tag, quoteReferences) };
-    });
-    const messageWithReferences = create(DataType.Message, {
-      ...message,
-      blocks: blocksWithReferences,
-    });
-
-    log.info('output', { messageWithReferences });
-
-    return {
-      message: messageWithReferences,
-      timeElapsed: performance.now() - startTime,
-    };
+    throw new Error('not implemented');
+    // log.info('input', { message, options });
+    // const startTime = performance.now();
+    // const { db } = context.getService(Database.Service);
+    // const { extractFullEntities } = await import('./named-entity-recognition');
+
+    // const entitiesPromise = Promise.all(
+    //   message.blocks.map(async (block) => {
+    //     invariant(block._tag === 'transcript' || block._tag === 'text');
+    //     return extractFullEntities(block.text);
+    //   }),
+    // ).then((entities) => entities.flat());
+    // const entities = options?.timeout ? await asyncTimeout(entitiesPromise, options.timeout) : await entitiesPromise;
+
+    // log.info('entities', { entities });
+    // const quoteReferences = await findQuotes(
+    //   entities.map((entity) => entity.word),
+    //   db,
+    // );
+
+    // const blocksWithReferences = message.blocks.map((block) => {
+    //   invariant(block._tag === 'transcript' || block._tag === 'text');
+    //   return { ...block, text: insertReferences(block._tag, quoteReferences) };
+    // });
+
+    // const messageWithReferences = create(Message.Message, {
+    //   ...message,
+    //   blocks: blocksWithReferences,
+    // });
+
+    // log.info('output', { messageWithReferences });
+    // return {
+    //   message: messageWithReferences,
+    //   timeElapsed: performance.now() - startTime,
+    // };
   },
 });

package/src/extraction/extraction-ner-function/named-entity-recognition.test.ts

@@ -6,11 +6,13 @@ import { type TokenClassificationOutput, type TokenClassificationPipelineType }
 import { beforeAll, describe, expect, test } from 'vitest';
 
 import { log } from '@dxos/log';
-import { createTestData } from '@dxos/schema/testing';
+import { type ContentBlock, type Message } from '@dxos/types';
+import { createTestData } from '@dxos/types/testing';
 
 import { combineNerTokens, createTokenGroups, extractFullEntities, getNer } from './named-entity-recognition';
 
-describe('NamedEntityRecognition', () => {
+// TODO(mykola): This should not run on CI.
+describe.skip('NamedEntityRecognition', () => {
   let ner: TokenClassificationPipelineType;
 
   beforeAll(async () => {
@@ -56,8 +58,10 @@ describe('NamedEntityRecognition', () => {
   test('own data', async () => {
     const { transcriptWoflram, transcriptJosiah } = await createTestData();
 
-    const blocks = [...transcriptWoflram, ...transcriptJosiah].flatMap((message) =>
-      message.blocks.flatMap((block) => (block._tag === 'transcript' ? [block.text] : [])),
+    const blocks = [...transcriptWoflram, ...transcriptJosiah].flatMap((message: Message.Message) =>
+      message.blocks.flatMap((block: ContentBlock.Any) =>
+        block._tag === 'transcript' ? [(block as ContentBlock.Transcript).text] : [],
+      ),
     );
 
     for (const block of blocks) {
@@ -69,8 +73,10 @@ describe('NamedEntityRecognition', () => {
   test('more own data', async () => {
     const { transcriptMessages } = await createTestData();
 
-    const blocks = transcriptMessages.flatMap((message) =>
-      message.blocks.flatMap((block) => (block._tag === 'transcript' ? [block.text] : [])),
+    const blocks = transcriptMessages.flatMap((message: Message.Message) =>
+      message.blocks.flatMap((block: ContentBlock.Any) =>
+        block._tag === 'transcript' ? [(block as ContentBlock.Transcript).text] : [],
+      ),
     );
 
     for (const block of blocks) {

package/src/extraction/extraction-ner-function/named-entity-recognition.ts

@@ -12,6 +12,7 @@ import {
 import { log } from '@dxos/log';
 
 let _ner: Promise<TokenClassificationPipelineType>;
+
 /**
  * Named Entity Recognition pipeline.
  * Initializes the pipeline on first call.
@@ -24,6 +25,7 @@ export const getNer = () => {
       return ner;
     });
   }
+
   return _ner;
 };
 

package/src/extraction/extraction.ts

@@ -2,17 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { asyncTimeout } from '@dxos/async';
-import { Expando } from '@dxos/echo-schema';
-import { type FunctionDefinition, type FunctionExecutor } from '@dxos/functions';
+import { Type } from '@dxos/echo';
+import { type FunctionDefinition } from '@dxos/functions';
+import { type FunctionExecutor } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Message } from '@dxos/types';
 
 export const ExtractionInput = Schema.Struct({
-  message: DataType.Message,
-  objects: Schema.optional(Schema.Array(Expando)),
+  message: Message.Message,
+  objects: Schema.optional(Schema.Array(Type.Obj)),
   options: Schema.optional(
     Schema.Struct({
       timeout: Schema.optional(Schema.Number),
@@ -23,12 +24,12 @@ export const ExtractionInput = Schema.Struct({
 export interface ExtractionInput extends Schema.Schema.Type<typeof ExtractionInput> {}
 
 export const ExtractionOutput = Schema.Struct({
-  message: DataType.Message,
+  message: Message.Message,
   timeElapsed: Schema.Number,
 });
 export interface ExtractionOutput extends Schema.Schema.Type<typeof ExtractionOutput> {}
 
-export type ProcessTranscriptMessageParams = {
+export type ProcessTranscriptMessageProps = {
   input: ExtractionInput;
   function: FunctionDefinition<ExtractionInput, ExtractionOutput>;
   executor: FunctionExecutor;
@@ -54,7 +55,7 @@ export type ExtractionFunction = FunctionDefinition<ExtractionInput, ExtractionO
  * Extract entities from the transcript message and add them to the message.
  */
 // TODO(dmaretskyi): Move context to a vector search index.
-export const processTranscriptMessage = async (params: ProcessTranscriptMessageParams): Promise<ExtractionOutput> => {
+export const processTranscriptMessage = async (params: ProcessTranscriptMessageProps): Promise<ExtractionOutput> => {
   try {
     if (params.options?.timeout && params.options.timeout > 0) {
       return await asyncTimeout(params.executor.invoke(params.function, params.input), params.options.timeout);

package/src/extraction/quotes.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { describe, test, expect } from 'vitest';
+import { describe, expect, test } from 'vitest';
 
 import { insertReferences } from './quotes';
 
@@ -13,7 +13,7 @@ describe('insertReferences', () => {
     };
 
     expect(insertReferences('This is a computational irreducibility test.', quotes)).toBe(
-      'This is a [computational irreducibility][dxn:echo:@:01JTG9JW11XGWJZ32AW8ET93D1] test.',
+      'This is a [computational irreducibility](dxn:echo:@:01JTG9JW11XGWJZ32AW8ET93D1) test.',
     );
     expect(
       insertReferences(
@@ -21,7 +21,7 @@ describe('insertReferences', () => {
         quotes,
       ),
     ).toBe(
-      "And what I'd like to talk today about is Steven Wolfram's concept of a [computational irreducibility][dxn:echo:@:01JTG9JW11XGWJZ32AW8ET93D1].",
+      "And what I'd like to talk today about is Steven Wolfram's concept of a [computational irreducibility](dxn:echo:@:01JTG9JW11XGWJZ32AW8ET93D1).",
     );
   });
 });

package/src/extraction/quotes.ts

@@ -2,11 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
-import { Query, Filter } from '@dxos/echo';
-import { type EchoDatabase } from '@dxos/echo-db';
-import { ObjectId } from '@dxos/echo-schema';
+import { type Database, Filter, Query } from '@dxos/echo';
+import { ObjectId } from '@dxos/keys';
 import { DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
 
@@ -28,10 +27,10 @@ export const ReferencedQuotes = Schema.Struct({
 });
 export type ReferencedQuotes = Schema.Schema.Type<typeof ReferencedQuotes>;
 
-export const findQuotes = async (quotes: string[], db: EchoDatabase): Promise<ReferencedQuotes> => {
+export const findQuotes = async (quotes: string[], db: Database.Database): Promise<ReferencedQuotes> => {
   const references = await Promise.all(
     quotes.map(async (quote) => {
-      const { objects } = await db.query(Query.select(Filter.text(quote, { type: 'vector' }))).run();
+      const objects = await db.query(Query.select(Filter.text(quote, { type: 'vector' }))).run();
       log.info('found quotes in vector index', { objects, quote });
       return objects.length > 0 ? [{ id: objects[0].id.toString(), quote }] : [];
     }),
@@ -51,7 +50,7 @@ export const insertReferences = (text: string, quotes: ReferencedQuotes) => {
 
     // Use a case-insensitive regular expression to replace the quote.
     const regex = new RegExp(quote.quote.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
-    text = text.replace(regex, `[${quote.quote}][${DXN.fromLocalObjectId(quote.id).toString()}]`);
+    text = text.replace(regex, `[${quote.quote}](${DXN.fromLocalObjectId(quote.id).toString()})`);
   }
 
   return text;

package/src/functions/services.ts

@@ -2,72 +2,140 @@
 // Copyright 2025 DXOS.org
 //
 
-import { AiTool } from '@effect/ai';
-import { Context, Effect, Layer, Match, Predicate, Record, Schema } from 'effect';
+import * as Tool from '@effect/ai/Tool';
+import type * as Toolkit from '@effect/ai/Toolkit';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Record from 'effect/Record';
+import * as Schema from 'effect/Schema';
+import type * as SchemaAST from 'effect/SchemaAST';
 
 import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from '@dxos/ai';
 import { todo } from '@dxos/debug';
-import { FunctionError, type FunctionContext, type FunctionDefinition, type Services } from '@dxos/functions';
+import { Query, Type } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { Function, FunctionDefinition, FunctionInvocationService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 
+import { RefFromLLM } from '../types';
+
+/**
+ * Constructs a `ToolResolverService` whose `resolve(id)` looks up tools in the following order:
+ *  1. Toolkit: return an existing tool from the provided `toolkit` if one is present under `id`.
+ *  2. Functions in DB: query `FunctionType` by `key=id`; if found, deserialize and project to a tool
+ *     (propagating any `deployedFunctionId` discovered in the object's metadata).
+ *  3. Functions passed in: fall back to a matching `FunctionDefinition` from the `functions` array.
+ *
+ * If none of the above yield a match, the effect fails with `AiToolNotFoundError`.
+ *
+ * Requires `Database.Service` in the environment.
+ */
 export const makeToolResolverFromFunctions = (
-  functions: FunctionDefinition<any, any>[],
-): Layer.Layer<ToolResolverService> => {
-  return Layer.succeed(ToolResolverService, {
-    resolve: Effect.fn('resolveTool')(function* (id) {
-      const fn = functions.find((f) => f.name === id);
-      if (!fn) {
-        return yield* Effect.fail(new AiToolNotFoundError(id));
-      }
-
-      return projectFunctionToTool(fn);
+  functions: FunctionDefinition.Any[],
+  toolkit: Toolkit.Toolkit<any>,
+): Layer.Layer<ToolResolverService, never, Database.Service> => {
+  return Layer.effect(
+    ToolResolverService,
+    Effect.gen(function* () {
+      const dbService = yield* Database.Service;
+      return {
+        resolve: (id): Effect.Effect<Tool.Any, AiToolNotFoundError> =>
+          Effect.gen(function* () {
+            // TODO(dmaretskyi): Use FunctionInvocationService.resolveFunction().
+
+            const tool = toolkit.tools[id];
+            if (tool) {
+              return tool;
+            }
+
+            const [dbFunction] = yield* Database.Service.runQuery(Query.type(Function.Function, { key: id }));
+
+            const functionDef = dbFunction
+              ? FunctionDefinition.deserialize(dbFunction)
+              : functions.find((fn) => fn.key === id);
+
+            if (!functionDef) {
+              return yield* Effect.fail(new AiToolNotFoundError(id));
+            }
+
+            return projectFunctionToTool(functionDef);
+          }).pipe(Effect.provideService(Database.Service, dbService)),
+      } satisfies Context.Tag.Service<ToolResolverService>;
     }),
-  });
+  );
 };
 
 export const makeToolExecutionServiceFromFunctions = (
-  functions: FunctionDefinition<any, any>[],
-): Layer.Layer<ToolExecutionService> => {
-  return Layer.succeed(ToolExecutionService, {
-    handlersFor: (toolkit) => {
-      const makeHandler = (tool: AiTool.Any): ((params: unknown) => Effect.Effect<unknown, any, any>) => {
-        return Effect.fn('toolFunctionHandler')(function* (input: any) {
-          const { functionName } = Context.get(FunctionToolAnnotation)(tool.annotations as any);
-          const fnDef = functions.find((f) => f.name === functionName);
-          if (!fnDef) {
-            return yield* Effect.fail(new AiToolNotFoundError(tool.name));
-          }
-
-          return yield* invokeFunction(fnDef, input).pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));
-        });
+  toolkit: Toolkit.Toolkit<any>,
+  handlersLayer: Layer.Layer<Tool.Handler<any>, never, never>,
+): Layer.Layer<ToolExecutionService, never, FunctionInvocationService> => {
+  return Layer.effect(
+    ToolExecutionService,
+    Effect.gen(function* () {
+      const toolkitHandler = yield* toolkit.pipe(Effect.provide(handlersLayer));
+      invariant(isHandlerLike(toolkitHandler));
+      const functionInvocationService = yield* FunctionInvocationService;
+
+      return {
+        handlersFor: (toolkit) => {
+          const makeHandler = (tool: Tool.Any): ((params: unknown) => Effect.Effect<unknown, any, any>) => {
+            return Effect.fn(`toolFunctionHandler ${tool.name}`)(function* (input: any) {
+              if (toolkitHandler.tools[tool.name]) {
+                if (Tool.isProviderDefined(tool)) {
+                  throw new Error('Attempted to call a provider-defined tool');
+                }
+
+                // TODO(wittjosiah): Everything is `never` here.
+                const { result } = yield* (toolkitHandler.handle as any)(tool.name, input);
+                return result;
+              }
+
+              const { definition: functionDef } = Context.get(FunctionToolAnnotation)(tool.annotations as any);
+
+              return yield* functionInvocationService
+                .invokeFunction(functionDef, input as any)
+                .pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));
+            });
+          };
+
+          return toolkit.of(
+            Record.map(toolkit.tools, (tool, _name) => (Tool.isUserDefined(tool) ? makeHandler(tool) : null)) as any,
+          ) as any;
+        },
       };
-
-      return toolkit.of(Record.map(toolkit.tools, (tool, name) => makeHandler(tool)) as any) as any;
-    },
-  });
+    }),
+  );
 };
 
-/**
- * Tools that are projected from functions have this annotation.
- */
-class FunctionToolAnnotation extends Context.Tag('@dxos/assisatnt/FunctionToolAnnotation')<
+class FunctionToolAnnotation extends Context.Tag('@dxos/assistant/FunctionToolAnnotation')<
   FunctionToolAnnotation,
-  {
-    functionName: string;
-  }
+  { definition: FunctionDefinition.Any }
 >() {}
 
-const toolCache = new WeakMap<FunctionDefinition<any, any>, AiTool.Any>();
-const projectFunctionToTool = (fn: FunctionDefinition<any, any>): AiTool.Any => {
+const toolCache = new WeakMap<FunctionDefinition.Any, Tool.Any>();
+
+/**
+ * Projects a `FunctionDefinition` into an `AiTool`.
+ *
+ * @param fn The function definition to project into a tool.
+ * @param meta Optional projection metadata.
+ * @param meta.deployedFunctionId Backend deployment ID used for remote invocation when present.
+ *    This is the EDGE service's function deployment identifier (not the ECHO object ID/DXN and not `FunctionDefinition.key`).
+ */
+const projectFunctionToTool = (fn: FunctionDefinition.Any): Tool.Any => {
   if (toolCache.has(fn)) {
     return toolCache.get(fn)!;
   }
-  const tool = AiTool.make(makeToolName(fn.name), {
+
+  // TODO(burdon): Use and map function.key?
+  // TODO(dmaretskyi): Use function key instead.
+  const tool = Tool.make(makeToolName(fn.name), {
     description: fn.description,
     parameters: createStructFieldsFromSchema(fn.inputSchema),
     // TODO(dmaretskyi): Include output schema.
     failure: Schema.Any, // TODO(dmaretskyi): Better type for the failure?
-  }).annotate(FunctionToolAnnotation, { functionName: fn.name });
+  }).annotate(FunctionToolAnnotation, { definition: fn });
   toolCache.set(fn, tool);
   return tool;
 };
@@ -76,64 +144,37 @@ const projectFunctionToTool = (fn: FunctionDefinition<any, any>): AiTool.Any =>
  * @returns Tool name produced from function name by escaping invalid characters.
  */
 const makeToolName = (name: string) => {
-  const toolName = name.replace(/[^a-zA-Z0-9]/g, '');
-  invariant(toolName.match(/^[a-zA-Z_][a-zA-Z0-9-_]*$/));
+  const toolName = name.toLowerCase().replace(/[^a-zA-Z0-9]/g, '-');
+  invariant(toolName.match(/^[a-z_][a-z0-9-_]*$/));
   return toolName;
 };
 
 // TODO(dmaretskyi): Factor out.
 const createStructFieldsFromSchema = (schema: Schema.Schema<any, any>): Record<string, Schema.Schema<any, any>> => {
-  return Match.value(schema.ast).pipe(
-    Match.when(Predicate.isTagged('TypeLiteral'), (ast) => {
-      return Object.fromEntries(ast.propertySignatures.map((prop) => [prop.name, Schema.make(prop.type)]));
-    }),
-    Match.orElseAbsurd,
-  );
+  switch (schema.ast._tag) {
+    case 'TypeLiteral':
+      return Object.fromEntries(
+        schema.ast.propertySignatures.map((prop) => [prop.name, Schema.make(mapSchemaTypeForLLM(prop.type))]),
+      );
+    case 'VoidKeyword':
+      return {};
+    default:
+      return todo(`Unsupported schema AST: ${schema.ast._tag}`);
+  }
 };
 
-// TODO(dmaretskyi): Factor out.
-const invokeFunction = (fnDef: FunctionDefinition<any, any>, input: any): Effect.Effect<unknown, never, Services> =>
-  Effect.gen(function* () {
-    // Assert input matches schema
-    const assertInput = fnDef.inputSchema.pipe(Schema.asserts);
-    (assertInput as any)(input);
-
-    const context: FunctionContext = {
-      getService: () => todo(),
-      getSpace: async (_spaceId: any) => {
-        throw new Error('Not available. Use the database service instead.');
-      },
-      space: undefined,
-      get ai(): never {
-        throw new Error('Not available. Use the ai service instead.');
-      },
-    };
-
-    // TODO(dmaretskyi): This should be delegated to a function invoker service.
-    const data = yield* Effect.gen(function* () {
-      const result = fnDef.handler({ context, data: input });
-      if (Effect.isEffect(result)) {
-        return yield* (result as Effect.Effect<unknown, unknown, Services>).pipe(Effect.orDie);
-      } else if (
-        typeof result === 'object' &&
-        result !== null &&
-        'then' in result &&
-        typeof result.then === 'function'
-      ) {
-        return yield* Effect.promise(() => result);
-      } else {
-        return result;
-      }
-    }).pipe(
-      Effect.orDie,
-      Effect.catchAllDefect((defect) =>
-        Effect.die(new FunctionError('Error running function', { context: { name: fnDef.name }, cause: defect })),
-      ),
-    );
-
-    // Assert output matches schema
-    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
-    (assertOutput as any)(data);
-
-    return data;
-  }).pipe(Effect.withSpan('invokeFunction', { attributes: { name: fnDef.name } }));
+/**
+ * Picks an LLM-friendly schema type for the given schema AST.
+ * The picked schema type decodes to the original schema type.
+ */
+const mapSchemaTypeForLLM = (ast: SchemaAST.AST): SchemaAST.AST => {
+  if (Type.Ref.isRefSchemaAST(ast)) {
+    return RefFromLLM.ast;
+  }
+
+  return ast;
+};
+
+const isHandlerLike = (value: unknown): value is Toolkit.WithHandler<Record<string, Tool.Any>> => {
+  return typeof (value as any).tools === 'object' && typeof (value as any).handle === 'function';
+};