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

package/src/hooks/useChatServices.ts

@@ -0,0 +1,91 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Layer } from 'effect';
+import { useMemo } from 'react';
+import { useDeepCompareMemoize } from 'use-deep-compare-effect';
+
+import { type AiService, type ToolExecutionService, ToolRegistry, type ToolResolverService } from '@dxos/ai';
+import { AiServiceTestingPreset } from '@dxos/ai/testing';
+import { Capabilities, useCapabilities } from '@dxos/app-framework';
+import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
+import { type Space } from '@dxos/client/echo';
+import {
+  ConfiguredCredentialsService,
+  CredentialsService,
+  DatabaseService,
+  EventLogger,
+  FunctionCallService,
+  QueueService,
+  TracingService,
+} from '@dxos/functions';
+
+export * from '@dxos/assistant';
+
+// TODO(burdon): Deconstruct into separate layers?
+export type ChatServices =
+  | AiService
+  | CredentialsService
+  | DatabaseService
+  | QueueService
+  | FunctionCallService
+  | ToolResolverService
+  | ToolExecutionService
+  | TracingService
+  | EventLogger;
+
+export type UseChatServicesProps = {
+  space?: Space;
+};
+
+/**
+ * Construct service layer.
+ */
+export const useChatServices = ({ space }: UseChatServicesProps): Layer.Layer<ChatServices> | undefined => {
+  const toolRegistry = useToolRegistry();
+  // TODO(dmaretskyi): We can provide the plugin registry as a layer and then build the entire layer stack from there. We need to think how plugin reactivity affect our layer structure.
+  const toolResolver = useToolResolver();
+  const toolExecutionService = useToolExecutionService();
+
+  return useMemo(() => {
+    return Layer.mergeAll(
+      AiServiceTestingPreset('edge-remote').pipe(Layer.orDie), // TODO(burdon): Error management?
+      Layer.succeed(CredentialsService, new ConfiguredCredentialsService()),
+      space ? Layer.succeed(DatabaseService, DatabaseService.make(space.db)) : DatabaseService.notAvailable,
+      space ? Layer.succeed(QueueService, QueueService.make(space.queues)) : QueueService.notAvailable,
+      Layer.succeed(FunctionCallService, FunctionCallService.mock()),
+      Layer.succeed(TracingService, TracingService.noop),
+      Layer.succeed(EventLogger, EventLogger.noop),
+      toolResolver,
+      toolExecutionService,
+    );
+  }, [space, toolRegistry, toolResolver]);
+};
+
+const useToolResolver = (): Layer.Layer<ToolResolverService> => {
+  const functions = useCapabilities(Capabilities.Functions).flat();
+  return useMemo(() => makeToolResolverFromFunctions(functions), [useDeepCompareMemoize(functions.map((f) => f.name))]);
+};
+
+const useToolExecutionService = (): Layer.Layer<ToolExecutionService> => {
+  const functions = useCapabilities(Capabilities.Functions).flat();
+  return useMemo(
+    () => makeToolExecutionServiceFromFunctions(functions),
+    [useDeepCompareMemoize(functions.map((f) => f.name))],
+  );
+};
+
+// TODO(burdon): Factor out.
+const useToolRegistry = (): ToolRegistry => {
+  const tools = useCapabilities(Capabilities.Tools).flat();
+  return useMemo(() => {
+    const toolRegistry = new ToolRegistry([]);
+    for (const tool of tools) {
+      if (!toolRegistry.has(tool)) {
+        toolRegistry.register(tool);
+      }
+    }
+    return toolRegistry;
+  }, [useDeepCompareMemoize(tools)]);
+};

package/src/hooks/{useContextProvider.ts → useReferencesProvider.ts}

@@ -7,27 +7,25 @@ import { useMemo } from 'react';
 import { Capabilities, useCapabilities } from '@dxos/app-framework';
 import { type Space } from '@dxos/client/echo';
 import { Filter, Obj, type Type } from '@dxos/echo';
+import { type ReferencesProvider } from '@dxos/react-ui-chat';
 
-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());
-
-export const useContextProvider = (space?: Space): ContextProvider | undefined => {
+/**
+ * Resolve references to objects in the space.
+ */
+export const useReferencesProvider = (space?: Space): ReferencesProvider | undefined => {
+  // TODO(burdon): Pass in.
   const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
 
-  return useMemo<ContextProvider | undefined>((): ContextProvider | undefined => {
+  return useMemo<ReferencesProvider | undefined>((): ReferencesProvider | undefined => {
     if (!space) {
       return undefined;
     }
 
     return {
-      query: async ({ query }) => {
-        const artifactSchemas = artifactDefinitions.map((artifact) => artifact.schema);
+      getReferences: async ({ query }) => {
+        const schemas = artifactDefinitions.map((artifact) => artifact.schema);
         const { objects } = await space.db
-          .query(Filter.or(...artifactSchemas.map((schema) => Filter.type(schema as Type.Schema))))
+          .query(Filter.or(...schemas.map((schema) => Filter.type(schema as Type.Schema))))
           .run();
 
         return (
@@ -46,10 +44,12 @@ export const useContextProvider = (space?: Space): ContextProvider | undefined =
             }))
         );
       },
-      resolveMetadata: async ({ uri }) => {
+      resolveReference: async ({ uri }) => {
         const object = await space.db.query(Filter.ids(uri)).first();
         return { uri, label: Obj.getLabel(object) ?? '' };
       },
-    };
+    } satisfies ReferencesProvider;
   }, [space, artifactDefinitions]);
 };
+
+const stringMatch = (query: string, label: string) => label.toLowerCase().startsWith(query.toLowerCase());

package/src/parser/index.ts

@@ -4,4 +4,4 @@
 
 export * from './filter-generator';
 export * from './query-parser';
-export * from './types';
+export type * from './types';

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;

package/src/stories/Chat.stories.tsx

@@ -0,0 +1,378 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import '@dxos-theme';
+
+import { type StoryObj, type Meta } from '@storybook/react-vite';
+import React, { useCallback, useEffect, useMemo, useState, type FC } from 'react';
+
+import { Capabilities, contributes, Events, IntentPlugin, type Plugin, SettingsPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { ContextBinder } from '@dxos/assistant';
+import {
+  DESIGN_BLUEPRINT,
+  TASK_BLUEPRINT,
+  readDocument,
+  remoteServiceEndpoints,
+  writeDocument,
+} from '@dxos/assistant-testing';
+import { Blueprint } from '@dxos/blueprints';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+import { ChessPlugin } from '@dxos/plugin-chess';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { InboxPlugin } from '@dxos/plugin-inbox';
+import { MapPlugin } from '@dxos/plugin-map';
+import { MarkdownPlugin } from '@dxos/plugin-markdown';
+import { DocumentType } from '@dxos/plugin-markdown/types';
+import { SpacePlugin } from '@dxos/plugin-space';
+import { TablePlugin } from '@dxos/plugin-table';
+import { TranscriptionPlugin } from '@dxos/plugin-transcription';
+import { Config } from '@dxos/react-client';
+import { createDocAccessor, useQuery, useSpace } from '@dxos/react-client/echo';
+import { Toolbar, useThemeContext, useTranslation } from '@dxos/react-ui';
+import {
+  Editor,
+  createBasicExtensions,
+  createDataExtensions,
+  createMarkdownExtensions,
+  createThemeExtensions,
+  outliner,
+} from '@dxos/react-ui-editor';
+import { mx } from '@dxos/react-ui-theme';
+import { DataType } from '@dxos/schema';
+import { render, withLayout, withTheme } from '@dxos/storybook-utils';
+
+import { AssistantPlugin } from '../AssistantPlugin';
+import { Chat, TemplateEditor, type ChatPromptProps } from '../components';
+import { type AiServicePreset, AiServicePresets } from '../hooks';
+import { useChatProcessor, useChatServices } from '../hooks';
+import { meta as AssistantMeta } from '../meta';
+import { translations } from '../translations';
+import { Assistant } from '../types';
+
+//
+// Story container
+//
+
+const DefaultStory = ({ components }: { components: (FC | FC[])[] }) => {
+  return (
+    <div
+      className={mx('grid grid-cols gap-2 m-2')}
+      style={{ gridTemplateColumns: `repeat(${components.length}, minmax(0, 40rem))` }}
+    >
+      {components.map((Component, index) =>
+        Array.isArray(Component) ? (
+          <div
+            key={index}
+            className='grid grid-rows gap-2 overflow-hidden'
+            style={{ gridTemplateRows: `repeat(${Component.length}, 1fr)` }}
+          >
+            {Component.map((Component, index) => (
+              <div key={index} className='flex flex-col overflow-hidden bg-baseSurface border border-separator'>
+                <Component />
+              </div>
+            ))}
+          </div>
+        ) : (
+          <div key={index} className='flex flex-col overflow-hidden bg-baseSurface border border-separator'>
+            <Component />
+          </div>
+        ),
+      )}
+    </div>
+  );
+};
+
+//
+// Components
+//
+
+const ChatContainer = () => {
+  const { t } = useTranslation(AssistantMeta.id);
+  const space = useSpace();
+
+  const [chat, setChat] = useState<Assistant.Chat>();
+  useEffect(() => {
+    const results = space?.db.query(Filter.type(Assistant.Chat)).runSync();
+    if (results?.length) {
+      setChat(results[0].object);
+    }
+  }, [space]);
+
+  // TODO(burdon): Memo preset for provider.
+  const [online, setOnline] = useState(true);
+  const [preset, setPreset] = useState<AiServicePreset>();
+  const presets = useMemo(
+    () => AiServicePresets.filter((preset) => online === (preset.provider === 'dxos-remote')),
+    [online],
+  );
+  useEffect(() => {
+    setPreset(presets[0]);
+  }, [presets]);
+
+  const services = useChatServices({ space });
+  const blueprintRegistry = useMemo(() => new Blueprint.Registry([DESIGN_BLUEPRINT, TASK_BLUEPRINT]), []);
+  const processor = useChatProcessor({
+    preset,
+    chat,
+    space,
+    services,
+    blueprintRegistry,
+    noPluginArtifacts: true,
+  });
+
+  const handleChangePreset = useCallback<NonNullable<ChatPromptProps['onChangePreset']>>(
+    (id) => {
+      const preset = presets.find((preset) => preset.id === id);
+      if (preset) {
+        setPreset(preset);
+      }
+    },
+    [presets],
+  );
+
+  const handleNewChat = useCallback(() => {
+    invariant(space);
+    const chat = space.db.add(
+      Obj.make(Assistant.Chat, {
+        queue: Ref.fromDXN(space.queues.create().dxn),
+      }),
+    );
+    setChat(chat);
+  }, [space]);
+
+  const handleBranchChat = useCallback(() => {}, [space]);
+
+  if (!chat || !processor) {
+    return null;
+  }
+
+  return (
+    <Chat.Root chat={chat} processor={processor} onEvent={(event) => log.info('event', { event })}>
+      <Toolbar.Root classNames='border-b border-subduedSeparator'>
+        <Toolbar.IconButton icon='ph--plus--regular' iconOnly label={t('button new thread')} onClick={handleNewChat} />
+        <Toolbar.IconButton
+          disabled
+          icon='ph--git-branch--regular'
+          iconOnly
+          label={t('button branch thread')}
+          onClick={handleBranchChat}
+        />
+      </Toolbar.Root>
+      <Chat.Thread />
+      <div className='p-4'>
+        <Chat.Prompt
+          classNames='p-2 border border-subduedSeparator rounded focus-within:outline focus-within:border-transparent outline-primary-500'
+          expandable
+          online={online}
+          presets={presets.map(({ id, model, label }) => ({ id, label: label ?? model }))}
+          preset={preset?.id}
+          onChangeOnline={setOnline}
+          onChangePreset={handleChangePreset}
+        />
+      </div>
+    </Chat.Root>
+  );
+};
+
+const DocumentContainer = () => {
+  const { themeMode } = useThemeContext();
+  const space = useSpace();
+  const [document] = useQuery(space, Filter.type(DocumentType));
+  if (!document?.content.target) {
+    return null;
+  }
+
+  return (
+    <>
+      <Toolbar.Root classNames='border-b border-subduedSeparator'>
+        <h2>{Obj.getLabel(document)}</h2>
+      </Toolbar.Root>
+      <Editor
+        id={document.id}
+        text={document.content.target}
+        classNames='h-full p-2 overflow-hidden'
+        extensions={[
+          // TODO(burdon): Create util.
+          createDataExtensions({ id: document.id, text: createDocAccessor(document.content.target, ['content']) }),
+          createBasicExtensions({ readOnly: false }),
+          createMarkdownExtensions({ themeMode }),
+          createThemeExtensions({ themeMode }),
+          outliner(),
+        ]}
+      />
+    </>
+  );
+};
+
+// TODO(burdon): Show all active blueprints from context?
+const BlueprintContainer = () => {
+  const space = useSpace();
+  const [blueprint] = useQuery(space, Filter.type(Blueprint.Blueprint));
+  if (!blueprint?.instructions.target) {
+    return null;
+  }
+
+  return (
+    <div className='flex flex-col h-full'>
+      <Toolbar.Root classNames='border-b border-subduedSeparator'>
+        <h2>{Obj.getLabel(blueprint)}</h2>
+      </Toolbar.Root>
+      <TemplateEditor template={blueprint.instructions.target} />
+    </div>
+  );
+};
+
+//
+// Configuration
+//
+
+const meta = {
+  title: 'plugins/plugin-assistant/Chat',
+  render: render(DefaultStory),
+  decorators: [],
+  parameters: {
+    translations,
+    controls: { disable: true },
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+//
+// Decorators
+//
+
+const remoteConfig = new Config({
+  runtime: {
+    services: {
+      ai: {
+        // TODO(burdon): 'url'?
+        server: remoteServiceEndpoints.ai,
+      },
+      edge: {
+        url: remoteServiceEndpoints.edge,
+      },
+    },
+  },
+});
+
+const getDecorators = ({
+  config,
+  plugins = [],
+  blueprints = [],
+  context = false,
+}: {
+  config: Config;
+  plugins?: Plugin[];
+  blueprints?: Blueprint.Blueprint[];
+  context?: boolean;
+}) => [
+  withPluginManager({
+    fireEvents: [Events.SetupArtifactDefinition],
+    plugins: [
+      ClientPlugin({
+        config,
+        types: [Assistant.Chat, DocumentType, Blueprint.Blueprint],
+        onClientInitialized: async (_, client) => {
+          await client.halo.createIdentity();
+          await client.spaces.waitUntilReady();
+          const space = client.spaces.default;
+          // ISSUE(burdon): Should not require this.
+          //  ERROR: invariant violation: Database was not initialized with root object.
+          await space.waitUntilReady();
+
+          // TODO(burdon): Remove need for this boilerplate. Namespace for types?
+          const chat = space.db.add(
+            Obj.make(Assistant.Chat, {
+              queue: Ref.fromDXN(space.queues.create().dxn),
+            }),
+          );
+          const binder = new ContextBinder(await chat.queue.load());
+
+          const doc = space.db.add(
+            Obj.make(DocumentType, {
+              name: 'Tasks',
+              content: Ref.make(Obj.make(DataType.Text, { content: '' })),
+            }),
+          );
+          if (context) {
+            await binder.bind({ objects: [Ref.make(doc)] });
+          }
+
+          for (const blueprint of blueprints) {
+            // Clone blueprints and bind to conversation.
+            // TODO(dmaretskyi): This should be done by Obj.clone.
+            const { id: _id, ...data } = blueprint;
+            const obj = space.db.add(Obj.make(Blueprint.Blueprint, data));
+            await binder.bind({ blueprints: [Ref.make(obj)] });
+          }
+        },
+      }),
+      IntentPlugin(),
+      SettingsPlugin(),
+      SpacePlugin(),
+
+      TranscriptionPlugin(),
+      AssistantPlugin(),
+
+      ...plugins,
+    ],
+    capabilities: [contributes(Capabilities.Functions, [readDocument, writeDocument])],
+  }),
+  withTheme,
+  withLayout({
+    fullscreen: true,
+    classNames: 'bg-deckSurface justify-center',
+  }),
+];
+
+//
+// Stories
+//
+
+export const Default = {
+  decorators: getDecorators({
+    config: remoteConfig,
+  }),
+  args: {
+    components: [ChatContainer],
+  },
+} satisfies Story;
+
+export const WithDocument = {
+  decorators: getDecorators({
+    config: remoteConfig,
+    plugins: [MarkdownPlugin()],
+  }),
+  args: {
+    components: [ChatContainer, DocumentContainer],
+  },
+} satisfies Story;
+
+export const WithBlueprints = {
+  decorators: getDecorators({
+    config: remoteConfig,
+    plugins: [ChessPlugin(), InboxPlugin(), MapPlugin(), MarkdownPlugin(), TablePlugin()],
+    blueprints: [TASK_BLUEPRINT],
+    context: true,
+  }),
+  args: {
+    components: [ChatContainer, [DocumentContainer, BlueprintContainer]],
+  },
+} satisfies Story;
+
+// export const WithArtifacts = {
+//   decorators: getDecorators({
+//     config: remoteConfig,
+//     plugins: [ChessPlugin(), InboxPlugin(), MapPlugin(), MarkdownPlugin(), TablePlugin()],
+//   }),
+//   args: {
+//     components: [ChatContainer],
+//   },
+// } satisfies Story;

package/src/testing/index.ts

@@ -2,6 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './test-blueprint';
+export * from './test-sequence';
 export * from './test-functions';
 export * from './test-services';

package/src/testing/test-functions.ts

@@ -3,7 +3,7 @@
 //
 
 import { DEFAULT_EDGE_MODEL, type GenerateRequest } from '@dxos/ai';
-import { createSystemPrompt } from '@dxos/artifact';
+import { createSystemPrompt } from '@dxos/assistant';
 
 export const createProcessorOptions = (artifacts: string[]): Pick<GenerateRequest, 'model' | 'systemPrompt'> => ({
   model: DEFAULT_EDGE_MODEL,

package/src/testing/test-sequence.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ToolId, ToolRegistry } from '@dxos/ai';
+// import { createExaTool, createGraphWriterTool, createLocalSearchTool } from '@dxos/assistant';
+import { type Space } from '@dxos/client/echo';
+import { SequenceParser, type SequenceDefinition } from '@dxos/conductor';
+import { type DXN } from '@dxos/keys';
+import { isNonNullable } from '@dxos/util';
+
+// TODO(dmaretskyi): make db available through services (same as function executor).
+// TODO(burdon): Can tools implement "aspects" so that variants can be used rather than an explicit reference?
+export const createToolRegistry = (space: Space, queueDxn?: DXN): ToolRegistry => {
+  return new ToolRegistry(
+    [
+      // createExaTool({ apiKey: EXA_API_KEY }),
+      // createLocalSearchTool(space.db, queueDxn && space.queues.get(queueDxn)),
+      // queueDxn &&
+      //   createGraphWriterTool({
+      //     db: space.db,
+      //     queue: space.queues.get(queueDxn),
+      //     schema: DataTypes,
+      //     onDone: async (objects) => {
+      //       const queue = space.queues.get(queueDxn);
+      //       await queue.append(objects);
+      //     },
+      //   }),
+    ].filter(isNonNullable),
+  );
+};
+
+export const RESEARCH_SEQUENCE_DEFINITION: SequenceDefinition = {
+  steps: [
+    {
+      instructions: 'Research information and entities related to the selected objects.',
+      tools: [ToolId.make('search/web_search')],
+    },
+    {
+      instructions:
+        'Based on your research find matching entires that are already in the graph. Do exaustive research.',
+      tools: [ToolId.make('search/local_search')],
+    },
+    {
+      instructions: 'Add researched data to the graph. Make connections to existing objects.',
+      tools: [ToolId.make('search/local_search'), ToolId.make('graph/writer')],
+    },
+  ],
+};
+
+export const RESEARCH_SEQUENCE = SequenceParser.create().parse(RESEARCH_SEQUENCE_DEFINITION);