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

package/src/capabilities/capabilities.ts

@@ -0,0 +1,71 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Layer, type ManagedRuntime } from 'effect';
+
+import { type AiService, type AiServiceRouter, type ToolExecutionService, type ToolResolverService } from '@dxos/ai';
+import { defineCapability } from '@dxos/app-framework';
+import type {
+  CredentialsService,
+  DatabaseService,
+  FunctionImplementationResolver,
+  InvocationTracer,
+  LocalFunctionExecutionService,
+  QueueService,
+  RemoteFunctionExecutionService,
+  TriggerDispatcher,
+  TriggerStateStore,
+} from '@dxos/functions';
+import type { SpaceId } from '@dxos/keys';
+import { type DeepReadonly } from '@dxos/util';
+
+import { meta } from '../meta';
+import { type Assistant } from '../types';
+
+export namespace AssistantCapabilities {
+  export type AssistantState = {
+    /** Map of primary object fq id to current chat. */
+    currentChat: Record<string, Assistant.Chat>;
+  };
+  export const State = defineCapability<DeepReadonly<AssistantState>>(`${meta.id}/capability/state`);
+  export const MutableState = defineCapability<AssistantState>(`${meta.id}/capability/state`);
+
+  export type AiServiceLayer = Layer.Layer<AiService.AiService>;
+  export const AiServiceLayer = defineCapability<AiServiceLayer>(`${meta.id}/capability/ai-service-factory`);
+
+  /**
+   * Plugins can contribute them to provide model resolvers.
+   */
+  export const AiModelResolver = defineCapability<Layer.Layer<AiServiceRouter.AiModelResolver>>(
+    `${meta.id}/capability/ai-model-resolver`,
+  );
+
+  /**
+   * Service stack for executing agents, functions, and triggers.
+   */
+  export type ComputeServices =
+    | TriggerDispatcher
+    | AiService.AiService
+    | DatabaseService
+    | QueueService
+    | CredentialsService
+    | LocalFunctionExecutionService
+    | RemoteFunctionExecutionService
+    // TODO(dmaretskyi): This service is private and shouldn't be exposed as a part of public API.
+    | FunctionImplementationResolver
+    | InvocationTracer
+    | TriggerStateStore
+    // TODO(dmaretskyi): Those should be provided at AI-chat call site.
+    | ToolResolverService
+    | ToolExecutionService;
+
+  export interface ComputeRuntimeProvider {
+    getRuntime(spaceId: SpaceId): ManagedRuntime.ManagedRuntime<ComputeServices, never>;
+  }
+
+  /**
+   * Runtime for executing agents, functions, and triggers.
+   */
+  export const ComputeRuntime = defineCapability<ComputeRuntimeProvider>(`${meta.id}/capability/compute-runtime`);
+}

package/src/capabilities/compute-runtime.ts

@@ -0,0 +1,124 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AiTool, AiToolkit } from '@effect/ai';
+import { BrowserKeyValueStore } from '@effect/platform-browser';
+import { Effect, Layer, ManagedRuntime } from 'effect';
+
+import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
+import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
+import { PropertiesType } from '@dxos/client/echo';
+import { Resource } from '@dxos/context';
+import { Query, Ref } from '@dxos/echo';
+import {
+  CredentialsService,
+  DatabaseService,
+  FunctionImplementationResolver,
+  InvocationTracer,
+  LocalFunctionExecutionService,
+  QueueService,
+  RemoteFunctionExecutionService,
+  TriggerDispatcher,
+} from '@dxos/functions';
+import { TriggerStateStore } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { type SpaceId } from '@dxos/keys';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { AssistantCapabilities } from './capabilities';
+
+export default async (context: PluginContext) => {
+  const provider = await new ComputeRuntimeProviderImpl(context).open();
+  return contributes(AssistantCapabilities.ComputeRuntime, provider, async () => {
+    await provider.close();
+  });
+};
+
+class ComputeRuntimeProviderImpl extends Resource implements AssistantCapabilities.ComputeRuntimeProvider {
+  readonly #runtimes = new Map<SpaceId, ManagedRuntime.ManagedRuntime<AssistantCapabilities.ComputeServices, never>>();
+  readonly #context: PluginContext;
+
+  constructor(context: PluginContext) {
+    super();
+    this.#context = context;
+  }
+
+  protected override async _open() {}
+
+  protected override async _close() {
+    await Promise.all(Array.from(this.#runtimes.values()).map((rt) => rt.dispose()));
+    this.#runtimes.clear();
+  }
+
+  getRuntime(spaceId: SpaceId): ManagedRuntime.ManagedRuntime<AssistantCapabilities.ComputeServices, never> {
+    if (this.#runtimes.has(spaceId)) {
+      return this.#runtimes.get(spaceId)!;
+    }
+
+    const layer = Layer.unwrapEffect(
+      Effect.gen(this, function* () {
+        const client = this.#context.getCapability(ClientCapabilities.Client);
+        const serviceLayer =
+          this.#context.getCapability(AssistantCapabilities.AiServiceLayer) ?? Layer.die('AiService not found');
+
+        // TODO(dmaretskyi): Make those reactive.
+        const functions = this.#context.getCapabilities(Capabilities.Functions);
+        const toolkits = this.#context.getCapabilities(Capabilities.Toolkit);
+        const handlers = this.#context.getCapabilities(Capabilities.ToolkitHandler);
+
+        const allFunctions = functions.flat();
+        // TODO(wittjosiah): Don't cast.
+        const toolkit = AiToolkit.merge(...toolkits) as AiToolkit.Any as AiToolkit.AiToolkit<AiTool.Any>;
+        const handlersLayer = Layer.mergeAll(Layer.empty, ...handlers);
+
+        const space = client.spaces.get(spaceId);
+        invariant(space);
+        yield* Effect.promise(() => space.waitUntilReady());
+
+        return Layer.mergeAll(TriggerDispatcher.layer({ timeControl: 'natural' })).pipe(
+          Layer.provideMerge(
+            Layer.mergeAll(
+              IvocationTracerLive,
+              TriggerStateStore.layerKv.pipe(Layer.provide(BrowserKeyValueStore.layerLocalStorage)),
+              serviceLayer,
+              makeToolResolverFromFunctions(allFunctions, toolkit),
+              makeToolExecutionServiceFromFunctions(allFunctions, toolkit, handlersLayer),
+              CredentialsService.layerFromDatabase(),
+            ),
+          ),
+          Layer.provideMerge(
+            Layer.mergeAll(
+              space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable,
+              space ? QueueService.layer(space.queues) : QueueService.notAvailable,
+              LocalFunctionExecutionService.layerLive,
+              RemoteFunctionExecutionService.mockLayer,
+            ),
+          ),
+          Layer.provideMerge(FunctionImplementationResolver.layerTest({ functions: allFunctions })),
+        );
+      }),
+    );
+
+    const runtime = ManagedRuntime.make(layer);
+    this.#runtimes.set(spaceId, runtime);
+
+    return runtime;
+  }
+}
+
+const IvocationTracerLive = Layer.unwrapEffect(
+  Effect.gen(function* () {
+    const {
+      objects: [properties],
+    } = yield* DatabaseService.runQuery(Query.type(PropertiesType));
+    invariant(properties);
+    if (!properties.invocationTraceQueue) {
+      const queue = yield* QueueService.createQueue({ subspaceTag: 'trace' });
+      properties.invocationTraceQueue = Ref.fromDXN(queue.dxn);
+    }
+    const queue = properties.invocationTraceQueue.target;
+    invariant(queue);
+    return InvocationTracer.layerLive({ invocationTraceQueue: queue });
+  }),
+);

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

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as AnthropicClient from '@effect/ai-anthropic/AnthropicClient';
+import { FetchHttpClient } from '@effect/platform';
+import { Layer } from 'effect';
+
+import { AiServiceRouter } from '@dxos/ai';
+import { type Capability, contributes } from '@dxos/app-framework';
+
+import { AssistantCapabilities } from './capabilities';
+
+export default (): Capability<any>[] => [
+  contributes(
+    AssistantCapabilities.AiModelResolver,
+    AiServiceRouter.AnthropicResolver.pipe(
+      Layer.provide(
+        AnthropicClient.layer({
+          // TODO(dmaretskyi): Read endpoint from config/settings.
+          apiUrl: 'https://ai-service.dxos.workers.dev/provider/anthropic',
+        }),
+      ),
+      Layer.provide(FetchHttpClient.layer),
+    ),
+  ),
+];

package/src/capabilities/index.ts

@@ -4,7 +4,17 @@
 
 import { lazy } from '@dxos/app-framework';
 
+export const AiService = lazy(() => import('./ai-service'));
 export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
+export const AssistantState = lazy(() => import('./state'));
+export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
+export const EdgeModelResolver = lazy(() => import('./edge-model-resolver'));
 export const IntentResolver = lazy(() => import('./intent-resolver'));
+export const LocalModelResolver = lazy(() => import('./local-model-resolver'));
 export const ReactSurface = lazy(() => import('./react-surface'));
 export const Settings = lazy(() => import('./settings'));
+export const Toolkit = lazy(() => import('./toolkit'));
+export const ComputeRuntime = lazy(() => import('./compute-runtime'));
+
+export * from './blueprint-definition';
+export * from './capabilities';

package/src/capabilities/intent-resolver.ts

@@ -4,18 +4,23 @@
 
 import { Effect } from 'effect';
 
-import { Capabilities, contributes, createIntent, createResolver, type PluginContext } from '@dxos/app-framework';
-import { Blueprint } from '@dxos/blueprints';
+import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
+import { AiContextBinder } from '@dxos/assistant';
+import { Blueprint, Template } from '@dxos/blueprints';
+import { fullyQualifiedId } from '@dxos/client/echo';
 import { Sequence } from '@dxos/conductor';
-import { Key, Obj, Ref } from '@dxos/echo';
+import { Filter, Key, Obj, Ref } from '@dxos/echo';
 import { CollectionAction } from '@dxos/plugin-space/types';
 
-import { Assistant } from '../types';
+import { Assistant, AssistantAction } from '../types';
+
+import { BLUEPRINT_KEY, createBlueprint } from './blueprint-definition';
+import { AssistantCapabilities } from './capabilities';
 
 export default (context: PluginContext) => [
   contributes(Capabilities.IntentResolver, [
     createResolver({
-      intent: Assistant.OnSpaceCreated,
+      intent: AssistantAction.OnSpaceCreated,
       resolve: ({ space, rootCollection }) =>
         Effect.gen(function* () {
           const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
@@ -27,33 +32,42 @@ export default (context: PluginContext) => [
           );
           rootCollection.objects.push(Ref.make(chatCollection), Ref.make(blueprintCollection));
 
-          const { object: chat } = yield* dispatch(createIntent(Assistant.CreateChat, { space }));
+          // Create default chat.
+          const { object: chat } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
           space.db.add(chat);
-
-          // TODO(wittjosiah): Create default blueprint.
-          // const { object: blueprint } = yield* dispatch(createIntent(Assistant.CreateBlueprint, { ... }));
-          // space.db.add(blueprint);
         }),
     }),
     createResolver({
-      intent: Assistant.CreateChat,
-      resolve: ({ space, name }) => ({
-        data: {
-          object: Obj.make(Assistant.Chat, {
-            name,
-            queue: Ref.fromDXN(space.queues.create().dxn),
-          }),
-        },
-      }),
+      intent: AssistantAction.CreateChat,
+      resolve: async ({ space, name }) => {
+        const queue = space.queues.create();
+        const chat = Obj.make(Assistant.Chat, { name, queue: Ref.fromDXN(queue.dxn) });
+        const { objects: blueprints } = await space.db.query(Filter.type(Blueprint.Blueprint)).run();
+        // TODO(wittjosiah): This should be a space-level setting.
+        // TODO(burdon): Clone when activated. Copy-on-write for template.
+        let defaultBlueprint = blueprints.find((blueprint) => blueprint.key === BLUEPRINT_KEY);
+        if (!defaultBlueprint) {
+          defaultBlueprint = space.db.add(createBlueprint());
+        }
+
+        const binder = new AiContextBinder(queue);
+        await binder.bind({ blueprints: [Ref.make(defaultBlueprint)] });
+
+        return {
+          data: { object: chat },
+        };
+      },
     }),
     createResolver({
-      intent: Assistant.CreateBlueprint,
-      resolve: ({ name, description }) => ({
-        data: { object: Blueprint.make({ name, description }) },
+      intent: AssistantAction.CreateBlueprint,
+      resolve: ({ key, name, description }) => ({
+        data: {
+          object: Blueprint.make({ key, name, description, instructions: Template.make({ source: '' }) }),
+        },
       }),
     }),
     createResolver({
-      intent: Assistant.CreateSequence,
+      intent: AssistantAction.CreateSequence,
       resolve: ({ name }) => ({
         data: {
           object: Obj.make(Sequence, {
@@ -68,5 +82,13 @@ export default (context: PluginContext) => [
         },
       }),
     }),
+    createResolver({
+      intent: AssistantAction.SetCurrentChat,
+      resolve: ({ companionTo, chat }) =>
+        Effect.gen(function* () {
+          const state = context.getCapability(AssistantCapabilities.MutableState);
+          state.currentChat[fullyQualifiedId(companionTo)] = chat;
+        }),
+    }),
   ]),
 ];

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

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OpenAiClient } from '@effect/ai-openai';
+import { FetchHttpClient } from '@effect/platform';
+import { Layer } from 'effect';
+
+import { AiServiceRouter } from '@dxos/ai';
+import { type Capability, contributes } from '@dxos/app-framework';
+
+import { AssistantCapabilities } from './capabilities';
+
+/**
+ * To start LM Studio server:
+ * ```bash
+ * ~/.lmstudio/bin/lms server start --cors
+ * ```
+ */
+export default (): Capability<any>[] => [
+  contributes(
+    AssistantCapabilities.AiModelResolver,
+    AiServiceRouter.LMStudioResolver.pipe(
+      Layer.provide(
+        OpenAiClient.layer({
+          apiUrl: AiServiceRouter.LMSTUDIO_ENDPOINT,
+        }),
+      ),
+      Layer.provide(FetchHttpClient.layer),
+    ),
+  ),
+];

package/src/capabilities/react-surface.tsx

@@ -2,28 +2,27 @@
 // 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 { Capabilities, contributes, createSurface } from '@dxos/app-framework';
 import { Blueprint } from '@dxos/blueprints';
-import { fullyQualifiedId, getSpace, getTypename } from '@dxos/client/echo';
+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 { StackItem } from '@dxos/react-ui-stack';
 
 import {
   AssistantSettings,
   BlueprintContainer,
+  ChatCompanion,
   ChatContainer,
   ChatDialog,
   PromptSettings,
   SequenceContainer,
 } from '../components';
-import { meta, ASSISTANT_DIALOG } from '../meta';
+import { ASSISTANT_DIALOG, meta } from '../meta';
 import { Assistant } from '../types';
 
 export default () =>
@@ -43,59 +42,12 @@ export default () =>
       component: ({ data, role }) => <ChatContainer role={role} chat={data.subject} />,
     }),
     createSurface({
-      id: `${meta.id}/object-chat`,
+      id: `${meta.id}/companion-chat`,
       role: 'article',
       filter: (data): data is { companionTo: Obj.Any; subject: Assistant.Chat | 'assistant-chat' } =>
         Obj.isObject(data.companionTo) &&
         (Obj.instanceOf(Assistant.Chat, 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(Assistant.CompanionTo).source())
-                .run();
-              if (result.objects.length > 0) {
-                return;
-              }
-
-              const program = Effect.gen(function* () {
-                const { object } = yield* dispatch(createIntent(Assistant.CreateChat, { space }));
-                yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
-                yield* dispatch(
-                  createIntent(SpaceAction.AddRelation, {
-                    space,
-                    schema: Assistant.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} artifact={associatedArtifact} />;
-      },
+      component: ({ data, role }) => <ChatCompanion role={role} data={data} />,
     }),
     createSurface({
       id: `${meta.id}/sequence`,
@@ -104,10 +56,11 @@ export default () =>
       component: ({ data }) => <SequenceContainer sequence={data.subject} />,
     }),
     createSurface({
-      id: `${meta.id}/companion/logs`,
+      id: `${meta.id}/companion-logs`,
       role: 'article',
       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 (

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, 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 Error(`Schema not found for ${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)),
+];