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

package/src/blueprints/database/{functions → operations}/schema-list.ts

@@ -4,29 +4,32 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Routine, Blueprint } from '@dxos/compute';
-import { Operation } from '@dxos/compute';
-import { Database, Feed, JsonSchema, Type, View } from '@dxos/echo';
+import { Routine, Blueprint, Operation } from '@dxos/compute';
+import { Database, Feed, Filter, JsonSchema, Query, Scope, Type, View } from '@dxos/echo';
 
 import { SchemaList } from './definitions';
 
 // TODO(dmaretskyi): This is a balance between not filling the agent's context with too many types and not excluding important types.
-const EXCLUDED_TYPES = [Type.PersistentType, View.View, Routine.Routine, Blueprint.Blueprint, Feed.Feed];
+const EXCLUDED_TYPES = [Type.Type, View.View, Routine.Routine, Blueprint.Blueprint, Feed.Feed];
 const excludedTypenames = EXCLUDED_TYPES.map((type) => Type.getTypename(type));
 
 export default SchemaList.pipe(
   Operation.withHandler(
     Effect.fn(function* () {
-      const { db } = yield* Database.Service;
-      const schema = yield* Effect.promise(() => db.schemaRegistry.query({ location: ['database', 'runtime'] }).run());
-      return schema
+      const types = yield* Database.query(Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry()))
+        .run;
+      return [...types]
         .filter((schema) => !excludedTypenames.includes(Type.getTypename(schema)))
+        .sort((a, b) => {
+          const aKey = `${Type.getTypename(a)}:${Type.getVersion(a)}`;
+          const bKey = `${Type.getTypename(b)}:${Type.getVersion(b)}`;
+          return aKey.localeCompare(bKey);
+        })
         .map((schema) => {
-          const meta = Type.getMeta(schema);
           return {
             typename: Type.getTypename(schema),
             jsonSchema: JsonSchema.toJsonSchema(schema),
-            kind: meta?.sourceSchema ? 'relation' : 'record',
+            kind: Type.isRelation(schema) ? 'relation' : 'record',
           };
         });
     }),

package/src/blueprints/database/{functions → operations}/tag-add.ts

@@ -5,7 +5,7 @@
 import * as Effect from 'effect/Effect';
 
 import { Operation } from '@dxos/compute';
-import { Database, Entity, Obj } from '@dxos/echo';
+import { Database, Entity } from '@dxos/echo';
 
 import { TagAdd } from './definitions';
 
@@ -13,8 +13,7 @@ export default TagAdd.pipe(
   Operation.withHandler(
     Effect.fn(function* ({ tag, obj }) {
       const object = yield* Database.load(obj);
-      const tagObj = yield* Database.load(tag);
-      Entity.update(object, (object) => Entity.addTag(object, Obj.getDXN(tagObj).toString()));
+      Entity.update(object, (object) => Entity.addTag(object, tag));
       return Entity.toJSON(object);
     }),
   ),

package/src/blueprints/database/{functions → operations}/tag-remove.ts

@@ -5,7 +5,7 @@
 import * as Effect from 'effect/Effect';
 
 import { Operation } from '@dxos/compute';
-import { Database, Entity, Obj } from '@dxos/echo';
+import { Database, Entity } from '@dxos/echo';
 
 import { TagRemove } from './definitions';
 
@@ -13,8 +13,7 @@ export default TagRemove.pipe(
   Operation.withHandler(
     Effect.fn(function* ({ tag, obj }) {
       const object = yield* Database.load(obj);
-      const tagObj = yield* Database.load(tag);
-      Entity.update(object, (object) => Entity.removeTag(object, Obj.getDXN(tagObj).toString()));
+      Entity.update(object, (object) => Entity.removeTag(object, tag));
       return Entity.toJSON(object);
     }),
   ),

package/src/blueprints/delegation/blueprint.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Blueprint } from '@dxos/compute';
+
+import { DelegateTask } from './operations/delegate-task';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.delegation';
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Delegation',
+    description: 'Delegates work to sub-agents and tracks it as plan tasks.',
+    tools: Blueprint.toolDefinitions({ operations: [DelegateTask] }),
+  });
+
+const blueprint: Blueprint.Definition = {
+  key: BLUEPRINT_KEY,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/delegation/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { default as DelegationBlueprint } from './blueprint';
+export { DelegationHandlers, DelegationOperations } from './operations';

package/src/blueprints/delegation/operations/delegate-task.test.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { Blueprint, Operation } from '@dxos/compute';
+import { Database, Feed, Obj } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
+import { invariant } from '@dxos/invariant';
+import { EntityId } from '@dxos/keys';
+
+import { Agent, Chat, Plan } from '../../../types';
+import DelegationBlueprint from '../blueprint';
+import { DelegateTask } from './delegate-task';
+import { DelegationHandlers } from './index';
+
+EntityId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  operationHandlers: DelegationHandlers,
+  types: [Agent.Agent, Plan.Plan, Chat.Chat, Chat.CompanionTo, Blueprint.Blueprint, Feed.Feed],
+  blueprints: [DelegationBlueprint.make()],
+  disableLlmMemoization: true,
+});
+
+describe('DelegateTask', () => {
+  it.scoped(
+    'adds an in-progress task to the agent plan for delegated work',
+    Effect.fnUntraced(
+      function* ({ expect }) {
+        const agent = yield* Agent.makeInitialized(
+          { name: 'Supervisor', instructions: 'Test.' },
+          DelegationBlueprint.make(),
+        );
+        yield* Database.flush();
+
+        const chatFeed = agent.chat?.target?.feed?.target;
+        invariant(chatFeed, 'Agent chat feed not found.');
+
+        yield* Operation.invoke(DelegateTask, { title: 'Research widgets' }).pipe(
+          Effect.provide(Operation.withInvocationOptions({ conversation: Obj.getURI(chatFeed) })),
+        );
+
+        const plan = yield* Database.load(agent.plan);
+        expect(plan.tasks).toHaveLength(1);
+        expect(plan.tasks[0]).toMatchObject({ title: 'Research widgets', status: 'in-progress' });
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

package/src/blueprints/delegation/operations/delegate-task.ts

@@ -0,0 +1,57 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { AiContext } from '@dxos/assistant';
+import { Operation } from '@dxos/compute';
+import { Database, Obj } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
+import { trim } from '@dxos/util';
+
+import { Agent, Plan } from '../../../types';
+
+export const DelegateTask = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.delegation.delegateTask'),
+    name: 'Delegate task',
+    description: trim`
+      Delegate a unit of work to a sub-agent. 
+      Records the work as an in-progress task on the plan and returns the updated plan. 
+      Use this to hand off work that can proceed in the background while you continue the conversation.
+    `,
+    icon: 'ph--share-network--regular',
+  },
+  input: Schema.Struct({
+    title: Schema.String.annotations({
+      description: 'Short title describing the work to delegate to a sub-agent.',
+    }),
+  }),
+  output: Schema.Any,
+  services: [AiContext.Service, Database.Service],
+});
+
+/**
+ * Records delegated work as an in-progress task on the current agent's plan.
+ */
+export default DelegateTask.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ title }) {
+      const agent = yield* Agent.getFromChatContext;
+      const plan = yield* Database.load(agent.plan);
+      Obj.update(plan, (plan) => {
+        // Mark as delegated so the supervisor's reconcile loop picks it up (and ordinary
+        // `update-tasks` tasks are NOT spawned as sub-agents).
+        Plan.addTasks(plan, [{ title, status: 'in-progress', delegated: true }]);
+      });
+      return trim`
+        Delegated work as an in-progress task. Current plan:
+        <plan>
+          ${Plan.formatPlan(plan)}
+        </plan>
+      `;
+    }),
+  ),
+);

package/src/blueprints/delegation/operations/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export * as DelegationOperations from './delegate-task';
+
+export const DelegationHandlers = OperationHandlerSet.lazy(() => import('./delegate-task'));

package/src/blueprints/discord/blueprint.ts

@@ -7,7 +7,7 @@ import { Ref } from '@dxos/echo';
 import { Text } from '@dxos/schema';
 import { trim } from '@dxos/util';
 
-import { FetchMessages } from './functions';
+import { FetchMessages } from './operations/definitions';
 
 const BLUEPRINT_KEY = 'org.dxos.blueprint.discord';
 
@@ -28,7 +28,7 @@ const make = () =>
     name: 'Discord',
     description: 'Discord integration.',
     instructions: {
-      source: Ref.make(Text.make(instructions)),
+      source: Ref.make(Text.make({ content: instructions })),
     },
     tools: Blueprint.toolDefinitions({ operations: [FetchMessages] }),
   });

package/src/blueprints/discord/index.ts

@@ -3,4 +3,4 @@
 //
 
 export { default as DiscordBlueprint } from './blueprint';
-export { FetchMessages, DiscordHandlers } from './functions';
+export { DiscordHandlers, DiscordOperations } from './operations';

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

@@ -4,8 +4,8 @@
 
 import * as Schema from 'effect/Schema';
 
-import { CredentialsService, Trace } from '@dxos/compute';
-import { Operation } from '@dxos/compute';
+import { Credential, Trace, Operation } from '@dxos/compute';
+import { DXN } from '@dxos/keys';
 
 // TODO(dmaretskyi): Extract.
 const TimeRangeSchema = Schema.String.pipe(Schema.pattern(/\d+(s|m|h|d)/)).annotations({
@@ -37,8 +37,9 @@ export const TimeRange = Object.assign(TimeRangeSchema, {
 
 export const FetchMessages = Operation.make({
   meta: {
-    key: 'org.dxos.function.fetch-discord-messages',
+    key: DXN.make('org.dxos.function.discord.fetchDiscordMessages'),
     name: 'Sync Discord messages',
+    icon: 'ph--hash--regular',
   },
   input: Schema.Struct({
     serverId: Schema.String.annotations({
@@ -67,5 +68,5 @@ export const FetchMessages = Operation.make({
     }),
   }),
   output: Schema.Any,
-  services: [CredentialsService, Trace.TraceService],
+  services: [Credential.CredentialsService, Trace.TraceService],
 });

package/src/blueprints/discord/{functions → operations}/fetch-messages.test.ts

@@ -8,9 +8,9 @@ import * as Config from 'effect/Config';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { CredentialsService } from '@dxos/compute';
 import { Operation, OperationHandlerSet } from '@dxos/compute';
 import { TestHelpers } from '@dxos/effect/testing';
+import { credentialsLayerConfig } from '@dxos/functions';
 import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 
 import { default as fetchMessages } from './fetch-messages';
@@ -20,13 +20,18 @@ const TestLayer = AssistantTestLayer({
 });
 
 const TestLayerWithCredentials = Layer.mergeAll(
-  CredentialsService.layerConfig([{ service: 'discord.com', apiKey: Config.redacted('DISCORD_TOKEN') }]),
+  credentialsLayerConfig([
+    {
+      service: 'discord.com',
+      apiKey: Config.redacted('DISCORD_TOKEN'),
+    },
+  ]),
   FetchHttpClient.layer,
 ).pipe(Layer.provideMerge(TestLayer));
 
 const DXOS_SERVER_ID = '837138313172353095';
 
-describe('Feed', { timeout: 600_000 }, () => {
+describe.skipIf(!process.env.DISCORD_TOKEN)('Feed', { timeout: 600_000 }, () => {
   it.effect(
     'fetch discord messages',
     Effect.fnUntraced(

package/src/blueprints/discord/{functions → operations}/fetch-messages.ts

@@ -17,8 +17,7 @@ import * as Function from 'effect/Function';
 import * as Layer from 'effect/Layer';
 import * as Option from 'effect/Option';
 
-import { CredentialsService, Trace } from '@dxos/compute';
-import { Operation } from '@dxos/compute';
+import { Credential, Trace, Operation } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
 import { Message } from '@dxos/types';
@@ -28,7 +27,7 @@ import { FetchMessages, TimeRange } from './definitions';
 const DiscordConfigFromCredential = Layer.unwrapEffect(
   Effect.gen(function* () {
     return DiscordConfig.layer({
-      token: yield* CredentialsService.getApiKey({ service: 'discord.com' }),
+      token: yield* Credential.CredentialsService.getApiKey({ service: 'discord.com' }),
       rest: {
         baseUrl: 'https://api-proxy.dxos.workers.dev/discord.com/api/v10',
       },

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

@@ -4,6 +4,6 @@
 
 import { OperationHandlerSet } from '@dxos/compute';
 
-export * from './definitions';
+export * as DiscordOperations from './definitions';
 
 export const DiscordHandlers = OperationHandlerSet.lazy(() => import('./fetch-messages'));

package/src/blueprints/github/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2026 DXOS.org
 //
 
-export { FetchPrs, GithubHandlers } from './functions';
+export { GithubHandlers, GithubOperations } from './operations';

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

@@ -5,14 +5,15 @@
 import * as HttpClient from '@effect/platform/HttpClient';
 import * as Schema from 'effect/Schema';
 
-import { CredentialsService } from '@dxos/compute';
-import { Operation } from '@dxos/compute';
+import { Credential, Operation } from '@dxos/compute';
+import { DXN } from '@dxos/keys';
 
 export const FetchPrs = Operation.make({
   meta: {
-    key: 'org.dxos.function.github.fetch-prs',
+    key: DXN.make('org.dxos.function.github.fetchPrs'),
     name: 'Fetch PRs',
     description: 'Fetches PRs from GitHub.',
+    icon: 'ph--github-logo--regular',
   },
   input: Schema.Struct({
     owner: Schema.String.annotations({
@@ -23,5 +24,5 @@ export const FetchPrs = Operation.make({
     }),
   }),
   output: Schema.Any,
-  services: [CredentialsService, HttpClient.HttpClient],
+  services: [Credential.CredentialsService, HttpClient.HttpClient],
 });

package/src/blueprints/github/{functions → operations}/fetch-prs.ts

@@ -5,15 +5,15 @@
 import * as HttpClient from '@effect/platform/HttpClient';
 import * as Effect from 'effect/Effect';
 
-import { CredentialsService, withAuthorization } from '@dxos/compute';
-import { Operation } from '@dxos/compute';
+import { Credential, Operation } from '@dxos/compute';
+import { withAuthorization } from '@dxos/functions';
 
 import { FetchPrs } from './definitions';
 
 export default FetchPrs.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* ({ owner, repo }) {
-      const credential = yield* CredentialsService.getCredential({ service: 'github.com' });
+      const credential = yield* Credential.CredentialsService.getCredential({ service: 'github.com' });
       const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(credential.apiKey!)));
 
       const response = yield* client.get(`https://api.github.com/repos/${owner}/${repo}/pulls`);

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

@@ -4,6 +4,6 @@
 
 import { OperationHandlerSet } from '@dxos/compute';
 
-export * from './definitions';
+export * as GithubOperations from './definitions';
 
 export const GithubHandlers = OperationHandlerSet.lazy(() => import('./fetch-prs'));

package/src/blueprints/index.ts

@@ -2,14 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './agent';
+export * from './agent-wizard';
+export * from './automation';
+export * from './blueprint-manager';
+export * from './browser';
+export * from './database';
+export * from './delegation';
 export * from './discord';
-export * from './project';
 export * from './linear';
+export * from './memory';
 export * from './planning';
 export * from './websearch';
-export * from './browser';
-export * from './database';
-export * from './memory';
-export * from './automation';
-export * from './blueprint-manager';
-export * from './project-wizard';

package/src/blueprints/linear/blueprint.ts

@@ -7,7 +7,7 @@ import { Ref } from '@dxos/echo';
 import { Text } from '@dxos/schema';
 import { trim } from '@dxos/util';
 
-import { SyncIssues } from './functions';
+import { SyncIssues } from './operations/definitions';
 
 const BLUEPRINT_KEY = 'org.dxos.blueprint.linear';
 
@@ -29,7 +29,7 @@ const make = () =>
     name: 'Linear',
     description: 'Syncs Linear workspaces.',
     instructions: {
-      source: Ref.make(Text.make(instructions)),
+      source: Ref.make(Text.make({ content: instructions })),
     },
     tools: Blueprint.toolDefinitions({ operations: [SyncIssues] }),
   });

package/src/blueprints/linear/index.ts

@@ -3,4 +3,4 @@
 //
 
 export { default as LinearBlueprint } from './blueprint';
-export { SyncIssues, LinearHandlers } from './functions';
+export { LinearHandlers, LinearOperations } from './operations';

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

@@ -4,15 +4,16 @@
 
 import * as Schema from 'effect/Schema';
 
-import { CredentialsService } from '@dxos/compute';
-import { Operation } from '@dxos/compute';
+import { Credential, Operation } from '@dxos/compute';
 import { Database } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
 
 export const SyncIssues = Operation.make({
   meta: {
-    key: 'org.dxos.function.linear.sync-issues',
+    key: DXN.make('org.dxos.function.linear.syncIssues'),
     name: 'Linear',
     description: 'Sync issues from Linear.',
+    icon: 'ph--arrows-clockwise--regular',
   },
   input: Schema.Struct({
     team: Schema.String.annotations({
@@ -20,5 +21,5 @@ export const SyncIssues = Operation.make({
     }),
   }),
   output: Schema.Any,
-  services: [CredentialsService, Database.Service],
+  services: [Credential.CredentialsService, Database.Service],
 });

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

@@ -4,6 +4,6 @@
 
 import { OperationHandlerSet } from '@dxos/compute';
 
-export * from './definitions';
+export * as LinearOperations from './definitions';
 
 export const LinearHandlers = OperationHandlerSet.lazy(() => import('./sync-issues'));

package/src/blueprints/linear/{functions → operations}/linear.test.ts

@@ -5,10 +5,8 @@
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 
-import { Operation } from '@dxos/compute';
-import { OperationHandlerSet } from '@dxos/compute';
-import { Obj, Query } from '@dxos/echo';
-import { Database } from '@dxos/echo';
+import { Operation, OperationHandlerSet } from '@dxos/compute';
+import { Database, Obj, Query } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
 import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 import { Person, Pipeline, Task } from '@dxos/types';
@@ -33,17 +31,17 @@ describe.skip('Linear', { timeout: 600_000 }, () => {
           team: '1127c63a-6f77-4725-9229-50f6cd47321c',
         });
 
-        const persons = yield* Database.runQuery(Query.type(Person.Person));
+        const persons = yield* Database.query(Query.type(Person.Person)).run;
         console.log('people', {
           count: persons.length,
           people: persons.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
         });
-        const projects = yield* Database.runQuery(Query.type(Pipeline.Pipeline));
+        const projects = yield* Database.query(Query.type(Pipeline.Pipeline)).run;
         console.log('projects', {
           count: projects.length,
           projects: projects.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
         });
-        const tasks = yield* Database.runQuery(Query.type(Task.Task));
+        const tasks = yield* Database.query(Query.type(Task.Task)).run;
         console.log('tasks', {
           count: tasks.length,
           tasks: tasks.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),

package/src/blueprints/linear/{functions → operations}/sync-issues.ts

@@ -8,10 +8,9 @@ import * as Array from 'effect/Array';
 import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
 
-import { CredentialsService, withAuthorization } from '@dxos/compute';
-import { Operation } from '@dxos/compute';
-import { Filter, Obj, Query, Ref, type Type } from '@dxos/echo';
-import { Database } from '@dxos/echo';
+import { Credential, Operation } from '@dxos/compute';
+import { Database, Filter, Obj, Query, Ref, type Type } from '@dxos/echo';
+import { withAuthorization } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { Person, Pipeline, Task } from '@dxos/types';
 
@@ -79,7 +78,7 @@ export const LINEAR_UPDATED_AT_KEY = 'linear.app/updatedAt';
 export default SyncIssues.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* ({ team }) {
-      const credential = yield* CredentialsService.getCredential({ service: 'linear.app' });
+      const credential = yield* Credential.CredentialsService.getCredential({ service: 'linear.app' });
       const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(credential.apiKey!)));
 
       const after = yield* getLatestUpdateTimestamp(team, Task.Task);
@@ -109,9 +108,9 @@ const getLatestUpdateTimestamp: (
   teamId: string,
   dataType: Type.AnyObj,
 ) => Effect.Effect<string, never, Database.Service> = Effect.fnUntraced(function* (teamId, dataType) {
-  const existingTasks = yield* Database.runQuery(
+  const existingTasks = yield* Database.query(
     Query.type(dataType).select(Filter.foreignKeys(dataType, [{ source: LINEAR_TEAM_ID_KEY, id: teamId }])),
-  );
+  ).run;
   return Function.pipe(
     existingTasks,
     Array.map((task) => Obj.getKeys(task, LINEAR_UPDATED_AT_KEY).at(0)?.id),