@dxos/assistant-toolkit 0.8.4-main.2c6827d → 0.8.4-main.3eb6e50203

package/dist/lib/{browser → neutral}/index.mjs

@@ -1,13 +1,11 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/blueprints/design/design-blueprint.ts
 import { ToolId } from "@dxos/ai";
 import { Blueprint } from "@dxos/blueprints";
-import { Obj as Obj10, Ref as Ref6 } from "@dxos/echo";
+import { Ref as Ref7 } from "@dxos/echo";
 import { Text as Text2 } from "@dxos/schema";
 import { trim as trim5 } from "@dxos/util";
 
@@ -22,7 +20,8 @@ import { AiService, ConsolePrinter, ModelName } from "@dxos/ai";
 import { AiSession, GenerationObserver, createToolkit } from "@dxos/assistant";
 import { Prompt, Template } from "@dxos/blueprints";
 import { Obj, Ref, Type } from "@dxos/echo";
-import { DatabaseService, TracingService, defineFunction } from "@dxos/functions";
+import { Database } from "@dxos/echo";
+import { TracingService, defineFunction } from "@dxos/functions";
 import { log } from "@dxos/log";
 var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/functions/agent/prompt.ts";
 var DEFAULT_MODEL = "@anthropic/claude-opus-4-0";
@@ -51,19 +50,19 @@ var prompt_default = defineFunction({
       input: data.input
     }, {
       F: __dxlog_file,
-      L: 40,
+      L: 41,
       S: this,
       C: (f, a) => f(...a)
     });
     const input = yield* Match.value(data.input).pipe(Match.when((value2) => Ref.isRef(value2), Effect.fnUntraced(function* (ref) {
-      const object = yield* DatabaseService.load(ref);
+      const object = yield* Database.load(ref);
       return Obj.toJSON(object);
     })), Match.orElse(() => Effect.succeed(data.input)));
-    yield* DatabaseService.flush({
+    yield* Database.flush({
       indexes: true
     });
-    const prompt = yield* DatabaseService.load(data.prompt);
-    const systemPrompt = data.systemPrompt ? yield* DatabaseService.load(data.systemPrompt) : void 0;
+    const prompt = yield* Database.load(data.prompt);
+    const systemPrompt = data.systemPrompt ? yield* Database.load(data.systemPrompt) : void 0;
     yield* TracingService.emitStatus({
       message: `Running ${prompt.id}`
     });
@@ -72,18 +71,18 @@ var prompt_default = defineFunction({
       input
     }, {
       F: __dxlog_file,
-      L: 70,
+      L: 71,
       S: this,
       C: (f, a) => f(...a)
     });
-    const blueprints = yield* Function.pipe(prompt.blueprints, Array2.appendAll(systemPrompt?.blueprints ?? []), Effect.forEach(DatabaseService.loadOption), Effect.map(Array2.filter(Option.isSome)), Effect.map(Array2.map((option) => option.value)));
-    const objects = yield* Function.pipe(prompt.context, Array2.appendAll(systemPrompt?.context ?? []), Effect.forEach(DatabaseService.loadOption), Effect.map(Array2.filter(Option.isSome)), Effect.map(Array2.map((option) => option.value)));
+    const blueprints = yield* Function.pipe(prompt.blueprints, Array2.appendAll(systemPrompt?.blueprints ?? []), Effect.forEach(Database.loadOption), Effect.map(Array2.filter(Option.isSome)), Effect.map(Array2.map((option) => option.value)));
     const toolkit = yield* createToolkit({
       blueprints
     });
-    const promptInstructions = yield* DatabaseService.load(prompt.instructions.source);
+    const objects = yield* Function.pipe(prompt.context, Array2.appendAll(systemPrompt?.context ?? []), Effect.forEach(Database.loadOption), Effect.map(Array2.filter(Option.isSome)), Effect.map(Array2.map((option) => option.value)));
+    const promptInstructions = yield* Database.load(prompt.instructions.source);
     const promptText = Template.process(promptInstructions.content, input);
-    const systemInstructions = systemPrompt ? yield* DatabaseService.load(systemPrompt.instructions.source) : void 0;
+    const systemInstructions = systemPrompt ? yield* Database.load(systemPrompt.instructions.source) : void 0;
     const systemText = systemInstructions ? Template.process(systemInstructions.content, {}) : void 0;
     const session = new AiSession();
     const result = yield* session.run({
@@ -211,7 +210,15 @@ var fetch_messages_default = defineFunction2({
       throw new Error("no channels found");
     }
     for (const channel of channels) {
-      console.log(channel.id, "name" in channel ? channel.name : void 0);
+      log2.info("channel", {
+        id: channel.id,
+        name: "name" in channel ? channel.name : void 0
+      }, {
+        F: __dxlog_file2,
+        L: 136,
+        S: this,
+        C: (f, a) => f(...a)
+      });
     }
     yield* TracingService2.emitStatus({
       message: `Will fetch from channels: ${channels.length}`
@@ -308,27 +315,56 @@ ${thread.messages.map((message) => `  ${message.sender.name}: ${message.blocks.f
 })(Discord || (Discord = {}));
 var Discord;
 
-// src/functions/document/read.ts
+// src/functions/document/create.ts
 import * as Effect3 from "effect/Effect";
 import * as Schema3 from "effect/Schema";
-import { ArtifactId } from "@dxos/assistant";
-import { DatabaseService as DatabaseService2, defineFunction as defineFunction3 } from "@dxos/functions";
+import { Database as Database2, Ref as Ref2 } from "@dxos/echo";
+import { defineFunction as defineFunction3 } from "@dxos/functions";
 import { Markdown } from "@dxos/plugin-markdown/types";
-var read_default = defineFunction3({
+var create_default = defineFunction3({
+  key: "dxos.org/function/markdown/create",
+  name: "Create markdown document",
+  description: "Creates a new markdown document.",
+  inputSchema: Schema3.Struct({
+    name: Schema3.String.annotations({
+      description: "Name of the document."
+    }),
+    content: Schema3.String.annotations({
+      description: "Content of the document."
+    })
+  }),
+  outputSchema: Schema3.Void,
+  handler: Effect3.fn(function* ({ data: { name, content } }) {
+    const doc = yield* Database2.add(Markdown.make({
+      name,
+      content
+    }));
+    return {
+      document: Ref2.make(doc)
+    };
+  })
+});
+
+// src/functions/document/read.ts
+import * as Effect4 from "effect/Effect";
+import * as Schema4 from "effect/Schema";
+import { Database as Database3, Type as Type2 } from "@dxos/echo";
+import { defineFunction as defineFunction4 } from "@dxos/functions";
+import { Markdown as Markdown2 } from "@dxos/plugin-markdown/types";
+var read_default = defineFunction4({
   key: "dxos.org/function/markdown/read",
   name: "Read markdown document",
-  description: "Read markdown document.",
-  inputSchema: Schema3.Struct({
-    id: ArtifactId.annotations({
-      description: "The ID of the document to read."
+  description: "Read markdown document. Note that result is a snapshot in time, and might have changed since the document was last read.",
+  inputSchema: Schema4.Struct({
+    document: Type2.Ref(Markdown2.Document).annotations({
+      description: "The document to read."
     })
   }),
-  outputSchema: Schema3.Struct({
-    content: Schema3.String
+  outputSchema: Schema4.Struct({
+    content: Schema4.String
   }),
-  handler: Effect3.fn(function* ({ data: { id } }) {
-    const doc = yield* DatabaseService2.resolve(ArtifactId.toDXN(id), Markdown.Document);
-    const { content } = yield* DatabaseService2.load(doc.content);
+  handler: Effect4.fn(function* ({ data: { document } }) {
+    const { content } = yield* document.pipe(Database3.load, Effect4.flatMap((doc) => doc.content.pipe(Database3.load)));
     return {
       content
     };
@@ -336,28 +372,30 @@ var read_default = defineFunction3({
 });
 
 // src/functions/document/update.ts
-import * as Effect4 from "effect/Effect";
-import * as Schema4 from "effect/Schema";
-import { ArtifactId as ArtifactId2 } from "@dxos/assistant";
-import { DatabaseService as DatabaseService3, defineFunction as defineFunction4 } from "@dxos/functions";
-import { Markdown as Markdown2 } from "@dxos/plugin-markdown/types";
-var update_default = defineFunction4({
+import * as Effect5 from "effect/Effect";
+import * as Schema5 from "effect/Schema";
+import { Database as Database4, Obj as Obj3, Type as Type3 } from "@dxos/echo";
+import { defineFunction as defineFunction5 } from "@dxos/functions";
+import { Markdown as Markdown3 } from "@dxos/plugin-markdown/types";
+var update_default = defineFunction5({
   key: "dxos.org/function/markdown/update",
   name: "Update markdown",
   description: "Updates the entire contents of the markdown document.",
-  inputSchema: Schema4.Struct({
-    id: ArtifactId2.annotations({
+  inputSchema: Schema5.Struct({
+    doc: Type3.Ref(Markdown3.Document).annotations({
       description: "The ID of the document to write."
     }),
-    content: Schema4.String.annotations({
+    content: Schema5.String.annotations({
       description: "New content to write to the document."
     })
   }),
-  outputSchema: Schema4.Void,
-  handler: Effect4.fn(function* ({ data: { id, content } }) {
-    const doc = yield* DatabaseService3.resolve(ArtifactId2.toDXN(id), Markdown2.Document);
-    const text = yield* DatabaseService3.load(doc.content);
-    text.content = content;
+  outputSchema: Schema5.Void,
+  handler: Effect5.fn(function* ({ data: { doc, content } }) {
+    const document = yield* Database4.load(doc);
+    const text = yield* Database4.load(document.content);
+    Obj3.change(text, (t) => {
+      t.content = content;
+    });
   })
 });
 
@@ -365,19 +403,20 @@ var update_default = defineFunction4({
 (function(Document2) {
   Document2.read = read_default;
   Document2.update = update_default;
+  Document2.create = create_default;
 })(Document || (Document = {}));
 var Document;
 
 // src/functions/entity-extraction/entity-extraction.ts
-import * as Toolkit3 from "@effect/ai/Toolkit";
-import * as Effect11 from "effect/Effect";
+import * as Effect12 from "effect/Effect";
 import * as Layer4 from "effect/Layer";
 import * as Predicate from "effect/Predicate";
-import * as Schema11 from "effect/Schema";
+import * as Schema12 from "effect/Schema";
 import { AiService as AiService3 } from "@dxos/ai";
-import { AiSession as AiSession3, makeToolExecutionServiceFromFunctions as makeToolExecutionServiceFromFunctions2, makeToolResolverFromFunctions as makeToolResolverFromFunctions2 } from "@dxos/assistant";
-import { Filter as Filter2, Obj as Obj7, Ref as Ref3 } from "@dxos/echo";
-import { DatabaseService as DatabaseService8, defineFunction as defineFunction9 } from "@dxos/functions";
+import { AiSession as AiSession3, GenericToolkit as GenericToolkit2, ToolExecutionServices as ToolExecutionServices2 } from "@dxos/assistant";
+import { Filter as Filter2, Obj as Obj8, Ref as Ref4, Type as Type7 } from "@dxos/echo";
+import { Database as Database9 } from "@dxos/echo";
+import { defineFunction as defineFunction10 } from "@dxos/functions";
 import { FunctionInvocationServiceLayerTest } from "@dxos/functions-runtime/testing";
 import { log as log5 } from "@dxos/log";
 import { LegacyOrganization as LegacyOrganization2, Message as Message2, Organization, Person as Person2 } from "@dxos/types";
@@ -387,37 +426,35 @@ import { trim as trim4 } from "@dxos/util";
 import * as Tool from "@effect/ai/Tool";
 import * as Toolkit from "@effect/ai/Toolkit";
 import * as Context from "effect/Context";
-import * as Effect5 from "effect/Effect";
+import * as Effect6 from "effect/Effect";
 import * as Function3 from "effect/Function";
 import * as Option3 from "effect/Option";
-import * as Schema5 from "effect/Schema";
+import * as Schema6 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
-import { Obj as Obj3 } from "@dxos/echo";
-import { Filter, Query } from "@dxos/echo";
-import { EntityKind, ObjectId, ReferenceAnnotationId, RelationSourceDXNId, RelationSourceId, RelationTargetDXNId, RelationTargetId, create, getEntityKind, getSchemaDXN, getSchemaTypename, getTypeAnnotation, getTypeIdentifierAnnotation } from "@dxos/echo/internal";
+import { Entity, Filter, Obj as Obj4, Query, Type as Type4 } from "@dxos/echo";
+import { Database as Database5 } from "@dxos/echo";
+import { ReferenceAnnotationId, RelationSourceDXNId, RelationSourceId, RelationTargetDXNId, RelationTargetId, createObject, getTypeAnnotation, getTypeIdentifierAnnotation } from "@dxos/echo/internal";
 import { isEncodedReference } from "@dxos/echo-protocol";
 import { mapAst } from "@dxos/effect";
-import { ContextQueueService, DatabaseService as DatabaseService4 } from "@dxos/functions";
-import { DXN } from "@dxos/keys";
+import { ContextQueueService } from "@dxos/functions";
+import { DXN, ObjectId } from "@dxos/keys";
 import { log as log3 } from "@dxos/log";
 import { deepMapValues, isNonNullable, trim } from "@dxos/util";
 var __dxlog_file3 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/crud/graph.ts";
-var Subgraph = Schema5.Struct({
+var Subgraph = Schema6.Struct({
   /** Objects and relations. */
-  objects: Schema5.Array(Schema5.Any)
+  objects: Schema6.Array(Schema6.Any)
 });
 var findRelatedSchema = async (db, anchor) => {
-  const allSchemas = [
-    ...db.graph.schemaRegistry.schemas
-  ];
+  const allSchemas = await db.graph.schemaRegistry.query().run();
   return allSchemas.filter((schema) => {
-    if (getTypeAnnotation(schema)?.kind !== EntityKind.Relation) {
+    if (getTypeAnnotation(schema)?.kind !== Entity.Kind.Relation) {
       return false;
     }
     return isSchemaAddressableByDxn(anchor, DXN.parse(getTypeAnnotation(schema).sourceSchema)) || isSchemaAddressableByDxn(anchor, DXN.parse(getTypeAnnotation(schema).targetSchema));
   }).map((schema) => ({
-    schema,
-    kind: "relation"
+    kind: "relation",
+    schema
   }));
 };
 var isSchemaAddressableByDxn = (schema, dxn) => {
@@ -426,34 +463,34 @@ var isSchemaAddressableByDxn = (schema, dxn) => {
   }
   const t = dxn.asTypeDXN();
   if (t) {
-    return t.type === getSchemaTypename(schema);
+    return t.type === Type4.getTypename(schema);
   }
   return false;
 };
 var LocalSearchToolkit = Toolkit.make(Tool.make("search_local_search", {
   description: "Search the local database for information using a vector index",
   parameters: {
-    query: Schema5.String.annotations({
+    query: Schema6.String.annotations({
       description: "The query to search for. Could be a question or a topic or a set of keywords."
     })
   },
-  success: Schema5.Unknown,
-  failure: Schema5.Never,
+  success: Schema6.Unknown,
+  failure: Schema6.Never,
   dependencies: [
-    DatabaseService4
+    Database5.Service
   ]
 }));
 var LocalSearchHandler = LocalSearchToolkit.toLayer({
-  search_local_search: Effect5.fn(function* ({ query }) {
-    const { objects } = yield* DatabaseService4.runQuery(Query.select(Filter.text(query, {
+  search_local_search: Effect6.fn(function* ({ query }) {
+    const objects = yield* Database5.runQuery(Query.select(Filter.text(query, {
       type: "vector"
     })));
     const results = [
       ...objects
     ];
-    const option = yield* Effect5.serviceOption(ContextQueueService);
+    const option = yield* Effect6.serviceOption(ContextQueueService);
     if (Option3.isSome(option)) {
-      const queueObjects = yield* Effect5.promise(() => option.value.queue.queryObjects());
+      const queueObjects = yield* Effect6.promise(() => option.value.queue.queryObjects());
       results.push(...queueObjects);
     }
     return trim`
@@ -469,10 +506,10 @@ var makeGraphWriterToolkit = ({ schema }) => {
   return Toolkit.make(Tool.make("graph_writer", {
     description: "Write to the local graph database",
     parameters: createExtractionSchema(schema).fields,
-    success: Schema5.Unknown,
-    failure: Schema5.Never,
+    success: Schema6.Unknown,
+    failure: Schema6.Never,
     dependencies: [
-      DatabaseService4,
+      Database5.Service,
       ContextQueueService
     ]
   }).annotateContext(Context.make(GraphWriterSchema, {
@@ -482,29 +519,29 @@ var makeGraphWriterToolkit = ({ schema }) => {
 var makeGraphWriterHandler = (toolkit, { onAppend } = {}) => {
   const { schema } = Context.get(toolkit.tools.graph_writer.annotations, GraphWriterSchema);
   return toolkit.toLayer({
-    graph_writer: Effect5.fn(function* (input) {
-      const { db } = yield* DatabaseService4;
+    graph_writer: Effect6.fn(function* (input) {
+      const { db } = yield* Database5.Service;
       const { queue } = yield* ContextQueueService;
-      const data = yield* Effect5.promise(() => sanitizeObjects(schema, input, db, queue));
-      yield* Effect5.promise(() => queue.append(data));
-      const dxns = data.map((obj) => Obj3.getDXN(obj));
+      const data = yield* Effect6.promise(() => sanitizeObjects(schema, input, db, queue));
+      yield* Effect6.promise(() => queue.append(data));
+      const dxns = data.map((obj) => Obj4.getDXN(obj));
       onAppend?.(dxns);
       return dxns;
     })
   });
 };
 var createExtractionSchema = (types) => {
-  return Schema5.Struct({
+  return Schema6.Struct({
     ...Object.fromEntries(types.map(preprocessSchema).map((schema, index) => [
       `objects_${getSanitizedSchemaName(types[index])}`,
-      Schema5.optional(Schema5.Array(schema)).annotations({
-        description: `The objects of type: ${getSchemaDXN(types[index])?.asTypeDXN().type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option3.getOrElse(() => ""))}`
+      Schema6.optional(Schema6.Array(schema)).annotations({
+        description: `The objects of type: ${Type4.getDXN(types[index])?.asTypeDXN().type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option3.getOrElse(() => ""))}`
       })
     ]))
   });
 };
 var getSanitizedSchemaName = (schema) => {
-  return getSchemaDXN(schema).asTypeDXN().type.replaceAll(/[^a-zA-Z0-9]+/g, "_");
+  return Type4.getDXN(schema).asTypeDXN().type.replaceAll(/[^a-zA-Z0-9]+/g, "_");
 };
 var sanitizeObjects = async (types, data, db, queue) => {
   const entries = types.map((type) => data[`objects_${getSanitizedSchemaName(type)}`]?.map((object) => ({
@@ -549,14 +586,14 @@ var sanitizeObjects = async (types, data, db, queue) => {
       }
       return recurse(value2);
     });
-    if (getEntityKind(entry.schema) === "relation") {
+    if (Entity.getKind(entry.schema) === "relation") {
       const sourceDxn = resolveId(data2.source);
       if (!sourceDxn) {
         log3.warn("source not found", {
           source: data2.source
         }, {
           F: __dxlog_file3,
-          L: 281,
+          L: 273,
           S: void 0,
           C: (f, a) => f(...a)
         });
@@ -567,7 +604,7 @@ var sanitizeObjects = async (types, data, db, queue) => {
           target: data2.target
         }, {
           F: __dxlog_file3,
-          L: 285,
+          L: 277,
           S: void 0,
           C: (f, a) => f(...a)
         });
@@ -582,7 +619,7 @@ var sanitizeObjects = async (types, data, db, queue) => {
       schema: entry.schema
     };
   }).filter((object) => !existingIds.has(object.data.id));
-  const { objects: dbObjects } = await db.query(Query.select(Filter.ids(...existingIds))).run();
+  const dbObjects = await db.query(Query.select(Filter.id(...existingIds))).run();
   const queueObjects = await queue?.getObjectsById([
     ...existingIds
   ]) ?? [];
@@ -596,7 +633,7 @@ var sanitizeObjects = async (types, data, db, queue) => {
     existingIds
   }, {
     F: __dxlog_file3,
-    L: 306,
+    L: 298,
     S: void 0,
     C: (f, a) => f(...a)
   });
@@ -627,7 +664,7 @@ var sanitizeObjects = async (types, data, db, queue) => {
       }
     }
     if (!skip) {
-      const obj = create(schema, data2);
+      const obj = createObject(schema, data2);
       enitties.set(obj.id, obj);
       return [
         obj
@@ -636,13 +673,13 @@ var sanitizeObjects = async (types, data, db, queue) => {
     return [];
   });
 };
-var SoftRef = Schema5.Struct({
-  "/": Schema5.String
+var SoftRef = Schema6.Struct({
+  "/": Schema6.String
 }).annotations({
   description: "Reference to another object."
 });
 var preprocessSchema = (schema) => {
-  const isRelationSchema = getEntityKind(schema) === "relation";
+  const isRelationSchema = Entity.getKind(schema) === "relation";
   const go = (ast, visited = /* @__PURE__ */ new Set()) => {
     if (visited.has(ast)) {
       return ast;
@@ -653,84 +690,83 @@ var preprocessSchema = (schema) => {
     }
     return mapAst(ast, (child) => go(child, visited));
   };
-  return Schema5.make(mapAst(schema.ast, (ast) => go(ast))).pipe(Schema5.omit("id"), Schema5.extend(Schema5.Struct({
-    id: Schema5.String.annotations({
+  return Schema6.make(mapAst(schema.ast, (ast) => go(ast))).pipe(Schema6.omit("id"), Schema6.extend(Schema6.Struct({
+    id: Schema6.String.annotations({
       description: "The id of this object. Come up with a unique id based on your judgement."
     })
-  })), isRelationSchema ? Schema5.extend(Schema5.Struct({
-    source: Schema5.String.annotations({
+  })), isRelationSchema ? Schema6.extend(Schema6.Struct({
+    source: Schema6.String.annotations({
       description: "The id of the source object for this relation."
     }),
-    target: Schema5.String.annotations({
+    target: Schema6.String.annotations({
       description: "The id of the target object for this relation."
     })
   })) : Function3.identity);
 };
 
 // src/functions/research/document-create.ts
-import * as Effect6 from "effect/Effect";
-import * as Schema6 from "effect/Schema";
-import { ArtifactId as ArtifactId3 } from "@dxos/assistant";
-import { Obj as Obj4, Relation } from "@dxos/echo";
-import { DatabaseService as DatabaseService5, TracingService as TracingService3, defineFunction as defineFunction5 } from "@dxos/functions";
+import * as Effect7 from "effect/Effect";
+import * as Schema7 from "effect/Schema";
+import { Database as Database6, Obj as Obj5, Relation, Type as Type5 } from "@dxos/echo";
+import { TracingService as TracingService3, defineFunction as defineFunction6 } from "@dxos/functions";
 import { log as log4 } from "@dxos/log";
-import { Markdown as Markdown3 } from "@dxos/plugin-markdown/types";
+import { Markdown as Markdown4 } from "@dxos/plugin-markdown/types";
 import { HasSubject } from "@dxos/types";
 import { trim as trim2 } from "@dxos/util";
 var __dxlog_file4 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/functions/research/document-create.ts";
-var document_create_default = defineFunction5({
+var document_create_default = defineFunction6({
   key: "dxos.org/function/research/document-create",
   name: "Create research document",
   description: "Creates a note summarizing the research.",
-  inputSchema: Schema6.Struct({
-    subject: ArtifactId3.annotations({
+  inputSchema: Schema7.Struct({
+    subject: Type5.Ref(Type5.Obj).annotations({
       description: trim2`
         ID of the object (organization, contact, etc.) for which the research was performed. 
       `
     }),
-    name: Schema6.String.annotations({
+    name: Schema7.String.annotations({
       description: "Name of the document."
     }),
-    content: Schema6.String.annotations({
+    content: Schema7.String.annotations({
       description: trim2`
         Content of the note. 
         Supports (and are prefered) references to research objects using @ syntax and <object> tags (refer to research blueprint instructions).
       `
     })
   }),
-  outputSchema: Schema6.Struct({
-    document: ArtifactId3.annotations({
+  outputSchema: Schema7.Struct({
+    document: Schema7.String.annotations({
       description: "DXN of the created document."
     })
   }),
-  handler: Effect6.fnUntraced(function* ({ data: { subject, name, content } }) {
+  handler: Effect7.fnUntraced(function* ({ data: { subject, name, content } }) {
     log4.info("Creating research document", {
       subject,
       name,
       content
     }, {
       F: __dxlog_file4,
-      L: 42,
+      L: 41,
       S: this,
       C: (f, a) => f(...a)
     });
-    yield* DatabaseService5.flush({
+    yield* Database6.flush({
       indexes: true
     });
     yield* TracingService3.emitStatus({
       message: "Creating research document..."
     });
-    const target = yield* DatabaseService5.resolve(ArtifactId3.toDXN(subject));
-    const object = yield* DatabaseService5.add(Markdown3.make({
+    const target = yield* Database6.load(subject);
+    const object = yield* Database6.add(Markdown4.make({
       name,
       content
     }));
-    yield* DatabaseService5.add(Relation.make(HasSubject.HasSubject, {
+    yield* Database6.add(Relation.make(HasSubject.HasSubject, {
       [Relation.Source]: object,
       [Relation.Target]: target,
       completedAt: (/* @__PURE__ */ new Date()).toISOString()
     }));
-    yield* DatabaseService5.flush({
+    yield* Database6.flush({
       indexes: true
     });
     log4.info("Created research document", {
@@ -738,12 +774,12 @@ var document_create_default = defineFunction5({
       object
     }, {
       F: __dxlog_file4,
-      L: 69,
+      L: 67,
       S: this,
       C: (f, a) => f(...a)
     });
     return {
-      document: Obj4.getDXN(object).toString()
+      document: Obj5.getDXN(object).toString()
     };
   })
 });
@@ -752,42 +788,43 @@ var document_create_default = defineFunction5({
 import * as Toolkit2 from "@effect/ai/Toolkit";
 import * as AnthropicTool from "@effect/ai-anthropic/AnthropicTool";
 import * as Array6 from "effect/Array";
-import * as Effect10 from "effect/Effect";
+import * as Effect11 from "effect/Effect";
 import * as Function4 from "effect/Function";
 import * as Layer3 from "effect/Layer";
 import * as Option4 from "effect/Option";
-import * as Schema10 from "effect/Schema";
-import * as String10 from "effect/String";
+import * as Schema11 from "effect/Schema";
+import * as String11 from "effect/String";
 import { AiService as AiService2, ConsolePrinter as ConsolePrinter2 } from "@dxos/ai";
-import { AiSession as AiSession2, GenerationObserver as GenerationObserver2, createToolkit as createToolkit2, makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from "@dxos/assistant";
+import { AiSession as AiSession2, GenerationObserver as GenerationObserver2, GenericToolkit, ToolExecutionServices, createToolkit as createToolkit2 } from "@dxos/assistant";
 import { Template as Template2 } from "@dxos/blueprints";
-import { Obj as Obj6 } from "@dxos/echo";
-import { DatabaseService as DatabaseService7, TracingService as TracingService4, defineFunction as defineFunction8 } from "@dxos/functions";
+import { Entity as Entity2, Obj as Obj7 } from "@dxos/echo";
+import { Database as Database8 } from "@dxos/echo";
+import { TracingService as TracingService4, defineFunction as defineFunction9 } from "@dxos/functions";
 import { FunctionInvocationServiceLayerTestMocked } from "@dxos/functions-runtime/testing";
 import { Person } from "@dxos/types";
 import { trim as trim3 } from "@dxos/util";
 
 // src/functions/exa/exa.ts
-import * as Effect7 from "effect/Effect";
-import * as Schema7 from "effect/Schema";
+import * as Effect8 from "effect/Effect";
+import * as Schema8 from "effect/Schema";
 import Exa from "exa-js";
-import { CredentialsService as CredentialsService2, defineFunction as defineFunction6 } from "@dxos/functions";
-var exa_default = defineFunction6({
+import { CredentialsService as CredentialsService2, defineFunction as defineFunction7 } from "@dxos/functions";
+var exa_default = defineFunction7({
   key: "dxos.org/function/exa",
   name: "Exa",
   description: "Search the web for information",
-  inputSchema: Schema7.Struct({
-    query: Schema7.String.annotations({
+  inputSchema: Schema8.Struct({
+    query: Schema8.String.annotations({
       description: "The query to search for."
     })
   }),
-  outputSchema: Schema7.Unknown,
-  handler: Effect7.fnUntraced(function* ({ data: { query } }) {
+  outputSchema: Schema8.Unknown,
+  handler: Effect8.fnUntraced(function* ({ data: { query } }) {
     const credential = yield* CredentialsService2.getCredential({
       service: "exa.ai"
     });
     const exa = new Exa(credential.apiKey);
-    const context = yield* Effect7.promise(async () => exa.searchAndContents(query, {
+    const context = yield* Effect8.promise(async () => exa.searchAndContents(query, {
       type: "auto",
       text: {
         maxCharacters: 3e3
@@ -799,11 +836,11 @@ var exa_default = defineFunction6({
 });
 
 // src/functions/exa/mock.ts
-import * as Effect8 from "effect/Effect";
-import * as Schema8 from "effect/Schema";
-import { defineFunction as defineFunction7 } from "@dxos/functions";
+import * as Effect9 from "effect/Effect";
+import * as Schema9 from "effect/Schema";
+import { defineFunction as defineFunction8 } from "@dxos/functions";
 
-// src/testing/data/exa-search-1748337321991.ts
+// src/functions/exa/data/exa-search-1748337321991.ts
 var exa_search_1748337321991_default = {
   requestId: "324936368a74f4db978982172bc18a6c",
   autopromptString: "AI personal knowledge management tools projects 2024",
@@ -959,7 +996,7 @@ var exa_search_1748337321991_default = {
   }
 };
 
-// src/testing/data/exa-search-1748337331526.ts
+// src/functions/exa/data/exa-search-1748337331526.ts
 var exa_search_1748337331526_default = {
   requestId: "0dc12e344fa649884456960ca1a54954",
   autopromptString: "PKM software artificial intelligence integration open source projects",
@@ -1182,7 +1219,7 @@ npm run tauri dev
   }
 };
 
-// src/testing/data/exa-search-1748337344119.ts
+// src/functions/exa/data/exa-search-1748337344119.ts
 var exa_search_1748337344119_default = {
   requestId: "32df0c541f9883180b35e04caece4374",
   autopromptString: "open source AI knowledge management projects features comparison 2024",
@@ -1305,7 +1342,7 @@ var exa_search_1748337344119_default = {
   }
 };
 
-// src/testing/data/index.ts
+// src/functions/exa/data/index.ts
 var SEARCH_RESULTS = [
   exa_search_1748337321991_default,
   exa_search_1748337331526_default,
@@ -1313,17 +1350,17 @@ var SEARCH_RESULTS = [
 ];
 
 // src/functions/exa/mock.ts
-var mock_default = defineFunction7({
+var mock_default = defineFunction8({
   key: "dxos.org/function/exa-mock",
   name: "Exa mock",
   description: "Search the web for information",
-  inputSchema: Schema8.Struct({
-    query: Schema8.String.annotations({
+  inputSchema: Schema9.Struct({
+    query: Schema9.String.annotations({
       description: "The query to search for."
     })
   }),
-  outputSchema: Schema8.Unknown,
-  handler: Effect8.fnUntraced(function* ({ data: { query } }) {
+  outputSchema: Schema9.Unknown,
+  handler: Effect9.fnUntraced(function* ({ data: { query } }) {
     const result = SEARCH_RESULTS.reduce((closest, current) => {
       if (!current.autopromptString) {
         return closest;
@@ -1359,31 +1396,33 @@ var levenshteinDistance = (str1, str2) => {
 };
 
 // src/functions/research/research-graph.ts
-import * as Effect9 from "effect/Effect";
+import * as Effect10 from "effect/Effect";
 import * as Layer2 from "effect/Layer";
-import * as Schema9 from "effect/Schema";
-import { Obj as Obj5, Query as Query2, Ref as Ref2, Type as Type2 } from "@dxos/echo";
+import * as Schema10 from "effect/Schema";
+import { Obj as Obj6, Query as Query2, Ref as Ref3, Type as Type6 } from "@dxos/echo";
+import { Database as Database7 } from "@dxos/echo";
+import { SystemTypeAnnotation } from "@dxos/echo/internal";
 import { Queue } from "@dxos/echo-db";
-import { ContextQueueService as ContextQueueService2, DatabaseService as DatabaseService6, QueueService } from "@dxos/functions";
-var ResearchGraph = Schema9.Struct({
-  queue: Type2.Ref(Queue)
-}).pipe(Type2.Obj({
+import { ContextQueueService as ContextQueueService2, QueueService } from "@dxos/functions";
+var ResearchGraph = Schema10.Struct({
+  queue: Type6.Ref(Queue)
+}).pipe(Type6.object({
   typename: "dxos.org/type/ResearchGraph",
   version: "0.1.0"
-}));
-var queryResearchGraph = Effect9.fn("queryResearchGraph")(function* () {
-  const { objects } = yield* DatabaseService6.runQuery(Query2.type(ResearchGraph));
+}), SystemTypeAnnotation.set(true));
+var queryResearchGraph = Effect10.fn("queryResearchGraph")(function* () {
+  const objects = yield* Database7.runQuery(Query2.type(ResearchGraph));
   return objects.at(0);
 });
-var createResearchGraph = Effect9.fn("createResearchGraph")(function* () {
+var createResearchGraph = Effect10.fn("createResearchGraph")(function* () {
   const queue = yield* QueueService.createQueue();
-  return yield* DatabaseService6.add(Obj5.make(ResearchGraph, {
-    queue: Ref2.fromDXN(queue.dxn)
+  return yield* Database7.add(Obj6.make(ResearchGraph, {
+    queue: Ref3.fromDXN(queue.dxn)
   }));
 });
-var contextQueueLayerFromResearchGraph = Layer2.unwrapEffect(Effect9.gen(function* () {
+var contextQueueLayerFromResearchGraph = Layer2.unwrapEffect(Effect10.gen(function* () {
   const researchGraph = (yield* queryResearchGraph()) ?? (yield* createResearchGraph());
-  const researchQueue = yield* DatabaseService6.load(researchGraph.queue);
+  const researchQueue = yield* Database7.load(researchGraph.queue);
   return ContextQueueService2.layer(researchQueue);
 }));
 
@@ -1392,7 +1431,7 @@ var research_instructions_default = "You are the Research Agent.\n\nThe Research
 
 // src/functions/research/types.ts
 import { Text } from "@dxos/schema";
-import { Event, HasConnection, HasRelationship, LegacyOrganization, LegacyPerson, Project, Task } from "@dxos/types";
+import { Event, HasConnection, HasRelationship, LegacyOrganization, LegacyPerson, Pipeline, Task } from "@dxos/types";
 var ResearchDataTypes = [
   // Objects
   Event.Event,
@@ -1403,13 +1442,13 @@ var ResearchDataTypes = [
   // TODO(wittjosiah): Until views (e.g., Table) support relations this needs to be expressed via organization ref.
   // Employer.Employer,
   LegacyPerson,
-  Project.Project,
+  Pipeline.Pipeline,
   HasRelationship.HasRelationship,
   HasConnection.HasConnection
 ];
 
 // src/functions/research/research.ts
-var research_default = defineFunction8({
+var research_default = defineFunction9({
   key: "dxos.org/function/research",
   name: "Research",
   description: trim3`
@@ -1417,24 +1456,24 @@ var research_default = defineFunction8({
     Inserts structured data into the research graph. 
     Creates a research summary and returns the objects created.
   `,
-  inputSchema: Schema10.Struct({
-    query: Schema10.String.annotations({
+  inputSchema: Schema11.Struct({
+    query: Schema11.String.annotations({
       description: trim3`
         The search query.
         If doing research on an object then load it first and pass it as JSON.
       `
     }),
-    instructions: Schema10.optional(Schema10.String).annotations({
+    instructions: Schema11.optional(Schema11.String).annotations({
       description: trim3`
         The instructions for the research agent. 
       `
     }),
     // TOOD(burdon): Move to context.
-    mockSearch: Schema10.optional(Schema10.Boolean).annotations({
+    mockSearch: Schema11.optional(Schema11.Boolean).annotations({
       description: "Whether to use the mock search tool.",
       default: false
     }),
-    entityExtraction: Schema10.optional(Schema10.Boolean).annotations({
+    entityExtraction: Schema11.optional(Schema11.Boolean).annotations({
       description: trim3`
         Whether to extract structured entities from the research. 
         Experimental feature only enable if user explicitly requests it.
@@ -1442,17 +1481,17 @@ var research_default = defineFunction8({
       default: false
     })
   }),
-  outputSchema: Schema10.Struct({
-    document: Schema10.optional(Schema10.String).annotations({
+  outputSchema: Schema11.Struct({
+    document: Schema11.optional(Schema11.String).annotations({
       description: "The generated research document."
     }),
-    objects: Schema10.Array(Schema10.Unknown).annotations({
+    objects: Schema11.Array(Schema11.Unknown).annotations({
       description: "Structured objects created during the research process."
     })
   }),
-  handler: Effect10.fnUntraced(function* ({ data: { query, instructions: instructions6, mockSearch = false, entityExtraction = false } }) {
+  handler: Effect11.fnUntraced(function* ({ data: { query, instructions: instructions7, mockSearch = false, entityExtraction = false } }) {
     if (mockSearch) {
-      const mockPerson = yield* DatabaseService7.add(Obj6.make(Person.Person, {
+      const mockPerson = yield* Database8.add(Obj7.make(Person.Person, {
         preferredName: "John Doe",
         emails: [
           {
@@ -1468,14 +1507,14 @@ var research_default = defineFunction8({
       return {
         document: trim3`
             The research ran in test-mode and was mocked. Proceed as usual.
-            We reference John Doe to test reference: ${Obj6.getDXN(mockPerson)}
+            We reference John Doe to test reference: ${Obj7.getDXN(mockPerson)}
           `,
         objects: [
-          Obj6.toJSON(mockPerson)
+          Obj7.toJSON(mockPerson)
         ]
       };
     }
-    yield* DatabaseService7.flush({
+    yield* Database8.flush({
       indexes: true
     });
     yield* TracingService4.emitStatus({
@@ -1497,34 +1536,26 @@ var research_default = defineFunction8({
     }
     const finishedToolkit = yield* createToolkit2({
       toolkit
-    }).pipe(Effect10.provide(handlers));
+    }).pipe(Effect11.provide(handlers));
     const session = new AiSession2();
     const result = yield* session.run({
       prompt: query,
       system: join(Template2.process(research_instructions_default, {
         entityExtraction
-      }), instructions6 && `<instructions>${instructions6}</instructions>`),
+      }), instructions7 && `<instructions>${instructions7}</instructions>`),
       toolkit: finishedToolkit,
       observer: GenerationObserver2.fromPrinter(new ConsolePrinter2({
         tag: "research"
       }))
     });
-    const objects = yield* Effect10.forEach(objectDXNs, (dxn) => DatabaseService7.resolve(dxn)).pipe(Effect10.map(Array6.map((obj) => Obj6.toJSON(obj))));
+    const objects = yield* Effect11.forEach(objectDXNs, (dxn) => Database8.resolve(dxn)).pipe(Effect11.map(Array6.map((obj) => Entity2.toJSON(obj))));
     return {
       document: extractLastTextBlock(result),
       objects
     };
-  }, Effect10.provide(Layer3.mergeAll(
-    AiService2.model("@anthropic/claude-sonnet-4-0"),
-    // TODO(dmaretskyi): Extract.
-    makeToolResolverFromFunctions([
-      exa_default,
-      mock_default
-    ], Toolkit2.make()),
-    makeToolExecutionServiceFromFunctions(Toolkit2.make(), Layer3.empty)
-  ).pipe(Layer3.provide(
+  }, Effect11.provide(Layer3.mergeAll(AiService2.model("@anthropic/claude-sonnet-4-0"), ToolExecutionServices).pipe(Layer3.provide(
     // TODO(dmaretskyi): This should be provided by environment.
-    Layer3.mergeAll(FunctionInvocationServiceLayerTestMocked({
+    Layer3.mergeAll(GenericToolkit.providerEmpty, FunctionInvocationServiceLayerTestMocked({
       functions: [
         exa_default,
         mock_default
@@ -1534,7 +1565,7 @@ var research_default = defineFunction8({
 });
 var join = (...strings) => strings.filter(Boolean).join("\n\n");
 var extractLastTextBlock = (result) => {
-  return Function4.pipe(result, Array6.last, Option4.map(Function4.flow((_) => _.blocks, Array6.reverse, Array6.dropWhile((_) => _._tag === "summary"), Array6.takeWhile((_) => _._tag === "text"), Array6.reverse, Array6.map((_) => _.text), Array6.reduce("", String10.concat))), Option4.getOrElse(() => ""));
+  return Function4.pipe(result, Array6.last, Option4.map(Function4.flow((_) => _.blocks, Array6.reverse, Array6.dropWhile((_) => _._tag === "summary"), Array6.takeWhile((_) => _._tag === "text"), Array6.reverse, Array6.map((_) => _.text), Array6.reduce("", String11.concat))), Option4.getOrElse(() => ""));
 };
 
 // src/functions/research/index.ts
@@ -1546,26 +1577,26 @@ var Research;
 
 // src/functions/entity-extraction/entity-extraction.ts
 var __dxlog_file5 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/functions/entity-extraction/entity-extraction.ts";
-var entity_extraction_default = defineFunction9({
+var entity_extraction_default = defineFunction10({
   key: "dxos.org/functions/entity-extraction",
   name: "Entity Extraction",
   description: "Extracts entities from emails and transcripts.",
-  inputSchema: Schema11.Struct({
+  inputSchema: Schema12.Struct({
     source: Message2.Message.annotations({
       description: "Email or transcript to extract entities from."
     }),
     // TODO(dmaretskyi): Consider making this an array of blueprints instead.
-    instructions: Schema11.optional(Schema11.String).annotations({
+    instructions: Schema12.optional(Schema12.String).annotations({
       description: "Instructions extraction process."
     })
   }),
-  outputSchema: Schema11.Struct({
-    entities: Schema11.optional(Schema11.Array(Obj7.Any).annotations({
+  outputSchema: Schema12.Struct({
+    entities: Schema12.optional(Schema12.Array(Type7.Obj).annotations({
       description: "Extracted entities."
     }))
   }),
-  handler: Effect11.fnUntraced(function* ({ data: { source: message, instructions: instructions6 } }) {
-    const tags = Obj7.getMeta(message)?.tags;
+  handler: Effect12.fnUntraced(function* ({ data: { source: message, instructions: instructions7 } }) {
+    const tags = Obj8.getMeta(message)?.tags;
     const contact = yield* extractContact(message.sender, tags);
     let organization = null;
     if (contact && !contact.organization) {
@@ -1578,12 +1609,12 @@ var entity_extraction_default = defineFunction9({
       const GraphWriterHandler = makeGraphWriterHandler(GraphWriterToolkit, {
         onAppend: (dxns) => created.push(...dxns)
       });
-      const toolkit = yield* GraphWriterToolkit.pipe(Effect11.provide(GraphWriterHandler.pipe(Layer4.provide(contextQueueLayerFromResearchGraph))));
+      const toolkit = yield* GraphWriterToolkit.pipe(Effect12.provide(GraphWriterHandler.pipe(Layer4.provide(contextQueueLayerFromResearchGraph))));
       yield* new AiSession3().run({
         system: trim4`
             Extract the sender's organization from the email. If you are not sure, do nothing.
             The extracted organization URL must match the sender's email domain.
-            ${instructions6 ? "<user_intructions>" + instructions6 + "</user_intructions>" : ""},
+            ${instructions7 ? "<user_intructions>" + instructions7 + "</user_intructions>" : ""},
           `,
         prompt: JSON.stringify({
           source: message,
@@ -1594,10 +1625,15 @@ var entity_extraction_default = defineFunction9({
       if (created.length > 1) {
         throw new Error("Multiple organizations created");
       } else if (created.length === 1) {
-        organization = yield* DatabaseService8.resolve(created[0], Organization.Organization);
-        Obj7.getMeta(organization).tags ??= [];
-        Obj7.getMeta(organization).tags.push(...tags ?? []);
-        contact.organization = Ref3.make(organization);
+        organization = yield* Database9.resolve(created[0], Organization.Organization);
+        Obj8.change(organization, (org) => {
+          const meta = Obj8.getMeta(org);
+          meta.tags ??= [];
+          meta.tags.push(...tags ?? []);
+        });
+        Obj8.change(contact, (c) => {
+          c.organization = Ref4.make(organization);
+        });
       }
     }
     return {
@@ -1606,12 +1642,12 @@ var entity_extraction_default = defineFunction9({
         organization
       ].filter(Predicate.isNotNullable)
     };
-  }, Effect11.provide(Layer4.mergeAll(AiService3.model("@anthropic/claude-sonnet-4-0"), makeToolResolverFromFunctions2([], Toolkit3.make()), makeToolExecutionServiceFromFunctions2(Toolkit3.make(), Layer4.empty)).pipe(Layer4.provide(
+  }, Effect12.provide(Layer4.mergeAll(AiService3.model("@anthropic/claude-sonnet-4-0"), ToolExecutionServices2).pipe(Layer4.provide(
     // TODO(dmaretskyi): This should be provided by environment.
-    Layer4.mergeAll(FunctionInvocationServiceLayerTest())
+    Layer4.mergeAll(GenericToolkit2.providerEmpty, FunctionInvocationServiceLayerTest())
   ))))
 });
-var extractContact = Effect11.fn("extractContact")(function* (actor, tags) {
+var extractContact = Effect12.fn("extractContact")(function* (actor, tags) {
   const name = actor.name;
   const email = actor.email;
   if (!email) {
@@ -1619,13 +1655,13 @@ var extractContact = Effect11.fn("extractContact")(function* (actor, tags) {
       actor
     }, {
       F: __dxlog_file5,
-      L: 100,
+      L: 110,
       S: this,
       C: (f, a) => f(...a)
     });
     return void 0;
   }
-  const { objects: existingContacts } = yield* DatabaseService8.runQuery(Filter2.type(Person2.Person));
+  const existingContacts = yield* Database9.runQuery(Filter2.type(Person2.Person));
   const existingContact = existingContacts.find((contact) => contact.emails?.some((contactEmail) => contactEmail.value === email));
   if (existingContact) {
     log5.info("Contact already exists", {
@@ -1633,25 +1669,31 @@ var extractContact = Effect11.fn("extractContact")(function* (actor, tags) {
       existingContact
     }, {
       F: __dxlog_file5,
-      L: 113,
+      L: 123,
       S: this,
       C: (f, a) => f(...a)
     });
     return existingContact;
   }
-  const newContact = Obj7.make(Person2.Person, {
-    [Obj7.Meta]: {
-      tags
-    },
+  const newContact = Obj8.make(Person2.Person, {
+    ...tags ? {
+      [Obj8.Meta]: {
+        tags: [
+          ...tags
+        ]
+      }
+    } : {},
     emails: [
       {
         value: email
       }
     ]
   });
-  yield* DatabaseService8.add(newContact);
+  yield* Database9.add(newContact);
   if (name) {
-    newContact.fullName = name;
+    Obj8.change(newContact, (c) => {
+      c.fullName = name;
+    });
   }
   const emailDomain = email.split("@")[1]?.toLowerCase();
   if (!emailDomain) {
@@ -1659,7 +1701,7 @@ var extractContact = Effect11.fn("extractContact")(function* (actor, tags) {
       email
     }, {
       F: __dxlog_file5,
-      L: 129,
+      L: 141,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -1669,11 +1711,11 @@ var extractContact = Effect11.fn("extractContact")(function* (actor, tags) {
     emailDomain
   }, {
     F: __dxlog_file5,
-    L: 133,
+    L: 145,
     S: this,
     C: (f, a) => f(...a)
   });
-  const { objects: existingOrganisations } = yield* DatabaseService8.runQuery(Filter2.type(Organization.Organization));
+  const existingOrganisations = yield* Database9.runQuery(Filter2.type(Organization.Organization));
   const matchingOrg = existingOrganisations.find((org) => {
     if (org.website) {
       try {
@@ -1686,7 +1728,7 @@ var extractContact = Effect11.fn("extractContact")(function* (actor, tags) {
           error: e
         }, {
           F: __dxlog_file5,
-          L: 151,
+          L: 163,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -1700,11 +1742,13 @@ var extractContact = Effect11.fn("extractContact")(function* (actor, tags) {
       organization: matchingOrg
     }, {
       F: __dxlog_file5,
-      L: 159,
+      L: 174,
       S: this,
       C: (f, a) => f(...a)
     });
-    newContact.organization = Ref3.make(matchingOrg);
+    Obj8.change(newContact, (c) => {
+      c.organization = Ref4.make(matchingOrg);
+    });
   }
   return newContact;
 });
@@ -1719,57 +1763,58 @@ var EntityExtraction;
 import * as FetchHttpClient2 from "@effect/platform/FetchHttpClient";
 import * as HttpClient from "@effect/platform/HttpClient";
 import * as Array9 from "effect/Array";
-import * as Effect13 from "effect/Effect";
+import * as Effect14 from "effect/Effect";
 import * as Function5 from "effect/Function";
-import * as Schema12 from "effect/Schema";
-import { Filter as Filter4, Obj as Obj9, Query as Query4, Ref as Ref5 } from "@dxos/echo";
-import { DatabaseService as DatabaseService10, defineFunction as defineFunction10, withAuthorization } from "@dxos/functions";
+import * as Schema13 from "effect/Schema";
+import { Filter as Filter4, Obj as Obj10, Query as Query4, Ref as Ref6 } from "@dxos/echo";
+import { Database as Database11 } from "@dxos/echo";
+import { CredentialsService as CredentialsService3, defineFunction as defineFunction11, withAuthorization } from "@dxos/functions";
 import { log as log7 } from "@dxos/log";
-import { Person as Person3, Project as Project2, Task as Task2 } from "@dxos/types";
+import { Person as Person3, Pipeline as Pipeline2, Task as Task2 } from "@dxos/types";
 
 // src/sync/sync.ts
-import * as Effect12 from "effect/Effect";
-import { Filter as Filter3, Obj as Obj8, Query as Query3, Ref as Ref4 } from "@dxos/echo";
-import { DatabaseService as DatabaseService9 } from "@dxos/functions";
+import * as Effect13 from "effect/Effect";
+import { Filter as Filter3, Obj as Obj9, Query as Query3, Ref as Ref5 } from "@dxos/echo";
+import { Database as Database10 } from "@dxos/echo";
 import { failedInvariant } from "@dxos/invariant";
 import { log as log6 } from "@dxos/log";
 var __dxlog_file6 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/sync/sync.ts";
-var syncObjects = Effect12.fn("syncObjects")(function* (objs, { foreignKeyId }) {
-  return yield* Effect12.forEach(objs, Effect12.fnUntraced(function* (obj) {
+var syncObjects = Effect13.fn("syncObjects")(function* (objs, { foreignKeyId }) {
+  return yield* Effect13.forEach(objs, Effect13.fnUntraced(function* (obj) {
     for (const key of Object.keys(obj)) {
       if (typeof key !== "string" || key === "id") continue;
-      if (!Ref4.isRef(obj[key])) continue;
+      if (!Ref5.isRef(obj[key])) continue;
       const ref = obj[key];
       if (!ref.target) continue;
-      if (Obj8.getDXN(ref.target).isLocalObjectId()) {
+      if (Obj9.getDXN(ref.target).isLocalObjectId()) {
         const [target] = yield* syncObjects([
           ref.target
         ], {
           foreignKeyId
         });
-        obj[key] = Ref4.make(target);
+        obj[key] = Ref5.make(target);
       }
     }
-    const schema = Obj8.getSchema(obj) ?? failedInvariant("No schema.");
-    const foreignId = Obj8.getKeys(obj, foreignKeyId)[0]?.id ?? failedInvariant("No foreign key.");
-    const { objects: [existing] } = yield* DatabaseService9.runQuery(Query3.select(Filter3.foreignKeys(schema, [
+    const schema = Obj9.getSchema(obj) ?? failedInvariant("No schema.");
+    const foreignId = Obj9.getKeys(obj, foreignKeyId)[0]?.id ?? failedInvariant("No foreign key.");
+    const [existing] = yield* Database10.runQuery(Query3.select(Filter3.foreignKeys(schema, [
       {
         source: foreignKeyId,
         id: foreignId
       }
     ])));
     log6("sync object", {
-      type: Obj8.getTypename(obj),
+      type: Obj9.getTypename(obj),
       foreignId,
-      existing: existing ? Obj8.getDXN(existing) : void 0
+      existing: existing ? Obj9.getDXN(existing) : void 0
     }, {
       F: __dxlog_file6,
-      L: 47,
+      L: 48,
       S: this,
       C: (f, a) => f(...a)
     });
     if (!existing) {
-      yield* DatabaseService9.add(obj);
+      yield* Database10.add(obj);
       return obj;
     } else {
       copyObjectData(existing, obj);
@@ -1780,23 +1825,25 @@ var syncObjects = Effect12.fn("syncObjects")(function* (objs, { foreignKeyId })
   });
 });
 var copyObjectData = (existing, newObj) => {
-  for (const key of Object.keys(newObj)) {
-    if (typeof key !== "string" || key === "id") continue;
-    if (typeof newObj[key] !== "string" && typeof newObj[key] !== "number" && typeof newObj[key] !== "boolean" && !Ref4.isRef(newObj[key])) continue;
-    existing[key] = newObj[key];
-  }
-  for (const key of Object.keys(existing)) {
-    if (typeof key !== "string" || key === "id") continue;
-    if (!(key in newObj)) {
-      delete existing[key];
+  Obj9.change(existing, (obj) => {
+    for (const key of Object.keys(newObj)) {
+      if (typeof key !== "string" || key === "id") continue;
+      if (typeof newObj[key] !== "string" && typeof newObj[key] !== "number" && typeof newObj[key] !== "boolean" && !Ref5.isRef(newObj[key])) continue;
+      obj[key] = newObj[key];
     }
-  }
-  for (const foreignKey of Obj8.getMeta(newObj).keys) {
-    Obj8.deleteKeys(existing, foreignKey.source);
-    Obj8.getMeta(existing).keys.push({
-      ...foreignKey
-    });
-  }
+    for (const key of Object.keys(obj)) {
+      if (typeof key !== "string" || key === "id") continue;
+      if (!(key in newObj)) {
+        delete obj[key];
+      }
+    }
+    for (const foreignKey of Obj9.getMeta(newObj).keys) {
+      Obj9.deleteKeys(obj, foreignKey.source);
+      Obj9.getMeta(obj).keys.push({
+        ...foreignKey
+      });
+    }
+  });
 };
 
 // src/util/graphql.ts
@@ -1826,7 +1873,7 @@ query Issues($teamId: String!, $after: DateTimeOrDuration!) {
             updatedAt
             description
             assignee { id, name }
-            state { 
+            state {
                 name
             }
             project {
@@ -1847,25 +1894,26 @@ query Issues($teamId: String!, $after: DateTimeOrDuration!) {
 var LINEAR_ID_KEY = "linear.app/id";
 var LINEAR_TEAM_ID_KEY = "linear.app/teamId";
 var LINEAR_UPDATED_AT_KEY = "linear.app/updatedAt";
-var sync_issues_default = defineFunction10({
+var sync_issues_default = defineFunction11({
   key: "dxos.org/function/linear/sync-issues",
   name: "Linear",
   description: "Sync issues from Linear.",
-  inputSchema: Schema12.Struct({
-    team: Schema12.String.annotations({
+  inputSchema: Schema13.Struct({
+    team: Schema13.String.annotations({
       description: "Linear team id."
     })
   }),
-  handler: Effect13.fnUntraced(function* ({ data }) {
-    const client = yield* HttpClient.HttpClient.pipe(Effect13.map(withAuthorization({
+  handler: Effect14.fnUntraced(function* ({ data }) {
+    const credential = yield* CredentialsService3.getCredential({
       service: "linear.app"
-    })));
+    });
+    const client = yield* HttpClient.HttpClient.pipe(Effect14.map(withAuthorization(credential.apiKey)));
     const after = yield* getLatestUpdateTimestamp(data.team, Task2.Task);
     log7.info("will fetch", {
       after
     }, {
       F: __dxlog_file7,
-      L: 91,
+      L: 93,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -1883,7 +1931,7 @@ var sync_issues_default = defineFunction10({
       count: tasks.length
     }, {
       F: __dxlog_file7,
-      L: 104,
+      L: 106,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -1893,19 +1941,19 @@ var sync_issues_default = defineFunction10({
       }),
       syncComplete: tasks.length < 150
     };
-  }, Effect13.provide(FetchHttpClient2.layer))
+  }, Effect14.provide(FetchHttpClient2.layer))
 });
-var getLatestUpdateTimestamp = Effect13.fnUntraced(function* (teamId, dataType) {
-  const { objects: existingTasks } = yield* DatabaseService10.runQuery(Query4.type(dataType).select(Filter4.foreignKeys(dataType, [
+var getLatestUpdateTimestamp = Effect14.fnUntraced(function* (teamId, dataType) {
+  const existingTasks = yield* Database11.runQuery(Query4.type(dataType).select(Filter4.foreignKeys(dataType, [
     {
       source: LINEAR_TEAM_ID_KEY,
       id: teamId
     }
   ])));
-  return Function5.pipe(existingTasks, Array9.map((task) => Obj9.getKeys(task, LINEAR_UPDATED_AT_KEY).at(0)?.id), Array9.filter((x) => x !== void 0), Array9.reduce("2025-01-01T00:00:00.000Z", (acc, x) => x > acc ? x : acc));
+  return Function5.pipe(existingTasks, Array9.map((task) => Obj10.getKeys(task, LINEAR_UPDATED_AT_KEY).at(0)?.id), Array9.filter((x) => x !== void 0), Array9.reduce("2025-01-01T00:00:00.000Z", (acc, x) => x > acc ? x : acc));
 });
-var mapLinearPerson = (person, { teamId }) => Obj9.make(Person3.Person, {
-  [Obj9.Meta]: {
+var mapLinearPerson = (person, { teamId }) => Obj10.make(Person3.Person, {
+  [Obj10.Meta]: {
     keys: [
       {
         id: person.id,
@@ -1919,8 +1967,8 @@ var mapLinearPerson = (person, { teamId }) => Obj9.make(Person3.Person, {
   },
   nickname: person.name
 });
-var mapLinearIssue = (issue, { teamId }) => Obj9.make(Task2.Task, {
-  [Obj9.Meta]: {
+var mapLinearIssue = (issue, { teamId }) => Obj10.make(Task2.Task, {
+  [Obj10.Meta]: {
     keys: [
       {
         id: issue.id,
@@ -1938,13 +1986,13 @@ var mapLinearIssue = (issue, { teamId }) => Obj9.make(Task2.Task, {
   },
   title: issue.title ?? void 0,
   description: issue.description ?? void 0,
-  assigned: !issue.assignee ? void 0 : Ref5.make(mapLinearPerson(issue.assignee, {
+  assigned: !issue.assignee ? void 0 : Ref6.make(mapLinearPerson(issue.assignee, {
     teamId
   })),
   // TODO(dmaretskyi): Sync those (+ linear team as org?).
   // state: issue.state.name,
-  project: !issue.project ? void 0 : Ref5.make(Project2.make({
-    [Obj9.Meta]: {
+  project: !issue.project ? void 0 : Ref6.make(Pipeline2.make({
+    [Obj10.Meta]: {
       keys: [
         {
           id: issue.project.id,
@@ -1967,26 +2015,26 @@ var mapLinearIssue = (issue, { teamId }) => Obj9.make(Task2.Task, {
 var Linear;
 
 // src/functions/tasks/read.ts
-import * as Effect14 from "effect/Effect";
-import * as Schema13 from "effect/Schema";
-import { ArtifactId as ArtifactId4 } from "@dxos/assistant";
-import { DatabaseService as DatabaseService11, defineFunction as defineFunction11 } from "@dxos/functions";
-import { Markdown as Markdown4 } from "@dxos/plugin-markdown/types";
-var read_default2 = defineFunction11({
+import * as Effect15 from "effect/Effect";
+import * as Schema14 from "effect/Schema";
+import { Database as Database12, Type as Type8 } from "@dxos/echo";
+import { defineFunction as defineFunction12 } from "@dxos/functions";
+import { Markdown as Markdown5 } from "@dxos/plugin-markdown/types";
+var read_default2 = defineFunction12({
   key: "dxos.org/function/markdown/read-tasks",
   name: "Read",
   description: "Read markdown tasks.",
-  inputSchema: Schema13.Struct({
-    id: ArtifactId4.annotations({
+  inputSchema: Schema14.Struct({
+    doc: Type8.Ref(Markdown5.Document).annotations({
       description: "The ID of the document to read."
     })
   }),
-  outputSchema: Schema13.Struct({
-    content: Schema13.String
+  outputSchema: Schema14.Struct({
+    content: Schema14.String
   }),
-  handler: Effect14.fn(function* ({ data: { id } }) {
-    const doc = yield* DatabaseService11.resolve(ArtifactId4.toDXN(id), Markdown4.Document);
-    const { content } = yield* DatabaseService11.load(doc.content);
+  handler: Effect15.fn(function* ({ data: { doc } }) {
+    const document = yield* Database12.load(doc);
+    const { content } = yield* Database12.load(document.content);
     const lines = content.split("\n");
     const len = String(lines.length).length;
     const numbered = lines.map((line, i) => `${String(i + 1).padStart(len, " ")}. ${line}`).join("\n");
@@ -1997,11 +2045,11 @@ var read_default2 = defineFunction11({
 });
 
 // src/functions/tasks/update.ts
-import * as Effect15 from "effect/Effect";
-import * as Schema14 from "effect/Schema";
-import { ArtifactId as ArtifactId5 } from "@dxos/assistant";
-import { DatabaseService as DatabaseService12, defineFunction as defineFunction12 } from "@dxos/functions";
-import { Markdown as Markdown5 } from "@dxos/plugin-markdown/types";
+import * as Effect16 from "effect/Effect";
+import * as Schema15 from "effect/Schema";
+import { Database as Database13, Type as Type9 } from "@dxos/echo";
+import { defineFunction as defineFunction13 } from "@dxos/functions";
+import { Markdown as Markdown6 } from "@dxos/plugin-markdown/types";
 
 // src/functions/tasks/task-list.ts
 var MarkdownTasks = class {
@@ -2132,27 +2180,27 @@ var MarkdownTasks = class {
 };
 
 // src/functions/tasks/update.ts
-var update_default2 = defineFunction12({
+var update_default2 = defineFunction13({
   key: "dxos.org/function/markdown/update-tasks",
   name: "Update markdown",
   description: "Creates and updates tasks in markdown documents.",
-  inputSchema: Schema14.Struct({
-    id: ArtifactId5.annotations({
+  inputSchema: Schema15.Struct({
+    doc: Type9.Ref(Markdown6.Document).annotations({
       description: "The ID of the document to update."
     }),
-    operations: Schema14.optional(Schema14.Array(Schema14.Any.annotations({
+    operations: Schema15.optional(Schema15.Array(Schema15.Any.annotations({
       description: "Task operations to apply."
     })))
   }),
-  outputSchema: Schema14.Struct({
-    content: Schema14.String,
-    numberedContent: Schema14.String.annotations({
+  outputSchema: Schema15.Struct({
+    content: Schema15.String,
+    numberedContent: Schema15.String.annotations({
       description: "Content with line numbers for agent reference."
     })
   }),
-  handler: Effect15.fn(function* ({ data: { id, operations = [] } }) {
-    const doc = yield* DatabaseService12.resolve(ArtifactId5.toDXN(id), Markdown5.Document);
-    const { content } = yield* DatabaseService12.load(doc.content);
+  handler: Effect16.fn(function* ({ data: { doc, operations = [] } }) {
+    const document = yield* Database13.load(doc);
+    const { content } = yield* Database13.load(document.content);
     const taskManager = new MarkdownTasks(content);
     if (operations.length > 0) {
       taskManager.applyOperations(operations);
@@ -2181,27 +2229,26 @@ var instructions = trim5`
   When replying to the user, be terse with your comments about design doc handling.
   Do not announce when you read or write the design spec document.
 `;
-var blueprint = Obj10.make(Blueprint.Blueprint, {
+var blueprint = Blueprint.make({
   key: "dxos.org/blueprint/design",
   name: "Design Spec",
   description: "Preserve the conversation in the design spec.",
   instructions: {
-    source: Ref6.make(Text2.make(instructions))
+    source: Ref7.make(Text2.make(instructions))
   },
   tools: [
     Document.read,
     Document.update
-  ].map((fn9) => ToolId.make(fn9.key))
+  ].map((fn11) => ToolId.make(fn11.key))
 });
-var design_blueprint_default = blueprint;
 
 // src/blueprints/design/index.ts
-var design_default = design_blueprint_default;
+var design_default = blueprint;
 
 // src/blueprints/discord/discord-blueprint.ts
 import { ToolId as ToolId2 } from "@dxos/ai";
 import { Blueprint as Blueprint2 } from "@dxos/blueprints";
-import { Obj as Obj11, Ref as Ref7 } from "@dxos/echo";
+import { Ref as Ref8 } from "@dxos/echo";
 import { Text as Text3 } from "@dxos/schema";
 import { trim as trim6 } from "@dxos/util";
 var instructions2 = trim6`
@@ -2211,26 +2258,25 @@ var instructions2 = trim6`
 
   DXOS serverId: 837138313172353095
 `;
-var blueprint2 = Obj11.make(Blueprint2.Blueprint, {
+var blueprint2 = Blueprint2.make({
   key: "dxos.org/blueprint/discord",
   name: "Discord",
   description: "Discord integration.",
   instructions: {
-    source: Ref7.make(Text3.make(instructions2))
+    source: Ref8.make(Text3.make(instructions2))
   },
   tools: [
     ToolId2.make(Discord.fetch.key)
   ]
 });
-var discord_blueprint_default = blueprint2;
 
 // src/blueprints/discord/index.ts
-var discord_default = discord_blueprint_default;
+var discord_default = blueprint2;
 
 // src/blueprints/linear/linear-blueprint.ts
 import { ToolId as ToolId3 } from "@dxos/ai";
 import { Blueprint as Blueprint3 } from "@dxos/blueprints";
-import { Obj as Obj12, Ref as Ref8 } from "@dxos/echo";
+import { Ref as Ref9 } from "@dxos/echo";
 import { Text as Text4 } from "@dxos/schema";
 import { trim as trim7 } from "@dxos/util";
 var instructions3 = trim7`
@@ -2241,26 +2287,25 @@ var instructions3 = trim7`
 
   DXOS teamId: 1127c63a-6f77-4725-9229-50f6cd47321c
 `;
-var blueprint3 = Obj12.make(Blueprint3.Blueprint, {
+var blueprint3 = Blueprint3.make({
   key: "dxos.org/blueprint/linear",
   name: "Linear",
   description: "Syncs Linear workspaces.",
   instructions: {
-    source: Ref8.make(Text4.make(instructions3))
+    source: Ref9.make(Text4.make(instructions3))
   },
   tools: [
     Linear.sync
   ].map((tool) => ToolId3.make(tool.key))
 });
-var linear_blueprint_default = blueprint3;
 
 // src/blueprints/linear/index.ts
-var linear_default = linear_blueprint_default;
+var linear_default = blueprint3;
 
 // src/blueprints/planning/planning-blueprint.ts
 import { ToolId as ToolId4 } from "@dxos/ai";
 import { Blueprint as Blueprint4 } from "@dxos/blueprints";
-import { Obj as Obj13, Ref as Ref9 } from "@dxos/echo";
+import { Ref as Ref10 } from "@dxos/echo";
 import { Text as Text5 } from "@dxos/schema";
 import { trim as trim8 } from "@dxos/util";
 var instructions4 = trim8`
@@ -2334,27 +2379,26 @@ var instructions4 = trim8`
   - When creating subtasks, consider the parent task's completion status
   - Be precise with task descriptions and hierarchy levels
 `;
-var blueprint4 = Obj13.make(Blueprint4.Blueprint, {
+var blueprint4 = Blueprint4.make({
   key: "dxos.org/blueprint/planning",
   name: "Planning",
   description: "Plans and tracks complex tasks with artifact management.",
   instructions: {
-    source: Ref9.make(Text5.make(instructions4))
+    source: Ref10.make(Text5.make(instructions4))
   },
   tools: [
     Tasks.read,
     Tasks.update
-  ].map((fn9) => ToolId4.make(fn9.key))
+  ].map((fn11) => ToolId4.make(fn11.key))
 });
-var planning_blueprint_default = blueprint4;
 
 // src/blueprints/planning/index.ts
-var planning_default = planning_blueprint_default;
+var planning_default = blueprint4;
 
 // src/blueprints/research/research-blueprint.ts
 import { ToolId as ToolId5 } from "@dxos/ai";
 import { Blueprint as Blueprint5 } from "@dxos/blueprints";
-import { Obj as Obj14, Ref as Ref10 } from "@dxos/echo";
+import { Ref as Ref11 } from "@dxos/echo";
 import { Text as Text6 } from "@dxos/schema";
 import { trim as trim9 } from "@dxos/util";
 var instructions5 = trim9`
@@ -2383,85 +2427,650 @@ var instructions5 = trim9`
     Reply normally with the text mode of the result of your research.
   </unstructured_mode>
 `;
-var blueprint5 = Obj14.make(Blueprint5.Blueprint, {
+var blueprint5 = Blueprint5.make({
   key: "dxos.org/blueprint/research",
   name: "Research",
   description: "Researches the web and creates structured data.",
   instructions: {
-    source: Ref10.make(Text6.make(instructions5))
+    source: Ref11.make(Text6.make(instructions5))
   },
   tools: [
     Research.create,
     Research.research
-  ].map((fn9) => ToolId5.make(fn9.key))
+  ].map((fn11) => ToolId5.make(fn11.key))
 });
-var research_blueprint_default = blueprint5;
 
 // src/blueprints/research/index.ts
-var research_default2 = research_blueprint_default;
+var research_default2 = blueprint5;
 
 // src/blueprints/websearch/websearch-blueprint.ts
 import { ToolId as ToolId6 } from "@dxos/ai";
 import { Blueprint as Blueprint6 } from "@dxos/blueprints";
-import { Obj as Obj15, Ref as Ref11 } from "@dxos/echo";
+import { Ref as Ref12 } from "@dxos/echo";
 import { Text as Text7 } from "@dxos/schema";
-var blueprint6 = Obj15.make(Blueprint6.Blueprint, {
+var blueprint6 = Blueprint6.make({
   key: "dxos.org/blueprint/web-search",
   name: "Web Search",
   description: "Search the web.",
   instructions: {
-    source: Ref11.make(Text7.make())
+    source: Ref12.make(Text7.make())
   },
   tools: [
     ToolId6.make("AnthropicWebSearch")
   ]
 });
-var websearch_blueprint_default = blueprint6;
 
 // src/blueprints/websearch/websearch-toolkit.ts
-import * as Toolkit4 from "@effect/ai/Toolkit";
+import * as Toolkit3 from "@effect/ai/Toolkit";
 import * as AnthropicTool2 from "@effect/ai-anthropic/AnthropicTool";
-var WebSearchToolkit = Toolkit4.make(AnthropicTool2.WebSearch_20250305({}));
+var WebSearchToolkit = Toolkit3.make(AnthropicTool2.WebSearch_20250305({}));
 
 // src/blueprints/websearch/index.ts
-var websearch_default = websearch_blueprint_default;
+var websearch_default = blueprint6;
 
-// src/plugins.tsx
-import * as Schema15 from "effect/Schema";
-import React from "react";
-import { Capabilities, contributes, createSurface } from "@dxos/app-framework";
-import { Type as Type3 } from "@dxos/echo";
-import { JsonFilter } from "@dxos/react-ui-syntax-highlighter";
-var MapSchema = Schema15.Struct({
-  coordinates: Type3.Format.GeoPoint
-}).pipe(Type3.Obj({
-  typename: "example.com/type/Map",
+// src/blueprints/markdown/markdown-blueprint.ts
+import { Blueprint as Blueprint7 } from "@dxos/blueprints";
+import { Ref as Ref13 } from "@dxos/echo";
+import { Text as Text8 } from "@dxos/schema";
+import { trim as trim10 } from "@dxos/util";
+var instructions6 = trim10`
+  You read, write & create markdown documents.
+`;
+var blueprint7 = Blueprint7.make({
+  key: "dxos.org/blueprint/markdown",
+  name: "Markdown",
+  description: "Work with markdown documents.",
+  instructions: {
+    source: Ref13.make(Text8.make(instructions6))
+  },
+  tools: Blueprint7.toolDefinitions({
+    functions: [
+      Document.read,
+      Document.update,
+      Document.create
+    ]
+  })
+});
+
+// src/blueprints/markdown/index.ts
+var markdown_default = blueprint7;
+
+// src/chat/Chat.ts
+var Chat_exports = {};
+__export(Chat_exports, {
+  Chat: () => Chat,
+  CompanionTo: () => CompanionTo,
+  make: () => make7
+});
+import * as Schema16 from "effect/Schema";
+import { Obj as Obj11, Type as Type10 } from "@dxos/echo";
+import { FormInputAnnotation, LabelAnnotation } from "@dxos/echo/internal";
+import { Queue as Queue2 } from "@dxos/echo-db";
+var Chat = Schema16.Struct({
+  name: Schema16.String.pipe(Schema16.optional),
+  queue: Type10.Ref(Queue2).pipe(FormInputAnnotation.set(false)),
+  // TODO(dmaretskyi): Eventually this and the message queue will be the same.
+  traceQueue: Type10.Ref(Queue2).pipe(FormInputAnnotation.set(false), Schema16.optional)
+}).pipe(Type10.object({
+  typename: "dxos.org/type/assistant/Chat",
+  version: "0.2.0"
+}), LabelAnnotation.set([
+  "name"
+]));
+var make7 = (props) => Obj11.make(Chat, props);
+var CompanionTo = Schema16.Struct({
+  id: Obj11.ID
+}).pipe(Type10.relation({
+  typename: "dxos.org/relation/assistant/CompanionTo",
+  version: "0.1.0",
+  source: Chat,
+  target: Type10.Obj
+}));
+
+// src/initiative/index.ts
+var initiative_exports = {};
+__export(initiative_exports, {
+  Initiative: () => Initiative,
+  Plan: () => Plan,
+  Task: () => Task3,
+  TaskId: () => TaskId,
+  addArtifact: () => addArtifact_default,
+  addTasks: () => addTasks,
+  agent: () => agent_default,
+  formatPlan: () => formatPlan,
+  generateTaskId: () => generateTaskId,
+  getContext: () => getContext_default,
+  getFromChatContext: () => getFromChatContext,
+  getFunctions: () => getFunctions,
+  makeBlueprint: () => makeBlueprint,
+  makeInitialized: () => makeInitialized,
+  makePlan: () => makePlan,
+  qualifier: () => qualifier_default,
+  resetChatHistory: () => resetChatHistory
+});
+
+// src/initiative/Initiative.ts
+import * as Schema18 from "effect/Schema";
+import { Type as Type12 } from "@dxos/echo";
+import { Queue as Queue3 } from "@dxos/echo-db";
+import { QueueAnnotation, Text as Text9 } from "@dxos/schema";
+
+// src/initiative/plan.ts
+import * as Schema17 from "effect/Schema";
+import { Obj as Obj12, Type as Type11 } from "@dxos/echo";
+var TaskId = Schema17.String.pipe(Schema17.brand("@dxos/assistant-toolkit/TaskId"));
+var Task3 = Schema17.Struct({
+  /**
+  * Short task ID unique within the plan.
+  */
+  id: TaskId,
+  title: Schema17.String.annotations({
+    description: "Task title and description."
+  }),
+  status: Schema17.Literal("todo", "in-progress", "done"),
+  /**
+  * Parent task ID.
+  */
+  parent: Schema17.optional(TaskId).annotations({
+    description: "Parent task ID."
+  }),
+  /**
+  * Chat object that this task is associated with.
+  */
+  chat: Schema17.optional(Type11.Ref(Chat))
+});
+var Plan = Schema17.Struct({
+  tasks: Schema17.Array(Task3)
+}).pipe(Type11.object({
+  typename: "dxos.org/type/Plan",
   version: "0.1.0"
 }));
-var isImage = (data) => false;
-var capabilities = [
-  contributes(Capabilities.ReactSurface, createSurface({
-    id: "plugin-image",
-    role: "card--extrinsic",
-    filter: (data) => isImage(data.value),
-    component: ({ data }) => /* @__PURE__ */ React.createElement("img", {
-      className: "grow object-cover",
-      src: `data:image/jpeg;base64,${data.value.source.data}`,
-      alt: data.value.prompt ?? `Generated image [id=${data.value.id}]`
-    })
+var generateTaskId = (plan) => {
+  const existingIds = plan.tasks.map((task) => {
+    const [num, letter] = task.id.split("-");
+    return parseInt(num);
+  }).filter((_) => !isNaN(_));
+  let newId;
+  if (existingIds.length === 0) {
+    newId = 1;
+  } else {
+    newId = Math.max(...existingIds) + 1;
+  }
+  return TaskId.make(`${newId}-${crypto.randomUUID().slice(0, 2)}`);
+};
+var addTasks = (plan, tasks) => {
+  for (const task of tasks) {
+    const taskId = generateTaskId(plan);
+    plan.tasks.push({
+      id: taskId,
+      ...task,
+      status: task.status ?? "todo"
+    });
+  }
+  return plan;
+};
+var makePlan = (props) => {
+  const plan = Obj12.make(Plan, {
+    tasks: []
+  });
+  Obj12.change(plan, (plan2) => {
+    addTasks(plan2, props.tasks);
+  });
+  return plan;
+};
+var formatPlan = (plan) => {
+  return plan.tasks.map((task) => `- **${task.status?.toLocaleUpperCase()}**: ${task.title ?? "No title"} <!-- id=${task.id} -->`).join("\n");
+};
+
+// src/initiative/Initiative.ts
+var Initiative = Schema18.Struct({
+  name: Schema18.String,
+  spec: Type12.Ref(Text9.Text),
+  plan: Type12.Ref(Plan),
+  artifacts: Schema18.Array(Schema18.Struct({
+    // TODO(dmaretskyi): Consider gettings names from the artifact itself using Obj.getLabel.
+    name: Schema18.String,
+    data: Type12.Ref(Type12.Obj)
   })),
-  //
-  // Default
-  //
-  contributes(Capabilities.ReactSurface, createSurface({
-    id: "plugin-default",
-    role: "card--extrinsic",
-    position: "fallback",
-    component: ({ role, data }) => /* @__PURE__ */ React.createElement(JsonFilter, {
-      data
+  /**
+  * Incoming queue that the agent processes.
+  */
+  // NOTE: Named `queue` to conform to subscribable schema (see QueueAnnotation).
+  queue: Schema18.optional(Type12.Ref(Queue3)),
+  // TODO(dmaretskyi): Multiple chats.
+  chat: Schema18.optional(Type12.Ref(Chat)),
+  /**
+  * Objects to subscribe to.
+  * References to objects with a a canonical queue property.
+  * Schema must have the QueueAnnotation.
+  */
+  // TODO(dmaretskyi): Turn into an array of objects when form-data
+  subscriptions: Schema18.Array(Type12.Ref(Type12.Obj)),
+  useQualifyingAgent: Schema18.optional(Schema18.Boolean),
+  newChatOnEveryEvent: Schema18.optional(Schema18.Boolean)
+}).pipe(Type12.object({
+  typename: "dxos.org/type/Initiative",
+  version: "0.1.0"
+}), QueueAnnotation.set(true));
+
+// src/initiative/util.ts
+import * as Effect17 from "effect/Effect";
+import * as Function6 from "effect/Function";
+import { AiContextBinder, AiContextService } from "@dxos/assistant";
+import { Database as Database14, Obj as Obj13, Ref as Ref14, Relation as Relation2 } from "@dxos/echo";
+import { acquireReleaseResource } from "@dxos/effect";
+import { QueueService as QueueService2 } from "@dxos/functions";
+import { invariant } from "@dxos/invariant";
+import { Text as Text10 } from "@dxos/schema";
+var __dxlog_file8 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/initiative/util.ts";
+var makeInitialized = (props, blueprint8) => Effect17.gen(function* () {
+  const initiative = Obj13.make(Initiative, {
+    ...props,
+    spec: Ref14.make(Text10.make(props.spec)),
+    plan: Ref14.make(makePlan({
+      tasks: []
+    })),
+    artifacts: props.artifacts ?? [],
+    subscriptions: props.subscriptions ?? []
+  });
+  yield* Database14.add(initiative);
+  const queue = yield* QueueService2.createQueue();
+  const contextBinder = new AiContextBinder({
+    queue
+  });
+  const initiativeBlueprint = yield* Database14.add(Obj13.clone(blueprint8, {
+    deep: true
+  }));
+  yield* Effect17.promise(() => contextBinder.bind({
+    blueprints: [
+      Ref14.make(initiativeBlueprint),
+      ...props.blueprints ?? []
+    ],
+    objects: [
+      Ref14.make(initiative),
+      ...props.contextObjects ?? []
+    ]
+  }));
+  const chat = yield* Database14.add(make7({
+    queue: Ref14.fromDXN(queue.dxn)
+  }));
+  yield* Database14.add(Relation2.make(CompanionTo, {
+    [Relation2.Source]: chat,
+    [Relation2.Target]: initiative
+  }));
+  const inputQueue = yield* QueueService2.createQueue();
+  Obj13.change(initiative, (initiative2) => {
+    initiative2.chat = Ref14.make(chat);
+    initiative2.queue = Ref14.fromDXN(inputQueue.dxn);
+  });
+  return initiative;
+});
+var resetChatHistory = (initiative) => Effect17.gen(function* () {
+  invariant(initiative.chat, "Initiative must have an existing chat to reset.", {
+    F: __dxlog_file8,
+    L: 91,
+    S: this,
+    A: [
+      "initiative.chat",
+      "'Initiative must have an existing chat to reset.'"
+    ]
+  });
+  const existingQueue = yield* initiative.chat.pipe(Database14.load).pipe(Effect17.map((_) => _.queue), Effect17.flatMap(Database14.load));
+  const existingContextBinder = yield* acquireReleaseResource(() => new AiContextBinder({
+    queue: existingQueue
+  }));
+  const blueprints = existingContextBinder.getBlueprints().map((blueprint8) => Ref14.make(blueprint8));
+  const objects = existingContextBinder.getObjects().map((object) => Ref14.make(object));
+  const queue = yield* QueueService2.createQueue();
+  const contextBinder = new AiContextBinder({
+    queue
+  });
+  yield* Effect17.promise(() => contextBinder.bind({
+    blueprints,
+    objects
+  }));
+  const chat = yield* Database14.add(make7({
+    queue: Ref14.fromDXN(queue.dxn)
+  }));
+  Obj13.change(initiative, (initiative2) => {
+    initiative2.chat = Ref14.make(chat);
+  });
+  yield* Database14.add(Relation2.make(CompanionTo, {
+    [Relation2.Source]: chat,
+    [Relation2.Target]: initiative
+  }));
+}).pipe(Effect17.scoped);
+var getFromChatContext = Effect17.gen(function* () {
+  const initiatives = yield* Function6.pipe(AiContextService.findObjects(Initiative));
+  if (initiatives.length !== 1) {
+    throw new Error("There should be exactly one initiative in context. Got: " + initiatives.length);
+  }
+  const initiative = initiatives[0];
+  return initiative;
+});
+
+// src/initiative/blueprint.ts
+import { Blueprint as Blueprint8, Template as Template3 } from "@dxos/blueprints";
+import { trim as trim12 } from "@dxos/util";
+
+// src/initiative/functions/getContext.ts
+import * as Effect18 from "effect/Effect";
+import * as Schema19 from "effect/Schema";
+import { AiContextService as AiContextService2 } from "@dxos/assistant";
+import { Database as Database15, Obj as Obj14 } from "@dxos/echo";
+import { defineFunction as defineFunction14 } from "@dxos/functions";
+var getContext_default = defineFunction14({
+  key: "dxos.org/function/initiative/get-context",
+  name: "Get Initiative Context",
+  description: "Get the context of an initiative.",
+  inputSchema: Schema19.Struct({}),
+  outputSchema: Schema19.Struct({
+    id: Schema19.String,
+    name: Schema19.String,
+    spec: Schema19.String,
+    plan: Schema19.String,
+    artifacts: Schema19.Array(Schema19.Struct({
+      name: Schema19.String,
+      type: Schema19.optional(Schema19.String),
+      dxn: Schema19.optional(Schema19.String)
+    }))
+  }),
+  services: [
+    AiContextService2
+  ],
+  handler: Effect18.fnUntraced(function* ({ data: _data }) {
+    const initiative = yield* getFromChatContext;
+    return {
+      id: initiative.id,
+      name: initiative.name,
+      spec: yield* initiative.spec.pipe(Database15.load).pipe(Effect18.map((_) => _.content), Effect18.catchTag("ObjectNotFoundError", () => Effect18.succeed("No spec found."))),
+      plan: yield* initiative.plan?.pipe(Database15.load).pipe(Effect18.map(formatPlan), Effect18.catchTag("ObjectNotFoundError", () => Effect18.succeed("No plan found."))) ?? Effect18.succeed("No plan found."),
+      artifacts: yield* Effect18.forEach(initiative.artifacts, (artifact) => Effect18.gen(function* () {
+        return {
+          name: artifact.name,
+          type: yield* Database15.load(artifact.data).pipe(Effect18.map(Obj14.getTypename), Effect18.catchTag("ObjectNotFoundError", () => Effect18.succeed("Artifact not found."))),
+          dxn: artifact.data.dxn.toString()
+        };
+      }))
+    };
+  }, AiContextService2.fixFunctionHandlerType)
+});
+
+// src/initiative/functions/addArtifact.ts
+import * as Effect19 from "effect/Effect";
+import * as Schema20 from "effect/Schema";
+import { AiContextService as AiContextService3 } from "@dxos/assistant";
+import { Database as Database16, Obj as Obj15, Type as Type13 } from "@dxos/echo";
+import { defineFunction as defineFunction15 } from "@dxos/functions";
+var addArtifact_default = defineFunction15({
+  key: "dxos.org/function/initiative/add-artifact",
+  name: "Add artifact",
+  description: "Adds a new artifact.",
+  inputSchema: Schema20.Struct({
+    name: Schema20.String.annotations({
+      description: "The name of the artifact to add."
+    }),
+    artifact: Type13.Ref(Type13.Obj).annotations({
+      description: "The artifact to add. Do NOT guess or try to generate the ID."
     })
-  }))
+  }),
+  services: [
+    AiContextService3
+  ],
+  handler: Effect19.fnUntraced(function* ({ data }) {
+    if (!(yield* Database16.load(data.artifact))) {
+      throw new Error("Artifact not found.");
+    }
+    const initiative = yield* getFromChatContext;
+    Obj15.change(initiative, (initiative2) => {
+      initiative2.artifacts.push({
+        name: data.name,
+        data: data.artifact
+      });
+    });
+  }, AiContextService3.fixFunctionHandlerType)
+});
+
+// src/initiative/functions/agent.ts
+import * as Effect20 from "effect/Effect";
+import * as Schema21 from "effect/Schema";
+import { AiService as AiService4 } from "@dxos/ai";
+import { AiContextService as AiContextService4, AiConversation } from "@dxos/assistant";
+import { Database as Database17, Obj as Obj16, Type as Type14 } from "@dxos/echo";
+import { acquireReleaseResource as acquireReleaseResource2 } from "@dxos/effect";
+import { TriggerEvent, defineFunction as defineFunction16 } from "@dxos/functions";
+import { invariant as invariant2 } from "@dxos/invariant";
+var __dxlog_file9 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/initiative/functions/agent.ts";
+var agent_default = defineFunction16({
+  key: "dxos.org/function/initiative/agent",
+  name: "Initiative Agent",
+  description: "Agentic worker that drives the initiative autonomously.",
+  inputSchema: Schema21.Struct({
+    initiative: Schema21.suspend(() => Type14.Ref(Initiative)),
+    prompt: Schema21.optional(Schema21.String),
+    event: Schema21.optional(TriggerEvent.TriggerEvent)
+  }),
+  outputSchema: Schema21.Void,
+  services: [
+    AiContextService4
+  ],
+  handler: Effect20.fnUntraced(function* ({ data }) {
+    const initiative = yield* Database17.load(data.initiative);
+    invariant2(Obj16.instanceOf(Initiative, initiative), void 0, {
+      F: __dxlog_file9,
+      L: 34,
+      S: this,
+      A: [
+        "Obj.instanceOf(Initiative.Initiative, initiative)",
+        ""
+      ]
+    });
+    invariant2(initiative.chat, "Initiative has no chat.", {
+      F: __dxlog_file9,
+      L: 35,
+      S: this,
+      A: [
+        "initiative.chat",
+        "'Initiative has no chat.'"
+      ]
+    });
+    if (initiative.newChatOnEveryEvent) {
+      yield* resetChatHistory(initiative);
+    }
+    const chatQueue = yield* initiative.chat.pipe(Database17.load, Effect20.flatMap((chat) => Database17.load(chat.queue)));
+    invariant2(chatQueue, "Initiative chat queue not found.", {
+      F: __dxlog_file9,
+      L: 45,
+      S: this,
+      A: [
+        "chatQueue",
+        "'Initiative chat queue not found.'"
+      ]
+    });
+    const conversation = yield* acquireReleaseResource2(() => new AiConversation({
+      queue: chatQueue
+    }));
+    const iniativesInContext = conversation.context.getObjects().filter(Obj16.instanceOf(Initiative));
+    if (iniativesInContext.length !== 1) {
+      throw new Error("There should be exactly one initiative in context. Got: " + iniativesInContext.length);
+    }
+    if (!data.prompt && !data.event) {
+      throw new Error("Either prompt or event must be provided.");
+    }
+    let input = "";
+    if (data.prompt) {
+      input += `${data.prompt}
+
+`;
+    }
+    if (data.event) {
+      input += `<event>
+${JSON.stringify(data.event, null, 2)}
+</event>
+
+`;
+    }
+    yield* conversation.createRequest({
+      prompt: input
+    }).pipe(Effect20.retry({
+      times: 2
+    }));
+  }, Effect20.scoped, Effect20.provide(AiService4.model("@anthropic/claude-sonnet-4-5")), AiContextService4.fixFunctionHandlerType)
+});
+
+// src/initiative/functions/qualifier.ts
+import * as LanguageModel from "@effect/ai/LanguageModel";
+import * as Prompt2 from "@effect/ai/Prompt";
+import * as Effect21 from "effect/Effect";
+import * as Schema22 from "effect/Schema";
+import { AiService as AiService5 } from "@dxos/ai";
+import { Database as Database18, Obj as Obj17, Ref as Ref15, Type as Type15 } from "@dxos/echo";
+import { TriggerEvent as TriggerEvent2, defineFunction as defineFunction17 } from "@dxos/functions";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { trim as trim11 } from "@dxos/util";
+var __dxlog_file10 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/initiative/functions/qualifier.ts";
+var qualifier_default = defineFunction17({
+  key: "dxos.org/function/initiative/qualifier",
+  name: "Initiative Qualifier",
+  description: "Qualifier that determines if the event is relevant to the initiative. Puts the data into the input queue of the initiative.",
+  inputSchema: Schema22.Struct({
+    initiative: Schema22.suspend(() => Type15.Ref(Initiative)),
+    event: TriggerEvent2.TriggerEvent
+  }),
+  outputSchema: Schema22.Void,
+  services: [],
+  handler: Effect21.fnUntraced(function* ({ data }) {
+    const initiative = yield* Database18.load(data.initiative);
+    invariant3(Obj17.instanceOf(Initiative, initiative), void 0, {
+      F: __dxlog_file10,
+      L: 33,
+      S: this,
+      A: [
+        "Obj.instanceOf(Initiative.Initiative, initiative)",
+        ""
+      ]
+    });
+    invariant3(initiative.chat, "Initiative has no chat.", {
+      F: __dxlog_file10,
+      L: 34,
+      S: this,
+      A: [
+        "initiative.chat",
+        "'Initiative has no chat.'"
+      ]
+    });
+    const { id, name, queue } = initiative;
+    if (!queue) {
+      throw new Error("Initiative has no queue.");
+    }
+    const plan = yield* Database18.load(initiative.plan);
+    const spec = yield* Database18.load(initiative.spec);
+    const { value: { isRelevant } } = yield* LanguageModel.generateObject({
+      schema: Schema22.Struct({
+        isRelevant: Schema22.Boolean
+      }),
+      prompt: Prompt2.fromMessages([
+        Prompt2.systemMessage({
+          content: trim11`
+              You are a qualifying agent that determines if the event is relevant to the initiative.
+              Respond with true if the event is relevant to the initiative, false otherwise.
+              If you are not sure, return true.
+              The qualified events will be forwarded to the larger agent that will process them.
+              <initiative id="${id}" name="${name}">
+                <spec>
+                ${spec.content}
+                </spec>
+                <plan>
+                  ${formatPlan(plan)}
+                </plan>
+              </initiative>
+            `
+        }),
+        Prompt2.userMessage({
+          content: [
+            Prompt2.makePart("text", {
+              text: trim11`
+                  <event>
+                    ${JSON.stringify(data.event, null, 2)}
+                  </event>
+                `
+            })
+          ]
+        })
+      ])
+    });
+    if (isRelevant) {
+      const queueTarget = yield* Database18.load(queue);
+      if ("queue" in data.event && data.event.item) {
+        const obj = data.event.item;
+        yield* Effect21.promise(() => queueTarget.append([
+          obj
+        ]));
+      } else if ("subject" in data.event && Ref15.isRef(data.event.subject)) {
+        const obj = yield* Database18.load(data.event.subject);
+        yield* Effect21.promise(() => queueTarget.append([
+          obj
+        ]));
+      } else {
+        throw new Error("Invalid event.");
+      }
+    }
+  }, Effect21.scoped, Effect21.provide(AiService5.model("@anthropic/claude-sonnet-4-5")))
+});
+
+// src/initiative/blueprint.ts
+var getFunctions = () => [
+  getContext_default,
+  addArtifact_default,
+  agent_default,
+  qualifier_default
 ];
+var makeBlueprint = () => Blueprint8.make({
+  key: "dxos.org/blueprint/initiative",
+  name: "Initiative blueprint",
+  instructions: Template3.make({
+    source: trim12`
+        You work on an initiative. Each initiative has a spec - the goal of the initiative.
+        The initiative plan shows the current progress of the initiative.
+        Initiative has an number of associated artifacts you can read/write.
+        Spec and plan are also artifacts.
+        You can edit them if necessary.
+
+        IMPORTANT: When create a new artifact, always add it to the initiative using the add-artifact function.
+        
+        {{#with initiative}}
+        <initiative id="{{id}}" name="{{name}}">
+          <spec>
+            {{spec}}
+          </spec>
+          <plan>
+            {{plan}}
+          </plan>
+
+          <artifacts>
+          {{#each artifacts}}
+            <artifact type="{{type}}" dxn="{{dxn}}">
+              {{name}}
+            </artifact>
+          {{/each}}
+          </artifacts>
+        </initiative>
+        {{/with}}
+      `,
+    inputs: [
+      {
+        name: "initiative",
+        kind: "function",
+        function: "dxos.org/function/initiative/get-context"
+      }
+    ]
+  }),
+  tools: Blueprint8.toolDefinitions({
+    functions: [
+      addArtifact_default
+    ]
+  })
+});
 
 // src/toolkits/AssistantToolkit.ts
 var AssistantToolkit_exports = {};
@@ -2471,37 +3080,62 @@ __export(AssistantToolkit_exports, {
   tools: () => tools
 });
 import * as Tool2 from "@effect/ai/Tool";
-import * as Toolkit5 from "@effect/ai/Toolkit";
-import * as Effect16 from "effect/Effect";
+import * as Toolkit4 from "@effect/ai/Toolkit";
+import * as Effect22 from "effect/Effect";
 import * as Record from "effect/Record";
-import * as Schema16 from "effect/Schema";
-import { AiContextService, ArtifactId as ArtifactId6 } from "@dxos/assistant";
-import { Ref as Ref12 } from "@dxos/echo";
-import { DatabaseService as DatabaseService13 } from "@dxos/functions";
-import { trim as trim10 } from "@dxos/util";
-var AssistantToolkit = Toolkit5.make(Tool2.make("add-to-context", {
-  description: trim10`
+import * as Schema23 from "effect/Schema";
+import { AiContextService as AiContextService5, ArtifactId } from "@dxos/assistant";
+import { Database as Database19 } from "@dxos/echo";
+import { trim as trim13 } from "@dxos/util";
+var AssistantToolkit = Toolkit4.make(Tool2.make("context-add", {
+  description: trim13`
       Adds the object to the chat context.
     `,
   parameters: {
-    id: ArtifactId6.annotations({
-      description: "The ID of the document to read."
+    id: ArtifactId.annotations({
+      description: "The ID of the document to add."
+    })
+  },
+  success: Schema23.Void,
+  failure: Schema23.Never,
+  dependencies: [
+    AiContextService5,
+    Database19.Service
+  ]
+}), Tool2.make("context-remove", {
+  description: trim13`
+      Removes the object from the chat context.
+    `,
+  parameters: {
+    id: ArtifactId.annotations({
+      description: "The ID of the document to remove."
     })
   },
-  success: Schema16.Void,
-  failure: Schema16.Never,
+  success: Schema23.Void,
+  failure: Schema23.Never,
   dependencies: [
-    AiContextService,
-    DatabaseService13
+    AiContextService5,
+    Database19.Service
   ]
 }));
 var tools = Record.keys(AssistantToolkit.tools);
 var layer3 = () => AssistantToolkit.toLayer({
-  "add-to-context": Effect16.fnUntraced(function* ({ id }) {
-    const { binder } = yield* AiContextService;
-    const { db } = yield* DatabaseService13;
-    const ref = Ref12.fromDXN(ArtifactId6.toDXN(id, db.spaceId));
-    yield* Effect16.promise(() => binder.bind({
+  ["context-add"]: Effect22.fnUntraced(function* ({ id }) {
+    const { binder } = yield* AiContextService5;
+    const { db } = yield* Database19.Service;
+    const ref = db.makeRef(ArtifactId.toDXN(id, db.spaceId));
+    yield* Effect22.promise(() => binder.bind({
+      blueprints: [],
+      objects: [
+        ref
+      ]
+    }));
+  }),
+  ["context-remove"]: Effect22.fnUntraced(function* ({ id }) {
+    const { binder } = yield* AiContextService5;
+    const { db } = yield* Database19.Service;
+    const ref = db.makeRef(ArtifactId.toDXN(id, db.spaceId));
+    yield* Effect22.promise(() => binder.unbind({
       blueprints: [],
       objects: [
         ref
@@ -2518,173 +3152,225 @@ __export(SystemToolkit_exports, {
   tools: () => tools2
 });
 import * as Tool3 from "@effect/ai/Tool";
-import * as Toolkit6 from "@effect/ai/Toolkit";
-import * as Effect17 from "effect/Effect";
+import * as Toolkit5 from "@effect/ai/Toolkit";
+import * as Effect23 from "effect/Effect";
 import * as Record2 from "effect/Record";
-import * as Schema17 from "effect/Schema";
-import { ArtifactId as ArtifactId7 } from "@dxos/assistant";
-import { DXN as DXN2, Obj as Obj16, Relation as Relation2, Tag as Tag2, Type as Type4 } from "@dxos/echo";
-import { DatabaseService as DatabaseService14 } from "@dxos/functions";
-import { trim as trim11 } from "@dxos/util";
-var SystemToolkit = Toolkit6.make(
+import * as Schema24 from "effect/Schema";
+import { ArtifactId as ArtifactId2 } from "@dxos/assistant";
+import { DXN as DXN2, Database as Database20, Entity as Entity3, Filter as Filter5, Obj as Obj18, Relation as Relation3, Tag as Tag2, Type as Type16 } from "@dxos/echo";
+import { invariant as invariant4 } from "@dxos/invariant";
+import { trim as trim14 } from "@dxos/util";
+var __dxlog_file11 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/toolkits/SystemToolkit.ts";
+var SystemToolkit = Toolkit5.make(
   //
   // Schema
   //
   Tool3.make("schema-list", {
-    description: trim11`
+    description: trim14`
       Lists schemas definitions.
     `,
     parameters: {
       // TODO(wittjosiah): Remove this once parameter-less tools are fixed.
-      limit: Schema17.Number
+      limit: Schema24.Number
     },
     // TODO(dmaretskyi): Effect returns ({ result, encodedResult })
-    success: Schema17.Any,
-    failure: Schema17.Never,
+    success: Schema24.Any,
+    failure: Schema24.Never,
     dependencies: [
-      DatabaseService14
+      Database20.Service
     ]
   }),
   Tool3.make("schema-add", {
-    description: trim11`
+    description: trim14`
       Adds a schema to the space.
       The name will be used when displayed to the user.
       The typename must be in the format of "example.com/type/Type".
     `,
     parameters: {
-      name: Schema17.String,
-      typename: Schema17.String,
-      jsonSchema: Schema17.Any
+      name: Schema24.String,
+      typename: Schema24.String,
+      jsonSchema: Schema24.Any
     },
-    success: Schema17.Any,
-    failure: Schema17.Never,
+    success: Schema24.Any,
+    failure: Schema24.Never,
     dependencies: [
-      DatabaseService14
+      Database20.Service
+    ]
+  }),
+  //
+  // Query
+  //
+  Tool3.make("query", {
+    description: trim14`
+      Queries objects in the space.
+      Get the typename from the schema-list tool.
+    `,
+    parameters: {
+      typename: Schema24.String
+    },
+    success: Schema24.Any,
+    failure: Schema24.Never,
+    dependencies: [
+      Database20.Service
     ]
   }),
   //
   // Objects
   //
   Tool3.make("object-create", {
-    description: trim11`
+    description: trim14`
       Creates a new object and adds it to the current space.
       Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
     `,
     parameters: {
-      typename: Schema17.String,
-      data: Schema17.Any
+      typename: Schema24.String,
+      data: Schema24.Any
+    },
+    success: Schema24.Any,
+    failure: Schema24.Never,
+    dependencies: [
+      Database20.Service
+    ]
+  }),
+  Tool3.make("object-delete", {
+    description: trim14`
+      Deletes the object.
+    `,
+    parameters: {
+      id: ArtifactId2.annotations({
+        description: "The ID of the object."
+      })
     },
-    success: Schema17.Any,
-    failure: Schema17.Never,
+    success: Schema24.Any,
+    failure: Schema24.Never,
     dependencies: [
-      DatabaseService14
+      Database20.Service
     ]
   }),
-  Tool3.make("object-remove", {
-    description: trim11`
-      Removes an object or relation from the database.
+  Tool3.make("object-update", {
+    description: trim14`
+      Updates the object properties.
     `,
     parameters: {
-      id: ArtifactId7.annotations({
+      id: ArtifactId2.annotations({
         description: "The ID of the object."
+      }),
+      properties: Schema24.Record({
+        key: Schema24.String,
+        value: Schema24.Any
       })
     },
-    success: Schema17.Any,
-    failure: Schema17.Never,
+    success: Schema24.Any,
+    failure: Schema24.Never,
     dependencies: [
-      DatabaseService14
+      Database20.Service
     ]
   }),
   //
   // Relations
   //
   Tool3.make("relation-create", {
-    description: trim11`
+    description: trim14`
       Creates a new relation and adds it to the current space.
       Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
     `,
     parameters: {
-      typename: Schema17.String,
-      source: ArtifactId7.annotations({
+      typename: Schema24.String,
+      source: ArtifactId2.annotations({
         description: "The ID of the source object."
       }),
-      target: ArtifactId7.annotations({
+      target: ArtifactId2.annotations({
         description: "The ID of the target object."
       }),
-      data: Schema17.Any.annotations({
+      data: Schema24.Any.annotations({
         description: "The data to be stored in the relation."
       })
     },
-    success: Schema17.Any,
-    failure: Schema17.Never,
+    success: Schema24.Any,
+    failure: Schema24.Never,
+    dependencies: [
+      Database20.Service
+    ]
+  }),
+  Tool3.make("relation-delete", {
+    description: trim14`
+      Deletes the relation.
+    `,
+    parameters: {
+      id: ArtifactId2.annotations({
+        description: "The ID of the relation."
+      })
+    },
+    success: Schema24.Any,
+    failure: Schema24.Never,
     dependencies: [
-      DatabaseService14
+      Database20.Service
     ]
   }),
   //
   // Tags
   //
   Tool3.make("tag-add", {
-    description: trim11`
+    description: trim14`
       Adds a tag to an object.
       Tags are objects of type ${Tag2.Tag.typename}.
     `,
     parameters: {
-      tagId: ArtifactId7.annotations({
+      tagId: ArtifactId2.annotations({
         description: "The ID of the tag."
       }),
-      objectId: ArtifactId7.annotations({
+      objectId: ArtifactId2.annotations({
         description: "The ID of the object."
       })
     },
-    success: Schema17.Any,
-    failure: Schema17.Never,
+    success: Schema24.Any,
+    failure: Schema24.Never,
     dependencies: [
-      DatabaseService14
+      Database20.Service
     ]
   }),
   Tool3.make("tag-remove", {
-    description: trim11`
+    description: trim14`
       Removes a tag from an object.
       Tags are objects of type ${Tag2.Tag.typename}.
     `,
     parameters: {
-      tagId: ArtifactId7.annotations({
+      tagId: ArtifactId2.annotations({
         description: "The ID of the tag."
       }),
-      objectId: ArtifactId7.annotations({
+      objectId: ArtifactId2.annotations({
         description: "The ID of the object."
       })
     },
-    success: Schema17.Any,
-    failure: Schema17.Never,
+    success: Schema24.Any,
+    failure: Schema24.Never,
     dependencies: [
-      DatabaseService14
+      Database20.Service
     ]
   })
 );
 var tools2 = Record2.keys(SystemToolkit.tools);
 var layer4 = () => SystemToolkit.toLayer({
-  "schema-list": Effect17.fnUntraced(function* () {
-    const { db } = yield* DatabaseService14;
-    const schema = yield* Effect17.promise(() => db.schemaRegistry.query({
+  ["schema-list"]: Effect23.fnUntraced(function* () {
+    const { db } = yield* Database20.Service;
+    const schema = yield* Effect23.promise(() => db.schemaRegistry.query({
       location: [
         "database",
         "runtime"
       ]
     }).run());
     return schema.map((schema2) => {
-      const meta = Type4.getMeta(schema2);
+      const meta = Type16.getMeta(schema2);
       return {
-        typename: Type4.getTypename(schema2),
-        jsonSchema: Type4.toJsonSchema(schema2),
+        typename: Type16.getTypename(schema2),
+        jsonSchema: Type16.toJsonSchema(schema2),
         kind: meta?.sourceSchema ? "relation" : "record"
       };
     });
   }),
-  "schema-add": Effect17.fnUntraced(function* ({ name, typename, jsonSchema }) {
-    const { db } = yield* DatabaseService14;
-    yield* Effect17.promise(() => db.schemaRegistry.register([
+  ["schema-add"]: Effect23.fnUntraced(function* ({ name, typename, jsonSchema }) {
+    const { db } = yield* Database20.Service;
+    yield* Effect23.promise(() => db.schemaRegistry.register([
       {
         typename,
         version: "0.1.0",
@@ -2693,66 +3379,310 @@ var layer4 = () => SystemToolkit.toLayer({
       }
     ]));
   }),
-  "object-create": Effect17.fnUntraced(function* ({ typename, data }) {
-    const { db } = yield* DatabaseService14;
-    const schema = yield* Effect17.promise(() => db.schemaRegistry.query({
+  ["query"]: Effect23.fnUntraced(function* ({ typename }) {
+    const objects = yield* Database20.runQuery(Filter5.typename(typename));
+    return objects;
+  }),
+  ["object-create"]: Effect23.fnUntraced(function* ({ typename, data }) {
+    const { db } = yield* Database20.Service;
+    const schema = yield* Effect23.promise(() => db.schemaRegistry.query({
       typename,
       location: [
         "database",
         "runtime"
       ]
     }).first());
-    const object = db.add(Obj16.make(schema, data));
+    invariant4(Type16.isObjectSchema(schema), "Schema is not an object schema", {
+      F: __dxlog_file11,
+      L: 238,
+      S: this,
+      A: [
+        "Type.isObjectSchema(schema)",
+        "'Schema is not an object schema'"
+      ]
+    });
+    const object = db.add(Obj18.make(schema, data));
     return object;
   }),
-  "object-remove": Effect17.fnUntraced(function* ({ id }) {
-    const { db } = yield* DatabaseService14;
-    const object = yield* DatabaseService14.resolve(DXN2.parse(id));
+  ["object-delete"]: Effect23.fnUntraced(function* ({ id }) {
+    const { db } = yield* Database20.Service;
+    const object = yield* Database20.resolve(DXN2.parse(id));
     db.remove(object);
     return object;
   }),
-  "relation-create": Effect17.fnUntraced(function* ({ typename, source, target, data }) {
-    const { db } = yield* DatabaseService14;
-    const schema = yield* Effect17.promise(() => db.schemaRegistry.query({
+  ["object-update"]: Effect23.fnUntraced(function* ({ id, properties }) {
+    const object = yield* Database20.resolve(DXN2.parse(id));
+    Entity3.change(object, (obj) => {
+      for (const [key, value2] of Object.entries(properties)) {
+        obj[key] = value2;
+      }
+    });
+    return object;
+  }),
+  ["relation-create"]: Effect23.fnUntraced(function* ({ typename, source, target, data }) {
+    const { db } = yield* Database20.Service;
+    const schema = yield* Effect23.promise(() => db.schemaRegistry.query({
       typename,
       location: [
         "database",
         "runtime"
       ]
     }).first());
-    const sourceObj = yield* DatabaseService14.resolve(DXN2.parse(source));
-    const targetObj = yield* DatabaseService14.resolve(DXN2.parse(target));
-    const relation = db.add(Relation2.make(schema, {
-      [Relation2.Source]: sourceObj,
-      [Relation2.Target]: targetObj,
+    invariant4(Type16.isRelationSchema(schema), "Schema is not a relation schema", {
+      F: __dxlog_file11,
+      L: 267,
+      S: this,
+      A: [
+        "Type.isRelationSchema(schema)",
+        "'Schema is not a relation schema'"
+      ]
+    });
+    const sourceObj = yield* Database20.resolve(DXN2.parse(source));
+    const targetObj = yield* Database20.resolve(DXN2.parse(target));
+    const relation = db.add(Relation3.make(schema, {
+      [Relation3.Source]: sourceObj,
+      [Relation3.Target]: targetObj,
       ...data
     }));
     return relation;
   }),
-  "tag-add": Effect17.fnUntraced(function* ({ tagId, objectId }) {
-    const object = yield* DatabaseService14.resolve(DXN2.parse(objectId));
-    Obj16.addTag(object, DXN2.parse(tagId).toString());
+  ["relation-delete"]: Effect23.fnUntraced(function* ({ id }) {
+    const { db } = yield* Database20.Service;
+    const relation = yield* Database20.resolve(DXN2.parse(id));
+    db.remove(relation);
+    return relation;
+  }),
+  ["tag-add"]: Effect23.fnUntraced(function* ({ tagId, objectId }) {
+    const object = yield* Database20.resolve(DXN2.parse(objectId));
+    Entity3.change(object, (obj) => Entity3.addTag(obj, DXN2.parse(tagId).toString()));
     return object;
   }),
-  "tag-remove": Effect17.fnUntraced(function* ({ tagId, objectId }) {
-    const object = yield* DatabaseService14.resolve(DXN2.parse(objectId));
-    Obj16.removeTag(object, DXN2.parse(tagId).toString());
+  ["tag-remove"]: Effect23.fnUntraced(function* ({ tagId, objectId }) {
+    const object = yield* Database20.resolve(DXN2.parse(objectId));
+    Entity3.change(object, (obj) => Entity3.removeTag(obj, DXN2.parse(tagId).toString()));
     return object;
   })
 });
+
+// src/toolkits/WebToolkit.ts
+var WebToolkit_exports = {};
+__export(WebToolkit_exports, {
+  WebToolkit: () => WebToolkit,
+  layer: () => layer5
+});
+import * as Tool4 from "@effect/ai/Tool";
+import * as Toolkit6 from "@effect/ai/Toolkit";
+import * as AnthropicTool3 from "@effect/ai-anthropic/AnthropicTool";
+import * as Effect24 from "effect/Effect";
+import * as Schema25 from "effect/Schema";
+var WebToolkit = Toolkit6.make(AnthropicTool3.WebSearch_20250305({}).pipe(), Tool4.make("WebFetch", {
+  parameters: {
+    url: Schema25.String
+  },
+  success: Schema25.String
+}));
+var layer5 = WebToolkit.toLayer({
+  WebFetch: Effect24.fnUntraced(function* ({ url }) {
+    const response = yield* Effect24.promise(() => fetch(url).then((response2) => response2.text()));
+    return response;
+  })
+});
+
+// src/planning/index.ts
+var planning_exports = {};
+__export(planning_exports, {
+  PlanningBlueprint: () => PlanningBlueprint,
+  PlanningFunctions: () => functions_exports
+});
+
+// src/planning/blueprint.ts
+import { Blueprint as Blueprint9 } from "@dxos/blueprints";
+
+// src/planning/functions/index.ts
+var functions_exports = {};
+__export(functions_exports, {
+  updateTasks: () => update_tasks_default
+});
+
+// src/planning/functions/update-tasks.ts
+import * as Effect25 from "effect/Effect";
+import * as Schema26 from "effect/Schema";
+import { AiContextService as AiContextService6 } from "@dxos/assistant";
+import { Database as Database21, Obj as Obj19 } from "@dxos/echo";
+import { defineFunction as defineFunction18 } from "@dxos/functions";
+import { trim as trim15 } from "@dxos/util";
+var INSTRUCTIONS = trim15`
+TASK MANAGEMENT TOOL - USAGE GUIDELINES
+
+This tool maintains an organized task list during work sessions to track progress, break down objectives, and ensure thoroughness. After creating initial tasks, update them silently without announcing changes to the user.
+
+=== CORE USAGE PRINCIPLES ===
+
+Create and manage tasks for: multi-step objectives requiring 3+ distinct actions, complex projects needing careful sequencing, user requests for task organization, multiple deliverables provided together, new instructions (capture as tasks immediately with new IDs), completed work (mark done and add follow-ups), and active work (mark as 'in-progress', limit one at a time).
+
+Skip task management for: single straightforward actions, simple requests achievable in 1-2 steps, informational queries, quick lookups or clarifications, and avoid creating verification tasks unless requested.
+
+=== TOOL SPECIFICATION ===
+
+update-tasks requires an array of task objects. Each task object contains:
+- id (string, required): unique identifier like "task_1" or "research_sources"
+- title (string, optional): update to clarify or refine task description
+- status (string, optional): 'todo' | 'in-progress' | 'done'
+
+Task status meanings: 'todo' means not yet started, 'in-progress' means currently being worked on, 'done' means completed successfully.
+
+=== OPERATIONAL GUIDELINES ===
+
+Update tasks in real-time as work progresses. Mark tasks 'done' immediately upon completion. Maintain only ONE task with 'in-progress' status at a time. Complete current tasks before starting new ones. Use specific, actionable task titles. Break complex work into manageable logical pieces. Batch task updates with other actions when possible for efficiency.
+
+=== USAGE EXAMPLES ===
+
+<example type="research_project">
+<user_message>I need to research sustainable packaging options and write a report comparing costs and environmental impact.</user_message>
+<assistant_action>
+Creates tasks:
+1. {id: "research_materials", title: "Research sustainable packaging materials", status: "in-progress"}
+2. {id: "compare_costs", title: "Compile cost comparison data", status: "todo"}
+3. {id: "assess_impact", title: "Evaluate environmental impact metrics", status: "todo"}
+4. {id: "draft_report", title: "Write comparative analysis report", status: "todo"}
+
+Begins research work immediately in same response.
+</assistant_action>
+<reasoning>Multi-phase project requiring systematic tracking across research, analysis, and writing stages.</reasoning>
+</example>
+
+<example type="event_planning">
+<user_message>Help me plan a team retreat - venue, agenda, catering, and send invitations.</user_message>
+<assistant_action>
+Creates tasks:
+1. {id: "venue_options", title: "Research and recommend venues", status: "in-progress"}
+2. {id: "draft_agenda", title: "Create retreat agenda", status: "todo"}
+3. {id: "arrange_catering", title: "Coordinate catering options", status: "todo"}
+4. {id: "send_invites", title: "Draft and send invitations", status: "todo"}
+</assistant_action>
+<reasoning>Multiple distinct deliverables with dependencies requiring organized tracking.</reasoning>
+</example>
+
+<example type="document_analysis">
+<user_message>Review this 30-page contract for key terms, risks, and negotiation points.</user_message>
+<assistant_action>
+Creates tasks:
+1. {id: "extract_key_terms", title: "Identify key contractual terms", status: "in-progress"}
+2. {id: "flag_risks", title: "Flag potential risks and liabilities", status: "todo"}
+3. {id: "negotiation_points", title: "Compile negotiation recommendations", status: "todo"}
+4. {id: "summary_doc", title: "Prepare executive summary", status: "todo"}
+</assistant_action>
+<reasoning>Substantial analysis work requiring methodical breakdown and systematic review.</reasoning>
+</example>
+
+<example type="multiple_deliverables">
+<user_message>I need: 1) competitor analysis for three companies, 2) SWOT analysis, 3) market positioning recommendations.</user_message>
+<assistant_action>
+Creates tasks:
+1. {id: "competitor_research", title: "Research three competitor companies", status: "in-progress"}
+2. {id: "swot_analysis", title: "Develop SWOT analysis", status: "todo"}
+3. {id: "positioning_recs", title: "Create market positioning recommendations", status: "todo"}
+</assistant_action>
+<reasoning>User provided numbered list of distinct deliverables requiring separate effort.</reasoning>
+</example>
+
+<example type="skip_simple_question">
+<user_message>What's the difference between renewable and sustainable energy?</user_message>
+<assistant_action>Provides explanation directly without creating tasks.</assistant_action>
+<reasoning>Informational request with no actionable work to complete or track.</reasoning>
+</example>
+
+<example type="skip_quick_lookup">
+<user_message>Find the population of Tokyo.</user_message>
+<assistant_action>Searches and provides answer without task tracking.</assistant_action>
+<reasoning>Single straightforward lookup completable immediately.</reasoning>
+</example>
+
+<example type="skip_trivial_task">
+<user_message>Summarize this 2-paragraph email.</user_message>
+<assistant_action>Provides summary directly without creating tasks.</assistant_action>
+<reasoning>Single simple action requiring no breakdown or progress tracking.</reasoning>
+</example>
+
+<example type="skip_single_action">
+<user_message>Check if my flight is on time.</user_message>
+<assistant_action>Performs lookup and reports status without task management.</assistant_action>
+<reasoning>One-step action with immediate completion, no organizational benefit from tasks.</reasoning>
+</example>
+
+=== BEST PRACTICES ===
+
+For task creation: use descriptive unique IDs reflecting the work, start first task as 'in-progress', batch initial creation with beginning work. For progress tracking: update status immediately upon completion, keep only one 'in-progress' task unless parallel work is natural, add follow-up tasks as they emerge. For task breakdown: aim for reasonably-scoped tasks, group related small actions into logical units, split tasks requiring different approaches.
+
+When uncertain whether to use task management, err on the side of creating tasks. Proactive organization demonstrates thoroughness and ensures comprehensive work completion.
+`;
+var TaskProps = Schema26.Struct({
+  id: TaskId,
+  title: Schema26.String,
+  status: Schema26.Literal("todo", "in-progress", "done")
+});
+var update_tasks_default = defineFunction18({
+  key: "dxos.org/function/planning/update-tasks",
+  name: "Update tasks",
+  description: INSTRUCTIONS,
+  inputSchema: Schema26.Struct({
+    tasks: Schema26.Array(TaskProps)
+  }),
+  handler: Effect25.fn(function* ({ data: { tasks: newTasks } }) {
+    const initiative = yield* getFromChatContext;
+    const plan = yield* Database21.load(initiative.plan);
+    Obj19.change(plan, (plan2) => {
+      for (const task of newTasks) {
+        const existingTask = plan2.tasks.find((t) => t.id === task.id);
+        if (existingTask) {
+          existingTask.title = task.title;
+          existingTask.status = task.status;
+        } else {
+          plan2.tasks.push({
+            id: task.id,
+            title: task.title,
+            status: task.status
+          });
+        }
+      }
+    });
+    return `
+      Tasks updated. Don't forget to mark tasks as done when you're done with them or update their status to 'in-progress' when you start working on them.
+      Current plan:
+      <plan>
+        ${formatPlan(plan)}
+      </plan>
+    `;
+  }, AiContextService6.fixFunctionHandlerType)
+});
+
+// src/planning/blueprint.ts
+var PlanningBlueprint = Blueprint9.make({
+  key: "dxos.org/blueprint/planning",
+  name: "Planning",
+  description: "Plans and tracks complex tasks with artifact management.",
+  tools: Blueprint9.toolDefinitions({
+    functions: [
+      update_tasks_default
+    ]
+  })
+});
 export {
   Agent,
   AssistantToolkit_exports as AssistantToolkit,
+  Chat_exports as Chat,
   design_default as DesignBlueprint,
   Discord,
   discord_default as DiscordBlueprint,
   Document,
   EntityExtraction,
+  initiative_exports as Initiative,
   Linear,
   linear_default as LinearBlueprint,
   LocalSearchHandler,
   LocalSearchToolkit,
-  MapSchema,
+  markdown_default as MarkdownBlueprint,
+  planning_exports as Planning,
   planning_default as PlanningBlueprint,
   Research,
   research_default2 as ResearchBlueprint,
@@ -2763,7 +3693,7 @@ export {
   Tasks,
   websearch_default as WebSearchBlueprint,
   WebSearchToolkit,
-  capabilities,
+  WebToolkit_exports as WebToolkit,
   contextQueueLayerFromResearchGraph,
   createExtractionSchema,
   createResearchGraph,