@dxos/assistant-toolkit 0.8.4-main.fcc0d83b33 → 0.8.4-staging.60fe92afc8

package/src/blueprints/{project → agent}/blueprint.test.ts

@@ -9,32 +9,30 @@ import * as Exit from 'effect/Exit';
 import { MemoizedAiService } from '@dxos/ai/testing';
 import { AiSession } from '@dxos/assistant';
 import { SpaceProperties } from '@dxos/client-protocol';
-import { Blueprint } from '@dxos/compute';
-import { QueueService, Trigger } from '@dxos/compute';
-import { Operation, OperationHandlerSet } from '@dxos/compute';
-import { Database, Feed, Filter, Obj, Query, Ref } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
-import { acquireReleaseResource } from '@dxos/effect';
+import { Blueprint, Trigger, Operation, OperationHandlerSet } from '@dxos/compute';
+import { Collection, Database, Feed, Filter, Obj, Query, Ref } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
 import { TestHelpers } from '@dxos/effect/testing';
 import { TriggerDispatcher } from '@dxos/functions-runtime';
 import { AssistantTestLayerWithTriggers } from '@dxos/functions-runtime/testing';
 import { invariant } from '@dxos/invariant';
-import { ObjectId } from '@dxos/keys';
-import { MarkdownBlueprint } from '@dxos/plugin-markdown/blueprints';
-import { MarkdownOperationHandlerSet } from '@dxos/plugin-markdown/operations';
+import { EntityId } from '@dxos/keys';
+import { MarkdownBlueprint } from '@dxos/plugin-markdown';
+import { Markdown } from '@dxos/plugin-markdown';
+import { MarkdownOperationHandlerSet } from '@dxos/plugin-markdown/plugin';
 import { WithProperties } from '@dxos/plugin-markdown/testing';
-import { Markdown } from '@dxos/plugin-markdown/types';
 import { Text } from '@dxos/schema';
 import { Message } from '@dxos/types';
 import { trim } from '@dxos/util';
 
 import { Chat, Plan, Agent } from '../../types';
+import { AgentWizardHandlers, AgentWizardOperations } from '../agent-wizard';
 import { PlanningBlueprint, PlanningHandlers } from '../planning';
-import { AgentWizardHandlers, SyncTriggers } from '../project-wizard';
 import AgentBlueprintDef from './blueprint';
-import { AgentWorker, AgentBlueprintHandlers } from './functions';
+import { AgentBlueprintHandlers } from './operations';
+import { AgentWorker } from './operations/definitions';
 
-ObjectId.dangerouslyDisableRandomness();
+EntityId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayerWithTriggers({
   aiServicePreset: 'edge-remote',
@@ -75,8 +73,8 @@ describe('Agent', () => {
       function* (_) {
         const agent = yield* Agent.makeInitialized(
           {
-            name: 'Test Project',
-            instructions: 'A test project for adding artifacts.',
+            name: 'Test Agent',
+            instructions: 'A test agent for adding artifacts.',
             blueprints: [Ref.make(MarkdownBlueprint.make())],
           },
           blueprint,
@@ -86,7 +84,7 @@ describe('Agent', () => {
         const document = yield* Database.add(
           Obj.make(Markdown.Document, {
             name: 'Test Document',
-            content: Ref.make(Text.make('This is a test document with some content.')),
+            content: Ref.make(Text.make({ content: 'This is a test document with some content.' })),
           }),
         );
         yield* Database.flush();
@@ -96,14 +94,16 @@ describe('Agent', () => {
         const chatFeed = agent.chat?.target?.feed?.target;
         invariant(chatFeed, 'Agent chat feed not found.');
         const runtime = yield* Effect.runtime<Feed.FeedService>();
-        const session = yield* acquireReleaseResource(() => new AiSession({ feed: chatFeed, runtime }));
+        const session = yield* EffectEx.acquireReleaseResource(
+          () => new AiSession.Session({ feed: chatFeed, runtime }),
+        );
         yield* Effect.promise(() => session.context.open());
 
-        const documentDxn = Obj.getDXN(document);
+        const documentUri = Obj.getURI(document);
         yield* session
           .createRequest({
             system: SYSTEM,
-            prompt: `Please add the document ${documentDxn} as an artifact named "My Test Document" to this agent.`,
+            prompt: `Please add the document ${documentUri} as an artifact named "My Test Document" to this agent.`,
           })
           .pipe(Effect.provide(session.makeToolExecutionServices()));
 
@@ -134,7 +134,9 @@ describe('Agent', () => {
         invariant(chatFeed, 'Agent chat feed not found.');
         yield* Database.flush();
         const runtime = yield* Effect.runtime<Feed.FeedService>();
-        const session = yield* acquireReleaseResource(() => new AiSession({ feed: chatFeed, runtime }));
+        const session = yield* EffectEx.acquireReleaseResource(
+          () => new AiSession.Session({ feed: chatFeed, runtime }),
+        );
         yield* Effect.promise(() => session.context.open());
 
         yield* session
@@ -175,11 +177,11 @@ describe('Agent', () => {
         );
         yield* Database.flush();
 
-        const inboxQueue = yield* QueueService.createQueue();
+        const inboxFeed = yield* Database.add(Feed.make());
         yield* Database.add(
           Trigger.make({
             enabled: true,
-            spec: Trigger.specQueue(inboxQueue.dxn.toString()),
+            spec: Trigger.specFeed(inboxFeed),
             function: Ref.make(Operation.serialize(AgentWorker)),
             input: {
               agent: Ref.make(agent),
@@ -188,13 +190,13 @@ describe('Agent', () => {
           }),
         );
 
-        yield* QueueService.append(
-          inboxQueue,
+        yield* Feed.append(
+          inboxFeed,
           TEST_MESSAGES.map((message) => Obj.clone(message)),
         );
 
         const dispatcher = yield* TriggerDispatcher;
-        const invocations = yield* dispatcher.invokeScheduledTriggers({ kinds: ['queue'], untilExhausted: true });
+        const invocations = yield* dispatcher.invokeScheduledTriggers({ kinds: ['feed'], untilExhausted: true });
         expect(invocations.every((invocation) => Exit.isSuccess(invocation.result))).toBe(true);
 
         console.log(yield* Effect.promise(() => dumpAgent(agent)));
@@ -222,11 +224,11 @@ describe('Agent', () => {
         );
         yield* Database.flush();
 
-        yield* Operation.invoke(SyncTriggers, { agent: Ref.make(agent) });
+        yield* Operation.invoke(AgentWizardOperations.SyncTriggers, { agent: Ref.make(agent) });
 
-        const triggers = yield* Database.runQuery(
+        const triggers = yield* Database.query(
           Query.select(Filter.type(Trigger.Trigger)).debugLabel('assistant-toolkit.blueprint.test.timer'),
-        );
+        ).run;
         const timerTriggers = triggers.filter(
           (trigger) => trigger.spec?.kind === 'timer' && trigger.spec.cron === cron,
         );
@@ -241,7 +243,7 @@ describe('Agent', () => {
         invariant(timerTrigger.function);
         const operation = yield* Database.load(timerTrigger.function);
         invariant(Obj.instanceOf(Operation.PersistentOperation, operation));
-        expect(operation.key).toBe(AgentWorker.meta.key);
+        expect(Obj.getMeta(operation).key).toBe(AgentWorker.meta.key);
       },
       Effect.provide(TestLayer),
       TestHelpers.provideTestContext,
@@ -287,7 +289,9 @@ describe('Agent', () => {
         invariant(chatFeed, 'Agent chat feed not found.');
         yield* Database.flush();
         const runtime = yield* Effect.runtime<Feed.FeedService>();
-        const session = yield* acquireReleaseResource(() => new AiSession({ feed: chatFeed, runtime }));
+        const session = yield* EffectEx.acquireReleaseResource(
+          () => new AiSession.Session({ feed: chatFeed, runtime }),
+        );
         yield* Effect.promise(() => session.context.open());
 
         yield* session
@@ -322,22 +326,22 @@ describe('Agent', () => {
         );
         yield* Database.flush();
 
-        yield* Operation.invoke(SyncTriggers, { agent: Ref.make(agent) });
+        yield* Operation.invoke(AgentWizardOperations.SyncTriggers, { agent: Ref.make(agent) });
 
-        const triggers = yield* Database.runQuery(
+        const triggers = yield* Database.query(
           Query.select(Filter.type(Trigger.Trigger)).debugLabel('assistant-toolkit.blueprint.test.toggle-enabled'),
-        );
+        ).run;
         expect(triggers.every((trigger) => trigger.enabled === false)).toBe(true);
 
         Obj.update(agent, (agent) => {
           agent.enabled = true;
         });
         yield* Database.flush();
-        yield* Operation.invoke(SyncTriggers, { agent: Ref.make(agent) });
+        yield* Operation.invoke(AgentWizardOperations.SyncTriggers, { agent: Ref.make(agent) });
 
-        const triggersAfter = yield* Database.runQuery(
+        const triggersAfter = yield* Database.query(
           Query.select(Filter.type(Trigger.Trigger)).debugLabel('assistant-toolkit.blueprint.test.after'),
-        );
+        ).run;
         expect(triggersAfter).toHaveLength(triggers.length);
         expect(triggersAfter.every((trigger) => trigger.enabled === true)).toBe(true);
       },

package/src/blueprints/{project → agent}/blueprint.ts

@@ -5,7 +5,7 @@
 import { Blueprint, Template } from '@dxos/compute';
 import { trim } from '@dxos/util';
 
-import { AddArtifact } from './functions';
+import { AddArtifact } from './operations/definitions';
 
 const BLUEPRINT_KEY = 'org.dxos.blueprint.agent';
 
@@ -48,8 +48,8 @@ const make = () =>
       inputs: [
         {
           name: 'agent',
-          kind: 'function',
-          function: 'org.dxos.function.agent.get-context',
+          kind: 'operation',
+          operation: 'org.dxos.function.agent.getContext',
         },
       ],
     }),

package/src/blueprints/agent/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as AgentBlueprint } from './blueprint';
+export { AgentBlueprintHandlers, AgentBlueprintOperations } from './operations';

package/src/blueprints/{project/functions → agent/operations}/add-artifact.ts

@@ -5,7 +5,6 @@
 import * as Effect from 'effect/Effect';
 
 import { Operation } from '@dxos/compute';
-import { Database, Obj } from '@dxos/echo';
 
 import { Agent } from '../../../types';
 import { AddArtifact } from './definitions';
@@ -13,18 +12,9 @@ import { AddArtifact } from './definitions';
 export default AddArtifact.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* ({ name, artifact }) {
-      if (!(yield* Database.load(artifact))) {
-        throw new Error('Artifact not found.');
-      }
-
       const agent = yield* Agent.getFromChatContext;
-
-      Obj.update(agent, (agent) => {
-        agent.artifacts.push({
-          name,
-          data: artifact,
-        });
-      });
-    }) as any,
+      yield* Agent.addArtifact(agent, { name, id: artifact });
+    }),
   ),
+  Operation.opaqueHandler,
 );

package/src/blueprints/{project/functions → agent/operations}/agent.ts

@@ -9,7 +9,7 @@ import { AiService } from '@dxos/ai';
 import { AiSession, ToolExecutionServices } from '@dxos/assistant';
 import { Operation } from '@dxos/compute';
 import { Database, Feed, Obj } from '@dxos/echo';
-import { acquireReleaseResource } from '@dxos/effect';
+import { EffectEx } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 import { ContentBlock } from '@dxos/types';
 
@@ -20,7 +20,7 @@ export default AgentWorker.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* ({ agent: agentRef, prompt, event }) {
       const agent = yield* Database.load(agentRef).pipe(
-        Effect.catchTag('ObjectNotFoundError', () => Effect.die(new Error('Unable to load agent object.'))),
+        Effect.catchTag('EntityNotFoundError', () => Effect.die(new Error('Unable to load agent object.'))),
       );
       invariant(Obj.instanceOf(Agent.Agent, agent));
       invariant(agent.chat, 'Agent has no chat.');
@@ -28,11 +28,11 @@ export default AgentWorker.pipe(
       const chatFeed = yield* agent.chat.pipe(
         Database.load,
         Effect.flatMap((chat) => Database.load(chat.feed)),
-        Effect.catchTag('ObjectNotFoundError', () => Effect.die(new Error('Unable to load agent chat feed object.'))),
+        Effect.catchTag('EntityNotFoundError', () => Effect.die(new Error('Unable to load agent chat feed object.'))),
       );
       invariant(chatFeed, 'Agent chat feed not found.');
       const runtime = yield* Effect.runtime<Feed.FeedService>();
-      const session = yield* acquireReleaseResource(() => new AiSession({ feed: chatFeed, runtime }));
+      const session = yield* EffectEx.acquireReleaseResource(() => new AiSession.Session({ feed: chatFeed, runtime }));
 
       const agentsInContext = session.context.getObjects().filter(Obj.instanceOf(Agent.Agent));
       if (agentsInContext.length !== 1) {
@@ -57,8 +57,8 @@ export default AgentWorker.pipe(
         })
         .pipe(
           Effect.provide(
-            Layer.mergeAll(AiService.model('@anthropic/claude-opus-4-6'), ToolExecutionServices).pipe(
-              Layer.provideMerge(Operation.withInvocationOptions({ conversation: Obj.getDXN(chatFeed).toString() })),
+            Layer.mergeAll(AiService.model('ai.claude.model.claude-opus-4-6'), ToolExecutionServices).pipe(
+              Layer.provideMerge(Operation.withInvocationOptions({ conversation: Obj.getURI(chatFeed) })),
             ),
           ),
           Effect.retry({ times: 2 }),

package/src/blueprints/{project/functions → agent/operations}/definitions.ts

@@ -5,18 +5,19 @@
 import * as Schema from 'effect/Schema';
 
 import { AiService, OpaqueToolkit } from '@dxos/ai';
-import { AiContextService } from '@dxos/assistant';
-import { QueueService, Trace, TriggerEvent } from '@dxos/compute';
-import { Operation, OperationRegistry } from '@dxos/compute';
-import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { AiContext } from '@dxos/assistant';
+import { Trace, TriggerEvent, Operation } from '@dxos/compute';
+import { Database, Feed, Ref, Registry } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
 
 import { Agent } from '../../../types';
 
 export const AgentWorker = Operation.make({
   meta: {
-    key: 'org.dxos.function.agent.worker',
+    key: DXN.make('org.dxos.function.agent.worker'),
     name: 'Agent Worker',
     description: 'Agentic worker that drives the agent autonomously.',
+    icon: 'ph--brain--regular',
   },
   input: Schema.Struct({
     agent: Schema.suspend(() => Ref.Ref(Agent.Agent)),
@@ -27,9 +28,8 @@ export const AgentWorker = Operation.make({
   services: [
     AiService.AiService,
     Database.Service,
-    QueueService,
     Feed.FeedService,
-    OperationRegistry.Service,
+    Registry.Service,
     Trace.TraceService,
     OpaqueToolkit.OpaqueToolkitProvider,
   ],
@@ -37,24 +37,26 @@ export const AgentWorker = Operation.make({
 
 export const Qualifier = Operation.make({
   meta: {
-    key: 'org.dxos.function.agent.qualifier',
+    key: DXN.make('org.dxos.function.agent.qualifier'),
     name: 'Agent Qualifier',
     description:
       'Qualifier that determines if the event is relevant to the agent. Puts the data into the input queue of the agent.',
+    icon: 'ph--funnel--regular',
   },
   input: Schema.Struct({
     agent: Schema.suspend(() => Ref.Ref(Agent.Agent)),
     event: TriggerEvent.TriggerEvent,
   }),
   output: Schema.Void,
-  services: [AiService.AiService, Database.Service],
+  services: [AiService.AiService, Database.Service, Feed.FeedService],
 });
 
 export const GetContext = Operation.make({
   meta: {
-    key: 'org.dxos.function.agent.get-context',
+    key: DXN.make('org.dxos.function.agent.getContext'),
     name: 'Get Agent Context',
     description: 'Get the context of an agent.',
+    icon: 'ph--info--regular',
   },
   input: Schema.Struct({}),
   output: Schema.Struct({
@@ -70,23 +72,25 @@ export const GetContext = Operation.make({
       }),
     ),
   }),
-  services: [AiContextService, Database.Service],
+  services: [AiContext.Service, Database.Service],
 });
 
 export const AddArtifact = Operation.make({
   meta: {
-    key: 'org.dxos.function.agent.add-artifact',
+    key: DXN.make('org.dxos.function.agent.addArtifact'),
     name: 'Add artifact',
     description: 'Adds a new artifact.',
+    icon: 'ph--plus--regular',
   },
   input: Schema.Struct({
     name: Schema.String.annotations({
       description: 'The name of the artifact to add.',
     }),
-    artifact: Ref.Ref(Obj.Unknown).annotations({
-      description: 'The artifact to add. Do NOT guess or try to generate the ID.',
+    artifact: Schema.String.annotations({
+      description:
+        'The id of the artifact to add, exactly as returned by the tool that created it. Do NOT guess or generate the id.',
     }),
   }),
   output: Schema.Void,
-  services: [AiContextService, Database.Service],
+  services: [AiContext.Service, Database.Service],
 });

package/src/blueprints/{project/functions → agent/operations}/get-context.ts

@@ -4,6 +4,7 @@
 
 import * as Effect from 'effect/Effect';
 
+import { AiContext } from '@dxos/assistant';
 import { Operation } from '@dxos/compute';
 import { Database, Obj } from '@dxos/echo';
 
@@ -13,19 +14,29 @@ import { GetContext } from './definitions';
 export default GetContext.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* () {
-      const agent = yield* Agent.getFromChatContext;
+      // This runs unconditionally during system-prompt formatting. A delegated sub-agent has no
+      // agent bound to its context, so degrade gracefully for the zero-agent case — but still
+      // surface the "more than one agent" invariant rather than masking every failure.
+      const agents = yield* AiContext.Service.findObjects(Agent.Agent);
+      if (agents.length === 0) {
+        return { id: '', name: '', instructions: 'No agent context.', plan: 'No plan found.', artifacts: [] };
+      }
+      if (agents.length > 1) {
+        return yield* Effect.fail(new Error(`There should be exactly one agent in context. Got: ${agents.length}`));
+      }
+      const agent = agents[0];
 
       return {
         id: agent.id,
         name: agent.name,
         instructions: yield* agent.instructions.pipe(Database.load).pipe(
           Effect.map((_) => _.content),
-          Effect.catchTag('ObjectNotFoundError', () => Effect.succeed('No instructions found.')),
+          Effect.catchTag('EntityNotFoundError', () => Effect.succeed('No instructions found.')),
         ),
         plan: yield* (
           agent.plan?.pipe(Database.load).pipe(
             Effect.map(Plan.formatPlan),
-            Effect.catchTag('ObjectNotFoundError', () => Effect.succeed('No plan found.')),
+            Effect.catchTag('EntityNotFoundError', () => Effect.succeed('No plan found.')),
           ) ?? Effect.succeed('No plan found.')
         ),
         artifacts: yield* Effect.forEach(agent.artifacts, (artifact) =>
@@ -34,13 +45,14 @@ export default GetContext.pipe(
               name: artifact.name,
               type: yield* Database.load(artifact.data).pipe(
                 Effect.map(Obj.getTypename),
-                Effect.catchTag('ObjectNotFoundError', () => Effect.succeed('Artifact not found.')),
+                Effect.catchTag('EntityNotFoundError', () => Effect.succeed('Artifact not found.')),
               ),
-              dxn: artifact.data.dxn.toString(),
+              dxn: artifact.data.uri,
             };
           }),
         ),
       };
     }) as any,
   ),
+  Operation.opaqueHandler,
 );

package/src/blueprints/{project/functions → agent/operations}/index.ts

@@ -4,7 +4,7 @@
 
 import { OperationHandlerSet } from '@dxos/compute';
 
-export * from './definitions';
+export * as AgentBlueprintOperations from './definitions';
 
 export const AgentBlueprintHandlers = OperationHandlerSet.lazy(
   () => import('./add-artifact'),

package/src/blueprints/{project/functions → agent/operations}/qualifier.ts

@@ -9,14 +9,14 @@ import * as Schema from 'effect/Schema';
 
 import { AiService } from '@dxos/ai';
 import { Operation } from '@dxos/compute';
-import { Database, Obj, Ref } from '@dxos/echo';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { trim } from '@dxos/util';
 
 import { Plan, Agent } from '../../../types';
 import { Qualifier } from './definitions';
 
-export default Qualifier.pipe(
+const handler: Operation.WithHandler<typeof Qualifier> = Qualifier.pipe(
   Operation.withHandler(
     Effect.fnUntraced(
       function* ({ agent: agentRef, event }) {
@@ -24,7 +24,7 @@ export default Qualifier.pipe(
         invariant(Obj.instanceOf(Agent.Agent, agent));
         invariant(agent.chat, 'Agent has no chat.');
 
-        const { id, name, queue } = agent;
+        const { id, name, feed: queue } = agent;
         if (!queue) {
           throw new Error('Agent has no queue.');
         }
@@ -72,19 +72,20 @@ export default Qualifier.pipe(
         const { isRelevant } = value as { isRelevant: boolean };
 
         if (isRelevant) {
-          const queueTarget = yield* Database.load(queue);
-          if ('queue' in event && event.item) {
+          const feedTarget = yield* Database.load(queue);
+          if ('feed' in event && event.item) {
             const obj = event.item;
-            yield* Effect.promise(() => queueTarget.append([obj]));
+            yield* Feed.append(feedTarget, [obj]);
           } else if ('subject' in event && Ref.isRef(event.subject)) {
             const obj = yield* Database.load(event.subject);
-            yield* Effect.promise(() => queueTarget.append([obj]));
+            yield* Feed.append(feedTarget, [obj]);
           } else {
             throw new Error('Invalid event.');
           }
         }
       },
-      Effect.provide(AiService.model('@anthropic/claude-sonnet-4-5')),
+      Effect.provide(AiService.model('ai.claude.model.claude-sonnet-4-5')),
     ),
   ),
 );
+export default handler;

package/src/blueprints/{project-wizard → agent-wizard}/blueprint.ts

@@ -5,9 +5,9 @@
 import { Blueprint, Template } from '@dxos/compute';
 import { trim } from '@dxos/util';
 
-import { AgentRules, CreateAgent, SyncTriggers } from './functions';
+import { AgentRules, CreateAgent, SyncTriggers } from './operations/definitions';
 
-const BLUEPRINT_KEY = 'org.dxos.blueprint.agent-wizard';
+const BLUEPRINT_KEY = 'org.dxos.blueprint.agentWizard';
 
 /**
  * Creates the Agent Wizard blueprint. This is a function to avoid circular dependency issues.

package/src/blueprints/{project-wizard → agent-wizard}/index.ts

@@ -3,4 +3,4 @@
 //
 
 export { default as AgentWizardBlueprint } from './blueprint';
-export { AgentRules, CreateAgent, SyncTriggers, AgentWizardHandlers } from './functions';
+export { AgentWizardHandlers, AgentWizardOperations } from './operations';

package/src/blueprints/{project-wizard/functions/create-project.ts → agent-wizard/operations/create-agent.ts}

@@ -4,12 +4,11 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Blueprint } from '@dxos/compute';
-import { Operation } from '@dxos/compute';
+import { Blueprint, Operation } from '@dxos/compute';
 import { Obj, Ref } from '@dxos/echo';
 
 import { Agent } from '../../../types';
-import { AgentBlueprint } from '../../project';
+import { AgentBlueprint } from '../../agent';
 import { CreateAgent, SyncTriggers } from './definitions';
 
 export default CreateAgent.pipe(

package/src/blueprints/{project-wizard/functions → agent-wizard/operations}/definitions.ts

@@ -4,18 +4,18 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Blueprint } from '@dxos/compute';
-import { QueueService } from '@dxos/compute';
 import { Operation } from '@dxos/compute';
-import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { Database, Feed, Obj, Ref, Registry, Type } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
 
 import { Agent } from '../../../types';
 
 export const AgentRules = Operation.make({
   meta: {
-    key: 'org.dxos.function.agent-wizard.agent-rules',
+    key: DXN.make('org.dxos.function.agentWizard.agentRules'),
     name: 'Agent rules',
     description: 'Gets the rules for creating an agent.',
+    icon: 'ph--book-open--regular',
   },
   input: Schema.Struct({}),
   output: Schema.String,
@@ -23,9 +23,10 @@ export const AgentRules = Operation.make({
 
 export const CreateAgent = Operation.make({
   meta: {
-    key: 'org.dxos.function.agent-wizard.create-agent',
+    key: DXN.make('org.dxos.function.agentWizard.createAgent'),
     name: 'Create agent',
     description: 'Creates a new agent.',
+    icon: 'ph--brain--regular',
   },
   input: Schema.Struct({
     name: Schema.String.annotations({
@@ -43,16 +44,17 @@ export const CreateAgent = Operation.make({
       description: 'The objects to subscribe to for the agent. Can be references to mailboxes.',
     }),
   }),
-  output: Agent.Agent,
-  services: [Blueprint.RegistryService, Database.Service, QueueService, Feed.FeedService],
+  output: Type.getSchema(Agent.Agent),
+  services: [Registry.Service, Database.Service, Feed.FeedService],
 });
 
 export const SyncTriggers = Operation.make({
   meta: {
-    key: 'org.dxos.function.agent.sync-triggers',
+    key: DXN.make('org.dxos.function.agent.syncTriggers'),
     name: 'Sync triggers',
     description:
       'Synchronizes triggers with the agent: subscriptions, cron, filter-events, and enabled (copied to every trigger). Call after editing those fields.',
+    icon: 'ph--arrows-clockwise--regular',
   },
   input: Schema.Struct({
     agent: Ref.Ref(Agent.Agent).annotations({

package/src/blueprints/{project-wizard/functions → agent-wizard/operations}/index.ts

@@ -4,10 +4,10 @@
 
 import { OperationHandlerSet } from '@dxos/compute';
 
-export * from './definitions';
+export * as AgentWizardOperations from './definitions';
 
 export const AgentWizardHandlers = OperationHandlerSet.lazy(
-  () => import('./create-project'),
-  () => import('./project-rules'),
+  () => import('./create-agent'),
+  () => import('./agent-rules'),
   () => import('./sync-triggers'),
 );