@dxos/plugin-assistant 0.8.4-main.c1de068 → 0.8.4-main.fd6878d

package/src/hooks/chat-processor.ts

@@ -2,23 +2,30 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Signal, batch, computed, signal } from '@preact/signals-core';
-import { Effect, type Layer } from 'effect';
+import { Registry, Result, Rx } from '@effect-rx/rx-react';
+import { Effect, type Layer, Option, Stream, pipe } from 'effect';
 
-import { AiService, DEFAULT_EDGE_MODEL, type ExecutableTool, type GenerateRequest } from '@dxos/ai';
+import { AiService, DEFAULT_EDGE_MODEL, type ModelName, type ModelRegistry } from '@dxos/ai';
 import { type PromiseIntentDispatcher } from '@dxos/app-framework';
-import { type AiSession, ArtifactDiffResolver, type ContextBinder, type Conversation } from '@dxos/assistant';
-import { type ArtifactDefinition, type Blueprint } from '@dxos/blueprints';
+import {
+  type AiConversation,
+  type AiConversationRunParams,
+  AiSession,
+  ArtifactDiffResolver,
+  createSystemPrompt,
+} from '@dxos/assistant';
+import { type Blueprint } from '@dxos/blueprints';
 import { Context } from '@dxos/context';
 import { Obj } from '@dxos/echo';
 import { runAndForwardErrors } from '@dxos/effect';
 import { log } from '@dxos/log';
 import { Filter, type Space, getVersion } from '@dxos/react-client/echo';
-import { DataType } from '@dxos/schema';
+import { type ContentBlock, DataType } from '@dxos/schema';
 
-import type { ChatServices } from './useChatServices';
+import { AiServiceOverloadedError } from './errors';
+import { type AiChatServices } from './useChatServices';
 
-// TODO(burdon): Factor out.
+// TODO(burdon): Is this still used?
 declare global {
   interface ToolContextExtensions {
     space?: Space;
@@ -26,24 +33,20 @@ declare global {
   }
 }
 
-type RequestOptions = {
+export type AiRequestOptions = {
   // Empty for now.
 };
 
-export type ChatProcessorOptions = {
-  // TODO(burdon): Change to AiToolkit.
-  tools?: readonly ExecutableTool[];
+export type AiChatProcessorOptions = {
+  model?: ModelName;
+  modelRegistry?: ModelRegistry;
   blueprintRegistry?: Blueprint.Registry;
-
-  // TODO(dmaretskyi): Remove.
-  artifacts?: readonly ArtifactDefinition[];
+  observableRegistry?: Registry.Registry;
   extensions?: ToolContextExtensions;
-  // TODO(burdon): Remove systemPrompt -- should come from blueprint.
-} & Pick<GenerateRequest, 'model' | 'systemPrompt'>;
+} & Pick<AiConversationRunParams<any>, 'system'>;
 
-const defaultOptions: Partial<ChatProcessorOptions> = {
+const defaultOptions: Partial<AiChatProcessorOptions> = {
   model: DEFAULT_EDGE_MODEL,
-  systemPrompt: 'you are a helpful assistant',
 };
 
 /**
@@ -52,189 +55,148 @@ const defaultOptions: Partial<ChatProcessorOptions> = {
  * Executes tools based on AI responses.
  * Supports cancellation of in-progress requests.
  */
-// TODO(burdon): Rename ChatContext?
-export class ChatProcessor {
+export class AiChatProcessor {
   /**
-   * Pending messages (incl. the current user request).
-   * @reactive
+   * Last error.
    */
-  private readonly _pending: Signal<DataType.Message[]> = signal([]);
+  // TODO(wittjosiah): Error should come from the message stream.
+  readonly error = Rx.make<Option.Option<Error>>(Option.none());
+
+  /** Rx registry. */
+  private readonly _observableRegistry: Registry.Registry;
+
+  /** Current session. */
+  private readonly _session = Rx.make<Option.Option<AiSession>>(Option.none());
 
   /**
    * Current streaming message (from the AI service).
-   * @reactive
    */
-  private readonly _streaming: Signal<DataType.Message | undefined> = signal(undefined);
+  private readonly _streaming: Rx.Rx<Result.Result<Option.Option<DataType.Message>, Error>> = Rx.make((get) => {
+    return pipe(
+      get(this._session),
+      Option.map((session) => Stream.fromQueue(session.blockQueue)),
+      Option.getOrElse(() => Stream.make()),
+      Stream.scan<Option.Option<DataType.Message>, Option.Option<ContentBlock.Any>>(Option.none(), (acc, blockOption) =>
+        Option.flatMap(blockOption, (block) =>
+          acc.pipe(
+            Option.match({
+              onNone: () => [block],
+              onSome: (message) => [...message.blocks.filter((b) => !b.pending), block],
+            }),
+            Option.some,
+            Option.map((blocks) =>
+              Obj.make(DataType.Message, {
+                created: new Date().toISOString(),
+                sender: { role: 'assistant' },
+                blocks,
+              }),
+            ),
+          ),
+        ),
+      ),
+    );
+  });
 
   /**
    * Streaming state.
-   * @reactive
    */
-  public readonly streaming: Signal<boolean> = computed(() => this._streaming.value !== undefined);
+  readonly streaming: Rx.Rx<boolean> = Rx.make((get) => {
+    return pipe(
+      get(this._streaming),
+      Result.map((streaming) => Option.isSome(streaming)),
+      Result.getOrElse(() => false),
+    );
+  });
 
   /**
-   * Last error.
-   * @reactive
+   * Pending messages (incl. the current user request).
    */
-  public readonly error: Signal<Error | undefined> = signal(undefined);
+  private readonly _pending: Rx.Rx<Result.Result<DataType.Message[], Error>> = Rx.make((get) => {
+    // TODO(wittjosiah): For some reason using Option.map here loses reactivity.
+    const session = get(this._session);
+    return Option.isSome(session)
+      ? pipe(
+          session.value.messageQueue,
+          Stream.fromQueue,
+          Stream.scan<DataType.Message[], DataType.Message>([], (acc, message) => [...acc, message]),
+        )
+      : Stream.make();
+  });
 
   /**
    * Array of Messages (incl. the current message being streamed).
-   * @reactive
    */
-  public readonly messages: Signal<DataType.Message[]> = computed(() => {
-    const messages = [...this._pending.value];
-    if (this._streaming.value) {
-      // TODO(dmaretskyi): Replace with Obj.clone.
-      // NOTE: We have to clone the message here so that react will re-render.
-      messages.push(Obj.make(DataType.Message, this._streaming.value));
-    }
-
-    return messages;
+  readonly messages: Rx.Rx<Result.Result<DataType.Message[], Error>> = Rx.make((get) => {
+    const streaming = get(this._streaming);
+    return Result.map(get(this._pending), (pending) =>
+      Result.match(streaming, {
+        onInitial: () => pending,
+        onSuccess: (streaming) =>
+          Option.match(streaming.value, {
+            onNone: () => pending,
+            onSome: (message) => [...pending, message],
+          }),
+        onFailure: () => pending,
+      }),
+    );
   });
 
-  // TODO(burdon): Replace with Toolkit.
-  private _tools?: ExecutableTool[];
-
-  /** Current session. */
-  private _session: AiSession | undefined = undefined;
-
   constructor(
     // TODO(dmaretskyi): Replace this with effect's ManagedRuntime wrapping this layer.
-    private readonly _services: Layer.Layer<ChatServices>,
-    private readonly _conversation: Conversation,
-    private readonly _options: ChatProcessorOptions = defaultOptions,
+    private readonly _services: Layer.Layer<AiChatServices>,
+    private readonly _conversation: AiConversation,
+    private readonly _options: AiChatProcessorOptions = defaultOptions,
   ) {
-    this._tools = [...(_options.tools ?? [])];
+    // Initialize registries and defaults before using in other logic.
+    this._observableRegistry = this._options.observableRegistry ?? Registry.make();
+    if (this._options.model && !this._options.system) {
+      const capabilities = this._options.modelRegistry?.getCapabilities(this._options.model) ?? {};
+      this._options.system = createSystemPrompt(capabilities);
+    }
   }
 
-  get conversation() {
-    return this._conversation;
+  get context() {
+    return this._conversation.context;
   }
 
-  get context(): ContextBinder {
-    return this._conversation.context;
+  get conversation() {
+    return this._conversation;
   }
 
   get blueprintRegistry() {
     return this._options.blueprintRegistry;
   }
 
-  get tools() {
-    return this._tools;
-  }
-
-  /**
-   * @deprecated Replace with blueprints
-   */
-  setTools(tools: ExecutableTool[]): void {
-    this._tools = tools;
-  }
-
   /**
    * Make GPT request.
    */
-  async request(message: string, options: RequestOptions = {}): Promise<DataType.Message[]> {
+  async request(message: string, _options: AiRequestOptions = {}): Promise<void> {
     await using ctx = Context.default(); // Auto-disposed at the end of this block.
 
-    this._conversation.onBegin.on(ctx, (session) => {
-      log.info('onBegin', { session, isDisposed: ctx.disposed });
-
-      this._session = session;
-      ctx.onDispose(() => {
-        log.info('onDispose', { session, isDisposed: ctx.disposed });
-        if (this._session === session) {
-          this._session = undefined;
-        }
-      });
+    const session = new AiSession();
+    this._observableRegistry.set(this._session, Option.some(session));
 
-      // User message.
-      session.userMessage.on((message) => {
-        log.info('userMessage', { message });
-        this._pending.value = [...this._pending.value, message];
-      });
-
-      // Message complete.
-      session.message.on((message) => {
-        batch(() => {
-          this._pending.value = [...this._pending.value, message];
-          this._streaming.value = undefined;
-        });
-      });
-
-      // Streaming update (happens before message complete).
-      session.update.on((block) => {
-        batch(() => {
-          if (!this._streaming.value) {
-            // TODO(burdon): Hack to create temp message; better for session to send initial partial object?
-            this._streaming.value = Obj.make(DataType.Message, {
-              created: new Date().toISOString(),
-              sender: { role: 'assistant' },
-              blocks: [block],
-            });
-          } else if (this._streaming.value.blocks.at(-1)?.pending === true) {
-            this._streaming.value.blocks[this._streaming.value.blocks.length - 1] = block;
-          } else {
-            this._streaming.value.blocks.push(block);
+    ctx.onDispose(() => {
+      log.info('onDispose', { session, isDisposed: ctx.disposed });
+      Option.match(this._observableRegistry.get(this._session), {
+        onSome: (s) => {
+          if (s === session) {
+            this._observableRegistry.set(this._session, Option.none());
           }
-        });
+        },
+        onNone: () => {},
       });
-
-      session.block.on((block) => {
-        if (!this._streaming.value) {
-          // TODO(burdon): Hack to create temp message; better for session to send initial partial object?
-          this._streaming.value = Obj.make(DataType.Message, {
-            created: new Date().toISOString(),
-            sender: { role: 'assistant' },
-            blocks: [block],
-          });
-        } else if (this._streaming.value.blocks.at(-1)?.pending === true) {
-          this._streaming.value.blocks[this._streaming.value.blocks.length - 1] = block;
-        } else {
-          this._streaming.value.blocks.push(block);
-        }
-      });
-
-      // TODO(dmaretskyi): Handle tool status reports.
-      // session.toolStatusReport.on(({ message, status }) => {
-      //   const msg = this._pending.peek().find((m) => m.id === message.id);
-      //   const toolUse = msg?.content.find((block) => block.type === 'tool_use');
-      //   if (!toolUse) {
-      //     return;
-      //   }
-
-      //   const block = msg?.content.find(
-      //     (block): block is ToolUseContentBlock => block.type === 'tool_use' && block.id === toolUse.id,
-      //   );
-      //   if (block) {
-      //     this._pending.value = this._pending.value.map((m) => {
-      //       if (m.id === message.id) {
-      //         return {
-      //           ...m,
-      //           content: m.content.map((block) =>
-      //             block.type === 'tool_use' && block.id === toolUse.id ? { ...block, currentStatus: status } : block,
-      //           ),
-      //         };
-      //       }
-
-      //       return m;
-      //     });
-      //   } else {
-      //     log.warn('no block for status report');
-      //   }
-      // });
     });
 
     try {
       const messages = await runAndForwardErrors(
         this._conversation
           .run({
+            session,
             prompt: message,
-            // TODO(burdon): Construct from blueprints?
-            systemPrompt: this._options.systemPrompt,
+            system: this._options.system,
           })
           .pipe(
-            //
             Effect.provide(AiService.model(this._options.model ?? DEFAULT_EDGE_MODEL)),
             // TODO(dmaretskyi): Move ArtifactDiffResolver upstream.
             Effect.provideService(ArtifactDiffResolver, this._artifactDiffResolver),
@@ -250,35 +212,23 @@ export class ChatProcessor {
     } catch (err) {
       log.catch(err);
       if (err instanceof Error && err.message.includes('Overloaded')) {
-        this.error.value = new AiServiceOverloadedError('AI service overloaded', { cause: err });
+        this._observableRegistry.set(
+          this.error,
+          Option.some(new AiServiceOverloadedError('AI service overloaded', { cause: err })),
+        );
       } else {
-        this.error.value = new Error('AI service error', { cause: err });
+        this._observableRegistry.set(this.error, Option.some(new Error('AI service error', { cause: err })));
       }
     }
-
-    return this._reset();
   }
 
   /**
    * Cancel pending requests.
-   * @returns Pending requests (incl. the request message).
    */
-  async cancel(): Promise<DataType.Message[]> {
+  async cancel(): Promise<void> {
     log.info('cancelling...');
 
-    // TODO(dmaretskyi): Conversation should handle aborting.
-    this._session?.abort();
-    return this._reset();
-  }
-
-  private async _reset(): Promise<DataType.Message[]> {
-    const messages = this._pending.value;
-    batch(() => {
-      this._pending.value = [];
-      this._streaming.value = undefined;
-    });
-
-    return messages;
+    // TODO(dmaretskyi): Abort using Fiber.interrupt.
   }
 
   private _artifactDiffResolver: ArtifactDiffResolver.Service = {
@@ -297,6 +247,7 @@ export class ChatProcessor {
           if (!object) {
             return;
           }
+
           versions.set(artifact.id, {
             version: getVersion(object),
             diff: `Current state: ${JSON.stringify(object)}`,
@@ -307,8 +258,3 @@ export class ChatProcessor {
     },
   };
 }
-
-// TODO(wittjosiah): Move to ai-service-client.
-export class AiServiceOverloadedError extends Error {
-  code = 'AI_SERVICE_OVERLOADED';
-}

package/src/hooks/errors.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// TODO(wittjosiah): Move to ai-service-client.
+export class AiServiceOverloadedError extends Error {
+  code = 'AI_SERVICE_OVERLOADED';
+}

package/src/hooks/index.ts

@@ -3,9 +3,13 @@
 //
 
 export * from './chat-processor';
+export * from './errors';
 export * from './presets';
 
-export * from './useBlueprints';
+export * from './useBlueprintRegistry';
 export * from './useChatProcessor';
 export * from './useChatServices';
+export * from './useOnline';
+export * from './usePresets';
 export * from './useReferencesProvider';
+export * from './useResolveRef';

package/src/hooks/presets.ts

@@ -4,7 +4,7 @@
 
 import { Schema } from 'effect';
 
-import { type LLMModel } from '@dxos/ai';
+import { type ModelName } from '@dxos/ai';
 
 const ModelProviders = ['dxos-local', 'dxos-remote', 'lm-studio'] as const;
 
@@ -14,11 +14,11 @@ type ModelProvider = Schema.Schema.Type<typeof ModelProvider>;
 export type AiServicePreset = {
   id: string;
   provider: ModelProvider;
-  model: LLMModel;
+  model: ModelName;
   label?: string;
 };
 
-const createModelLabel = (model: LLMModel) => {
+const createModelLabel = (model: ModelName) => {
   const parts = model.split('/');
   return parts[parts.length - 1];
 };
@@ -27,11 +27,11 @@ const createModelLabel = (model: LLMModel) => {
 export const AiServicePresets: AiServicePreset[] = [
   {
     provider: 'dxos-remote' as const,
-    model: '@anthropic/claude-3-5-haiku-20241022' as const,
+    model: '@anthropic/claude-opus-4-0' as const,
   },
   {
     provider: 'dxos-remote' as const,
-    model: '@anthropic/claude-opus-4-0' as const,
+    model: '@anthropic/claude-3-5-haiku-20241022' as const,
   },
   {
     provider: 'lm-studio' as const,
@@ -41,6 +41,7 @@ export const AiServicePresets: AiServicePreset[] = [
     provider: 'lm-studio' as const,
     model: '@mlx-community/llama-3.2-3b-instruct' as const,
   },
+  { model: 'deepseek-r1:latest' as const, provider: 'dxos-local' as const },
 ].map(
   ({ model, provider }, i) =>
     ({

package/src/hooks/useBlueprintRegistry.ts

@@ -0,0 +1,79 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useSignalEffect } from '@preact/signals-react';
+import { useCallback, useMemo, useState } from 'react';
+
+import { Capabilities, useCapabilities } from '@dxos/app-framework';
+import { type AiContextBinder } from '@dxos/assistant';
+import { Blueprint } from '@dxos/blueprints';
+import { type Space } from '@dxos/client/echo';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { isNonNullable } from '@dxos/util';
+
+/**
+ * Provide a registry of blueprints from plugins.
+ */
+// TODO(burdon): Reconcile with eventual public registry.
+export const useBlueprintRegistry = () => {
+  const blueprints = useCapabilities(Capabilities.BlueprintDefinition);
+  return useMemo(() => new Blueprint.Registry(blueprints), [blueprints]);
+};
+
+/**
+ * Create reactive map of active blueprints (by key).
+ */
+export const useBlueprints = ({ context }: { context?: AiContextBinder }) => {
+  const [active, setActive] = useState<Map<string, Blueprint.Blueprint>>(new Map());
+  useSignalEffect(() => {
+    const refs = [...(context?.blueprints.value ?? [])];
+    const t = setTimeout(async () => {
+      const blueprints = (await Ref.Array.loadAll(refs)).filter(isNonNullable);
+      setActive(new Map(blueprints.map((blueprint) => [blueprint.key, blueprint])));
+    });
+
+    return () => clearTimeout(t);
+  });
+
+  return active;
+};
+
+// TODO(burdon): Context should manage ephemeral state of bindings until prompt is issued?
+export const useBlueprintHandlers = ({
+  space,
+  context,
+  blueprintRegistry,
+}: {
+  space: Space;
+  context?: AiContextBinder;
+  blueprintRegistry?: Blueprint.Registry;
+}) => {
+  const onUpdateBlueprint = useCallback(
+    async (key: string, checked: boolean) => {
+      if (!context || !blueprintRegistry) {
+        return;
+      }
+
+      // Find existing cloned blueprint.
+      const { objects } = await space.db.query(Filter.type(Blueprint.Blueprint)).run();
+      let storedBlueprint = objects.find((blueprint) => blueprint.key === key);
+      if (checked) {
+        if (!storedBlueprint) {
+          const blueprint = blueprintRegistry.getByKey(key);
+          if (!blueprint) {
+            return;
+          }
+          // NOTE: Possible race condition with other peers.
+          storedBlueprint = space.db.add(Obj.clone(blueprint));
+        }
+        await context.bind({ blueprints: [Ref.make(storedBlueprint)] });
+      } else if (storedBlueprint) {
+        await context.unbind({ blueprints: [Ref.make(storedBlueprint)] });
+      }
+    },
+    [space, context, blueprintRegistry],
+  );
+
+  return { onUpdateBlueprint };
+};