@dxos/assistant 0.8.3 → 0.8.4-main.3a94e84

package/dist/lib/browser/index.mjs

@@ -1,512 +1,294 @@
-// packages/core/assistant/src/extraction/extraction.ts
+// src/context/binder.ts
+import { computed } from "@preact/signals-core";
+import { Array as Array2, pipe } from "effect";
+import { Obj } from "@dxos/echo";
+import { ComplexSet } from "@dxos/util";
+
+// src/context/binding.ts
 import { Schema } from "effect";
-import { asyncTimeout } from "@dxos/async";
-import { Expando } from "@dxos/echo-schema";
-import { log } from "@dxos/log";
-import { DataType } from "@dxos/schema";
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/assistant/src/extraction/extraction.ts";
-var ExtractionInput = Schema.Struct({
-  message: DataType.Message,
-  objects: Schema.optional(Schema.Array(Expando)),
-  options: Schema.optional(Schema.Struct({
-    timeout: Schema.optional(Schema.Number),
-    fallbackToRaw: Schema.optional(Schema.Boolean)
-  }))
-});
-var ExtractionOutput = Schema.Struct({
-  message: DataType.Message,
-  timeElapsed: Schema.Number
-});
-var processTranscriptMessage = async (params) => {
-  try {
-    if (params.options?.timeout && params.options.timeout > 0) {
-      return await asyncTimeout(params.executor.invoke(params.function, params.input), params.options.timeout);
-    } else {
-      return await params.executor.invoke(params.function, params.input);
+import { Blueprint } from "@dxos/blueprints";
+import { Type } from "@dxos/echo";
+var ContextBinding = Schema.Struct({
+  blueprints: Schema.Struct({
+    added: Schema.Array(Type.Ref(Blueprint.Blueprint)),
+    removed: Schema.Array(Type.Ref(Blueprint.Blueprint))
+  }),
+  // TODO(burdon): Type.Expando => Type.Obj (or Obj.Any?)
+  objects: Schema.Struct({
+    added: Schema.Array(Type.Ref(Type.Expando)),
+    removed: Schema.Array(Type.Ref(Type.Expando))
+  })
+}).pipe(Type.Obj({
+  typename: "dxos.org/type/ContextBinding",
+  version: "0.1.0"
+}));
+
+// src/context/binder.ts
+var ContextBinder = class {
+  constructor(_queue) {
+    this._queue = _queue;
+    this.bindings = computed(() => this._reduce(this._queue.objects));
+    this.blueprints = computed(() => [
+      ...this.bindings.value.blueprints
+    ]);
+    this.objects = computed(() => [
+      ...this.bindings.value.objects
+    ]);
+  }
+  /**
+  * Asynchronous query of all bindings.
+  */
+  async query() {
+    const queueItems = await this._queue.queryObjects();
+    return this._reduce(queueItems);
+  }
+  // TODO(burdon): Pass in Blueprint obj (from registry?) and create reference.
+  async bind(props) {
+    if (!props.blueprints?.length && !props.objects?.length) {
+      return;
     }
-  } catch (error) {
-    if (params.options?.fallbackToRaw) {
-      log.warn("failed to process message, falling back to raw text", {
-        error
-      }, {
-        F: __dxlog_file,
-        L: 66,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      return {
-        message: params.input.message,
-        timeElapsed: 0
-      };
-    } else {
-      throw error;
+    await this._queue.append([
+      Obj.make(ContextBinding, {
+        blueprints: {
+          added: props.blueprints ?? [],
+          removed: []
+        },
+        objects: {
+          added: props.objects ?? [],
+          removed: []
+        }
+      })
+    ]);
+  }
+  async unbind(props) {
+    if (!props.blueprints?.length && !props.objects?.length) {
+      return;
     }
+    await this._queue.append([
+      Obj.make(ContextBinding, {
+        blueprints: {
+          added: [],
+          removed: props.blueprints ?? []
+        },
+        objects: {
+          added: [],
+          removed: props.objects ?? []
+        }
+      })
+    ]);
+  }
+  _reduce(items) {
+    return pipe(items, Array2.filter(Obj.instanceOf(ContextBinding)), Array2.reduce(new Bindings(), (context, item) => {
+      item.blueprints.removed.forEach((item2) => context.blueprints.delete(item2));
+      item.blueprints.added.forEach((item2) => context.blueprints.add(item2));
+      item.objects.removed.forEach((item2) => context.objects.delete(item2));
+      item.objects.added.forEach((item2) => context.objects.add(item2));
+      return context;
+    }));
+  }
+};
+var Bindings = class {
+  constructor() {
+    this.blueprints = new ComplexSet((ref) => ref.dxn.toString());
+    this.objects = new ComplexSet((ref) => ref.dxn.toString());
   }
 };
 
-// packages/core/assistant/src/extraction/extraction-llm-function/extraction-llm-function.ts
-import { Message as Message2 } from "@dxos/ai";
-import { Obj as Obj2 } from "@dxos/echo";
-import { create as create2 } from "@dxos/echo-schema";
-import { AiService, defineFunction } from "@dxos/functions";
+// src/conversation/conversation.ts
+import { Effect as Effect2 } from "effect";
+import { Event as Event2 } from "@dxos/async";
+import { Obj as Obj3 } from "@dxos/echo";
+import { DatabaseService as DatabaseService2 } from "@dxos/functions";
 import { DataType as DataType2 } from "@dxos/schema";
 
-// raw-loader:./instructions.tpl?raw
-var instructions_default = 'You are an AI assistant specialized in processing and enhancing transcripts with contextual information.\nYour task is to analyze a given transcript and extract references to the context objects.\n\nThe context and transcript are provided in the user message in `context` and `transcript` XML tags.\n\nHere are your instructions:\n\n1. Read the transcript and context information provided above.\n\n2. Process each segment of the transcript separately.\n\n3. For each segment:\n   a. Analyze the content and identify relevant information from the context.\n   b. Extract a number of references to the context objects that are mentioned in the segment.\n   c. Output the references in the format `{ "quote": "earnings report", "id": "01JT0JP9AX0XKGZX4MV4B69VT6" }`.\n   d. If there are no references, just output an empty array.\n\n4. Maintain the exact order and structure of the original transcript segments.\n\nOutput Format:\nYou have been provided with a tool that specifies output format\n\nRemember:\n- Only quote the text that is in the transcript.\n- Analyze each segment carefully before processing it.\n- Only reference objects that appear in the context and exactly by their id, If the object is not in the context, do not insert a reference. \n\nNow, process the transcript and context provided below according to these instructions.';
-
-// packages/core/assistant/src/session/session.ts
-import { Option, Schema as Schema3 } from "effect";
-import { AgentStatusReport, isToolUse, runTools, structuredOutputParser, Message, MixedStreamParser, ToolResult, createTool } from "@dxos/ai";
-import { Event, synchronized } from "@dxos/async";
-import { Obj } from "@dxos/echo";
+// src/session/session.ts
+import { AiLanguageModel, AiToolkit } from "@effect/ai";
+import { Chunk, Context, Effect, Option, pipe as pipe2, Stream } from "effect";
+import { Array as Array3, String } from "effect";
+import { AiParser, AiPreprocessor, getToolCalls, runTool, ToolExecutionService, ToolResolverService } from "@dxos/ai";
+import { Event } from "@dxos/async";
+import { todo } from "@dxos/debug";
+import { Obj as Obj2 } from "@dxos/echo";
 import { ObjectVersion } from "@dxos/echo-db";
-import { create } from "@dxos/echo-schema";
-import { invariant } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
+import { DatabaseService } from "@dxos/functions";
+import { log } from "@dxos/log";
+import { DataType } from "@dxos/schema";
 
-// packages/core/assistant/src/session/version-pin.ts
-import { Schema as Schema2 } from "effect";
-import { getVersion } from "@dxos/echo-db";
-import { ObjectId } from "@dxos/echo-schema";
-var ObjectVersionSchema = Schema2.Unknown;
-var VersionPinSchema = Schema2.Struct({
-  // TODO(dmaretskyi): Use Ref when those support encoding.
-  objectId: ObjectId,
-  // TODO(dmaretskyi): Could be opaque
-  version: ObjectVersionSchema
-});
-var VersionPin = class extends VersionPinSchema {
-  static {
-    this.DISPOSITION = "version-pin";
-  }
-  static fromObject(object) {
-    return VersionPin.make({
-      objectId: object.id,
-      version: getVersion(object)
-    });
-  }
-  static createBlock(pin) {
-    return {
-      type: "json",
-      disposition: VersionPin.DISPOSITION,
-      json: JSON.stringify(pin)
-    };
-  }
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var AiAssistantError = class extends BaseError.extend("AI_ASSISTANT_ERROR") {
 };
 
-// packages/core/assistant/src/session/session.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/assistant/src/session/session.ts";
-var AISession = class _AISession {
-  constructor(_options) {
+// src/session/session.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant/src/session/session.ts";
+var AiSession = class {
+  constructor(_options = {}) {
     this._options = _options;
-    this._parser = new MixedStreamParser();
+    this._semaphore = Effect.runSync(Effect.makeSemaphore(1));
     this._pending = [];
     this._history = [];
-    this.message = this._parser.message;
-    this.block = this._parser.block;
-    this.update = this._parser.update;
-    this.streamEvent = this._parser.streamEvent;
+    this.message = new Event();
+    this.block = new Event();
+    this.update = new Event();
+    this.streamEvent = new Event();
     this.userMessage = new Event();
     this.statusReport = new Event();
-    this.toolStatusReport = new Event();
-    this._parser.message.on((message) => {
-      this._pending.push(message);
-    });
-    this._parser.block.on((block) => {
-      if (block.type === "text" && block.disposition === "status") {
-        this.statusReport.emit(create(AgentStatusReport, {
-          message: block.text
-        }));
-      }
-    });
-  }
-  async run(options) {
-    const systemTools = [];
-    switch (this._options.operationModel) {
-      case "planning":
-        systemTools.push(this._createQueryArtifactsTool(options.artifacts), this._createPlanningTool(options));
-        break;
-      case "importing":
-        systemTools.push(this._createQueryArtifactsTool(options.artifacts), this._createRequireTool(options.artifacts, (artifactDefinitionIds) => {
-          for (const artifactDefinitionId of artifactDefinitionIds) {
-            requiredArtifactIds.add(artifactDefinitionId);
-          }
-        }));
-        break;
-      case "configured":
-        break;
-      default:
-        throw new TypeError(`Invalid operation model: ${this._options.operationModel}`);
-    }
-    this._history = [
-      ...options.history
-    ];
-    this._pending = [
-      await this._formatUserPrompt(options.artifactDiffResolver, options.prompt, options.history)
-    ];
-    this.userMessage.emit(this._pending.at(-1));
-    this._stream = void 0;
-    let error;
-    const requiredArtifactIds = new Set(options.requiredArtifactIds ?? []);
-    try {
-      let more = false;
+    this.done = new Event();
+    this.run = (options) => Effect.gen(this, function* () {
+      this._history = [
+        ...options.history
+      ];
+      const promptMessages = yield* this._formatUserPrompt(options.prompt, options.history);
+      this._pending = [
+        promptMessages
+      ];
+      this.userMessage.emit(promptMessages);
       do {
-        const tools = [
-          ...systemTools,
-          ...options.tools,
-          ...options.artifacts.filter((artifact) => requiredArtifactIds.has(artifact.id)).flatMap((artifact) => artifact.tools)
-        ];
-        log2("request", {
+        log("request", {
           pending: this._pending.length,
           history: this._history.length,
-          tools: tools.map((tool) => tool.name)
+          tools: Object.values(options.toolkit?.tools ?? {}).map((tool) => tool.name)
         }, {
-          F: __dxlog_file2,
-          L: 201,
+          F: __dxlog_file,
+          L: 126,
           S: this,
           C: (f, a) => f(...a)
         });
-        this._stream = await options.client.execStream({
-          ...options.generationOptions ?? {},
-          // TODO(burdon): Rename messages or separate history/message.
-          history: [
-            ...this._history,
-            ...this._pending
-          ],
-          tools,
-          systemPrompt: options.systemPrompt ?? createBaseInstructions({
-            availableArtifacts: Array.from(requiredArtifactIds),
-            operationModel: this._options.operationModel
-          })
-        });
-        await this._parser.parse(this._stream);
-        await this._stream.complete();
-        log2("response", {
-          pending: this._pending
+        const prompt = yield* AiPreprocessor.preprocessAiInput([
+          ...this._history,
+          ...this._pending
+        ]);
+        const blueprints = options.blueprints ?? [];
+        const systemPrompt = yield* pipe2(blueprints, Effect.forEach((blueprint) => DatabaseService.loadRef(blueprint.instructions)), Effect.flatMap(Effect.forEach((template) => DatabaseService.loadRef(template.source))), Effect.map(Array3.map((template) => `
+
+<blueprint>${template.content}</blueprint>`)), Effect.map(Array3.reduce(options.systemPrompt ?? "", String.concat)));
+        const blueprintToolkit = yield* ToolResolverService.resolveToolkit(blueprints.flatMap((bp) => bp.tools));
+        const blueprintToolkitHandler = yield* blueprintToolkit.toContext(yield* ToolExecutionService.handlersFor(blueprintToolkit));
+        const toolkit = options.toolkit != null ? AiToolkit.merge(options.toolkit, blueprintToolkit) : blueprintToolkit;
+        const toolkitWithBlueprintHandlers = yield* toolkit.pipe(Effect.provide(blueprintToolkitHandler));
+        log.info("run", {
+          systemPrompt: [
+            systemPrompt.slice(0, 32),
+            "...",
+            systemPrompt.slice(-32),
+            systemPrompt.length
+          ].join(" "),
+          tools: Object.keys(blueprintToolkit.tools)
         }, {
-          F: __dxlog_file2,
-          L: 226,
+          F: __dxlog_file,
+          L: 155,
           S: this,
           C: (f, a) => f(...a)
         });
-        more = false;
-        const message = this._pending.at(-1);
-        invariant(message, void 0, {
-          F: __dxlog_file2,
-          L: 231,
-          S: this,
-          A: [
-            "message",
-            ""
-          ]
-        });
-        if (isToolUse(message)) {
-          log2("tool request...", void 0, {
-            F: __dxlog_file2,
-            L: 233,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          const response = await runTools({
-            message: this._pending.at(-1),
-            tools,
-            extensions: options.extensions ?? {},
-            reportStatus: (status) => this._onToolStatusReport(message, status)
-          });
-          log2("tool response", {
-            response
-          }, {
-            F: __dxlog_file2,
-            L: 241,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          switch (response.type) {
-            case "continue": {
-              this._pending = [
-                ...this._pending,
-                response.message
-              ];
-              this.userMessage.emit(response.message);
-              more = true;
-              break;
+        const blocks = yield* AiLanguageModel.streamText({
+          prompt,
+          system: systemPrompt,
+          toolkit: toolkitWithBlueprintHandlers,
+          disableToolCallResolution: true
+        }).pipe(AiParser.parseGptStream({
+          onBlock: (block) => Effect.gen(this, function* () {
+            if (block.pending) {
+              this.update.emit(block);
+            } else {
+              this.block.emit(block);
             }
-          }
-        }
-      } while (more);
-    } catch (err) {
-      log2.catch(err, void 0, {
-        F: __dxlog_file2,
-        L: 253,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      if (err instanceof Error && err.message.includes("Overloaded")) {
-        error = new AIServiecOverloadedError("AI service overloaded", {
-          cause: err
-        });
-      } else {
-        error = new Error("AI service error", {
-          cause: err
-        });
-      }
-    } finally {
-      this._stream = void 0;
-    }
-    if (error) {
-      throw error;
-    }
-    return this._pending;
-  }
-  async runStructured(schema, options) {
-    const parser = structuredOutputParser(schema);
-    const result = await this.run({
-      ...options,
-      tools: [
-        ...options.tools,
-        parser.tool
-      ]
-    });
-    return parser.getResult(result);
-  }
-  async _formatUserPrompt(artifactDiffResolver, prompt, history) {
-    const prelude = [];
-    if (artifactDiffResolver) {
-      const versions = gatherObjectVersions(history);
-      const artifactDiff = await artifactDiffResolver(Array.from(versions.entries()).map(([id, version]) => ({
-        id,
-        lastVersion: version
-      })));
-      log2.info("vision", {
-        artifactDiff,
-        versions
-      }, {
-        F: __dxlog_file2,
-        L: 296,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      for (const [id, { version }] of [
-        ...artifactDiff.entries()
-      ]) {
-        if (ObjectVersion.equals(version, versions.get(id))) {
-          artifactDiff.delete(id);
-          continue;
-        }
-        prelude.push(VersionPin.createBlock(VersionPin.make({
-          objectId: id,
-          version
-        })));
-      }
-      if (artifactDiff.size > 0) {
-        prelude.push(createArtifactUpdateBlock(artifactDiff));
-      }
-    }
-    return Obj.make(Message, {
-      role: "user",
-      content: [
-        ...prelude,
-        {
-          type: "text",
-          text: prompt
-        }
-      ]
-    });
-  }
-  _createQueryArtifactsTool(artifacts) {
-    return createTool("system", {
-      name: "query_artifact_definitions",
-      description: "Query the available artifact definitions",
-      schema: Schema3.Struct({}),
-      execute: async () => {
-        return ToolResult.Success({
-          artifactDefinitions: artifacts.map((artifact) => ({
-            id: artifact.id,
-            name: artifact.name,
-            description: artifact.description
-          }))
-        });
-      }
-    });
-  }
-  _createRequireTool(artifacts, onRequire) {
-    return createTool("system", {
-      name: "require_artifact_definitions",
-      description: "Require the use of specific artifact definitions. This will allow the model to interact with artifact definitions and use their tools.",
-      schema: Schema3.Struct({
-        artifactDefinitionIds: Schema3.Array(Schema3.String).annotations({
-          description: "The ids of the artifact definitions to require",
-          examples: [
-            [
-              "artifact:dxos.org/example/Test"
-            ]
-          ]
-        })
-      }),
-      execute: async ({ artifactDefinitionIds }) => {
-        const missingArtifactDefinitionIds = artifactDefinitionIds.filter((artifactId) => !artifacts.some((artifact) => artifact.id === artifactId));
-        if (missingArtifactDefinitionIds.length > 0) {
-          return ToolResult.Error(`One or more artifact definition ids are invalid: ${missingArtifactDefinitionIds.join(", ")}`);
-        }
-        onRequire(artifactDefinitionIds);
-        return ToolResult.Success({});
-      }
-    });
-  }
-  _createPlanningTool(options) {
-    return createTool("system", {
-      name: "create_plan",
-      description: "Create a plan. Make sure that each step is independent and can be executed solely on the data returned by the previous step. The steps only share the data that is specified in the plan.",
-      schema: Schema3.Struct({
-        goal: Schema3.String.annotations({
-          description: "The goal that the plan will achieve."
-        }),
-        steps: Schema3.Array(Schema3.Struct({
-          action: Schema3.String.annotations({
-            description: "Complete, detailed action to perform."
-          }),
-          input: Schema3.String.annotations({
-            description: "The required input data for this step. First step must not require any data."
           }),
-          output: Schema3.String.annotations({
-            description: "The output data from this step. This is passed to the next step as input."
-          }),
-          requiredArtifactIds: Schema3.Array(Schema3.String).annotations({
-            description: "The ids of the artifacts required to perform this step.",
-            examples: [
-              [
-                "artifact:dxos.org/example/Test"
-              ]
-            ]
+          onPart: (part) => Effect.gen(this, function* () {
+            this.streamEvent.emit(part);
           })
-        })).annotations({
-          description: "Steps"
-        })
-      }),
-      execute: async ({ goal, steps }) => {
-        const missingArtifactIds = steps.flatMap((step) => step.requiredArtifactIds).filter((artifactId) => !options.artifacts.some((artifact) => artifact.id === artifactId));
-        if (missingArtifactIds.length > 0) {
-          return ToolResult.Error(`One or more artifact ids are invalid: ${missingArtifactIds.join(", ")}`);
+        }), Stream.runCollect, Effect.map(Chunk.toArray));
+        const response = Obj2.make(DataType.Message, {
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          sender: {
+            role: "assistant"
+          },
+          blocks
+        });
+        this._pending.push(response);
+        this.message.emit(response);
+        const toolCalls = getToolCalls(response);
+        if (toolCalls.length === 0) {
+          break;
         }
-        const stepResults = [];
-        for (const step of steps) {
-          log2("executing step", {
-            action: step.action
-          }, {
-            F: __dxlog_file2,
-            L: 403,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          const session = new _AISession({
-            operationModel: "importing"
-          });
-          session.message.on((ev) => this.message.emit(ev));
-          session.block.on((ev) => this.block.emit(ev));
-          session.update.on((ev) => this.update.emit(ev));
-          session.streamEvent.on((ev) => this.streamEvent.emit(ev));
-          session.userMessage.on((ev) => this.userMessage.emit(ev));
-          const messages = await session.run({
-            client: options.client,
-            artifacts: options.artifacts,
-            tools: options.tools,
-            history: options.history,
-            extensions: options.extensions,
-            generationOptions: options.generationOptions,
-            requiredArtifactIds: step.requiredArtifactIds.slice(),
-            artifactDiffResolver: options.artifactDiffResolver,
-            prompt: `
-              You are an agent that executes the subtask in a plan.
-              
-              While you know the plan's goal only focus on your subtask
-              Use the data from the previous step to complete your task.
-              Return all of the data from "output" in your last message.
-              
-              Current step (that you need to complete):
-              ${JSON.stringify({
-              goal,
-              input: step.input,
-              output: step.output,
-              yourTask: step.action
-            }, null, 2)}
-              
-              Previous step results:
-              ${JSON.stringify(stepResults.at(-1))}.
-            `
+        const toolResults = yield* runTools(toolCalls, toolkitWithBlueprintHandlers);
+        this._pending.push(Obj2.make(DataType.Message, {
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          sender: {
+            role: "user"
+          },
+          blocks: toolResults
+        }));
+      } while (true);
+      return this._pending;
+    }).pipe(this._semaphore.withPermits(1), Effect.withSpan("AiSession.run"));
+    this._formatUserPrompt = (prompt, history) => Effect.gen(function* () {
+      const prelude = [];
+      const artifactDiffResolver = yield* Effect.serviceOption(ArtifactDiffResolver);
+      if (Option.isSome(artifactDiffResolver)) {
+        const versions = gatherObjectVersions(history);
+        const artifactDiff = yield* Effect.tryPromise({
+          try: () => artifactDiffResolver.value.resolve([
+            ...versions.entries()
+          ].map(([id, version]) => ({
+            id,
+            lastVersion: version
+          }))),
+          catch: AiAssistantError.wrap("Artifact diff resolution error")
+        });
+        log.info("vision", {
+          artifactDiff,
+          versions
+        }, {
+          F: __dxlog_file,
+          L: 240,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        for (const [id, { version }] of [
+          ...artifactDiff.entries()
+        ]) {
+          if (ObjectVersion.equals(version, versions.get(id))) {
+            artifactDiff.delete(id);
+            continue;
+          }
+          prelude.push({
+            _tag: "anchor",
+            objectId: id,
+            version
           });
-          const result = messages.at(-1);
-          stepResults.push(result);
         }
-        return ToolResult.Success({
-          stepResults
-        });
+        if (artifactDiff.size > 0) {
+          prelude.push(createArtifactUpdateBlock(artifactDiff));
+        }
       }
+      return Obj2.make(DataType.Message, {
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        sender: {
+          role: "user"
+        },
+        blocks: [
+          ...prelude,
+          {
+            _tag: "text",
+            text: prompt
+          }
+        ]
+      });
     });
   }
-  _onToolStatusReport(message, status) {
-    this.toolStatusReport.emit({
-      message,
-      status
-    });
+  async runStructured(schema, options) {
+    return todo();
   }
   abort() {
     this._stream?.abort();
   }
 };
-_ts_decorate([
-  synchronized
-], AISession.prototype, "run", null);
-var createBaseInstructions = ({ availableArtifacts, operationModel }) => `
-  You are a friendly, advanced AI assistant capable of creating and managing artifacts from available data and tools. 
-  Your task is to process user commands and questions and decide how best to respond.
-  In some cases, you will need to create or reference data objects called artifacts.
-
-  Follow these guidelines carefully:
-
-  Decision-making:
-
-  - Analyze the structure and type of the content in the user's message.
-  
-  
-  ${operationModel === "planning" ? `
-      - Can you complete the task using the available artifacts?
-      - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
-      - Identify which artifacts are relevant to the user's request.
-        - Break down the user's request into a step-by-step plan that you will use to execute the user's request, the plan items should include artifacts which will be used to perform the actions.
-      ` : ""}
-  ${operationModel === "importing" ? `
-      - Can you complete the task using the available artifacts?
-      - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
-      - Identify which artifacts are relevant to the user's request.
-    - Are the required artifacts already available?
-    - If not, select which artifact(s) will be the most relevant and require them using the require_artifacts tool.
-    - The require'd artifact tools will be available for use after require.
-  ` : ""}
-  ${operationModel === "configured" ? `
-    - Select the most relevant artifact(s) to complete the task.
-    - Call the appropriate tool to use the artifact(s).
-  ` : ""}
-
-  ${availableArtifacts.length > 0 ? `Artifacts already in context: ${availableArtifacts.join("\n")}` : ""}
-`;
-var AIServiecOverloadedError = class extends Schema3.TaggedError()("AIServiecOverloadedError", {}) {
-};
 var gatherObjectVersions = (messages) => {
   const artifactIds = /* @__PURE__ */ new Map();
   for (const message of messages) {
-    for (const block of message.content) {
-      if (block.type === "json" && block.disposition === VersionPin.DISPOSITION) {
-        const pin = VersionPin.pipe(Schema3.decodeOption)(JSON.parse(block.json)).pipe(Option.getOrUndefined);
-        if (!pin) {
-          continue;
-        }
-        artifactIds.set(pin.objectId, pin.version);
+    for (const block of message.blocks) {
+      if (block._tag === "anchor") {
+        artifactIds.set(block.objectId, block.version);
       }
     }
   }
@@ -514,23 +296,153 @@ var gatherObjectVersions = (messages) => {
 };
 var createArtifactUpdateBlock = (artifactDiff) => {
   return {
-    type: "text",
+    _tag: "text",
+    // TODO(dmaretskyi): Does this need to be a special content-block?
     disposition: "artifact-update",
     text: `
       The following artifacts have been updated since the last message:
-      ${Array.from(artifactDiff.entries()).map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `
+      ${[
+      ...artifactDiff.entries()
+    ].map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `
 ${diff}` : ""}</changed-artifact>`).join("\n")}
     `
   };
 };
+var ArtifactDiffResolver = class extends Context.Tag("ArtifactDiffResolver")() {
+};
+var runTools = Effect.fn("runTools")(function* (toolCalls, toolkit) {
+  const toolkitWithHandlers = Effect.isEffect(toolkit) ? yield* toolkit : toolkit;
+  return yield* Effect.forEach(toolCalls, (toolCall) => runTool(toolkitWithHandlers, toolCall));
+});
+
+// src/session/version-pin.ts
+import { Schema as Schema2 } from "effect";
+import { getVersion } from "@dxos/echo-db";
+import { ObjectId } from "@dxos/echo-schema";
+var ObjectVersionSchema = Schema2.Unknown;
+var VersionPinSchema = Schema2.Struct({
+  // TODO(dmaretskyi): Use Ref when those support encoding.
+  objectId: ObjectId,
+  // TODO(dmaretskyi): Could be opaque
+  version: ObjectVersionSchema
+});
+var VersionPin = class extends VersionPinSchema {
+  static {
+    this.DISPOSITION = "version-pin";
+  }
+  static fromObject(object) {
+    return VersionPin.make({
+      objectId: object.id,
+      version: getVersion(object)
+    });
+  }
+  static createBlock(pin) {
+    return {
+      _tag: "json",
+      disposition: VersionPin.DISPOSITION,
+      data: JSON.stringify(pin)
+    };
+  }
+};
+
+// src/conversation/conversation.ts
+var Conversation = class {
+  constructor(options) {
+    /**
+    * Fired when the execution loop begins.
+    * This is called before the first message is sent.
+    */
+    this.onBegin = new Event2();
+    this.run = (options) => Effect2.gen(this, function* () {
+      const session = new AiSession();
+      this.onBegin.emit(session);
+      const history = yield* Effect2.promise(() => this.getHistory());
+      const context = yield* Effect2.promise(() => this.context.query());
+      const blueprints = yield* Effect2.forEach(context.blueprints.values(), DatabaseService2.loadRef);
+      const contextObjects = yield* Effect2.forEach(context.objects.values(), DatabaseService2.loadRef);
+      const systemPrompt = (options.systemPrompt ?? "") + "\n\n" + contextObjects.map((obj) => `<object>${Obj3.getDXN(obj)}</object>`).join("\n");
+      const messages = yield* session.run({
+        prompt: options.prompt,
+        history,
+        systemPrompt,
+        toolkit: options.toolkit,
+        blueprints
+      });
+      yield* Effect2.promise(() => this._queue.append(messages));
+      return messages;
+    }).pipe(Effect2.withSpan("Conversation.run"));
+    this._queue = options.queue;
+    this.context = new ContextBinder(this._queue);
+  }
+  async getHistory() {
+    const queueItems = await this._queue.queryObjects();
+    return queueItems.filter(Obj3.instanceOf(DataType2.Message));
+  }
+};
+
+// src/extraction/extraction.ts
+import { Schema as Schema3 } from "effect";
+import { asyncTimeout } from "@dxos/async";
+import { Expando } from "@dxos/echo-schema";
+import { log as log2 } from "@dxos/log";
+import { DataType as DataType3 } from "@dxos/schema";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/assistant/src/extraction/extraction.ts";
+var ExtractionInput = Schema3.Struct({
+  message: DataType3.Message,
+  objects: Schema3.optional(Schema3.Array(Expando)),
+  options: Schema3.optional(Schema3.Struct({
+    timeout: Schema3.optional(Schema3.Number),
+    fallbackToRaw: Schema3.optional(Schema3.Boolean)
+  }))
+});
+var ExtractionOutput = Schema3.Struct({
+  message: DataType3.Message,
+  timeElapsed: Schema3.Number
+});
+var processTranscriptMessage = async (params) => {
+  try {
+    if (params.options?.timeout && params.options.timeout > 0) {
+      return await asyncTimeout(params.executor.invoke(params.function, params.input), params.options.timeout);
+    } else {
+      return await params.executor.invoke(params.function, params.input);
+    }
+  } catch (error) {
+    if (params.options?.fallbackToRaw) {
+      log2.warn("failed to process message, falling back to raw text", {
+        error
+      }, {
+        F: __dxlog_file2,
+        L: 66,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return {
+        message: params.input.message,
+        timeElapsed: 0
+      };
+    } else {
+      throw error;
+    }
+  }
+};
 
-// packages/core/assistant/src/extraction/quotes.ts
+// src/extraction/extraction-llm-function/extraction-llm-function.ts
+import { ToolRegistry, AiService } from "@dxos/ai";
+import { Obj as Obj4 } from "@dxos/echo";
+import { create } from "@dxos/echo-schema";
+import { defineFunction } from "@dxos/functions";
+import { DataType as DataType4 } from "@dxos/schema";
+
+// raw-loader:./instructions.tpl?raw
+var instructions_default = 'You are an AI assistant specialized in processing and enhancing transcripts with contextual information.\nYour task is to analyze a given transcript and extract references to the context objects.\n\nThe context and transcript are provided in the user message in `context` and `transcript` XML tags.\n\nHere are your instructions:\n\n1. Read the transcript and context information provided above.\n\n2. Process each segment of the transcript separately.\n\n3. For each segment:\n   a. Analyze the content and identify relevant information from the context.\n   b. Extract a number of references to the context objects that are mentioned in the segment.\n   c. Output the references in the format `{ "quote": "earnings report", "id": "01JT0JP9AX0XKGZX4MV4B69VT6" }`.\n   d. If there are no references, just output an empty array.\n\n4. Maintain the exact order and structure of the original transcript segments.\n\nOutput Format:\nYou have been provided with a tool that specifies output format\n\nRemember:\n- Only quote the text that is in the transcript.\n- Analyze each segment carefully before processing it.\n- Only reference objects that appear in the context and exactly by their id, If the object is not in the context, do not insert a reference. \n\nNow, process the transcript and context provided below according to these instructions.';
+
+// src/extraction/quotes.ts
 import { Schema as Schema4 } from "effect";
 import { Query, Filter } from "@dxos/echo";
 import { ObjectId as ObjectId2 } from "@dxos/echo-schema";
 import { DXN } from "@dxos/keys";
 import { log as log3 } from "@dxos/log";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/assistant/src/extraction/quotes.ts";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/assistant/src/extraction/quotes.ts";
 var ReferencedQuotes = Schema4.Struct({
   references: Schema4.Array(Schema4.Struct({
     id: Schema4.String,
@@ -579,7 +491,7 @@ var insertReferences = (text, quotes) => {
   return text;
 };
 
-// packages/core/assistant/src/extraction/extraction-llm-function/extraction-llm-function.ts
+// src/extraction/extraction-llm-function/extraction-llm-function.ts
 var extractionAnthropicFn = defineFunction({
   description: "Extract entities from the transcript message and add them to the message.",
   inputSchema: ExtractionInput,
@@ -587,7 +499,7 @@ var extractionAnthropicFn = defineFunction({
   handler: async ({ data: { message, objects }, context }) => {
     const startTime = performance.now();
     const ai = context.getService(AiService);
-    const session = new AISession({
+    const session = new AiSession({
       operationModel: "configured"
     });
     const result = await session.runStructured(ReferencedQuotes, {
@@ -597,15 +509,18 @@ var extractionAnthropicFn = defineFunction({
       client: ai.client,
       systemPrompt: instructions_default,
       history: [
-        Obj2.make(Message2, {
-          role: "user",
-          content: [
+        Obj4.make(DataType4.Message, {
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          sender: {
+            role: "user"
+          },
+          blocks: [
             {
-              type: "text",
+              _tag: "text",
               text: `<context>${JSON.stringify(objects)}</context>`
             },
             {
-              type: "text",
+              _tag: "text",
               text: `<transcript>${JSON.stringify(message.blocks)}</transcript>`
             }
           ]
@@ -613,12 +528,13 @@ var extractionAnthropicFn = defineFunction({
       ],
       artifacts: [],
       prompt: "",
-      tools: []
+      tools: [],
+      toolResolver: new ToolRegistry([])
     });
     return {
-      message: create2(DataType2.Message, {
+      message: create(DataType4.Message, {
         ...message,
-        blocks: message.blocks.map((block, i) => block.type !== "transcription" ? block : {
+        blocks: message.blocks.map((block, i) => block._tag !== "transcript" ? block : {
           ...block,
           text: insertReferences(block.text, result)
         })
@@ -628,18 +544,18 @@ var extractionAnthropicFn = defineFunction({
   }
 });
 
-// packages/core/assistant/src/extraction/extraction-ner-function/extraction-ner-function.ts
+// src/extraction/extraction-ner-function/extraction-ner-function.ts
 import { asyncTimeout as asyncTimeout2 } from "@dxos/async";
-import { create as create3 } from "@dxos/echo-schema";
-import { DatabaseService, defineFunction as defineFunction2 } from "@dxos/functions";
-import { invariant as invariant2 } from "@dxos/invariant";
+import { create as create2 } from "@dxos/echo-schema";
+import { DatabaseService as DatabaseService3, defineFunction as defineFunction2 } from "@dxos/functions";
+import { invariant } from "@dxos/invariant";
 import { log as log5 } from "@dxos/log";
-import { DataType as DataType3 } from "@dxos/schema";
+import { DataType as DataType5 } from "@dxos/schema";
 
-// packages/core/assistant/src/extraction/extraction-ner-function/named-entity-recognition.ts
+// src/extraction/extraction-ner-function/named-entity-recognition.ts
 import { pipeline } from "@xenova/transformers";
 import { log as log4 } from "@dxos/log";
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/assistant/src/extraction/extraction-ner-function/named-entity-recognition.ts";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/assistant/src/extraction/extraction-ner-function/named-entity-recognition.ts";
 var _ner;
 var getNer = () => {
   if (!_ner) {
@@ -718,8 +634,8 @@ var combineNerTokens = (group) => {
   return combinedToken;
 };
 
-// packages/core/assistant/src/extraction/extraction-ner-function/extraction-ner-function.ts
-var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/assistant/src/extraction/extraction-ner-function/extraction-ner-function.ts";
+// src/extraction/extraction-ner-function/extraction-ner-function.ts
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/assistant/src/extraction/extraction-ner-function/extraction-ner-function.ts";
 var extractionNerFn = defineFunction2({
   description: "Extracts named entities from a text",
   inputSchema: ExtractionInput,
@@ -730,19 +646,19 @@ var extractionNerFn = defineFunction2({
       options
     }, {
       F: __dxlog_file5,
-      L: 22,
+      L: 25,
       S: void 0,
       C: (f, a) => f(...a)
     });
     const startTime = performance.now();
-    const { db } = context.getService(DatabaseService);
+    const { db } = context.getService(DatabaseService3);
     const entitiesPromise = Promise.all(message.blocks.map(async (block) => {
-      invariant2(block.type === "transcription" || block.type === "text", "Block must have text", {
+      invariant(block._tag === "transcript" || block._tag === "text", "Block must have text", {
         F: __dxlog_file5,
-        L: 28,
+        L: 31,
         S: void 0,
         A: [
-          "block.type === 'transcription' || block.type === 'text'",
+          "block._tag === 'transcript' || block._tag === 'text'",
           "'Block must have text'"
         ]
       });
@@ -753,27 +669,27 @@ var extractionNerFn = defineFunction2({
       entities
     }, {
       F: __dxlog_file5,
-      L: 33,
+      L: 36,
       S: void 0,
       C: (f, a) => f(...a)
     });
     const quoteReferences = await findQuotes(entities.map((entity) => entity.word), db);
     const blocksWithReferences = message.blocks.map((block, i) => {
-      invariant2(block.type === "transcription" || block.type === "text", "Block must have text", {
+      invariant(block._tag === "transcript" || block._tag === "text", "Block must have text", {
         F: __dxlog_file5,
-        L: 39,
+        L: 42,
         S: void 0,
         A: [
-          "block.type === 'transcription' || block.type === 'text'",
+          "block._tag === 'transcript' || block._tag === 'text'",
           "'Block must have text'"
         ]
       });
       return {
         ...block,
-        text: insertReferences(block.text, quoteReferences)
+        text: insertReferences(block._tag, quoteReferences)
       };
     });
-    const messageWithReferences = create3(DataType3.Message, {
+    const messageWithReferences = create2(DataType5.Message, {
       ...message,
       blocks: blocksWithReferences
     });
@@ -781,7 +697,7 @@ var extractionNerFn = defineFunction2({
       messageWithReferences
     }, {
       F: __dxlog_file5,
-      L: 47,
+      L: 50,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -792,13 +708,129 @@ var extractionNerFn = defineFunction2({
   }
 });
 
-// packages/core/assistant/src/research/exa.ts
-import { Schema as Schema5 } from "effect";
+// src/functions/services.ts
+import { AiTool } from "@effect/ai";
+import { Context as Context2, Effect as Effect3, Layer, Match, Predicate, Record, Schema as Schema5 } from "effect";
+import { AiToolNotFoundError, ToolExecutionService as ToolExecutionService2, ToolResolverService as ToolResolverService2 } from "@dxos/ai";
+import { todo as todo2 } from "@dxos/debug";
+import { FunctionError } from "@dxos/functions";
+import { invariant as invariant2 } from "@dxos/invariant";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/core/assistant/src/functions/services.ts";
+var makeToolResolverFromFunctions = (functions) => {
+  return Layer.succeed(ToolResolverService2, {
+    resolve: Effect3.fn("resolveTool")(function* (id) {
+      const fn = functions.find((f) => f.name === id);
+      if (!fn) {
+        return yield* Effect3.fail(new AiToolNotFoundError(id));
+      }
+      return projectFunctionToTool(fn);
+    })
+  });
+};
+var makeToolExecutionServiceFromFunctions = (functions) => {
+  return Layer.succeed(ToolExecutionService2, {
+    handlersFor: (toolkit) => {
+      const makeHandler = (tool) => {
+        return Effect3.fn("toolFunctionHandler")(function* (input) {
+          const { functionName } = Context2.get(FunctionToolAnnotation)(tool.annotations);
+          const fnDef = functions.find((f) => f.name === functionName);
+          if (!fnDef) {
+            return yield* Effect3.fail(new AiToolNotFoundError(tool.name));
+          }
+          return yield* invokeFunction(fnDef, input).pipe(Effect3.catchAllDefect((defect) => Effect3.fail(defect)));
+        });
+      };
+      return toolkit.of(Record.map(toolkit.tools, (tool, name) => makeHandler(tool)));
+    }
+  });
+};
+var FunctionToolAnnotation = class extends Context2.Tag("@dxos/assisatnt/FunctionToolAnnotation")() {
+};
+var toolCache = /* @__PURE__ */ new WeakMap();
+var projectFunctionToTool = (fn) => {
+  if (toolCache.has(fn)) {
+    return toolCache.get(fn);
+  }
+  const tool = AiTool.make(makeToolName(fn.name), {
+    description: fn.description,
+    parameters: createStructFieldsFromSchema(fn.inputSchema),
+    // TODO(dmaretskyi): Include output schema.
+    failure: Schema5.Any
+  }).annotate(FunctionToolAnnotation, {
+    functionName: fn.name
+  });
+  toolCache.set(fn, tool);
+  return tool;
+};
+var makeToolName = (name) => {
+  const toolName = name.replace(/[^a-zA-Z0-9]/g, "");
+  invariant2(toolName.match(/^[a-zA-Z_][a-zA-Z0-9-_]*$/), void 0, {
+    F: __dxlog_file6,
+    L: 80,
+    S: void 0,
+    A: [
+      "toolName.match(/^[a-zA-Z_][a-zA-Z0-9-_]*$/)",
+      ""
+    ]
+  });
+  return toolName;
+};
+var createStructFieldsFromSchema = (schema) => {
+  return Match.value(schema.ast).pipe(Match.when(Predicate.isTagged("TypeLiteral"), (ast) => {
+    return Object.fromEntries(ast.propertySignatures.map((prop) => [
+      prop.name,
+      Schema5.make(prop.type)
+    ]));
+  }), Match.orElseAbsurd);
+};
+var invokeFunction = (fnDef, input) => Effect3.gen(function* () {
+  const assertInput = fnDef.inputSchema.pipe(Schema5.asserts);
+  assertInput(input);
+  const context = {
+    getService: () => todo2(),
+    getSpace: async (_spaceId) => {
+      throw new Error("Not available. Use the database service instead.");
+    },
+    space: void 0,
+    get ai() {
+      throw new Error("Not available. Use the ai service instead.");
+    }
+  };
+  const data = yield* Effect3.gen(function* () {
+    const result = fnDef.handler({
+      context,
+      data: input
+    });
+    if (Effect3.isEffect(result)) {
+      return yield* result.pipe(Effect3.orDie);
+    } else if (typeof result === "object" && result !== null && "then" in result && typeof result.then === "function") {
+      return yield* Effect3.promise(() => result);
+    } else {
+      return result;
+    }
+  }).pipe(Effect3.orDie, Effect3.catchAllDefect((defect) => Effect3.die(new FunctionError("Error running function", {
+    context: {
+      name: fnDef.name
+    },
+    cause: defect
+  }))));
+  const assertOutput = fnDef.outputSchema?.pipe(Schema5.asserts);
+  assertOutput(data);
+  return data;
+}).pipe(Effect3.withSpan("invokeFunction", {
+  attributes: {
+    name: fnDef.name
+  }
+}));
+
+// src/research/exa.ts
+import { AiTool as AiTool2, AiToolkit as AiToolkit2 } from "@effect/ai";
+import { Effect as Effect4, Schema as Schema6 } from "effect";
 import Exa from "exa-js";
-import { createTool as createTool2, ToolResult as ToolResult2 } from "@dxos/ai";
+import { CredentialsService } from "@dxos/functions";
 import { log as log6 } from "@dxos/log";
 
-// packages/core/assistant/src/testing/exa-search-1748337321991.ts
+// src/testing/exa-search-1748337321991.ts
 var exa_search_1748337321991_default = {
   requestId: "324936368a74f4db978982172bc18a6c",
   autopromptString: "AI personal knowledge management tools projects 2024",
@@ -954,7 +986,7 @@ var exa_search_1748337321991_default = {
   }
 };
 
-// packages/core/assistant/src/testing/exa-search-1748337331526.ts
+// src/testing/exa-search-1748337331526.ts
 var exa_search_1748337331526_default = {
   requestId: "0dc12e344fa649884456960ca1a54954",
   autopromptString: "PKM software artificial intelligence integration open source projects",
@@ -1177,7 +1209,7 @@ npm run tauri dev
   }
 };
 
-// packages/core/assistant/src/testing/exa-search-1748337344119.ts
+// src/testing/exa-search-1748337344119.ts
 var exa_search_1748337344119_default = {
   requestId: "32df0c541f9883180b35e04caece4374",
   autopromptString: "open source AI knowledge management projects features comparison 2024",
@@ -1300,73 +1332,69 @@ var exa_search_1748337344119_default = {
   }
 };
 
-// packages/core/assistant/src/testing/index.ts
+// src/testing/index.ts
 var SEARCH_RESULTS = [
   exa_search_1748337321991_default,
   exa_search_1748337331526_default,
   exa_search_1748337344119_default
 ];
 
-// packages/core/assistant/src/research/exa.ts
-var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/assistant/src/research/exa.ts";
-var createExaTool = ({ apiKey }) => {
-  const exa = new Exa(apiKey);
-  return createTool2("search", {
-    name: "web_search",
-    description: "Search the web for information",
-    schema: Schema5.Struct({
-      query: Schema5.String.annotations({
-        description: "The query to search for"
-      })
-    }),
-    execute: async ({ query }) => {
-      const context = await exa.searchAndContents(query, {
-        type: "auto",
-        text: {
-          maxCharacters: 3e3
-        },
-        livecrawl: "always"
-      });
-      log6.info("exa search", {
-        query,
-        costDollars: context.costDollars
-      }, {
-        F: __dxlog_file6,
-        L: 35,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      return ToolResult2.Success(context);
-    }
-  });
-};
-var createMockExaTool = () => {
-  return createTool2("search", {
-    name: "web_search",
-    description: "Search the web for information",
-    schema: Schema5.Struct({
-      query: Schema5.String.annotations({
-        description: "The query to search for"
-      })
-    }),
-    execute: async ({ query }) => {
-      const result = SEARCH_RESULTS.reduce((closest, current) => {
-        if (!current.autopromptString) {
-          return closest;
-        }
-        if (!closest) {
-          return current;
-        }
-        const dist1 = levenshteinDistance(query, current.autopromptString);
-        const dist2 = levenshteinDistance(query, closest.autopromptString || "");
-        const weight1 = dist1 / Math.max(query.length, current.autopromptString.length);
-        const weight2 = dist2 / Math.max(query.length, closest.autopromptString?.length || 0);
-        return weight1 < weight2 ? current : closest;
-      }, null);
-      return ToolResult2.Success(result);
-    }
-  });
+// src/research/exa.ts
+var __dxlog_file7 = "/__w/dxos/dxos/packages/core/assistant/src/research/exa.ts";
+var ExaToolkit = class extends AiToolkit2.make(AiTool2.make("exa_search", {
+  description: "Search the web for information",
+  parameters: {
+    query: Schema6.String.annotations({
+      description: "The query to search for"
+    })
+  },
+  success: Schema6.Unknown,
+  failure: Schema6.Never
+}).addRequirement()) {
 };
+var LiveExaHandler = ExaToolkit.toLayer({
+  exa_search: Effect4.fn(function* ({ query }) {
+    const credential = yield* CredentialsService.getCredential({
+      service: "exa.ai"
+    });
+    const exa = new Exa(credential.apiKey);
+    const context = yield* Effect4.promise(async () => exa.searchAndContents(query, {
+      type: "auto",
+      text: {
+        maxCharacters: 3e3
+      },
+      livecrawl: "always"
+    }));
+    log6.info("exa search", {
+      query,
+      costDollars: context.costDollars
+    }, {
+      F: __dxlog_file7,
+      L: 40,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return context;
+  })
+});
+var MockExaHandler = ExaToolkit.toLayer({
+  exa_search: Effect4.fn(function* ({ query }) {
+    const result = SEARCH_RESULTS.reduce((closest, current) => {
+      if (!current.autopromptString) {
+        return closest;
+      }
+      if (!closest) {
+        return current;
+      }
+      const dist1 = levenshteinDistance(query, current.autopromptString);
+      const dist2 = levenshteinDistance(query, closest.autopromptString || "");
+      const weight1 = dist1 / Math.max(query.length, current.autopromptString.length);
+      const weight2 = dist2 / Math.max(query.length, closest.autopromptString?.length || 0);
+      return weight1 < weight2 ? current : closest;
+    }, null);
+    return result;
+  })
+});
 var levenshteinDistance = (str1, str2) => {
   const m = str1.length;
   const n = str2.length;
@@ -1385,28 +1413,29 @@ var levenshteinDistance = (str1, str2) => {
   return dp[m][n];
 };
 
-// packages/core/assistant/src/research/research.ts
-import { Schema as Schema7 } from "effect";
-import { AgentStatusReport as AgentStatusReport2, ConsolePrinter } from "@dxos/ai";
-import { create as create5 } from "@dxos/echo-schema";
-import { AiService as AiService2, CredentialsService, DatabaseService as DatabaseService2, defineFunction as defineFunction3, TracingService } from "@dxos/functions";
+// src/research/research.ts
+import { AiToolkit as AiToolkit4 } from "@effect/ai";
+import { Effect as Effect6, Layer as Layer2, Schema as Schema8 } from "effect";
+import { AiService as AiService2, ConsolePrinter } from "@dxos/ai";
+import { defineFunction as defineFunction3, TracingService } from "@dxos/functions";
 import { log as log8 } from "@dxos/log";
 import { DataTypes } from "@dxos/schema";
 
-// packages/core/assistant/src/research/graph.ts
-import { Schema as Schema6, identity, Option as Option2, SchemaAST } from "effect";
-import { createTool as createTool3, ToolResult as ToolResult3 } from "@dxos/ai";
-import { Query as Query2, Filter as Filter2 } from "@dxos/echo";
+// src/research/graph.ts
+import { AiTool as AiTool3, AiToolkit as AiToolkit3 } from "@effect/ai";
+import { Context as Context3, Effect as Effect5, identity, Option as Option2, Schema as Schema7, SchemaAST } from "effect";
+import { Filter as Filter2, Query as Query2 } from "@dxos/echo";
 import { isEncodedReference } from "@dxos/echo-protocol";
-import { EntityKind, getSchemaTypename, getTypeAnnotation, getTypeIdentifierAnnotation, create as create4, getEntityKind, getSchemaDXN, ObjectId as ObjectId3, ReferenceAnnotationId, RelationSourceDXNId, RelationTargetDXNId, RelationSourceId, RelationTargetId } from "@dxos/echo-schema";
+import { create as create3, EntityKind, getEntityKind, getSchemaDXN, getSchemaTypename, getTypeAnnotation, getTypeIdentifierAnnotation, ObjectId as ObjectId3, ReferenceAnnotationId, RelationSourceDXNId, RelationSourceId, RelationTargetDXNId, RelationTargetId } from "@dxos/echo-schema";
 import { mapAst } from "@dxos/effect";
+import { ContextQueueService, DatabaseService as DatabaseService4 } from "@dxos/functions";
 import { DXN as DXN2 } from "@dxos/keys";
 import { log as log7 } from "@dxos/log";
 import { deepMapValues, isNonNullable } from "@dxos/util";
-var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/assistant/src/research/graph.ts";
-var Subgraph = Schema6.Struct({
+var __dxlog_file8 = "/__w/dxos/dxos/packages/core/assistant/src/research/graph.ts";
+var Subgraph = Schema7.Struct({
   /** Objects and relations. */
-  objects: Schema6.Array(Schema6.Any)
+  objects: Schema7.Array(Schema7.Any)
 });
 var findRelatedSchema = async (db, anchor) => {
   const allSchemas = [
@@ -1432,39 +1461,65 @@ var isSchemaAddressableByDxn = (schema, dxn) => {
   }
   return false;
 };
-var createLocalSearchTool = (db, queue) => {
-  return createTool3("search", {
-    name: "local_search",
-    description: "Search the local database for information using a vector index",
-    schema: Schema6.Struct({
-      query: Schema6.String.annotations({
-        description: "The query to search for. Could be a question or a topic or a set of keywords."
-      })
-    }),
-    execute: async ({ query }) => {
-      const { objects } = await db.query(Query2.select(Filter2.text(query, {
-        type: "vector"
-      }))).run();
-      const results = [
-        ...objects
-      ];
-      if (queue) {
-        const queueObjects = await queue.queryObjects();
-        results.push(...queueObjects);
-      }
-      return ToolResult3.Success(`
-        <local_context>
-          ${JSON.stringify(results, null, 2)}
-        </local_context>
-        `);
+var LocalSearchToolkit = class extends AiToolkit3.make(AiTool3.make("search_local_search", {
+  description: "Search the local database for information using a vector index",
+  parameters: {
+    query: Schema7.String.annotations({
+      description: "The query to search for. Could be a question or a topic or a set of keywords."
+    })
+  },
+  success: Schema7.Unknown,
+  failure: Schema7.Never
+}).addRequirement()) {
+};
+var LocalSearchHandler = LocalSearchToolkit.toLayer({
+  search_local_search: Effect5.fn(function* ({ query }) {
+    const { objects } = yield* DatabaseService4.runQuery(Query2.select(Filter2.text(query, {
+      type: "vector"
+    })));
+    const results = [
+      ...objects
+    ];
+    const contextQueue = yield* Effect5.serviceOption(ContextQueueService);
+    if (Option2.isSome(contextQueue)) {
+      const queueObjects = yield* Effect5.promise(() => contextQueue.value.contextQueue.queryObjects());
+      results.push(...queueObjects);
     }
+    return `
+      <local_context>
+        ${JSON.stringify(results, null, 2)}
+      </local_context>
+      `;
+  })
+});
+var GraphWriterSchema = class extends Context3.Tag("GraphWriterSchema")() {
+};
+var makeGraphWriterToolkit = ({ schema }) => {
+  return AiToolkit3.make(AiTool3.make("graph_writer", {
+    description: "Write to the local graph database",
+    parameters: createExtractionSchema(schema).fields,
+    success: Schema7.Unknown,
+    failure: Schema7.Never
+  }).addRequirement().annotateContext(Context3.make(GraphWriterSchema, {
+    schema
+  })));
+};
+var makeGraphWriterHandler = (toolkit) => {
+  const { schema } = Context3.get(toolkit.tools.graph_writer.annotations, GraphWriterSchema);
+  return toolkit.toLayer({
+    graph_writer: Effect5.fn(function* (input) {
+      const { db } = yield* DatabaseService4;
+      const contextQueue = yield* Effect5.serviceOption(ContextQueueService);
+      const data = yield* Effect5.promise(() => sanitizeObjects(schema, input, db, contextQueue.pipe(Option2.getOrUndefined)?.contextQueue));
+      return data;
+    })
   });
 };
 var createExtractionSchema = (types) => {
-  return Schema6.Struct({
+  return Schema7.Struct({
     ...Object.fromEntries(types.map(preprocessSchema).map((schema, index) => [
       `objects_${getSanitizedSchemaName(types[index])}`,
-      Schema6.optional(Schema6.Array(schema)).annotations({
+      Schema7.optional(Schema7.Array(schema)).annotations({
         description: `The objects of type: ${getSchemaDXN(types[index])?.asTypeDXN().type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option2.getOrElse(() => ""))}`
       })
     ]))
@@ -1522,8 +1577,8 @@ var sanitizeObjects = async (types, data, db, queue) => {
         log7.warn("source not found", {
           source: data2.source
         }, {
-          F: __dxlog_file7,
-          L: 214,
+          F: __dxlog_file8,
+          L: 262,
           S: void 0,
           C: (f, a) => f(...a)
         });
@@ -1533,8 +1588,8 @@ var sanitizeObjects = async (types, data, db, queue) => {
         log7.warn("target not found", {
           target: data2.target
         }, {
-          F: __dxlog_file7,
-          L: 218,
+          F: __dxlog_file8,
+          L: 266,
           S: void 0,
           C: (f, a) => f(...a)
         });
@@ -1562,8 +1617,8 @@ var sanitizeObjects = async (types, data, db, queue) => {
     queueObjects,
     existingIds
   }, {
-    F: __dxlog_file7,
-    L: 239,
+    F: __dxlog_file8,
+    L: 287,
     S: void 0,
     C: (f, a) => f(...a)
   });
@@ -1594,7 +1649,7 @@ var sanitizeObjects = async (types, data, db, queue) => {
       }
     }
     if (!skip) {
-      const obj = create4(schema, data2);
+      const obj = create3(schema, data2);
       enitties.set(obj.id, obj);
       return [
         obj
@@ -1603,543 +1658,159 @@ var sanitizeObjects = async (types, data, db, queue) => {
     return [];
   });
 };
-var SoftRef = Schema6.Struct({
-  "/": Schema6.String
+var SoftRef = Schema7.Struct({
+  "/": Schema7.String
 }).annotations({
   description: "Reference to another object."
 });
 var preprocessSchema = (schema) => {
   const isRelationSchema = getEntityKind(schema) === "relation";
-  const go = (ast) => {
+  const go = (ast, visited = /* @__PURE__ */ new Set()) => {
+    if (visited.has(ast)) {
+      return ast;
+    }
+    visited.add(ast);
     if (SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option2.isSome)) {
       return SoftRef.ast;
     }
-    return mapAst(ast, go);
+    return mapAst(ast, (child) => go(child, visited));
   };
-  return Schema6.make(mapAst(schema.ast, go)).pipe(Schema6.omit("id"), Schema6.extend(Schema6.Struct({
-    id: Schema6.String.annotations({
+  return Schema7.make(mapAst(schema.ast, (ast) => go(ast))).pipe(Schema7.omit("id"), Schema7.extend(Schema7.Struct({
+    id: Schema7.String.annotations({
       description: "The id of this object. Come up with a unique id based on your judgement."
     })
-  })), isRelationSchema ? Schema6.extend(Schema6.Struct({
-    source: Schema6.String.annotations({
+  })), isRelationSchema ? Schema7.extend(Schema7.Struct({
+    source: Schema7.String.annotations({
       description: "The id of the source object for this relation."
     }),
-    target: Schema6.String.annotations({
+    target: Schema7.String.annotations({
       description: "The id of the target object for this relation."
     })
   })) : identity);
 };
-var createGraphWriterTool = ({ db, queue, schema, onDone = async (x) => x }) => {
-  return createTool3("graph", {
-    name: "writer",
-    description: "Write to the local graph database",
-    schema: createExtractionSchema(schema),
-    execute: async (input) => {
-      const data = await sanitizeObjects(schema, input, db, queue);
-      return ToolResult3.Success(await onDone(data));
-    }
-  });
-};
 
 // raw-loader:./instructions-research.tpl?raw
-var instructions_research_default = "You are the Research Agent.\n\nThe Research Agent is an expert assistant that conducts in-depth research using real-time web search.\nThe Research Agent outputs results in a structured format matching the schema provided.\n\nThe Research Agent is equipped with the ability to:\n\n- Generate precise and effective search queries \n- Request web pages by query (through a `web_search` tool)\n- Read the full content of retrieved pages\n- Synthesize accurate, clear, and structured answers using reliable information from the retrieved content\n- Search the local database for information using a vector index (through a `local_search` tool)\n\nThe Research Agent always follows these principles:\n\n- Relevance First: The Research Agent only returns facts supported by content in retrieved web pages. The Research Agent never fabricates or guesses information.\n- Summarize, Don't Copy: The Research Agent synthesizes and rephrases content in its own words. The Research Agent quotes only when necessary.\n- Multiple Sources: The Research Agent cross-references at least 2 sources before drawing conclusions, unless the information is directly stated and non-controversial.\n- Transparency: The Research Agent mentions which sources were used and explains how it arrived at conclusions.\n- Accuracy Over Brevity: The Research Agent prefers detailed, technically accurate explanations over shallow summaries.\n- The Research Agent admits uncertainty rather than misleading.\n- The Research Agent picks the most concrete schema types for extracted information.\n- The Research Agent fills schema fields completely with information it is confident about, and omits fields it is not confident about.\n- When outputting results, the Research Agent adds extra data that fits the schema even if not directly related to the user's question.\n- The Research Agent creates relations and references between new objects found and what's already in the database.\n- The Research Agent does not create objects that are already in the database.\n- The Research Agent re-uses existing object IDs as references when enriching existing objects.\n\nThe Research Agent may be asked for:\n\n- Technical explanations\n- Literature reviews  \n- Comparisons\n- Emerging trends\n- Implementation strategies\n\nThe Research Agent begins by interpreting the user's request, then:\n\nThe Research Agent breaks it into sub-questions (if applicable).\n\nFor each sub-question, the Research Agent generates a clear, concise web search query.\n\nThe Research Agent uses `web_search`(query) to retrieve information.\n\nThe Research Agent extracts and synthesizes relevant answers.\n\nThe Research Agent's output includes:\n\n- A clear, structured answer to the user's question\n- A citation list or link list of sources used\n\nOptionally, the Research Agent provides follow-up suggestions or questions for deeper inquiry.\n\nHere's how the Research Agent operates:\n\n1. The Research Agent analyzes the user's request and identifies key topics to search for (3 or more), printing them out.\n2. The Research Agent performs a web search for each topic.\n3. The Research Agent reads and analyzes results, cross references information from multiple sources, and represents conflicting information as ranges of possible values.\n\n4. The Research Agent searches the local database for information using a vector index that might link to the user's question.\n6. The Research Agent creates relations and references between new objects and existing database objects when related, using existing object IDs as references.\n7. The Research Agent selects the most concrete schema types for extracted information, using multiple types as needed, and prints its decision and reasoning.\n5. The Research Agent creates a clear, structured answer to the user's question.\n8. The Research Agent submits results using the specific schema.\n\nIMPORTANT:\n\n- The Research Agent always runs the `local_search` tool to search the local database at least once before submitting results.\n- The Research Agent does not create objects that already exist in the database.\n- Ids that are not in the database are human-readable strings like `ivan_zhao_1`.\n\nStatus reporting:\n\nThe Research Agent reports its status frequently using the `<status>` tags: <status>Searching for Google Founders</status>\nThe Research Agent reports its status in-between each tool call and before submitting results.\n\n<example>\n\nBased on my research, I can now provide information about Google and it's founders.\n\nThe following objects are already in the database, I will not submit them again, but I'll re-use their IDs as references:\n\n- 01JWRDEHPB5TT2JQQQC15038BT Google\n- 01JWRDEHPA14CYW2NW9FAH6DJJ Larry Page\n- 01JWRDEHPBN0BBJP57B9S108W6 Sergey Brin\n\nI will use the following schema to construct new objects:\n\n- type:dxos.org/type/Organization for Alphabet Inc.\n- type:dxos.org/type/Person for Ivan Zhao\n- type:dxos.org/type/Person for Simon Last\n- dxn:type:dxos.org/relation/Employer for Ivan's employer\n- dxn:type:dxos.org/relation/Employer for Simon's employer\n\n<status>Formatting results</status>\n\n</example>";
+var instructions_research_default = "You are the Research Agent.\n\nThe Research Agent is an expert assistant that conducts in-depth research using real-time web search.\nThe Research Agent outputs results in a structured format matching the schema provided.\n\nThe Research Agent is equipped with the ability to:\n\n- Generate precise and effective search queries \n- Request web pages by query (through a `web_search` tool)\n- Read the full content of retrieved pages\n- Synthesize accurate, clear, and structured answers using reliable information from the retrieved content\n- Search the local database for information using a vector index (through a `local_search` tool)\n\nThe Research Agent always follows these principles:\n\n- Relevance First: The Research Agent only returns facts supported by content in retrieved web pages. The Research Agent never fabricates or guesses information.\n- Summarize, Don't Copy: The Research Agent synthesizes and rephrases content in its own words. The Research Agent quotes only when necessary.\n- Multiple Sources: The Research Agent cross-references at least 2 sources before drawing conclusions, unless the information is directly stated and non-controversial.\n- Transparency: The Research Agent mentions which sources were used and explains how it arrived at conclusions.\n- Accuracy Over Brevity: The Research Agent prefers detailed, technically accurate explanations over shallow summaries.\n- The Research Agent admits uncertainty rather than misleading.\n- The Research Agent picks the most concrete schema types for extracted information.\n- The Research Agent fills schema fields completely with information it is confident about, and omits fields it is not confident about.\n- When outputting results, the Research Agent adds extra data that fits the schema even if not directly related to the user's question.\n- The Research Agent creates relations and references between new objects found and what's already in the database.\n- The Research Agent does not create objects that are already in the database.\n- The Research Agent re-uses existing object IDs as references when enriching existing objects.\n- The Research Agent ALWAYS calls the `graph_writer` at the end to save the data. This conversation will be delted, so only the data written to the graph will be preserved.\n\nThe Research Agent may be asked for:\n\n- Technical explanations\n- Literature reviews  \n- Comparisons\n- Emerging trends\n- Implementation strategies\n\nThe Research Agent begins by interpreting the user's request, then:\n\nThe Research Agent breaks it into sub-questions (if applicable).\n\nFor each sub-question, the Research Agent generates a clear, concise web search query.\n\nThe Research Agent uses `web_search`(query) to retrieve information.\n\nThe Research Agent extracts and synthesizes relevant answers.\n\nThe Research Agent's output includes:\n\n- A clear, structured answer to the user's question\n- A citation list or link list of sources used\n\nOptionally, the Research Agent provides follow-up suggestions or questions for deeper inquiry.\n\nHere's how the Research Agent operates:\n\n1. The Research Agent analyzes the user's request and identifies key topics to search for (3 or more), printing them out.\n2. The Research Agent performs a web search for each topic.\n3. The Research Agent reads and analyzes results, cross references information from multiple sources, and represents conflicting information as ranges of possible values.\n\n4. The Research Agent searches the local database for information using a vector index that might link to the user's question.\n6. The Research Agent creates relations and references between new objects and existing database objects when related, using existing object IDs as references.\n7. The Research Agent selects the most concrete schema types for extracted information, using multiple types as needed, and prints its decision and reasoning.\n5. The Research Agent creates a clear, structured answer to the user's question.\n8. The Research Agent submits results using the specific schema.\n\nIMPORTANT:\n\n- The Research Agent always runs the `local_search` tool to search the local database at least once before submitting results.\n- The Research Agent does not create objects that already exist in the database.\n- Ids that are not in the database are human-readable strings like `ivan_zhao_1`.\n\nStatus reporting:\n\nThe Research Agent reports its status frequently using the `<status>` tags: <status>Searching for Google Founders</status>\nThe Research Agent reports its status in-between each tool call and before submitting results.\n\n<example>\n\nBased on my research, I can now provide information about Google and it's founders.\n\nThe following objects are already in the database, I will not submit them again, but I'll re-use their IDs as references:\n\n- 01JWRDEHPB5TT2JQQQC15038BT Google\n- 01JWRDEHPA14CYW2NW9FAH6DJJ Larry Page\n- 01JWRDEHPBN0BBJP57B9S108W6 Sergey Brin\n\nI will use the following schema to construct new objects:\n\n- type:dxos.org/type/Organization for Alphabet Inc.\n- type:dxos.org/type/Person for Ivan Zhao\n- type:dxos.org/type/Person for Simon Last\n- dxn:type:dxos.org/relation/Employer for Ivan's employer\n- dxn:type:dxos.org/relation/Employer for Simon's employer\n\n<status>Formatting results</status>\n\n</example>";
 
-// packages/core/assistant/src/research/research.ts
-var __dxlog_file8 = "/home/runner/work/dxos/dxos/packages/core/assistant/src/research/research.ts";
+// src/research/research.ts
+var __dxlog_file9 = "/__w/dxos/dxos/packages/core/assistant/src/research/research.ts";
 var researchFn = defineFunction3({
   description: "Research the web for information",
-  inputSchema: Schema7.Struct({
-    query: Schema7.String.annotations({
+  inputSchema: Schema8.Struct({
+    query: Schema8.String.annotations({
       description: "The query to search for."
     }),
     // TOOD(burdon): Move to context.
-    mockSearch: Schema7.optional(Schema7.Boolean).annotations({
+    mockSearch: Schema8.optional(Schema8.Boolean).annotations({
       description: "Whether to use the mock search tool.",
       default: false
     })
   }),
-  outputSchema: Schema7.Struct({
-    // result: Schema.String,
-    result: Schema7.Any
+  outputSchema: Schema8.Struct({
+    result: Schema8.Unknown
   }),
-  handler: async ({ data: { query, mockSearch }, context }) => {
-    const ai = context.getService(AiService2);
-    const credentials = context.getService(CredentialsService);
-    const { db } = context.getService(DatabaseService2);
-    const tracing = context.getService(TracingService);
-    tracing.write(create5(AgentStatusReport2, {
+  handler: Effect6.fnUntraced(function* ({ data: { query, mockSearch } }) {
+    yield* TracingService.emitStatus({
       message: "Researching..."
-    }));
-    const exaCredential = await credentials.getCredential({
-      service: "exa.ai"
     });
-    const searchTool = mockSearch ? createMockExaTool() : createExaTool({
-      apiKey: exaCredential.apiKey
+    const graphWriteToolkit = makeGraphWriterToolkit({
+      schema: DataTypes
     });
+    const toolkit = yield* AiToolkit4.merge(ExaToolkit, LocalSearchToolkit, graphWriteToolkit).pipe(Effect6.provide(Layer2.mergeAll(mockSearch ? MockExaHandler : LiveExaHandler, LocalSearchHandler, makeGraphWriterHandler(graphWriteToolkit))));
     const printer = new ConsolePrinter();
-    const session = new AISession({
-      operationModel: "configured"
-    });
+    const session = new AiSession();
     session.message.on((message) => printer.printMessage(message));
     session.userMessage.on((message) => printer.printMessage(message));
     session.block.on((block) => printer.printContentBlock(block));
-    session.statusReport.on((status) => {
-      log8.info("[agent] status", {
-        status
-      }, {
-        F: __dxlog_file8,
-        L: 58,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      tracing.write(status);
-    });
     session.streamEvent.on((event) => log8("stream", {
       event
     }, {
-      F: __dxlog_file8,
-      L: 61,
-      S: void 0,
+      F: __dxlog_file9,
+      L: 62,
+      S: this,
       C: (f, a) => f(...a)
     }));
-    const graphWriteTool = createGraphWriterTool({
-      db,
-      schema: DataTypes
-    });
-    log8.info("graphWriteTool", {
-      schema: graphWriteTool.parameters
-    }, {
-      F: __dxlog_file8,
-      L: 64,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    const result = await session.run({
-      client: ai.client,
-      systemPrompt: instructions_research_default,
-      artifacts: [],
-      tools: [
-        searchTool,
-        graphWriteTool
-      ],
+    const result = yield* session.run({
+      prompt: query,
       history: [],
-      prompt: query
+      systemPrompt: instructions_research_default,
+      toolkit
     });
     return {
       result
     };
-  }
+  }, Effect6.provide(AiService2.model("@anthropic/claude-3-5-sonnet-20241022")))
 });
 
-// packages/core/assistant/src/types.ts
-var createArtifactElement = (id) => `<artifact id=${id} />`;
+// src/templates/prompt.ts
+import { Template } from "@dxos/blueprints";
 
-// packages/core/assistant/src/blueprint/blueprint.ts
-import { Schema as Schema8 } from "effect";
-import { Key, Obj as Obj3, Type } from "@dxos/echo";
-var BlueprintStep = Schema8.Struct({
-  id: Key.ObjectId,
-  instructions: Schema8.String,
-  tools: Schema8.optional(Schema8.Array(Schema8.String))
-});
-var BlueprintDefinition = Schema8.Struct({
-  steps: Schema8.Array(BlueprintStep.pipe(Schema8.omit("id")))
-});
-var Blueprint = Schema8.Struct({
-  name: Schema8.optional(Schema8.String),
-  steps: Schema8.Array(BlueprintStep)
-}).pipe(Type.Obj({
-  typename: "dxos.org/type/Blueprint",
-  version: "0.1.0"
-}));
-(function(BlueprintBuilder2) {
-  BlueprintBuilder2.create = () => new Builder();
-  class Builder {
-    constructor() {
-      this._steps = [];
-    }
-    step(instructions, options) {
-      this._steps.push({
-        id: Key.ObjectId.random(),
-        instructions,
-        tools: options?.tools ?? []
-      });
-      return this;
-    }
-    build() {
-      return Obj3.make(Blueprint, {
-        steps: this._steps
-      });
-    }
-  }
-})(BlueprintBuilder || (BlueprintBuilder = {}));
-(function(BlueprintParser2) {
-  BlueprintParser2.create = () => new Parser();
-  class Parser {
-    parse({ steps }) {
-      const builder = BlueprintBuilder.create();
-      for (const step of steps) {
-        builder.step(step.instructions, {
-          tools: step.tools ?? []
-        });
-      }
-      return builder.build();
-    }
-  }
-})(BlueprintParser || (BlueprintParser = {}));
-var BlueprintBuilder;
-var BlueprintParser;
+// raw-loader:./assistant.tpl?raw
+var assistant_default = "{{! System Prompt }}\n\nYou are a friendly, advanced AI assistant capable of creating and managing artifacts from available data and tools.\nYour task is to process user commands and questions and decide how best to respond.\nIn some cases, you will need to create or reference data objects called artifacts.\n\nFollow these guidelines carefully:\n\n{{section}}. Decision-making:\n\n{{#if cot}}\nBefore responding, explain your reasoning and include your detailed chain-of-thought in a <cot> tag.\n{{/if}}\n\nInclude the following steps:\n\n- Analyze the structure and type of the content in the user's message.\n- Can you complete the task using the available artifact definitions?\n- If you can't complete the task using the available artifact definitions, query the list of available artifact definitions using the appropriate tool.\n- Identify which artifact definitions are relevant to the user's request.\n- Evaluate the potential benefits of creating an artifact vs. normal processing for each identified element.\n- Make a final decision on whether to create an artifact and explain your reasoning.\n- Are the required artifact definitions already available?\n- If not, select which artifact definition(s) will be the most relevant and require them using the require_artifact_definitions tool.\n- The require'd artifact tools will be available for use after require.\n- If creating an artifact, outline how you will structure it within the response.\n- Decide if the artifact needs to be shown to the user.\n- Call the show tool to show the artifact to the user.\n- If you ask the user a multiple choice question, then present each of the possible answers as concise text inside <option> tags inside a well formed <select> tag.\n- If you have suggestions for follow-up actions then present each action as text within a <suggest> tag.\n- Your reasoning must include: whether to use artifacts or not, to create one or query, whether to show the artifact to the user, and how to structure the response.\n\nIf the user asks for a list of tools, then just emit a single self-closing <tool-list/> tag instead of listing the tools.The tag will be replaced with the list of tools when the response is rendered.\nDo not list the tools or artifacts in your response, only emit the tag.\nDo not mention the tag anywhere else in your response unless you are rendering a tool list.\n\n{{section}}. Artifacts:\n\n- Determine if the interaction involves an artifact. Prefer artifacts for tables, lists, spreadsheets, kanbans, games, images, and other structured data.\n- Determine if the user is explicitly talking about creating a new artifact, or wants to use an existing artifact.\n- If it is ambiguous, query for existing artifacts first and then decide.\n- If you decide to create an artifact, call the associated tool to create the artifact.\n- Artifacts are stored in the database. Tools are used to create and query artifacts.\n- If you are unsure about creating an artifact ask the user for clarification.\n\n{{#if artifacts}}\n{{section}}. Artifact Rules:\n\n- Artifacts are mutable objects that can change over the course of the conversation.\n- Always re-query the artifact using the tool (like query or inspect) to get the latest state of the artifact before answering the user.\n- You must never generate the id of the artifact; only recall the ids that are already in the history.\n- Artifacts are created by requiring the specific artifact using the require_artifact tool and creating it by calling the associated tool.\n\n{{section}}. Artifact Providers:\n\n{{#each artifacts}}\n- {{this}}\n{{/each}}\n{{/if}}\n\n{{#if associatedArtifact}}\n{{section}}. Associated artifact:\n\nThe following ID and typename identify the artifact associated with this conversation.\nThis conversation appears alongside the associated artifact as a peer, and the user is likely to make reference to and requests about it.\nYou can interact with this artifact using tools.\n\nID: {{associatedArtifact.id}}\nTypename: {{associatedArtifact.typename}}\n{{/if}}\n\n{{#if suggestions}}\n{{section}}. Suggested actions:\n\n- You can add suggested actions at the end of your response.\n- Suggested actions should be very concise and start with a verb and be phrased as a command to an agent -- not a question to the user.\n- Suggested actions must be in the form of a user instruction that you can follow.\n- Suggested actions could include actions that create artifacts.\n- Suggested actions must be enclosed in a <suggest> tag and on a separate line.\n  Examples:\n  <suggest>Show the data on a map.</suggest>\n  <suggest>Create a kanban from the table.</suggest>\n\n- If you have asked a multiple choice question, then present each of the possible answers as concise text inside <option> tags inside a well formed <select> tag.\n  Example:\n  <select><option>Yes</option><option>No</option></select>\n{{/if}}\n\n{{section}}. Content proposals:\n\nYou can propose content to add to associated artifacts. Enclose the content you are proposing to add in a <proposal> tag on a separate line.\nFor example:\n<proposal>Apples add a delightful crunch and natural sweetness to salads</proposal>\n\n{{section}}. Output Formats:\n\nIt is very important to respond in the correct format.\n\n{{#if cot}}\n- Your detailed chain-of-thought must be in the form of a markdown list enclosed in <cot> tags.\n- The <cot> tag should be the first thing in your response.\n{{/if}}\n- Suggested actions must be enclosed in a <suggest> tag and on a separate line.\n- Content proposals must be enclosed in a <proposal> tag and on a separate line.\n\nReferences:\n\n- Both user and you can reference external data in the markdown format: [label][URI].\n- If you get references back from a tool call, you can render them as is by preserving the ID literally.\n\n{{instructions}}";
 
-// packages/core/assistant/src/blueprint/machine.ts
-import { Match, Schema as Schema9 } from "effect";
-import { createTool as createTool4, Message as Message3, ToolResult as ToolResult4 } from "@dxos/ai";
-import { Event as Event2 } from "@dxos/async";
-import { Key as Key2, Obj as Obj4 } from "@dxos/echo";
-import { log as log9 } from "@dxos/log";
-import { isNonNullable as isNonNullable2 } from "@dxos/util";
-var __dxlog_file9 = "/home/runner/work/dxos/dxos/packages/core/assistant/src/blueprint/machine.ts";
-var SYSTEM_PROMPT = `
-You are a smart Rule-Following Agent.
-Rule-Following Agent executes the command that the user sent in the last message.
-After doing the work, the Rule-Following Agent calls report tool.
-If the Rule-Following agent believes that no action is needed, it calls the report tool with "skipped" status.
-If the Rule-Following Agent is unable to perform the task, it calls the report tool with "bail" status.
-Rule-Following Agent explains the reason it is unable to perform the task before bailing.
-The Rule-Following Agent can express creativity and imagination in the way it performs the task.
-The Rule-Following Agent precisely follows the instructions.
-`;
-var INITIAL_STATE = {
-  state: "working",
-  history: [],
-  trace: []
-};
-var BlueprintMachine = class {
-  constructor(registry, blueprint) {
-    this.registry = registry;
-    this.blueprint = blueprint;
-    this.begin = new Event2();
-    this.end = new Event2();
-    this.stepStart = new Event2();
-    this.stepComplete = new Event2();
-    this.message = new Event2();
-    this.block = new Event2();
-    this._state = structuredClone(INITIAL_STATE);
-  }
-  get state() {
-    return this._state;
-  }
-  setLogger(logger) {
-    this.logger = logger;
-    return this;
-  }
-  async runToCompletion(options) {
-    const invocationId = Key2.ObjectId.random();
-    log9.info("runToCompletion", {
-      invocationId,
-      options
-    }, {
-      F: __dxlog_file9,
-      L: 107,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this.begin.emit();
-    this.logger?.log({
-      type: "begin",
-      invocationId
-    });
-    let firstStep = true;
-    while (this._state.state !== "done") {
-      const input = firstStep ? options.input : void 0;
-      firstStep = false;
-      this._state = await this._execStep(invocationId, this._state, {
-        input,
-        aiClient: options.aiClient
-      });
-      const step = this.blueprint.steps.find((step2) => step2.id === this._state.trace.at(-1)?.stepId);
-      this.stepComplete.emit(step);
-      this.logger?.log({
-        type: "step-complete",
-        invocationId,
-        step
-      });
-      if (this._state.state === "bail") {
-        throw new Error("Agent unable to follow the blueprint");
-      }
-    }
-    this.end.emit();
-    this.logger?.log({
-      type: "end",
-      invocationId
-    });
-  }
-  async _execStep(invocationId, state, options) {
-    const prevStep = this.blueprint.steps.findIndex((step) => step.id === this._state.trace.at(-1)?.stepId);
-    if (prevStep === this.blueprint.steps.length - 1) {
-      throw new Error("Done execution blueprint");
-    }
-    const nextStep = this.blueprint.steps[prevStep + 1];
-    const onLastStep = prevStep === this.blueprint.steps.length - 2;
-    this.stepStart.emit(nextStep);
-    this.logger?.log({
-      type: "step-start",
-      invocationId,
-      step: nextStep
-    });
-    const ReportSchema = Schema9.Struct({
-      status: Schema9.Literal("done", "bailed", "skipped").annotations({
-        description: "The status of the task completion"
-      }),
-      comment: Schema9.String.annotations({
-        description: "A comment about the task completion. If you bailed, you must explain why in detail (min couple of sentences)."
-      })
-    });
-    const report = createTool4("system", {
-      name: "report",
-      description: "This tool reports that the agent has completed the task or is unable to do so.",
-      schema: ReportSchema,
-      execute: async (input) => ToolResult4.Break(input)
-    });
-    const session = new AISession({
-      operationModel: "configured"
-    });
-    session.userMessage.pipeInto(this.message);
-    session.message.pipeInto(this.message);
-    session.block.pipeInto(this.block);
-    const inputMessages = options.input ? [
-      Obj4.make(Message3, {
-        role: "user",
-        content: [
-          taggedDataBlock("input", options.input)
-        ]
-      })
-    ] : [];
-    inputMessages.forEach((message) => {
-      this.message.emit(message);
-      this.logger?.log({
-        type: "message",
-        invocationId,
-        message
-      });
-    });
-    const tools = nextStep.tools?.map((tool) => this.registry.get(tool)).filter(isNonNullable2) ?? [];
-    const messages = await session.run({
-      systemPrompt: SYSTEM_PROMPT,
-      history: [
-        ...state.history,
-        ...inputMessages
-      ],
-      tools: [
-        ...tools,
-        report
-      ],
-      artifacts: [],
-      client: options.aiClient,
-      prompt: nextStep.instructions
-    });
-    const { messages: trimmedHistory, call: lastBlock } = popLastToolCall(messages);
-    if (!lastBlock) {
-      throw new Error("Agent did not call the report tool");
-    }
-    const { status, comment } = ReportSchema.pipe(Schema9.decodeUnknownSync)(lastBlock.input);
-    return {
-      history: [
-        ...state.history,
-        ...inputMessages,
-        ...trimmedHistory
-      ],
-      trace: [
-        ...state.trace,
-        {
-          stepId: nextStep.id,
-          status,
-          comment
-        }
-      ],
-      state: Match.value(status).pipe(Match.withReturnType(), Match.when("done", () => onLastStep ? "done" : "working"), Match.when("skipped", () => onLastStep ? "done" : "working"), Match.when("bailed", () => "bail"), Match.exhaustive)
-    };
-  }
-};
-var taggedDataBlock = (tag, data) => {
-  return {
-    type: "text",
-    text: `<${tag}>
-${JSON.stringify(data, null, 2)}
-</${tag}>`
-  };
-};
-var popLastToolCall = (messages) => {
-  const lastBlock = messages.at(-1)?.content.at(-1);
-  if (lastBlock?.type !== "tool_use") {
-    return {
-      messages
-    };
-  }
-  const trimmedHistory = [
-    ...messages.slice(0, -1),
-    {
-      ...messages.at(-1),
-      content: [
-        ...messages.at(-1).content.slice(0, -1)
-      ]
-    }
-  ];
-  return {
-    messages: trimmedHistory,
-    call: lastBlock
-  };
+// src/templates/prompt.ts
+var createSystemPrompt = (options) => {
+  return Template.createPrompt(assistant_default, options);
 };
 
-// packages/core/assistant/src/blueprint/logger.ts
-import { signal } from "@preact/signals-core";
-import chalk from "chalk";
-import { ConsolePrinter as ConsolePrinter2 } from "@dxos/ai";
-import { combine } from "@dxos/async";
-import { log as log10 } from "@dxos/log";
-chalk.level = 2;
-var DEFAULT_LOGGER = {
-  log: log10.info
-};
-var BufferedLogger = class {
-  constructor() {
-    this._messages = signal([]);
-  }
-  get messages() {
-    return this._messages;
-  }
-  clear() {
-    this._messages.value = [];
-  }
-  log(message) {
-    this._messages.value = [
-      ...this._messages.value,
-      message
-    ];
-  }
-};
-var BlueprintLoggerAdapter = class {
-  constructor(logger = DEFAULT_LOGGER) {
-    this.logger = logger;
-  }
-  log(event) {
-    switch (event.type) {
-      case "begin":
-        this.logger.log("begin", {
-          invocationId: event.invocationId
-        });
-        break;
-      case "end":
-        this.logger.log("end", {
-          invocationId: event.invocationId
-        });
-        break;
-      case "step-start":
-        this.logger.log("step-start", {
-          invocationId: event.invocationId,
-          step: event.step
-        });
-        break;
-      case "step-complete":
-        this.logger.log("step-complete", {
-          invocationId: event.invocationId,
-          step: event.step
-        });
-        break;
-      case "message":
-        this.logger.log("message", {
-          invocationId: event.invocationId,
-          message: event.message
-        });
-        break;
-      case "block":
-        this.logger.log("block", {
-          invocationId: event.invocationId,
-          block: event.block
-        });
-        break;
+// src/types.ts
+import { Schema as Schema9 } from "effect";
+import { DXN as DXN3, LOCAL_SPACE_TAG } from "@dxos/keys";
+var createArtifactElement = (id) => `<artifact id=${id} />`;
+var ArtifactId = class extends Schema9.String.annotations({
+  description: `
+  The ID of the referenced object. Formats accepted:
+  - DXN (dxn:echo:@:XXXXX). DXNs can be prepended with an @ symbol for compatibility with in-text references.
+  - space ID, object ID tuple (spaceID:objectID)
+  - Only object ID that is assumed to be in the current space (XXXXX)
+  `,
+  examples: [
+    "dxn:echo:@:XXXXX",
+    "@dxn:echo:@:XXXXX",
+    "spaceID:objectID",
+    "XXXXX"
+  ]
+}) {
+  static toDXN(reference, owningSpaceId) {
+    if (reference.startsWith("@dxn:")) {
+      return DXN3.parse(reference.slice(1));
+    } else if (reference.startsWith("dxn:")) {
+      return DXN3.parse(reference);
+    } else if (/^[A-Z0-9]+:[A-Z0-9]+$/.test(reference)) {
+      const [spaceId, objectId] = reference.split(":");
+      return new DXN3(DXN3.kind.ECHO, [
+        spaceId === owningSpaceId ? LOCAL_SPACE_TAG : spaceId,
+        objectId
+      ]);
+    } else if (/^[A-Z0-9]+$/.test(reference)) {
+      return DXN3.fromLocalObjectId(reference);
+    } else {
+      throw new Error(`Unable to parse object reference: ${reference}`);
     }
   }
 };
-var setLogger = (machine, logger) => {
-  return combine(machine.begin.on(() => {
-    logger.log("Starting...");
-  }), machine.stepStart.on((step) => {
-    const index = machine.blueprint.steps.indexOf(step);
-    logger.log(`Step ${index + 1} of ${machine.blueprint.steps.length}`);
-    logger.log(`Instructions: ${step.instructions}`);
-  }), machine.stepComplete.on((step) => {
-    const trace = machine.state.trace.find((t) => t.stepId === step.id);
-    logger.log(`Complete: ${trace?.comment}`);
-  }), machine.end.on(() => {
-    logger.log("OK");
-  }));
-};
-var setConsolePrinter = (machine, verbose = false) => {
-  const printer = new ConsolePrinter2();
-  return combine(machine.begin.on(() => printTrace(machine.blueprint, machine.state)), machine.stepStart.on((step) => console.log(`
-${chalk.magenta(`${chalk.bold(`STEP ${machine.blueprint.steps.indexOf(step) + 1} of ${machine.blueprint.steps.length}:`)} ${step.instructions}`)}
-`)), machine.stepComplete.on(() => printTrace(machine.blueprint, machine.state)), machine.end.on(() => console.log("DONE")), verbose ? [
-    machine.message.on((msg) => printer.printMessage(msg)),
-    machine.block.on((block) => printer.printContentBlock(block))
-  ] : []);
-};
-var BREAK_LINE = `
-${"_".repeat(80)}
-`;
-var printTrace = (blueprint, state) => {
-  console.group(chalk.bold("\nBlueprint"));
-  blueprint.steps.forEach((step) => {
-    const traceStep = state.trace.find((t) => t.stepId === step.id);
-    let color = chalk.gray;
-    let bullet = "\u25CB";
-    if (traceStep) {
-      switch (traceStep.status) {
-        case "done":
-          color = chalk.green;
-          bullet = "\u2713";
-          break;
-        case "skipped":
-          color = chalk.blue;
-          bullet = "\u2193";
-          break;
-        case "bailed":
-          color = chalk.red;
-          bullet = "\u2717";
-          break;
-      }
-    }
-    console.log(color(`
-${bullet} ${step.instructions}`));
-    if (traceStep?.comment) {
-      console.log(chalk.white(`  \u21B3 ${traceStep.comment}`));
-    }
-  });
-  console.groupEnd();
-  console.log(BREAK_LINE);
-};
 export {
-  AIServiecOverloadedError,
-  AISession,
-  Blueprint,
-  BlueprintBuilder,
-  BlueprintDefinition,
-  BlueprintLoggerAdapter,
-  BlueprintMachine,
-  BlueprintParser,
-  BlueprintStep,
-  BufferedLogger,
+  AiSession,
+  ArtifactDiffResolver,
+  ArtifactId,
+  Bindings,
+  ContextBinder,
+  ContextBinding,
+  Conversation,
+  ExaToolkit,
   ExtractionInput,
   ExtractionOutput,
+  LiveExaHandler,
+  LocalSearchHandler,
+  LocalSearchToolkit,
+  MockExaHandler,
   ReferencedQuotes,
   Subgraph,
   VersionPin,
   combineNerTokens,
   createArtifactElement,
-  createExaTool,
   createExtractionSchema,
-  createGraphWriterTool,
-  createLocalSearchTool,
-  createMockExaTool,
+  createSystemPrompt,
   createTokenGroups,
   extractFullEntities,
   extractionAnthropicFn,
@@ -2149,10 +1820,12 @@ export {
   getNer,
   getSanitizedSchemaName,
   insertReferences,
+  makeGraphWriterHandler,
+  makeGraphWriterToolkit,
+  makeToolExecutionServiceFromFunctions,
+  makeToolResolverFromFunctions,
   processTranscriptMessage,
   researchFn,
-  sanitizeObjects,
-  setConsolePrinter,
-  setLogger
+  sanitizeObjects
 };
 //# sourceMappingURL=index.mjs.map