@dxos/assistant-toolkit 0.8.4-main.bc674ce → 0.8.4-main.c85a9c8dae

package/src/{functions/research → blueprints/research/functions}/research.test.ts

@@ -6,75 +6,53 @@ import { inspect } from 'node:util';
 
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-
-import { AiService, ConsolePrinter } from '@dxos/ai';
-import { MemoizedAiService, TestAiService } from '@dxos/ai/testing';
-import {
-  AiConversation,
-  type ContextBinding,
-  GenerationObserver,
-  makeToolExecutionServiceFromFunctions,
-  makeToolResolverFromFunctions,
-} from '@dxos/assistant';
+
+import { ConsolePrinter } from '@dxos/ai';
+import { MemoizedAiService } from '@dxos/ai/testing';
+import { AiConversation, type ContextBinding, GenerationObserver } from '@dxos/assistant';
+import { AssistantTestLayer } from '@dxos/assistant/testing';
 import { Blueprint } from '@dxos/blueprints';
 import { Database, Filter, Obj, Query, Ref } from '@dxos/echo';
 import { acquireReleaseResource } from '@dxos/effect';
 import { TestHelpers } from '@dxos/effect/testing';
-import { CredentialsService, FunctionInvocationService, QueueService, TracingService } from '@dxos/functions';
-import { FunctionInvocationServiceLayerTest, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
+import { FunctionInvocationService, QueueService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { ObjectId } from '@dxos/keys';
 import { MarkdownBlueprint } from '@dxos/plugin-markdown/blueprints';
 import { Markdown } from '@dxos/plugin-markdown/types';
 import { HasSubject, type Message, Organization } from '@dxos/types';
 
-import { ResearchBlueprint } from '../../blueprints';
-import { testToolkit } from '../../blueprints/testing';
+import ResearchBlueprint from '../blueprint';
+import { ResearchDataTypes, ResearchGraph } from '../types';
 
 import { default as createDocument } from './document-create';
 import { default as research } from './research';
-import { ResearchGraph, queryResearchGraph } from './research-graph';
-import { ResearchDataTypes } from './types';
 
 ObjectId.dangerouslyDisableRandomness();
 
-const TestLayer = Layer.mergeAll(
-  AiService.model('@anthropic/claude-opus-4-0'),
-  makeToolResolverFromFunctions([research, createDocument, ...MarkdownBlueprint.functions], testToolkit),
-  makeToolExecutionServiceFromFunctions(testToolkit, testToolkit.toLayer({}) as any),
-).pipe(
-  Layer.provideMerge(
-    FunctionInvocationServiceLayerTest({
-      functions: [research, createDocument, ...MarkdownBlueprint.functions],
-    }),
-  ),
-  Layer.provideMerge(
-    Layer.mergeAll(
-      TestAiService(),
-      TestDatabaseLayer({
-        spaceKey: 'fixed',
-        indexing: { vector: true },
-        types: [...ResearchDataTypes, ResearchGraph, Blueprint.Blueprint, Markdown.Document, HasSubject.HasSubject],
-      }),
-      CredentialsService.configuredLayer([]),
-      TracingService.layerNoop,
-    ),
-  ),
-);
+const TestLayer = AssistantTestLayer({
+  functions: [research, createDocument, ...MarkdownBlueprint.functions],
+  types: [
+    ...ResearchDataTypes,
+    ResearchGraph.ResearchGraph,
+    Blueprint.Blueprint,
+    Markdown.Document,
+    HasSubject.HasSubject,
+  ],
+});
 
 describe('Research', () => {
   it.effect(
     'call a function to generate a research report',
     Effect.fnUntraced(
       function* (_) {
-        yield* Database.Service.add(
+        yield* Database.add(
           Obj.make(Organization.Organization, {
             name: 'BlueYard',
             website: 'https://blueyard.com',
           }),
         );
-        yield* Database.Service.flush({ indexes: true });
+        yield* Database.flush({ indexes: true });
         const result = yield* FunctionInvocationService.invokeFunction(research, {
           query: 'Founders and portfolio of BlueYard.',
         });
@@ -82,10 +60,10 @@ describe('Research', () => {
         console.log(inspect(result, { depth: null, colors: true }));
         console.log(JSON.stringify(result, null, 2));
 
-        yield* Database.Service.flush({ indexes: true });
-        const researchGraph = yield* queryResearchGraph();
+        yield* Database.flush({ indexes: true });
+        const researchGraph = yield* ResearchGraph.query();
         if (researchGraph) {
-          const data = yield* Database.Service.load(researchGraph.queue).pipe(
+          const data = yield* Database.load(researchGraph.queue).pipe(
             Effect.flatMap((queue) => Effect.promise(() => queue.queryObjects())),
           );
           console.log(inspect(data, { depth: null, colors: true }));
@@ -101,7 +79,7 @@ describe('Research', () => {
     'create and update research report',
     Effect.fnUntraced(
       function* (_) {
-        const organization = yield* Database.Service.add(
+        const organization = yield* Database.add(
           Obj.make(Organization.Organization, {
             name: 'BlueYard',
             website: 'https://blueyard.com',
@@ -111,9 +89,9 @@ describe('Research', () => {
         const queue = yield* QueueService.createQueue<Message.Message | ContextBinding>();
         const conversation = yield* acquireReleaseResource(() => new AiConversation({ queue }));
 
-        yield* Database.Service.flush({ indexes: true });
-        const researchBlueprint = yield* Database.Service.add(Obj.clone(ResearchBlueprint));
-        const markdownBlueprint = yield* Database.Service.add(Obj.clone(MarkdownBlueprint.make()));
+        yield* Database.flush({ indexes: true });
+        const researchBlueprint = yield* Database.add(Obj.clone(ResearchBlueprint.make()));
+        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
         yield* Effect.promise(() =>
           conversation.context.bind({
             blueprints: [Ref.make(researchBlueprint), Ref.make(markdownBlueprint)],
@@ -128,18 +106,18 @@ describe('Research', () => {
           prompt: `Create a research summary about ${organization.name}.`,
         });
         {
-          const docs = yield* Database.Service.runQuery(
+          const docs = yield* Database.runQuery(
             Query.select(Filter.id(organization.id)).targetOf(HasSubject.HasSubject).source(),
           );
           if (docs.length !== 1) {
-            throw new Error(`Expected 1 research document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+            throw new Error(`Expected 1 research document; got ${docs.length}: ${docs.map((_) => (_ as any).name)}`);
           }
 
           const doc = docs[0];
           invariant(Obj.instanceOf(Markdown.Document, doc));
           console.log({
             name: doc.name,
-            content: yield* Database.Service.load(doc.content).pipe(Effect.map((_) => _.content)),
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
           });
         }
 
@@ -148,18 +126,18 @@ describe('Research', () => {
           prompt: 'Add a section about their portfolio.',
         });
         {
-          const docs = yield* Database.Service.runQuery(
+          const docs = yield* Database.runQuery(
             Query.select(Filter.id(organization.id)).targetOf(HasSubject.HasSubject).source(),
           );
           if (docs.length !== 1) {
-            throw new Error(`Expected 1 research document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+            throw new Error(`Expected 1 research document; got ${docs.length}: ${docs.map((_) => (_ as any).name)}`);
           }
 
           const doc = docs[0];
           invariant(Obj.instanceOf(Markdown.Document, doc));
           console.log({
             name: doc.name,
-            content: yield* Database.Service.load(doc.content).pipe(Effect.map((_) => _.content)),
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
           });
         }
       },

package/src/{functions/research → blueprints/research/functions}/research.ts

@@ -13,27 +13,20 @@ import * as Schema from 'effect/Schema';
 import * as String from 'effect/String';
 
 import { AiService, ConsolePrinter } from '@dxos/ai';
-import {
-  AiSession,
-  GenerationObserver,
-  createToolkit,
-  makeToolExecutionServiceFromFunctions,
-  makeToolResolverFromFunctions,
-} from '@dxos/assistant';
+import { GenericToolkit } from '@dxos/ai';
+import { AiSession, GenerationObserver, ToolExecutionServices, createToolkit } from '@dxos/assistant';
 import { Template } from '@dxos/blueprints';
 import { type DXN, Entity, Obj } from '@dxos/echo';
 import { Database } from '@dxos/echo';
 import { TracingService, defineFunction } from '@dxos/functions';
-import { FunctionInvocationServiceLayerTestMocked } from '@dxos/functions-runtime/testing';
 import { type Message, Person } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { LocalSearchHandler, LocalSearchToolkit, makeGraphWriterHandler, makeGraphWriterToolkit } from '../../crud';
-import { exaFunction, exaMockFunction } from '../exa';
+import { LocalSearchHandler, LocalSearchToolkit, makeGraphWriterHandler, makeGraphWriterToolkit } from '../../../crud';
+import { ResearchGraph } from '../types';
+import { ResearchDataTypes } from '../types';
 
-import { contextQueueLayerFromResearchGraph } from './research-graph';
 import PROMPT from './research-instructions.tpl?raw';
-import { ResearchDataTypes } from './types';
 
 /**
  * Exec external service and return the results as a Subgraph.
@@ -85,7 +78,7 @@ export default defineFunction({
   handler: Effect.fnUntraced(
     function* ({ data: { query, instructions, mockSearch = false, entityExtraction = false } }) {
       if (mockSearch) {
-        const mockPerson = yield* Database.Service.add(
+        const mockPerson = yield* Database.add(
           Obj.make(Person.Person, {
             preferredName: 'John Doe',
             emails: [{ value: 'john.doe@example.com' }],
@@ -102,7 +95,7 @@ export default defineFunction({
         };
       }
 
-      yield* Database.Service.flush({ indexes: true });
+      yield* Database.flush({ indexes: true });
       yield* TracingService.emitStatus({ message: 'Starting research...' });
 
       const NativeWebSearch = Toolkit.make(AnthropicTool.WebSearch_20250305({}));
@@ -119,7 +112,7 @@ export default defineFunction({
 
         toolkit = Toolkit.merge(toolkit, LocalSearchToolkit, GraphWriterToolkit);
         handlers = Layer.mergeAll(handlers, LocalSearchHandler, GraphWriterHandler).pipe(
-          Layer.provide(contextQueueLayerFromResearchGraph),
+          Layer.provide(ResearchGraph.contextQueueLayer),
         ) as any;
       }
 
@@ -136,7 +129,7 @@ export default defineFunction({
         observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'research' })),
       });
 
-      const objects = yield* Effect.forEach(objectDXNs, (dxn) => Database.Service.resolve(dxn)).pipe(
+      const objects = yield* Effect.forEach(objectDXNs, (dxn) => Database.resolve(dxn)).pipe(
         Effect.map(Array.map((obj) => Entity.toJSON(obj))),
       );
 
@@ -146,16 +139,9 @@ export default defineFunction({
       };
     },
     Effect.provide(
-      Layer.mergeAll(
-        AiService.model('@anthropic/claude-sonnet-4-0'),
-        // TODO(dmaretskyi): Extract.
-        makeToolResolverFromFunctions([exaFunction, exaMockFunction], Toolkit.make()),
-        makeToolExecutionServiceFromFunctions(Toolkit.make() as any, Layer.empty as any),
-      ).pipe(
-        Layer.provide(
-          // TODO(dmaretskyi): This should be provided by environment.
-          Layer.mergeAll(FunctionInvocationServiceLayerTestMocked({ functions: [exaFunction, exaMockFunction] })),
-        ),
+      AiService.model('@anthropic/claude-sonnet-4-0').pipe(
+        Layer.merge(ToolExecutionServices),
+        Layer.provide(GenericToolkit.providerEmpty),
       ),
     ),
   ),
@@ -177,7 +163,7 @@ const extractLastTextBlock = (result: Message.Message[]) => {
       Function.flow(
         (_: Message.Message) => _.blocks,
         Array.reverse,
-        Array.dropWhile((_: any) => _._tag === 'summary'),
+        Array.dropWhile((_: any) => _._tag === 'stats'),
         Array.takeWhile((_: any) => _._tag === 'text'),
         Array.reverse,
         Array.map((_: any) => _.text),

package/src/blueprints/research/index.ts

@@ -2,6 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-import { blueprint } from './research-blueprint';
-
-export default blueprint;
+export { default as ResearchBlueprint } from './blueprint';
+export * from './types';

package/src/blueprints/research/types/ResearchGraph.ts

@@ -0,0 +1,49 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
+
+import { Database, Obj, Query, Ref, Type } from '@dxos/echo';
+import { SystemTypeAnnotation } from '@dxos/echo/internal';
+import { Queue } from '@dxos/echo-db';
+import { ContextQueueService, QueueService } from '@dxos/functions';
+
+/**
+ * Container for a set of ephemeral research results.
+ */
+export const ResearchGraph = Schema.Struct({
+  queue: Ref.Ref(Queue),
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/ResearchGraph',
+    version: '0.1.0',
+  }),
+  SystemTypeAnnotation.set(true),
+);
+
+export interface ResearchGraph extends Schema.Schema.Type<typeof ResearchGraph> {}
+
+export const create: () => Effect.Effect<ResearchGraph, never, Database.Service | QueueService> = Effect.fn(
+  'createResearchGraph',
+)(function* () {
+  const queue = yield* QueueService.createQueue();
+  return yield* Database.add(Obj.make(ResearchGraph, { queue: Ref.fromDXN(queue.dxn) }));
+});
+
+export const query: () => Effect.Effect<ResearchGraph | undefined, never, Database.Service> = Effect.fn(
+  'queryResearchGraph',
+)(function* () {
+  const objects = yield* Database.runQuery(Query.type(ResearchGraph));
+  return objects.at(0);
+});
+
+export const contextQueueLayer = Layer.unwrapEffect(
+  Effect.gen(function* () {
+    const researchGraph = (yield* query()) ?? (yield* create());
+    const researchQueue = yield* Database.load(researchGraph.queue);
+    return ContextQueueService.layer(researchQueue);
+  }),
+);

package/src/{functions/research/types.ts → blueprints/research/types/index.ts}

@@ -1,26 +1,32 @@
 //
-// Copyright 2025 DXOS.org
+// Copyright 2026 DXOS.org
 //
 
 import { type Type } from '@dxos/echo';
 import { Text } from '@dxos/schema';
-import { Event, HasConnection, HasRelationship, LegacyOrganization, LegacyPerson, Project, Task } from '@dxos/types';
+import { Event, HasConnection, HasRelationship, LegacyOrganization, LegacyPerson, Pipeline, Task } from '@dxos/types';
+
+export * as ResearchGraph from './ResearchGraph';
 
 /**
  * Data types for research.
  */
-export const ResearchDataTypes: Type.Entity.Any[] = [
+// TODO(burdon): This should not be hardcoded.
+export const ResearchDataTypes: Type.AnyEntity[] = [
   // Objects
   Event.Event,
-  LegacyOrganization,
   Task.Task,
   Text.Text,
 
-  // Relations
   // TODO(wittjosiah): Until views (e.g., Table) support relations this needs to be expressed via organization ref.
   // Employer.Employer,
+  // Organization.Organization,
   LegacyPerson,
-  Project.Project,
+  LegacyOrganization,
+
+  Pipeline.Pipeline,
+
+  // Relations
   HasRelationship.HasRelationship,
   HasConnection.HasConnection,
 ];

package/src/blueprints/testing.ts

@@ -2,17 +2,36 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Toolkit from '@effect/ai/Toolkit';
+import * as Arr from 'effect/Array';
 import * as Effect from 'effect/Effect';
+import { pipe } from 'effect/Function';
 
 import { ConsolePrinter } from '@dxos/ai';
-import { type AiConversation, type AiConversationRunProps, GenerationObserver } from '@dxos/assistant';
+import {
+  AiContextService,
+  type AiConversation,
+  type AiConversationRunProps,
+  GenerationObserver,
+} from '@dxos/assistant';
+import type { Blueprint } from '@dxos/blueprints';
+import { Database, Ref } from '@dxos/echo';
+import { type FunctionDefinition } from '@dxos/functions';
 import { log } from '@dxos/log';
 
 export type TestStep = Pick<AiConversationRunProps, 'prompt' | 'system'> & {
   test?: () => Promise<void>;
 };
 
+/**
+ * Blueprint definition type for testing.
+ * Mirrors AppCapabilities.BlueprintDefinition to avoid circular dependency with app-toolkit.
+ */
+export interface BlueprintDefinition {
+  key: string;
+  functions: FunctionDefinition.Any[];
+  make: () => Blueprint.Blueprint;
+}
+
 /**
  * Runs the prompt steps, calling the test function after each step.
  */
@@ -30,5 +49,17 @@ export const runSteps = Effect.fn(function* (conversation: AiConversation, steps
   }
 });
 
-// TODO(wittjosiah): Don't cast.
-export const testToolkit = Toolkit.empty as Toolkit.Toolkit<any>;
+/**
+ * Binds blueprints from the blueprint definitions.
+ */
+// TODO(dmaretskyi): Potentially the agent will auto-bind the blueprints.
+export const addBlueprints = Effect.fnUntraced(function* (blueprints: BlueprintDefinition[]) {
+  yield* AiContextService.bindContext({
+    blueprints: yield* pipe(
+      blueprints,
+      Arr.map((blueprint) => blueprint.make()),
+      Effect.forEach(Database.add),
+      Effect.map(Arr.map(Ref.make)),
+    ),
+  });
+});

package/src/blueprints/websearch/blueprint.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ToolId } from '@dxos/ai';
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+import { Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+
+const BLUEPRINT_KEY = 'dxos.org/blueprint/web-search';
+
+const functions: AppCapabilities.BlueprintDefinition['functions'] = [];
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Web Search',
+    description: 'Search the web.',
+    instructions: {
+      source: Ref.make(Text.make()),
+    },
+    tools: [ToolId.make('AnthropicWebSearch')],
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  functions,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/websearch/index.ts

@@ -2,8 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-import { blueprint } from './websearch-blueprint';
-
-export { WebSearchToolkit } from './websearch-toolkit';
-
-export default blueprint;
+export { default as WebSearchBlueprint } from './blueprint';
+export { WebSearchToolkit } from './toolkit';

package/src/crud/graph.test.ts

@@ -10,7 +10,7 @@ import { AiSession } from '@dxos/assistant';
 import { AssistantTestLayer } from '@dxos/assistant/testing';
 import { TestHelpers } from '@dxos/effect/testing';
 import { log } from '@dxos/log';
-import { Project } from '@dxos/types';
+import { Pipeline } from '@dxos/types';
 
 import { makeGraphWriterHandler, makeGraphWriterToolkit } from './graph';
 
@@ -23,7 +23,7 @@ describe('graph', () => {
   //   const relatedSchemas = await findRelatedSchema(db, Schema.Struct({}));
   // });
 
-  const Toolkit = makeGraphWriterToolkit({ schema: [Project.Project] });
+  const Toolkit = makeGraphWriterToolkit({ schema: [Pipeline.Pipeline] });
   const ToolkitLayer = makeGraphWriterHandler(Toolkit);
 
   it.effect.skip(

package/src/crud/graph.ts

@@ -40,7 +40,7 @@ export const Subgraph = Schema.Struct({
 export interface Subgraph extends Schema.Schema.Type<typeof Subgraph> {}
 
 export type RelatedSchema = {
-  schema: Type.Entity.Any;
+  schema: Type.AnyEntity;
   kind: 'reference' | 'relation';
 };
 
@@ -51,7 +51,7 @@ export type RelatedSchema = {
  * @param schema
  * @returns
  */
-export const findRelatedSchema = async (db: Database.Database, anchor: Type.Entity.Any): Promise<RelatedSchema[]> => {
+export const findRelatedSchema = async (db: Database.Database, anchor: Type.AnyEntity): Promise<RelatedSchema[]> => {
   // TODO(dmaretskyi): Query stored schemas.
   const allSchemas = await db.graph.schemaRegistry.query().run();
 
@@ -79,7 +79,7 @@ export const findRelatedSchema = async (db: Database.Database, anchor: Type.Enti
  * Non-strict DXN comparison.
  * Returns true if the DXN could be resolved to the schema.
  */
-const isSchemaAddressableByDxn = (schema: Type.Entity.Any, dxn: DXN): boolean => {
+const isSchemaAddressableByDxn = (schema: Type.AnyEntity, dxn: DXN): boolean => {
   if (getTypeIdentifierAnnotation(schema) === dxn.toString()) {
     return true;
   }
@@ -112,7 +112,7 @@ export const LocalSearchToolkit = Toolkit.make(
 
 export const LocalSearchHandler = LocalSearchToolkit.toLayer({
   search_local_search: Effect.fn(function* ({ query }) {
-    const objects = yield* Database.Service.runQuery(Query.select(Filter.text(query, { type: 'vector' })));
+    const objects = yield* Database.runQuery(Query.select(Filter.text(query, { type: 'vector' })));
     const results = [...objects];
 
     const option = yield* Effect.serviceOption(ContextQueueService);
@@ -136,14 +136,14 @@ export const LocalSearchHandler = LocalSearchToolkit.toLayer({
 class GraphWriterSchema extends Context.Tag('@dxos/assistant/GraphWriterSchema')<
   GraphWriterSchema,
   {
-    schema: Type.Entity.Any[];
+    schema: Type.AnyEntity[];
   }
 >() {}
 
 /**
  * Forms typed objects that can be written to the graph database.
  */
-export const makeGraphWriterToolkit = ({ schema }: { schema: Type.Entity.Any[] }) => {
+export const makeGraphWriterToolkit = ({ schema }: { schema: Type.AnyEntity[] }) => {
   return Toolkit.make(
     Tool.make('graph_writer', {
       description: 'Write to the local graph database',
@@ -185,7 +185,7 @@ export const makeGraphWriterHandler = (
 /**
  * Create a schema for structured data extraction.
  */
-export const createExtractionSchema = (types: Type.Entity.Any[]) => {
+export const createExtractionSchema = (types: Type.AnyEntity[]) => {
   return Schema.Struct({
     ...Object.fromEntries(
       types.map(preprocessSchema).map((schema, index) => [
@@ -198,14 +198,14 @@ export const createExtractionSchema = (types: Type.Entity.Any[]) => {
   });
 };
 
-export const getSanitizedSchemaName = (schema: Type.Entity.Any) => {
+export const getSanitizedSchemaName = (schema: Type.AnyEntity) => {
   return Type.getDXN(schema)!
     .asTypeDXN()!
     .type.replaceAll(/[^a-zA-Z0-9]+/g, '_');
 };
 
 export const sanitizeObjects = async (
-  types: Type.Entity.Any[],
+  types: Type.AnyEntity[],
   data: Record<string, readonly unknown[]>,
   db: Database.Database,
   queue?: Queue,

package/src/functions/READ_THIS.md

@@ -0,0 +1,5 @@
+###
+
+Can we move all functions into the corresponding blueprint folder?
+
+###

package/src/functions/agent/index.ts

@@ -2,10 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type FunctionDefinition } from '@dxos/functions';
+import Prompt from './prompt';
 
-import { default as prompt$ } from './prompt';
-
-export namespace Agent {
-  export const prompt: FunctionDefinition.Any = prompt$; // TODO(burdon): Temp fix for TS error.
-}
+export const AgentFunctions = {
+  Prompt,
+};