@dxos/assistant 0.9.1-main.c7dcc2e112 → 0.10.0

package/src/session/AiContext.ts

@@ -6,15 +6,13 @@
 
 import { Atom, Registry as AtomRegistry } from '@effect-atom/atom-react';
 import * as EArray from 'effect/Array';
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
 import * as Runtime from 'effect/Runtime';
 import * as Schema from 'effect/Schema';
 
-import { Blueprint } from '@dxos/compute';
+import { Skill } from '@dxos/compute';
 import { Resource } from '@dxos/context';
-import { Annotation, DXN, Feed, Obj, type QueryResult, Query, Ref, Type } from '@dxos/echo';
+import { Annotation, Database, DXN, Feed, Obj, Query, type QueryResult, Ref, Type } from '@dxos/echo';
 import { assertArgument } from '@dxos/invariant';
 import { EID, type URI } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -23,26 +21,26 @@ import { ComplexSet, isNonNullable } from '@dxos/util';
 /**
  * Thread message that binds or unbinds contextual objects to a conversation.
  */
-export const Binding = Schema.Struct({
-  blueprints: Schema.Struct({
-    added: Schema.Array(Ref.Ref(Blueprint.Blueprint)),
-    removed: Schema.Array(Ref.Ref(Blueprint.Blueprint)),
-  }),
-
-  objects: Schema.Struct({
-    added: Schema.Array(Ref.Ref(Obj.Unknown)),
-    removed: Schema.Array(Ref.Ref(Obj.Unknown)),
-  }),
-}).pipe(Annotation.HiddenAnnotation.set(true), Type.makeObject(DXN.make('org.dxos.type.contextBinding', '0.1.0')));
-
-export type Binding = Type.InstanceType<typeof Binding>;
+export class Binding extends Type.makeObject<Binding>(DXN.make('org.dxos.type.contextBinding', '0.1.0'))(
+  Schema.Struct({
+    skills: Schema.Struct({
+      added: Schema.Array(Ref.Ref(Skill.Skill)),
+      removed: Schema.Array(Ref.Ref(Skill.Skill)),
+    }),
+
+    objects: Schema.Struct({
+      added: Schema.Array(Ref.Ref(Obj.Unknown)),
+      removed: Schema.Array(Ref.Ref(Obj.Unknown)),
+    }),
+  }).pipe(Annotation.HiddenAnnotation.set(true)),
+) {}
 export type BindingProps = Partial<{
-  blueprints: Ref.Ref<Blueprint.Blueprint>[];
+  skills: Ref.Ref<Skill.Skill>[];
   objects: Ref.Ref<Obj.Unknown>[];
 }>;
 
 export class Bindings {
-  readonly blueprints = new ComplexSet<Ref.Ref<Blueprint.Blueprint>>((ref) => ref.uri);
+  readonly skills = new ComplexSet<Ref.Ref<Skill.Skill>>((ref) => ref.uri);
 
   // TODO(burdon): Some DXNs have the Space prefix so only compare the object ID.
   readonly objects = new ComplexSet<Ref.Ref<Obj.Unknown>>((ref) => {
@@ -50,9 +48,9 @@ export class Bindings {
     return echoUri ? EID.getEntityId(echoUri) : undefined;
   });
 
-  toJSON(): { blueprints: URI.URI[]; objects: URI.URI[] } {
+  toJSON(): { skills: URI.URI[]; objects: URI.URI[] } {
     return {
-      blueprints: EArray.fromIterable(this.blueprints).map((ref) => ref.uri),
+      skills: EArray.fromIterable(this.skills).map((ref) => ref.uri),
       objects: EArray.fromIterable(this.objects).map((ref) => ref.uri),
     };
   }
@@ -60,21 +58,21 @@ export class Bindings {
 
 export type BinderOptions = {
   feed: Feed.Feed;
-  runtime: Runtime.Runtime<Feed.FeedService>;
+  runtime: Runtime.Runtime<Database.Service>;
   /** @effect-atom/atom-react Registry for reactive state management. */
   registry?: AtomRegistry.Registry;
 };
 
 /**
- * Manages bindings of blueprints and objects to a conversation.
+ * Manages bindings of skills and objects to a conversation.
  */
 // TODO(burdon): Context should manage ephemeral state of bindings until prompt is issued?
 export class Binder extends Resource {
-  private readonly _blueprints = Atom.make<Blueprint.Blueprint[]>([]).pipe(Atom.keepAlive);
+  private readonly _skills = Atom.make<Skill.Skill[]>([]).pipe(Atom.keepAlive);
   private readonly _objects = Atom.make<Obj.Unknown[]>([]).pipe(Atom.keepAlive);
   private readonly _registry: AtomRegistry.Registry;
   private readonly _feed: Feed.Feed;
-  private readonly _runtime: Runtime.Runtime<Feed.FeedService>;
+  private readonly _runtime: Runtime.Runtime<Database.Service>;
 
   #bindingsQuery: QueryResult.QueryResult<Binding> | undefined;
 
@@ -88,10 +86,10 @@ export class Binder extends Resource {
   }
 
   /**
-   * Returns the blueprints atom for subscription.
+   * Returns the skills atom for subscription.
    */
-  get blueprints(): Atom.Atom<Blueprint.Blueprint[]> {
-    return this._blueprints;
+  get skills(): Atom.Atom<Skill.Skill[]> {
+    return this._skills;
   }
 
   /**
@@ -102,10 +100,10 @@ export class Binder extends Resource {
   }
 
   /**
-   * Gets the current blueprints value.
+   * Gets the current skills value.
    */
-  getBlueprints(): Blueprint.Blueprint[] {
-    return this._registry.get(this._blueprints);
+  getSkills(): Skill.Skill[] {
+    return this._registry.get(this._skills);
   }
 
   /**
@@ -116,10 +114,10 @@ export class Binder extends Resource {
   }
 
   /**
-   * Subscribe to changes in blueprints.
+   * Subscribe to changes in skills.
    */
-  subscribeBlueprints(cb: (blueprints: Blueprint.Blueprint[]) => void): () => void {
-    return this._registry.subscribe(this._blueprints, () => cb(this._registry.get(this._blueprints)));
+  subscribeSkills(cb: (skills: Skill.Skill[]) => void): () => void {
+    return this._registry.subscribe(this._skills, () => cb(this._registry.get(this._skills)));
   }
 
   /**
@@ -153,8 +151,8 @@ export class Binder extends Resource {
       log('sync', { bindingItems: results.length });
       await this._updateBindings(results);
       log('sync complete', {
-        blueprints: this._registry.get(this._blueprints).length,
-        blueprintKeys: this._registry.get(this._blueprints).map((bp) => Blueprint.getKey(bp)),
+        skills: this._registry.get(this._skills).length,
+        skillKeys: this._registry.get(this._skills).map((bp) => Skill.getKey(bp)),
       });
     }
   }
@@ -169,25 +167,25 @@ export class Binder extends Resource {
 
     log('_updateBindings', {
       items: items.length,
-      blueprintRefs: [...bindings.blueprints].map((ref) => ({ uri: ref.uri, available: ref.isAvailable })),
+      skillRefs: [...bindings.skills].map((ref) => ({ uri: ref.uri, available: ref.isAvailable })),
     });
 
     // Resolve references (loading them first if needed).
-    const currentBlueprints = this._registry.get(this._blueprints);
+    const currentSkills = this._registry.get(this._skills);
     const currentObjects = this._registry.get(this._objects);
-    const resolvedBlueprints = await this._resolve(bindings.blueprints, currentBlueprints);
+    const resolvedSkills = await this._resolve(bindings.skills, currentSkills);
     const resolvedObjects = await this._resolve(bindings.objects, currentObjects);
 
     log('_updateBindings resolved', {
-      resolvedBlueprints: resolvedBlueprints.length,
-      resolvedBlueprintKeys: resolvedBlueprints.map((bp) => Obj.getMeta(bp).key ?? '<missing>'),
+      resolvedSkills: resolvedSkills.length,
+      resolvedSkillKeys: resolvedSkills.map((bp) => Obj.getMeta(bp).key ?? '<missing>'),
     });
 
-    // Drop blueprints that have no registry key — they cannot be used downstream
-    // (e.g. tool/operation registration calls Blueprint.getKey which throws).
-    const keyedBlueprints = resolvedBlueprints.filter((bp) => {
+    // Drop skills that have no registry key — they cannot be used downstream
+    // (e.g. tool/operation registration calls Skill.getKey which throws).
+    const keyedSkills = resolvedSkills.filter((bp) => {
       if (Obj.getMeta(bp).key === undefined) {
-        log.warn('dropping blueprint with no meta key', { uri: Obj.getURI(bp) });
+        log.warn('dropping skill with no meta key', { uri: Obj.getURI(bp) });
         return false;
       }
       return true;
@@ -195,54 +193,54 @@ export class Binder extends Resource {
 
     // Filter current state to only items still in the reduced binding set,
     // then merge in newly resolved items. This ensures unbind events are respected.
-    const reducedBlueprintDxns = new Set<URI.URI>([...bindings.blueprints].map((ref) => ref.uri));
+    const reducedSkillDxns = new Set<URI.URI>([...bindings.skills].map((ref) => ref.uri));
     const reducedObjectDxns = new Set<URI.URI>([...bindings.objects].map((ref) => ref.uri));
-    const filteredBlueprints = currentBlueprints.filter((obj) => {
+    const filteredSkills = currentSkills.filter((obj) => {
       const uri = Obj.getURI(obj);
-      return uri != null && reducedBlueprintDxns.has(uri) && Obj.getMeta(obj).key !== undefined;
+      return uri != null && reducedSkillDxns.has(uri) && Obj.getMeta(obj).key !== undefined;
     });
     const filteredObjects = currentObjects.filter((obj) => {
       const uri = Obj.getURI(obj);
       return uri != null && reducedObjectDxns.has(uri);
     });
-    const mergedBlueprints = this._mergeInto(filteredBlueprints, keyedBlueprints);
+    const mergedSkills = this._mergeInto(filteredSkills, keyedSkills);
     const mergedObjects = this._mergeInto(filteredObjects, resolvedObjects);
 
-    this._registry.set(this._blueprints, mergedBlueprints);
+    this._registry.set(this._skills, mergedSkills);
     this._registry.set(this._objects, mergedObjects);
 
     log('updated bindings', {
-      blueprints: mergedBlueprints.length,
+      skills: mergedSkills.length,
       objects: mergedObjects.length,
     });
   }
 
   protected override async _close(): Promise<void> {
     // Reset atoms to empty state.
-    this._registry.set(this._blueprints, []);
+    this._registry.set(this._skills, []);
     this._registry.set(this._objects, []);
   }
 
-  async bind({ blueprints, objects }: BindingProps): Promise<void> {
-    const currentBlueprints = this._registry.get(this._blueprints);
+  async bind({ skills, objects }: BindingProps): Promise<void> {
+    const currentSkills = this._registry.get(this._skills);
     const currentObjects = this._registry.get(this._objects);
 
-    const { added: addedBlueprints, next: nextBlueprints } = this._processBindings(blueprints, currentBlueprints);
+    const { added: addedSkills, next: nextSkills } = this._processBindings(skills, currentSkills);
     const { added: addedObjects, next: nextObjects } = this._processBindings(objects, currentObjects);
-    if (!addedBlueprints.length && !addedObjects.length) {
+    if (!addedSkills.length && !addedObjects.length) {
       return;
     }
 
     // Atomic updates - subscribers notified automatically.
-    this._registry.set(this._blueprints, nextBlueprints);
+    this._registry.set(this._skills, nextSkills);
     this._registry.set(this._objects, nextObjects);
 
-    log('bind', { blueprints: addedBlueprints.length, objects: addedObjects.length });
+    log('bind', { skills: addedSkills.length, objects: addedObjects.length });
     await Runtime.runPromise(this._runtime)(
       Feed.append(this._feed, [
         Obj.make(Binding, {
-          blueprints: {
-            added: addedBlueprints,
+          skills: {
+            added: addedSkills,
             removed: [],
           },
           objects: {
@@ -254,19 +252,19 @@ export class Binder extends Resource {
     );
   }
 
-  async unbind({ blueprints, objects }: BindingProps): Promise<void> {
-    if (!blueprints?.length && !objects?.length) {
+  async unbind({ skills, objects }: BindingProps): Promise<void> {
+    if (!skills?.length && !objects?.length) {
       return;
     }
 
     // Immediately update atom state so removals are reflected before the queue round-trips.
-    const removedBlueprintDxns = (blueprints ?? []).map((ref) => ref.uri);
+    const removedSkillDxns = (skills ?? []).map((ref) => ref.uri);
     const removedObjectDxns = (objects ?? []).map((ref) => ref.uri);
-    if (removedBlueprintDxns.length > 0) {
-      const current = this._registry.get(this._blueprints);
+    if (removedSkillDxns.length > 0) {
+      const current = this._registry.get(this._skills);
       this._registry.set(
-        this._blueprints,
-        current.filter((obj) => !removedBlueprintDxns.some((uri) => Obj.getURI(obj) === uri)),
+        this._skills,
+        current.filter((obj) => !removedSkillDxns.some((uri) => Obj.getURI(obj) === uri)),
       );
     }
     if (removedObjectDxns.length > 0) {
@@ -277,13 +275,13 @@ export class Binder extends Resource {
       );
     }
 
-    log('unbind', { blueprints: blueprints?.length, objects: objects?.length });
+    log('unbind', { skills: skills?.length, objects: objects?.length });
     await Runtime.runPromise(this._runtime)(
       Feed.append(this._feed, [
         Obj.make(Binding, {
-          blueprints: {
+          skills: {
             added: [],
-            removed: blueprints ?? [],
+            removed: skills ?? [],
           },
           objects: {
             added: [],
@@ -329,14 +327,14 @@ export class Binder extends Resource {
   }
 
   /**
-   * Reduce results into sets of blueprints and objects.
+   * Reduce results into sets of skills and objects.
    */
   private _reduce(items: Binding[]): Bindings {
     return Function.pipe(
       items,
-      EArray.reduce(new Bindings(), (context, { blueprints, objects }) => {
-        blueprints.added.forEach((ref) => context.blueprints.add(ref));
-        blueprints.removed.forEach((ref) => context.blueprints.delete(ref));
+      EArray.reduce(new Bindings(), (context, { skills, objects }) => {
+        skills.added.forEach((ref) => context.skills.add(ref));
+        skills.removed.forEach((ref) => context.skills.delete(ref));
 
         objects.added.forEach((ref) => context.objects.add(ref));
         objects.removed.forEach((ref) => {
@@ -375,7 +373,7 @@ export class Binder extends Resource {
 
   /**
    * Resolve references to objects, loading them first if needed and falling back to existing objects.
-   * DXN refs (e.g. `dxn:org.dxos.blueprint.database`) resolve via the wired-up ECHO ref resolver
+   * DXN refs (e.g. `dxn:org.dxos.skill.database`) resolve via the wired-up ECHO ref resolver
    * which already spans both the space DB and the hypergraph registry.
    */
   private async _resolve<T extends Obj.Unknown>(refs: Iterable<Ref.Ref<T>>, current: T[]): Promise<T[]> {
@@ -398,23 +396,3 @@ export class Binder extends Resource {
       .filter(isNonNullable);
   }
 }
-
-export class Service extends Context.Tag('@dxos/assistant/AiContextService')<
-  Service,
-  {
-    binder: Binder;
-  }
->() {
-  static bindContext = ({ blueprints, objects }: BindingProps): Effect.Effect<void, never, Service> =>
-    Effect.gen(function* () {
-      const { binder } = yield* Service;
-      yield* Effect.promise(() => binder.bind({ blueprints, objects }));
-    });
-
-  static findObjects = <T extends Type.AnyObj>(type: T): Effect.Effect<Type.InstanceType<T>[], never, Service> => {
-    return Effect.gen(function* () {
-      const { binder } = yield* Service;
-      return binder.getObjects().filter(Obj.instanceOf(type));
-    });
-  };
-}

package/src/session/AiSession.test.ts

@@ -27,7 +27,7 @@ describe('AiSession.Session.getHistory', () => {
       const message = makeMessage('hello');
       yield* Feed.append(feed, [message]);
 
-      const runtime = yield* Effect.runtime<Feed.FeedService>();
+      const runtime = yield* Effect.runtime<Database.Service>();
       const session = new AiSession.Session({ feed, runtime });
 
       const result = yield* Effect.promise(() => session.getHistory());
@@ -51,7 +51,7 @@ describe('AiSession.Session.getHistory', () => {
         forkMsg,
       ]);
 
-      const runtime = yield* Effect.runtime<Feed.FeedService>();
+      const runtime = yield* Effect.runtime<Database.Service>();
       const session = new AiSession.Session({ feed: forkFeed, runtime });
 
       const result = yield* Effect.promise(() => session.getHistory());
@@ -76,7 +76,7 @@ describe('AiSession.Session.getHistory', () => {
         Obj.make(SessionLink.SessionLink, { feedRef: Ref.make(sourceFeed), messageId: msg2.id }),
       ]);
 
-      const runtime = yield* Effect.runtime<Feed.FeedService>();
+      const runtime = yield* Effect.runtime<Database.Service>();
       const session = new AiSession.Session({ feed: forkFeed, runtime });
 
       const result = yield* Effect.promise(() => session.getHistory());
@@ -100,7 +100,7 @@ describe('AiSession.Session.getHistory', () => {
         forkMsg,
       ]);
 
-      const runtime = yield* Effect.runtime<Feed.FeedService>();
+      const runtime = yield* Effect.runtime<Database.Service>();
       const session = new AiSession.Session({ feed: forkFeed, runtime });
 
       const result = yield* Effect.promise(() => session.getHistory());

package/src/session/AiSession.ts

@@ -6,7 +6,6 @@
 
 import { type Registry as AtomRegistry } from '@effect-atom/atom-react';
 import * as Array from 'effect/Array';
-import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Either from 'effect/Either';
 import { pipe } from 'effect/Function';
@@ -15,20 +14,21 @@ import * as Record from 'effect/Record';
 import * as Runtime from 'effect/Runtime';
 
 import { type OpaqueToolkit, type ToolExecutionService, type ToolResolverService } from '@dxos/ai';
-import { type Blueprint, McpServer, Operation, Trace } from '@dxos/compute';
+import { McpServer, Operation, type Skill, Trace } from '@dxos/compute';
 import { Resource } from '@dxos/context';
 import { Database, Feed, Filter, Obj, Registry } from '@dxos/echo';
-import { EffectEx } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { McpToolkit } from '@dxos/mcp-client';
-import { Message, type ContentBlock } from '@dxos/types';
+import { type ContentBlock, Message } from '@dxos/types';
 
-import { ToolExecutionServices } from '../functions';
 import { AiRequest, type GenerationObserver, formatSystemPrompt } from '../request';
+import { ToolExecutionServices } from '../tool-runtime';
 import { McpServerError } from '../util';
 import * as AiContext from './AiContext';
+import * as Harness from './Harness';
 import { SessionLoader } from './SessionLoader';
+import * as SkillHooks from './SkillHooks';
 import { createToolkit } from './toolkit';
 
 export type RunProps<R = never> = {
@@ -38,7 +38,7 @@ export type RunProps<R = never> = {
   toolkit?: OpaqueToolkit.OpaqueToolkit<R>;
 
   /**
-   * Space-level MCP servers to connect alongside blueprint-defined ones.
+   * Space-level MCP servers to connect alongside skill-defined ones.
    */
   mcpServers?: readonly McpServer.McpServer[];
 
@@ -52,7 +52,7 @@ export type RunProps<R = never> = {
 
 export type Options = {
   feed: Feed.Feed;
-  runtime: Runtime.Runtime<Feed.FeedService>;
+  runtime: Runtime.Runtime<Database.Service>;
   /** @effect-atom/atom-react Registry for reactive state. */
   registry?: AtomRegistry.Registry;
 };
@@ -69,11 +69,11 @@ const SUMMARY_THRESHOLD = 80_000;
  */
 export class Session extends Resource {
   /**
-   * Blueprints and objects bound to the session.
+   * Skills and objects bound to the session.
    */
   private readonly _binder: AiContext.Binder;
   private readonly _feed: Feed.Feed;
-  private readonly _runtime: Runtime.Runtime<Feed.FeedService>;
+  private readonly _runtime: Runtime.Runtime<Database.Service>;
   private readonly _sessionLoader = new SessionLoader();
 
   public constructor(options: Options) {
@@ -114,7 +114,7 @@ export class Session extends Resource {
     ToolExecutionService | ToolResolverService
   > {
     return Effect.gen(this, function* () {
-      const toolkit = yield* createToolkit({ blueprints: this.context.getBlueprints() });
+      const toolkit = yield* createToolkit({ skills: this.context.getSkills() });
       return toolkit.toolkit.tools;
     }).pipe(Effect.orDie);
   }
@@ -140,12 +140,12 @@ export class Session extends Resource {
   ): Effect.Effect<Message.Message[], AiRequest.RunError, AiRequest.RunRequirements | R> {
     return Effect.gen(this, function* () {
       const history = yield* Effect.promise(() => this.getHistory());
-      const blueprints = this.context.getBlueprints();
+      const skills = this.context.getSkills();
       const objects = this.context.getObjects();
 
       log('run', {
         history: history.length,
-        blueprints: blueprints.length,
+        skills: skills.length,
         objects: objects.length,
       });
 
@@ -159,34 +159,47 @@ export class Session extends Resource {
 
       yield* request.begin({
         history,
-        blueprints,
+        skills,
         objects,
         prompt: params.prompt,
         system: params.system,
       });
 
-      // Turn loop: recompute toolkit and system prompt between turns to pick up dynamically enabled blueprints.
+      // Fire begin-request hooks declared by the bound skills. These run in the agent's turn
+      // fiber (Tier A only), so they cannot reach the live host (Tier B) — that is the end hook's job.
+      yield* SkillHooks.runHooks({
+        skills,
+        phase: 'begin-request',
+        invoke: (operation, input) => Operation.invoke(operation, input).pipe(Effect.asVoid, Effect.orDie),
+      });
+
+      // Turn loop: recompute toolkit and system prompt between turns to pick up dynamically enabled skills.
       do {
         yield* Effect.promise(() => this.context.sync());
-        const currentBlueprints = this.context.getBlueprints();
-        const mcps = yield* connectMcpServers(currentBlueprints, params.mcpServers);
+        const currentSkills = this.context.getSkills();
+        const mcps = yield* connectMcpServers(currentSkills, params.mcpServers);
         const toolkit = yield* createToolkit({
           toolkit: params.toolkit,
-          blueprints: currentBlueprints,
+          skills: currentSkills,
           opaqueToolkits: mcps,
         });
 
         log('toolkit', { tools: Record.keys(toolkit.toolkit.tools) });
         const system = yield* formatSystemPrompt({
           system: params.system,
-          blueprints: currentBlueprints,
+          skills: currentSkills,
           objects: this.context.getObjects(),
         }).pipe(Effect.orDie);
 
-        const { done } = yield* request.runAgentTurn({ system, toolkit });
+        const { done, finishReason } = yield* request.runAgentTurn({ system, toolkit });
         if (done) {
           break;
         }
+        // A paused server-tool turn (e.g. Anthropic `pause_turn`) resumes with another request and
+        // no local tool execution; the trailing server tool call must be left intact for the provider.
+        if (finishReason === 'pause') {
+          continue;
+        }
 
         yield* request.runTools({ toolkit });
       } while (true);
@@ -201,10 +214,13 @@ export class Session extends Resource {
     }).pipe(
       Effect.provide(
         Layer.mergeAll(
-          Layer.succeed(AiContext.Service, {
-            binder: this.context,
-          }),
-          Layer.succeed(Service, this),
+          // Tier A only: the agent's own turn fiber has no `ProcessManager.Service` in scope, so
+          // Tier B (setAlarm/enqueueMessage) is reachable only by child operations through the
+          // process-affinity HarnessService LayerSpec — not from here.
+          Layer.succeed(
+            Harness.HarnessService,
+            Harness.fromBinder({ feed: this._feed, runtime: this._runtime, binder: this.context }),
+          ),
           Operation.withInvocationOptions({ conversation: Obj.getURI(this._feed) }),
         ),
       ),
@@ -213,68 +229,12 @@ export class Session extends Resource {
   }
 }
 
-/**
- * Gives access to the ai session.
- */
-export class Service extends Context.Tag('@dxos/assistant/AiSessionService')<Service, Session>() {
-  /**
-   * Create a new session layer from options.
-   */
-  static layer = (options: Options): Layer.Layer<Service | AiContext.Service> =>
-    aiContextFromSession.pipe(
-      Layer.provideMerge(
-        Layer.scoped(
-          Service,
-          Effect.gen(function* () {
-            const session = yield* EffectEx.acquireReleaseResource(() => new Session(options));
-            return session;
-          }),
-        ),
-      ),
-    );
-
-  /**
-   * Create a new session with a new feed.
-   */
-  static layerNewFeed = (
-    options?: Omit<Options, 'feed' | 'runtime'>,
-  ): Layer.Layer<Service | AiContext.Service, never, Database.Service | Feed.FeedService> =>
-    Layer.unwrapScoped(
-      Effect.gen(function* () {
-        const feed = yield* Database.add(Feed.make());
-        const runtime = yield* Effect.runtime<Feed.FeedService>();
-        return Service.layer({ ...options, feed, runtime });
-      }),
-    );
-
-  /**
-   * Run a prompt in the current session.
-   */
-  static run = <R = never>(
-    params: RunProps<R>,
-  ): Effect.Effect<Message.Message[], AiRequest.RunError, AiRequest.RunRequirements | Service | R> =>
-    Effect.gen(function* () {
-      const session = yield* Service;
-      return yield* session.createRequest(params);
-    });
-}
-
-const aiContextFromSession = Layer.effect(
-  AiContext.Service,
-  Effect.gen(function* () {
-    const session = yield* Service;
-    return {
-      binder: session.context,
-    };
-  }),
-);
-
 const connectMcpServers = (
-  blueprints: readonly Blueprint.Blueprint[],
+  skills: readonly Skill.Skill[],
   spaceMcpServers: readonly McpServer.McpServer[] = [],
 ): Effect.Effect<OpaqueToolkit.OpaqueToolkit[], never, Trace.TraceService> => {
-  const blueprintServers: McpToolkit.McpToolkitOptions[] = pipe(
-    blueprints,
+  const skillServers: McpToolkit.McpToolkitOptions[] = pipe(
+    skills,
     Array.flatMap((_) => _.mcpServers ?? []),
     Array.map(({ url, protocol, apiKey }) => ({ url, protocol, apiKey })),
   );
@@ -283,7 +243,7 @@ const connectMcpServers = (
     protocol,
     apiKey,
   }));
-  const allServers = [...blueprintServers, ...spaceServers];
+  const allServers = [...skillServers, ...spaceServers];
 
   return pipe(
     allServers,