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

package/src/blueprints/assistant/blueprint.test.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { AiConversationService } from '@dxos/assistant';
+import { AssistantTestLayer } from '@dxos/assistant/testing';
+import { DatabaseBlueprint } from '@dxos/assistant-toolkit';
+import { addBlueprints } from '@dxos/assistant-toolkit/testing';
+import { Blueprint } from '@dxos/blueprints';
+import { TestHelpers } from '@dxos/effect/testing';
+import { ObjectId } from '@dxos/keys';
+import { Organization } from '@dxos/types';
+
+import AssistantBlueprint from './blueprint';
+
+ObjectId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  functions: [...Object.values(DatabaseBlueprint.functions)],
+  types: [Organization.Organization, Blueprint.Blueprint],
+  tracing: 'pretty',
+});
+
+const provideTestLayers = Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer)));
+
+describe('Assistant Blueprint', () => {
+  // TODO(dmaretskyi): Regenerate memoized conversation with ALLOW_LLM_GENERATION=1.
+  it.effect.skip(
+    'works with Database blueprint to create objects',
+    Effect.fnUntraced(
+      function* (_) {
+        yield* addBlueprints([AssistantBlueprint, DatabaseBlueprint]);
+        const messages = yield* AiConversationService.run({
+          prompt: 'Create a new organization called "Test Corp".',
+        });
+        const lastMessage = messages.at(-1);
+        expect(lastMessage).toBeDefined();
+      },
+      provideTestLayers,
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 60_000 },
+  );
+});

package/src/blueprints/assistant/blueprint.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { templates } from '@dxos/assistant';
+import { Blueprint } from '@dxos/blueprints';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.assistant';
+
+const tools = ['open-item'];
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Assistant',
+    tools: Blueprint.toolDefinitions({ tools }),
+    instructions: templates.system,
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  functions: [],
+  make,
+};
+
+export default blueprint;

package/src/blueprints/assistant/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as AssistantBlueprint } from './blueprint';

package/src/blueprints/index.ts

@@ -2,11 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Blueprint } from '@dxos/blueprints';
-import { type FunctionDefinition } from '@dxos/functions';
-
-import * as AssistantBlueprint from './assistant-blueprint';
-
-export { AssistantBlueprint };
-export const blueprints: Blueprint.Blueprint[] = AssistantBlueprint.blueprints;
-export const functions: FunctionDefinition[] = AssistantBlueprint.functions;
+export * from './assistant';

package/src/capabilities/ai-service/ai-service.ts

@@ -6,11 +6,12 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { AiModelResolver } from '@dxos/ai';
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    const resolvers = yield* Capability.getAll(Common.Capability.AiModelResolver);
+    const resolvers = yield* Capability.getAll(AppCapabilities.AiModelResolver);
 
     // TODO(dmaretskyi): Extract function to reduce them.
     const combinedLayer = resolvers.reduce(
@@ -21,7 +22,7 @@ export default Capability.makeModule(
     return [
       // TODO(dmaretskyi): Read config from settings.
       Capability.contributes(
-        Common.Capability.AiServiceLayer,
+        AppCapabilities.AiServiceLayer,
         AiModelResolver.AiModelResolver.buildAiService.pipe(Layer.provide(combinedLayer)),
       ),
     ];

package/src/capabilities/app-graph-builder/app-graph-builder.ts

@@ -4,22 +4,24 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
-import { Prompt } from '@dxos/blueprints';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities, COMPANION_PREFIX, LayoutOperation } from '@dxos/app-toolkit';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Blueprint, Prompt } from '@dxos/blueprints';
 import { Sequence } from '@dxos/conductor';
-import { DXN, type Database, Obj, type Ref } from '@dxos/echo';
+import { DXN, Database, Obj, type Ref } from '@dxos/echo';
 import { AtomObj } from '@dxos/echo-atom';
 import { invariant } from '@dxos/invariant';
 import { Operation, type OperationInvoker } from '@dxos/operation';
 import { ClientCapabilities } from '@dxos/plugin-client';
-import { ATTENDABLE_PATH_SEPARATOR, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
+import { DECK_COMPANION_TYPE, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
 import { GraphBuilder, NodeMatcher } from '@dxos/plugin-graph';
 import { getActiveSpace } from '@dxos/plugin-space';
 import { SpaceOperation } from '@dxos/plugin-space/types';
 import { Query } from '@dxos/react-client/echo';
 
 import { ASSISTANT_DIALOG, meta } from '../../meta';
-import { Assistant, AssistantCapabilities, AssistantOperation } from '../../types';
+import { AssistantCapabilities, AssistantOperation } from '../../types';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
@@ -27,13 +29,12 @@ export default Capability.makeModule(
 
     const extensions = yield* Effect.all([
       GraphBuilder.createTypeExtension({
-        id: `${meta.id}/root`,
-        type: Assistant.Chat,
+        id: `${meta.id}.root`,
+        type: Chat.Chat,
         actions: (chat) => {
-          const id = Obj.getDXN(chat).toString();
           return Effect.succeed([
             {
-              id: `${AssistantOperation.UpdateChatName.meta.key}/${id}`,
+              id: AssistantOperation.UpdateChatName.meta.key,
               data: () => Operation.invoke(AssistantOperation.UpdateChatName, { chat }),
               properties: {
                 label: ['chat update name label', { ns: meta.id }],
@@ -46,29 +47,27 @@ export default Capability.makeModule(
       }),
 
       GraphBuilder.createExtension({
-        id: `${meta.id}/assistant`,
+        id: `${meta.id}.assistant`,
         match: NodeMatcher.whenRoot,
         actions: () =>
           Effect.succeed([
             {
-              id: `${Common.LayoutOperation.UpdateDialog.meta.key}/assistant/open`,
+              id: `${LayoutOperation.UpdateDialog.meta.key}.assistant.open`,
               data: Effect.fnUntraced(function* () {
                 const capabilities = yield* Capability.Service;
                 const client = yield* Capability.get(ClientCapabilities.Client);
-                const operationInvoker = yield* Capability.get(Common.Capability.OperationInvoker);
+                const operationInvoker = yield* Capability.get(Capabilities.OperationInvoker);
                 const space = getActiveSpace(capabilities) ?? client.spaces.default;
                 const chat = yield* Effect.tryPromise(() => getOrCreateChat(operationInvoker.invokePromise, space.db));
                 if (!chat) {
                   return;
                 }
 
-                yield* Operation.invoke(Common.LayoutOperation.UpdateDialog, {
+                yield* Operation.invoke(LayoutOperation.UpdateDialog, {
                   subject: ASSISTANT_DIALOG,
                   state: true,
                   blockAlign: 'end',
-                  props: {
-                    chat,
-                  },
+                  props: { chat },
                 });
               }),
               properties: {
@@ -82,11 +81,30 @@ export default Capability.makeModule(
                 },
               },
             },
+            {
+              id: `${meta.id}.reset-blueprints`,
+              data: Effect.fnUntraced(function* () {
+                const capabilities = yield* Capability.Service;
+                const client = yield* Capability.get(ClientCapabilities.Client);
+                const space = getActiveSpace(capabilities) ?? client.spaces.default;
+                const blueprints = yield* Effect.tryPromise(() =>
+                  space.db.query(Query.type(Blueprint.Blueprint)).run(),
+                );
+                for (const blueprint of blueprints) {
+                  space.db.remove(blueprint);
+                }
+                yield* Database.flush();
+              }),
+              properties: {
+                label: ['reset blueprints label', { ns: meta.id }],
+                icon: 'ph--arrow-clockwise--regular',
+              },
+            },
           ]),
       }),
 
       GraphBuilder.createExtension({
-        id: `${meta.id}/companion-chat`,
+        id: `${meta.id}.companion-chat`,
         match: NodeMatcher.whenEchoObject,
         connector: (object, get) =>
           Effect.gen(function* () {
@@ -96,7 +114,7 @@ export default Capability.makeModule(
             if (!currentChatState) {
               return [
                 {
-                  id: [Obj.getDXN(object).toString(), 'assistant-chat'].join(ATTENDABLE_PATH_SEPARATOR),
+                  id: 'assistant-chat',
                   type: PLANK_COMPANION_TYPE,
                   data: 'assistant-chat',
                   properties: {
@@ -113,15 +131,14 @@ export default Capability.makeModule(
             const currentChatDxn = DXN.tryParse(currentChatState);
             const currentChatRef = currentChatDxn ? db?.makeRef(currentChatDxn) : undefined;
             const currentChat = currentChatRef ? get(AtomObj.make(currentChatRef as Ref.Ref<Obj.Unknown>)) : undefined;
-            if (!Obj.isObject(currentChat)) {
-              return [];
-            }
 
+            // Return the resolved chat object, or fall back to 'assistant-chat' string if it can't be resolved.
+            // This ensures the companion remains visible even during transient states.
             return [
               {
-                id: [Obj.getDXN(object).toString(), 'assistant-chat'].join(ATTENDABLE_PATH_SEPARATOR),
+                id: 'assistant-chat',
                 type: PLANK_COMPANION_TYPE,
-                data: currentChat,
+                data: Obj.isObject(currentChat) ? currentChat : 'assistant-chat',
                 properties: {
                   label: ['assistant chat label', { ns: meta.id }],
                   icon: 'ph--sparkle--regular',
@@ -134,15 +151,15 @@ export default Capability.makeModule(
       }),
 
       GraphBuilder.createExtension({
-        id: `${meta.id}/invocations`,
+        id: `${meta.id}.invocations`,
         match: NodeMatcher.whenAny(
           NodeMatcher.whenEchoTypeMatches(Sequence),
           NodeMatcher.whenEchoTypeMatches(Prompt.Prompt),
         ),
-        connector: (node) =>
+        connector: () =>
           Effect.succeed([
             {
-              id: [node.id, 'invocations'].join(ATTENDABLE_PATH_SEPARATOR),
+              id: 'invocations',
               type: PLANK_COMPANION_TYPE,
               data: 'invocations',
               properties: {
@@ -153,9 +170,28 @@ export default Capability.makeModule(
             },
           ]),
       }),
+
+      GraphBuilder.createExtension({
+        id: `${meta.id}.trace`,
+        match: NodeMatcher.whenRoot,
+        connector: () =>
+          Effect.succeed([
+            {
+              id: `${COMPANION_PREFIX}trace`,
+              type: DECK_COMPANION_TYPE,
+              data: 'trace' as const,
+              properties: {
+                label: ['trace label', { ns: meta.id }],
+                icon: 'ph--line-segments--regular',
+                disposition: 'hidden',
+                position: 'fallback',
+              },
+            },
+          ]),
+      }),
     ]);
 
-    return Capability.contributes(Common.Capability.AppGraphBuilder, extensions);
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
   }),
 );
 
@@ -163,10 +199,10 @@ export default Capability.makeModule(
 const getOrCreateChat = async (
   invokePromise: OperationInvoker.OperationInvoker['invokePromise'],
   db: Database.Database,
-): Promise<Assistant.Chat | undefined> => {
+): Promise<Chat.Chat | undefined> => {
   // TODO(wittjosiah): This should be possible with a single query.
-  const allChats = await db.query(Query.type(Assistant.Chat)).run();
-  const relatedChats = await db.query(Query.type(Assistant.Chat).sourceOf(Assistant.CompanionTo).source()).run();
+  const allChats = await db.query(Query.type(Chat.Chat)).run();
+  const relatedChats = await db.query(Query.type(Chat.Chat).sourceOf(Chat.CompanionTo).source()).run();
 
   const chats = allChats.filter((chat) => !relatedChats.includes(chat));
   if (chats.length > 0) {
@@ -174,7 +210,7 @@ const getOrCreateChat = async (
   }
 
   const { data } = await invokePromise(AssistantOperation.CreateChat, { db });
-  invariant(Obj.instanceOf(Assistant.Chat, data?.object));
+  invariant(Obj.instanceOf(Chat.Chat, data?.object));
   await invokePromise(SpaceOperation.AddObject, { target: db, object: data.object });
   return data.object;
 };

package/src/capabilities/blueprint-definition/blueprint-definition.ts

@@ -3,58 +3,52 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Record from 'effect/Record';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import {
-  Agent,
-  Discord,
+  AgentFunctions,
+  BrowserBlueprint,
+  DatabaseBlueprint,
   DiscordBlueprint,
-  EntityExtraction,
-  Linear,
+  EntityExtractionFunctions,
   LinearBlueprint,
-  Research,
+  PlanningBlueprint,
+  ProjectBlueprint,
+  ProjectFunctions,
   ResearchBlueprint,
   WebSearchBlueprint,
+  MemoryBlueprint,
+  AutomationBlueprint,
+  ProjectWizardBlueprint,
 } from '@dxos/assistant-toolkit';
-import { type Blueprint } from '@dxos/blueprints';
 
 import { AssistantBlueprint } from '../../blueprints';
 
-export const createBlueprint: () => Blueprint.Blueprint = AssistantBlueprint.make;
-export { AssistantBlueprint };
-
-export type BlueprintCapabilities = [
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-];
-
-export default Capability.makeModule<[], BlueprintCapabilities>(() =>
+const blueprintDefinition = Capability.makeModule(() =>
   Effect.succeed([
-    Capability.contributes(Common.Capability.Functions, AssistantBlueprint.functions$),
-    Capability.contributes(Common.Capability.BlueprintDefinition, AssistantBlueprint.blueprint),
-
-    // TODO(burdon): Factor out.
-    Capability.contributes(Common.Capability.Functions, [Research.create, Research.research]),
-    Capability.contributes(Common.Capability.BlueprintDefinition, ResearchBlueprint),
-
-    // TODO(burdon): Factor out.
-    Capability.contributes(Common.Capability.Functions, [Agent.prompt, EntityExtraction.extract]),
-    Capability.contributes(Common.Capability.BlueprintDefinition, WebSearchBlueprint),
-
-    // TODO(burdon): Factor out.
-    Capability.contributes(Common.Capability.Functions, [Discord.fetch]),
-    Capability.contributes(Common.Capability.BlueprintDefinition, DiscordBlueprint),
-
-    // TODO(burdon): Factor out.
-    Capability.contributes(Common.Capability.Functions, [Linear.sync]),
-    Capability.contributes(Common.Capability.BlueprintDefinition, LinearBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, AssistantBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, BrowserBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, DatabaseBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, ResearchBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, WebSearchBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, DiscordBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, LinearBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, ProjectBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, PlanningBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, MemoryBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, AutomationBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, ProjectWizardBlueprint),
+
+    Capability.contributes(AppCapabilities.Functions, Record.values(AgentFunctions)),
+    Capability.contributes(AppCapabilities.Functions, Record.values(EntityExtractionFunctions)),
+    Capability.contributes(AppCapabilities.Functions, [
+      ProjectFunctions.Agent,
+      ProjectFunctions.GetContext,
+      ProjectFunctions.Qualifier,
+    ]),
   ]),
 );
+
+export default blueprintDefinition;

package/src/capabilities/blueprint-definition/index.ts

@@ -5,4 +5,3 @@
 import { Capability } from '@dxos/app-framework';
 
 export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
-export { AssistantBlueprint } from './blueprint-definition';

package/src/capabilities/edge-model-resolver/edge-model-resolver.ts

@@ -8,14 +8,15 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { AnthropicResolver } from '@dxos/ai/resolvers';
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 
-export type EdgeModelResolverCapabilities = [Capability.Capability<typeof Common.Capability.AiModelResolver>];
+export type EdgeModelResolverCapabilities = [Capability.Capability<typeof AppCapabilities.AiModelResolver>];
 
 const edgeModelResolver = Capability.makeModule<[], EdgeModelResolverCapabilities>(() =>
   Effect.succeed([
     Capability.contributes(
-      Common.Capability.AiModelResolver,
+      AppCapabilities.AiModelResolver,
       AnthropicResolver.make().pipe(
         Layer.provide(
           AnthropicClient.layer({

package/src/capabilities/index.ts

@@ -7,9 +7,9 @@ export * from './app-graph-builder';
 export * from './blueprint-definition';
 export * from './edge-model-resolver';
 export * from './local-model-resolver';
+export * from './markdown';
 export * from './operation-resolver';
 export * from './react-surface';
-export * from './repair';
 export * from './settings';
 export * from './state';
 export * from './toolkit';

package/src/capabilities/local-model-resolver/local-model-resolver.ts

@@ -8,9 +8,10 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { LMStudioResolver } from '@dxos/ai/resolvers';
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 
-export type LocalModelResolverCapabilities = [Capability.Capability<typeof Common.Capability.AiModelResolver>];
+export type LocalModelResolverCapabilities = [Capability.Capability<typeof AppCapabilities.AiModelResolver>];
 
 /**
  * To start LM Studio server:
@@ -21,7 +22,7 @@ export type LocalModelResolverCapabilities = [Capability.Capability<typeof Commo
 const localModelResolver = Capability.makeModule<[], LocalModelResolverCapabilities>(() =>
   Effect.succeed([
     Capability.contributes(
-      Common.Capability.AiModelResolver,
+      AppCapabilities.AiModelResolver,
       LMStudioResolver.make().pipe(
         Layer.provide(
           OpenAiClient.layer({

package/src/capabilities/markdown/index.ts

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

package/src/capabilities/markdown/markdown.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+import { MarkdownCapabilities } from '@dxos/plugin-markdown';
+
+import { promptRunExtension } from '../../extensions';
+import { AssistantOperation } from '../../types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilities = yield* Capability.Service;
+
+    return Capability.contributes(MarkdownCapabilities.Extensions, [
+      ({ document: doc }) => {
+        if (!doc) {
+          return undefined;
+        }
+
+        const db = Obj.getDatabase(doc);
+        if (!db) {
+          return undefined;
+        }
+
+        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+
+        return promptRunExtension({
+          onRun: (promptText) => {
+            void invokePromise(AssistantOperation.RunPromptInNewChat, { db, prompt: promptText });
+          },
+        });
+      },
+    ]);
+  }),
+);