@dxos/assistant 0.8.4-main.84f28bd → 0.8.4-main.b97322e

package/dist/lib/browser/index.mjs

@@ -1,72 +1,3 @@
-// src/blueprint/blueprint.ts
-import { Schema } from "effect";
-import { ToolId } from "@dxos/ai";
-import { Type } from "@dxos/echo";
-import { LabelAnnotation } from "@dxos/echo-schema";
-var Blueprint = Schema.Struct({
-  /**
-  * Global registry ID.
-  * NOTE: Once a blueprint has been cloned from the registry, its stored definition may converge,
-  * but the `key` property refers to the original registry entry.
-  */
-  // TODO(burdon): Create Format type.
-  key: Schema.String.annotations({
-    description: "Unique registration key for the blueprint"
-  }),
-  /**
-  * Human-readable name of the blueprint.
-  */
-  name: Schema.String.annotations({
-    description: "Human-readable name of the blueprint"
-  }),
-  /**
-  * Description of the blueprint's purpose and functionality.
-  */
-  description: Schema.optional(Schema.String).annotations({
-    description: "Description of the blueprint's purpose and functionality"
-  }),
-  /**
-  * Instructions that guide the AI assistant's behavior and responses.
-  * These are system prompts or guidelines that the AI should follow.
-  */
-  instructions: Schema.String.annotations({
-    description: "Instructions that guide the AI assistant's behavior and responses"
-  }),
-  /**
-  * Array of tools that the AI assistant can use when this blueprint is active.
-  */
-  tools: Schema.Array(ToolId).annotations({
-    description: "Array of tools that the AI assistant can use when this blueprint is active"
-  }),
-  /**
-  * Array of artifacts that the AI assistant can create or modify.
-  */
-  artifacts: Schema.Array(Schema.String).annotations({
-    description: "Ids of artifact definitions that should be pulled into the blueprint"
-  })
-}).pipe(
-  Type.Obj({
-    // TODO(burdon): Is this a DXN? Need to create a Format type for these IDs.
-    typename: "dxos.org/type/Blueprint",
-    version: "0.1.0"
-  }),
-  // TODO(burdon): Move to main API.
-  LabelAnnotation.set([
-    "name"
-  ])
-);
-
-// src/blueprint/registry.ts
-var BlueprintRegistry = class {
-  constructor(_blueprints) {
-    this._blueprints = _blueprints;
-    this._blueprints.sort(({ name: a }, { name: b }) => a.localeCompare(b));
-  }
-  query() {
-    return this._blueprints;
-  }
-};
-
 // src/context/binder.ts
 import { computed } from "@preact/signals-core";
 import { Array as Array2, pipe } from "effect";
@@ -74,19 +5,20 @@ import { Obj } from "@dxos/echo";
 import { ComplexSet } from "@dxos/util";
 
 // src/context/binding.ts
-import { Schema as Schema2 } from "effect";
-import { Type as Type2 } from "@dxos/echo";
-var ContextBinding = Schema2.Struct({
-  blueprints: Schema2.Struct({
-    added: Schema2.Array(Type2.Ref(Blueprint)),
-    removed: Schema2.Array(Type2.Ref(Blueprint))
+import { Schema } from "effect";
+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: Schema2.Struct({
-    added: Schema2.Array(Type2.Ref(Type2.Expando)),
-    removed: Schema2.Array(Type2.Ref(Type2.Expando))
+  objects: Schema.Struct({
+    added: Schema.Array(Type.Ref(Type.Expando)),
+    removed: Schema.Array(Type.Ref(Type.Expando))
   })
-}).pipe(Type2.Obj({
+}).pipe(Type.Obj({
   typename: "dxos.org/type/ContextBinding",
   version: "0.1.0"
 }));
@@ -163,479 +95,200 @@ var Bindings = class {
 };
 
 // src/conversation/conversation.ts
-import { Message as Message2 } from "@dxos/ai";
+import { Effect as Effect2 } from "effect";
 import { Event as Event2 } from "@dxos/async";
-import { Obj as Obj3, Ref } from "@dxos/echo";
-import { AiService, ToolResolverService } from "@dxos/functions";
-import { log as log2 } from "@dxos/log";
-import { isNonNullable } from "@dxos/util";
+import { Obj as Obj3 } from "@dxos/echo";
+import { DatabaseService as DatabaseService2 } from "@dxos/functions";
+import { DataType as DataType2 } from "@dxos/schema";
 
 // src/session/session.ts
-import { Array as Array3, Option, pipe as pipe2, Schema as Schema4 } from "effect";
-import { AgentStatusReport, isToolUse, runTools, structuredOutputParser, Message, MixedStreamParser, ToolResult, createTool } from "@dxos/ai";
-import { Event, synchronized } from "@dxos/async";
+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 { DatabaseService } from "@dxos/functions";
 import { log } from "@dxos/log";
+import { DataType } from "@dxos/schema";
 
-// src/session/version-pin.ts
-import { Schema as Schema3 } from "effect";
-import { getVersion } from "@dxos/echo-db";
-import { ObjectId } from "@dxos/echo-schema";
-var ObjectVersionSchema = Schema3.Unknown;
-var VersionPinSchema = Schema3.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") {
 };
 
 // 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_file = "/__w/dxos/dxos/packages/core/assistant/src/session/session.ts";
-var AISession = class _AISession {
-  constructor(_options) {
+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.done = 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
-        }));
-      }
-    });
-  }
-  /**
-  * Runs the AI model loop interacting with tools and artifacts.
-  * @param options - The session options.
-  * @returns The messages generated by the session, including the user's prompt.
-  */
-  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.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 = pipe2([
-          ...systemTools,
-          ...await Promise.all(options.tools.map((toolId) => options.toolResolver.resolve(toolId))),
-          ...options.executableTools ?? [],
-          ...options.artifacts.filter((artifact) => requiredArtifactIds.has(artifact.id)).flatMap((artifact) => artifact.tools)
-        ], Array3.dedupeWith((a, b) => a.id === b.id));
         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_file,
-          L: 231,
+          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: [
-              ...requiredArtifactIds
-            ],
-            operationModel: this._options.operationModel
-          })
-        });
-        await this._parser.parse(this._stream);
-        await this._stream.complete();
-        log("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_file,
-          L: 256,
+          L: 155,
           S: this,
           C: (f, a) => f(...a)
         });
-        more = false;
-        const message = this._pending.at(-1);
-        invariant(message, void 0, {
-          F: __dxlog_file,
-          L: 261,
-          S: this,
-          A: [
-            "message",
-            ""
-          ]
-        });
-        if (isToolUse(message)) {
-          log("tool request...", void 0, {
-            F: __dxlog_file,
-            L: 263,
-            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)
-          });
-          log("tool response", {
-            response
-          }, {
-            F: __dxlog_file,
-            L: 271,
-            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) {
-      log.catch(err, void 0, {
-        F: __dxlog_file,
-        L: 283,
-        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;
-      this.done.emit();
-    }
-    if (error) {
-      throw error;
-    }
-    return this._pending;
-  }
-  async runStructured(schema, options) {
-    const parser = structuredOutputParser(schema);
-    const result = await this.run({
-      ...options,
-      executableTools: [
-        ...options.executableTools ?? [],
-        parser.tool
-      ]
-    });
-    return parser.getResult(result);
-  }
-  async _formatUserPrompt(artifactDiffResolver, prompt, history) {
-    const prelude = [];
-    if (artifactDiffResolver) {
-      const versions = gatherObjectVersions(history);
-      const artifactDiff = await artifactDiffResolver([
-        ...versions.entries()
-      ].map(([id, version]) => ({
-        id,
-        lastVersion: version
-      })));
-      log.info("vision", {
-        artifactDiff,
-        versions
-      }, {
-        F: __dxlog_file,
-        L: 327,
-        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 Obj2.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: Schema4.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: Schema4.Struct({
-        artifactDefinitionIds: Schema4.Array(Schema4.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: Schema4.Struct({
-        goal: Schema4.String.annotations({
-          description: "The goal that the plan will achieve."
-        }),
-        steps: Schema4.Array(Schema4.Struct({
-          action: Schema4.String.annotations({
-            description: "Complete, detailed action to perform."
-          }),
-          input: Schema4.String.annotations({
-            description: "The required input data for this step. First step must not require any data."
           }),
-          output: Schema4.String.annotations({
-            description: "The output data from this step. This is passed to the next step as input."
-          }),
-          requiredArtifactIds: Schema4.Array(Schema4.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) {
-          log("executing step", {
-            action: step.action
-          }, {
-            F: __dxlog_file,
-            L: 434,
-            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({
-            artifacts: options.artifacts,
-            tools: options.tools,
-            history: options.history,
-            extensions: options.extensions,
-            requiredArtifactIds: step.requiredArtifactIds.slice(),
-            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))}.
-            `,
-            generationOptions: options.generationOptions,
-            client: options.client,
-            toolResolver: options.toolResolver,
-            artifactDiffResolver: options.artifactDiffResolver
+        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 Schema4.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(Schema4.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);
       }
     }
   }
@@ -643,7 +296,8 @@ 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:
@@ -654,9 +308,44 @@ ${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 __dxlog_file2 = "/__w/dxos/dxos/packages/core/assistant/src/conversation/conversation.ts";
 var Conversation = class {
   constructor(options) {
     /**
@@ -664,72 +353,51 @@ var Conversation = class {
     * This is called before the first message is sent.
     */
     this.onBegin = new Event2();
-    this._serviceContainer = options.serviceContainer;
+    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 run(options) {
-    const session = new AISession({
-      operationModel: "configured"
-    });
-    this.onBegin.emit(session);
-    const history = await this.getHistory();
-    const context = await this.context.query();
-    const blueprints = (await Ref.Array.loadAll([
-      ...context.blueprints
-    ])).filter(isNonNullable);
-    if (blueprints.length > 1) {
-      log2.warn("multiple blueprints are not yet supported", void 0, {
-        F: __dxlog_file2,
-        L: 72,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    const messages = await session.run({
-      history,
-      prompt: options.prompt,
-      systemPrompt: (options.systemPrompt ?? "") + (blueprints.at(0)?.instructions ?? ""),
-      // TODO(dmaretskyi): Artifacts come from the blueprint?
-      artifacts: options.artifacts ?? [],
-      tools: blueprints.at(0)?.tools ?? [],
-      executableTools: options.tools,
-      requiredArtifactIds: options.requiredArtifactIds,
-      client: this._serviceContainer.getService(AiService).client,
-      toolResolver: this._serviceContainer.getService(ToolResolverService).toolResolver,
-      extensions: {
-        serviceContainer: this._serviceContainer,
-        ...options.extensions
-      },
-      generationOptions: options.generationOptions
-    });
-    await this._queue.append(messages);
-    return messages;
-  }
   async getHistory() {
     const queueItems = await this._queue.queryObjects();
-    return queueItems.filter(Obj3.instanceOf(Message2));
+    return queueItems.filter(Obj3.instanceOf(DataType2.Message));
   }
 };
 
 // src/extraction/extraction.ts
-import { Schema as Schema5 } from "effect";
+import { Schema as Schema3 } from "effect";
 import { asyncTimeout } from "@dxos/async";
 import { Expando } from "@dxos/echo-schema";
-import { log as log3 } from "@dxos/log";
-import { DataType } from "@dxos/schema";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/assistant/src/extraction/extraction.ts";
-var ExtractionInput = Schema5.Struct({
-  message: DataType.Message,
-  objects: Schema5.optional(Schema5.Array(Expando)),
-  options: Schema5.optional(Schema5.Struct({
-    timeout: Schema5.optional(Schema5.Number),
-    fallbackToRaw: Schema5.optional(Schema5.Boolean)
+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 = Schema5.Struct({
-  message: DataType.Message,
-  timeElapsed: Schema5.Number
+var ExtractionOutput = Schema3.Struct({
+  message: DataType3.Message,
+  timeElapsed: Schema3.Number
 });
 var processTranscriptMessage = async (params) => {
   try {
@@ -740,10 +408,10 @@ var processTranscriptMessage = async (params) => {
     }
   } catch (error) {
     if (params.options?.fallbackToRaw) {
-      log3.warn("failed to process message, falling back to raw text", {
+      log2.warn("failed to process message, falling back to raw text", {
         error
       }, {
-        F: __dxlog_file3,
+        F: __dxlog_file2,
         L: 66,
         S: void 0,
         C: (f, a) => f(...a)
@@ -759,27 +427,27 @@ var processTranscriptMessage = async (params) => {
 };
 
 // src/extraction/extraction-llm-function/extraction-llm-function.ts
-import { Message as Message3, ToolRegistry } from "@dxos/ai";
+import { ToolRegistry, AiService } from "@dxos/ai";
 import { Obj as Obj4 } from "@dxos/echo";
-import { create as create2 } from "@dxos/echo-schema";
-import { AiService as AiService2, defineFunction } from "@dxos/functions";
-import { DataType as DataType2 } from "@dxos/schema";
+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 Schema6 } from "effect";
+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 log4 } from "@dxos/log";
-var __dxlog_file4 = "/__w/dxos/dxos/packages/core/assistant/src/extraction/quotes.ts";
-var ReferencedQuotes = Schema6.Struct({
-  references: Schema6.Array(Schema6.Struct({
-    id: Schema6.String,
-    quote: Schema6.String
-  })).pipe(Schema6.mutable).annotations({
+import { log as log3 } from "@dxos/log";
+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,
+    quote: Schema4.String
+  })).pipe(Schema4.mutable).annotations({
     // TODO(burdon): Does this description make sense?
     description: `
       The references to the context objects that are mentioned in the transcript. 
@@ -792,11 +460,11 @@ var findQuotes = async (quotes, db) => {
     const { objects } = await db.query(Query.select(Filter.text(quote, {
       type: "vector"
     }))).run();
-    log4.info("found quotes in vector index", {
+    log3.info("found quotes in vector index", {
       objects,
       quote
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file3,
       L: 35,
       S: void 0,
       C: (f, a) => f(...a)
@@ -830,8 +498,8 @@ var extractionAnthropicFn = defineFunction({
   outputSchema: ExtractionOutput,
   handler: async ({ data: { message, objects }, context }) => {
     const startTime = performance.now();
-    const ai = context.getService(AiService2);
-    const session = new AISession({
+    const ai = context.getService(AiService);
+    const session = new AiSession({
       operationModel: "configured"
     });
     const result = await session.runStructured(ReferencedQuotes, {
@@ -841,15 +509,18 @@ var extractionAnthropicFn = defineFunction({
       client: ai.client,
       systemPrompt: instructions_default,
       history: [
-        Obj4.make(Message3, {
-          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>`
             }
           ]
@@ -861,9 +532,9 @@ var extractionAnthropicFn = defineFunction({
       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)
         })
@@ -875,22 +546,22 @@ var extractionAnthropicFn = defineFunction({
 
 // 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 { log as log6 } from "@dxos/log";
-import { DataType as DataType3 } from "@dxos/schema";
+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 DataType5 } from "@dxos/schema";
 
 // src/extraction/extraction-ner-function/named-entity-recognition.ts
 import { pipeline } from "@xenova/transformers";
-import { log as log5 } from "@dxos/log";
-var __dxlog_file5 = "/__w/dxos/dxos/packages/core/assistant/src/extraction/extraction-ner-function/named-entity-recognition.ts";
+import { log as log4 } from "@dxos/log";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/assistant/src/extraction/extraction-ner-function/named-entity-recognition.ts";
 var _ner;
 var getNer = () => {
   if (!_ner) {
     _ner = pipeline("ner", "Xenova/bert-base-NER").then((ner) => {
-      log5.info("NER model is ready", void 0, {
-        F: __dxlog_file5,
+      log4.info("NER model is ready", void 0, {
+        F: __dxlog_file4,
         L: 23,
         S: void 0,
         C: (f, a) => f(...a)
@@ -964,69 +635,69 @@ var combineNerTokens = (group) => {
 };
 
 // src/extraction/extraction-ner-function/extraction-ner-function.ts
-var __dxlog_file6 = "/__w/dxos/dxos/packages/core/assistant/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,
   outputSchema: ExtractionOutput,
   handler: async ({ data: { message, options }, context }) => {
-    log6.info("input", {
+    log5.info("input", {
       message,
       options
     }, {
-      F: __dxlog_file6,
-      L: 22,
+      F: __dxlog_file5,
+      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", {
-        F: __dxlog_file6,
-        L: 28,
+      invariant(block._tag === "transcript" || block._tag === "text", "Block must have text", {
+        F: __dxlog_file5,
+        L: 31,
         S: void 0,
         A: [
-          "block.type === 'transcription' || block.type === 'text'",
+          "block._tag === 'transcript' || block._tag === 'text'",
           "'Block must have text'"
         ]
       });
       return extractFullEntities(block.text);
     })).then((entities2) => entities2.flat());
     const entities = options?.timeout ? await asyncTimeout2(entitiesPromise, options.timeout) : await entitiesPromise;
-    log6.info("entities", {
+    log5.info("entities", {
       entities
     }, {
-      F: __dxlog_file6,
-      L: 33,
+      F: __dxlog_file5,
+      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", {
-        F: __dxlog_file6,
-        L: 39,
+      invariant(block._tag === "transcript" || block._tag === "text", "Block must have text", {
+        F: __dxlog_file5,
+        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
     });
-    log6.info("output", {
+    log5.info("output", {
       messageWithReferences
     }, {
-      F: __dxlog_file6,
-      L: 47,
+      F: __dxlog_file5,
+      L: 50,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -1037,11 +708,127 @@ var extractionNerFn = defineFunction2({
   }
 });
 
+// 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 { Schema as Schema7 } from "effect";
+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 { log as log7 } from "@dxos/log";
+import { CredentialsService } from "@dxos/functions";
+import { log as log6 } from "@dxos/log";
 
 // src/testing/exa-search-1748337321991.ts
 var exa_search_1748337321991_default = {
@@ -1554,64 +1341,60 @@ var SEARCH_RESULTS = [
 
 // src/research/exa.ts
 var __dxlog_file7 = "/__w/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: Schema7.Struct({
-      query: Schema7.String.annotations({
-        description: "The query to search for"
-      })
-    }),
-    execute: async ({ query }) => {
-      const context = await exa.searchAndContents(query, {
-        type: "auto",
-        text: {
-          maxCharacters: 3e3
-        },
-        livecrawl: "always"
-      });
-      log7.info("exa search", {
-        query,
-        costDollars: context.costDollars
-      }, {
-        F: __dxlog_file7,
-        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: Schema7.Struct({
-      query: Schema7.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);
-    }
-  });
+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;
@@ -1631,27 +1414,28 @@ var levenshteinDistance = (str1, str2) => {
 };
 
 // src/research/research.ts
-import { Schema as Schema9 } from "effect";
-import { AgentStatusReport as AgentStatusReport2, ConsolePrinter, ToolRegistry as ToolRegistry2 } from "@dxos/ai";
-import { create as create5 } from "@dxos/echo-schema";
-import { AiService as AiService3, CredentialsService, DatabaseService as DatabaseService2, defineFunction as defineFunction3, TracingService } from "@dxos/functions";
-import { log as log9 } from "@dxos/log";
+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";
 
 // src/research/graph.ts
-import { Schema as Schema8, 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";
+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 log8 } from "@dxos/log";
-import { deepMapValues, isNonNullable as isNonNullable2 } from "@dxos/util";
+import { log as log7 } from "@dxos/log";
+import { deepMapValues, isNonNullable } from "@dxos/util";
 var __dxlog_file8 = "/__w/dxos/dxos/packages/core/assistant/src/research/graph.ts";
-var Subgraph = Schema8.Struct({
+var Subgraph = Schema7.Struct({
   /** Objects and relations. */
-  objects: Schema8.Array(Schema8.Any)
+  objects: Schema7.Array(Schema7.Any)
 });
 var findRelatedSchema = async (db, anchor) => {
   const allSchemas = [
@@ -1677,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: Schema8.Struct({
-      query: Schema8.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 Schema8.Struct({
+  return Schema7.Struct({
     ...Object.fromEntries(types.map(preprocessSchema).map((schema, index) => [
       `objects_${getSanitizedSchemaName(types[index])}`,
-      Schema8.optional(Schema8.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(() => ""))}`
       })
     ]))
@@ -1764,22 +1574,22 @@ var sanitizeObjects = async (types, data, db, queue) => {
     if (getEntityKind(entry.schema) === "relation") {
       const sourceDxn = resolveId(data2.source);
       if (!sourceDxn) {
-        log8.warn("source not found", {
+        log7.warn("source not found", {
           source: data2.source
         }, {
           F: __dxlog_file8,
-          L: 214,
+          L: 262,
           S: void 0,
           C: (f, a) => f(...a)
         });
       }
       const targetDxn = resolveId(data2.target);
       if (!targetDxn) {
-        log8.warn("target not found", {
+        log7.warn("target not found", {
           target: data2.target
         }, {
           F: __dxlog_file8,
-          L: 218,
+          L: 266,
           S: void 0,
           C: (f, a) => f(...a)
         });
@@ -1801,14 +1611,14 @@ var sanitizeObjects = async (types, data, db, queue) => {
   const objects = [
     ...dbObjects,
     ...queueObjects
-  ].filter(isNonNullable2);
-  log8.info("objects", {
+  ].filter(isNonNullable);
+  log7.info("objects", {
     dbObjects,
     queueObjects,
     existingIds
   }, {
     F: __dxlog_file8,
-    L: 239,
+    L: 287,
     S: void 0,
     C: (f, a) => f(...a)
   });
@@ -1839,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
@@ -1848,161 +1658,159 @@ var sanitizeObjects = async (types, data, db, queue) => {
     return [];
   });
 };
-var SoftRef = Schema8.Struct({
-  "/": Schema8.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 Schema8.make(mapAst(schema.ast, go)).pipe(Schema8.omit("id"), Schema8.extend(Schema8.Struct({
-    id: Schema8.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 ? Schema8.extend(Schema8.Struct({
-    source: Schema8.String.annotations({
+  })), isRelationSchema ? Schema7.extend(Schema7.Struct({
+    source: Schema7.String.annotations({
       description: "The id of the source object for this relation."
     }),
-    target: Schema8.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>";
 
 // 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: Schema9.Struct({
-    query: Schema9.String.annotations({
+  inputSchema: Schema8.Struct({
+    query: Schema8.String.annotations({
       description: "The query to search for."
     }),
     // TOOD(burdon): Move to context.
-    mockSearch: Schema9.optional(Schema9.Boolean).annotations({
+    mockSearch: Schema8.optional(Schema8.Boolean).annotations({
       description: "Whether to use the mock search tool.",
       default: false
     })
   }),
-  outputSchema: Schema9.Struct({
-    // result: Schema.String,
-    result: Schema9.Any
+  outputSchema: Schema8.Struct({
+    result: Schema8.Unknown
   }),
-  handler: async ({ data: { query, mockSearch }, context }) => {
-    const ai = context.getService(AiService3);
-    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) => {
-      log9.info("[agent] status", {
-        status
-      }, {
-        F: __dxlog_file9,
-        L: 58,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      tracing.write(status);
-    });
-    session.streamEvent.on((event) => log9("stream", {
+    session.streamEvent.on((event) => log8("stream", {
       event
     }, {
       F: __dxlog_file9,
-      L: 61,
-      S: void 0,
+      L: 62,
+      S: this,
       C: (f, a) => f(...a)
     }));
-    const graphWriteTool = createGraphWriterTool({
-      db,
-      schema: DataTypes
-    });
-    log9.info("graphWriteTool", {
-      schema: graphWriteTool.parameters
-    }, {
-      F: __dxlog_file9,
-      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.id,
-        graphWriteTool.id
-      ],
-      history: [],
+    const result = yield* session.run({
       prompt: query,
-      toolResolver: new ToolRegistry2([
-        searchTool,
-        graphWriteTool
-      ])
+      history: [],
+      systemPrompt: instructions_research_default,
+      toolkit
     });
     return {
       result
     };
-  }
+  }, Effect6.provide(AiService2.model("@anthropic/claude-3-5-sonnet-20241022")))
 });
 
+// src/templates/prompt.ts
+import { Template } from "@dxos/blueprints";
+
+// 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}}";
+
+// src/templates/prompt.ts
+var createSystemPrompt = (options) => {
+  return Template.createPrompt(assistant_default, options);
+};
+
 // 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}`);
+    }
+  }
+};
 export {
-  AIServiecOverloadedError,
-  AISession,
+  AiSession,
+  ArtifactDiffResolver,
+  ArtifactId,
   Bindings,
-  Blueprint,
-  BlueprintRegistry,
   ContextBinder,
   ContextBinding,
   Conversation,
+  ExaToolkit,
   ExtractionInput,
   ExtractionOutput,
+  LiveExaHandler,
+  LocalSearchHandler,
+  LocalSearchToolkit,
+  MockExaHandler,
   ReferencedQuotes,
   Subgraph,
   VersionPin,
   combineNerTokens,
   createArtifactElement,
-  createExaTool,
   createExtractionSchema,
-  createGraphWriterTool,
-  createLocalSearchTool,
-  createMockExaTool,
+  createSystemPrompt,
   createTokenGroups,
   extractFullEntities,
   extractionAnthropicFn,
@@ -2012,6 +1820,10 @@ export {
   getNer,
   getSanitizedSchemaName,
   insertReferences,
+  makeGraphWriterHandler,
+  makeGraphWriterToolkit,
+  makeToolExecutionServiceFromFunctions,
+  makeToolResolverFromFunctions,
   processTranscriptMessage,
   researchFn,
   sanitizeObjects