@dxos/plugin-assistant 0.8.4-main.28f8d3d → 0.8.4-main.406dc2a

package/src/components/Toolbox/Toolbox.stories.tsx

@@ -2,9 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import '@dxos-theme';
-
-import { type Meta } from '@storybook/react-vite';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React from 'react';
 
 import { IntentPlugin, SettingsPlugin } from '@dxos/app-framework';
@@ -15,7 +13,7 @@ import { ClientPlugin } from '@dxos/plugin-client';
 import { MapPlugin } from '@dxos/plugin-map';
 import { SpacePlugin } from '@dxos/plugin-space';
 import { TablePlugin } from '@dxos/plugin-table';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
+import { withTheme } from '@dxos/react-ui/testing';
 
 import { translations } from '../../translations';
 
@@ -25,11 +23,12 @@ const DefaultStory = (props: ToolboxProps) => {
   return <Toolbox {...props} classNames='w-[30rem] h-[15rem] rounded-sm border border-separator py-1' />;
 };
 
-const meta: Meta<typeof Toolbox> = {
+const meta = {
   title: 'plugins/plugin-assistant/Toolbox',
-  component: Toolbox,
+  component: Toolbox as any,
   render: DefaultStory,
   decorators: [
+    withTheme,
     withPluginManager({
       plugins: [
         ClientPlugin({
@@ -37,7 +36,7 @@ const meta: Meta<typeof Toolbox> = {
             await client.halo.createIdentity();
           },
         }),
-        SpacePlugin(),
+        SpacePlugin({}),
         SettingsPlugin(),
         IntentPlugin(),
         ChessPlugin(),
@@ -46,17 +45,15 @@ const meta: Meta<typeof Toolbox> = {
       ],
       capabilities,
     }),
-    withTheme,
-    withLayout(),
   ],
   parameters: {
     layout: 'centered',
     translations,
   },
-};
+} satisfies Meta<typeof DefaultStory>;
 
 export default meta;
 
-type Story = Meta<typeof Toolbox>;
+type Story = StoryObj<typeof meta>;
 
-export const Default = {} satisfies Story;
+export const Default: Story = {};

package/src/components/Toolbox/Toolbox.tsx

@@ -4,7 +4,6 @@
 
 import React, { type FC, Fragment, useEffect, useState } from 'react';
 
-import { type Tool } from '@dxos/ai';
 import { type Blueprint } from '@dxos/blueprints';
 import { type Ref } from '@dxos/echo';
 import { FunctionType } from '@dxos/functions';
@@ -14,13 +13,12 @@ import { type ThemedClassName } from '@dxos/react-ui';
 import { useTranslation } from '@dxos/react-ui';
 import { mx } from '@dxos/react-ui-theme';
 
-import { type AiChatProcessor } from '../../hooks';
 import { meta } from '../../meta';
-import { createToolsFromService } from '../../tools';
+import { type AiChatProcessor } from '../../processor';
 import { ServiceType } from '../../types';
 
 export type ToolboxProps = ThemedClassName<{
-  services?: { service: ServiceType; tools: Tool[] }[];
+  services?: { service: ServiceType }[];
   functions?: FunctionType[];
   // TODO(burdon): Combine into single array.
   blueprints?: readonly Ref.Ref<Blueprint.Blueprint>[];
@@ -57,10 +55,10 @@ export const Toolbox = ({ classNames, functions, services, blueprints, activeBlu
       {services && services.length > 0 && (
         <Section
           title='Services'
-          items={services.map(({ service: { serviceId, name, description }, tools }) => ({
+          items={services.map(({ service: { serviceId, name, description } }) => ({
             name: name ?? serviceId,
             description,
-            subitems: tools.map(({ name, description }) => ({ name: `∙ ${name}`, description })),
+            // subitems: tools.map(({ name, description }) => ({ name: `∙ ${name}`, description })),
           }))}
         />
       )}
@@ -68,10 +66,6 @@ export const Toolbox = ({ classNames, functions, services, blueprints, activeBlu
       {functions && functions.length > 0 && (
         <Section title='Functions' items={functions.map(({ name, description }) => ({ name, description }))} />
       )}
-
-      {!blueprints?.length && !activeBlueprints?.length && !services?.length && !functions?.length && (
-        <div>{t('no tools')}</div>
-      )}
     </div>
   );
 };
@@ -118,15 +112,15 @@ export type ToolboxContainerProps = ThemedClassName<{
 export const ToolboxContainer = ({ classNames, space, processor }: ToolboxContainerProps) => {
   // Registered services.
   const services = useQuery(space, Filter.type(ServiceType));
-  const [serviceTools, setServiceTools] = useState<{ service: ServiceType; tools: Tool[] }[]>([]);
+  const [serviceTools, setServiceTools] = useState<{ service: ServiceType }[]>([]);
   useEffect(() => {
     log('creating service tools...', { services: services.length });
     queueMicrotask(async () => {
-      const tools = await Promise.all(
-        services.map(async (service) => ({ service, tools: await createToolsFromService(service) })),
-      );
-
-      setServiceTools(tools);
+      // TODO(burdon): Fix.
+      // const tools = await Promise.all(
+      //   services.map(async (service) => ({ service, tools: await createToolsFromService(service) })),
+      // );
+      // setServiceTools(tools);
     });
   }, [services]);
 

package/src/components/index.ts

@@ -6,12 +6,14 @@ import { lazy } from 'react';
 
 export * from './AssistantSettings';
 export * from './Chat';
+export * from './ChatProgress';
 export * from './PromptSettings';
 export * from './TemplateEditor';
-export * from './Timeline';
+export * from './Toolbar';
 export * from './Toolbox';
 
 export const BlueprintContainer = lazy(() => import('./BlueprintContainer'));
+export const ChatCompanion = lazy(() => import('./ChatCompanion'));
 export const ChatContainer = lazy(() => import('./ChatContainer'));
 export const ChatDialog = lazy(() => import('./ChatDialog'));
 export const SequenceContainer = lazy(() => import('./SequenceContainer'));

package/src/functions/analysis.ts

@@ -2,19 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
 import { defineFunction } from '@dxos/functions';
 import { log } from '@dxos/log';
 
 export default defineFunction({
-  name: 'dxos.org/function/assistant-analysis',
+  key: 'dxos.org/function/assistant-analysis',
+  name: 'Assistant analysis',
   description: 'Enter analysis analysis mode.',
   inputSchema: Schema.Struct({
     enable: Schema.Boolean.annotations({ description: 'Enable or disable analysis mode.' }),
   }),
   outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { enable } }) {
-    log.info('analysis mode', { enable });
+  handler: Effect.fn(function* ({ context, data: { enable } }) {
+    log.info('analysis mode', { space: context.space?.id, enable });
   }),
 });

package/src/functions/list.ts

@@ -2,7 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
 import { Filter, Obj, Query } from '@dxos/echo';
 import { DatabaseService, defineFunction } from '@dxos/functions';
@@ -10,7 +11,8 @@ import { trim } from '@dxos/util';
 
 // TODO(burdon): Factor out to space plugin.
 export default defineFunction({
-  name: 'dxos.org/function/assistant/list',
+  key: 'dxos.org/function/assistant/list',
+  name: 'Assistant list',
   description:
     // TODO(wittjosiah): Find a better way to prompt for looking up typenames before querying with them.
     trim`
@@ -31,7 +33,11 @@ export default defineFunction({
     ),
   }),
   handler: Effect.fn(function* ({ data: { typename } }) {
-    const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.typename(typename)));
+    // TODO(wittjosiah): Typename query is not working for dynamic schemas.
+    const [schema] = yield* DatabaseService.runSchemaQuery({ typename });
+    const filter = schema ? Filter.type(schema) : Filter.typename(typename);
+
+    const { objects } = yield* DatabaseService.runQuery(Query.select(filter));
     const results = objects.map((object) => ({
       dxn: Obj.getDXN(object).toString(),
       label: Obj.getLabel(object),

package/src/functions/load.ts

@@ -2,17 +2,20 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Option, Schema, pipe } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
 
 import { ArtifactId } from '@dxos/assistant';
 import { Obj } from '@dxos/echo';
 import { DatabaseService, defineFunction } from '@dxos/functions';
-import { log } from '@dxos/log';
 
 // TODO(burdon): Common error handling.
 // TODO(burdon): Factor out to space plugin.
 export default defineFunction({
-  name: 'dxos.org/function/assistant/load',
+  key: 'dxos.org/function/assistant/load',
+  name: 'Assistant load',
   description: 'Loads the object.',
   inputSchema: Schema.Struct({
     id: ArtifactId.annotations({
@@ -28,13 +31,13 @@ export default defineFunction({
   }),
   handler: Effect.fn(function* ({ data: { id, typename } }) {
     const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id));
-    return yield* pipe(
+    return yield* Function.pipe(
       Option.fromNullable(object),
       Option.flatMap((object) => (Obj.getTypename(object) === typename ? Option.some(object) : Option.none())),
       Option.match({
         onNone: () => Effect.fail('Object not found.'),
         onSome: (object) => {
-          log.info('object', { object });
+          // log.info('object', { object });
           return Effect.succeed({ object });
         },
       }),

package/src/hooks/index.ts

@@ -2,14 +2,13 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './chat-processor';
-export * from './errors';
-export * from './presets';
-
 export * from './useBlueprintRegistry';
 export * from './useChatProcessor';
 export * from './useChatServices';
+export * from './useContextBinder';
+export * from './useContextObjects';
+export * from './useFlush';
+export * from './useItemTypes';
 export * from './useOnline';
 export * from './usePresets';
 export * from './useReferencesProvider';
-export * from './useResolveRef';

package/src/hooks/useBlueprintRegistry.ts

@@ -10,7 +10,8 @@ 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';
+import { useQuery } from '@dxos/react-client/echo';
+import { distinctBy, isNonNullable } from '@dxos/util';
 
 /**
  * Provide a registry of blueprints from plugins.
@@ -21,25 +22,38 @@ export const useBlueprintRegistry = () => {
   return useMemo(() => new Blueprint.Registry(blueprints), [blueprints]);
 };
 
+export const useBlueprints = ({
+  blueprintRegistry,
+  space,
+}: {
+  blueprintRegistry?: Blueprint.Registry;
+  space?: Space;
+}) => {
+  const staticBlueprints = useMemo(() => blueprintRegistry?.query() ?? [], [blueprintRegistry]);
+  const spaceBlueprints = useQuery(space, Filter.type(Blueprint.Blueprint));
+  return useMemo(() => {
+    const blueprints = distinctBy([...staticBlueprints, ...spaceBlueprints], (b) => b.key);
+    blueprints.sort(({ name: a }, { name: b }) => a.localeCompare(b));
+    return blueprints;
+  }, [staticBlueprints, spaceBlueprints]);
+};
+
 /**
  * Create reactive map of active blueprints (by key).
  */
-export const useBlueprints = ({ context }: { context?: AiContextBinder }) => {
+export const useActiveBlueprints = ({ 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);
+    const blueprints = refs.map((ref) => ref.target).filter(isNonNullable);
+    setActive(new Map(blueprints.map((blueprint) => [blueprint.key, blueprint])));
   });
 
   return active;
 };
 
-// TODO(burdon): Context should manage ephemeral state of bindings until prompt is issued?
+// TODO(burdon): Move logic into binder.
 export const useBlueprintHandlers = ({
   space,
   context,
@@ -64,6 +78,7 @@ export const useBlueprintHandlers = ({
           if (!blueprint) {
             return;
           }
+
           // NOTE: Possible race condition with other peers.
           storedBlueprint = space.db.add(Obj.clone(blueprint));
         }

package/src/hooks/useChatProcessor.ts

@@ -3,23 +3,22 @@
 //
 
 import { RegistryContext } from '@effect-rx/rx-react';
-import { type Layer } from 'effect';
-import { useContext, useMemo } from 'react';
+import type * as Runtime from 'effect/Runtime';
+import { useContext, useMemo, useState } from 'react';
 
-import { useIntentDispatcher } from '@dxos/app-framework';
 import { AiConversation } from '@dxos/assistant';
 import { type Blueprint } from '@dxos/blueprints';
 import { log } from '@dxos/log';
-import { type Queue, type Space, fullyQualifiedId } from '@dxos/react-client/echo';
+import { type Queue } from '@dxos/react-client/echo';
+import { useAsyncEffect } from '@dxos/react-ui';
 
-import { AiChatProcessor, type AiChatServices, type AiServicePreset } from '../hooks';
+import { AiChatProcessor, type AiChatServices, type AiServicePreset } from '../processor';
 import { type Assistant } from '../types';
 
 export type UseChatProcessorProps = {
-  space?: Space;
   chat?: Assistant.Chat;
   preset?: AiServicePreset;
-  services?: Layer.Layer<AiChatServices>;
+  services?: () => Promise<Runtime.Runtime<AiChatServices>>;
   blueprintRegistry?: Blueprint.Registry;
   settings?: Assistant.Settings;
 };
@@ -28,7 +27,6 @@ export type UseChatProcessorProps = {
  * Configure and create AiChatProcessor.
  */
 export const useChatProcessor = ({
-  space,
   chat,
   preset,
   services,
@@ -36,22 +34,24 @@ export const useChatProcessor = ({
   settings,
 }: UseChatProcessorProps): AiChatProcessor | undefined => {
   const observableRegistry = useContext(RegistryContext);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
 
-  // Tools and context.
-  const chatId = useMemo(() => (chat ? fullyQualifiedId(chat) : undefined), [chat]);
-  const extensions = useMemo(() => ({ space, dispatch, pivotId: chatId }), [dispatch, space, chatId]);
-
-  const conversation = useMemo(() => {
+  // Create conversation from chat queue.
+  const [conversation, setConversation] = useState<AiConversation>();
+  useAsyncEffect(async () => {
     if (!chat?.queue.target) {
       return;
     }
 
-    return new AiConversation({ queue: chat.queue.target as Queue<any> });
+    const conversation = new AiConversation({ queue: chat.queue.target as Queue<any> });
+    await conversation.open();
+    setConversation(conversation);
+
+    return () => {
+      void conversation.close();
+    };
   }, [chat?.queue.target]);
 
   // Create processor.
-  // TODO(burdon): Updated on each query update above; should just update current processor?
   const processor = useMemo(() => {
     if (!services || !conversation) {
       return undefined;
@@ -63,19 +63,12 @@ export const useChatProcessor = ({
       settings,
     });
 
-    return new AiChatProcessor(services, conversation, {
-      extensions,
-      blueprintRegistry,
+    return new AiChatProcessor(conversation, services, {
       observableRegistry,
+      blueprintRegistry,
       model: preset?.model,
     });
-  }, [services, conversation, blueprintRegistry, extensions, preset]);
+  }, [services, conversation, blueprintRegistry, preset]);
 
   return processor;
 };
-
-// TODO(dmaretskyi): Extract.
-export const Stable = Object.freeze({
-  array: [] as readonly never[],
-  object: {} as {},
-});

package/src/hooks/useChatServices.ts

@@ -2,71 +2,48 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type AiTool, AiToolkit } from '@effect/ai';
-import { Layer } from 'effect';
+import * as Effect from 'effect/Effect';
+import type * as Runtime from 'effect/Runtime';
 import { useMemo } from 'react';
 
-import { type AiService, type ToolExecutionService, type ToolResolverService } from '@dxos/ai';
-import { Capabilities, useCapabilities } from '@dxos/app-framework';
-import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
+import { useCapability } from '@dxos/app-framework';
 import { type Space } from '@dxos/client/echo';
-import {
-  ComputeEventLogger,
-  CredentialsService,
-  DatabaseService,
-  LocalFunctionExecutionService,
-  QueueService,
-  RemoteFunctionExecutionService,
-  TracingService,
-} from '@dxos/functions';
+import { TracingService } from '@dxos/functions';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
+import { useClient } from '@dxos/react-client';
 
-import { AssistantCapabilities } from '../capabilities';
-
-// TODO(burdon): Deconstruct into separate layers?
-export type AiChatServices =
-  | AiService.AiService
-  | CredentialsService
-  | DatabaseService
-  | QueueService
-  | RemoteFunctionExecutionService
-  | ToolResolverService
-  | ToolExecutionService
-  | TracingService;
+import { type AiChatServices } from '../processor';
+import { type Assistant } from '../types';
 
 export type UseChatServicesProps = {
   space?: Space;
+  chat?: Assistant.Chat;
 };
 
 /**
  * Construct service layer.
  */
-export const useChatServices = ({ space }: UseChatServicesProps): Layer.Layer<AiChatServices> | undefined => {
-  const serviceLayer = useCapabilities(AssistantCapabilities.AiServiceLayer).at(0) ?? Layer.die('AiService not found');
-  const functions = useCapabilities(Capabilities.Functions);
-  const toolkits = useCapabilities(Capabilities.Toolkit);
-  const handlers = useCapabilities(Capabilities.ToolkitHandler);
+// TODO(dmaretskyi): Better return type.
+export const useChatServices = ({
+  space,
+  chat,
+}: UseChatServicesProps): (() => Promise<Runtime.Runtime<AiChatServices>>) | undefined => {
+  const client = useClient();
+  space ??= client.spaces.default;
+
+  const computeRuntimeResolver = useCapability(AutomationCapabilities.ComputeRuntime);
 
   return useMemo(() => {
-    const allFunctions = functions.flat();
-    // TODO(wittjosiah): Don't cast.
-    const toolkit = AiToolkit.merge(...toolkits) as AiToolkit.Any as AiToolkit.AiToolkit<AiTool.Any>;
-    const handlersLayer = Layer.mergeAll(Layer.empty, ...handlers);
-    return Layer.mergeAll(
-      serviceLayer,
-      makeToolResolverFromFunctions(allFunctions, toolkit),
-      makeToolExecutionServiceFromFunctions(allFunctions, toolkit, handlersLayer),
-      CredentialsService.layerFromDatabase(),
-      ComputeEventLogger.layerFromTracing,
-    ).pipe(
-      Layer.provideMerge(
-        Layer.mergeAll(
-          space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable,
-          space ? QueueService.layer(space.queues) : QueueService.notAvailable,
-          TracingService.layerNoop,
-          LocalFunctionExecutionService.layer,
-          RemoteFunctionExecutionService.mockLayer,
-        ),
-      ),
-    );
-  }, [space, functions, toolkits, handlers]);
+    const runtime = computeRuntimeResolver.getRuntime(space.id);
+    return () =>
+      runtime.runPromise(
+        Effect.gen(function* () {
+          return yield* Effect.runtime<AiChatServices>().pipe(
+            Effect.provide(
+              chat?.traceQueue?.target ? TracingService.layerQueue(chat.traceQueue?.target) : TracingService.layerNoop,
+            ),
+          );
+        }),
+      );
+  }, [space, chat?.traceQueue?.target]);
 };

package/src/hooks/useContextBinder.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useState } from 'react';
+
+import { AiContextBinder } from '@dxos/assistant';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import { type Assistant } from '../types';
+
+export const useContextBinder = (chat: Assistant.Chat | undefined): AiContextBinder | undefined => {
+  const [binder, setBinder] = useState<AiContextBinder>();
+
+  useAsyncEffect(async () => {
+    if (!chat?.queue.target) {
+      return;
+    }
+
+    const binder = new AiContextBinder(chat.queue.target);
+    await binder.open();
+    setBinder(binder);
+
+    return () => {
+      void binder.close();
+    };
+  }, [chat?.queue.target]);
+
+  return binder;
+};

package/src/hooks/useContextObjects.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCallback } from 'react';
+
+import { type AiContextBinder } from '@dxos/assistant';
+import { type DXN, type Obj, Ref } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { type Space } from '@dxos/react-client/echo';
+import { isNonNullable } from '@dxos/util';
+
+export type UseContextObjects = {
+  objects: Obj.Any[];
+  onUpdateObject: (dxn: DXN, checked: boolean) => Promise<void>;
+};
+
+/**
+ * Create reactive map of active object references (by DXN string).
+ */
+export const useContextObjects = ({
+  space,
+  context,
+}: {
+  space?: Space;
+  context?: AiContextBinder;
+}): UseContextObjects => {
+  const objects = context?.objects.value.map((ref) => ref.target).filter(isNonNullable) ?? [];
+
+  const handleUpdateObject = useCallback<UseContextObjects['onUpdateObject']>(
+    async (dxn: DXN, checked: boolean) => {
+      if (!space || !context) {
+        return;
+      }
+
+      // Load the object by DXN/id from the current space.
+      const id = dxn.asEchoDXN();
+      const object = id && (await space.db.getObjectById(id.echoId));
+      if (!object) {
+        log.warn('Object not found', { dxn, id });
+        return;
+      }
+
+      const ref = Ref.fromDXN(dxn);
+      if (checked) {
+        await context.bind({ objects: [ref] });
+      } else {
+        await context.unbind({ objects: [ref] });
+      }
+    },
+    [space, context],
+  );
+
+  return {
+    objects,
+    onUpdateObject: handleUpdateObject,
+  };
+};

package/src/hooks/useItemTypes.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+import { useEffect, useState } from 'react';
+
+import { type Type } from '@dxos/echo';
+import { type Space } from '@dxos/react-client/echo';
+import { ItemAnnotation } from '@dxos/schema';
+
+// TODO(burdon): Pass in filter.
+export const useItemTypes = (space?: Space): Type.Obj.Any[] => {
+  const [types, setTypes] = useState<Type.Obj.Any[]>([]);
+  useEffect(() => {
+    if (!space) {
+      return;
+    }
+
+    return space.db.schemaRegistry.query().subscribe(
+      (query) => {
+        const types = Array.from(
+          new Set(
+            [...space.db.graph.schemaRegistry.schemas, ...query.results].filter((type) =>
+              Option.isSome(ItemAnnotation.get(type)),
+            ),
+          ),
+        );
+
+        setTypes(types);
+      },
+      { fire: true },
+    );
+  }, [space]);
+
+  return types;
+};