@dxos/plugin-assistant 0.8.3 → 0.8.4-main.28f8d3d

package/src/capabilities/capabilities.ts

@@ -2,14 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type ReadonlySignal } from '@preact/signals-core';
+import { type Layer } from 'effect';
 
-import { type AiServiceClient } from '@dxos/ai';
+import { type AiService, type AiServiceRouter } from '@dxos/ai';
 import { defineCapability } from '@dxos/app-framework';
 
-import { ASSISTANT_PLUGIN } from '../meta';
+import { meta } from '../meta';
 
-// TODO(burdon): Move to types to import from other plugins?
 export namespace AssistantCapabilities {
-  export const AiClient = defineCapability<ReadonlySignal<AiServiceClient>>(`${ASSISTANT_PLUGIN}/capability/ai-client`);
+  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`,
+  );
 }

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

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AnthropicClient } from '@effect/ai-anthropic';
+import { FetchHttpClient } from '@effect/platform';
+import { Layer } from 'effect';
+
+import { AiServiceRouter } from '@dxos/ai';
+import { contributes } from '@dxos/app-framework';
+
+import { AssistantCapabilities } from './capabilities';
+
+export default () => {
+  return [
+    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,10 +4,13 @@
 
 import { lazy } from '@dxos/app-framework';
 
-export const AiClient = lazy(() => import('./ai-client'));
+export * from './capabilities';
+
+export const AiService = lazy(() => import('./ai-service'));
 export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
+export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
+export const EdgeModelResolver = lazy(() => import('./edge-model-resolver'));
 export const IntentResolver = lazy(() => import('./intent-resolver'));
 export const ReactSurface = lazy(() => import('./react-surface'));
 export const Settings = lazy(() => import('./settings'));
-
-export * from './capabilities';
+export const Toolkit = lazy(() => import('./toolkit'));

package/src/capabilities/intent-resolver.ts

@@ -2,34 +2,62 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, createResolver } from '@dxos/app-framework';
-import { Blueprint } from '@dxos/assistant';
+import { Effect } from 'effect';
+
+import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
+import { Blueprint, Template } from '@dxos/blueprints';
+import { Sequence } from '@dxos/conductor';
 import { Key, Obj, Ref } from '@dxos/echo';
+import { CollectionAction } from '@dxos/plugin-space/types';
 
-import { AssistantAction, AIChatType } from '../types';
+import { Assistant, AssistantAction } from '../types';
 
-export default () => [
-  contributes(
-    Capabilities.IntentResolver,
+export default (context: PluginContext) => [
+  contributes(Capabilities.IntentResolver, [
+    createResolver({
+      intent: AssistantAction.OnSpaceCreated,
+      resolve: ({ space, rootCollection }) =>
+        Effect.gen(function* () {
+          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+          const { object: chatCollection } = yield* dispatch(
+            createIntent(CollectionAction.CreateQueryCollection, { typename: Assistant.Chat.typename }),
+          );
+          const { object: blueprintCollection } = yield* dispatch(
+            createIntent(CollectionAction.CreateQueryCollection, { typename: Blueprint.Blueprint.typename }),
+          );
+          rootCollection.objects.push(Ref.make(chatCollection), Ref.make(blueprintCollection));
+          const { object: chat } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
+          space.db.add(chat);
+
+          // TODO(wittjosiah): Create default blueprint.
+          // const { object: blueprint } = yield* dispatch(createIntent(AssistantAction.CreateBlueprint, { ... }));
+          // space.db.add(blueprint);
+        }),
+    }),
     createResolver({
       intent: AssistantAction.CreateChat,
       resolve: ({ space, name }) => ({
         data: {
-          object: Obj.make(AIChatType, {
+          object: Obj.make(Assistant.Chat, {
             name,
             queue: Ref.fromDXN(space.queues.create().dxn),
           }),
         },
       }),
     }),
-  ),
-  contributes(
-    Capabilities.IntentResolver,
     createResolver({
       intent: AssistantAction.CreateBlueprint,
+      resolve: ({ key, name, description }) => ({
+        data: {
+          object: Blueprint.make({ key, name, description, instructions: Template.make({ source: '' }) }),
+        },
+      }),
+    }),
+    createResolver({
+      intent: AssistantAction.CreateSequence,
       resolve: ({ name }) => ({
         data: {
-          object: Obj.make(Blueprint, {
+          object: Obj.make(Sequence, {
             name,
             steps: [
               {
@@ -41,5 +69,5 @@ export default () => [
         },
       }),
     }),
-  ),
+  ]),
 ];

package/src/capabilities/react-surface.tsx

@@ -3,68 +3,63 @@
 //
 
 import { Effect } from 'effect';
-import React, { useEffect, useMemo } from 'react';
+import React, { useCallback, useEffect } from 'react';
 
 import { Capabilities, contributes, createIntent, createSurface, useIntentDispatcher } from '@dxos/app-framework';
-import { Blueprint } from '@dxos/assistant';
+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 { Filter, Obj, Query, Ref } 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,
   ChatContainer,
+  ChatDialog,
   PromptSettings,
-  TemplateContainer,
+  SequenceContainer,
 } from '../components';
-import { ASSISTANT_PLUGIN, ASSISTANT_DIALOG } from '../meta';
-import { AIChatType, AssistantAction, type AssistantSettingsProps, CompanionTo, TemplateType } from '../types';
+import { type AiChatProcessor } from '../hooks';
+import { ASSISTANT_DIALOG, meta } from '../meta';
+import { Assistant, AssistantAction } 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}/object-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'),
+        (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],
-        );
 
+        // Initialize companion chat if it doesn't exist.
         // 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())
+                .query(Query.select(Filter.ids(data.companionTo.id)).targetOf(Assistant.CompanionTo).source())
                 .run();
               if (result.objects.length > 0) {
                 return;
@@ -76,12 +71,13 @@ export default () =>
                 yield* dispatch(
                   createIntent(SpaceAction.AddRelation, {
                     space,
-                    schema: CompanionTo,
+                    schema: Assistant.CompanionTo,
                     source: object,
                     target: data.companionTo,
                   }),
                 );
               });
+
               void Effect.runPromise(program);
             }
           });
@@ -89,49 +85,61 @@ export default () =>
           return () => clearTimeout(timeout);
         }, [data.subject]);
 
+        // TODO(wittjosiah): Factor out to container.
+        const handleProcessorReady = useCallback(
+          (processor: AiChatProcessor) => {
+            if (Obj.instanceOf(Blueprint.Blueprint, data.companionTo)) {
+              void processor.context.bind({ blueprints: [Ref.make(data.companionTo)] });
+            } else {
+              void processor.context.bind({ objects: [Ref.make(data.companionTo)] });
+            }
+          },
+          [data.companionTo],
+        );
+
         if (data.subject === 'assistant-chat') {
           return null;
         }
 
-        return <ChatContainer role={role} chat={data.subject} associatedArtifact={associatedArtifact} />;
+        return <ChatContainer role={role} chat={data.subject} onProcessorReady={handleProcessorReady} />;
       },
     }),
     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',
       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/toolkit.ts

@@ -0,0 +1,106 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AiTool, AiToolkit } from '@effect/ai';
+import { Effect, Schema } from 'effect';
+
+import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import { Filter, Obj, Type } from '@dxos/echo';
+import { DatabaseService } from '@dxos/functions';
+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';
+
+class SchemaToolkit extends AiToolkit.make(
+  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('create-record', {
+    description: trim`
+      Creates a new record.
+      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) =>
+    SchemaToolkit.toLayer({
+      //
+      'get-schemas': () => {
+        const space = getActiveSpace(context);
+        const service = space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable;
+        return Effect.gen(function* () {
+          const forms = context.getCapabilities(SpaceCapabilities.ObjectForm).map((form) => ({
+            typename: Type.getTypename(form.objectSchema),
+            jsonSchema: Type.toJsonSchema(form.objectSchema),
+            kind: 'item',
+          }));
+          const allowed = context
+            .getCapabilities(ClientCapabilities.SchemaWhiteList)
+            .flat()
+            .map((schema) => ({
+              typename: Type.getTypename(schema),
+              jsonSchema: Type.toJsonSchema(schema),
+              kind: 'record',
+            }));
+          const schemas = [...forms, ...allowed];
+          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.map((schema) => schema.typename);
+        }).pipe(Effect.provide(service));
+      },
+
+      //
+      'create-record': ({ typename, data }) => {
+        const space = getActiveSpace(context);
+        const service = space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable;
+        console.log('create-record', { typename, data, space });
+        return Effect.gen(function* () {
+          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+          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(service), Effect.orDie);
+      },
+    });
+}
+
+export default (context: PluginContext) => [
+  contributes(Capabilities.Toolkit, SchemaToolkit),
+  contributes(Capabilities.ToolkitHandler, SchemaToolkit.layer(context)),
+];

package/src/components/AssistantSettings/AssistantSettings.tsx

@@ -8,8 +8,8 @@ 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 { 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,8 +20,8 @@ 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>

package/src/components/BlueprintContainer.tsx

@@ -2,145 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type EditorView } from '@codemirror/view';
-import JSON5 from 'json5';
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import React from 'react';
 
-import { ToolRegistry } from '@dxos/ai';
-import { useCapability } from '@dxos/app-framework';
-import {
-  type Blueprint,
-  type BlueprintDefinition,
-  BlueprintMachine,
-  createLocalSearchTool,
-  createExaTool,
-  createGraphWriterTool,
-} from '@dxos/assistant';
-import { getSpace } from '@dxos/client/echo';
-import { DXN, Key } from '@dxos/echo';
-import { Toolbar, useTranslation } from '@dxos/react-ui';
-import { getSelectionSet, useSelectionManager } from '@dxos/react-ui-attention';
-import { StackItem, type StackItemContentProps } from '@dxos/react-ui-stack';
+import { type Blueprint } from '@dxos/blueprints';
+import { StackItem } from '@dxos/react-ui-stack';
 
-import { BlueprintEditor } from './BlueprintEditor';
-import { AssistantCapabilities } from '../capabilities';
-import { meta } from '../meta';
-import { QueueLogger } from '../queue-logger';
+import { TemplateEditor } from './TemplateEditor';
 
-// TODO(burdon): Move to config.
-export const EXA_API_KEY = '9c7e17ff-0c85-4cd5-827a-8b489f139e03';
-
-// TODO(burdon): Validate.
-const parseBlueprint = (text: string): BlueprintDefinition | undefined => {
-  try {
-    const json = JSON5.parse(text);
-    const { steps } = json;
-    return { steps };
-  } catch (error) {
-    // Ignore.
-  }
+export type BlueprintContainerProps = {
+  blueprint: Blueprint.Blueprint;
 };
 
-export const BlueprintContainer = ({
-  role,
-  blueprint,
-}: Pick<StackItemContentProps, 'role'> & { blueprint: Blueprint }) => {
-  const { t } = useTranslation(meta.id);
-  const aiClient = useCapability(AssistantCapabilities.AiClient);
-  const selectionManager = useSelectionManager();
-  const [definition, setDefinition] = useState<BlueprintDefinition>();
-  useEffect(() => {
-    setDefinition({
-      steps: blueprint.steps.map(({ instructions, tools }) => ({ instructions, tools })),
-    });
-  }, [blueprint]);
-
-  const editorRef = useRef<EditorView | undefined>(undefined);
-
-  // TODO(burdon): Factor out.
-  const toolRegistry = useMemo(() => {
-    const space = getSpace(blueprint);
-    if (!space) {
-      return;
-    }
-
-    // TODO(burdon): How should the queue be created?
-    const queue = space.queues.create();
-
-    return new ToolRegistry([
-      createExaTool({ apiKey: EXA_API_KEY }),
-      createLocalSearchTool(space.db, queue),
-      createGraphWriterTool({
-        db: space.db,
-        queue,
-        schema: [], // TODO(burdon): Get schema from client/blueprint?
-        onDone: async (objects) => {
-          await queue.append(objects);
-        },
-      }),
-    ]);
-  }, [blueprint]);
-
-  const formatAndSave = useCallback((): BlueprintDefinition | undefined => {
-    if (!blueprint) {
-      return;
-    }
-
-    const text = editorRef.current?.state.doc.toString();
-    if (!text) {
-      return;
-    }
-
-    const definition = parseBlueprint(text);
-    if (!definition) {
-      return;
-    }
-
-    setDefinition(definition);
-    const formatted = JSON.stringify(definition, null, 2);
-    editorRef.current?.dispatch({
-      changes: { from: 0, to: text.length, insert: formatted },
-    });
-
-    blueprint.steps.length = 0;
-    for (const step of definition.steps) {
-      blueprint.steps.push({
-        id: Key.ObjectId.random(),
-        instructions: step.instructions,
-        tools: step.tools,
-      });
-    }
-
-    return blueprint;
-  }, [blueprint]);
-
-  // TODO(burdon): Save raw blueprint separately from parsed blueprint? (like Script).
-  const handleSave = useCallback(() => formatAndSave(), [formatAndSave]);
-
-  const handleRun = useCallback(async () => {
-    if (!aiClient?.value || !toolRegistry) {
-      return;
-    }
-
-    formatAndSave();
-
-    // Get input from selection.
-    const input = Array.from(getSelectionSet(selectionManager)).map((id) => DXN.fromLocalObjectId(id));
-    if (!input.length) {
-      return;
-    }
-
-    const machine = new BlueprintMachine(toolRegistry, blueprint).setLogger(new QueueLogger(blueprint));
-    await machine.runToCompletion({ aiClient: aiClient.value, input });
-  }, [aiClient.value, blueprint, formatAndSave, selectionManager, toolRegistry]);
-
+export const BlueprintContainer = ({ blueprint }: BlueprintContainerProps) => {
   return (
-    <StackItem.Content role={role} toolbar>
-      <Toolbar.Root>
-        <Toolbar.Button onClick={handleSave}>{t('button save')}</Toolbar.Button>
-        <Toolbar.Button onClick={handleRun}>{t('button run')}</Toolbar.Button>
-      </Toolbar.Root>
-      {definition && <BlueprintEditor ref={editorRef} blueprint={definition} />}
+    <StackItem.Content classNames='container-max-width'>
+      <TemplateEditor id={blueprint.id} template={blueprint.instructions} />
     </StackItem.Content>
   );
 };