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

package/src/stories/components/index.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './types';
+
+export * from './BlueprintContainer';
+export * from './ChatContainer';
+export * from './CommentsContainer';
+export * from './GraphContainer';
+export * from './InvocationsContainer';
+export * from './LoggingContainer';
+export * from './MessageContainer';
+export * from './ResearchInputStack';
+export * from './ResearchOutputStack';
+export * from './PromptContainer';
+export * from './TasksContainer';
+export * from './TokenManagerContainer';
+export * from './TriggersContainer';
+export * from './ChessContainer';

package/src/stories/components/types.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Space } from '@dxos/client/echo';
+
+export type ComponentProps = {
+  space: Space;
+  debug?: boolean;
+  onEvent?: (event: string) => void;
+};

package/src/stories/testing/data.ts

@@ -0,0 +1,142 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Live, type Space } from '@dxos/client/echo';
+import { Obj, Relation, type Type } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { DataType } from '@dxos/schema';
+
+// import { faker } from '@dxos/random';
+// import { DataType } from '@dxos/schema';
+// import { type ValueGenerator, createGenerator } from '@dxos/schema/testing';
+// faker.seed(1);
+// const generator = faker as any as ValueGenerator;
+// const objectGenerator = createGenerator(generator, DataType.Organization, { force: true });
+
+export const testTypes: Type.Obj.Any[] = [
+  DataType.Organization,
+  DataType.Person,
+  DataType.Employer,
+  DataType.HasConnection,
+];
+
+export const organizations: (Type.Properties<DataType.Organization> & { id: string })[] = [
+  { id: 'dxos', name: 'DXOS', website: 'https://dxos.org' },
+  { id: 'socket_supply', name: 'Socket Supply', website: 'https://socketsupply.com' },
+  { id: 'ink_and_switch', name: 'Ink & Switch', website: 'https://inkandswitch.com' },
+  { id: 'effectful', name: 'Effectful', website: 'https://effect.co' },
+  { id: 'blueyard', name: 'Blue Yard', website: 'https://blueyard.com' },
+  { id: 'backed', name: 'Backed', website: 'https://backed.vc' },
+  { id: 'protocol_labs', name: 'Protocol Labs', website: 'https://protocol.ai' },
+  { id: 'newlab', name: 'Newlab', website: 'https://newlab.com' },
+  { id: 'google', name: 'Google', website: 'https://google.com' },
+  { id: 'microsoft', name: 'Microsoft', website: 'https://microsoft.com' },
+  { id: 'openai', name: 'OpenAI', website: 'https://openai.com' },
+  { id: 'anthropic', name: 'Anthropic', website: 'https://anthropic.com' },
+  { id: 'amazon', name: 'Amazon', website: 'https://amazon.com' },
+  { id: 'deshaw', name: 'D. E. Shaw & Co.', website: 'https://deshaw.com' },
+];
+
+const people: (Type.Properties<DataType.Person> & { id: string })[] = [
+  { id: 'rich_burdon', fullName: 'Rich Burdon' },
+  { id: 'josiah_witt', fullName: 'Josiah Witt' },
+  { id: 'dima_dmaretskyi', fullName: 'Dima Maretskyi' },
+  { id: 'chad_fowler', fullName: 'Chad Fowler' },
+  { id: 'ciaran_oleary', fullName: "Ciarán O'Leary" },
+  { id: 'jason_whitmire', fullName: 'Jason Whitmire' },
+  { id: 'alex_brunicki', fullName: 'Alex Brunicki' },
+  { id: 'andre_de_haes', fullName: 'Andre de Haes' },
+  { id: 'scott_cohen', fullName: 'Scott Cohen' },
+  { id: 'juan_benet', fullName: 'Juan Benet' },
+  { id: 'satya_nadella', fullName: 'Satya Nadella' },
+  { id: 'kevin_scott', fullName: 'Kevin Scott' },
+  { id: 'jeff_bezos', fullName: 'Jeff Bezos' },
+];
+
+const testObjects: Record<string, any[]> = {
+  [DataType.Organization.typename]: organizations,
+  [DataType.Person.typename]: people,
+};
+
+const testRelationships: Record<
+  string,
+  ({
+    source: string;
+    target: string;
+  } & Record<string, any>)[]
+> = {
+  [DataType.Employer.typename]: [
+    // prettier-ignore
+    { source: 'rich_burdon', target: 'dxos' },
+    { source: 'rich_burdon', target: 'google', active: false }, // TODO(burdon): Should not contribute to force.
+    { source: 'rich_burdon', target: 'deshaw', active: false },
+    { source: 'josiah_witt', target: 'dxos' },
+    { source: 'dima_dmaretskyi', target: 'dxos' },
+    { source: 'chad_fowler', target: 'blueyard' },
+    { source: 'chad_fowler', target: 'microsoft', active: false },
+    { source: 'ciaran_oleary', target: 'blueyard' },
+    { source: 'jason_whitmire', target: 'blueyard' },
+    { source: 'juan_benet', target: 'protocol_labs' },
+    { source: 'alex_brunicki', target: 'backed' },
+    { source: 'andre_de_haes', target: 'backed' },
+    { source: 'scott_cohen', target: 'newlab' },
+    { source: 'satya_nadella', target: 'microsoft' },
+    { source: 'kevin_scott', target: 'microsoft' },
+    { source: 'kevin_scott', target: 'google', active: false },
+    { source: 'jeff_bezos', target: 'amazon' },
+    { source: 'jeff_bezos', target: 'deshaw', active: false },
+  ],
+
+  // TODO(burdon): Limit graph view to selected relationship types.
+  [DataType.HasConnection.typename]: [
+    // prettier-ignore
+    { kind: 'partner', source: 'dxos', target: 'ink_and_switch' },
+    { kind: 'partner', source: 'dxos', target: 'effectful' },
+    { kind: 'partner', source: 'dxos', target: 'socket_supply' },
+
+    // prettier-ignore
+    { kind: 'investor', source: 'blueyard', target: 'dxos' },
+    { kind: 'investor', source: 'blueyard', target: 'protocol_labs' },
+    { kind: 'investor', source: 'protocol_labs', target: 'dxos' },
+    { kind: 'investor', source: 'backed', target: 'dxos' },
+    { kind: 'investor', source: 'newlab', target: 'dxos' },
+    { kind: 'investor', source: 'microsoft', target: 'openai' },
+    { kind: 'investor', source: 'google', target: 'anthropic' },
+    { kind: 'investor', source: 'amazon', target: 'anthropic' },
+  ],
+};
+
+export const addTestData = async (space: Space): Promise<void> => {
+  const objectMap = new Map<string, Live<any>>();
+
+  for (const [typename, objects] of Object.entries(testObjects)) {
+    const schema = space.db.graph.schemaRegistry.getSchema(typename);
+    invariant(schema, `Schema not found: ${typename}`);
+    for (const { id, ...data } of objects) {
+      const object = space.db.add(Obj.make(schema, data));
+      objectMap.set(id, object);
+    }
+  }
+
+  for (const [typename, relationships] of Object.entries(testRelationships)) {
+    const schema = space.db.graph.schemaRegistry.getSchema(typename);
+    invariant(schema, `Schema not found: ${typename}`);
+
+    for (const { source, target, ...data } of relationships) {
+      const sourceObject = objectMap.get(source);
+      const targetObject = objectMap.get(target);
+      invariant(sourceObject, `Source object not found: ${source}`);
+      invariant(targetObject, `Target object not found: ${target}`);
+
+      space.db.add(
+        Relation.make(schema, {
+          // TODO(burdon): Test source/target types match.
+          [Relation.Source]: sourceObject,
+          [Relation.Target]: targetObject,
+          ...data,
+        }),
+      );
+    }
+  }
+};

package/src/stories/testing/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './testing';
+export * from './schema';

package/src/stories/testing/schema.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Schema } from 'effect';
+
+import { Type } from '@dxos/echo';
+import { Queue } from '@dxos/echo-db';
+
+export const ResearchInputQueue = Schema.Struct({
+  queue: Type.Ref(Queue),
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/ResearchInputQueue',
+    version: '0.1.0',
+  }),
+);

package/src/stories/testing/testing.tsx

@@ -0,0 +1,279 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AiTool, AiToolkit } from '@effect/ai';
+import { Console, Schema } from 'effect';
+
+import { SERVICES_CONFIG } from '@dxos/ai/testing';
+import {
+  Capabilities,
+  Events,
+  IntentPlugin,
+  LayoutAction,
+  type Plugin,
+  type PluginContext,
+  SettingsPlugin,
+  allOf,
+  contributes,
+  createIntent,
+  createResolver,
+  defineModule,
+  definePlugin,
+} from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AiContextBinder, ArtifactId } from '@dxos/assistant';
+import {
+  DESIGN_BLUEPRINT,
+  PLANNING_BLUEPRINT,
+  readDocument,
+  readTasks,
+  research,
+  updateDocument,
+  updateTasks,
+} from '@dxos/assistant-testing';
+import { Blueprint, Prompt } from '@dxos/blueprints';
+import { type Space } from '@dxos/client/echo';
+import { Obj, Ref } from '@dxos/echo';
+import { FunctionTrigger, FunctionType, exampleFunctions } from '@dxos/functions';
+import { log } from '@dxos/log';
+import { AttentionPlugin } from '@dxos/plugin-attention';
+import { ClientCapabilities, ClientEvents, ClientPlugin } from '@dxos/plugin-client';
+import { type ClientPluginOptions } from '@dxos/plugin-client/types';
+import { DeckAction } from '@dxos/plugin-deck/types';
+import { GraphPlugin } from '@dxos/plugin-graph';
+import { Markdown } from '@dxos/plugin-markdown/types';
+import { PreviewPlugin } from '@dxos/plugin-preview';
+import { SpacePlugin } from '@dxos/plugin-space';
+import { StorybookLayoutPlugin } from '@dxos/plugin-storybook-layout';
+import { ThemePlugin } from '@dxos/plugin-theme';
+import { Config } from '@dxos/react-client';
+import { defaultTx } from '@dxos/react-ui-theme';
+import { DataType } from '@dxos/schema';
+import { withLayout } from '@dxos/storybook-utils';
+import { trim } from '@dxos/util';
+
+import { AssistantPlugin } from '../../AssistantPlugin';
+import { Assistant, AssistantAction } from '../../types';
+
+// TODO(burdon): Factor out.
+export const config = {
+  remote: new Config({
+    runtime: {
+      services: SERVICES_CONFIG.REMOTE,
+    },
+  }),
+  persistent: new Config({
+    runtime: {
+      client: {
+        storage: {
+          persistent: true,
+        },
+      },
+      services: SERVICES_CONFIG.REMOTE,
+    },
+  }),
+  local: new Config({
+    runtime: {
+      services: SERVICES_CONFIG.LOCAL,
+    },
+  }),
+};
+
+class TestingToolkit extends AiToolkit.make(
+  AiTool.make('open-item', {
+    description: trim`
+      Opens an item in the application.
+    `,
+    parameters: {
+      id: ArtifactId,
+    },
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+) {
+  static layer = (_context: PluginContext) =>
+    TestingToolkit.toLayer({
+      'open-item': ({ id }) => Console.log('Called open-item', { id }),
+    });
+}
+
+type DecoratorsProps = Omit<ClientPluginOptions, 'onClientInitialized' | 'onSpacesReady'> & {
+  plugins?: Plugin[];
+  accessTokens?: DataType.AccessToken[];
+  onInit?: (props: { space: Space }) => Promise<void>;
+  onChatCreated?: (props: { space: Space; chat: Assistant.Chat; binder: AiContextBinder }) => Promise<void>;
+};
+
+/**
+ * Create storybook decorators.
+ */
+export const getDecorators = ({
+  types = [],
+  plugins = [],
+  accessTokens = [],
+  onInit,
+  onChatCreated,
+  ...props
+}: DecoratorsProps) => [
+  withPluginManager({
+    plugins: [
+      // System plugins.
+      AttentionPlugin(),
+      GraphPlugin(),
+      IntentPlugin(),
+      SettingsPlugin(),
+      SpacePlugin(),
+      ClientPlugin({
+        types: [
+          Markdown.Document,
+          Assistant.Chat,
+          Blueprint.Blueprint,
+          Prompt.Prompt,
+          DataType.AccessToken,
+          FunctionTrigger,
+          FunctionType,
+          ...types,
+        ],
+        onClientInitialized: async ({ client }) => {
+          log('onClientInitialized', { identity: client.halo.identity.get()?.did });
+          // Abort if already initialized.
+          if (client.halo.identity.get()) {
+            return;
+          }
+
+          await client.halo.createIdentity();
+          await client.spaces.waitUntilReady();
+
+          const space = client.spaces.default;
+          // TODO(burdon): Should not require this.
+          //  ERROR: invariant violation: Database was not initialized with root object.
+          // TODO(burdon): onSpacesReady is never called.
+          await space.waitUntilReady();
+
+          // Add tokens.
+          for (const accessToken of accessTokens) {
+            space.db.add(Obj.clone(accessToken));
+          }
+
+          await space.db.flush({ indexes: true });
+          await onInit?.({ space });
+          await space.db.flush({ indexes: true });
+        },
+        ...props,
+      }),
+
+      // Cards
+      ThemePlugin({ tx: defaultTx }),
+      StorybookLayoutPlugin(),
+      PreviewPlugin(),
+
+      // User plugins.
+      AssistantPlugin(),
+
+      // Custom.
+      definePlugin({ id: 'example.com/plugin/testing', name: 'Testing' }, [
+        defineModule({
+          id: 'example.com/plugin/testing/module/testing',
+          activatesOn: Events.SetupArtifactDefinition,
+          activate: () => [
+            // TODO(burdon): Move into assistnat?
+            contributes(Capabilities.BlueprintDefinition, DESIGN_BLUEPRINT),
+            contributes(Capabilities.BlueprintDefinition, PLANNING_BLUEPRINT),
+            contributes(Capabilities.Functions, [readDocument, updateDocument]),
+            contributes(Capabilities.Functions, [readTasks, updateTasks]),
+            contributes(Capabilities.Functions, [research]),
+            contributes(Capabilities.Functions, [exampleFunctions.reply]),
+          ],
+        }),
+        defineModule({
+          id: 'example.com/plugin/testing/module/toolkit',
+          activatesOn: Events.Startup,
+          activate: (context) => [
+            contributes(Capabilities.Toolkit, TestingToolkit),
+            contributes(Capabilities.ToolkitHandler, TestingToolkit.layer(context)),
+          ],
+        }),
+        defineModule({
+          id: 'example.com/plugin/testing/module/setup',
+          activatesOn: allOf(Events.DispatcherReady, ClientEvents.SpacesReady),
+          activate: async (context) => {
+            const client = context.getCapability(ClientCapabilities.Client);
+            const space = client.spaces.default;
+            const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+
+            // Ensure workspace is set.
+            await dispatch(createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: space.id }));
+
+            // Create initial chat.
+            await dispatch(createIntent(AssistantAction.CreateChat, { space }));
+
+            return [];
+          },
+        }),
+        defineModule({
+          id: 'example.com/plugin/testing/module/intent-resolver',
+          activatesOn: Events.SetupIntentResolver,
+          activate: () => [
+            contributes(Capabilities.IntentResolver, [
+              createResolver({
+                intent: DeckAction.ChangeCompanion,
+                resolve: () => ({}),
+              }),
+              createResolver({
+                intent: AssistantAction.CreateChat,
+                position: 'hoist',
+                resolve: async ({ space, name }) => {
+                  const queue = space.queues.create();
+                  const traceQueue = space.queues.create();
+                  const chat = Obj.make(Assistant.Chat, {
+                    name,
+                    queue: Ref.fromDXN(queue.dxn),
+                    traceQueue: Ref.fromDXN(traceQueue.dxn),
+                  });
+                  const binder = new AiContextBinder(queue);
+
+                  // Story-specific behaviour to allow chat creation to be extended.
+                  space.db.add(chat);
+                  await space.db.flush({ indexes: true });
+                  await onChatCreated?.({ space, chat, binder });
+
+                  return {
+                    data: { object: chat },
+                  };
+                },
+              }),
+            ]),
+          ],
+        }),
+      ]),
+
+      // Test-specific.
+      ...plugins,
+    ],
+  }),
+  withLayout({
+    fullscreen: true,
+    classNames: 'justify-center bg-deckSurface',
+  }),
+];
+
+/**
+ * Creates access tokens from environment variables.
+ * @param tokens - Record of token sources mapped to their VITE_ prefixed environment variable values
+ * @returns Array of AccessToken objects for non-empty token values
+ * @example
+ * ```tsx
+ * const tokens = accessTokensFromEnv({
+ *   'exa.ai': process.env.VITE_EXA_API_KEY,
+ *   'linear.app': process.env.VITE_LINEAR_API_KEY
+ * });
+ * ```
+ * @note All environment variables should use the VITE_ prefix for proper Vite bundling
+ */
+
+export const accessTokensFromEnv = (tokens: Record<string, string | undefined>) => {
+  return Object.entries(tokens)
+    .filter(([, token]) => !!token)
+    .map(([source, token]) => Obj.make(DataType.AccessToken, { source, token: token! }));
+};

package/src/testing/index.ts

@@ -2,6 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './test-sequence';
+export * from './test-data';
 export * from './test-functions';
+export * from './test-generator';
+export * from './test-sequence';
 export * from './test-services';