@dxos/assistant 0.8.3 → 0.8.4-main.3a94e84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/assistant",
-  "version": "0.8.3",
+  "version": "0.8.4-main.3a94e84",
   "description": "Natural language interface to DXOS",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -21,41 +21,40 @@
     "src"
   ],
   "dependencies": {
+    "@effect/ai": "0.23.0",
+    "@effect/ai-anthropic": "^0.13.0",
+    "@effect/platform": "^0.89.0",
+    "@effect/platform-node": "^0.92.0",
     "@preact/signals-core": "^1.9.0",
     "@xenova/transformers": "^2.17.2",
     "chalk": "^4.1.0",
     "exa-js": "^1.5.12",
-    "@dxos/ai": "0.8.3",
-    "@dxos/artifact": "0.8.3",
-    "@dxos/context": "0.8.3",
-    "@dxos/async": "0.8.3",
-    "@dxos/debug": "0.8.3",
-    "@dxos/echo": "0.8.3",
-    "@dxos/echo-db": "0.8.3",
-    "@dxos/echo-protocol": "0.8.3",
-    "@dxos/echo-schema": "0.8.3",
-    "@dxos/functions": "0.8.3",
-    "@dxos/graph": "0.8.3",
-    "@dxos/effect": "0.8.3",
-    "@dxos/keys": "0.8.3",
-    "@dxos/invariant": "0.8.3",
-    "@dxos/live-object": "0.8.3",
-    "@dxos/log": "0.8.3",
-    "@dxos/node-std": "0.8.3",
-    "@dxos/util": "0.8.3",
-    "@dxos/schema": "0.8.3"
+    "handlebars": "4.7.8",
+    "lodash.defaultsdeep": "^4.6.1",
+    "@dxos/ai": "0.8.4-main.3a94e84",
+    "@dxos/blueprints": "0.8.4-main.3a94e84",
+    "@dxos/async": "0.8.4-main.3a94e84",
+    "@dxos/context": "0.8.4-main.3a94e84",
+    "@dxos/debug": "0.8.4-main.3a94e84",
+    "@dxos/echo": "0.8.4-main.3a94e84",
+    "@dxos/echo-schema": "0.8.4-main.3a94e84",
+    "@dxos/effect": "0.8.4-main.3a94e84",
+    "@dxos/echo-db": "0.8.4-main.3a94e84",
+    "@dxos/echo-protocol": "0.8.4-main.3a94e84",
+    "@dxos/errors": "0.8.4-main.3a94e84",
+    "@dxos/functions": "0.8.4-main.3a94e84",
+    "@dxos/graph": "0.8.4-main.3a94e84",
+    "@dxos/invariant": "0.8.4-main.3a94e84",
+    "@dxos/keys": "0.8.4-main.3a94e84",
+    "@dxos/live-object": "0.8.4-main.3a94e84",
+    "@dxos/log": "0.8.4-main.3a94e84",
+    "@dxos/schema": "0.8.4-main.3a94e84",
+    "@dxos/node-std": "0.8.4-main.3a94e84",
+    "@dxos/util": "0.8.4-main.3a94e84"
   },
   "devDependencies": {
-    "@effect/ai": "^0.19.4",
-    "@effect/ai-anthropic": "^0.9.5",
-    "@effect/ai-openai": "^0.22.4",
-    "@effect/cluster": "^0.39.4",
-    "@effect/experimental": "^0.49.2",
-    "@effect/platform": "^0.85.2",
-    "@effect/platform-node": "^0.86.4",
-    "@effect/rpc": "^0.62.4",
-    "@effect/sql": "^0.38.2",
-    "effect": "3.14.21",
+    "@types/lodash.defaultsdeep": "^4.6.6",
+    "effect": "3.17.0",
     "inquirer": "^12.0.0"
   },
   "peerDependencies": {

package/src/context/binder.ts

@@ -0,0 +1,103 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { computed, type ReadonlySignal } from '@preact/signals-core';
+import { Array, pipe } from 'effect';
+
+import { type Blueprint } from '@dxos/blueprints';
+import { Obj, type Type, type Ref, type Relation } from '@dxos/echo';
+import { type Queue } from '@dxos/echo-db';
+import { ComplexSet } from '@dxos/util';
+
+import { ContextBinding } from './binding';
+
+/**
+ * Manages bindings of blueprints and objects to a conversation.
+ */
+export class ContextBinder {
+  constructor(private readonly _queue: Queue) {}
+
+  /**
+   * Reactive query of all bindings.
+   */
+  // TODO(burdon): Cache value?
+  readonly bindings: ReadonlySignal<Bindings> = computed(() => this._reduce(this._queue.objects));
+
+  // TODO(burdon): load refs?
+  readonly blueprints: ReadonlySignal<Ref.Ref<Blueprint.Blueprint>[]> = computed(() => [
+    ...this.bindings.value.blueprints,
+  ]);
+  readonly objects: ReadonlySignal<Ref.Ref<Type.Expando>[]> = computed(() => [...this.bindings.value.objects]);
+
+  /**
+   * Asynchronous query of all bindings.
+   */
+  async query(): Promise<Bindings> {
+    const queueItems = await this._queue.queryObjects();
+    return this._reduce(queueItems);
+  }
+
+  // TODO(burdon): Pass in Blueprint obj (from registry?) and create reference.
+  async bind(props: BindingProps): Promise<void> {
+    if (!props.blueprints?.length && !props.objects?.length) {
+      return;
+    }
+
+    await this._queue.append([
+      Obj.make(ContextBinding, {
+        blueprints: {
+          added: props.blueprints ?? [],
+          removed: [],
+        },
+        objects: {
+          added: props.objects ?? [],
+          removed: [],
+        },
+      }),
+    ]);
+  }
+
+  async unbind(props: BindingProps): Promise<void> {
+    if (!props.blueprints?.length && !props.objects?.length) {
+      return;
+    }
+
+    await this._queue.append([
+      Obj.make(ContextBinding, {
+        blueprints: {
+          added: [],
+          removed: props.blueprints ?? [],
+        },
+        objects: {
+          added: [],
+          removed: props.objects ?? [],
+        },
+      }),
+    ]);
+  }
+
+  private _reduce(items: (Obj.Any | Relation.Any)[]): Bindings {
+    return pipe(
+      items,
+      Array.filter(Obj.instanceOf(ContextBinding)),
+      Array.reduce(new Bindings(), (context, item) => {
+        item.blueprints.removed.forEach((item) => context.blueprints.delete(item));
+        item.blueprints.added.forEach((item) => context.blueprints.add(item));
+        item.objects.removed.forEach((item) => context.objects.delete(item));
+        item.objects.added.forEach((item) => context.objects.add(item));
+        return context;
+      }),
+    );
+  }
+}
+
+export type BindingProps = Partial<{
+  blueprints: Ref.Ref<Blueprint.Blueprint>[];
+  objects: Ref.Ref<Type.Expando>[];
+}>;
+
+export class Bindings {
+  blueprints = new ComplexSet<Ref.Ref<Blueprint.Blueprint>>((ref) => ref.dxn.toString());
+  objects = new ComplexSet<Ref.Ref<Type.Expando>>((ref) => ref.dxn.toString());
+}

package/src/context/binding.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Schema } from 'effect';
+
+import { Blueprint } from '@dxos/blueprints';
+import { Type } from '@dxos/echo';
+
+/**
+ * Thread message that binds or unbinds contextual objects to a conversation.
+ */
+// TODO(burdon): Make ContentBlock.
+export const ContextBinding = Schema.Struct({
+  blueprints: Schema.Struct({
+    added: Schema.Array(Type.Ref(Blueprint.Blueprint)),
+    removed: Schema.Array(Type.Ref(Blueprint.Blueprint)),
+  }),
+
+  // TODO(burdon): Type.Expando => Type.Obj (or Obj.Any?)
+  objects: Schema.Struct({
+    added: Schema.Array(Type.Ref(Type.Expando)),
+    removed: Schema.Array(Type.Ref(Type.Expando)),
+  }),
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/ContextBinding',
+    version: '0.1.0',
+  }),
+);
+
+export interface ContextBinding extends Schema.Schema.Type<typeof ContextBinding> {}

package/src/context/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './binder';
+export * from './binding';

package/src/conversation/conversation.ts

@@ -0,0 +1,96 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AiError, type AiLanguageModel, type AiTool, type AiToolkit } from '@effect/ai';
+import { Effect } from 'effect';
+
+import {
+  type ToolExecutionService,
+  type ToolResolverService,
+  type AiInputPreprocessingError,
+  type AiToolNotFoundError,
+} from '@dxos/ai';
+import { Event } from '@dxos/async';
+import { Obj } from '@dxos/echo';
+import { type Queue } from '@dxos/echo-db';
+import { DatabaseService } from '@dxos/functions';
+import { DataType } from '@dxos/schema';
+
+import { ContextBinder, type ContextBinding } from '../context';
+import type { AiAssistantError } from '../errors';
+import { AiSession } from '../session';
+
+export interface ConversationRunOptions<Tools extends AiTool.Any> {
+  systemPrompt?: string;
+  prompt: string;
+
+  toolkit?: AiToolkit.AiToolkit<Tools>;
+}
+
+export type ConversationOptions = {
+  queue: Queue<DataType.Message | ContextBinding>;
+};
+
+/**
+ * Persistent conversation state.
+ * Context + history + artifacts.
+ * Backed by a Queue.
+ */
+export class Conversation {
+  private readonly _queue: Queue<DataType.Message | ContextBinding>;
+
+  /**
+   * Fired when the execution loop begins.
+   * This is called before the first message is sent.
+   */
+  public readonly onBegin = new Event<AiSession>();
+
+  /**
+   * Blueprints bound to the conversation.
+   */
+  public readonly context: ContextBinder;
+
+  constructor(options: ConversationOptions) {
+    this._queue = options.queue;
+    this.context = new ContextBinder(this._queue);
+  }
+
+  async getHistory(): Promise<DataType.Message[]> {
+    const queueItems = await this._queue.queryObjects();
+    return queueItems.filter(Obj.instanceOf(DataType.Message));
+  }
+
+  run = <Tools extends AiTool.Any>(
+    options: ConversationRunOptions<Tools>,
+  ): Effect.Effect<
+    DataType.Message[],
+    AiAssistantError | AiInputPreprocessingError | AiError.AiError | AiToolNotFoundError,
+    AiLanguageModel.AiLanguageModel | ToolResolverService | ToolExecutionService | AiTool.ToHandler<Tools>
+  > =>
+    Effect.gen(this, function* () {
+      const session = new AiSession();
+      this.onBegin.emit(session);
+
+      const history = yield* Effect.promise(() => this.getHistory());
+      const context = yield* Effect.promise(() => this.context.query());
+      const blueprints = yield* Effect.forEach(context.blueprints.values(), DatabaseService.loadRef);
+
+      const contextObjects = yield* Effect.forEach(context.objects.values(), DatabaseService.loadRef);
+
+      const systemPrompt =
+        (options.systemPrompt ?? '') +
+        '\n\n' +
+        contextObjects.map((obj) => `<object>${Obj.getDXN(obj)}</object>`).join('\n');
+
+      const messages = yield* session.run({
+        prompt: options.prompt,
+        history,
+        systemPrompt,
+        toolkit: options.toolkit,
+        blueprints,
+      });
+      yield* Effect.promise(() => this._queue.append(messages));
+      return messages;
+    }).pipe(Effect.withSpan('Conversation.run'));
+}

package/src/conversation/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './conversation';

package/src/errors.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { BaseError } from '@dxos/errors';
+
+/**
+ * Generic error for AI agent execution.
+ */
+export class AiAssistantError extends BaseError.extend('AI_ASSISTANT_ERROR') {}

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

@@ -2,35 +2,23 @@
 // Copyright 2025 DXOS.org
 //
 
-import { describe, test, beforeAll } from 'vitest';
+import { beforeAll, describe, test } from 'vitest';
 
-import { EdgeAiServiceClient } from '@dxos/ai';
-import { AI_SERVICE_ENDPOINT } from '@dxos/ai/testing';
-import { FunctionExecutor, ServiceContainer } from '@dxos/functions';
+import { todo } from '@dxos/debug';
+import { FunctionExecutor } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { createTestData } from '@dxos/schema/testing';
 import { range } from '@dxos/util';
 
-import { extractionAnthropicFn } from './extraction-llm-function';
 import { processTranscriptMessage } from '../extraction';
+import { extractionAnthropicFn } from './extraction-llm-function';
 
+// TODO(burdon): Rewrite test.
 describe.skip('LLM EntityExtraction', () => {
   let executor: FunctionExecutor;
 
   beforeAll(async () => {
-    executor = new FunctionExecutor(
-      new ServiceContainer().setServices({
-        ai: {
-          client: new EdgeAiServiceClient({
-            endpoint: AI_SERVICE_ENDPOINT.REMOTE,
-            defaultGenerationOptions: {
-              // model: '@anthropic/claude-sonnet-4-20250514',
-              model: '@anthropic/claude-3-5-haiku-20241022',
-            },
-          }),
-        },
-      }),
-    );
+    executor = new FunctionExecutor(todo());
   });
 
   test('should process a transcript block', async () => {

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

@@ -2,14 +2,17 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Message } from '@dxos/ai';
+// TODO(burdon): Fix.
+// @ts-nocheck
+
+import { ToolRegistry, AiService } from '@dxos/ai';
 import { Obj } from '@dxos/echo';
 import { create } from '@dxos/echo-schema';
-import { AiService, defineFunction, type FunctionDefinition } from '@dxos/functions';
-import { DataType } from '@dxos/schema';
+import { defineFunction, type FunctionDefinition } from '@dxos/functions';
+import { type ContentBlock, DataType } from '@dxos/schema';
 
 import PROMPT from './instructions.tpl?raw';
-import { AISession } from '../../session';
+import { AiSession } from '../../session';
 import { ExtractionInput, ExtractionOutput } from '../extraction';
 import { insertReferences, ReferencedQuotes } from '../quotes';
 
@@ -20,7 +23,7 @@ export const extractionAnthropicFn: FunctionDefinition<ExtractionInput, Extracti
   handler: async ({ data: { message, objects }, context }) => {
     const startTime = performance.now();
     const ai = context.getService(AiService);
-    const session = new AISession({ operationModel: 'configured' });
+    const session = new AiSession({ operationModel: 'configured' });
     const result = await session.runStructured(ReferencedQuotes, {
       generationOptions: {
         model: '@anthropic/claude-3-5-haiku-20241022',
@@ -28,30 +31,32 @@ export const extractionAnthropicFn: FunctionDefinition<ExtractionInput, Extracti
       client: ai.client,
       systemPrompt: PROMPT,
       history: [
-        Obj.make(Message, {
-          role: 'user',
-          content: [
+        Obj.make(DataType.Message, {
+          created: new Date().toISOString(),
+          sender: { role: 'user' },
+          blocks: [
             {
-              type: 'text',
+              _tag: 'text',
               text: `<context>${JSON.stringify(objects)}</context>`,
-            },
+            } satisfies ContentBlock.Text,
             {
-              type: 'text',
+              _tag: 'text',
               text: `<transcript>${JSON.stringify(message.blocks)}</transcript>`,
-            },
+            } satisfies ContentBlock.Text,
           ],
         }),
       ],
       artifacts: [],
       prompt: '',
       tools: [],
-    });
+      toolResolver: new ToolRegistry([]),
+    } as any); // TODO(burdon): Rewrite test.
 
     return {
       message: create(DataType.Message, {
         ...message,
         blocks: message.blocks.map((block, i) =>
-          block.type !== 'transcription'
+          block._tag !== 'transcript'
             ? block
             : {
                 ...block,

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

@@ -2,6 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
+// TODO(burdon): Fix.
+// @ts-nocheck
+
 import { asyncTimeout } from '@dxos/async';
 import { create } from '@dxos/echo-schema';
 import { DatabaseService, defineFunction } from '@dxos/functions';
@@ -25,7 +28,7 @@ export const extractionNerFn = defineFunction({
 
     const entitiesPromise = Promise.all(
       message.blocks.map(async (block) => {
-        invariant(block.type === 'transcription' || block.type === 'text', 'Block must have text');
+        invariant(block._tag === 'transcript' || block._tag === 'text', 'Block must have text');
         return extractFullEntities(block.text);
       }),
     ).then((entities) => entities.flat());
@@ -36,8 +39,8 @@ export const extractionNerFn = defineFunction({
       db,
     );
     const blocksWithReferences = message.blocks.map((block, i) => {
-      invariant(block.type === 'transcription' || block.type === 'text', 'Block must have text');
-      return { ...block, text: insertReferences(block.text, quoteReferences) };
+      invariant(block._tag === 'transcript' || block._tag === 'text', 'Block must have text');
+      return { ...block, text: insertReferences(block._tag, quoteReferences) };
     });
     const messageWithReferences = create(DataType.Message, {
       ...message,

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

@@ -57,7 +57,7 @@ describe('NamedEntityRecognition', () => {
     const { transcriptWoflram, transcriptJosiah } = await createTestData();
 
     const blocks = [...transcriptWoflram, ...transcriptJosiah].flatMap((message) =>
-      message.blocks.flatMap((block) => (block.type === 'transcription' ? [block.text] : [])),
+      message.blocks.flatMap((block) => (block._tag === 'transcript' ? [block.text] : [])),
     );
 
     for (const block of blocks) {
@@ -70,7 +70,7 @@ describe('NamedEntityRecognition', () => {
     const { transcriptMessages } = await createTestData();
 
     const blocks = transcriptMessages.flatMap((message) =>
-      message.blocks.flatMap((block) => (block.type === 'transcription' ? [block.text] : [])),
+      message.blocks.flatMap((block) => (block._tag === 'transcript' ? [block.text] : [])),
     );
 
     for (const block of blocks) {

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

@@ -4,9 +4,9 @@
 
 import {
   type TokenClassificationOutput,
+  type TokenClassificationPipelineType,
   type TokenClassificationSingle,
   pipeline,
-  type TokenClassificationPipelineType,
 } from '@xenova/transformers';
 
 import { log } from '@dxos/log';

package/src/functions/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './services';

package/src/functions/services.ts

@@ -0,0 +1,139 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AiTool } from '@effect/ai';
+import { Context, Effect, Layer, Match, Predicate, Record, Schema } from 'effect';
+
+import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { todo } from '@dxos/debug';
+import { FunctionError, type FunctionContext, type FunctionDefinition, type Services } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+
+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);
+    }),
+  });
+};
+
+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)));
+        });
+      };
+
+      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')<
+  FunctionToolAnnotation,
+  {
+    functionName: string;
+  }
+>() {}
+
+const toolCache = new WeakMap<FunctionDefinition<any, any>, AiTool.Any>();
+const projectFunctionToTool = (fn: FunctionDefinition<any, any>): AiTool.Any => {
+  if (toolCache.has(fn)) {
+    return toolCache.get(fn)!;
+  }
+  const tool = AiTool.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 });
+  toolCache.set(fn, tool);
+  return tool;
+};
+
+/**
+ * @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-_]*$/));
+  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,
+  );
+};
+
+// 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 } }));

package/src/index.ts

@@ -2,8 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './context';
+export * from './conversation';
 export * from './extraction';
+export * from './functions';
 export * from './research';
 export * from './session';
+export * from './templates';
 export * from './types';
-export * from './blueprint';