@dxos/assistant 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/src/conversation/conversation.ts

@@ -2,15 +2,27 @@
 // Copyright 2025 DXOS.org
 //
 
-import type * as Toolkit from '@effect/ai/Toolkit';
 import type { Registry } from '@effect-atom/atom-react';
+import type * as Tool from '@effect/ai/Tool';
+import type * as Toolkit from '@effect/ai/Toolkit';
+import * as Array from 'effect/Array';
+import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import * as Either from 'effect/Either';
+import { pipe } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Record from 'effect/Record';
+import * as Runtime from 'effect/Runtime';
 
+import { type ToolExecutionService, type ToolResolverService } from '@dxos/ai';
+import { type GenericToolkit } from '@dxos/ai';
+import { type Blueprint } from '@dxos/blueprints';
 import { Resource } from '@dxos/context';
-import { Obj } from '@dxos/echo';
-import { type Queue } from '@dxos/echo-db';
+import { Database, Feed, Filter, Obj } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
+import { McpToolkit } from '@dxos/mcp-client';
 import { Message } from '@dxos/types';
 
 import {
@@ -19,24 +31,31 @@ import {
   type AiSessionRunRequirements,
   type GenerationObserver,
   createToolkit,
+  formatSystemPrompt,
 } from '../session';
+import { AiContextBinder, AiContextService } from './context';
 
-import { AiContextBinder, AiContextService, type ContextBinding } from './context';
-
-export interface AiConversationRunProps {
+export interface AiConversationRunProps<Tools extends Record<string, Tool.Any>> {
   prompt: string;
   system?: string;
   observer?: GenerationObserver;
+  toolkit?: Toolkit.Toolkit<Tools>;
 }
 
 export type AiConversationOptions = {
-  queue: Queue<Message.Message | ContextBinding>;
-  toolkit?: Toolkit.Any;
+  feed: Feed.Feed;
+  runtime: Runtime.Runtime<Feed.FeedService>;
   registry?: Registry.Registry;
 };
 
+// TODO(dmaretskyi): Take from model characteristics. opus has 200k max tokens.
 /**
- * Durable conversation state (initiated by users and agents) backed by a Queue.
+ * Summarization threshold in tokens.
+ */
+const SUMMARY_THRESHOLD = 80_000;
+
+/**
+ * Durable conversation state (initiated by users and agents) backed by a Feed.
  * Executes tools based on AI responses and supports cancellation of in-progress requests.
  */
 export class AiConversation extends Resource {
@@ -44,23 +63,25 @@ export class AiConversation extends Resource {
    * Blueprints and objects bound to the conversation.
    */
   private readonly _binder: AiContextBinder;
-  private readonly _queue: Queue<Message.Message | ContextBinding>;
+  private readonly _feed: Feed.Feed;
+  private readonly _runtime: Runtime.Runtime<Feed.FeedService>;
   private readonly _toolkit?: Toolkit.Any;
 
   public constructor(options: AiConversationOptions) {
     super();
-    this._queue = options.queue;
-    this._toolkit = options.toolkit;
-    invariant(this._queue);
-    this._binder = new AiContextBinder({ queue: this._queue, registry: options.registry });
+    this._feed = options.feed;
+    this._runtime = options.runtime;
+    invariant(this._feed);
+    invariant(this._runtime);
+    this._binder = new AiContextBinder({ feed: this._feed, runtime: this._runtime, registry: options.registry });
   }
 
   protected override async _open(): Promise<void> {
     await this._binder.open(this._ctx);
   }
 
-  public get queue() {
-    return this._queue;
+  public get feed() {
+    return this._feed;
   }
 
   public get context() {
@@ -72,54 +93,183 @@ export class AiConversation extends Resource {
   }
 
   public async getHistory(): Promise<Message.Message[]> {
-    const queueItems = await this._queue.queryObjects(); // TODO(burdon): Update.
-    return queueItems.filter(Obj.instanceOf(Message.Message));
+    const queryResult = await Runtime.runPromise(this._runtime)(Feed.query(this._feed, Filter.type(Message.Message)));
+    const items = await queryResult.run();
+    return items.filter(Obj.instanceOf(Message.Message));
+  }
+
+  getTools(): Effect.Effect<Record<string, Tool.Any>, never, ToolExecutionService | ToolResolverService> {
+    return Effect.gen(this, function* () {
+      const blueprints = this.context.getBlueprints();
+      const tookit = yield* createToolkit({ toolkit: this._toolkit, blueprints });
+      return tookit.tools;
+    }).pipe(Effect.orDie);
   }
 
   /**
    * Creates a new cancelable request effect.
    */
-  public createRequest(
-    params: AiConversationRunProps,
-  ): Effect.Effect<Message.Message[], AiSessionRunError, AiSessionRunRequirements> {
-    const self = this;
-    return Effect.gen(function* () {
-      const history = yield* Effect.promise(() => self.getHistory());
-
-      // Create toolkit.
-      const blueprints = self.context.getBlueprints();
-      const toolkit = yield* createToolkit({
-        toolkit: self._toolkit,
-        blueprints,
-      });
-
-      // Context objects.
-      const objects = self.context.getObjects();
+  public createRequest<Tools extends Record<string, Tool.Any> = {}>(
+    params: AiConversationRunProps<Tools>,
+  ): Effect.Effect<Message.Message[], AiSessionRunError, AiSessionRunRequirements | Tool.HandlersFor<Tools>> {
+    return Effect.gen(this, function* () {
+      const history = yield* Effect.promise(() => this.getHistory());
+      const blueprints = this.context.getBlueprints();
+      const objects = this.context.getObjects();
 
       log('run', {
         history: history.length,
         blueprints: blueprints.length,
-        tools: Object.keys(toolkit.tools).length,
         objects: objects.length,
       });
 
-      // Process request.
-      const session = new AiSession();
-      const messages = yield* session.run({ history, blueprints, toolkit, objects, ...params }).pipe(
-        Effect.provideService(AiContextService, {
-          binder: self.context,
-        }),
-      );
+      const session = new AiSession({
+        summarizationThreshold: SUMMARY_THRESHOLD,
+        observer: params.observer,
+        onOutput: (message) =>
+          Effect.promise(() => Runtime.runPromise(this._runtime)(Feed.append(this._feed, [message]))),
+      });
+
+      yield* session.begin({
+        history,
+        blueprints,
+        objects,
+        prompt: params.prompt,
+        system: params.system,
+      });
+
+      // Turn loop: recompute toolkit and system prompt between turns to pick up dynamically enabled blueprints.
+      do {
+        yield* Effect.promise(() => this.context.sync());
+        const currentBlueprints = this.context.getBlueprints();
+        const mcps = yield* connectMcpServers(currentBlueprints);
+        const toolkit = yield* createToolkit({
+          toolkit: params.toolkit,
+          blueprints: currentBlueprints,
+          genericToolkits: mcps,
+        });
+        log('toolkit', { tools: Record.keys(toolkit.tools) });
+        const system = yield* formatSystemPrompt({
+          system: params.system,
+          blueprints: currentBlueprints,
+          objects: this.context.getObjects(),
+        }).pipe(Effect.orDie);
+
+        const { done } = yield* session.runAgentTurn({
+          system,
+          toolkit,
+        });
+
+        if (done) {
+          break;
+        }
+
+        yield* session.runTools({ toolkit });
+      } while (true);
 
       log('result', {
-        messages: messages.length,
+        messages: session.pending.length,
         duration: session.duration,
         toolCalls: session.toolCalls,
       });
 
-      // Append to queue.
-      yield* Effect.promise(() => self._queue.append(messages));
-      return messages;
-    });
+      return [...session.pending];
+    }).pipe(
+      Effect.provide(
+        Layer.mergeAll(
+          Layer.succeed(AiContextService, {
+            binder: this.context,
+          }),
+          Layer.succeed(AiConversationService, this),
+        ),
+      ),
+    );
   }
 }
+
+/**
+ * Gives access to the ai conversation.
+ */
+export class AiConversationService extends Context.Tag('@dxos/assistant/AiConversationService')<
+  AiConversationService,
+  AiConversation
+>() {
+  /**
+   * Create a new conversation layer from options.
+   */
+  static layer = (options: AiConversationOptions): Layer.Layer<AiConversationService | AiContextService> =>
+    aiContextFromConversation.pipe(
+      Layer.provideMerge(
+        Layer.scoped(
+          AiConversationService,
+          Effect.gen(function* () {
+            const conversation = yield* acquireReleaseResource(() => new AiConversation(options));
+            return conversation;
+          }),
+        ),
+      ),
+    );
+
+  /**
+   * Create a new conversation with a new feed.
+   */
+  static layerNewFeed = (
+    options?: Omit<AiConversationOptions, 'feed' | 'runtime'>,
+  ): Layer.Layer<AiConversationService | AiContextService, never, Database.Service | Feed.FeedService> =>
+    Layer.unwrapScoped(
+      Effect.gen(function* () {
+        const feed = Feed.make();
+        yield* Database.add(feed);
+        const runtime = yield* Effect.runtime<Feed.FeedService>();
+        return AiConversationService.layer({
+          ...options,
+          feed,
+          runtime,
+        });
+      }),
+    );
+
+  /**
+   * Run a prompt in the current conversation.
+   */
+  static run = <Tools extends Record<string, Tool.Any> = {}>(
+    params: AiConversationRunProps<Tools>,
+  ): Effect.Effect<
+    Message.Message[],
+    AiSessionRunError,
+    AiSessionRunRequirements | Tool.HandlersFor<Tools> | AiConversationService
+  > =>
+    Effect.gen(function* () {
+      const conversation = yield* AiConversationService;
+      return yield* conversation.createRequest(params);
+    });
+}
+
+const aiContextFromConversation = Layer.effect(
+  AiContextService,
+  Effect.gen(function* () {
+    const conversation = yield* AiConversationService;
+    return {
+      binder: conversation.context,
+    };
+  }),
+);
+
+const connectMcpServers = (
+  blueprints: readonly Blueprint.Blueprint[],
+): Effect.Effect<GenericToolkit.GenericToolkit[]> =>
+  pipe(
+    blueprints,
+    Array.flatMap((_) => _.mcpServers ?? []),
+    Effect.forEach(({ url, protocol }) =>
+      McpToolkit.make({ url, kind: protocol }).pipe(
+        // NOTE: Type-inference fails here without explicit void return.
+        Effect.tap((toolkit): void =>
+          log.info('Connected to MCP server', { url, tools: Object.keys(toolkit.toolkit.tools).length }),
+        ),
+        Effect.tapDefect((error) => Effect.sync(() => log.warn('Failed to connect to MCP server', { error }))),
+        Effect.either,
+      ),
+    ),
+    Effect.map(Array.filterMap((_) => Either.getRight(_))),
+  );

package/src/diff.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { createDocAccessor } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
@@ -12,10 +12,17 @@ import { trim } from '@dxos/util';
 import { applyDiffs } from './diff';
 
 describe('diff', () => {
+  let builder: EchoTestBuilder;
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
   it('should apply diffs', async () => {
-    const builder = new EchoTestBuilder();
-    const { db, graph } = await builder.createDatabase();
-    await graph.schemaRegistry.register([Text.Text]);
+    const { db } = await builder.createDatabase({ types: [Text.Text] });
 
     const document = trim`
       # Hello World
@@ -24,7 +31,7 @@ describe('diff', () => {
       But not this one.
     `;
 
-    const text = db.add(Text.make(document));
+    const text = db.add(Text.make({ content: document }));
     const accessor = createDocAccessor(text, ['content']);
     const result = applyDiffs(accessor, [
       `- There'z a typo in this sentence.`,
@@ -40,4 +47,28 @@ describe('diff', () => {
       But not this one.
     `);
   });
+
+  it('should apply diffs that append content at the end', async () => {
+    const { db } = await builder.createDatabase({ types: [Text.Text] });
+
+    const document = '# Shopping list';
+
+    const text = db.add(Text.make({ content: document }));
+    const accessor = createDocAccessor(text, ['content']);
+    const result = applyDiffs(accessor, ['- # Shopping list', '+ # Shopping list\n- Milk']);
+
+    expect(result).toBe('# Shopping list\n- Milk');
+  });
+
+  it('should append text to an empty document', async () => {
+    const builder = new EchoTestBuilder();
+    const { db, graph } = await builder.createDatabase();
+    await graph.schemaRegistry.register([Text.Text]);
+
+    const text = db.add(Text.make({ content: '' }));
+    const accessor = createDocAccessor(text, ['content']);
+    const result = applyDiffs(accessor, ['+ # Shopping list']);
+
+    expect(result).toBe('# Shopping list');
+  });
 });

package/src/diff.ts

@@ -47,9 +47,10 @@ export const reduceDiffs = (diffs: readonly string[]): Diff[] => {
         }
         return acc;
       }
+      default: {
+        throw new Error(`Invalid diff format: each line must start with "- " or "+ ", got: ${JSON.stringify(diff)}`);
+      }
     }
-
-    return acc;
   }, []);
 };
 
@@ -65,7 +66,11 @@ export const computeDiffsWithCursors = <T>(accessor: DocAccessor<T>, diffs: read
     .filter(isNonNullable);
 };
 
-export const applyDiffs = <T>(accessor: DocAccessor<T>, diffs: readonly string[]): string => {
+export const applyDiffs = <T>(
+  accessor: DocAccessor<T>,
+  diffs: readonly string[],
+  { errorOnNotFound = false }: { errorOnNotFound?: boolean } = {},
+): string => {
   for (const diff of reduceDiffs(diffs)) {
     accessor.handle.change((doc: Doc<T>) => {
       const text = DocAccessor.getValue<string>(accessor);
@@ -75,7 +80,11 @@ export const applyDiffs = <T>(accessor: DocAccessor<T>, diffs: readonly string[]
         // NOTE: This only replaces the first match.
         A.splice(doc, accessor.path as A.Prop[], idx, diff.match.length, diff.replace);
       } else {
-        log.warn('diff not found', diff);
+        if (errorOnNotFound) {
+          throw new Error(`Diff not found: ${diff.match}`);
+        } else {
+          log.warn('diff not found', diff);
+        }
       }
     });
   }

package/src/execution-graph.test.ts

@@ -71,7 +71,7 @@ describe('ExecutionGraph', () => {
         blocks: [
           {
             _tag: 'text',
-            text: '{"id":"01K6AXZKK79H4E54RKP1YZDARK","@type":"dxn:type:dxos.org/type/Organization:0.1.0","@meta":{"keys":[]},"name":"Blue Yard","website":"https://blueyard.com"}',
+            text: '{"id":"01K6AXZKK79H4E54RKP1YZDARK","@type":"dxn:type:org.dxos.type.organization:0.1.0","@meta":{"keys":[]},"name":"Blue Yard","website":"https://blueyard.com"}',
           },
         ],
         properties: {},
@@ -619,7 +619,7 @@ describe('ExecutionGraph', () => {
           { _tag: 'reasoning', reasoningText: 'I need to think about this' },
           { _tag: 'toolCall', toolCallId: 'tool1', name: 'analyze', input: '{}', providerExecuted: false },
           {
-            _tag: 'summary',
+            _tag: 'stats',
             message: 'OK',
             duration: 1000,
             toolCalls: 1,

package/src/execution-graph.ts

@@ -40,7 +40,7 @@ enum IconType {
   // Interactions.
   USER = 'ph--user--regular',
   USER_INTERACTION = 'ph--user-sound--regular',
-  AGENT = 'ph--robot--regular',
+  AGENT = 'ph--drone--regular',
   THINKING = 'ph--brain--regular',
   LINK = 'ph--link--regular',
   TOOL = 'ph--wrench--regular',
@@ -412,7 +412,7 @@ const createBlockCommit = (
         message: block.error ? 'Tool error: ' + block.error : 'Tool call succeeded',
       } satisfies Commit;
 
-    case 'summary':
+    case 'stats':
       return {
         id: getGenericBlockId(message.id, idx),
         branch,
@@ -420,7 +420,7 @@ const createBlockCommit = (
         timestamp,
         icon: IconType.ROCKET,
         level: LogLevel.INFO,
-        message: ContentBlock.createSummaryMessage(block),
+        message: ContentBlock.createStatsMessage(block),
       } satisfies Commit;
 
     case 'status':

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

@@ -2,5 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './extraction-ner-function';
 export * from './named-entity-recognition';

package/src/extraction/extraction.ts

@@ -4,16 +4,14 @@
 
 import * as Schema from 'effect/Schema';
 
-import { asyncTimeout } from '@dxos/async';
-import { Type } from '@dxos/echo';
-import { type FunctionDefinition } from '@dxos/functions';
-import { type FunctionExecutor } from '@dxos/functions-runtime';
+import { Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
+import { Operation } from '@dxos/operation';
 import { Message } from '@dxos/types';
 
 export const ExtractionInput = Schema.Struct({
   message: Message.Message,
-  objects: Schema.optional(Schema.Array(Type.Obj)),
+  objects: Schema.optional(Schema.Array(Obj.Unknown)),
   options: Schema.optional(
     Schema.Struct({
       timeout: Schema.optional(Schema.Number),
@@ -31,8 +29,7 @@ export interface ExtractionOutput extends Schema.Schema.Type<typeof ExtractionOu
 
 export type ProcessTranscriptMessageProps = {
   input: ExtractionInput;
-  function: FunctionDefinition<ExtractionInput, ExtractionOutput>;
-  executor: FunctionExecutor;
+  function: Operation.Definition<ExtractionInput, ExtractionOutput>;
 
   options?: {
     /**
@@ -49,7 +46,35 @@ export type ProcessTranscriptMessageProps = {
   };
 };
 
-export type ExtractionFunction = FunctionDefinition<ExtractionInput, ExtractionOutput>;
+export type ExtractionFunction = Operation.Definition<ExtractionInput, ExtractionOutput>;
+
+/**
+ * Placeholder for Anthropic-based entity extraction.
+ * Implementation is currently disabled pending restoration of extraction logic.
+ */
+export const extractionAnthropicFunction = Operation.make({
+  meta: {
+    key: 'org.dxos.function.extraction.anthropic',
+    name: 'Entity Extraction (Anthropic)',
+    description: 'Extract entities from transcript using Anthropic LLM.',
+  },
+  input: ExtractionInput,
+  output: ExtractionOutput,
+});
+
+/**
+ * Placeholder for NER-based entity extraction.
+ * Implementation is currently disabled pending restoration of extraction logic.
+ */
+export const extractionNerFunction = Operation.make({
+  meta: {
+    key: 'org.dxos.function.extraction.ner',
+    name: 'Entity Extraction (NER)',
+    description: 'Extract entities from transcript using Named Entity Recognition.',
+  },
+  input: ExtractionInput,
+  output: ExtractionOutput,
+});
 
 /**
  * Extract entities from the transcript message and add them to the message.
@@ -58,9 +83,9 @@ export type ExtractionFunction = FunctionDefinition<ExtractionInput, ExtractionO
 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);
+      // return await asyncTimeout(params.executor.invoke(params.function, params.input), params.options.timeout);
     } else {
-      return await params.executor.invoke(params.function, params.input);
+      // return await params.executor.invoke(params.function, params.input);
     }
   } catch (error) {
     if (params.options?.fallbackToRaw) {
@@ -73,4 +98,7 @@ export const processTranscriptMessage = async (params: ProcessTranscriptMessageP
       throw error;
     }
   }
+
+  // TODO(dmaretskyi): Restore extraction logic.
+  return { message: params.input.message, timeElapsed: 0 };
 };

package/src/extraction/index.ts

@@ -3,6 +3,5 @@
 //
 
 export * from './extraction';
-export * from './extraction-llm-function';
 export * from './extraction-ner-function';
 export * from './quotes';