@dxos/assistant 0.8.4-main.84f28bd → 0.8.4-main.9735255

package/src/conversation/conversation.ts

@@ -2,102 +2,124 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Message, type ExecutableTool } from '@dxos/ai';
-import { type ArtifactDefinition } from '@dxos/artifact';
-import { Event } from '@dxos/async';
-import { Obj, Ref } from '@dxos/echo';
+import type * as Toolkit from '@effect/ai/Toolkit';
+import type { Registry } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+
+import { Resource } from '@dxos/context';
+import { Obj } from '@dxos/echo';
 import { type Queue } from '@dxos/echo-db';
-import { AiService, ToolResolverService, type ServiceContainer } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { isNonNullable } from '@dxos/util';
-
-import { ContextBinder, type ContextBinding } from '../context';
-import { AISession, type SessionRunOptions } from '../session';
+import { Message } from '@dxos/types';
 
-export interface ConversationRunOptions {
-  systemPrompt?: string;
-  prompt: string;
+import {
+  AiSession,
+  type AiSessionRunError,
+  type AiSessionRunRequirements,
+  type GenerationObserver,
+  createToolkit,
+} from '../session';
 
-  tools?: ExecutableTool[];
-  artifacts?: ArtifactDefinition[];
-  extensions?: ToolContextExtensions;
-  generationOptions?: SessionRunOptions['generationOptions'];
+import { AiContextBinder, AiContextService, type ContextBinding } from './context';
 
-  /** @depreacated Should be managed by the conversation. */
-  requiredArtifactIds?: string[];
-
-  // TODO(dmaretskyi): Move into conversation.
-  artifactDiffResolver?: SessionRunOptions['artifactDiffResolver'];
+export interface AiConversationRunProps {
+  prompt: string;
+  system?: string;
+  observer?: GenerationObserver;
 }
 
-export type ConversationOptions = {
-  serviceContainer: ServiceContainer;
-  queue: Queue<Message | ContextBinding>;
+export type AiConversationOptions = {
+  queue: Queue<Message.Message | ContextBinding>;
+  toolkit?: Toolkit.Any;
+  registry?: Registry.Registry;
 };
 
 /**
- * Persistent conversation state.
- * Context + history + artifacts.
- * Backed by a Queue.
+ * Durable conversation state (initiated by users and agents) backed by a Queue.
+ * Executes tools based on AI responses and supports cancellation of in-progress requests.
  */
-export class Conversation {
-  private readonly _serviceContainer: ServiceContainer;
-  private readonly _queue: Queue<Message | ContextBinding>;
-
+export class AiConversation extends Resource {
   /**
-   * Fired when the execution loop begins.
-   * This is called before the first message is sent.
+   * Blueprints and objects bound to the conversation.
    */
-  public readonly onBegin = new Event<AISession>();
+  private readonly _binder: AiContextBinder;
+  private readonly _queue: Queue<Message.Message | ContextBinding>;
+  private readonly _toolkit?: Toolkit.Any;
 
-  /**
-   * Blueprints bound to the conversation.
-   */
-  public readonly context: ContextBinder;
-
-  constructor(options: ConversationOptions) {
-    this._serviceContainer = options.serviceContainer;
+  public constructor(options: AiConversationOptions) {
+    super();
     this._queue = options.queue;
-    this.context = new ContextBinder(this._queue);
+    this._toolkit = options.toolkit;
+    invariant(this._queue);
+    this._binder = new AiContextBinder({ queue: this._queue, registry: options.registry });
   }
 
-  async run(options: ConversationRunOptions): Promise<Message[]> {
-    const session = new AISession({ operationModel: 'configured' });
-    this.onBegin.emit(session);
-
-    const history = await this.getHistory();
-    const context = await this.context.query();
-    const blueprints = (await Ref.Array.loadAll([...context.blueprints])).filter(isNonNullable);
-    if (blueprints.length > 1) {
-      log.warn('multiple blueprints are not yet supported');
-    }
-
-    const messages = await session.run({
-      history,
-      prompt: options.prompt,
-      systemPrompt: (options.systemPrompt ?? '') + (blueprints.at(0)?.instructions ?? ''),
-
-      // TODO(dmaretskyi): Artifacts come from the blueprint?
-      artifacts: options.artifacts ?? [],
-      tools: blueprints.at(0)?.tools ?? [],
-      executableTools: options.tools,
-      requiredArtifactIds: options.requiredArtifactIds,
-      client: this._serviceContainer.getService(AiService).client,
-      toolResolver: this._serviceContainer.getService(ToolResolverService).toolResolver,
-      extensions: {
-        serviceContainer: this._serviceContainer,
-        ...options.extensions,
-      },
-      generationOptions: options.generationOptions,
-    });
+  protected override async _open(): Promise<void> {
+    await this._binder.open(this._ctx);
+  }
 
-    await this._queue.append(messages);
+  public get queue() {
+    return this._queue;
+  }
 
-    return messages;
+  public get context() {
+    return this._binder;
   }
 
-  async getHistory(): Promise<Message[]> {
-    const queueItems = await this._queue.queryObjects();
-    return queueItems.filter(Obj.instanceOf(Message));
+  public get toolkit() {
+    return this._toolkit;
+  }
+
+  public async getHistory(): Promise<Message.Message[]> {
+    const queueItems = await this._queue.queryObjects(); // TODO(burdon): Update.
+    return queueItems.filter(Obj.instanceOf(Message.Message));
+  }
+
+  /**
+   * 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();
+
+      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,
+        }),
+      );
+
+      log('result', {
+        messages: messages.length,
+        duration: session.duration,
+        toolCalls: session.toolCalls,
+      });
+
+      // Append to queue.
+      yield* Effect.promise(() => self._queue.append(messages));
+      return messages;
+    });
   }
 }

package/src/conversation/index.ts

@@ -2,4 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './context';
 export * from './conversation';

package/src/diff.test.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from 'vitest';
+
+import { createDocAccessor } from '@dxos/echo-db';
+import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { Text } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+import { applyDiffs } from './diff';
+
+describe('diff', () => {
+  it('should apply diffs', async () => {
+    const builder = new EchoTestBuilder();
+    const { db, graph } = await builder.createDatabase();
+    await graph.schemaRegistry.register([Text.Text]);
+
+    const document = trim`
+      # Hello World
+      There'z a typo in this sentence.
+      And another oon here.
+      But not this one.
+    `;
+
+    const text = db.add(Text.make(document));
+    const accessor = createDocAccessor(text, ['content']);
+    const result = applyDiffs(accessor, [
+      `- There'z a typo in this sentence.`,
+      `+ There is a typo in this sentence.`,
+      `- And another oon here.`,
+      `+ And another one here.`,
+    ]);
+
+    expect(result).toBe(trim`
+      # Hello World
+      There is a typo in this sentence.
+      And another one here.
+      But not this one.
+    `);
+  });
+});

package/src/diff.ts

@@ -0,0 +1,84 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { next as A, type Doc } from '@automerge/automerge';
+
+import { DocAccessor, toCursorRange } from '@dxos/echo-db';
+import { log } from '@dxos/log';
+import { isNonNullable } from '@dxos/util';
+
+// Relevant info:
+// https://github.com/Minahil-official/GPT-4.1-Promting-Guide?tab=readme-ov-file#-apply-patch-tool-format-v4a-diff
+
+// TODO(burdon): Anthropic only.
+//  https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/text-editor-tool#example-str-replace-command
+//  AI_TOOL_NOT_FOUND: str_replace_based_edit_tool
+// 'str_replace_based_edit_tool',
+
+// TOOD(burdon): Support append to end (no "-").
+
+export type Diff = {
+  match: string;
+  replace: string;
+};
+
+/**
+ * Convert a list of diffs into a list of operations.
+ */
+export const reduceDiffs = (diffs: readonly string[]): Diff[] => {
+  return diffs.reduce<Diff[]>((acc, diff) => {
+    const current = acc[acc.length - 1];
+    const [op, ...rest] = diff.split(' ');
+    switch (op) {
+      case '-': {
+        if (current && !current.match) {
+          current.match += rest.join(' ');
+        } else {
+          acc.push({ match: rest.join(' '), replace: '' });
+        }
+        return acc;
+      }
+      case '+': {
+        if (current && !current.replace) {
+          current.replace += rest.join(' ');
+        } else {
+          acc.push({ match: '', replace: rest.join(' ') });
+        }
+        return acc;
+      }
+    }
+
+    return acc;
+  }, []);
+};
+
+export const computeDiffsWithCursors = <T>(accessor: DocAccessor<T>, diffs: readonly string[]) => {
+  return reduceDiffs(diffs)
+    .map((diff) => {
+      const text = DocAccessor.getValue<string>(accessor);
+      const idx = text.indexOf(diff.match);
+      if (idx !== -1) {
+        return { cursor: toCursorRange(accessor, idx, idx + diff.match.length), text: diff.replace };
+      }
+    })
+    .filter(isNonNullable);
+};
+
+export const applyDiffs = <T>(accessor: DocAccessor<T>, diffs: readonly string[]): string => {
+  for (const diff of reduceDiffs(diffs)) {
+    accessor.handle.change((doc: Doc<T>) => {
+      const text = DocAccessor.getValue<string>(accessor);
+      const idx = text.indexOf(diff.match);
+      if (idx !== -1) {
+        // TODO(burdon): Replace smallest substring.
+        // 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);
+      }
+    });
+  }
+
+  return DocAccessor.getValue<string>(accessor);
+};

package/src/errors.ts

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