@dxos/assistant 0.8.4-main.fd6878d → 0.8.4-main.fffef41

package/dist/lib/browser/index.mjs

@@ -1,18 +1,19 @@
 import {
-  AiAssistantError,
-  AiSession,
-  ArtifactDiffResolver,
-  GenerationObserver,
-  VersionPin
-} from "./chunk-NZGGCEF3.mjs";
+  __export
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/conversation/context.ts
 import { computed } from "@preact/signals-core";
-import { Schema } from "effect";
-import { Array, pipe } from "effect";
+import * as Array2 from "effect/Array";
+import * as Context from "effect/Context";
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
 import { Blueprint } from "@dxos/blueprints";
-import { Obj, Type } from "@dxos/echo";
+import { Resource } from "@dxos/context";
+import { DXN, Filter, Obj, Query, Type } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
 import { ComplexSet } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant/src/conversation/context.ts";
 var ContextBinding = Schema.Struct({
   blueprints: Schema.Struct({
     added: Schema.Array(Type.Ref(Blueprint.Blueprint)),
@@ -29,53 +30,103 @@ var ContextBinding = Schema.Struct({
 }));
 var Bindings = class {
   blueprints = new ComplexSet((ref) => ref.dxn.toString());
-  objects = new ComplexSet((ref) => ref.dxn.toString());
+  // TODO(burdon): Some DXNs have the Space prefix so only compare the object ID.
+  objects = new ComplexSet((ref) => ref.dxn.asEchoDXN()?.echoId);
   toJSON() {
     return {
-      blueprints: Array.fromIterable(this.blueprints).map((ref) => ref.dxn.toString()),
-      objects: Array.fromIterable(this.objects).map((ref) => ref.dxn.toString())
+      blueprints: Array2.fromIterable(this.blueprints).map((ref) => ref.dxn.toString()),
+      objects: Array2.fromIterable(this.objects).map((ref) => ref.dxn.toString())
     };
   }
 };
-var AiContextBinder = class {
+var AiContextBinder = class extends Resource {
   _queue;
   /**
   * Reactive query of all bindings.
   */
   // TODO(burdon): Cache value?
-  bindings;
-  blueprints;
-  objects;
+  _bindings;
+  _blueprints;
+  _objects;
   constructor(_queue) {
-    this._queue = _queue;
-    this.bindings = computed(() => this._reduce(this._queue.objects));
-    this.blueprints = computed(() => [
+    super(), this._queue = _queue;
+  }
+  get bindings() {
+    invariant(this._bindings, "AiContextBinder not open", {
+      F: __dxlog_file,
+      L: 78,
+      S: this,
+      A: [
+        "this._bindings",
+        "'AiContextBinder not open'"
+      ]
+    });
+    return this._bindings;
+  }
+  get blueprints() {
+    invariant(this._blueprints, "AiContextBinder not open", {
+      F: __dxlog_file,
+      L: 83,
+      S: this,
+      A: [
+        "this._blueprints",
+        "'AiContextBinder not open'"
+      ]
+    });
+    return this._blueprints;
+  }
+  get objects() {
+    invariant(this._objects, "AiContextBinder not open", {
+      F: __dxlog_file,
+      L: 88,
+      S: this,
+      A: [
+        "this._objects",
+        "'AiContextBinder not open'"
+      ]
+    });
+    return this._objects;
+  }
+  // TODO(wittjosiah): Use parent context?
+  async _open() {
+    const query = this._queue.query(Query.select(Filter.everything()));
+    this._ctx.onDispose(query.subscribe(() => {
+    }));
+    this._bindings = computed(() => this._reduce(query.objects));
+    this._blueprints = computed(() => [
       ...this.bindings.value.blueprints
     ]);
-    this.objects = computed(() => [
+    this._objects = computed(() => [
       ...this.bindings.value.objects
     ]);
   }
+  async _close() {
+    this._bindings = void 0;
+    this._blueprints = void 0;
+    this._objects = void 0;
+  }
   /**
   * Asynchronous query of all bindings.
   */
   async query() {
-    const queueItems = await this._queue.queryObjects();
-    return this._reduce(queueItems);
+    const { objects } = await this._queue.query(Query.select(Filter.everything())).run();
+    return this._reduce(objects);
   }
   // TODO(burdon): Pass in Blueprint obj (from registry?) and create reference.
   async bind(props) {
-    if (!props.blueprints?.length && !props.objects?.length) {
+    const blueprints = props.blueprints?.filter((ref) => !this.blueprints.peek().find((b) => b.dxn.toString() === ref.dxn.toString())) ?? [];
+    const objects = props.objects?.filter((ref) => !this.objects.peek().find((o) => o.dxn.toString() === ref.dxn.toString())) ?? [];
+    if (!blueprints.length && !objects.length) {
       return;
     }
     await this._queue.append([
       Obj.make(ContextBinding, {
         blueprints: {
-          added: props.blueprints ?? [],
+          added: blueprints,
           removed: []
         },
         objects: {
-          added: props.objects ?? [],
+          added: objects,
           removed: []
         }
       })
@@ -99,211 +150,1081 @@ var AiContextBinder = class {
     ]);
   }
   _reduce(items) {
-    return pipe(items, Array.filter(Obj.instanceOf(ContextBinding)), Array.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 Function.pipe(items, Array2.filter(Obj.instanceOf(ContextBinding)), Array2.reduce(new Bindings(), (context, item) => {
+      item.blueprints.removed.forEach((ref) => context.blueprints.delete(ref));
+      item.blueprints.added.forEach((ref) => context.blueprints.add(ref));
+      item.objects.removed.forEach((ref) => {
+        for (const obj of context.objects) {
+          if (DXN.equalsEchoId(obj.dxn, ref.dxn)) {
+            context.objects.delete(obj);
+          }
+        }
+      });
+      item.objects.added.forEach((ref) => context.objects.add(ref));
       return context;
     }));
   }
 };
+var AiContextService = class extends Context.Tag("@dxos/assistant/AiContextService")() {
+};
 
 // src/conversation/conversation.ts
-import { Effect } from "effect";
-import { Event } from "@dxos/async";
+import * as Array5 from "effect/Array";
+import * as Effect6 from "effect/Effect";
+import * as Option2 from "effect/Option";
+import { Resource as Resource2 } from "@dxos/context";
+import { Obj as Obj4 } from "@dxos/echo";
+import { DatabaseService as DatabaseService2 } from "@dxos/echo-db";
+import { log as log3 } from "@dxos/log";
+import { Message as Message3 } from "@dxos/types";
+
+// src/session/artifact-diff.ts
+import * as Context2 from "effect/Context";
+var ArtifactDiffResolver = class extends Context2.Tag("@dxos/assistant/ArtifactDiffResolver")() {
+};
+
+// src/session/observer.ts
+import * as Effect from "effect/Effect";
+import * as Function2 from "effect/Function";
+var GenerationObserver = Object.freeze({
+  make: ({ onBegin = Function2.constant(Effect.void), onPart = Function2.constant(Effect.void), onBlock = Function2.constant(Effect.void), onEnd = Function2.constant(Effect.void), onMessage = Function2.constant(Effect.void) } = {}) => ({
+    onBegin,
+    onPart,
+    onBlock,
+    onEnd,
+    onMessage
+  }),
+  noop: () => GenerationObserver.make(),
+  /**
+  * Debug printer to be used in unit-tests and browser devtools.
+  */
+  fromPrinter: (printer) => GenerationObserver.make({
+    onBlock: (block) => Effect.sync(() => {
+      if (block.pending) {
+        return;
+      }
+      printer.printContentBlock(block);
+    }),
+    onMessage: (message) => Effect.sync(() => {
+      if (message.sender.role === "assistant") {
+        return;
+      }
+      printer.printMessage(message);
+    })
+  })
+});
+
+// src/session/session.ts
+import * as LanguageModel from "@effect/ai/LanguageModel";
+import * as Chunk from "effect/Chunk";
+import * as Effect3 from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { AiParser, AiPreprocessor, callTool, getToolCalls } from "@dxos/ai";
+import { todo } from "@dxos/debug";
+import { Obj as Obj3 } from "@dxos/echo";
+import { TracingService } from "@dxos/functions";
+import { log as log2 } from "@dxos/log";
+import { Message as Message2 } from "@dxos/types";
+
+// src/session/format.ts
+import * as Array4 from "effect/Array";
+import * as Effect2 from "effect/Effect";
+import * as Function3 from "effect/Function";
+import * as Option from "effect/Option";
+import { Template } from "@dxos/blueprints";
 import { Obj as Obj2 } from "@dxos/echo";
-import { DatabaseService } from "@dxos/functions";
+import { DatabaseService, ObjectVersion } from "@dxos/echo-db";
 import { log } from "@dxos/log";
-import { DataType } from "@dxos/schema";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant/src/conversation/conversation.ts";
-var AiConversation = class {
+import { Message } from "@dxos/types";
+import { trim } from "@dxos/util";
+
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var AiModelError = class extends BaseError.extend("AI_MODEL_ERROR", "AI model error") {
+};
+var AiAssistantError = class extends BaseError.extend("AI_ASSISTANT_ERROR", "AI assistant error") {
+};
+
+// src/session/format.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/assistant/src/session/format.ts";
+var formatSystemPrompt = ({ system, blueprints = [], objects = [] }) => Effect2.gen(function* () {
+  const blueprintDefs = yield* Function3.pipe(blueprints, Effect2.forEach((blueprint) => Effect2.succeed(blueprint.instructions)), Effect2.flatMap(Effect2.forEach((template) => DatabaseService.loadOption(template.source))), Effect2.map(Array4.filter(Option.isSome)), Effect2.map(Array4.map((template) => trim`
+            <blueprint>
+              ${Template.process(template.value.content)}
+            </blueprint>
+          `)), Effect2.map((blueprints2) => blueprints2.length > 0 ? [
+    "## Blueprints Definitions",
+    ...blueprints2
+  ].join("\n\n") : void 0));
+  const objectDefs = yield* Function3.pipe(objects, Effect2.forEach((object) => Effect2.succeed(trim`
+          <object>
+            <dxn>${Obj2.getDXN(object)}</dxn>
+            <typename>${Obj2.getTypename(object)}</typename>
+          </object>
+        `)), Effect2.map((objects2) => objects2.length > 0 ? [
+    "## Context Objects",
+    ...objects2
+  ].join("\n\n") : void 0));
+  return yield* Function3.pipe(Effect2.succeed([
+    system,
+    blueprintDefs,
+    objectDefs
+  ].filter((def) => def !== void 0)), Effect2.map((parts) => parts.join("\n\n")));
+});
+var formatUserPrompt = ({ prompt, history = [] }) => Effect2.gen(function* () {
+  const blocks = [];
+  const artifactDiffResolver = yield* Effect2.serviceOption(ArtifactDiffResolver);
+  if (Option.isSome(artifactDiffResolver)) {
+    const versions = gatherObjectVersions(history);
+    const artifactDiff = yield* Effect2.tryPromise({
+      try: () => artifactDiffResolver.value.resolve([
+        ...versions.entries()
+      ].map(([id, version]) => ({
+        id,
+        lastVersion: version
+      }))),
+      catch: AiAssistantError.wrap({
+        message: "Artifact diff resolution error"
+      })
+    });
+    log("version", {
+      artifactDiff,
+      versions
+    }, {
+      F: __dxlog_file2,
+      L: 95,
+      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;
+      }
+      blocks.push({
+        _tag: "anchor",
+        objectId: id,
+        version
+      });
+    }
+    if (artifactDiff.size > 0) {
+      blocks.push(createArtifactUpdateBlock(artifactDiff));
+    }
+  }
+  return Obj2.make(Message.Message, {
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    sender: {
+      role: "user"
+    },
+    blocks: [
+      ...blocks,
+      {
+        _tag: "text",
+        text: prompt
+      }
+    ]
+  });
+});
+var gatherObjectVersions = (messages) => {
+  const artifactIds = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const block of message.blocks) {
+      if (block._tag === "anchor") {
+        artifactIds.set(block.objectId, block.version);
+      }
+    }
+  }
+  return artifactIds;
+};
+var createArtifactUpdateBlock = (artifactDiff) => {
+  return {
+    _tag: "text",
+    // TODO(dmaretskyi): Does this need to be a special content-block?
+    disposition: "artifact-update",
+    text: trim`
+      The following artifacts have been updated since the last message:
+      ${[
+      ...artifactDiff.entries()
+    ].map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `
+${diff}` : ""}</changed-artifact>`).join("\n")}
+    `
+  };
+};
+
+// src/session/session.ts
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/assistant/src/session/session.ts";
+var AiSession = class {
+  _options;
+  /** Prevents concurrent execution of session. */
+  _semaphore = Effect3.runSync(Effect3.makeSemaphore(1));
+  /** Message history from queue. */
+  // TODO(burdon): Evolve into supporting a git-like graph of messages.
+  _history = [];
+  /** Pending messages for this session (incl. the current prompt). */
+  _pending = [];
+  constructor(_options = {}) {
+    this._options = _options;
+  }
+  run = ({ prompt, system: systemTemplate, history = [], objects = [], blueprints = [], toolkit, observer = GenerationObserver.noop() }) => Effect3.gen(this, function* () {
+    this._history = [
+      ...history
+    ];
+    this._pending = [];
+    const pending = this._pending;
+    const submitMessage = Effect3.fnUntraced(function* (message) {
+      pending.push(message);
+      yield* observer.onMessage(message);
+      yield* TracingService.emitConverationMessage(message);
+      return message;
+    });
+    const promptMessage = yield* submitMessage(yield* formatUserPrompt({
+      prompt,
+      history
+    }));
+    const system = yield* formatSystemPrompt({
+      system: systemTemplate,
+      blueprints,
+      objects
+    });
+    do {
+      log2("request", {
+        prompt: promptMessage,
+        system: {
+          snippet: createSnippet(system),
+          length: system.length
+        },
+        pending: this._pending.length,
+        history: this._history.length,
+        objects: objects?.length ?? 0
+      }, {
+        F: __dxlog_file3,
+        L: 110,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const prompt2 = yield* AiPreprocessor.preprocessPrompt([
+        ...this._history,
+        ...this._pending
+      ], {
+        system
+      });
+      const blocks = yield* LanguageModel.streamText({
+        prompt: prompt2,
+        toolkit,
+        disableToolCallResolution: true
+      }).pipe(
+        // TOOD(dmaretskyi): Error mapping.
+        AiParser.parseResponse({
+          onBegin: () => observer.onBegin(),
+          onBlock: (block) => observer.onBlock(block),
+          onPart: (part) => observer.onPart(part),
+          onEnd: (summary) => observer.onEnd(summary)
+        }),
+        Stream.runCollect,
+        Effect3.map(Chunk.toArray)
+      );
+      const response = yield* submitMessage(Obj3.make(Message2.Message, {
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        sender: {
+          role: "assistant"
+        },
+        blocks
+      }));
+      const toolCalls = getToolCalls(response);
+      if (toolCalls.length === 0) {
+        break;
+      } else if (!toolkit) {
+        throw new Error("No toolkit provided");
+      }
+      const toolResults = yield* Effect3.forEach(toolCalls, (toolCall) => {
+        return callTool(toolkit, toolCall).pipe(Effect3.provide(TracingService.layerSubframe((context) => ({
+          ...context,
+          parentMessage: response.id,
+          toolCallId: toolCall.toolCallId
+        }))));
+      });
+      yield* submitMessage(Obj3.make(Message2.Message, {
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        sender: {
+          role: "tool"
+        },
+        blocks: toolResults
+      }));
+    } while (true);
+    log2("done", {
+      pending: this._pending.length
+    }, {
+      F: __dxlog_file3,
+      L: 181,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return this._pending;
+  }).pipe(this._semaphore.withPermits(1), Effect3.withSpan("AiSession.run"));
+  /**
+  * @deprecated
+  */
+  // TODO(burdon): Implement or remove.
+  async runStructured(_schema, _options) {
+    return todo();
+  }
+};
+var createSnippet = (text, len = 32) => text.length <= len * 2 ? text : [
+  text.slice(0, len),
+  "...",
+  text.slice(-len)
+].join("");
+
+// src/session/toolkit.ts
+import * as Toolkit from "@effect/ai/Toolkit";
+import * as Effect4 from "effect/Effect";
+import { ToolExecutionService, ToolResolverService } from "@dxos/ai";
+import { isTruthy } from "@dxos/util";
+var createToolkit = ({ toolkit: toolkitParam, toolIds = [], blueprints = [] }) => Effect4.gen(function* () {
+  const blueprintToolkit = yield* ToolResolverService.resolveToolkit([
+    ...blueprints.flatMap(({ tools }) => tools),
+    ...toolIds
+  ]);
+  const blueprintToolkitHandler = yield* blueprintToolkit.toContext(ToolExecutionService.handlersFor(blueprintToolkit));
+  const toolkit = Toolkit.merge(...[
+    toolkitParam,
+    blueprintToolkit
+  ].filter(isTruthy));
+  return yield* toolkit.pipe(Effect4.provide(blueprintToolkitHandler));
+});
+
+// src/session/version-pin.ts
+import * as Schema2 from "effect/Schema";
+import { ObjectId } from "@dxos/echo/internal";
+import { getVersion } from "@dxos/echo-db";
+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 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/session/GenericToolkit.ts
+var GenericToolkit_exports = {};
+__export(GenericToolkit_exports, {
+  TypeId: () => TypeId,
+  make: () => make,
+  merge: () => merge3
+});
+import * as Toolkit2 from "@effect/ai/Toolkit";
+import * as Effect5 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Pipeable from "effect/Pipeable";
+var TypeId = "~@dxos/assistant/GenericToolkit";
+var make = (toolkit, layer) => {
+  return {
+    [TypeId]: TypeId,
+    toolkit,
+    layer,
+    handlers: toolkit.pipe(Effect5.provide(layer)),
+    pipe() {
+      return Pipeable.pipeArguments(this, arguments);
+    }
+  };
+};
+var merge3 = (...toolkits) => {
+  return make(Toolkit2.merge(...toolkits.map((t) => t.toolkit)), Layer.mergeAll(...toolkits.map((t) => t.layer)));
+};
+
+// src/conversation/conversation.ts
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/assistant/src/conversation/conversation.ts";
+var AiConversation = class extends Resource2 {
+  /**
+  * Message and binding queue.
+  */
   _queue;
   /**
   * Blueprints bound to the conversation.
   */
   _context;
   /**
-  * Fired when the execution loop begins.
-  * This is called before the first message is sent.
-  *
-  * @deprecated Pass in a session instead.
+  * Toolkit from the current session request.
   */
-  // TODO(burdon): Is this still deprecated?
-  onBegin = new Event();
-  constructor(options) {
-    this._queue = options.queue;
+  _toolkit;
+  constructor(queue) {
+    super();
+    this._queue = queue;
     this._context = new AiContextBinder(this._queue);
   }
+  async _open() {
+    await this._context.open();
+  }
+  async _close() {
+    await this._context.close();
+  }
   get context() {
     return this._context;
   }
+  get toolkit() {
+    return this._toolkit;
+  }
   async getHistory() {
     const queueItems = await this._queue.queryObjects();
-    return queueItems.filter(Obj2.instanceOf(DataType.Message));
+    return queueItems.filter(Obj4.instanceOf(Message3.Message));
   }
   /**
-  * Executes a prompt.
-  * Each invocation creates a new `AiSession`, which handles potential tool calls.
+  * Creates a new cancelable request effect.
   */
-  run = ({
-    // TODO(burdon): Decide whether to pass in or to fully encapsulate.
-    session = new AiSession(),
-    ...params
-  }) => Effect.gen(this, function* () {
-    const history = yield* Effect.promise(() => this.getHistory());
-    const context = yield* Effect.promise(() => this.context.query());
-    const blueprints = yield* Effect.forEach(context.blueprints.values(), DatabaseService.load);
-    const objects = yield* Effect.forEach(context.objects.values(), DatabaseService.load);
-    log.info("run", {
-      prompt: params.prompt,
-      system: params.system,
-      history: history.length,
-      objects: objects.length,
-      blueprints: blueprints.length,
-      toolkit: params.toolkit
-    }, {
-      F: __dxlog_file,
-      L: 99,
-      S: this,
-      C: (f, a) => f(...a)
+  createRequest(params) {
+    return Effect6.gen(this, function* () {
+      const session = new AiSession();
+      const history = yield* Effect6.promise(() => this.getHistory());
+      const context = yield* Effect6.promise(() => this.context.query());
+      const blueprints = yield* Effect6.forEach(context.blueprints.values(), DatabaseService2.loadOption).pipe(Effect6.map(Array5.filter(Option2.isSome)), Effect6.map(Array5.map((option) => option.value)));
+      const objects = yield* Effect6.forEach(context.objects.values(), DatabaseService2.loadOption).pipe(Effect6.map(Array5.filter(Option2.isSome)), Effect6.map(Array5.map((option) => option.value)));
+      const toolkit = yield* createToolkit({
+        blueprints
+      });
+      this._toolkit = toolkit;
+      const start = Date.now();
+      log3("run", {
+        history: history.length,
+        blueprints: blueprints.length,
+        objects: objects.length,
+        tools: this._toolkit?.tools.length ?? 0
+      }, {
+        F: __dxlog_file4,
+        L: 107,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const messages = yield* session.run({
+        history,
+        blueprints,
+        objects,
+        toolkit,
+        ...params
+      }).pipe(Effect6.provideService(AiContextService, {
+        binder: this.context
+      }));
+      log3("result", {
+        messages: messages.length,
+        duration: Date.now() - start
+      }, {
+        F: __dxlog_file4,
+        L: 121,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      yield* Effect6.promise(() => this._queue.append(messages));
+      return messages;
+    }).pipe(Effect6.withSpan("AiConversation.request"));
+  }
+};
+
+// src/diff.ts
+import { next as A } from "@automerge/automerge";
+import { DocAccessor, toCursorRange } from "@dxos/echo-db";
+import { log as log4 } from "@dxos/log";
+import { isNonNullable } from "@dxos/util";
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/assistant/src/diff.ts";
+var reduceDiffs = (diffs) => {
+  return diffs.reduce((acc, diff) => {
+    const current = acc[acc.length - 1];
+    const [op, ...rest] = diff.split(" ");
+    switch (op) {
+      case "-": {
+        if (current && !current.match) {
+          current.match += rest.join(" ");
+        } else {
+          acc.push({
+            match: rest.join(" "),
+            replace: ""
+          });
+        }
+        return acc;
+      }
+      case "+": {
+        if (current && !current.replace) {
+          current.replace += rest.join(" ");
+        } else {
+          acc.push({
+            match: "",
+            replace: rest.join(" ")
+          });
+        }
+        return acc;
+      }
+    }
+    return acc;
+  }, []);
+};
+var computeDiffsWithCursors = (accessor, diffs) => {
+  return reduceDiffs(diffs).map((diff) => {
+    const text = DocAccessor.getValue(accessor);
+    const idx = text.indexOf(diff.match);
+    if (idx !== -1) {
+      return {
+        cursor: toCursorRange(accessor, idx, idx + diff.match.length),
+        text: diff.replace
+      };
+    }
+  }).filter(isNonNullable);
+};
+var applyDiffs = (accessor, diffs) => {
+  for (const diff of reduceDiffs(diffs)) {
+    accessor.handle.change((doc) => {
+      const text = DocAccessor.getValue(accessor);
+      const idx = text.indexOf(diff.match);
+      if (idx !== -1) {
+        A.splice(doc, accessor.path, idx, diff.match.length, diff.replace);
+      } else {
+        log4.warn("diff not found", diff, {
+          F: __dxlog_file5,
+          L: 78,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+      }
     });
-    const start = Date.now();
-    this.onBegin.emit(session);
-    const messages = yield* session.run({
-      prompt: params.prompt,
-      system: params.system,
-      history,
-      objects,
-      blueprints,
-      toolkit: params.toolkit,
-      observer: params.observer
+  }
+  return DocAccessor.getValue(accessor);
+};
+
+// src/execution-graph.ts
+import { AgentStatus } from "@dxos/ai";
+import { Obj as Obj5 } from "@dxos/echo";
+import { MESSAGE_PROPERTY_TOOL_CALL_ID } from "@dxos/functions";
+import { LogLevel } from "@dxos/log";
+import { ContentBlock, Message as Message4 } from "@dxos/types";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
+var SKIP_BLOCKS = [
+  "text"
+];
+var ExecutionGraph = class {
+  _skipBlocks;
+  // TODO(dmaretskyi): Evolve the internal state to support chats, functions, circuit workflows, etc.
+  _commits = [];
+  _branchNames = /* @__PURE__ */ new Set();
+  _lastBlockId;
+  // Tool call tracking.
+  _toolCallCommitIds = /* @__PURE__ */ new Map();
+  _lastCommitByBranch = /* @__PURE__ */ new Map();
+  _pendingToolResults = /* @__PURE__ */ new Map();
+  constructor(_skipBlocks = SKIP_BLOCKS) {
+    this._skipBlocks = _skipBlocks;
+  }
+  /**
+  * Adds events to the graph.
+  */
+  addEvents(events) {
+    const sortedEvents = this.sortObjectsByCreated(events);
+    for (const event of sortedEvents) {
+      if (Obj5.instanceOf(Message4.Message, event)) {
+        this._processMessage(event);
+      } else if (Obj5.instanceOf(AgentStatus, event)) {
+        this._processAgentStatus(event);
+      }
+    }
+  }
+  /**
+  * Processes a message event and creates commits for its blocks.
+  */
+  _processMessage(message) {
+    const messageCommits = messageToCommits(message, this._lastBlockId, this._toolCallCommitIds, this._lastCommitByBranch, this._skipBlocks);
+    this._commits.push(...messageCommits);
+    messageCommits.forEach((commit) => this._branchNames.add(commit.branch));
+    this._trackToolCalls(messageCommits);
+    if (messageCommits.length > 0) {
+      this._lastBlockId = messageCommits[messageCommits.length - 1].id;
+    }
+  }
+  /**
+  * Processes an AgentStatus event.
+  */
+  _processAgentStatus(event) {
+    const branch = this._getToolCallBranch(event.parentMessage, event.toolCallId);
+    this._branchNames.add(branch);
+    const agentStatusCommit = {
+      id: event.id,
+      branch,
+      message: event.message,
+      icon: "ph--flag--regular",
+      parents: this._getAgentStatusParents(event),
+      timestamp: new Date(event.created)
+    };
+    this._commits.push(agentStatusCommit);
+    this._lastBlockId = event.id;
+    if (event.toolCallId) {
+      this._lastCommitByBranch.set(branch, event.id);
+      this._updatePendingToolResults(event.toolCallId, event.id);
+    }
+  }
+  /**
+  * Stable sort: objects with 'created' field are sorted by it, others remain in place.
+  */
+  sortObjectsByCreated(objects) {
+    const sortedObjects = objects.slice();
+    const createdObjects = [];
+    sortedObjects.forEach((obj, idx) => {
+      if (obj && typeof obj.created === "string") {
+        createdObjects.push({
+          idx,
+          obj
+        });
+      }
     });
-    log.info("result", {
-      messages,
-      duration: Date.now() - start
-    }, {
-      F: __dxlog_file,
-      L: 121,
-      S: this,
-      C: (f, a) => f(...a)
+    createdObjects.sort((a, b) => {
+      const aDate = new Date(a.obj.created).getTime();
+      const bDate = new Date(b.obj.created).getTime();
+      return aDate - bDate;
     });
-    yield* Effect.promise(() => this._queue.append(messages));
-    return messages;
-  }).pipe(Effect.withSpan("AiConversation.run"));
+    let createdIdx = 0;
+    return sortedObjects.map((obj, _idx) => {
+      if (obj && typeof obj.created === "string") {
+        return createdObjects[createdIdx++].obj;
+      }
+      return obj;
+    });
+  }
+  /**
+  * Returns the current state of the graph.
+  */
+  getGraph(lastRequest = false) {
+    const idx = lastRequest ? this._commits.findLastIndex((c) => c.tags?.includes("user")) : -1;
+    const commits = idx === -1 ? this._commits : this._commits.slice(idx);
+    return {
+      branches: Array.from(this._branchNames),
+      commits
+    };
+  }
+  /**
+  * Tracks tool calls and handles pending tool result updates.
+  */
+  _trackToolCalls(commits) {
+    commits.forEach((commit) => {
+      if (this._isToolCallCommit(commit)) {
+        const toolCallId = this._extractToolCallId(commit.id);
+        if (toolCallId) {
+          this._toolCallCommitIds.set(toolCallId, commit.id);
+        }
+      }
+      if (this._isToolResultCommit(commit)) {
+        const toolCallId = this._extractToolCallId(commit.id);
+        if (toolCallId) {
+          this._pendingToolResults.set(toolCallId, commit.id);
+          this._handleLateToolResultUpdate(toolCallId, commit.id);
+        }
+      }
+      this._lastCommitByBranch.set(commit.branch, commit.id);
+    });
+  }
+  /**
+  * Updates pending tool results to point to an AgentStatus event.
+  */
+  _updatePendingToolResults(toolCallId, agentStatusId) {
+    const toolResultId = this._pendingToolResults.get(toolCallId);
+    if (!toolResultId) return;
+    const toolResultCommit = this._commits.find((c) => c.id === toolResultId);
+    if (!toolResultCommit) return;
+    const toolCallCommitId = this._toolCallCommitIds.get(toolCallId);
+    if (!toolCallCommitId) return;
+    const toolCallIndex = toolResultCommit.parents.indexOf(toolCallCommitId);
+    if (toolCallIndex !== -1) {
+      toolResultCommit.parents[toolCallIndex] = agentStatusId;
+    }
+    this._pendingToolResults.delete(toolCallId);
+  }
+  /**
+  * Handles late updates when AgentStatus is processed before tool result.
+  */
+  _handleLateToolResultUpdate(toolCallId, toolResultId) {
+    const toolCallCommitId = this._toolCallCommitIds.get(toolCallId);
+    if (!toolCallCommitId) return;
+    const messageId = toolCallCommitId.split("_toolCall_")[0];
+    const toolCallBranch = `${messageId}_${toolCallId}`;
+    const agentStatusCommitId = this._lastCommitByBranch.get(toolCallBranch);
+    if (agentStatusCommitId && agentStatusCommitId !== toolCallCommitId) {
+      const toolResultCommit = this._commits.find((c) => c.id === toolResultId);
+      if (toolResultCommit) {
+        const toolCallIndex = toolResultCommit.parents.indexOf(toolCallCommitId);
+        if (toolCallIndex !== -1) {
+          toolResultCommit.parents[toolCallIndex] = agentStatusCommitId;
+        }
+      }
+      this._pendingToolResults.delete(toolCallId);
+    }
+  }
+  /**
+  * Gets the branch name for a tool call.
+  */
+  _getToolCallBranch(parentMessage, toolCallId) {
+    if (toolCallId) {
+      return toolCallId;
+    }
+    return parentMessage || "main";
+  }
+  /**
+  * Gets the parents for an AgentStatus commit.
+  */
+  _getAgentStatusParents(event) {
+    if (event.parentMessage && event.toolCallId) {
+      return [
+        getToolCallId(event.parentMessage, event.toolCallId)
+      ];
+    }
+    return [];
+  }
+  /**
+  * Checks if a commit is a tool call commit.
+  */
+  _isToolCallCommit(commit) {
+    return commit.message.includes("Calling tool");
+  }
+  /**
+  * Checks if a commit is a tool result commit.
+  */
+  _isToolResultCommit(commit) {
+    return commit.message.includes("Tool call succeeded") || commit.message.includes("Tool error:");
+  }
+  /**
+  * Extracts tool call ID from a commit ID.
+  */
+  _extractToolCallId(commitId) {
+    const toolCallMatch = commitId.match(/_toolCall_(.+)$/);
+    const toolResultMatch = commitId.match(/_toolResult_(.+)$/);
+    return toolCallMatch?.[1] || toolResultMatch?.[1];
+  }
 };
-
-// src/functions/services.ts
-import { AiTool } from "@effect/ai";
-import { Context, Effect as Effect2, Layer, Match, Predicate, Record, Schema as Schema2 } from "effect";
-import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from "@dxos/ai";
-import { LocalFunctionExecutionService } from "@dxos/functions";
-import { invariant } from "@dxos/invariant";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/assistant/src/functions/services.ts";
-var makeToolResolverFromFunctions = (functions, toolkit) => {
-  return Layer.succeed(ToolResolverService, {
-    resolve: Effect2.fn("resolveTool")(function* (id) {
-      const tool = toolkit.tools[id];
-      if (tool) {
-        return tool;
+var messageToCommits = (message, lastBlockId, toolCallIds, lastCommitByBranch, skipBlocks) => {
+  let previousBlockId = lastBlockId;
+  return message.blocks.map((block, idx) => {
+    const branch = getMessageBranch(message);
+    const parents = getBlockParents(block, previousBlockId, message, toolCallIds, lastCommitByBranch);
+    if (skipBlocks?.includes(block._tag)) {
+      return null;
+    }
+    const commit = createBlockCommit(block, message, branch, parents, idx);
+    if (commit) {
+      previousBlockId = commit.id;
+    }
+    return commit;
+  }).filter(isNonNullable2);
+};
+var getBlockParents = (block, previousBlockId, message, toolCallIds, lastCommitByBranch) => {
+  const parents = [];
+  if (block._tag === "toolResult") {
+    if (previousBlockId) {
+      parents.push(previousBlockId);
+    }
+    const toolCallCommitId = toolCallIds?.get(block.toolCallId);
+    if (toolCallCommitId) {
+      const toolCallBranch = getToolCallBranchFromCommitId(toolCallCommitId, block.toolCallId);
+      const lastBlockFromToolCallBranch = lastCommitByBranch?.get(toolCallBranch);
+      if (lastBlockFromToolCallBranch) {
+        parents.push(lastBlockFromToolCallBranch);
+      } else {
+        parents.push(toolCallCommitId);
       }
-      const fn = functions.find((f) => f.name === id);
-      if (!fn) {
-        return yield* Effect2.fail(new AiToolNotFoundError(id));
+    }
+  } else {
+    if (previousBlockId) {
+      parents.push(previousBlockId);
+    } else {
+      const toolCallParent = getParentId(message);
+      if (toolCallParent) {
+        parents.push(toolCallParent);
       }
-      return projectFunctionToTool(fn);
-    })
+    }
+  }
+  return parents;
+};
+var createBlockCommit = (block, message, branch, parents, idx) => {
+  const timestamp = new Date(message.created);
+  switch (block._tag) {
+    case "text":
+      if (!block.text.trim().length) return null;
+      return {
+        id: getGenericBlockId(message.id, idx),
+        branch,
+        parents,
+        timestamp,
+        ...message.sender.role === "user" ? {
+          icon: "ph--user--regular",
+          tags: [
+            "user"
+          ],
+          message: "Processing request..."
+        } : {
+          icon: "ph--robot--regular",
+          message: `Response (${block.text.split(" ").length} words)`
+        }
+      };
+    case "toolCall":
+      return {
+        id: getToolCallId(message.id, block.toolCallId),
+        branch,
+        parents,
+        timestamp,
+        icon: "ph--wrench--regular",
+        level: LogLevel.INFO,
+        message: `Calling tool (${block.name})`
+      };
+    case "toolResult":
+      return {
+        id: getToolResultId(message.id, block.toolCallId),
+        branch,
+        parents,
+        timestamp,
+        icon: block.error ? "ph--x-circle--regular" : "ph--check-circle--regular",
+        level: block.error ? LogLevel.ERROR : LogLevel.INFO,
+        message: block.error ? "Tool error: " + block.error : "Tool call succeeded"
+      };
+    case "summary":
+      return {
+        id: getGenericBlockId(message.id, idx),
+        branch,
+        parents,
+        timestamp,
+        icon: "ph--rocket--regular",
+        level: LogLevel.INFO,
+        message: ContentBlock.createSummaryMessage(block)
+      };
+    case "status":
+      return {
+        id: getGenericBlockId(message.id, idx),
+        branch,
+        parents,
+        timestamp,
+        message: block.statusText,
+        level: LogLevel.INFO,
+        icon: "ph--flag--regular"
+      };
+    case "reasoning":
+      return {
+        id: getGenericBlockId(message.id, idx),
+        branch,
+        parents,
+        timestamp,
+        message: block.reasoningText ?? "Thinking...",
+        icon: "ph--brain--regular"
+      };
+    case "reference":
+      return {
+        id: getGenericBlockId(message.id, idx),
+        branch,
+        parents,
+        timestamp,
+        icon: "ph--link--regular",
+        message: stringifyRef(block.reference)
+      };
+    default:
+      return null;
+  }
+};
+var getToolCallBranchFromCommitId = (toolCallCommitId, toolCallId) => {
+  const messageId = toolCallCommitId.split("_toolCall_")[0];
+  return `${messageId}_${toolCallId}`;
+};
+var getToolCallId = (messageId, toolCallId) => `${messageId}_toolCall_${toolCallId}`;
+var getToolResultId = (messageId, toolCallId) => `${messageId}_toolResult_${toolCallId}`;
+var getGenericBlockId = (messageId, idx) => `${messageId}_block_${idx}`;
+var getBranchName = (options) => {
+  if (options.toolCallId) {
+    return options.toolCallId;
+  } else if (options.parentMessage) {
+    return options.parentMessage;
+  } else {
+    return "main";
+  }
+};
+var getMessageBranch = (message) => {
+  return getBranchName({
+    parentMessage: message.parentMessage,
+    toolCallId: message.properties?.[MESSAGE_PROPERTY_TOOL_CALL_ID]
   });
 };
-var makeToolExecutionServiceFromFunctions = (functions, toolkit, handlersLayer) => {
-  return Layer.effect(ToolExecutionService, Effect2.gen(function* () {
-    const toolkitHandler = yield* toolkit.pipe(Effect2.provide(handlersLayer));
-    const localFunctionExecutionService = yield* LocalFunctionExecutionService;
+var getParentId = (message) => {
+  if (message.parentMessage && message.properties?.[MESSAGE_PROPERTY_TOOL_CALL_ID]) {
+    return getToolCallId(message.parentMessage, message.properties[MESSAGE_PROPERTY_TOOL_CALL_ID]);
+  } else {
+    return void 0;
+  }
+};
+var stringifyRef = (ref) => {
+  if (ref.target) {
+    return stringifyObject(ref.target);
+  }
+  return ref.dxn.asEchoDXN()?.echoId ?? ref.dxn.asQueueDXN()?.objectId ?? "";
+};
+var stringifyObject = (obj) => {
+  return Obj5.getLabel(obj) ?? Obj5.getTypename(obj) ?? obj.id;
+};
+
+// src/functions/services.ts
+import * as Tool from "@effect/ai/Tool";
+import * as Context3 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import * as Record from "effect/Record";
+import * as Schema3 from "effect/Schema";
+import { AiToolNotFoundError, ToolExecutionService as ToolExecutionService2, ToolResolverService as ToolResolverService2 } from "@dxos/ai";
+import { todo as todo2 } from "@dxos/debug";
+import { Query as Query2 } from "@dxos/echo";
+import { DatabaseService as DatabaseService3 } from "@dxos/echo-db";
+import { Function as Function4, FunctionDefinition, FunctionInvocationService } 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, toolkit) => {
+  return Layer2.effect(ToolResolverService2, Effect7.gen(function* () {
+    const dbService = yield* DatabaseService3;
+    return {
+      resolve: (id) => Effect7.gen(function* () {
+        const tool = toolkit.tools[id];
+        if (tool) {
+          return tool;
+        }
+        const { objects: [dbFunction] } = yield* DatabaseService3.runQuery(Query2.type(Function4.Function, {
+          key: id
+        }));
+        const functionDef = dbFunction ? FunctionDefinition.deserialize(dbFunction) : functions.find((fn2) => fn2.key === id);
+        if (!functionDef) {
+          return yield* Effect7.fail(new AiToolNotFoundError(id));
+        }
+        return projectFunctionToTool(functionDef);
+      }).pipe(Effect7.provideService(DatabaseService3, dbService))
+    };
+  }));
+};
+var makeToolExecutionServiceFromFunctions = (toolkit, handlersLayer) => {
+  return Layer2.effect(ToolExecutionService2, Effect7.gen(function* () {
+    const toolkitHandler = yield* toolkit.pipe(Effect7.provide(handlersLayer));
+    invariant2(isHandlerLike(toolkitHandler), void 0, {
+      F: __dxlog_file6,
+      L: 74,
+      S: this,
+      A: [
+        "isHandlerLike(toolkitHandler)",
+        ""
+      ]
+    });
+    const functionInvocationService = yield* FunctionInvocationService;
     return {
       handlersFor: (toolkit2) => {
         const makeHandler = (tool) => {
-          return Effect2.fn("toolFunctionHandler")(function* (input) {
-            if (toolkitHandler.tools.find((t) => t.name === tool.name)) {
-              return yield* toolkitHandler.handle(tool.name, input);
-            }
-            const { functionName } = Context.get(FunctionToolAnnotation)(tool.annotations);
-            const fnDef = functions.find((f) => f.name === functionName);
-            if (!fnDef) {
-              return yield* Effect2.fail(new AiToolNotFoundError(tool.name));
+          return Effect7.fn(`toolFunctionHandler ${tool.name}`)(function* (input) {
+            if (toolkitHandler.tools[tool.name]) {
+              if (Tool.isProviderDefined(tool)) {
+                throw new Error("Attempted to call a provider-defined tool");
+              }
+              const { result } = yield* toolkitHandler.handle(tool.name, input);
+              return result;
             }
-            return yield* localFunctionExecutionService.invokeFunction(fnDef, input).pipe(Effect2.catchAllDefect((defect) => Effect2.fail(defect)));
+            const { definition: functionDef } = Context3.get(FunctionToolAnnotation)(tool.annotations);
+            return yield* functionInvocationService.invokeFunction(functionDef, input).pipe(Effect7.catchAllDefect((defect) => Effect7.fail(defect)));
           });
         };
-        return toolkit2.of(Record.map(toolkit2.tools, (tool, _name) => makeHandler(tool)));
+        return toolkit2.of(Record.map(toolkit2.tools, (tool, _name) => Tool.isUserDefined(tool) ? makeHandler(tool) : null));
       }
     };
   }));
 };
-var FunctionToolAnnotation = class extends Context.Tag("@dxos/assisatnt/FunctionToolAnnotation")() {
+var FunctionToolAnnotation = class extends Context3.Tag("@dxos/assistant/FunctionToolAnnotation")() {
 };
 var toolCache = /* @__PURE__ */ new WeakMap();
-var projectFunctionToTool = (fn) => {
-  if (toolCache.has(fn)) {
-    return toolCache.get(fn);
+var projectFunctionToTool = (fn2) => {
+  if (toolCache.has(fn2)) {
+    return toolCache.get(fn2);
   }
-  const tool = AiTool.make(makeToolName(fn.name), {
-    description: fn.description,
-    parameters: createStructFieldsFromSchema(fn.inputSchema),
+  const tool = Tool.make(makeToolName(fn2.name), {
+    description: fn2.description,
+    parameters: createStructFieldsFromSchema(fn2.inputSchema),
     // TODO(dmaretskyi): Include output schema.
-    failure: Schema2.Any
+    failure: Schema3.Any
   }).annotate(FunctionToolAnnotation, {
-    functionName: fn.name
+    definition: fn2
   });
-  toolCache.set(fn, tool);
+  toolCache.set(fn2, tool);
   return tool;
 };
 var makeToolName = (name) => {
-  const toolName = name.replace(/[^a-zA-Z0-9]/g, "_");
-  invariant(toolName.match(/^[a-zA-Z_][a-zA-Z0-9-_]*$/), void 0, {
-    F: __dxlog_file2,
-    L: 102,
+  const toolName = name.toLowerCase().replace(/[^a-zA-Z0-9]/g, "-");
+  invariant2(toolName.match(/^[a-z_][a-z0-9-_]*$/), void 0, {
+    F: __dxlog_file6,
+    L: 144,
     S: void 0,
     A: [
-      "toolName.match(/^[a-zA-Z_][a-zA-Z0-9-_]*$/)",
+      "toolName.match(/^[a-z_][a-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,
-      Schema2.make(prop.type)
-    ]));
-  }), Match.orElseAbsurd);
+  switch (schema.ast._tag) {
+    case "TypeLiteral":
+      return Object.fromEntries(schema.ast.propertySignatures.map((prop) => [
+        prop.name,
+        Schema3.make(prop.type)
+      ]));
+    case "VoidKeyword":
+      return {};
+    default:
+      return todo2(`Unsupported schema AST: ${schema.ast._tag}`);
+  }
+};
+var isHandlerLike = (value) => {
+  return typeof value.tools === "object" && typeof value.handle === "function";
 };
 
 // src/templates/system.ts
-import { Template } from "@dxos/blueprints";
+import defaultsDeep from "lodash.defaultsdeep";
+import { Template as Template2 } from "@dxos/blueprints";
 
-// raw-loader:./format.tpl?raw
-var format_default = "{{! System Core }}\n\n## Input Formats\n\n### Blueprints\n\nYou may be provided with Blueprint definitions that include specific instructions and tools for a given set of tasks.\nBlue print instructions will be enclosed in a <blueprint> tag.\n\n### Context objects\n\nYou may be provided with references to objects that are relevant to the current prompt.\nObjects will be in the form of a <object> tag with a <dxn> element that is the unique key of the object required by many tools.\nThe <typename> element is the type of the object.\n\n<object>\n  <dxn>object-id</dxn>\n  <typename>example.com/type/TypeName</typename>\n</object>\n\n## Response Formats\n\nIt is very important to respond in the correct format.\nYou response must be valid Markdown.\nIn some cases you should respond with well-formed XML tags along with the content.\n\n{{#if cot}}\nBefore responding, explain your reasoning and include your detailed chain-of-thought enclosed in a <cot> tag.\nThe <cot> tag should be the first thing in your response.\n{{/if}}\n\n## Block references\n\nYou can reply with a block reference for objects if you have the DXN. For example:\n\n<object>\n  <dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK464FSCKVQJAB2H662M</dxn>\n</object>\n<object>\n  <dxn>dxn:echo:@:01K24XPK464FSCKVQJAB2H662M</dxn>\n</object>\n\n### Suggestions\n\nEach suggestion must in the form of a proposed action enclosed in a <suggest> tag.\nExample: <suggest>Show on a map</suggest>\n\n### Multiple choice questions\n\nYou may ask multiple choice questions by wrapping consise options inside <option> tags inside a well formed <select> tag.\nExample: <select><option>Yes</option><option>No</option></select>\n\n## Toolkit\n\nIf the user asks for a list of tools, then just emit a single self-closing <toolkit/> tag instead of listing the tools.\n";
+// raw-loader:/__w/dxos/dxos/packages/core/assistant/src/templates/instructions/format.tpl?raw
+var format_default = "{{! System Core }}\n\n## Input Formats\n\n### Blueprints\n\nYou may be provided with Blueprint definitions that include specific instructions and tools for a given set of tasks.\nBlue print instructions will be enclosed in a <blueprint> tag.\n\n### Context objects\n\nYou may be provided with references to objects that are relevant to the current prompt.\nObjects will be in the form of a <object> tag with a <dxn> element that is the unique key of the object required by many tools.\nThe <typename> element is the type of the object.\n\n<object>\n  <dxn>object-id</dxn>\n  <typename>example.com/type/TypeName</typename>\n</object>\n\n## Response Formats\n\nIt is very important to respond in the correct format.\nYou response must be valid Markdown.\nIn some cases you should respond with well-formed XML tags along with the content.\nCode snippets should use 2-space indents.\n\n{{#if cot}}\nBefore responding, explain your reasoning and include your detailed chain-of-thought enclosed in a <cot> tag.\nThe <cot> tag should be the first thing in your response.\n{{/if}}\n\n## Block references\n\nYou can reply with a block reference for objects if you have the DXN. For example:\n\n<object>\n  <dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK464FSCKVQJAB2H662M</dxn>\n</object>\n<object>\n  <dxn>dxn:echo:@:01K24XPK464FSCKVQJAB2H662M</dxn>\n</object>\n\n### Suggestions\n\nEach suggestion must in the form of a proposed action enclosed in a <suggestion> tag.\nExample: <suggestion>Show on a map</suggestion>\nDo not use bullets when listing suggestions.\n\n### Multiple choice questions\n\nYou may ask multiple choice questions by wrapping consise options inside <option> tags inside a well formed <select> tag.\nExample: <select><option>Yes</option><option>No</option></select>\n\n## Toolkit\n\nIf the user asks for a list of tools, then just emit a single self-closing <toolkit/> tag instead of listing the tools.\n\n## Context\n\nThe current date and time is {{DATETIME}}.\n";
 
-// raw-loader:./system.tpl?raw
-var system_default = "{{! System Prompt }}\n\nYou are a helpful assistant called Kai. \nYour name is Kai and you are powered by different language models.\nYou were created by DXOS and operate in Composer and on the DXOS EDGE network.\nIn your initial greeting state your name and make some suggestions based on the current context objects.\n\nYou are an advanced AI assistant capable of creating and managing artifacts from provided data and tools.\nYour task is to process user commands and questions and decide how best to respond.\nIn general be concise and direct.\n\nFollow these guidelines carefully:\n\nInclude the following steps:\n\n- Analyze the structure and type of the content in the user's message.\n- Determine if you complete the task using the available blueprint definitions?\n- If you can't complete the task using the available blueprint definitions, query the list of available blueprint definitions using the appropriate tool.\n- Identify which blueprint 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 blueprint definitions already available?\n- If not, select which blueprint 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- 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\n# Blueprints\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- 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- 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";
+// raw-loader:/__w/dxos/dxos/packages/core/assistant/src/templates/instructions/system.tpl?raw
+var system_default = "{{! System Prompt }}\n\n- You are a helpful assistant called Kai. \n- Your name is Kai and you are powered by different language models.\n- You were created by DXOS and operate inside of Composer and on the DXOS EDGE network.\n- In your initial greeting state your name and make some suggestions based on the current context objects.\n- You are an advanced AI assistant capable of creating and managing artifacts from provided data and tools.\n- Your task is to process user commands and questions and decide how best to respond.\n- In general be concise and direct.\n- Follow all instructions carefully.\n\n## Planning\n\n- Analyze the structure and type of the content in the user's message.\n- Determine if you complete the task using the available blueprint definitions?\n- If you can't complete the task using the available blueprint definitions, query the list of available blueprint definitions using the appropriate tool.\n- Identify which blueprint 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 blueprint definitions already available?\n- If not, select which blueprint 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- 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\n## Blueprints and 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- 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- 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- After creating an artifact use a tool to add it to the chat context.\n\n## Context\n\nToday is {{DATETIME}}.\n";
 
 // src/templates/system.ts
-var createSystemPrompt = (options) => Template.process(format_default, options);
+var createSystemPrompt = (options = {}) => Template2.process(format_default, defaultsDeep(options, {
+  DATETIME: (/* @__PURE__ */ new Date()).toISOString()
+}));
 var templates = {
-  // Editable system prompt.
-  system: Template.make({
+  /** Editable system prompt.*/
+  system: Template2.make({
+    /**
+    * NOTE: We are forbidden from accessing randomness at model level in cloudflare, so we have to have pre-generated ids.
+    */
+    id: "01K2J2FZWH39F55CS7B26GP1Q3",
     source: system_default
   })
 };
 
-// src/types.ts
-import { Schema as Schema3 } from "effect";
-import { DXN, LOCAL_SPACE_TAG } from "@dxos/keys";
-import { trim } from "@dxos/util";
+// src/types/artifact.ts
+import * as Schema4 from "effect/Schema";
+import { DatabaseService as DatabaseService4 } from "@dxos/echo-db";
+import { DXN as DXN2, LOCAL_SPACE_TAG } from "@dxos/keys";
+import { trim as trim2 } from "@dxos/util";
 var createArtifactElement = (id) => `<artifact id=${id} />`;
-var ArtifactId = class extends Schema3.String.annotations({
-  description: trim`
+var ArtifactId = class extends Schema4.String.annotations({
+  // TODO(dmaretskyi): This section gets overriden.
+  description: trim2`
     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)
@@ -318,37 +1239,52 @@ var ArtifactId = class extends Schema3.String.annotations({
 }) {
   static toDXN(reference, owningSpaceId) {
     if (reference.startsWith("@dxn:")) {
-      return DXN.parse(reference.slice(1));
+      return DXN2.parse(reference.slice(1));
     } else if (reference.startsWith("dxn:")) {
-      return DXN.parse(reference);
+      return DXN2.parse(reference);
     } else if (/^[A-Z0-9]+:[A-Z0-9]+$/.test(reference)) {
       const [spaceId, objectId] = reference.split(":");
-      return new DXN(DXN.kind.ECHO, [
+      return new DXN2(DXN2.kind.ECHO, [
         spaceId === owningSpaceId ? LOCAL_SPACE_TAG : spaceId,
         objectId
       ]);
     } else if (/^[A-Z0-9]+$/.test(reference)) {
-      return DXN.fromLocalObjectId(reference);
+      return DXN2.fromLocalObjectId(reference);
     } else {
       throw new Error(`Unable to parse object reference: ${reference}`);
     }
   }
+  /**
+  * Resolves an artifact ID to an object.
+  */
+  static resolve(schema, ref) {
+    const dxn = ArtifactId.toDXN(ref);
+    return DatabaseService4.resolve(dxn, schema);
+  }
 };
 export {
   AiAssistantError,
   AiContextBinder,
+  AiContextService,
   AiConversation,
+  AiModelError,
   AiSession,
   ArtifactDiffResolver,
   ArtifactId,
   Bindings,
   ContextBinding,
+  ExecutionGraph,
   GenerationObserver,
+  GenericToolkit_exports as GenericToolkit,
   VersionPin,
+  applyDiffs,
+  computeDiffsWithCursors,
   createArtifactElement,
   createSystemPrompt,
+  createToolkit,
   makeToolExecutionServiceFromFunctions,
   makeToolResolverFromFunctions,
+  reduceDiffs,
   templates
 };
 //# sourceMappingURL=index.mjs.map