@dxos/plugin-assistant 0.8.3-staging.0fa589b → 0.8.4-main.f9ba587

package/src/hooks/{processor.ts → chat-processor.ts}

@@ -7,7 +7,6 @@ import { type Signal, batch, computed, signal } from '@preact/signals-core';
 import {
   DEFAULT_EDGE_MODEL,
   type ExecutableTool,
-  type AiServiceClient,
   type GenerateRequest,
   type Message,
   type MessageContentBlock,
@@ -15,10 +14,16 @@ import {
 } from '@dxos/ai';
 import { type PromiseIntentDispatcher } from '@dxos/app-framework';
 import { type ArtifactDefinition } from '@dxos/artifact';
-import { AISession, type ArtifactDiffResolver } from '@dxos/assistant';
-import { invariant } from '@dxos/invariant';
+import {
+  type AISession,
+  type ArtifactDiffResolver,
+  type BlueprintRegistry,
+  type ContextBinder,
+  type Conversation,
+} from '@dxos/assistant';
+import { Context } from '@dxos/context';
 import { log } from '@dxos/log';
-import { Filter, getVersion, type Space } from '@dxos/react-client/echo';
+import { Filter, type Space, getVersion } from '@dxos/react-client/echo';
 
 // TODO(burdon): Factor out.
 declare global {
@@ -29,11 +34,16 @@ declare global {
 }
 
 type RequestOptions = {
-  history?: Message[];
-  onComplete?: (messages: Message[]) => void;
+  // Empty for now.
 };
 
-export type ChatProcessorOptions = Pick<GenerateRequest, 'model' | 'systemPrompt'>;
+export type ChatProcessorOptions = {
+  // TODO(burdon): Change to AiToolkit.
+  tools?: readonly ExecutableTool[];
+  artifacts?: readonly ArtifactDefinition[];
+  extensions?: ToolContextExtensions;
+  blueprintRegistry?: BlueprintRegistry;
+} & Pick<GenerateRequest, 'model' | 'systemPrompt'>;
 
 const defaultOptions: ChatProcessorOptions = {
   model: DEFAULT_EDGE_MODEL,
@@ -46,16 +56,20 @@ const defaultOptions: ChatProcessorOptions = {
  * Executes tools based on AI responses.
  * Supports cancellation of in-progress requests.
  */
+// TODO(burdon): Rename ChatContext?
 export class ChatProcessor {
-  /** Pending messages (incl. the current user request). */
+  /**
+   * Pending messages (incl. the current user request).
+   * @reactive
+   */
   private readonly _pending: Signal<Message[]> = signal([]);
 
-  /** Current streaming block (from the AI service). */
+  /**
+   * Current streaming block (from the AI service).
+   * @reactive
+   */
   private readonly _block: Signal<MessageContentBlock | undefined> = signal(undefined);
 
-  /** Current streaming response. */
-  private _session: AISession | undefined;
-
   /**
    * Streaming state.
    * @reactive
@@ -74,10 +88,8 @@ export class ChatProcessor {
    */
   public readonly messages: Signal<Message[]> = computed(() => {
     const messages = [...this._pending.value];
-    if (this._block.value) {
-      const current = messages.pop();
-      invariant(current);
-      const { content, ...rest } = current;
+    if (this._block.value && messages.length) {
+      const { content, ...rest } = messages.pop()!;
       const message = { ...rest, content: [...content, this._block.value] };
       messages.push(message);
     }
@@ -85,20 +97,37 @@ export class ChatProcessor {
     return messages;
   });
 
+  // TODO(burdon): Replace with Toolkit.
+  private _tools?: ExecutableTool[];
+
+  /** Current session. */
+  private _session: AISession | undefined = undefined;
+
   constructor(
-    private readonly _ai: AiServiceClient,
-    private _tools?: ExecutableTool[],
-    private _artifacts?: ArtifactDefinition[],
-    private readonly _extensions?: ToolContextExtensions,
+    private readonly _conversation: Conversation,
     private readonly _options: ChatProcessorOptions = defaultOptions,
-  ) {}
+  ) {
+    this._tools = [...(_options.tools ?? [])];
+  }
+
+  get conversation() {
+    return this._conversation;
+  }
+
+  get context(): ContextBinder {
+    return this._conversation.context;
+  }
+
+  get blueprintRegistry() {
+    return this._options.blueprintRegistry;
+  }
 
   get tools() {
     return this._tools;
   }
 
   /**
-   * Update tools.
+   * @deprecated Replace with blueprints
    */
   setTools(tools: ExecutableTool[]): void {
     this._tools = tools;
@@ -108,64 +137,78 @@ export class ChatProcessor {
    * Make GPT request.
    */
   async request(message: string, options: RequestOptions = {}): Promise<Message[]> {
-    this._session = new AISession({ operationModel: 'configured' });
+    await using ctx = Context.default(); // Auto-disposed at the end of this block.
 
-    // Message complete.
-    this._session.message.on((message) => {
-      batch(() => {
-        this._pending.value = [...this._pending.value, message];
-        this._block.value = undefined;
+    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;
+        }
       });
-    });
 
-    // Streaming update (happens before message complete).
-    this._session.update.on((block) => {
-      batch(() => {
-        this._block.value = block;
+      // Message complete.
+      session.message.on((message) => {
+        batch(() => {
+          this._pending.value = [...this._pending.value, message];
+          this._block.value = undefined;
+        });
       });
-    });
 
-    this._session.userMessage.on((message) => {
-      this._pending.value = [...this._pending.value, message];
-    });
+      // Streaming update (happens before message complete).
+      session.update.on((block) => {
+        batch(() => {
+          this._block.value = block;
+        });
+      });
 
-    this._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;
-      }
+      session.userMessage.on((message) => {
+        log.info('userMessage', { message });
+        this._pending.value = [...this._pending.value, message];
+      });
 
-      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((b) =>
-                b.type === 'tool_use' && b.id === toolUse.id ? { ...b, currentStatus: status } : b,
-              ),
-            };
-          }
-          return m;
-        });
-      } else {
-        log.warn('no block for status report');
-      }
+      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 this._session.run({
-        client: this._ai,
-        history: options.history ?? [],
-        artifacts: this._artifacts ?? [],
-        requiredArtifactIds: this._artifacts?.map((artifact) => artifact.id) ?? [],
+      const messages = await this._conversation.run({
+        artifacts: [...(this._options.artifacts ?? [])],
+        requiredArtifactIds: this._options.artifacts?.map((artifact) => artifact.id) ?? [],
+
+        // TODO(dmaretskyi): Migrate to Effect's AiToolkit.
         tools: this._tools ?? [],
-        prompt: message,
         systemPrompt: this._options.systemPrompt,
-        extensions: this._extensions,
+        prompt: message,
+        extensions: this._options.extensions,
         artifactDiffResolver: this._artifactDiffResolver,
         generationOptions: {
           model: this._options.model,
@@ -173,7 +216,6 @@ export class ChatProcessor {
       });
 
       log('completed', { messages });
-      options.onComplete?.(this._pending.value);
     } catch (err) {
       log.catch(err);
       if (err instanceof Error && err.message.includes('Overloaded')) {
@@ -181,8 +223,6 @@ export class ChatProcessor {
       } else {
         this.error.value = new Error('AI service error', { cause: err });
       }
-    } finally {
-      this._session = undefined;
     }
 
     return this._reset();
@@ -194,6 +234,8 @@ export class ChatProcessor {
    */
   async cancel(): Promise<Message[]> {
     log.info('cancelling...');
+
+    // TODO(dmaretskyi): Conversation should handle aborting.
     this._session?.abort();
     return this._reset();
   }
@@ -209,10 +251,11 @@ export class ChatProcessor {
   }
 
   private _artifactDiffResolver: ArtifactDiffResolver = async (artifacts) => {
-    const space = this._extensions?.space;
+    const space = this._options.extensions?.space;
     if (!space) {
       return new Map();
     }
+
     const versions = new Map();
     await Promise.all(
       artifacts.map(async (artifact) => {

package/src/hooks/index.ts

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './processor';
+export * from './chat-processor';
 
+export * from './useBlueprints';
 export * from './useChatProcessor';
-export * from './useMessageQueue';
-export * from './useServices';
-export * from './useTextInputEvents';
 export * from './useContextProvider';
+export * from './useServiceContainer';
+export * from './useTextInputEvents';

package/src/hooks/useBlueprints.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCallback, useState } from 'react';
+
+import { type Blueprint, type ContextBinder } from '@dxos/assistant';
+import { Ref } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { useTimeout } from '@dxos/react-ui';
+import { isNonNullable } from '@dxos/util';
+
+export type UpdateCallback = (key: string, active: boolean) => void;
+
+export const useBlueprints = (context: ContextBinder): [Blueprint[], UpdateCallback] => {
+  const [blueprints, setBlueprints] = useState<Blueprint[]>([]);
+  useTimeout(
+    async () => {
+      const blueprints = (await Ref.Array.loadAll(context.blueprints.value ?? [])).filter(isNonNullable);
+      setBlueprints(blueprints);
+    },
+    0,
+    [context],
+  );
+
+  const handleUpdate = useCallback<UpdateCallback>((key: string, active: boolean) => {
+    log.info('update', { key, active });
+  }, []);
+
+  return [blueprints, handleUpdate] as const;
+};

package/src/hooks/useChatProcessor.tsx

@@ -5,42 +5,58 @@
 import { useEffect, useMemo, useState } from 'react';
 
 import { DEFAULT_EDGE_MODEL, DEFAULT_OLLAMA_MODEL, type ExecutableTool } from '@dxos/ai';
-import { Capabilities, useCapabilities, useCapability, useIntentDispatcher } from '@dxos/app-framework';
-import { type AssociatedArtifact, createSystemPrompt } from '@dxos/artifact';
-import { FunctionType } from '@dxos/functions';
+import { Capabilities, useCapabilities, useIntentDispatcher } from '@dxos/app-framework';
+import { type ArtifactDefinition, type AssociatedArtifact, createSystemPrompt } from '@dxos/artifact';
+import { type BlueprintRegistry, Conversation } from '@dxos/assistant';
+import { FunctionType, type ServiceContainer } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { useConfig } from '@dxos/react-client';
-import { Filter, fullyQualifiedId, type Space, useQuery } from '@dxos/react-client/echo';
+import { Filter, fullyQualifiedId, type Queue, type Space, useQuery } from '@dxos/react-client/echo';
 import { isNonNullable } from '@dxos/util';
 
-import { AssistantCapabilities } from '../capabilities';
 import { ChatProcessor, type ChatProcessorOptions } from '../hooks';
 import { convertFunctionToTool, createToolsFromService } from '../tools';
-import { type AIChatType, type AssistantSettingsProps, ServiceType } from '../types';
+import { type Assistant, ServiceType } from '../types';
 
 type UseChatProcessorProps = {
-  chat?: AIChatType;
-  space?: Space;
-  settings?: AssistantSettingsProps;
+  /** @deprecated Why is this required? */
   part?: 'deck' | 'dialog';
-  associatedArtifact?: AssociatedArtifact;
+  space?: Space;
+  chat?: Assistant.Chat;
+  // TODO(burdon): Reconcile all of below (overlapping concepts). Figure out how to inject vie effect layers.
+  serviceContainer: ServiceContainer;
+  blueprintRegistry?: BlueprintRegistry;
+  settings?: Assistant.Settings;
+  /** @deprecated */
+  instructions?: string;
+  /** @deprecated */
+  artifact?: AssociatedArtifact;
+  /** @deprecated */
+  noPluginArtifacts?: boolean;
 };
 
 /**
  * Configure and create ChatProcessor.
  */
 export const useChatProcessor = ({
-  chat,
+  part = 'deck',
   space,
+  chat,
+  serviceContainer,
+  blueprintRegistry,
   settings,
-  // part = 'deck',
-  part,
-  associatedArtifact,
-}: UseChatProcessorProps): ChatProcessor => {
-  const aiClient = useCapability(AssistantCapabilities.AiClient);
-  const globalTools = useCapabilities(Capabilities.Tools);
-  const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
+  instructions,
+  artifact,
+  noPluginArtifacts,
+}: UseChatProcessorProps): ChatProcessor | undefined => {
   const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const globalTools = useCapabilities(Capabilities.Tools);
+
+  // TODO(burdon): Spec artifacts.
+  let artifacts: readonly ArtifactDefinition[] = useCapabilities(Capabilities.ArtifactDefinition);
+  if (noPluginArtifacts) {
+    artifacts = Stable.array;
+  }
 
   // Services.
   const services = useQuery(space, Filter.type(ServiceType));
@@ -66,7 +82,7 @@ export const useChatProcessor = ({
         .map((fn) => convertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? '', space?.id))
         .filter(isNonNullable),
     ];
-    const extensions = { space, dispatch, pivotId: chatId, part };
+    const extensions = { part, space, dispatch, pivotId: chatId };
     return [tools, extensions];
   }, [dispatch, globalTools, space, chatId, serviceTools, functions]);
 
@@ -74,10 +90,11 @@ export const useChatProcessor = ({
   const systemPrompt = useMemo(
     () =>
       createSystemPrompt({
-        artifacts: artifactDefinitions.map((definition) => `${definition.name}\n${definition.instructions}`),
-        associatedArtifact,
+        artifacts: artifacts.map((definition) => `${definition.name}\n${definition.instructions}`),
+        artifact,
+        instructions,
       }),
-    [artifactDefinitions, associatedArtifact],
+    [artifacts, artifact, instructions],
   );
 
   // TODO(burdon): Remove default (let backend decide if not specified).
@@ -86,12 +103,40 @@ export const useChatProcessor = ({
       ? ((settings?.ollamaModel ?? DEFAULT_OLLAMA_MODEL) as ChatProcessorOptions['model'])
       : ((settings?.edgeModel ?? DEFAULT_EDGE_MODEL) as ChatProcessorOptions['model']);
 
+  const conversation = useMemo(() => {
+    if (!chat?.queue.target) {
+      return;
+    }
+
+    return new Conversation({
+      serviceContainer,
+      queue: chat.queue.target as Queue<any>,
+    });
+  }, [chat?.queue.target, serviceContainer]);
+
   // Create processor.
   // TODO(burdon): Updated on each query update above; should just update current processor.
   const processor = useMemo(() => {
+    if (!conversation) {
+      return undefined;
+    }
+
     log('creating processor...', { settings });
-    return new ChatProcessor(aiClient.value, tools, artifactDefinitions, extensions, { model, systemPrompt });
-  }, [aiClient.value, tools, artifactDefinitions, extensions, model, systemPrompt]);
+    return new ChatProcessor(conversation, {
+      tools,
+      extensions,
+      blueprintRegistry,
+      artifacts,
+      systemPrompt,
+      model,
+    });
+  }, [conversation, tools, blueprintRegistry, artifacts, extensions, systemPrompt, model]);
 
   return processor;
 };
+
+// TODO(dmaretskyi): Extract.
+export const Stable = Object.freeze({
+  array: [] as readonly never[],
+  object: {} as {},
+});

package/src/hooks/useContextProvider.ts

@@ -8,13 +8,17 @@ import { Capabilities, useCapabilities } from '@dxos/app-framework';
 import { type Space } from '@dxos/client/echo';
 import { Filter, Obj, type Type } from '@dxos/echo';
 
+/**
+ * @deprecated
+ */
 export type ContextProvider = {
   query: (params: { query: string }) => Promise<Array<{ uri: string; label: string }>>;
   resolveMetadata: (params: { uri: string }) => Promise<{ uri: string; label: string }>;
 };
 
-const stringMatch = (query: string, label: string) => label.toLowerCase().startsWith(query.toLowerCase());
-
+/**
+ * @deprecated
+ */
 export const useContextProvider = (space?: Space): ContextProvider | undefined => {
   const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
 
@@ -53,3 +57,5 @@ export const useContextProvider = (space?: Space): ContextProvider | undefined =
     };
   }, [space, artifactDefinitions]);
 };
+
+const stringMatch = (query: string, label: string) => label.toLowerCase().startsWith(query.toLowerCase());

package/src/hooks/useServiceContainer.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect, useMemo, useState } from 'react';
+
+import { ToolRegistry } from '@dxos/ai';
+import { Capabilities, useCapabilities, useCapability } from '@dxos/app-framework';
+import { AiService, DatabaseService, QueueService, ServiceContainer, ToolResolverService } from '@dxos/functions';
+import { type Space } from '@dxos/react-client/echo';
+
+import { AssistantCapabilities } from '../capabilities';
+
+interface UseServiceContainerProps {
+  space?: Space;
+}
+
+export const useServiceContainer = ({ space }: UseServiceContainerProps) => {
+  const aiClient = useCapability(AssistantCapabilities.AiClient);
+  const tools = useCapabilities(Capabilities.Tools).flat();
+
+  const [toolRegistry] = useState(() => new ToolRegistry([]));
+  useEffect(() => {
+    for (const tool of tools) {
+      if (!toolRegistry.has(tool)) {
+        toolRegistry.register(tool);
+      }
+    }
+  }, [toolRegistry, JSON.stringify(tools.map((tool) => tool.id))]);
+
+  return useMemo(
+    () =>
+      new ServiceContainer().setServices({
+        ai: AiService.make(aiClient.value),
+        database: space ? DatabaseService.make(space.db) : undefined,
+        queues: space ? QueueService.make(space.queues, undefined) : undefined,
+        // eventLogger: consoleLogger,
+        toolResolver: ToolResolverService.make(toolRegistry),
+      }),
+    [space, aiClient],
+  );
+};

package/src/queue-logger.ts

@@ -2,8 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Blueprint, type BlueprintEvent, type BlueprintLogger } from '@dxos/assistant';
 import { getSpace, Ref, type Queue, type Space } from '@dxos/client/echo';
+import { type Sequence, type SequenceEvent, type SequenceLogger } from '@dxos/conductor';
 import { DXN, Key, Obj } from '@dxos/echo';
 import {
   InvocationOutcome,
@@ -16,12 +16,12 @@ import {
 import { invariant } from '@dxos/invariant';
 import { QueueSubspaceTags } from '@dxos/keys';
 
-export class QueueLogger implements BlueprintLogger {
+export class QueueLogger implements SequenceLogger {
   private _space: Space;
   private _invocationTraceQueue: Queue<InvocationTraceEvent>;
 
-  constructor(private readonly blueprint: Blueprint) {
-    const space = getSpace(blueprint);
+  constructor(private readonly sequence: Sequence) {
+    const space = getSpace(sequence);
     invariant(space, 'Space not found');
     this._space = space;
     let dxn = this._space.properties.invocationTraceQueue?.dxn;
@@ -32,7 +32,7 @@ export class QueueLogger implements BlueprintLogger {
     this._invocationTraceQueue = this._space.queues.get(dxn);
   }
 
-  log(event: BlueprintEvent) {
+  log(event: SequenceEvent) {
     switch (event.type) {
       case 'begin':
         void this._invocationTraceQueue.append([
@@ -42,7 +42,7 @@ export class QueueLogger implements BlueprintLogger {
             timestampMs: Date.now(),
             input: {},
             invocationTraceQueue: Ref.fromDXN(this._getTraceQueueDxn(event.invocationId)),
-            invocationTarget: Ref.make(this.blueprint),
+            invocationTarget: Ref.make(this.sequence),
           }),
         ]);
         break;