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

package/src/capabilities/operation-resolver/operation-resolver.ts

@@ -0,0 +1,137 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { getObjectPathFromObject, LayoutOperation } from '@dxos/app-toolkit';
+import { AiContextBinder, AiConversation } from '@dxos/assistant';
+import { AgentFunctions, Chat, ProjectWizardBlueprint } from '@dxos/assistant-toolkit';
+import { DatabaseBlueprint } from '@dxos/assistant-toolkit';
+import { Blueprint, Prompt } from '@dxos/blueprints';
+import { type Queue } from '@dxos/client/echo';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { TracingService, serializeFunction } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { Operation, OperationResolver } from '@dxos/operation';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { type Message } from '@dxos/types';
+
+import { AssistantBlueprint } from '../../blueprints';
+import { type AiChatServices, updateName } from '../../processor';
+import { AssistantCapabilities, AssistantOperation } from '../../types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationResolver, [
+      OperationResolver.make({
+        operation: AssistantOperation.OnCreateSpace,
+        handler: Effect.fnUntraced(function* ({ space }) {
+          // TODO(wittjosiah): Remove once function registry is avaiable.
+          space.db.add(serializeFunction(AgentFunctions.Prompt));
+
+          // Create default chat.
+          const { object: chat } = yield* Operation.invoke(AssistantOperation.CreateChat, { db: space.db });
+          space.db.add(chat);
+        }),
+      }),
+      OperationResolver.make({
+        operation: AssistantOperation.CreateChat,
+        handler: Effect.fnUntraced(function* ({ db, name, addToSpace = true }) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
+          const client = yield* Capability.get(ClientCapabilities.Client);
+          const space = client.spaces.get(db.spaceId);
+          invariant(space, 'Space not found');
+          const queue = space.queues.create();
+          const chat = Chat.make({ name, queue: db.makeRef<any>(queue.dxn) });
+          if (addToSpace) {
+            space.db.add(chat);
+          }
+
+          // TODO(wittjosiah): This should be a space-level setting.
+          // TODO(burdon): Clone when activated. Copy-on-write for template.
+          const blueprints = yield* Effect.promise(() => db.query(Filter.type(Blueprint.Blueprint)).run());
+          let defaultAssistantBlueprint = blueprints.find((blueprint) => blueprint.key === AssistantBlueprint.key);
+          if (!defaultAssistantBlueprint) {
+            defaultAssistantBlueprint = db.add(AssistantBlueprint.make());
+          }
+          let defaultDatabaseBlueprint = blueprints.find((blueprint) => blueprint.key === DatabaseBlueprint.key);
+          if (!defaultDatabaseBlueprint) {
+            defaultDatabaseBlueprint = db.add(DatabaseBlueprint.make());
+          }
+          let defaultProjectWizardBlueprint = blueprints.find(
+            (blueprint) => blueprint.key === ProjectWizardBlueprint.key,
+          );
+          if (!defaultProjectWizardBlueprint) {
+            defaultProjectWizardBlueprint = db.add(ProjectWizardBlueprint.make());
+          }
+
+          const binder = new AiContextBinder({ queue, registry });
+          yield* Effect.promise(() =>
+            binder.use((b: AiContextBinder) =>
+              b.bind({
+                blueprints: [
+                  Ref.make(defaultAssistantBlueprint!),
+                  Ref.make(defaultDatabaseBlueprint!),
+                  Ref.make(defaultProjectWizardBlueprint!),
+                ],
+              }),
+            ),
+          );
+
+          return { object: chat };
+        }),
+      }),
+      OperationResolver.make({
+        operation: AssistantOperation.UpdateChatName,
+        handler: Effect.fnUntraced(function* ({ chat }) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
+          const db = Obj.getDatabase(chat);
+          const queue = chat.queue.target as Queue<Message.Message>;
+          if (!db || !queue) {
+            return;
+          }
+
+          const runtimeResolver = yield* Capability.get(AutomationCapabilities.ComputeRuntime);
+          const runtime = yield* Effect.promise(() =>
+            runtimeResolver
+              .getRuntime(db.spaceId)
+              .runPromise(Effect.runtime<AiChatServices>().pipe(Effect.provide(TracingService.layerNoop))),
+          );
+
+          yield* Effect.promise(() =>
+            new AiConversation({ queue, registry }).use(async (conversation) =>
+              updateName(runtime, conversation, chat),
+            ),
+          );
+        }),
+      }),
+      OperationResolver.make({
+        operation: AssistantOperation.SetCurrentChat,
+        handler: Effect.fnUntraced(function* ({ companionTo, chat }) {
+          const companionToId = Obj.getDXN(companionTo).toString();
+          const chatId = chat && Obj.getDXN(chat).toString();
+          yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
+            ...current,
+            currentChat: { ...current.currentChat, [companionToId]: chatId },
+          }));
+        }),
+      }),
+      OperationResolver.make({
+        operation: AssistantOperation.RunPromptInNewChat,
+        handler: Effect.fnUntraced(function* ({ db, prompt }) {
+          const { object: chat } = yield* Operation.invoke(AssistantOperation.CreateChat, { db });
+          const chatPath = getObjectPathFromObject(chat);
+          yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
+            ...current,
+            pendingPrompts: { ...current.pendingPrompts, [chatPath]: prompt },
+          }));
+          yield* Operation.invoke(LayoutOperation.Open, { subject: [chatPath] });
+          return { object: chat };
+        }),
+      }),
+    ]);
+  }),
+);

package/src/capabilities/react-surface/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/react-surface/react-surface.tsx

@@ -0,0 +1,133 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useSettingsState } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Chat, Project } from '@dxos/assistant-toolkit';
+import { Blueprint, Prompt } from '@dxos/blueprints';
+import { getSpace } from '@dxos/client/echo';
+import { Sequence } from '@dxos/conductor';
+import { InvocationTraceContainer } from '@dxos/devtools';
+import { Obj } from '@dxos/echo';
+import { Panel } from '@dxos/react-ui';
+
+import {
+  AssistantSettings,
+  BlueprintArticle,
+  ChatCompanion,
+  ChatContainer,
+  ChatDialog,
+  ProjectArticle,
+  ProjectSettings,
+  PromptArticle,
+  TracePanel,
+  TriggerStatus,
+} from '../../containers';
+import { ASSISTANT_DIALOG, meta } from '../../meta';
+import { type Assistant } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: `${meta.id}.plugin-settings`,
+        role: 'article',
+        filter: (data): data is { subject: AppCapabilities.Settings } =>
+          AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<Assistant.Settings>(subject.atom);
+          return <AssistantSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.chat`,
+        role: 'article',
+        filter: (data): data is { attendableId: string; subject: Chat.Chat; variant: undefined } =>
+          typeof data.attendableId === 'string' &&
+          Obj.instanceOf(Chat.Chat, data.subject) &&
+          data.variant !== 'assistant-chat',
+        component: ({ data, role, ref }) => (
+          <ChatContainer role={role} subject={data.subject} attendableId={data.attendableId} ref={ref} />
+        ),
+      }),
+      Surface.create({
+        id: `${meta.id}.project`,
+        role: 'article',
+        filter: (data): data is { subject: Project.Project } => Obj.instanceOf(Project.Project, data.subject),
+        component: ({ data, role }) => <ProjectArticle role={role} subject={data.subject} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.project.companion.settings`,
+        role: 'object-settings',
+        filter: (data): data is { subject: Project.Project } => Obj.instanceOf(Project.Project, data.subject),
+        component: ({ data }) => <ProjectSettings subject={data.subject} />,
+      }),
+      // TODO(wittjosiah): This is flashing when chat changes.
+      Surface.create({
+        id: `${meta.id}.companion-chat`,
+        role: 'article',
+        filter: (
+          data,
+        ): data is { attendableId: string; companionTo: Obj.Unknown; subject: Chat.Chat | 'assistant-chat' } =>
+          typeof data.attendableId === 'string' &&
+          Obj.isObject(data.companionTo) &&
+          (Obj.instanceOf(Chat.Chat, data.subject) || data.subject === 'assistant-chat'),
+        component: ({ data, role, ref }) => <ChatCompanion role={role} data={data} ref={ref} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.companion-invocations`,
+        role: 'article',
+        filter: (data): data is { companionTo: Sequence } =>
+          (Obj.instanceOf(Sequence, data.companionTo) || Obj.instanceOf(Prompt.Prompt, data.companionTo)) &&
+          data.subject === 'invocations',
+        component: ({ data, role }) => {
+          const space = getSpace(data.companionTo);
+          const queueDxn = space?.properties.invocationTraceQueue?.dxn;
+          // TODO(wittjosiah): Support invocation filtering for prompts.
+          const target = Obj.instanceOf(Prompt.Prompt, data.companionTo) ? undefined : data.companionTo;
+          return (
+            <Panel.Root role={role} className='dx-document'>
+              <Panel.Content asChild>
+                <InvocationTraceContainer db={space?.db} queueDxn={queueDxn} target={target} detailAxis='block' />
+              </Panel.Content>
+            </Panel.Root>
+          );
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.blueprint`,
+        role: 'article',
+        filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
+        component: ({ data }) => <BlueprintArticle subject={data.subject} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.prompt`,
+        role: 'article',
+        filter: (data): data is { subject: Prompt.Prompt } => Obj.instanceOf(Prompt.Prompt, data.subject),
+        component: ({ data }) => <PromptArticle subject={data.subject} />,
+      }),
+      Surface.create({
+        id: ASSISTANT_DIALOG,
+        role: 'dialog',
+        filter: (data): data is { props: { chat: Chat.Chat } } => data.component === ASSISTANT_DIALOG,
+        component: ({ data }) => <ChatDialog {...data.props} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.trace`,
+        role: 'deck-companion--trace',
+        filter: (data): data is { subject: 'trace' } => data.subject === 'trace',
+        component: () => <TracePanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.status`,
+        role: 'status',
+        component: () => <TriggerStatus />,
+      }),
+    ]),
+  ),
+);

package/src/capabilities/settings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const Settings = Capability.lazy('Settings', () => import('./settings'));

package/src/capabilities/settings/settings.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
+
+import { meta } from '../../meta';
+import { Assistant, AssistantCapabilities } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: Assistant.Settings,
+      defaultValue: () => ({}),
+    });
+
+    return [
+      Capability.contributes(AssistantCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: Assistant.Settings,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/capabilities/state/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const AssistantState = Capability.lazy('AssistantState', () => import('./state'));

package/src/capabilities/state/state.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { createKvsStore } from '@dxos/effect';
+
+import { meta } from '../../meta';
+import { AssistantCapabilities } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    // 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 stateAtom = createKvsStore({
+      key: meta.id,
+      schema: AssistantCapabilities.StateSchema,
+      defaultValue: () => ({
+        currentChat: {},
+        pendingPrompts: {},
+      }),
+    });
+
+    return Capability.contributes(AssistantCapabilities.State, stateAtom);
+  }),
+);

package/src/capabilities/toolkit/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const Toolkit = Capability.lazy('Toolkit', () => import('./toolkit'));

package/src/capabilities/toolkit/toolkit.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { GenericToolkit } from '@dxos/ai';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { WebSearchToolkit } from '@dxos/assistant-toolkit';
+
+export default Capability.makeModule(() =>
+  Effect.succeed([Capability.contributes(AppCapabilities.Toolkit, GenericToolkit.make(WebSearchToolkit, Layer.empty))]),
+);