@dxos/assistant 0.8.4-main.ead640a → 0.8.4-main.ef1bc66f44

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

@@ -3,295 +3,434 @@ import {
   AiModelError,
   AiSession,
   ArtifactDiffResolver,
+  ArtifactId,
   GenerationObserver,
+  GenericToolkit_exports,
+  RefFromLLM,
+  ToolExecutionServices,
   VersionPin,
-  createToolkit
-} from "./chunk-CWGVG235.mjs";
+  createArtifactElement,
+  createToolkit,
+  formatSystemPrompt,
+  formatUserPrompt,
+  makeToolExecutionServiceFromFunctions,
+  makeToolResolverFromFunctions
+} from "./chunk-ZPC54VRM.mjs";
+import "./chunk-J5LGTIGS.mjs";
 
 // src/conversation/context.ts
-import { computed } from "@preact/signals-core";
-import * as Array2 from "effect/Array";
+import { Atom, Registry } from "@effect-atom/atom-react";
+import * as EArray from "effect/Array";
 import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Schema from "effect/Schema";
 import { Blueprint } from "@dxos/blueprints";
 import { Resource } from "@dxos/context";
-import { DXN, Filter, Obj, Query, Type } from "@dxos/echo";
-import { invariant } from "@dxos/invariant";
-import { ComplexSet } from "@dxos/util";
-function _define_property(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
+import { DXN, Obj, Query, Type } from "@dxos/echo";
+import { assertArgument } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { ComplexSet, isTruthy } 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)),
     removed: Schema.Array(Type.Ref(Blueprint.Blueprint))
   }),
-  // TODO(burdon): Type.Expando => Type.Obj (or Obj.Any?)
   objects: Schema.Struct({
-    added: Schema.Array(Type.Ref(Type.Expando)),
-    removed: Schema.Array(Type.Ref(Type.Expando))
+    added: Schema.Array(Type.Ref(Type.Obj)),
+    removed: Schema.Array(Type.Ref(Type.Obj))
   })
-}).pipe(Type.Obj({
+}).pipe(Type.object({
   typename: "dxos.org/type/ContextBinding",
   version: "0.1.0"
 }));
 var Bindings = class {
+  blueprints = 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: Array2.fromIterable(this.blueprints).map((ref) => ref.dxn.toString()),
-      objects: Array2.fromIterable(this.objects).map((ref) => ref.dxn.toString())
+      blueprints: EArray.fromIterable(this.blueprints).map((ref) => ref.dxn.toString()),
+      objects: EArray.fromIterable(this.objects).map((ref) => ref.dxn.toString())
     };
   }
-  constructor() {
-    _define_property(this, "blueprints", new ComplexSet((ref) => ref.dxn.toString()));
-    _define_property(this, "objects", new ComplexSet((ref) => ref.dxn.asEchoDXN()?.echoId));
-  }
 };
 var AiContextBinder = class extends Resource {
-  get bindings() {
-    invariant(this._bindings, "AiContextBinder not open", {
-      F: __dxlog_file,
-      L: 78,
-      S: this,
-      A: [
-        "this._bindings",
-        "'AiContextBinder not open'"
-      ]
-    });
-    return this._bindings;
+  _blueprints = Atom.make([]).pipe(Atom.keepAlive);
+  _objects = Atom.make([]).pipe(Atom.keepAlive);
+  _registry;
+  _queue;
+  constructor(options) {
+    super();
+    assertArgument(options.queue, "options.queue", "Queue is required");
+    this._queue = options.queue;
+    this._registry = options.registry ?? Registry.make();
   }
+  /**
+  * Returns the blueprints atom for subscription.
+  */
   get blueprints() {
-    invariant(this._blueprints, "AiContextBinder not open", {
-      F: __dxlog_file,
-      L: 83,
-      S: this,
-      A: [
-        "this._blueprints",
-        "'AiContextBinder not open'"
-      ]
-    });
     return this._blueprints;
   }
+  /**
+  * Returns the objects atom for subscription.
+  */
   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.bindings.value.objects
-    ]);
+  /**
+  * Gets the current blueprints value.
+  */
+  getBlueprints() {
+    return this._registry.get(this._blueprints);
   }
-  async _close() {
-    this._bindings = void 0;
-    this._blueprints = void 0;
-    this._objects = void 0;
+  /**
+  * Gets the current objects value.
+  */
+  getObjects() {
+    return this._registry.get(this._objects);
   }
   /**
-  * Asynchronous query of all bindings.
+  * Subscribe to changes in blueprints.
   */
-  async query() {
-    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) {
-    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) {
+  subscribeBlueprints(cb) {
+    return this._registry.subscribe(this._blueprints, () => cb(this._registry.get(this._blueprints)));
+  }
+  /**
+  * Subscribe to changes in objects.
+  */
+  subscribeObjects(cb) {
+    return this._registry.subscribe(this._objects, () => cb(this._registry.get(this._objects)));
+  }
+  async _open() {
+    const query = this._queue.query(Query.type(ContextBinding));
+    const initialResults = await query.run();
+    await this._updateBindings(initialResults);
+    this._ctx.onDispose(query.subscribe(async () => {
+      await this._updateBindings(query.results);
+    }));
+  }
+  async _updateBindings(items) {
+    if (items.length === 0) {
       return;
     }
+    const bindings = this._reduce(items);
+    const currentBlueprints = this._registry.get(this._blueprints);
+    const currentObjects = this._registry.get(this._objects);
+    const newBlueprints = await this._resolve(bindings.blueprints, currentBlueprints);
+    const newObjects = await this._resolve(bindings.objects, currentObjects);
+    this._registry.set(this._blueprints, newBlueprints);
+    this._registry.set(this._objects, newObjects);
+    log("updated bindings", {
+      blueprints: newBlueprints.length,
+      objects: newObjects.length
+    }, {
+      F: __dxlog_file,
+      L: 159,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async _close() {
+    this._registry.set(this._blueprints, []);
+    this._registry.set(this._objects, []);
+  }
+  async bind({ blueprints, objects }) {
+    const currentBlueprints = this._registry.get(this._blueprints);
+    const currentObjects = this._registry.get(this._objects);
+    const { added: addedBlueprints, next: nextBlueprints } = this._processBindings(blueprints, currentBlueprints);
+    const { added: addedObjects, next: nextObjects } = this._processBindings(objects, currentObjects);
+    if (!addedBlueprints.length && !addedObjects.length) {
+      return;
+    }
+    this._registry.set(this._blueprints, nextBlueprints);
+    this._registry.set(this._objects, nextObjects);
+    log("bind", {
+      blueprints: addedBlueprints.length,
+      objects: addedObjects.length
+    }, {
+      F: __dxlog_file,
+      L: 185,
+      S: this,
+      C: (f, a) => f(...a)
+    });
     await this._queue.append([
       Obj.make(ContextBinding, {
         blueprints: {
-          added: blueprints,
+          added: addedBlueprints,
           removed: []
         },
         objects: {
-          added: objects,
+          added: addedObjects,
           removed: []
         }
       })
     ]);
   }
-  async unbind(props) {
-    if (!props.blueprints?.length && !props.objects?.length) {
+  async unbind({ blueprints, objects }) {
+    if (!blueprints?.length && !objects?.length) {
       return;
     }
+    log("unbind", {
+      blueprints: blueprints?.length,
+      objects: objects?.length
+    }, {
+      F: __dxlog_file,
+      L: 205,
+      S: this,
+      C: (f, a) => f(...a)
+    });
     await this._queue.append([
       Obj.make(ContextBinding, {
         blueprints: {
           added: [],
-          removed: props.blueprints ?? []
+          removed: blueprints ?? []
         },
         objects: {
           added: [],
-          removed: props.objects ?? []
+          removed: objects ?? []
         }
       })
     ]);
   }
+  /**
+  * Process bindings to filter duplicates and determine next state.
+  */
+  _processBindings(refs, current) {
+    const next = [
+      ...current
+    ];
+    const added = [];
+    if (!refs?.length) {
+      return {
+        added,
+        next
+      };
+    }
+    const seen = new Set(current.map((obj) => Obj.getDXN(obj).toString()));
+    for (const ref of refs) {
+      const dxn = ref.dxn.toString();
+      if (!seen.has(dxn)) {
+        seen.add(dxn);
+        added.push(ref);
+        if (ref.isAvailable) {
+          const target = ref.target;
+          if (target) {
+            next.push(target);
+          }
+        }
+      }
+    }
+    return {
+      added,
+      next
+    };
+  }
+  /**
+  * Reduce results into sets of blueprints and objects.
+  */
   _reduce(items) {
-    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) => {
+    return Function.pipe(items, EArray.reduce(new Bindings(), (context, { blueprints, objects }) => {
+      blueprints.added.forEach((ref) => context.blueprints.add(ref));
+      blueprints.removed.forEach((ref) => context.blueprints.delete(ref));
+      objects.added.forEach((ref) => context.objects.add(ref));
+      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;
     }));
   }
-  constructor(_queue) {
-    super(), _define_property(this, "_queue", void 0), /**
-    * Reactive query of all bindings.
-    */
-    // TODO(burdon): Cache value?
-    _define_property(this, "_bindings", void 0), _define_property(this, "_blueprints", void 0), _define_property(this, "_objects", void 0), this._queue = _queue;
+  /**
+  * Resolve references to objects, loading them first if needed and falling back to existing objects.
+  */
+  async _resolve(refs, current) {
+    const refArray = [
+      ...refs
+    ];
+    await Promise.all(refArray.map((ref) => ref.load()));
+    return refArray.map((ref) => {
+      let target;
+      if (ref.isAvailable) {
+        target = ref.target;
+      }
+      return target ?? current.find((obj) => Obj.getDXN(obj).toString() === ref.dxn.toString());
+    }).filter(isTruthy);
   }
 };
-var AiContextService = class extends Context.Tag("@dxos/assistant/AiContextService")() {
+var AiContextService = class _AiContextService extends Context.Tag("@dxos/assistant/AiContextService")() {
+  static bindContext = ({ blueprints, objects }) => Effect.gen(function* () {
+    const { binder } = yield* _AiContextService;
+    yield* Effect.promise(() => binder.bind({
+      blueprints,
+      objects
+    }));
+  });
+  static findObjects = (type) => {
+    return Effect.gen(function* () {
+      const { binder } = yield* _AiContextService;
+      return binder.getObjects().filter(Obj.instanceOf(type));
+    });
+  };
+  /**
+  * Glorified type cast until we figure out function service typing.
+  * For context, the AiContextService is provided to functions called from tool calls, but it's not implemented in types yet.
+  * @deprecated
+  */
+  static fixFunctionHandlerType = (eff) => eff;
 };
 
 // src/conversation/conversation.ts
-import * as Array4 from "effect/Array";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
+import * as Context2 from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import * as Layer from "effect/Layer";
 import { Resource as Resource2 } from "@dxos/context";
 import { Obj as Obj2 } from "@dxos/echo";
-import { DatabaseService } from "@dxos/functions";
-import { log } from "@dxos/log";
-import { DataType } from "@dxos/schema";
-function _define_property2(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
+import { acquireReleaseResource } from "@dxos/effect";
+import { QueueService } from "@dxos/functions";
+import { invariant } from "@dxos/invariant";
+import { log as log2 } from "@dxos/log";
+import { Message } from "@dxos/types";
 var __dxlog_file2 = "/__w/dxos/dxos/packages/core/assistant/src/conversation/conversation.ts";
 var AiConversation = class extends Resource2 {
+  /**
+  * Blueprints and objects bound to the conversation.
+  */
+  _binder;
+  _queue;
+  _toolkit;
+  constructor(options) {
+    super();
+    this._queue = options.queue;
+    this._toolkit = options.toolkit;
+    invariant(this._queue, void 0, {
+      F: __dxlog_file2,
+      L: 60,
+      S: this,
+      A: [
+        "this._queue",
+        ""
+      ]
+    });
+    this._binder = new AiContextBinder({
+      queue: this._queue,
+      registry: options.registry
+    });
+  }
   async _open() {
-    await this._context.open();
+    await this._binder.open(this._ctx);
   }
-  async _close() {
-    await this._context.close();
+  get queue() {
+    return this._queue;
   }
   get context() {
-    return this._context;
+    return this._binder;
   }
   get toolkit() {
     return this._toolkit;
   }
   async getHistory() {
     const queueItems = await this._queue.queryObjects();
-    return queueItems.filter(Obj2.instanceOf(DataType.Message));
+    return queueItems.filter(Obj2.instanceOf(Message.Message));
+  }
+  getTools() {
+    return Effect2.gen(this, function* () {
+      const blueprints = this.context.getBlueprints();
+      const tookit = yield* createToolkit({
+        toolkit: this._toolkit,
+        blueprints
+      });
+      return tookit.tools;
+    }).pipe(Effect2.orDie);
   }
   /**
   * Creates a new cancelable request effect.
   */
   createRequest(params) {
-    return Effect.gen(this, function* () {
-      const session = new AiSession();
-      const history = yield* Effect.promise(() => this.getHistory());
-      const context = yield* Effect.promise(() => this.context.query());
-      const blueprints = yield* Effect.forEach(context.blueprints.values(), DatabaseService.loadOption).pipe(Effect.map(Array4.filter(Option.isSome)), Effect.map(Array4.map((option) => option.value)));
-      const objects = yield* Effect.forEach(context.objects.values(), DatabaseService.loadOption).pipe(Effect.map(Array4.filter(Option.isSome)), Effect.map(Array4.map((option) => option.value)));
+    return Effect2.gen(this, function* () {
+      const history = yield* Effect2.promise(() => this.getHistory());
+      const blueprints = this.context.getBlueprints();
       const toolkit = yield* createToolkit({
+        toolkit: this._toolkit,
         blueprints
       });
-      this._toolkit = toolkit;
-      const start = Date.now();
-      log("run", {
+      const objects = this.context.getObjects();
+      log2("run", {
         history: history.length,
         blueprints: blueprints.length,
-        objects: objects.length,
-        tools: this._toolkit?.tools.length ?? 0
+        tools: Object.keys(toolkit.tools).length,
+        objects: objects.length
       }, {
         F: __dxlog_file2,
-        L: 107,
+        L: 112,
         S: this,
         C: (f, a) => f(...a)
       });
+      const session = new AiSession();
       const messages = yield* session.run({
         history,
         blueprints,
-        objects,
         toolkit,
+        objects,
         ...params
-      }).pipe(Effect.provideService(AiContextService, {
+      }).pipe(Effect2.provide(Layer.mergeAll(Layer.succeed(AiContextService, {
         binder: this.context
-      }));
-      log("result", {
+      }), Layer.succeed(AiConversationService, this))));
+      log2("result", {
         messages: messages.length,
-        duration: Date.now() - start
+        duration: session.duration,
+        toolCalls: session.toolCalls
       }, {
         F: __dxlog_file2,
-        L: 121,
+        L: 132,
         S: this,
         C: (f, a) => f(...a)
       });
-      yield* Effect.promise(() => this._queue.append(messages));
+      yield* Effect2.promise(() => this._queue.append(messages));
       return messages;
-    }).pipe(Effect.withSpan("AiConversation.request"));
-  }
-  constructor(queue) {
-    super(), /**
-    * Message and binding queue.
-    */
-    _define_property2(this, "_queue", void 0), /**
-    * Blueprints bound to the conversation.
-    */
-    _define_property2(this, "_context", void 0), /**
-    * Toolkit from the current session request.
-    */
-    _define_property2(this, "_toolkit", void 0);
-    this._queue = queue;
-    this._context = new AiContextBinder(this._queue);
+    });
   }
 };
+var AiConversationService = class _AiConversationService extends Context2.Tag("@dxos/assistant/AiConversationService")() {
+  /**
+  * Create a new conversation layer from options.
+  */
+  static layer = (options) => aiContextFromConversation.pipe(Layer.provideMerge(Layer.scoped(_AiConversationService, Effect2.gen(function* () {
+    const conversation = yield* acquireReleaseResource(() => new AiConversation(options));
+    return conversation;
+  }))));
+  /**
+  * Create a new conversation with a new queue.
+  */
+  static layerNewQueue = (options) => Layer.unwrapScoped(Effect2.gen(function* () {
+    return _AiConversationService.layer({
+      ...options,
+      queue: yield* QueueService.createQueue()
+    });
+  }));
+  /**
+  * Run a prompt in the current conversation.
+  */
+  static run = (params) => Effect2.gen(function* () {
+    const conversation = yield* _AiConversationService;
+    return yield* conversation.createRequest(params);
+  });
+};
+var aiContextFromConversation = Layer.effect(AiContextService, Effect2.gen(function* () {
+  const conversation = yield* AiConversationService;
+  return {
+    binder: conversation.context
+  };
+}));
 
 // src/diff.ts
 import { next as A } from "@automerge/automerge";
 import { DocAccessor, toCursorRange } from "@dxos/echo-db";
-import { log as log2 } from "@dxos/log";
+import { log as log3 } from "@dxos/log";
 import { isNonNullable } from "@dxos/util";
 var __dxlog_file3 = "/__w/dxos/dxos/packages/core/assistant/src/diff.ts";
 var reduceDiffs = (diffs) => {
@@ -321,8 +460,10 @@ var reduceDiffs = (diffs) => {
         }
         return acc;
       }
+      default: {
+        throw new Error(`Invalid diff format: each line must start with "- " or "+ ", got: ${JSON.stringify(diff)}`);
+      }
     }
-    return acc;
   }, []);
 };
 var computeDiffsWithCursors = (accessor, diffs) => {
@@ -337,7 +478,7 @@ var computeDiffsWithCursors = (accessor, diffs) => {
     }
   }).filter(isNonNullable);
 };
-var applyDiffs = (accessor, diffs) => {
+var applyDiffs = (accessor, diffs, { errorOnNotFound = false } = {}) => {
   for (const diff of reduceDiffs(diffs)) {
     accessor.handle.change((doc) => {
       const text = DocAccessor.getValue(accessor);
@@ -345,12 +486,16 @@ var applyDiffs = (accessor, diffs) => {
       if (idx !== -1) {
         A.splice(doc, accessor.path, idx, diff.match.length, diff.replace);
       } else {
-        log2.warn("diff not found", diff, {
-          F: __dxlog_file3,
-          L: 73,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
+        if (errorOnNotFound) {
+          throw new Error(`Diff not found: ${diff.match}`);
+        } else {
+          log3.warn("diff not found", diff, {
+            F: __dxlog_file3,
+            L: 86,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
       }
     });
   }
@@ -362,29 +507,31 @@ import { AgentStatus } from "@dxos/ai";
 import { Obj as Obj3 } from "@dxos/echo";
 import { MESSAGE_PROPERTY_TOOL_CALL_ID } from "@dxos/functions";
 import { LogLevel } from "@dxos/log";
-import { ContentBlock, DataType as DataType2 } from "@dxos/schema";
+import { ContentBlock, Message as Message2 } from "@dxos/types";
 import { isNonNullable as isNonNullable2 } from "@dxos/util";
-function _define_property3(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
+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 (Obj3.instanceOf(DataType2.Message, event)) {
+      if (Obj3.instanceOf(Message2.Message, event)) {
         this._processMessage(event);
       } else if (Obj3.instanceOf(AgentStatus, event)) {
         this._processAgentStatus(event);
@@ -395,7 +542,7 @@ var ExecutionGraph = class {
   * Processes a message event and creates commits for its blocks.
   */
   _processMessage(message) {
-    const messageCommits = messageToCommits(message, this._lastBlockId, this._toolCallCommitIds, this._lastCommitByBranch);
+    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);
@@ -559,20 +706,15 @@ var ExecutionGraph = class {
     const toolResultMatch = commitId.match(/_toolResult_(.+)$/);
     return toolCallMatch?.[1] || toolResultMatch?.[1];
   }
-  constructor() {
-    _define_property3(this, "_commits", []);
-    _define_property3(this, "_branchNames", /* @__PURE__ */ new Set());
-    _define_property3(this, "_lastBlockId", void 0);
-    _define_property3(this, "_toolCallCommitIds", /* @__PURE__ */ new Map());
-    _define_property3(this, "_lastCommitByBranch", /* @__PURE__ */ new Map());
-    _define_property3(this, "_pendingToolResults", /* @__PURE__ */ new Map());
-  }
 };
-var messageToCommits = (message, lastBlockId, toolCallIds, lastCommitByBranch) => {
+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;
@@ -730,128 +872,14 @@ var stringifyObject = (obj) => {
   return Obj3.getLabel(obj) ?? Obj3.getTypename(obj) ?? obj.id;
 };
 
-// src/functions/services.ts
-import * as Tool from "@effect/ai/Tool";
-import * as Context2 from "effect/Context";
-import * as Effect2 from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Record from "effect/Record";
-import * as Schema2 from "effect/Schema";
-import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from "@dxos/ai";
-import { todo } from "@dxos/debug";
-import { Query as Query2 } from "@dxos/echo";
-import { DatabaseService as DatabaseService2, FunctionDefinition, FunctionInvocationService, FunctionType } from "@dxos/functions";
-import { invariant as invariant2 } from "@dxos/invariant";
-var __dxlog_file4 = "/__w/dxos/dxos/packages/core/assistant/src/functions/services.ts";
-var makeToolResolverFromFunctions = (functions, toolkit) => {
-  return Layer.effect(ToolResolverService, Effect2.gen(function* () {
-    const dbService = yield* DatabaseService2;
-    return {
-      resolve: (id) => Effect2.gen(function* () {
-        const tool = toolkit.tools[id];
-        if (tool) {
-          return tool;
-        }
-        const { objects: [dbFunction] } = yield* DatabaseService2.runQuery(Query2.type(FunctionType, {
-          key: id
-        }));
-        const functionDef = dbFunction ? FunctionDefinition.deserialize(dbFunction) : functions.find((fn2) => fn2.key === id);
-        if (!functionDef) {
-          return yield* Effect2.fail(new AiToolNotFoundError(id));
-        }
-        return projectFunctionToTool(functionDef);
-      }).pipe(Effect2.provideService(DatabaseService2, dbService))
-    };
-  }));
-};
-var makeToolExecutionServiceFromFunctions = (toolkit, handlersLayer) => {
-  return Layer.effect(ToolExecutionService, Effect2.gen(function* () {
-    const toolkitHandler = yield* toolkit.pipe(Effect2.provide(handlersLayer));
-    invariant2(isHandlerLike(toolkitHandler), void 0, {
-      F: __dxlog_file4,
-      L: 73,
-      S: this,
-      A: [
-        "isHandlerLike(toolkitHandler)",
-        ""
-      ]
-    });
-    const functionInvocationService = yield* FunctionInvocationService;
-    return {
-      handlersFor: (toolkit2) => {
-        const makeHandler = (tool) => {
-          return Effect2.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");
-              }
-              return yield* toolkitHandler.handle(tool.name, input);
-            }
-            const { definition: functionDef } = Context2.get(FunctionToolAnnotation)(tool.annotations);
-            return yield* functionInvocationService.invokeFunction(functionDef, input).pipe(Effect2.catchAllDefect((defect) => Effect2.fail(defect)));
-          });
-        };
-        return toolkit2.of(Record.map(toolkit2.tools, (tool, _name) => Tool.isUserDefined(tool) ? makeHandler(tool) : null));
-      }
-    };
-  }));
-};
-var FunctionToolAnnotation = class extends Context2.Tag("@dxos/assistant/FunctionToolAnnotation")() {
-};
-var toolCache = /* @__PURE__ */ new WeakMap();
-var projectFunctionToTool = (fn2) => {
-  if (toolCache.has(fn2)) {
-    return toolCache.get(fn2);
-  }
-  const tool = Tool.make(makeToolName(fn2.name), {
-    description: fn2.description,
-    parameters: createStructFieldsFromSchema(fn2.inputSchema),
-    // TODO(dmaretskyi): Include output schema.
-    failure: Schema2.Any
-  }).annotate(FunctionToolAnnotation, {
-    definition: fn2
-  });
-  toolCache.set(fn2, 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_file4,
-    L: 140,
-    S: void 0,
-    A: [
-      "toolName.match(/^[a-zA-Z_][a-zA-Z0-9-_]*$/)",
-      ""
-    ]
-  });
-  return toolName;
-};
-var createStructFieldsFromSchema = (schema) => {
-  switch (schema.ast._tag) {
-    case "TypeLiteral":
-      return Object.fromEntries(schema.ast.propertySignatures.map((prop) => [
-        prop.name,
-        Schema2.make(prop.type)
-      ]));
-    case "VoidKeyword":
-      return {};
-    default:
-      return todo(`Unsupported schema AST: ${schema.ast._tag}`);
-  }
-};
-var isHandlerLike = (value) => {
-  return typeof value.tools === "object" && typeof value.handle === "function";
-};
-
 // src/templates/system.ts
 import defaultsDeep from "lodash.defaultsdeep";
 import { Template } from "@dxos/blueprints";
 
-// raw-loader:/__w/dxos/dxos/packages/core/assistant/src/templates/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>\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:/__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## Context\n\nThe current date and time is {{DATETIME}}.\n";
 
-// raw-loader:/__w/dxos/dxos/packages/core/assistant/src/templates/system.tpl?raw
+// 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
@@ -868,49 +896,12 @@ var templates = {
     source: system_default
   })
 };
-
-// src/types/artifact.ts
-import * as Schema3 from "effect/Schema";
-import { DXN as DXN2, LOCAL_SPACE_TAG } from "@dxos/keys";
-import { trim } from "@dxos/util";
-var createArtifactElement = (id) => `<artifact id=${id} />`;
-var ArtifactId = class extends Schema3.String.annotations({
-  description: trim`
-    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 DXN2.parse(reference.slice(1));
-    } else if (reference.startsWith("dxn:")) {
-      return DXN2.parse(reference);
-    } else if (/^[A-Z0-9]+:[A-Z0-9]+$/.test(reference)) {
-      const [spaceId, objectId] = reference.split(":");
-      return new DXN2(DXN2.kind.ECHO, [
-        spaceId === owningSpaceId ? LOCAL_SPACE_TAG : spaceId,
-        objectId
-      ]);
-    } else if (/^[A-Z0-9]+$/.test(reference)) {
-      return DXN2.fromLocalObjectId(reference);
-    } else {
-      throw new Error(`Unable to parse object reference: ${reference}`);
-    }
-  }
-};
 export {
   AiAssistantError,
   AiContextBinder,
   AiContextService,
   AiConversation,
+  AiConversationService,
   AiModelError,
   AiSession,
   ArtifactDiffResolver,
@@ -919,12 +910,17 @@ export {
   ContextBinding,
   ExecutionGraph,
   GenerationObserver,
+  GenericToolkit_exports as GenericToolkit,
+  RefFromLLM,
+  ToolExecutionServices,
   VersionPin,
   applyDiffs,
   computeDiffsWithCursors,
   createArtifactElement,
   createSystemPrompt,
   createToolkit,
+  formatSystemPrompt,
+  formatUserPrompt,
   makeToolExecutionServiceFromFunctions,
   makeToolResolverFromFunctions,
   reduceDiffs,