@dxos/assistant-toolkit 0.9.1-main.c7dcc2e112 → 0.9.1-staging.ee54ba693a

package/src/skills/skill-manager/operations/enable-skills.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Either from 'effect/Either';
+
+import { Harness } from '@dxos/assistant';
+import { Operation, Skill } from '@dxos/compute';
+import { Ref } from '@dxos/echo';
+
+import { EnableSkills } from './definitions';
+
+export default EnableSkills.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ keys }) {
+      const enabled: Skill.Skill[] = [];
+      const rejected: { key: string; reason: string }[] = [];
+
+      for (const key of keys) {
+        const result = yield* Skill.resolve(key).pipe(
+          Effect.mapError(() => ({ key, reason: 'Skill not found in registry.' })),
+          Effect.either,
+        );
+        if (Either.isLeft(result)) {
+          rejected.push(result.left);
+          continue;
+        }
+        if (!result.right.agentCanEnable) {
+          rejected.push({ key, reason: 'Skill does not allow agent auto-enable (agentCanEnable is not set).' });
+          continue;
+        }
+        const dbSkill = yield* Skill.upsert(key).pipe(Effect.orDie);
+        enabled.push(dbSkill);
+      }
+
+      if (enabled.length > 0) {
+        yield* Harness.bindContext({
+          skills: enabled.map(Ref.make),
+        });
+      }
+
+      return { enabled, rejected };
+    }),
+  ),
+);

package/src/skills/skill-manager/operations/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export * as SkillManagerOperations from './definitions';
+
+export const SkillManagerHandlers = OperationHandlerSet.lazy(
+  () => import('./query-skills'),
+  () => import('./enable-skills'),
+);

package/src/skills/skill-manager/operations/query-skills.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation, Skill } from '@dxos/compute';
+import { Filter, Registry } from '@dxos/echo';
+
+import { QuerySkills } from './definitions';
+
+export default QuerySkills.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      const skills = yield* Registry.runQuery(Filter.type(Skill.Skill));
+      return skills.slice().sort(({ name: a }, { name: b }) => a.localeCompare(b));
+    }),
+  ),
+);

package/src/skills/skill-manager/skill.test.ts

@@ -0,0 +1,174 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { AiContext, Harness } from '@dxos/assistant';
+import { Operation, Skill } from '@dxos/compute';
+import { Database, Feed, Obj } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
+import { TestHelpers } from '@dxos/effect/testing';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
+import { EntityId, type URI } from '@dxos/keys';
+
+import { DatabaseSkill, DiscordSkill, MemorySkill } from '../index';
+import { SkillManagerHandlers } from './operations';
+import { EnableSkills, QuerySkills } from './operations/definitions';
+
+EntityId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  aiServicePreset: 'edge-remote',
+  operationHandlers: SkillManagerHandlers,
+  types: [Skill.Skill],
+  skills: [DatabaseSkill.make(), MemorySkill.make(), DiscordSkill.make()],
+  tracing: 'pretty',
+});
+
+/** Conversation DXN for the scoped test harness feed. */
+class TestConversation extends Context.Tag('@dxos/assistant-toolkit/TestConversation')<
+  TestConversation,
+  { conversation: URI.URI }
+>() {}
+
+const ConversationHarnessLayer = Layer.unwrapScoped(
+  Effect.gen(function* () {
+    const feed = yield* Database.add(Feed.make());
+    const conversation = Obj.getURI(feed);
+    const runtime = yield* Effect.runtime<Database.Service>();
+    const binder = yield* EffectEx.acquireReleaseResource(() => new AiContext.Binder({ feed, runtime }));
+    return Layer.mergeAll(
+      Layer.succeed(TestConversation, { conversation }),
+      Layer.succeed(Harness.HarnessService, Harness.fromBinder({ feed, runtime, binder })),
+    );
+  }),
+);
+
+const provideTestLayers = Effect.provide(ConversationHarnessLayer.pipe(Layer.provideMerge(TestLayer)));
+
+const getConversationDXN = Effect.gen(function* () {
+  const { conversation } = yield* TestConversation;
+  return conversation;
+});
+
+const getBoundSkills = Effect.gen(function* () {
+  const binder = yield* Harness.binder;
+  yield* Effect.promise(() => binder.sync());
+  return binder.getSkills();
+});
+
+describe('Skill Manager', () => {
+  it.effect(
+    'query-skills: returns all registered skills',
+    Effect.fnUntraced(
+      function* (_) {
+        const conversation = yield* getConversationDXN;
+        const result = yield* Operation.invoke(QuerySkills, {}, { conversation });
+        expect(result).toHaveLength(3);
+        const keys = result.map((skill: Skill.Skill) => Obj.getMeta(skill).key);
+        expect(keys).toContain('org.dxos.skill.database');
+        expect(keys).toContain('org.dxos.skill.memory');
+        expect(keys).toContain('org.dxos.skill.discord');
+      },
+      provideTestLayers,
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 30_000 },
+  );
+
+  it.effect(
+    'enable-skills: enables skills with agentCanEnable=true',
+    Effect.fnUntraced(
+      function* (_) {
+        const conversation = yield* getConversationDXN;
+        const { enabled, rejected } = yield* Operation.invoke(
+          EnableSkills,
+          { keys: ['org.dxos.skill.database'] },
+          { conversation },
+        );
+        expect(enabled).toHaveLength(1);
+        expect(Obj.getMeta(enabled[0]).key).toBe('org.dxos.skill.database');
+        expect(rejected).toHaveLength(0);
+
+        const bound = yield* getBoundSkills;
+        expect(bound.some((bp: Skill.Skill) => Obj.getMeta(bp).key === 'org.dxos.skill.database')).toBe(true);
+      },
+      provideTestLayers,
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 30_000 },
+  );
+
+  it.effect(
+    'enable-skills: rejects skills without agentCanEnable',
+    Effect.fnUntraced(
+      function* (_) {
+        const conversation = yield* getConversationDXN;
+        const { enabled, rejected } = yield* Operation.invoke(
+          EnableSkills,
+          { keys: ['org.dxos.skill.discord'] },
+          { conversation },
+        );
+        expect(enabled).toHaveLength(0);
+        expect(rejected).toHaveLength(1);
+        expect(rejected[0].key).toBe('org.dxos.skill.discord');
+
+        const bound = yield* getBoundSkills;
+        expect(bound.some((bp: Skill.Skill) => Obj.getMeta(bp).key === 'org.dxos.skill.discord')).toBe(false);
+      },
+      provideTestLayers,
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 30_000 },
+  );
+
+  it.effect(
+    'enable-skills: mixed keys enables only allowed ones',
+    Effect.fnUntraced(
+      function* (_) {
+        const conversation = yield* getConversationDXN;
+        const { enabled, rejected } = yield* Operation.invoke(
+          EnableSkills,
+          {
+            keys: ['org.dxos.skill.database', 'org.dxos.skill.memory', 'org.dxos.skill.discord'],
+          },
+          { conversation },
+        );
+        expect(enabled).toHaveLength(2);
+        const enabledKeys = enabled.map((bp: Skill.Skill) => Obj.getMeta(bp).key);
+        expect(enabledKeys).toContain('org.dxos.skill.database');
+        expect(enabledKeys).toContain('org.dxos.skill.memory');
+        expect(rejected).toHaveLength(1);
+        expect(rejected[0].key).toBe('org.dxos.skill.discord');
+      },
+      provideTestLayers,
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 30_000 },
+  );
+
+  it.effect(
+    'enable-skills: unknown keys are rejected with reason',
+    Effect.fnUntraced(
+      function* (_) {
+        const conversation = yield* getConversationDXN;
+        const { enabled, rejected } = yield* Operation.invoke(
+          EnableSkills,
+          { keys: ['org.dxos.skill.nonexistent'] },
+          { conversation },
+        );
+        expect(enabled).toHaveLength(0);
+        expect(rejected).toHaveLength(1);
+        expect(rejected[0].key).toBe('org.dxos.skill.nonexistent');
+        expect(rejected[0].reason).toContain('not found');
+      },
+      provideTestLayers,
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 30_000 },
+  );
+});

package/src/skills/skill-manager/skill.ts

@@ -0,0 +1,49 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Skill, Template } from '@dxos/compute';
+import { DXN } from '@dxos/keys';
+import { trim } from '@dxos/util';
+
+import { EnableSkills, QuerySkills } from './operations/definitions';
+
+const SKILL_KEY = 'org.dxos.skill.skillManager';
+
+const make = () =>
+  Skill.make({
+    key: SKILL_KEY,
+    name: 'Skill Manager',
+    description: 'Query and enable skills in the current conversation.',
+    instructions: Template.make({
+      source: trim`
+        You can query available skills and enable them in the current conversation.
+        Use [query-skills] to refresh the list of available skills.
+        Use [enable-skills] to enable skills by their keys. Always call [query-skills] first.
+        Only skills with agentCanEnable=true can be enabled by the agent.
+
+        <available_skills>
+        {{#each skills}}
+        - {{key}} "{{name}}"{{#if description}} -- {{description}}{{/if}}{{#if agentCanEnable}} [agent-can-enable]{{/if}}
+        {{/each}}
+        </available_skills>
+
+        NOTE: You must enable the skill to use it, only then the tools from that skill will appear.
+      `,
+      inputs: [
+        {
+          name: 'skills',
+          kind: 'operation',
+          operation: DXN.getName(QuerySkills.meta.key),
+        },
+      ],
+    }),
+    tools: Skill.toolDefinitions({ operations: [QuerySkills, EnableSkills] }),
+  });
+
+const skill: Skill.Definition = {
+  key: SKILL_KEY,
+  make,
+};
+
+export default skill;

package/src/{blueprints → skills}/testing.ts

@@ -7,8 +7,8 @@ import * as Effect from 'effect/Effect';
 import { pipe } from 'effect/Function';
 
 import { ConsolePrinter } from '@dxos/ai';
-import { AiContext, AiRequest, AiSession, GenerationObserver } from '@dxos/assistant';
-import type { Blueprint } from '@dxos/compute';
+import { AiRequest, AiSession, GenerationObserver, Harness } from '@dxos/assistant';
+import type { Skill } from '@dxos/compute';
 import { Database, Ref } from '@dxos/echo';
 import { log } from '@dxos/log';
 
@@ -40,16 +40,15 @@ export const runSteps: (
 });
 
 /**
- * Binds blueprints from the blueprint definitions.
+ * Binds skills from the skill definitions.
  */
-// TODO(dmaretskyi): Potentially the agent will auto-bind the blueprints.
-export const addBlueprints = Effect.fnUntraced(function* (blueprints: Blueprint.Definition[]) {
-  yield* AiContext.Service.bindContext({
-    blueprints: yield* pipe(
-      blueprints,
-      Arr.map((blueprint) => blueprint.make()),
-      Effect.forEach(Database.add),
-      Effect.map(Arr.map(Ref.make)),
-    ),
-  });
+// TODO(dmaretskyi): Potentially the agent will auto-bind the skills.
+export const addSkills = Effect.fnUntraced(function* (skills: Skill.Definition[]) {
+  const skillRefs = yield* pipe(
+    skills,
+    Arr.map((skill) => skill.make()),
+    Effect.forEach(Database.add),
+    Effect.map(Arr.map(Ref.make)),
+  );
+  yield* Harness.bindContext({ skills: skillRefs });
 });

package/src/{blueprints → skills}/websearch/index.ts

@@ -2,6 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-export { default as WebSearchBlueprint } from './blueprint';
+export { default as WebSearchSkill } from './skill';
 export { WebSearchToolkit, WebSearchToolkitOpaque } from './toolkit';
 export { WebSearchHandlers, WebSearchOperations } from './operations';

package/src/{blueprints → skills}/websearch/operations/fetch.ts

@@ -16,6 +16,7 @@ export default Fetch.pipe(
         try: () => proxyFetchLegacy(new URL(url)),
         catch: (cause) => new Error(`Fetch failed: ${String(cause)}`),
       });
+      // TODO(dmaretskyi): Use browser rendering API.
       if (!response.ok) {
         const body = yield* Effect.promise(() => response.text());
         return yield* Effect.fail(new Error(`Fetch failed with status ${response.status}: ${body.slice(0, 256)}`));

package/src/{blueprints/websearch/blueprint.test.ts → skills/websearch/skill.test.ts}

@@ -9,25 +9,25 @@ import { TestHelpers } from '@dxos/effect/testing';
 import { AgentService } from '@dxos/functions-runtime';
 import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 
-import WebSearchBlueprint from './blueprint';
 import { WebSearchHandlers } from './operations';
+import WebSearchSkill from './skill';
 import { WebSearchToolkitOpaque } from './toolkit';
 
 const TestLayer = AssistantTestLayer({
-  blueprints: [WebSearchBlueprint.make()],
+  skills: [WebSearchSkill.make()],
   operationHandlers: [WebSearchHandlers],
   toolkits: [WebSearchToolkitOpaque],
   tracing: 'pretty',
 });
 
-describe('WebToolkit', () => {
+describe('WebSearchSkill', () => {
   // Keep skipped, this test is flaky.
   it.effect.skip(
     'WebFetch handler returns response text',
     Effect.fnUntraced(
       function* ({ expect }) {
         const session = yield* AgentService.createSession({
-          blueprints: [WebSearchBlueprint.make()],
+          skills: [WebSearchSkill.make()],
         });
         yield* session.submitPrompt('What is the capital of France? Make sure to use the web search tool.');
         yield* session.waitForCompletion();

package/src/skills/websearch/skill.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Skill } from '@dxos/compute';
+import { Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+
+import { Fetch } from './operations/definitions';
+import { WebSearchToolkit } from './toolkit';
+
+const SKILL_KEY = 'org.dxos.skill.webSearch';
+
+const make = () =>
+  Skill.make({
+    key: SKILL_KEY,
+    name: 'Web Search',
+    description: 'Search the web.',
+    agentCanEnable: true,
+    instructions: {
+      source: Ref.make(Text.make()),
+    },
+    tools: Skill.toolDefinitions({ operations: [Fetch], tools: [WebSearchToolkit.tools.AnthropicWebSearch.name] }),
+  });
+
+const skill: Skill.Definition = {
+  key: SKILL_KEY,
+  make,
+};
+
+export default skill;

package/src/{blueprints → skills}/websearch/toolkit.ts

@@ -2,12 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as AnthropicTool from '@effect/ai-anthropic/AnthropicTool';
 import * as Toolkit from '@effect/ai/Toolkit';
 import * as Layer from 'effect/Layer';
 
-import { OpaqueToolkit } from '@dxos/ai';
+import { AnthropicWebSearchTool, OpaqueToolkit } from '@dxos/ai';
 
-export const WebSearchToolkit = Toolkit.make(AnthropicTool.WebSearch_20250305({}));
+export const WebSearchToolkit = Toolkit.make(AnthropicWebSearchTool);
 
 export const WebSearchToolkitOpaque = OpaqueToolkit.make(WebSearchToolkit, Layer.empty);

package/src/supervisor/delegation-strategy.ts

@@ -7,7 +7,7 @@ import * as Effect from 'effect/Effect';
 import * as Exit from 'effect/Exit';
 
 import { AiContext } from '@dxos/assistant';
-import { Routine } from '@dxos/compute';
+import { Instructions } from '@dxos/compute';
 import { ProcessManager } from '@dxos/compute-runtime';
 import { Database, Feed, Filter, Obj, Ref } from '@dxos/echo';
 import { EffectEx } from '@dxos/effect';
@@ -16,13 +16,31 @@ import { log } from '@dxos/log';
 import { Message } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { DelegationBlueprint } from '../blueprints';
-import { AgentPrompt } from '../functions';
-import { Agent } from '../types';
+import { RunInstructions } from '../operations';
+import { DelegationSkill } from '../skills';
+import { Agent, Chat } from '../types';
+
+/**
+ * Resolves the chat backed by the given conversation feed, if any.
+ */
+const findChatForFeed = (feed: Feed.Feed): Effect.Effect<Chat.Chat | undefined, never, Database.Service> =>
+  Effect.gen(function* () {
+    const chats = yield* Database.query(Filter.type(Chat.Chat)).run;
+    for (const chat of chats) {
+      const matches = yield* Effect.gen(function* () {
+        const chatFeed = yield* Database.load(chat.feed);
+        return chatFeed.id === feed.id;
+      }).pipe(Effect.orElseSucceed(() => false));
+      if (matches) {
+        return chat;
+      }
+    }
+    return undefined;
+  });
 
 /**
  * Resolves the agent whose chat is backed by the given conversation feed, if any. Plain (agentless)
- * chats yield `undefined`, so the strategy is a no-op for them.
+ * chats yield `undefined`, so artifact folding is skipped for them.
  */
 const findAgentForFeed = (feed: Feed.Feed): Effect.Effect<Agent.Agent | undefined, never, Database.Service> =>
   Effect.gen(function* () {
@@ -49,7 +67,7 @@ const findAgentForFeed = (feed: Feed.Feed): Effect.Effect<Agent.Agent | undefine
 const formatResult = (value: unknown): string => (typeof value === 'string' ? value : JSON.stringify(value));
 
 /**
- * Extracts artifact ids a sub-agent reported in its result (see the synthesized routine
+ * Extracts artifact ids a sub-agent reported in its result (see the synthesized instructions
  * instructions). Tolerates the result being a string, or an object with `artifactIds`/`artifactId`.
  */
 const extractArtifactIds = (value: unknown): string[] => {
@@ -69,17 +87,17 @@ const extractArtifactIds = (value: unknown): string[] => {
 /**
  * Supervisor behaviour for the conversational agent: after each turn, every in-progress plan task
  * not already delegated is run by a sub-agent (a synthesized minimal `Routine` executed via
- * `AgentPrompt`); on completion the task status is updated and a templated message is posted back to
+ * `RunInstructions`); on completion the task status is updated and a templated message is posted back to
  * the conversation.
  */
 export const makeDelegationStrategy = (): DelegationStrategy => ({
   reconcile: (feed, activeIds) =>
     Effect.gen(function* () {
-      const agent = yield* findAgentForFeed(feed);
-      if (!agent) {
+      const chat = yield* findChatForFeed(feed);
+      if (!chat) {
         return [];
       }
-      const plan = yield* Database.load(agent.plan).pipe(Effect.orElseSucceed(() => undefined));
+      const plan = chat.plan ? yield* Database.load(chat.plan).pipe(Effect.orElseSucceed(() => undefined)) : undefined;
       if (!plan) {
         return [];
       }
@@ -93,24 +111,24 @@ export const makeDelegationStrategy = (): DelegationStrategy => ({
         return [];
       }
 
-      // Sub-agents inherit the supervisor's bound blueprints (so they have the same tools/
-      // capabilities), minus the delegation blueprint itself — otherwise a sub-agent could
+      // Sub-agents inherit the supervisor's bound skills (so they have the same tools/
+      // capabilities), minus the delegation skill itself — otherwise a sub-agent could
       // recursively delegate. Resolved from the conversation's AiContext bindings.
-      const inheritedBlueprints = yield* Effect.gen(function* () {
-        const runtime = yield* Effect.runtime<Feed.FeedService>();
+      const inheritedSkills = yield* Effect.gen(function* () {
+        const runtime = yield* Effect.runtime<Database.Service>();
         const binder = yield* EffectEx.acquireReleaseResource(() => new AiContext.Binder({ feed, runtime }));
-        return binder.getBlueprints().filter((blueprint) => Obj.getMeta(blueprint).key !== DelegationBlueprint.key);
+        return binder.getSkills().filter((skill) => Obj.getMeta(skill).key !== DelegationSkill.key);
       }).pipe(Effect.scoped);
-      const blueprints = inheritedBlueprints.map((blueprint) => Ref.make(blueprint));
+      const skills = inheritedSkills.map((skill) => Ref.make(skill));
 
       const delegations: Delegation[] = [];
       for (const task of pending) {
-        // Synthesize a minimal routine whose goal is the task; the sub-agent runs it via AgentPrompt
-        // with the inherited blueprints bound.
-        const routine = yield* Database.add(
-          Routine.make({
+        // Synthesize a minimal instructions whose goal is the task; the sub-agent runs it via RunInstructions
+        // with the inherited skills bound.
+        const instructions = yield* Database.add(
+          Instructions.make({
             name: task.title,
-            instructions: trim`
+            text: trim`
               Complete the following task and report the result concisely.
 
               If you create any documents or artifacts, call completeJob with a JSON object of the
@@ -119,7 +137,7 @@ export const makeDelegationStrategy = (): DelegationStrategy => ({
 
               Task: ${task.title}
             `,
-            blueprints,
+            skills,
           }),
         );
 
@@ -127,7 +145,10 @@ export const makeDelegationStrategy = (): DelegationStrategy => ({
           id: task.id,
           spawn: Effect.gen(function* () {
             const invoker = yield* ProcessManager.ProcessOperationInvoker.Service;
-            const fiber = yield* invoker.invokeFiber(AgentPrompt, { prompt: Ref.make(routine), input: {} });
+            const fiber = yield* invoker.invokeFiber(RunInstructions, {
+              instructions: Ref.make(instructions),
+              input: {},
+            });
             const pid = fiber.pid;
             Obj.update(plan, (plan) => {
               const taskRecord = plan.tasks.find((taskRecord) => taskRecord.id === task.id);
@@ -144,8 +165,10 @@ export const makeDelegationStrategy = (): DelegationStrategy => ({
 
   onComplete: (feed, id, exit) =>
     Effect.gen(function* () {
+      const chat = yield* findChatForFeed(feed);
       const agent = yield* findAgentForFeed(feed);
-      const plan = agent ? yield* Database.load(agent.plan).pipe(Effect.orElseSucceed(() => undefined)) : undefined;
+      const plan =
+        chat?.plan != null ? yield* Database.load(chat.plan).pipe(Effect.orElseSucceed(() => undefined)) : undefined;
 
       let title = id;
       if (plan) {

package/src/supervisor/index.ts

@@ -3,4 +3,3 @@
 //
 
 export * from './delegation-strategy';
-export * from './plan-completion-guard';

package/src/testing/index.ts

@@ -2,5 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from '../blueprints/testing';
+export * from '../skills/testing';
 export * from './plugins';

package/src/testing/plugins.tsx

@@ -11,6 +11,7 @@ import { AppSurface } from '@dxos/app-toolkit/ui';
 import { DXN, Format, type Obj, Type } from '@dxos/echo';
 import { Card } from '@dxos/react-ui';
 import { Syntax } from '@dxos/react-ui-syntax-highlighter';
+import { Position } from '@dxos/util';
 
 export const MapSchema = Schema.Struct({
   coordinates: Format.GeoPoint,
@@ -37,7 +38,7 @@ export const capabilities: Capability.Any[] = [
     Surface.create({
       id: 'pluginDefault',
       filter: Surface.makeFilter(AppSurface.CardContent),
-      position: 'last',
+      position: Position.last,
       component: ({ data }) => (
         <Card.Body>
           <Syntax.Root data={data}>

package/src/types/Agent.test.ts

@@ -5,7 +5,7 @@
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 
-import { Blueprint } from '@dxos/compute';
+import { Skill } from '@dxos/compute';
 import { Database, Feed, Obj } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
 import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
@@ -17,14 +17,14 @@ import { Agent, Chat, Plan } from '../types';
 EntityId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayer({
-  types: [Agent.Agent, Plan.Plan, Chat.Chat, Chat.CompanionTo, Blueprint.Blueprint, Feed.Feed, Text.Text],
+  types: [Agent.Agent, Plan.Plan, Chat.Chat, Chat.CompanionTo, Skill.Skill, Feed.Feed, Text.Text],
   disableLlmMemoization: true,
 });
 
 const makeAgent = Effect.fnUntraced(function* () {
   return yield* Agent.makeInitialized(
     { name: 'Test', instructions: '' },
-    Blueprint.make({ key: 'org.dxos.test.blueprint', name: 'Test' }),
+    Skill.make({ key: 'org.dxos.test.skill', name: 'Test' }),
   );
 });