@dxos/plugin-assistant 0.8.3 → 0.8.4-main.1da679c

package/src/capabilities/react-surface.tsx

@@ -2,136 +2,90 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
-import React, { useEffect, useMemo } from 'react';
+import React from 'react';
 
-import { Capabilities, contributes, createIntent, createSurface, useIntentDispatcher } from '@dxos/app-framework';
-import { Blueprint } from '@dxos/assistant';
+import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
+import { Blueprint } from '@dxos/blueprints';
+import { getSpace } from '@dxos/client/echo';
+import { Sequence } from '@dxos/conductor';
 import { InvocationTraceContainer } from '@dxos/devtools';
-import { Filter, type Key, Obj, Query } from '@dxos/echo';
+import { Obj } from '@dxos/echo';
 import { SettingsStore } from '@dxos/local-storage';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { fullyQualifiedId, getSpace, getTypename } from '@dxos/react-client/echo';
 import { StackItem } from '@dxos/react-ui-stack';
 
 import {
-  AssistantDialog,
   AssistantSettings,
   BlueprintContainer,
+  ChatCompanion,
   ChatContainer,
+  ChatDialog,
   PromptSettings,
-  TemplateContainer,
+  SequenceContainer,
 } from '../components';
-import { ASSISTANT_PLUGIN, ASSISTANT_DIALOG } from '../meta';
-import { AIChatType, AssistantAction, type AssistantSettingsProps, CompanionTo, TemplateType } from '../types';
+import { ASSISTANT_DIALOG, meta } from '../meta';
+import { Assistant } from '../types';
 
 export default () =>
   contributes(Capabilities.ReactSurface, [
     createSurface({
-      id: `${ASSISTANT_PLUGIN}/plugin-settings`,
+      id: `${meta.id}/plugin-settings`,
       role: 'article',
-      filter: (data): data is { subject: SettingsStore<AssistantSettingsProps> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === ASSISTANT_PLUGIN,
+      filter: (data): data is { subject: SettingsStore<Assistant.Settings> } =>
+        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
       component: ({ data: { subject } }) => <AssistantSettings settings={subject.value} />,
     }),
     createSurface({
-      id: `${ASSISTANT_PLUGIN}/chat`,
+      id: `${meta.id}/chat`,
       role: 'article',
-      filter: (data): data is { subject: AIChatType; variant: undefined } =>
-        Obj.instanceOf(AIChatType, data.subject) && data.variant !== 'assistant-chat',
+      filter: (data): data is { subject: Assistant.Chat; variant: undefined } =>
+        Obj.instanceOf(Assistant.Chat, data.subject) && data.variant !== 'assistant-chat',
       component: ({ data, role }) => <ChatContainer role={role} chat={data.subject} />,
     }),
     createSurface({
-      id: `${ASSISTANT_PLUGIN}/object-chat`,
+      id: `${meta.id}/companion-chat`,
       role: 'article',
-      filter: (data): data is { companionTo: Obj.Any; subject: AIChatType | 'assistant-chat' } =>
+      filter: (data): data is { companionTo: Obj.Any; subject: Assistant.Chat | 'assistant-chat' } =>
         Obj.isObject(data.companionTo) &&
-        (Obj.instanceOf(AIChatType, data.subject) || data.subject === 'assistant-chat'),
-      component: ({ data, role }) => {
-        const { dispatch } = useIntentDispatcher();
-        const associatedArtifact = useMemo(
-          () => ({
-            id: fullyQualifiedId(data.companionTo),
-            typename: getTypename(data.companionTo) ?? 'unknown',
-            spaceId: (getSpace(data.companionTo)?.id ?? 'unknown') as Key.SpaceId,
-          }),
-          [data.companionTo],
-        );
-
-        // TODO(wittjosiah): Factor out to container.
-        useEffect(() => {
-          const timeout = setTimeout(async () => {
-            const space = getSpace(data.companionTo);
-            if (space && data.subject === 'assistant-chat') {
-              const result = await space.db
-                .query(Query.select(Filter.ids(data.companionTo.id)).targetOf(CompanionTo).source())
-                .run();
-              if (result.objects.length > 0) {
-                return;
-              }
-
-              const program = Effect.gen(function* () {
-                const { object } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
-                yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
-                yield* dispatch(
-                  createIntent(SpaceAction.AddRelation, {
-                    space,
-                    schema: CompanionTo,
-                    source: object,
-                    target: data.companionTo,
-                  }),
-                );
-              });
-              void Effect.runPromise(program);
-            }
-          });
-
-          return () => clearTimeout(timeout);
-        }, [data.subject]);
-
-        if (data.subject === 'assistant-chat') {
-          return null;
-        }
-
-        return <ChatContainer role={role} chat={data.subject} associatedArtifact={associatedArtifact} />;
-      },
+        (Obj.instanceOf(Assistant.Chat, data.subject) || data.subject === 'assistant-chat'),
+      component: ({ data, role }) => <ChatCompanion role={role} data={data} />,
     }),
     createSurface({
-      id: `${ASSISTANT_PLUGIN}/blueprint`,
+      id: `${meta.id}/sequence`,
       role: 'article',
-      filter: (data): data is { subject: Blueprint } => Obj.instanceOf(Blueprint, data.subject),
-      component: ({ data, role }) => <BlueprintContainer role={role} blueprint={data.subject} />,
+      filter: (data): data is { subject: Sequence } => Obj.instanceOf(Sequence, data.subject),
+      component: ({ data }) => <SequenceContainer sequence={data.subject} />,
     }),
     createSurface({
-      id: `${ASSISTANT_PLUGIN}/companion/logs`,
+      id: `${meta.id}/companion-logs`,
       role: 'article',
-      filter: (data): data is { companionTo: Blueprint } =>
-        Obj.instanceOf(Blueprint, data.companionTo) && data.subject === 'logs',
+      filter: (data): data is { companionTo: Sequence } =>
+        Obj.instanceOf(Sequence, data.companionTo) && data.subject === 'logs',
+      // eslint-disable-next-line unused-imports/no-unused-vars
       component: ({ data, role }) => {
         const space = getSpace(data.companionTo);
         return (
-          <StackItem.Content role={role}>
+          <StackItem.Content>
             <InvocationTraceContainer space={space} target={data.companionTo} detailAxis='block' />
           </StackItem.Content>
         );
       },
     }),
     createSurface({
-      id: `${ASSISTANT_PLUGIN}/template`,
+      id: `${meta.id}/blueprint`,
       role: 'article',
-      filter: (data): data is { subject: TemplateType } => Obj.instanceOf(TemplateType, data.subject),
-      component: ({ data, role }) => <TemplateContainer role={role} template={data.subject} />,
+      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
+      component: ({ data }) => <BlueprintContainer blueprint={data.subject} />,
     }),
     createSurface({
-      id: ASSISTANT_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: { chat: AIChatType } } => data.component === ASSISTANT_DIALOG,
-      component: ({ data }) => <AssistantDialog {...data.props} />,
+      id: `${meta.id}/prompt-settings`,
+      role: 'object-settings',
+      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
+      component: ({ data }) => <PromptSettings template={data.subject.instructions} />,
     }),
     createSurface({
-      id: `${ASSISTANT_PLUGIN}/prompt-settings`,
-      role: 'object-settings',
-      filter: (data): data is { subject: TemplateType } => Obj.instanceOf(TemplateType, data.subject),
-      component: ({ data }) => <PromptSettings template={data.subject} />,
+      id: ASSISTANT_DIALOG,
+      role: 'dialog',
+      filter: (data): data is { props: { chat: Assistant.Chat } } => data.component === ASSISTANT_DIALOG,
+      component: ({ data }) => <ChatDialog {...data.props} />,
     }),
   ]);

package/src/capabilities/settings.ts

@@ -6,14 +6,14 @@ import { Capabilities, contributes } from '@dxos/app-framework';
 import { live } from '@dxos/live-object';
 
 import { meta } from '../meta';
-import { type AssistantSettingsProps, AssistantSettingsSchema } from '../types';
+import { Assistant } from '../types';
 
 export default () => {
-  const settings = live<AssistantSettingsProps>({});
+  const settings = live<Assistant.Settings>({});
 
   return contributes(Capabilities.Settings, {
     prefix: meta.id,
-    schema: AssistantSettingsSchema,
+    schema: Assistant.Settings,
     value: settings,
   });
 };

package/src/capabilities/state.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes } from '@dxos/app-framework';
+import { LocalStorageStore } from '@dxos/local-storage';
+
+import { meta } from '../meta';
+
+import { AssistantCapabilities } from './capabilities';
+
+export default () => {
+  // NOTE: This needs to be a chat object rather than a string id to avoid a query race.
+  // TODO(wittjosiah): Handle serialization and hydration for this so it can be cached.
+  const state = new LocalStorageStore<AssistantCapabilities.AssistantState>(meta.id, {
+    currentChat: {},
+  });
+
+  return contributes(AssistantCapabilities.State, state.values, () => state.close());
+};

package/src/capabilities/toolkit.ts

@@ -0,0 +1,163 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AiTool, AiToolkit } from '@effect/ai';
+import { Effect, Schema } from 'effect';
+
+import { Capabilities, type Capability, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import { AiContextService, ArtifactId } from '@dxos/assistant';
+import { Filter, Obj, Ref, SchemaNotFoundError, Type } from '@dxos/echo';
+import { DatabaseService } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { SpaceCapabilities, getActiveSpace } from '@dxos/plugin-space';
+import { SpaceAction } from '@dxos/plugin-space/types';
+import { DataType } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+// TODO(burdon): Reconcile with functions (currently reuses plugin framework intents).
+class Toolkit extends AiToolkit.make(
+  AiTool.make('add-to-context', {
+    description: trim`
+      Adds the object to the chat context.
+    `,
+    parameters: {
+      id: ArtifactId.annotations({
+        description: 'The ID of the document to read.',
+      }),
+    },
+    success: Schema.Void,
+    failure: Schema.Never,
+  }).addRequirement<AiContextService | DatabaseService>(), // TODO(burdon): Define standard contract.
+
+  AiTool.make('get-schemas', {
+    description: trim`
+      Retrieves schemas definitions.
+    `,
+    parameters: {
+      // TODO(wittjosiah): Remove this once parameter-less tools are fixed.
+      limit: Schema.Number,
+    },
+    // TODO(dmaretskyi): Effect returns ({ result, encodedResult })
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+
+  AiTool.make('add-schema', {
+    description: trim`
+      Adds a schema to the space.
+      The name will be used when displayed to the user.
+      The typename must be in the format of "example.com/type/Type".
+    `,
+    parameters: {
+      name: Schema.String,
+      typename: Schema.String,
+      jsonSchema: Schema.Any,
+    },
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+
+  AiTool.make('create-record', {
+    description: trim`
+      Creates a new record and adds it to the current space.
+      Get the schema from the get-schemas tool and ensure that the data matches the corresponding schema.
+      Note that only record schemas are supported.
+    `,
+    parameters: {
+      typename: Schema.String,
+      data: Schema.Any,
+    },
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+) {
+  static layer = (context: PluginContext) =>
+    Toolkit.toLayer({
+      'add-to-context': Effect.fnUntraced(function* ({ id }) {
+        const { binder } = yield* AiContextService;
+        const { db } = yield* DatabaseService;
+        const ref = Ref.fromDXN(ArtifactId.toDXN(id, db.spaceId));
+        yield* Effect.promise(() =>
+          binder.bind({
+            blueprints: [],
+            objects: [ref],
+          }),
+        );
+      }),
+
+      'get-schemas': () => {
+        const space = getActiveSpace(context);
+        invariant(space, 'No active space');
+
+        return Effect.gen(function* () {
+          const whitelist = context
+            .getCapabilities(ClientCapabilities.SchemaWhiteList)
+            .flat()
+            .map((schema) => ({
+              typename: Type.getTypename(schema),
+              jsonSchema: Type.toJsonSchema(schema),
+              kind: 'record',
+            }));
+
+          // TODO(burdon): Why ObjectForm (bad name for data capability; UI term)?
+          const forms = context.getCapabilities(SpaceCapabilities.ObjectForm).map((form) => ({
+            typename: Type.getTypename(form.objectSchema),
+            jsonSchema: Type.toJsonSchema(form.objectSchema),
+            kind: 'item',
+          }));
+
+          const schemas = [...whitelist, ...forms];
+          if (space) {
+            const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
+            schemas.push(
+              ...objects.map((object) => ({
+                typename: object.typename,
+                jsonSchema: object.jsonSchema,
+                kind: 'record',
+              })),
+            );
+          }
+
+          return schemas;
+        }).pipe(Effect.provide(DatabaseService.layer(space.db)));
+      },
+
+      'add-schema': ({ name, typename, jsonSchema }) => {
+        return Effect.gen(function* () {
+          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+          const space = getActiveSpace(context);
+          invariant(space, 'No active space');
+
+          const schema = Type.toEffectSchema(jsonSchema).pipe(Type.Obj({ typename, version: '0.1.0' }));
+          yield* dispatch(createIntent(SpaceAction.AddSchema, { space, name, typename, schema }));
+        }).pipe(Effect.orDie);
+      },
+
+      'create-record': ({ typename, data }) => {
+        const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+        const space = getActiveSpace(context);
+        invariant(space, 'No active space');
+
+        return Effect.gen(function* () {
+          const schemas = context.getCapabilities(ClientCapabilities.SchemaWhiteList).flat();
+          const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
+          schemas.push(...objects.map((object) => Type.toEffectSchema(object.jsonSchema)));
+          const schema = schemas.find((schema) => Type.getTypename(schema) === typename);
+          if (!schema) {
+            throw new SchemaNotFoundError(typename);
+          }
+
+          const object = Obj.make(schema, data);
+          yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
+          return object;
+        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
+      },
+    });
+}
+
+export default (context: PluginContext): Capability<any>[] => [
+  contributes(Capabilities.Toolkit, Toolkit),
+  contributes(Capabilities.ToolkitHandler, Toolkit.layer(context)),
+];

package/src/components/AssistantSettings/AssistantSettings.tsx

@@ -6,10 +6,10 @@ import React from 'react';
 
 import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from '@dxos/ai';
 import { Input, Select, useTranslation } from '@dxos/react-ui';
-import { DeprecatedFormContainer, DeprecatedFormInput } from '@dxos/react-ui-form';
+import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from '@dxos/react-ui-form';
 
-import { ASSISTANT_PLUGIN } from '../../meta';
-import { LLM_PROVIDERS, type AssistantSettingsProps } from '../../types';
+import { meta } from '../../meta';
+import { type Assistant, LLM_PROVIDERS } from '../../types';
 
 // TODO(burdon): Factor out default Selector.
 const DEFAULT_VALUE = '__default';
@@ -20,86 +20,93 @@ const LLM_PROVIDER_LABELS = {
   lmstudio: 'LM Studio',
 } as const;
 
-export const AssistantSettings = ({ settings }: { settings: AssistantSettingsProps }) => {
-  const { t } = useTranslation(ASSISTANT_PLUGIN);
+export const AssistantSettings = ({ settings }: { settings: Assistant.Settings }) => {
+  const { t } = useTranslation(meta.id);
 
   return (
-    <DeprecatedFormContainer>
-      <DeprecatedFormInput label={t('settings custom prompts label')}>
-        <Input.Switch
-          checked={!!settings.customPrompts}
-          onCheckedChange={(checked) => (settings.customPrompts = checked)}
-        />
-      </DeprecatedFormInput>
+    <ControlPage>
+      <ControlSection title={t('settings title', { ns: meta.id })}>
+        <ControlGroup>
+          <ControlItemInput title={t('settings custom prompts label')}>
+            <Input.Switch
+              checked={!!settings.customPrompts}
+              onCheckedChange={(checked) => (settings.customPrompts = checked)}
+            />
+          </ControlItemInput>
 
-      <DeprecatedFormInput label={t('settings llm provider label')}>
-        <Select.Root
-          value={settings.llmProvider ?? 'edge'}
-          onValueChange={(value) => {
-            settings.llmProvider = value === DEFAULT_VALUE ? undefined : (value as any);
-          }}
-        >
-          <Select.TriggerButton placeholder={t('settings llm provider label')} />
-          <Select.Portal>
-            <Select.Content>
-              <Select.Viewport>
-                <Select.Option value={DEFAULT_VALUE}>{t('settings default label')}</Select.Option>
-                {LLM_PROVIDERS.map((model) => (
-                  <Select.Option key={model} value={model}>
-                    {LLM_PROVIDER_LABELS[model]}
-                  </Select.Option>
-                ))}
-              </Select.Viewport>
-            </Select.Content>
-          </Select.Portal>
-        </Select.Root>
-      </DeprecatedFormInput>
+          <ControlItemInput title={t('settings llm provider label')}>
+            <Select.Root
+              value={settings.llmProvider ?? 'edge'}
+              onValueChange={(value) => {
+                settings.llmProvider = value === DEFAULT_VALUE ? undefined : (value as any);
+              }}
+            >
+              <Select.TriggerButton placeholder={t('settings llm provider label')} />
+              <Select.Portal>
+                <Select.Content>
+                  <Select.Viewport>
+                    <Select.Option value={DEFAULT_VALUE}>{t('settings default label')}</Select.Option>
+                    {LLM_PROVIDERS.map((model) => (
+                      <Select.Option key={model} value={model}>
+                        {LLM_PROVIDER_LABELS[model]}
+                      </Select.Option>
+                    ))}
+                  </Select.Viewport>
+                  <Select.Arrow />
+                </Select.Content>
+              </Select.Portal>
+            </Select.Root>
+          </ControlItemInput>
 
-      <DeprecatedFormInput label={t('settings edge llm model label')}>
-        <Select.Root
-          value={settings.edgeModel ?? DEFAULT_VALUE}
-          onValueChange={(value) => {
-            settings.edgeModel = value === DEFAULT_VALUE ? undefined : value;
-          }}
-        >
-          <Select.TriggerButton placeholder={t('settings default llm model label')} />
-          <Select.Portal>
-            <Select.Content>
-              <Select.Viewport>
-                <Select.Option value={DEFAULT_VALUE}>{t('settings default label')}</Select.Option>
-                {DEFAULT_EDGE_MODELS.map((model) => (
-                  <Select.Option key={model} value={model}>
-                    {model}
-                  </Select.Option>
-                ))}
-              </Select.Viewport>
-            </Select.Content>
-          </Select.Portal>
-        </Select.Root>
-      </DeprecatedFormInput>
+          <ControlItemInput title={t('settings edge llm model label')}>
+            <Select.Root
+              value={settings.edgeModel ?? DEFAULT_VALUE}
+              onValueChange={(value) => {
+                settings.edgeModel = value === DEFAULT_VALUE ? undefined : value;
+              }}
+            >
+              <Select.TriggerButton placeholder={t('settings default llm model label')} />
+              <Select.Portal>
+                <Select.Content>
+                  <Select.Viewport>
+                    <Select.Option value={DEFAULT_VALUE}>{t('settings default label')}</Select.Option>
+                    {DEFAULT_EDGE_MODELS.map((model) => (
+                      <Select.Option key={model} value={model}>
+                        {model}
+                      </Select.Option>
+                    ))}
+                  </Select.Viewport>
+                  <Select.Arrow />
+                </Select.Content>
+              </Select.Portal>
+            </Select.Root>
+          </ControlItemInput>
 
-      <DeprecatedFormInput label={t('settings ollama llm model label')}>
-        <Select.Root
-          value={settings.ollamaModel ?? DEFAULT_VALUE}
-          onValueChange={(value) => {
-            settings.ollamaModel = value === DEFAULT_VALUE ? undefined : value;
-          }}
-        >
-          <Select.TriggerButton placeholder={t('settings default llm model label')} />
-          <Select.Portal>
-            <Select.Content>
-              <Select.Viewport>
-                <Select.Option value={DEFAULT_VALUE}>{t('settings default label')}</Select.Option>
-                {DEFAULT_OLLAMA_MODELS.map((model) => (
-                  <Select.Option key={model} value={model}>
-                    {model}
-                  </Select.Option>
-                ))}
-              </Select.Viewport>
-            </Select.Content>
-          </Select.Portal>
-        </Select.Root>
-      </DeprecatedFormInput>
-    </DeprecatedFormContainer>
+          <ControlItemInput title={t('settings ollama llm model label')}>
+            <Select.Root
+              value={settings.ollamaModel ?? DEFAULT_VALUE}
+              onValueChange={(value) => {
+                settings.ollamaModel = value === DEFAULT_VALUE ? undefined : value;
+              }}
+            >
+              <Select.TriggerButton placeholder={t('settings default llm model label')} />
+              <Select.Portal>
+                <Select.Content>
+                  <Select.Viewport>
+                    <Select.Option value={DEFAULT_VALUE}>{t('settings default label')}</Select.Option>
+                    {DEFAULT_OLLAMA_MODELS.map((model) => (
+                      <Select.Option key={model} value={model}>
+                        {model}
+                      </Select.Option>
+                    ))}
+                  </Select.Viewport>
+                  <Select.Arrow />
+                </Select.Content>
+              </Select.Portal>
+            </Select.Root>
+          </ControlItemInput>
+        </ControlGroup>
+      </ControlSection>
+    </ControlPage>
   );
 };