@dxos/plugin-assistant 0.8.4-main.67995b8 → 0.8.4-main.c4373fc

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

@@ -2,12 +2,10 @@
 // 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, Capabilities, useCapabilities, SettingsPlugin } from '@dxos/app-framework';
+import { IntentPlugin, SettingsPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { capabilities } from '@dxos/assistant-testing';
 import { ChessPlugin } from '@dxos/plugin-chess';
@@ -15,35 +13,30 @@ 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 { Toolbox, type ToolboxProps } from './Toolbox';
 import { translations } from '../../translations';
 
+import { Toolbox, type ToolboxProps } from './Toolbox';
+
 const DefaultStory = (props: ToolboxProps) => {
-  const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
-  return (
-    <Toolbox
-      {...props}
-      artifacts={artifactDefinitions}
-      classNames='w-[30rem] h-[15rem] rounded-sm border border-separator py-1'
-    />
-  );
+  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({
-          onClientInitialized: async (_, client) => {
+          onClientInitialized: async ({ client }) => {
             await client.halo.createIdentity();
           },
         }),
-        SpacePlugin(),
+        SpacePlugin({}),
         SettingsPlugin(),
         IntentPlugin(),
         ChessPlugin(),
@@ -52,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: Story = {};

package/src/components/Toolbox/Toolbox.tsx

@@ -2,11 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useState, useEffect, Fragment, type FC } from 'react';
+import React, { type FC, Fragment, useEffect, useState } from 'react';
 
-import { parseToolName, type Tool } from '@dxos/ai';
-import { Capabilities, useCapabilities } from '@dxos/app-framework';
-import { type ArtifactDefinition } from '@dxos/blueprints';
 import { type Blueprint } from '@dxos/blueprints';
 import { type Ref } from '@dxos/echo';
 import { FunctionType } from '@dxos/functions';
@@ -16,29 +13,19 @@ import { type ThemedClassName } from '@dxos/react-ui';
 import { useTranslation } from '@dxos/react-ui';
 import { mx } from '@dxos/react-ui-theme';
 
-import { type ChatProcessor } from '../../hooks';
 import { meta } from '../../meta';
-import { createToolsFromService } from '../../tools';
+import { type AiChatProcessor } from '../../processor';
 import { ServiceType } from '../../types';
 
 export type ToolboxProps = ThemedClassName<{
-  blueprints?: readonly Ref.Ref<Blueprint.Blueprint>[];
-  artifacts?: ArtifactDefinition[];
-  services?: { service: ServiceType; tools: Tool[] }[];
+  services?: { service: ServiceType }[];
   functions?: FunctionType[];
+  // TODO(burdon): Combine into single array.
+  blueprints?: readonly Ref.Ref<Blueprint.Blueprint>[];
   activeBlueprints?: readonly Ref.Ref<Blueprint.Blueprint>[];
-  striped?: boolean;
 }>;
 
-export const Toolbox = ({
-  classNames,
-  artifacts,
-  functions,
-  services,
-  blueprints,
-  activeBlueprints,
-  striped,
-}: ToolboxProps) => {
+export const Toolbox = ({ classNames, functions, services, blueprints, activeBlueprints }: ToolboxProps) => {
   const { t } = useTranslation(meta.id);
 
   return (
@@ -49,7 +36,7 @@ export const Toolbox = ({
           items={blueprints.map(({ target }) => ({
             name: target?.name ?? '',
             description: target?.description ?? '',
-            subitems: target?.tools.map((toolId) => ({ name: `∙ ${parseToolName(toolId)}` })),
+            subitems: target?.tools.map((toolId) => ({ name: `∙ ${safeToolId(toolId)}` })),
           }))}
         />
       )}
@@ -60,18 +47,7 @@ export const Toolbox = ({
           items={activeBlueprints.map(({ target }) => ({
             name: target?.name ?? '',
             description: target?.description ?? '',
-            subitems: target?.tools.map((toolId) => ({ name: `∙ ${parseToolName(toolId)}` })),
-          }))}
-        />
-      )}
-
-      {artifacts && artifacts.length > 0 && (
-        <Section
-          title='Artifacts'
-          items={artifacts.map(({ name, description, tools }) => ({
-            name,
-            description,
-            subitems: tools.map(({ name, description }) => ({ name: `∙ ${parseToolName(name)}`, description })),
+            subitems: target?.tools.map((toolId) => ({ name: `∙ ${safeToolId(toolId)}` })),
           }))}
         />
       )}
@@ -79,10 +55,10 @@ export const Toolbox = ({
       {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 })),
           }))}
         />
       )}
@@ -90,12 +66,6 @@ export const Toolbox = ({
       {functions && functions.length > 0 && (
         <Section title='Functions' items={functions.map(({ name, description }) => ({ name, description }))} />
       )}
-
-      {!blueprints?.length &&
-        !activeBlueprints?.length &&
-        !artifacts?.length &&
-        !services?.length &&
-        !functions?.length && <div>{t('no tools')}</div>}
     </div>
   );
 };
@@ -136,24 +106,21 @@ const Section: FC<{
 
 export type ToolboxContainerProps = ThemedClassName<{
   space?: Space;
-  processor?: ChatProcessor;
+  processor?: AiChatProcessor;
 }>;
 
 export const ToolboxContainer = ({ classNames, space, processor }: ToolboxContainerProps) => {
-  // Plugin artifacts.
-  const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
-
   // 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]);
 
@@ -164,9 +131,12 @@ export const ToolboxContainer = ({ classNames, space, processor }: ToolboxContai
     <Toolbox
       classNames={classNames}
       blueprints={processor?.context.blueprints.value}
-      artifacts={artifactDefinitions}
       services={serviceTools}
       functions={functions}
     />
   );
 };
+
+const safeToolId = (name: string) => {
+  return name.split('_').pop();
+};

package/src/components/index.ts

@@ -6,15 +6,14 @@ import { lazy } from 'react';
 
 export * from './AssistantSettings';
 export * from './Chat';
+export * from './ChatProgress';
 export * from './PromptSettings';
 export * from './TemplateEditor';
+export * from './Toolbar';
 export * from './Toolbox';
 
-// TODO(burdon): Lazy loading causes issues with Tabster.
-//  Repro: open assistant dialog then close.
-//  https://github.com/microsoft/fluentui/issues/34020
-
 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/events.ts

@@ -2,10 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Events } from '@dxos/app-framework';
+import { defineEvent } from '@dxos/app-framework';
 
 import { meta } from './meta';
 
 export namespace AssistantEvents {
-  export const AiClientReady = Events.createStateEvent(`${meta.id}/ai-client-ready`);
+  export const SetupAiServiceProviders = defineEvent(`${meta.id}/event/setup-ai-service-providers`);
 }

package/src/functions/analysis.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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({
+  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* ({ context, data: { enable } }) {
+    log.info('analysis mode', { space: context.space?.id, enable });
+  }),
+});

package/src/functions/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as analysis } from './analysis';
+export { default as list } from './list';
+export { default as load } from './load';

package/src/functions/list.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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';
+import { trim } from '@dxos/util';
+
+// TODO(burdon): Factor out to space plugin.
+export default defineFunction({
+  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`
+      Lists the objects of the given type.
+      Check the list-schemas tool for available types before calling this function.
+    `,
+  inputSchema: Schema.Struct({
+    typename: Schema.String.annotations({
+      description: 'The typename of the objects to list.',
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    results: Schema.Array(
+      Schema.Struct({
+        dxn: Schema.String.annotations({ description: 'The DXN of the object.' }),
+        label: Schema.optional(Schema.String.annotations({ description: 'The label of the object.' })),
+      }),
+    ),
+  }),
+  handler: Effect.fn(function* ({ data: { 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),
+    }));
+
+    return { results };
+  }),
+});

package/src/functions/load.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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';
+
+// TODO(burdon): Common error handling.
+// TODO(burdon): Factor out to space plugin.
+export default defineFunction({
+  key: 'dxos.org/function/assistant/load',
+  name: 'Assistant load',
+  description: 'Loads the object.',
+  inputSchema: Schema.Struct({
+    id: ArtifactId.annotations({
+      description: 'The ID of the object.',
+    }),
+    typename: Schema.String.annotations({
+      description: 'The typename of the object.',
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    // TODO(wittjosiah): Type.Obj.Any | Type.Relation.Any
+    object: Schema.Any,
+  }),
+  handler: Effect.fn(function* ({ data: { id, typename } }) {
+    const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id));
+    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 });
+          return Effect.succeed({ object });
+        },
+      }),
+    );
+  }),
+});

package/src/hooks/index.ts

@@ -2,10 +2,13 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './chat-processor';
-export * from './presets';
-
-export * from './useBlueprints';
+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';

package/src/hooks/useBlueprintRegistry.ts

@@ -0,0 +1,94 @@
+//
+// 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 { useQuery } from '@dxos/react-client/echo';
+import { distinctBy, 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]);
+};
+
+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 useActiveBlueprints = ({ context }: { context?: AiContextBinder }) => {
+  const [active, setActive] = useState<Map<string, Blueprint.Blueprint>>(new Map());
+
+  useSignalEffect(() => {
+    const refs = [...(context?.blueprints.value ?? [])];
+    const blueprints = refs.map((ref) => ref.target).filter(isNonNullable);
+    setActive(new Map(blueprints.map((blueprint) => [blueprint.key, blueprint])));
+  });
+
+  return active;
+};
+
+// TODO(burdon): Move logic into binder.
+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 };
+};

package/src/hooks/useChatProcessor.ts

@@ -2,142 +2,65 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Layer } from 'effect';
-import { useEffect, useMemo, useState } from 'react';
+import { RegistryContext } from '@effect-rx/rx-react';
+import type * as Runtime from 'effect/Runtime';
+import { useContext, useMemo } from 'react';
 
-import { type ExecutableTool } from '@dxos/ai';
-import { Capabilities, useCapabilities, useIntentDispatcher } from '@dxos/app-framework';
-import { Conversation, createSystemPrompt } from '@dxos/assistant';
-import { type ArtifactDefinition, type AssociatedArtifact, type Blueprint } from '@dxos/blueprints';
-import { FunctionType } from '@dxos/functions';
+import { AiConversation } from '@dxos/assistant';
+import { type Blueprint } from '@dxos/blueprints';
 import { log } from '@dxos/log';
-import { useConfig } from '@dxos/react-client';
-import { Filter, fullyQualifiedId, type Queue, type Space, useQuery } from '@dxos/react-client/echo';
-import { isNonNullable } from '@dxos/util';
+import { type Queue } from '@dxos/react-client/echo';
 
-import { type AiServicePreset, ChatProcessor, type ChatServices } from '../hooks';
-import { convertFunctionToTool, createToolsFromService } from '../tools';
-import { type Assistant, ServiceType } from '../types';
+import { AiChatProcessor, type AiChatServices, type AiServicePreset } from '../processor';
+import { type Assistant } from '../types';
 
-type UseChatProcessorProps = {
-  preset?: AiServicePreset;
-  space?: Space;
+export type UseChatProcessorProps = {
   chat?: Assistant.Chat;
-
-  // TODO(burdon): Move into layer?
-  services?: Layer.Layer<ChatServices>;
+  preset?: AiServicePreset;
+  services?: () => Promise<Runtime.Runtime<AiChatServices>>;
   blueprintRegistry?: Blueprint.Registry;
-  // TODO(burdon): Not currently used.
   settings?: Assistant.Settings;
-
-  /** @deprecated */
-  instructions?: string;
-  /** @deprecated */
-  artifact?: AssociatedArtifact;
-  /** @deprecated */
-  noPluginArtifacts?: boolean;
 };
 
 /**
- * Configure and create ChatProcessor.
+ * Configure and create AiChatProcessor.
  */
 export const useChatProcessor = ({
-  preset,
-  space,
   chat,
+  preset,
   services,
   blueprintRegistry,
   settings,
-  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 remoteServices = useQuery(space, Filter.type(ServiceType));
-  const [serviceTools, setServiceTools] = useState<ExecutableTool[]>([]);
-  useEffect(() => {
-    log('creating service tools...');
-    queueMicrotask(async () => {
-      const tools = await Promise.all(remoteServices.map((service) => createToolsFromService(service)));
-      setServiceTools(tools.flat());
-    });
-  }, [remoteServices]);
-
-  // Tools and context.
-  const config = useConfig();
-  const functions = useQuery(space, Filter.type(FunctionType));
-  const chatId = useMemo(() => (chat ? fullyQualifiedId(chat) : undefined), [chat]);
-  const [tools, extensions] = useMemo(() => {
-    log('creating tools...');
-    const tools: ExecutableTool[] = [
-      ...globalTools.flat(),
-      ...serviceTools,
-      ...functions
-        .map((fn) => convertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? '', space?.id))
-        .filter(isNonNullable),
-    ];
-    const extensions = { space, dispatch, pivotId: chatId };
-    return [tools, extensions];
-  }, [dispatch, globalTools, space, chatId, serviceTools, functions]);
-
-  // TODO(burdon): Create from template.
-  const systemPrompt = useMemo(
-    () =>
-      createSystemPrompt({
-        artifacts: artifacts.map((definition) => `${definition.name}\n${definition.instructions}`),
-        artifact,
-        instructions,
-      }),
-    [artifacts, artifact, instructions],
-  );
+}: UseChatProcessorProps): AiChatProcessor | undefined => {
+  const observableRegistry = useContext(RegistryContext);
 
+  // Create conversation from chat queue.
   const conversation = useMemo(() => {
     if (!chat?.queue.target) {
       return;
     }
 
-    return new Conversation({ queue: chat.queue.target as Queue<any> });
+    return new AiConversation({ queue: chat.queue.target as Queue<any> });
   }, [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;
     }
 
-    log.info('creating processor', {
+    log('creating processor', {
       preset,
-      artifacts: artifacts.length,
-      systemPrompt: systemPrompt.length,
       model: preset?.model,
       settings,
     });
 
-    return new ChatProcessor(services, conversation, {
-      tools,
-      extensions,
+    return new AiChatProcessor(conversation, services, {
+      observableRegistry,
       blueprintRegistry,
-      artifacts,
-      systemPrompt,
       model: preset?.model,
     });
-  }, [services, conversation, tools, blueprintRegistry, artifacts, extensions, systemPrompt, preset]);
+  }, [services, conversation, blueprintRegistry, preset]);
 
   return processor;
 };
-
-// TODO(dmaretskyi): Extract.
-export const Stable = Object.freeze({
-  array: [] as readonly never[],
-  object: {} as {},
-});