@dxos/assistant-toolkit 0.8.4-main.3fbcb4aa9b → 0.8.4-main.43cb759274

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

@@ -10,15 +10,13 @@ import { MemoizedAiService } from '@dxos/ai/testing';
 import { AiSession } from '@dxos/assistant';
 import { SpaceProperties } from '@dxos/client-protocol';
 import { Blueprint, Trigger, Operation, OperationHandlerSet } from '@dxos/compute';
-import { Database, Feed, Filter, Obj, Query, Ref } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
+import { Collection, Database, Feed, Filter, Obj, Query, Ref } from '@dxos/echo';
 import { acquireReleaseResource } from '@dxos/effect';
 import { TestHelpers } from '@dxos/effect/testing';
-import { QueueService } from '@dxos/functions';
 import { TriggerDispatcher } from '@dxos/functions-runtime';
 import { AssistantTestLayerWithTriggers } from '@dxos/functions-runtime/testing';
 import { invariant } from '@dxos/invariant';
-import { ObjectId } from '@dxos/keys';
+import { EntityId } from '@dxos/keys';
 import { MarkdownBlueprint } from '@dxos/plugin-markdown';
 import { Markdown } from '@dxos/plugin-markdown';
 import { MarkdownOperationHandlerSet } from '@dxos/plugin-markdown/plugin';
@@ -33,7 +31,7 @@ import { AgentWizardHandlers, SyncTriggers } from '../project-wizard';
 import AgentBlueprintDef from './blueprint';
 import { AgentWorker, AgentBlueprintHandlers } from './functions';
 
-ObjectId.dangerouslyDisableRandomness();
+EntityId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayerWithTriggers({
   aiServicePreset: 'edge-remote',
@@ -95,14 +93,14 @@ 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* 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()));
 
@@ -133,7 +131,7 @@ 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* acquireReleaseResource(() => new AiSession.Session({ feed: chatFeed, runtime }));
         yield* Effect.promise(() => session.context.open());
 
         yield* session
@@ -174,11 +172,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),
@@ -187,13 +185,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)));
@@ -240,7 +238,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,
@@ -286,7 +284,7 @@ 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* acquireReleaseResource(() => new AiSession.Session({ feed: chatFeed, runtime }));
         yield* Effect.promise(() => session.context.open());
 
         yield* session

package/src/blueprints/project/blueprint.ts

@@ -49,7 +49,7 @@ const make = () =>
         {
           name: 'agent',
           kind: 'operation',
-          operation: 'org.dxos.function.agent.get-context',
+          operation: 'org.dxos.function.agent.getContext',
         },
       ],
     }),

package/src/blueprints/project/functions/add-artifact.ts

@@ -27,4 +27,5 @@ export default AddArtifact.pipe(
       });
     }) as any,
   ),
+  Operation.opaqueHandler,
 );

package/src/blueprints/project/functions/agent.ts

@@ -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* acquireReleaseResource(() => new AiSession.Session({ feed: chatFeed, runtime }));
 
       const agentsInContext = session.context.getObjects().filter(Obj.instanceOf(Agent.Agent));
       if (agentsInContext.length !== 1) {
@@ -58,7 +58,7 @@ 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.provideMerge(Operation.withInvocationOptions({ conversation: Obj.getURI(chatFeed) })),
             ),
           ),
           Effect.retry({ times: 2 }),

package/src/blueprints/project/functions/definitions.ts

@@ -5,18 +5,19 @@
 import * as Schema from 'effect/Schema';
 
 import { AiService, OpaqueToolkit } from '@dxos/ai';
-import { AiContextService } from '@dxos/assistant';
+import { AiContext } from '@dxos/assistant';
 import { Trace, TriggerEvent, Operation, OperationRegistry } from '@dxos/compute';
 import { Database, Feed, Obj, Ref } from '@dxos/echo';
-import { QueueService } from '@dxos/functions';
+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,34 +28,35 @@ export const AgentWorker = Operation.make({
   services: [
     AiService.AiService,
     Database.Service,
-    QueueService,
     Feed.FeedService,
     OperationRegistry.Service,
     Trace.TraceService,
     OpaqueToolkit.OpaqueToolkitProvider,
   ],
-}).pipe(Operation.intrinsic);
+});
 
 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],
-}).pipe(Operation.intrinsic);
+  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,14 +72,15 @@ export const GetContext = Operation.make({
       }),
     ),
   }),
-  services: [AiContextService, Database.Service],
-}).pipe(Operation.intrinsic);
+  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({
@@ -88,5 +91,5 @@ export const AddArtifact = Operation.make({
     }),
   }),
   output: Schema.Void,
-  services: [AiContextService, Database.Service],
-}).pipe(Operation.intrinsic);
+  services: [AiContext.Service, Database.Service],
+});

package/src/blueprints/project/functions/get-context.ts

@@ -20,12 +20,12 @@ export default GetContext.pipe(
         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 +34,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/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,13 +72,13 @@ 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.');
           }
@@ -88,3 +88,4 @@ export default Qualifier.pipe(
     ),
   ),
 );
+export default handler;

package/src/blueprints/project-wizard/blueprint.ts

@@ -7,7 +7,7 @@ import { trim } from '@dxos/util';
 
 import { AgentRules, CreateAgent, SyncTriggers } from './functions';
 
-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/functions/definitions.ts

@@ -4,17 +4,18 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Blueprint, Operation } from '@dxos/compute';
-import { Database, Feed, Obj, Ref } from '@dxos/echo';
-import { QueueService } from '@dxos/functions';
+import { Operation } from '@dxos/compute';
+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,
@@ -22,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({
@@ -42,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/sync-triggers.ts

@@ -6,7 +6,7 @@ import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
 import { Trigger, Operation } from '@dxos/compute';
-import { Database, Feed, Filter, Obj, Ref } from '@dxos/echo';
+import { Database, Feed, Filter, Obj, Ref, Type } from '@dxos/echo';
 import { FeedAnnotation } from '@dxos/schema';
 
 import { Agent } from '../../../types';
@@ -22,7 +22,7 @@ export default SyncTriggers.pipe(
 );
 
 /**
- * Foreign key {@link AGENT_TRIGGER_EXTENSION_KEY} => <agent id : ObjectId>.
+ * Foreign key {@link AGENT_TRIGGER_EXTENSION_KEY} => <agent id : EntityId>.
  */
 const AGENT_TRIGGER_EXTENSION_KEY = 'org.dxos.extension.AgentTrigger';
 
@@ -33,11 +33,11 @@ const AGENT_TRIGGER_TARGET_EXTENSION_KEY = 'org.dxos.extension.AgentTriggerTarge
 
 /** Checks if an object's schema has the FeedAnnotation. */
 const hasFeedAnnotation = (obj: Obj.Unknown): boolean => {
-  const schema = Obj.getSchema(obj);
-  if (!schema) {
+  const type = Obj.getType(obj);
+  if (!type) {
     return false;
   }
-  const annotation = FeedAnnotation.get(schema);
+  const annotation = FeedAnnotation.get(Type.getSchema(type));
   return Option.isSome(annotation) && annotation.value === true;
 };
 
@@ -76,12 +76,7 @@ const syncAgentTriggers = (agent: Agent.Agent): Effect.Effect<void, never, Datab
         feedObj = feedRef ? Option.getOrUndefined(yield* Database.loadOption(feedRef)) : undefined;
       }
 
-      const queueDxn = Option.fromNullable(feedObj).pipe(
-        Option.filter(Obj.instanceOf(Feed.Feed)),
-        Option.map(Feed.getQueueDxn),
-        Option.getOrUndefined,
-      );
-      if (!queueDxn) {
+      if (!feedObj || !Obj.instanceOf(Feed.Feed, feedObj) || !Feed.getQueueUri(feedObj)) {
         continue;
       }
 
@@ -93,11 +88,11 @@ const syncAgentTriggers = (agent: Agent.Agent): Effect.Effect<void, never, Datab
           [Obj.Meta]: {
             keys: [
               { source: AGENT_TRIGGER_EXTENSION_KEY, id: agent.id },
-              { source: AGENT_TRIGGER_TARGET_EXTENSION_KEY, id: subscription.dxn.toString() },
+              { source: AGENT_TRIGGER_TARGET_EXTENSION_KEY, id: subscription.uri },
             ],
           },
           enabled: triggersEnabled,
-          spec: Trigger.specQueue(queueDxn.toString()),
+          spec: Trigger.specFeed(feedObj),
           function: Ref.make(Operation.serialize(filterEvents ? Qualifier : AgentWorker)),
           input: {
             agent: Ref.make(agent),
@@ -108,28 +103,31 @@ const syncAgentTriggers = (agent: Agent.Agent): Effect.Effect<void, never, Datab
       );
     }
 
-    if ((agent.filterEvents ?? true) && agent.queue) {
-      yield* Database.add(
-        Trigger.make({
-          [Obj.Parent]: agent,
-          [Obj.Meta]: {
-            keys: [
-              { source: AGENT_TRIGGER_EXTENSION_KEY, id: agent.id },
-              {
-                source: AGENT_TRIGGER_TARGET_EXTENSION_KEY,
-                id: Obj.getDXN(agent)?.toString() ?? '',
-              },
-            ],
-          },
-          function: Ref.make(Operation.serialize(AgentWorker)),
-          enabled: triggersEnabled,
-          spec: Trigger.specQueue(agent.queue.dxn.toString()),
-          input: {
-            agent: Ref.make(agent),
-            event: '{{event}}',
-          },
-        }),
-      );
+    if ((agent.filterEvents ?? true) && agent.feed) {
+      const agentFeedOption = yield* Database.loadOption(agent.feed);
+      if (Option.isSome(agentFeedOption) && Feed.getQueueUri(agentFeedOption.value)) {
+        yield* Database.add(
+          Trigger.make({
+            [Obj.Parent]: agent,
+            [Obj.Meta]: {
+              keys: [
+                { source: AGENT_TRIGGER_EXTENSION_KEY, id: agent.id },
+                {
+                  source: AGENT_TRIGGER_TARGET_EXTENSION_KEY,
+                  id: Obj.getURI(agent) ?? '',
+                },
+              ],
+            },
+            function: Ref.make(Operation.serialize(AgentWorker)),
+            enabled: triggersEnabled,
+            spec: Trigger.specFeed(agentFeedOption.value),
+            input: {
+              agent: Ref.make(agent),
+              event: '{{event}}',
+            },
+          }),
+        );
+      }
     }
 
     // Timer trigger bypasses the qualifier and invokes the agent worker directly on a schedule.

package/src/blueprints/testing.ts

@@ -7,19 +7,25 @@ import * as Effect from 'effect/Effect';
 import { pipe } from 'effect/Function';
 
 import { ConsolePrinter } from '@dxos/ai';
-import { AiContextService, type AiSession, type AiSessionRunProps, GenerationObserver } from '@dxos/assistant';
+import { AiContext, AiRequest, AiSession, GenerationObserver } from '@dxos/assistant';
 import type { Blueprint } from '@dxos/compute';
 import { Database, Ref } from '@dxos/echo';
 import { log } from '@dxos/log';
 
-export type TestStep = Pick<AiSessionRunProps, 'prompt' | 'system'> & {
+export type TestStep = Pick<AiSession.RunProps, 'prompt' | 'system'> & {
   test?: () => Promise<void>;
 };
 
 /**
  * Runs the prompt steps, calling the test function after each step.
  */
-export const runSteps = Effect.fn(function* (session: AiSession, steps: TestStep[]) {
+export const runSteps: (
+  session: AiSession.Session,
+  steps: TestStep[],
+) => Effect.Effect<void, AiRequest.RunError, AiRequest.RunRequirements> = Effect.fn(function* (
+  session: AiSession.Session,
+  steps: TestStep[],
+) {
   for (const { test, ...props } of steps) {
     yield* session.createRequest({
       ...props,
@@ -38,7 +44,7 @@ export const runSteps = Effect.fn(function* (session: AiSession, steps: TestStep
  */
 // TODO(dmaretskyi): Potentially the agent will auto-bind the blueprints.
 export const addBlueprints = Effect.fnUntraced(function* (blueprints: Blueprint.Definition[]) {
-  yield* AiContextService.bindContext({
+  yield* AiContext.Service.bindContext({
     blueprints: yield* pipe(
       blueprints,
       Arr.map((blueprint) => blueprint.make()),