@dxos/assistant 0.8.4-main.5acf9ea → 0.8.4-main.5ea62a8

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';
 

package/src/extraction/quotes.ts

@@ -4,7 +4,7 @@
 
 import { Schema } from 'effect';
 
-import { Query, Filter } from '@dxos/echo';
+import { Filter, Query } from '@dxos/echo';
 import { type EchoDatabase } from '@dxos/echo-db';
 import { ObjectId } from '@dxos/echo-schema';
 import { DXN } from '@dxos/keys';

package/src/functions/services.ts

@@ -2,52 +2,68 @@
 // Copyright 2025 DXOS.org
 //
 
-import { AiTool } from '@effect/ai';
-import { Context, Effect, Layer, Match, Predicate, Record, Schema } from 'effect';
+import { AiTool, type AiToolkit } from '@effect/ai';
+import { Context, Effect, Layer, Record, Schema } from 'effect';
 
 import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from '@dxos/ai';
-import { LocalFunctionExecutionService, type FunctionDefinition } from '@dxos/functions';
+import { todo } from '@dxos/debug';
+import { type FunctionDefinition, LocalFunctionExecutionService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 
 export const makeToolResolverFromFunctions = (
   functions: FunctionDefinition<any, any>[],
+  toolkit: AiToolkit.Any,
 ): Layer.Layer<ToolResolverService> => {
   return Layer.succeed(ToolResolverService, {
     resolve: Effect.fn('resolveTool')(function* (id) {
-      const fn = functions.find((f) => f.name === id);
-      if (!fn) {
+      const tool = toolkit.tools[id];
+      if (tool) {
+        return tool;
+      }
+
+      const functionDef = functions.find((fn) => fn.name === id);
+      if (!functionDef) {
         return yield* Effect.fail(new AiToolNotFoundError(id));
       }
 
-      return projectFunctionToTool(fn);
+      return projectFunctionToTool(functionDef);
     }),
   });
 };
 
 export const makeToolExecutionServiceFromFunctions = (
   functions: FunctionDefinition<any, any>[],
+  toolkit: AiToolkit.AiToolkit<AiTool.Any>,
+  handlersLayer: Layer.Layer<AiTool.ToHandler<AiTool.AiTool<any>>, never, never>,
 ): Layer.Layer<ToolExecutionService, never, LocalFunctionExecutionService> => {
   return Layer.effect(
     ToolExecutionService,
     Effect.gen(function* () {
+      const toolkitHandler = yield* toolkit.pipe(Effect.provide(handlersLayer));
       const localFunctionExecutionService = yield* LocalFunctionExecutionService;
+
       return {
         handlersFor: (toolkit) => {
           const makeHandler = (tool: AiTool.Any): ((params: unknown) => Effect.Effect<unknown, any, any>) => {
             return Effect.fn('toolFunctionHandler')(function* (input: any) {
+              if (toolkitHandler.tools.find((t: AiTool.Any) => t.name === tool.name)) {
+                // TODO(wittjosiah): Everything is `never` here.
+                return yield* (toolkitHandler.handle as any)(tool.name, input);
+              }
+
               const { functionName } = Context.get(FunctionToolAnnotation)(tool.annotations as any);
-              const fnDef = functions.find((f) => f.name === functionName);
-              if (!fnDef) {
+              const functionDef = functions.find((fn) => fn.name === functionName);
+              if (!functionDef) {
                 return yield* Effect.fail(new AiToolNotFoundError(tool.name));
               }
 
               return yield* localFunctionExecutionService
-                .invokeFunction(fnDef, input)
+                .invokeFunction(functionDef, input)
                 .pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));
             });
           };
 
-          return toolkit.of(Record.map(toolkit.tools, (tool, name) => makeHandler(tool)) as any) as any;
+          return toolkit.of(Record.map(toolkit.tools, (tool, _name) => makeHandler(tool)) as any) as any;
         },
       };
     }),
@@ -65,10 +81,12 @@ class FunctionToolAnnotation extends Context.Tag('@dxos/assisatnt/FunctionToolAn
 >() {}
 
 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),
@@ -83,17 +101,19 @@ 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, '');
+  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,
-  );
+  switch (schema.ast._tag) {
+    case 'TypeLiteral':
+      return Object.fromEntries(schema.ast.propertySignatures.map((prop) => [prop.name, Schema.make(prop.type)]));
+    case 'VoidKeyword':
+      return {};
+    default:
+      return todo(`Unsupported schema AST: ${schema.ast._tag}`);
+  }
 };

package/src/index.ts

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

package/src/session/artifact-diff.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Context } from 'effect';
+
+import { type ObjectVersion } from '@dxos/echo-db';
+import { type ObjectId } from '@dxos/echo-schema';
+
+/**
+ * Resolves artifact ids to their versions.
+ * Used to give the model a sense of the changes to the artifacts made by users during the conversation.
+ * The artifacts versions are pinned in the history, and whenever the artifact changes in-between assistant's steps,
+ * a diff is inserted into the conversation.
+ *
+ * Can be optionally provided to the session run call.
+ */
+// TODO(dmaretskyi): Convert to Context.Reference
+export class ArtifactDiffResolver extends Context.Tag('@dxos/assistant/ArtifactDiffResolver')<
+  ArtifactDiffResolver,
+  ArtifactDiffResolver.Service
+>() {}
+
+export namespace ArtifactDiffResolver {
+  export type Service = {
+    resolve: (
+      artifacts: {
+        id: ObjectId;
+        lastVersion: ObjectVersion;
+      }[],
+    ) => Promise<
+      Map<
+        ObjectId,
+        {
+          version: ObjectVersion;
+          diff?: string;
+        }
+      >
+    >;
+  };
+}

package/src/session/error-handling.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AiError } from '@effect/ai';
+import { HttpClientError } from '@effect/platform';
+import { Effect, Schema } from 'effect';
+
+import { AnthropicError } from '../errors';
+
+const AnthropicErrorResponse = Schema.Struct({
+  type: Schema.Literal('error'),
+  error: Schema.Struct({
+    type: Schema.String,
+    message: Schema.String,
+  }),
+});
+
+export const mapAiError = (err: AiError.AiError): Effect.Effect<AiError.AiError> =>
+  Effect.gen(function* () {
+    const cause = err.cause;
+    if (HttpClientError.isHttpClientError(cause) && cause.reason === 'StatusCode') {
+      const body = yield* cause.response.json.pipe(
+        Effect.flatMap(Schema.decodeUnknown(AnthropicErrorResponse, { exact: false })),
+      );
+
+      const parsedCause = new AnthropicError(`${body.error.type}: ${body.error.message}`);
+      return new AiError.AiError({
+        description: body.error.message,
+        module: err.module,
+        method: err.method,
+        cause: parsedCause,
+      });
+    }
+    return err;
+  }).pipe(Effect.catchAll(() => Effect.succeed(err)));

package/src/session/format.test.ts

@@ -0,0 +1,60 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { beforeAll, describe, it } from '@effect/vitest';
+import { Effect } from 'effect';
+
+import { Blueprint, Template } from '@dxos/blueprints';
+import { Obj } from '@dxos/echo';
+import { type EchoDatabase } from '@dxos/echo-db';
+import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { DataType } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+import { createSystemPrompt } from '../templates/system';
+
+import { formatSystemPrompt } from './format';
+
+describe('format', () => {
+  let db: EchoDatabase;
+  beforeAll(async () => {
+    const builder = await new EchoTestBuilder().open();
+    ({ db } = await builder.createDatabase({
+      types: [DataType.Text, DataType.Organization, Blueprint.Blueprint],
+    }));
+  });
+
+  it.effect(
+    'should format',
+    Effect.fn(function* () {
+      const object = db.add(
+        Obj.make(DataType.Organization, {
+          name: 'Test',
+          website: 'https://www.test.com',
+        }),
+      );
+
+      const blueprint = db.add(
+        Blueprint.make({
+          key: 'example.com/blueprint/test',
+          name: 'Test',
+          instructions: Template.make({
+            source: trim`
+              Test
+              This is the test blueprint.
+            `,
+          }),
+        }),
+      );
+
+      const output = yield* formatSystemPrompt({
+        system: createSystemPrompt({}),
+        blueprints: [blueprint, blueprint],
+        objects: [object, object],
+      });
+
+      console.log(output);
+    }),
+  );
+});

package/src/session/format.ts

@@ -0,0 +1,139 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Array, Effect, Option, pipe } from 'effect';
+
+import { Template } from '@dxos/blueprints';
+import { Obj } from '@dxos/echo';
+import { ObjectVersion } from '@dxos/echo-db';
+import { type ObjectId } from '@dxos/echo-schema';
+import { DatabaseService } from '@dxos/functions';
+import { log } from '@dxos/log';
+import { type ContentBlock, DataType } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+import { AiAssistantError } from '../errors';
+
+import { ArtifactDiffResolver } from './artifact-diff';
+import { type AiSessionRunParams } from './session';
+
+/**
+ * Formats the system prompt.
+ */
+// TODO(burdon): Move to AiPreprocessor.
+export const formatSystemPrompt = ({
+  system,
+  blueprints = [],
+  objects = [],
+}: Pick<AiSessionRunParams<any>, 'system' | 'blueprints' | 'objects'>) =>
+  Effect.gen(function* () {
+    const blueprintDefs = yield* pipe(
+      blueprints,
+      Effect.forEach((blueprint) => Effect.succeed(blueprint.instructions)),
+      Effect.flatMap(Effect.forEach((template) => DatabaseService.loadOption(template.source))),
+      Effect.map(Array.filter(Option.isSome)),
+      Effect.map(
+        Array.map(
+          (template) => trim`
+            <blueprint>
+              ${Template.process(template.value.content)}
+            </blueprint>
+          `,
+        ),
+      ),
+      Effect.map((blueprints) =>
+        blueprints.length > 0 ? ['## Blueprints Definitions', ...blueprints].join('\n\n') : undefined,
+      ),
+    );
+
+    const objectDefs = yield* pipe(
+      objects,
+      Effect.forEach((object) =>
+        Effect.succeed(trim`
+          <object>
+            <dxn>${Obj.getDXN(object)}</dxn>
+            <typename>${Obj.getTypename(object)}</typename>
+          </object>
+        `),
+      ),
+      Effect.map((objects) => (objects.length > 0 ? ['## Context Objects', ...objects].join('\n\n') : undefined)),
+    );
+
+    return yield* pipe(
+      Effect.succeed([system, blueprintDefs, objectDefs].filter((def): def is string => def !== undefined)),
+      Effect.map((parts) => parts.join('\n\n')),
+    );
+  });
+
+/**
+ * Formats the user prompt.
+ */
+// TODO(burdon): Move to AiPreprocessor.
+// TODO(burdon): Convert util below to `Effect.fn` (to preserve stack info)
+export const formatUserPrompt = ({ prompt, history = [] }: Pick<AiSessionRunParams<any>, 'prompt' | 'history'>) =>
+  Effect.gen(function* () {
+    const blocks: ContentBlock.Any[] = [];
+
+    // TODO(dmaretskyi): Evaluate other approaches as `serviceOption` isn't represented in the type system.
+    const artifactDiffResolver = yield* Effect.serviceOption(ArtifactDiffResolver);
+    if (Option.isSome(artifactDiffResolver)) {
+      const versions = gatherObjectVersions(history);
+      const artifactDiff = yield* Effect.tryPromise({
+        try: () =>
+          artifactDiffResolver.value.resolve(
+            [...versions.entries()].map(([id, version]) => ({ id, lastVersion: version })),
+          ),
+        catch: AiAssistantError.wrap('Artifact diff resolution error'),
+      });
+
+      log.info('version', { artifactDiff, versions });
+      for (const [id, { version }] of [...artifactDiff.entries()]) {
+        if (ObjectVersion.equals(version, versions.get(id)!)) {
+          artifactDiff.delete(id);
+          continue;
+        }
+
+        blocks.push({ _tag: 'anchor', objectId: id, version });
+      }
+
+      if (artifactDiff.size > 0) {
+        blocks.push(createArtifactUpdateBlock(artifactDiff));
+      }
+    }
+
+    return Obj.make(DataType.Message, {
+      created: new Date().toISOString(),
+      sender: { role: 'user' },
+      blocks: [...blocks, { _tag: 'text', text: prompt }],
+    });
+  });
+
+const gatherObjectVersions = (messages: DataType.Message[]): Map<ObjectId, ObjectVersion> => {
+  const artifactIds = new Map<ObjectId, ObjectVersion>();
+  for (const message of messages) {
+    for (const block of message.blocks) {
+      if (block._tag === 'anchor') {
+        artifactIds.set(block.objectId, block.version as ObjectVersion);
+      }
+    }
+  }
+
+  return artifactIds;
+};
+
+const createArtifactUpdateBlock = (
+  artifactDiff: Map<ObjectId, { version: ObjectVersion; diff?: string }>,
+): ContentBlock.Any => {
+  return {
+    _tag: 'text',
+    // TODO(dmaretskyi): Does this need to be a special content-block?
+    disposition: 'artifact-update',
+    text: trim`
+      The following artifacts have been updated since the last message:
+      ${[...artifactDiff.entries()]
+        .map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `\n${diff}` : ''}</changed-artifact>`)
+        .join('\n')}
+    `,
+  };
+};

package/src/session/index.ts

@@ -2,5 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './artifact-diff';
+export * from './observer';
 export * from './session';
+export * from './toolkit';
 export * from './version-pin';

package/src/session/observer.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Function } from 'effect';
+
+import { type AiParser, type ConsolePrinter } from '@dxos/ai';
+import { type DataType } from '@dxos/schema';
+
+/**
+ * Live observer of the generation process.
+ */
+export interface GenerationObserver extends AiParser.ParseResponseCallbacks {
+  /**
+   * Complete messages fired during the session, both from the model and from the user.
+   * This message will contain all message blocks emitted through the `onBlock` callback.
+   */
+  onMessage: (message: DataType.Message) => Effect.Effect<void>;
+}
+
+export const GenerationObserver = Object.freeze({
+  make: ({
+    onBegin = Function.constant(Effect.void),
+    onPart = Function.constant(Effect.void),
+    onBlock = Function.constant(Effect.void),
+    onEnd = Function.constant(Effect.void),
+    onMessage = Function.constant(Effect.void),
+  }: Partial<GenerationObserver> = {}): GenerationObserver => ({
+    onBegin,
+    onPart,
+    onBlock,
+    onEnd,
+    onMessage,
+  }),
+
+  noop: () => GenerationObserver.make(),
+
+  /**
+   * Debug printer to be used in unit-tests and browser devtools.
+   */
+  fromPrinter: (printer: ConsolePrinter) =>
+    GenerationObserver.make({
+      onBlock: (block) =>
+        Effect.sync(() => {
+          if (block.pending) {
+            return; // Only prints full blocks (better for unit-tests and browser devtools).
+          }
+          printer.printContentBlock(block);
+        }),
+      onMessage: (message) =>
+        Effect.sync(() => {
+          if (message.sender.role === 'assistant') {
+            return; // Skip assistant messages since they are printed in the `onBlock` callback.
+          }
+          printer.printMessage(message);
+        }),
+    }),
+});

package/src/session/session.test.ts

@@ -9,6 +9,7 @@ import { Effect, Layer, Schema } from 'effect';
 import { AiService, ToolExecutionService, ToolResolverService } from '@dxos/ai';
 import { AiServiceTestingPreset } from '@dxos/ai/testing';
 import { Obj, Type } from '@dxos/echo';
+import { TracingService } from '@dxos/functions';
 import { log } from '@dxos/log';
 
 import { AiSession } from './session';
@@ -52,7 +53,7 @@ const toolkitLayer = TestToolkit.toLayer({
         const sanitizedInput = input.replace(/[^0-9+\-*/().\s]/g, '');
         log.info('calculate', { sanitizedInput });
 
-        // eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval
+        // eslint-disable-next-line @typescript-eslint/no-implied-eval
         return Function(`"use strict"; return (${sanitizedInput})`)();
       })();
 
@@ -61,49 +62,49 @@ const toolkitLayer = TestToolkit.toLayer({
 });
 
 describe.runIf(process.env.DX_RUN_SLOW_TESTS)('AiSession', () => {
-  it.effect(
-    'no tools',
-    Effect.fn(
-      function* ({ expect }) {
-        const session = new AiSession({ operationModel: 'configured' });
-
-        const response = yield* session.run({
-          prompt: 'Hello world!',
-          history: [],
-        });
-        log.info('response', { response });
-      },
+  it.effect('no tools', () =>
+    Effect.gen(function* () {
+      const session = new AiSession({ operationModel: 'configured' });
+      const response = yield* session.run({
+        prompt: 'Hello world!',
+        history: [],
+      });
+      log.info('response', { response });
+    }).pipe(
       Effect.provide(
-        AiService.model('@anthropic/claude-3-5-sonnet-20241022').pipe(
-          Layer.provideMerge(ToolResolverService.layerEmpty),
-          Layer.provideMerge(ToolExecutionService.layerEmpty),
-          Layer.provideMerge(AiServiceTestingPreset('direct')),
+        Layer.mergeAll(
+          toolkitLayer,
+          AiService.model('@anthropic/claude-3-5-sonnet-20241022').pipe(
+            Layer.provideMerge(ToolResolverService.layerEmpty),
+            Layer.provideMerge(ToolExecutionService.layerEmpty),
+            Layer.provideMerge(AiServiceTestingPreset('direct')),
+            Layer.provideMerge(TracingService.layerNoop),
+          ),
         ),
       ),
     ),
   );
 
-  it.effect.only(
-    'calculator',
-    Effect.fn(
-      function* ({ expect }) {
-        const session = new AiSession({ operationModel: 'configured' });
-
-        const response = yield* session.run({
-          prompt: 'What is 10 + 20?',
-          history: [],
-          toolkit: TestToolkit,
-        });
-        log.info('response', { response });
-      },
+  it.effect('calculator', () =>
+    Effect.gen(function* () {
+      const session = new AiSession({ operationModel: 'configured' });
+      const toolkit = yield* TestToolkit;
+      const response = yield* session.run({
+        toolkit,
+        prompt: 'What is 10 + 20?',
+        history: [],
+      });
+      log.info('response', { response });
+    }).pipe(
       Effect.provide(
         Layer.mergeAll(
-          toolkitLayer,
-          ToolResolverService.layerEmpty,
-          ToolExecutionService.layerEmpty,
+          TracingService.layerNoop,
           AiService.model('@anthropic/claude-3-5-sonnet-20241022').pipe(
             Layer.provideMerge(AiServiceTestingPreset('direct')),
           ),
+          ToolResolverService.layerEmpty,
+          ToolExecutionService.layerEmpty,
+          toolkitLayer,
         ),
       ),
     ),
@@ -112,11 +113,8 @@ describe.runIf(process.env.DX_RUN_SLOW_TESTS)('AiSession', () => {
   // TODO(dmaretskyi): Revive test.
   /*
   it.skip('create calendar itinerary', { timeout: 60_000 }, async () => {
-    
-    //   overrides: { model: 'llama3.1:8b' },
-    
+    // overrides: { model: 'llama3.1:8b' },
     const session = new AiSession({ operationModel: 'configured' });
-
     const objects = new Set<string>();
 
     // Define calendar artifact.
@@ -235,7 +233,7 @@ describe.runIf(process.env.DX_RUN_SLOW_TESTS)('AiSession', () => {
 });
 
 // Travel to rome, florence, livorno, siena, madrid for conferences
-// eslint-disable-next-line no-unused-vars
+
 const _CALENDAR_EVENTS: CalendarEvent[] = [
   Obj.make(CalendarEventSchema, {
     title: 'Exploring Ancient Ruins in Rome',