@dxos/assistant 0.8.4-main.406dc2a → 0.8.4-main.548089c

package/dist/lib/browser/index.mjs

@@ -1,12 +1,6 @@
 import {
-  AiAssistantError,
-  AiModelError,
-  AiSession,
-  ArtifactDiffResolver,
-  GenerationObserver,
-  VersionPin,
-  createToolkit
-} from "./chunk-CWGVG235.mjs";
+  __export
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/conversation/context.ts
 import { computed } from "@preact/signals-core";
@@ -19,19 +13,6 @@ 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;
-}
 var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant/src/conversation/context.ts";
 var ContextBinding = Schema.Struct({
   blueprints: Schema.Struct({
@@ -48,18 +29,28 @@ var ContextBinding = Schema.Struct({
   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())
     };
   }
-  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 {
+  _queue;
+  /**
+  * Reactive query of all bindings.
+  */
+  // TODO(burdon): Cache value?
+  _bindings;
+  _blueprints;
+  _objects;
+  constructor(_queue) {
+    super(), this._queue = _queue;
+  }
   get bindings() {
     invariant(this._bindings, "AiContextBinder not open", {
       F: __dxlog_file,
@@ -173,41 +164,412 @@ var AiContextBinder = class extends Resource {
       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;
-  }
 };
 var AiContextService = class extends Context.Tag("@dxos/assistant/AiContextService")() {
 };
 
 // src/conversation/conversation.ts
-import * as Array4 from "effect/Array";
+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 { Resource as Resource2 } from "@dxos/context";
+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";
-function _define_property2(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
+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"
+      })
     });
-  } else {
-    obj[key] = value;
+    log("version", {
+      artifactDiff,
+      versions
+    }, {
+      F: __dxlog_file2,
+      L: 92,
+      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 obj;
-}
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/assistant/src/conversation/conversation.ts";
+  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;
+  /**
+  * Toolkit from the current session request.
+  */
+  _toolkit;
+  constructor(queue) {
+    super();
+    this._queue = queue;
+    this._context = new AiContextBinder(this._queue);
+  }
   async _open() {
     await this._context.open();
   }
@@ -222,31 +584,31 @@ var AiConversation = class extends Resource2 {
   }
   async getHistory() {
     const queueItems = await this._queue.queryObjects();
-    return queueItems.filter(Obj2.instanceOf(DataType.Message));
+    return queueItems.filter(Obj4.instanceOf(Message3.Message));
   }
   /**
   * Creates a new cancelable request effect.
   */
   createRequest(params) {
-    return Effect.gen(this, function* () {
+    return Effect6.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)));
+      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();
-      log("run", {
+      log3("run", {
         history: history.length,
         blueprints: blueprints.length,
         objects: objects.length,
         tools: this._toolkit?.tools.length ?? 0
       }, {
-        F: __dxlog_file2,
-        L: 111,
+        F: __dxlog_file4,
+        L: 107,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -256,44 +618,30 @@ var AiConversation = class extends Resource2 {
         objects,
         toolkit,
         ...params
-      }).pipe(Effect.provideService(AiContextService, {
+      }).pipe(Effect6.provideService(AiContextService, {
         binder: this.context
       }));
-      log("result", {
+      log3("result", {
         messages: messages.length,
         duration: Date.now() - start
       }, {
-        F: __dxlog_file2,
-        L: 125,
+        F: __dxlog_file4,
+        L: 121,
         S: this,
         C: (f, a) => f(...a)
       });
-      yield* Effect.promise(() => this._queue.append(messages));
+      yield* Effect6.promise(() => this._queue.append(messages));
       return messages;
-    }).pipe(Effect.withSpan("AiConversation.request"));
-  }
-  constructor(options) {
-    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 = options.queue;
-    this._context = new AiContextBinder(this._queue);
+    }).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 log2 } from "@dxos/log";
+import { log as log4 } from "@dxos/log";
 import { isNonNullable } from "@dxos/util";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/assistant/src/diff.ts";
+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];
@@ -345,9 +693,9 @@ 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,
+        log4.warn("diff not found", diff, {
+          F: __dxlog_file5,
+          L: 78,
           S: void 0,
           C: (f, a) => f(...a)
         });
@@ -359,34 +707,36 @@ var applyDiffs = (accessor, diffs) => {
 
 // src/execution-graph.ts
 import { AgentStatus } from "@dxos/ai";
-import { Obj as Obj3 } from "@dxos/echo";
+import { Obj as Obj5 } 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 Message4 } 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 (Obj5.instanceOf(Message4.Message, event)) {
         this._processMessage(event);
-      } else if (Obj3.instanceOf(AgentStatus, event)) {
+      } else if (Obj5.instanceOf(AgentStatus, event)) {
         this._processAgentStatus(event);
       }
     }
@@ -395,7 +745,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 +909,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;
@@ -727,49 +1072,50 @@ var stringifyRef = (ref) => {
   return ref.dxn.asEchoDXN()?.echoId ?? ref.dxn.asQueueDXN()?.objectId ?? "";
 };
 var stringifyObject = (obj) => {
-  return Obj3.getLabel(obj) ?? Obj3.getTypename(obj) ?? obj.id;
+  return Obj5.getLabel(obj) ?? Obj5.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 Context3 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import * as Layer2 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 * 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 DatabaseService2, FunctionDefinition, FunctionInvocationService, FunctionType } from "@dxos/functions";
+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_file4 = "/__w/dxos/dxos/packages/core/assistant/src/functions/services.ts";
+var __dxlog_file6 = "/__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 Layer2.effect(ToolResolverService2, Effect7.gen(function* () {
+    const dbService = yield* DatabaseService3;
     return {
-      resolve: (id) => Effect2.gen(function* () {
+      resolve: (id) => Effect7.gen(function* () {
         const tool = toolkit.tools[id];
         if (tool) {
           return tool;
         }
-        const { objects: [dbFunction] } = yield* DatabaseService2.runQuery(Query2.type(FunctionType, {
+        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* Effect2.fail(new AiToolNotFoundError(id));
+          return yield* Effect7.fail(new AiToolNotFoundError(id));
         }
         return projectFunctionToTool(functionDef);
-      }).pipe(Effect2.provideService(DatabaseService2, dbService))
+      }).pipe(Effect7.provideService(DatabaseService3, dbService))
     };
   }));
 };
 var makeToolExecutionServiceFromFunctions = (toolkit, handlersLayer) => {
-  return Layer.effect(ToolExecutionService, Effect2.gen(function* () {
-    const toolkitHandler = yield* toolkit.pipe(Effect2.provide(handlersLayer));
+  return Layer2.effect(ToolExecutionService2, Effect7.gen(function* () {
+    const toolkitHandler = yield* toolkit.pipe(Effect7.provide(handlersLayer));
     invariant2(isHandlerLike(toolkitHandler), void 0, {
-      F: __dxlog_file4,
-      L: 73,
+      F: __dxlog_file6,
+      L: 74,
       S: this,
       A: [
         "isHandlerLike(toolkitHandler)",
@@ -780,15 +1126,16 @@ var makeToolExecutionServiceFromFunctions = (toolkit, handlersLayer) => {
     return {
       handlersFor: (toolkit2) => {
         const makeHandler = (tool) => {
-          return Effect2.fn(`toolFunctionHandler ${tool.name}`)(function* (input) {
+          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");
               }
-              return yield* toolkitHandler.handle(tool.name, input);
+              const { result } = yield* toolkitHandler.handle(tool.name, input);
+              return result;
             }
-            const { definition: functionDef } = Context2.get(FunctionToolAnnotation)(tool.annotations);
-            return yield* functionInvocationService.invokeFunction(functionDef, 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) => Tool.isUserDefined(tool) ? makeHandler(tool) : null));
@@ -796,7 +1143,7 @@ var makeToolExecutionServiceFromFunctions = (toolkit, handlersLayer) => {
     };
   }));
 };
-var FunctionToolAnnotation = class extends Context2.Tag("@dxos/assistant/FunctionToolAnnotation")() {
+var FunctionToolAnnotation = class extends Context3.Tag("@dxos/assistant/FunctionToolAnnotation")() {
 };
 var toolCache = /* @__PURE__ */ new WeakMap();
 var projectFunctionToTool = (fn2) => {
@@ -807,7 +1154,7 @@ var projectFunctionToTool = (fn2) => {
     description: fn2.description,
     parameters: createStructFieldsFromSchema(fn2.inputSchema),
     // TODO(dmaretskyi): Include output schema.
-    failure: Schema2.Any
+    failure: Schema3.Any
   }).annotate(FunctionToolAnnotation, {
     definition: fn2
   });
@@ -815,13 +1162,13 @@ var projectFunctionToTool = (fn2) => {
   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,
+  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-_]*$/)",
       ""
     ]
   });
@@ -832,12 +1179,12 @@ var createStructFieldsFromSchema = (schema) => {
     case "TypeLiteral":
       return Object.fromEntries(schema.ast.propertySignatures.map((prop) => [
         prop.name,
-        Schema2.make(prop.type)
+        Schema3.make(prop.type)
       ]));
     case "VoidKeyword":
       return {};
     default:
-      return todo(`Unsupported schema AST: ${schema.ast._tag}`);
+      return todo2(`Unsupported schema AST: ${schema.ast._tag}`);
   }
 };
 var isHandlerLike = (value) => {
@@ -846,21 +1193,21 @@ var isHandlerLike = (value) => {
 
 // src/templates/system.ts
 import defaultsDeep from "lodash.defaultsdeep";
-import { Template } from "@dxos/blueprints";
+import { Template as Template2 } 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## 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/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
-var createSystemPrompt = (options = {}) => Template.process(format_default, defaultsDeep(options, {
+var createSystemPrompt = (options = {}) => Template2.process(format_default, defaultsDeep(options, {
   DATETIME: (/* @__PURE__ */ new Date()).toISOString()
 }));
 var templates = {
   /** Editable system prompt.*/
-  system: Template.make({
+  system: Template2.make({
     /**
     * NOTE: We are forbidden from accessing randomness at model level in cloudflare, so we have to have pre-generated ids.
     */
@@ -870,12 +1217,14 @@ var templates = {
 };
 
 // src/types/artifact.ts
-import * as Schema3 from "effect/Schema";
+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 } from "@dxos/util";
+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)
@@ -905,6 +1254,13 @@ var ArtifactId = class extends Schema3.String.annotations({
       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,
@@ -919,6 +1275,7 @@ export {
   ContextBinding,
   ExecutionGraph,
   GenerationObserver,
+  GenericToolkit_exports as GenericToolkit,
   VersionPin,
   applyDiffs,
   computeDiffsWithCursors,