@dxos/assistant 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/dist/lib/neutral/index.mjs

@@ -1,391 +1,769 @@
 import {
-  ArtifactId,
-  RefFromLLM,
-  ToolExecutionServices,
-  createArtifactElement,
-  makeToolExecutionServiceFromFunctions,
-  makeToolResolverFromFunctions
-} from "./chunk-BE6SRJ4N.mjs";
+  __export
+} from "./chunk-J5LGTIGS.mjs";
 
-// src/conversation/context.ts
-import { Atom, Registry } from "@effect-atom/atom-react";
-import * as EArray from "effect/Array";
+// src/functions/services.ts
+import * as Tool from "@effect/ai/Tool";
 import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
+import * as Effect2 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Record from "effect/Record";
+import * as Schema4 from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from "@dxos/ai";
+import { OpaqueToolkit } from "@dxos/ai";
+import { Operation, OperationRegistry } from "@dxos/compute";
+import { todo } from "@dxos/debug";
+import { Ref as Ref2 } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+
+// src/util/artifact.ts
 import * as Schema from "effect/Schema";
-import { Blueprint } from "@dxos/blueprints";
-import { Resource } from "@dxos/context";
-import { DXN, Obj, Query, Ref, Type } from "@dxos/echo";
-import { assertArgument } from "@dxos/invariant";
+import { Database, Obj, Ref } from "@dxos/echo";
+import { EncodedReference } from "@dxos/echo-protocol";
+import { DXN, LOCAL_SPACE_TAG } from "@dxos/keys";
+import { trim } from "@dxos/util";
+var createArtifactElement = (id) => `<artifact id=${id} />`;
+var ArtifactId = class extends Schema.String.annotations({
+  // TODO(dmaretskyi): This section gets overriden.
+  description: trim`
+    The ID of the referenced object. Formats accepted:
+    - DXN (dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4). 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 (01KG7R1ZXWFMWQ4DA1Q6TN1DG4)
+  `,
+  examples: [
+    "dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4",
+    "@dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4",
+    "BM3FSHFOMJCHCG5QW7JTVKGYABD2GAA7G:01KG7R1ZXWFMWQ4DA1Q6TN1DG4",
+    "01KG7R1ZXWFMWQ4DA1Q6TN1DG4"
+  ]
+}) {
+  static toDXN(reference, owningSpaceId) {
+    if (reference.startsWith("@dxn:")) {
+      return DXN.parse(reference.slice(1));
+    } else if (reference.startsWith("dxn:")) {
+      return DXN.parse(reference);
+    } else if (/^[A-Z0-9]+:[A-Z0-9]+$/.test(reference)) {
+      const [spaceId, objectId] = reference.split(":");
+      return new DXN(DXN.kind.ECHO, [
+        spaceId === owningSpaceId ? LOCAL_SPACE_TAG : spaceId,
+        objectId
+      ]);
+    } else if (/^[A-Z0-9]+$/.test(reference)) {
+      return DXN.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 Database.resolve(dxn, schema);
+  }
+};
+var RefFromLLM = Schema.transform(ArtifactId, Ref.Ref(Obj.Unknown), {
+  decode: (fromA, fromI) => EncodedReference.fromDXN(ArtifactId.toDXN(fromA)),
+  encode: (toI, toA) => EncodedReference.toDXN(toI).toString(),
+  strict: false
+}).annotations({
+  description: ArtifactId.ast.annotations.description
+});
+
+// src/util/diff.ts
+import { next as A } from "@automerge/automerge";
+import { DocAccessor, toCursorRange } from "@dxos/echo-db";
 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(Ref.Ref(Blueprint.Blueprint)),
-    removed: Schema.Array(Ref.Ref(Blueprint.Blueprint))
-  }),
-  objects: Schema.Struct({
-    added: Schema.Array(Ref.Ref(Obj.Unknown)),
-    removed: Schema.Array(Ref.Ref(Obj.Unknown))
-  })
-}).pipe(Type.object({
-  typename: "org.dxos.type.context-binding",
-  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: EArray.fromIterable(this.blueprints).map((ref) => ref.dxn.toString()),
-      objects: EArray.fromIterable(this.objects).map((ref) => ref.dxn.toString())
-    };
+import { isNonNullable } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/assistant/src/util/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;
+      }
+      default: {
+        throw new Error(`Invalid diff format: each line must start with "- " or "+ ", got: ${JSON.stringify(diff)}`);
+      }
+    }
+  }, []);
+};
+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, { errorOnNotFound = false } = {}) => {
+  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 {
+        if (errorOnNotFound) {
+          throw new Error(`Diff not found: ${diff.match}`);
+        } else {
+          log.warn("diff not found", diff, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 71, S: void 0 });
+        }
+      }
+    });
   }
+  return DocAccessor.getValue(accessor);
 };
-var AiContextBinder = class extends Resource {
-  _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();
+
+// src/util/error-handling.ts
+import * as AiError from "@effect/ai/AiError";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import * as Effect from "effect/Effect";
+import * as Schema2 from "effect/Schema";
+
+// src/util/errors.ts
+import { BaseError } from "@dxos/errors";
+var AiModelError = class extends BaseError.extend("AiModelError", "AI model error") {
+};
+var AiAssistantError = class extends BaseError.extend("AiAssistantError", "AI assistant error") {
+};
+
+// src/util/error-handling.ts
+var AnthropicErrorResponse = Schema2.Struct({
+  type: Schema2.Literal("error"),
+  error: Schema2.Struct({
+    type: Schema2.String,
+    message: Schema2.String
+  })
+});
+var mapAiError = (err) => Effect.gen(function* () {
+  const cause = err.cause;
+  if (HttpClientError.isHttpClientError(cause) && cause.reason === "StatusCode") {
+    const body = yield* cause.response.json.pipe(Effect.flatMap(Schema2.decodeUnknown(AnthropicErrorResponse, {
+      exact: false
+    })));
+    const parsedCause = new AiModelError({
+      message: body.error.message,
+      context: {
+        model: "anthropic",
+        type: body.error.type
+      }
+    });
+    return AiError.UnknownError.make({
+      description: body.error.message,
+      module: err.module,
+      method: err.method,
+      cause: parsedCause
+    });
+  }
+  return err;
+}).pipe(Effect.catchAll(() => Effect.succeed(err)));
+
+// src/util/execution-graph.ts
+import { AgentStatus } from "@dxos/ai";
+import { Obj as Obj2 } from "@dxos/echo";
+import { MESSAGE_PROPERTY_TOOL_CALL_ID } from "@dxos/functions";
+import { LogLevel } from "@dxos/log";
+import { ContentBlock, Message } 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;
   }
   /**
-  * Returns the blueprints atom for subscription.
+  * Adds events to the graph.
   */
-  get blueprints() {
-    return this._blueprints;
+  addEvents(events) {
+    const sortedEvents = this.sortObjectsByCreated(events);
+    for (const event of sortedEvents) {
+      if (Obj2.instanceOf(Message.Message, event)) {
+        this._processMessage(event);
+      } else if (Obj2.instanceOf(AgentStatus, event)) {
+        this._processAgentStatus(event);
+      }
+    }
   }
   /**
-  * Returns the objects atom for subscription.
+  * Processes a message event and creates commits for its blocks.
   */
-  get objects() {
-    return this._objects;
+  _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;
+    }
   }
   /**
-  * Gets the current blueprints value.
+  * Processes an AgentStatus event.
   */
-  getBlueprints() {
-    return this._registry.get(this._blueprints);
+  _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);
+    }
   }
   /**
-  * Gets the current objects value.
+  * Stable sort: objects with 'created' field are sorted by it, others remain in place.
   */
-  getObjects() {
-    return this._registry.get(this._objects);
+  sortObjectsByCreated(objects) {
+    const sortedObjects = objects.slice();
+    const createdObjects = [];
+    sortedObjects.forEach((obj, idx) => {
+      if (obj && typeof obj.created === "string") {
+        createdObjects.push({
+          idx,
+          obj
+        });
+      }
+    });
+    createdObjects.sort((a, b) => {
+      const aDate = new Date(a.obj.created).getTime();
+      const bDate = new Date(b.obj.created).getTime();
+      return aDate - bDate;
+    });
+    let createdIdx = 0;
+    return sortedObjects.map((obj, _idx) => {
+      if (obj && typeof obj.created === "string") {
+        return createdObjects[createdIdx++].obj;
+      }
+      return obj;
+    });
   }
   /**
-  * Subscribe to changes in blueprints.
+  * Returns the current state of the graph.
   */
-  subscribeBlueprints(cb) {
-    return this._registry.subscribe(this._blueprints, () => cb(this._registry.get(this._blueprints)));
+  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
+    };
   }
   /**
-  * Subscribe to changes in objects.
+  * Tracks tool calls and handles pending tool result updates.
   */
-  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);
-    }));
+  _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);
+    });
   }
-  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) {
+  /**
+  * Updates pending tool results to point to an AgentStatus event.
+  */
+  _updatePendingToolResults(toolCallId, agentStatusId) {
+    const toolResultId = this._pendingToolResults.get(toolCallId);
+    if (!toolResultId) {
       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: addedBlueprints,
-          removed: []
-        },
-        objects: {
-          added: addedObjects,
-          removed: []
-        }
-      })
-    ]);
-  }
-  async unbind({ blueprints, objects }) {
-    if (!blueprints?.length && !objects?.length) {
+    const toolResultCommit = this._commits.find((c) => c.id === toolResultId);
+    if (!toolResultCommit) {
       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: blueprints ?? []
-        },
-        objects: {
-          added: [],
-          removed: objects ?? []
-        }
-      })
-    ]);
+    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);
   }
   /**
-  * Process bindings to filter duplicates and determine next state.
+  * Handles late updates when AgentStatus is processed before tool result.
   */
-  _processBindings(refs, current) {
-    const next = [
-      ...current
-    ];
-    const added = [];
-    if (!refs?.length) {
-      return {
-        added,
-        next
-      };
+  _handleLateToolResultUpdate(toolCallId, toolResultId) {
+    const toolCallCommitId = this._toolCallCommitIds.get(toolCallId);
+    if (!toolCallCommitId) {
+      return;
     }
-    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);
-          }
+    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);
     }
-    return {
-      added,
-      next
-    };
   }
   /**
-  * Reduce results into sets of blueprints and objects.
+  * Gets the branch name for a tool call.
   */
-  _reduce(items) {
-    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);
-          }
-        }
-      });
-      return context;
-    }));
+  _getToolCallBranch(parentMessage, toolCallId) {
+    if (toolCallId) {
+      return toolCallId;
+    }
+    return parentMessage || "main";
   }
   /**
-  * Resolve references to objects, loading them first if needed and falling back to existing objects.
+  * Gets the parents for an AgentStatus commit.
   */
-  async _resolve(refs, current) {
-    const refArray = [
-      ...refs
-    ];
-    await Promise.all(refArray.map((ref) => ref.tryLoad()));
-    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);
+  _getAgentStatusParents(event) {
+    if (event.parentMessage && event.toolCallId) {
+      return [
+        getToolCallId(event.parentMessage, event.toolCallId)
+      ];
+    }
+    return [];
   }
-};
-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
+  * Checks if a commit is a tool call commit.
   */
-  static fixFunctionHandlerType = (eff) => eff;
-};
-
-// src/conversation/conversation.ts
-import * as Array3 from "effect/Array";
-import * as Context3 from "effect/Context";
-import * as Effect6 from "effect/Effect";
-import * as Either from "effect/Either";
-import { pipe as pipe3 } from "effect/Function";
-import * as Layer from "effect/Layer";
-import { Resource as Resource2 } from "@dxos/context";
-import { Obj as Obj4 } from "@dxos/echo";
-import { acquireReleaseResource } from "@dxos/effect";
-import { QueueService } from "@dxos/functions";
-import { invariant } from "@dxos/invariant";
-import { log as log4 } from "@dxos/log";
-import { McpToolkit } from "@dxos/mcp-client";
-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 Effect2 from "effect/Effect";
-import * as Function2 from "effect/Function";
-var GenerationObserver = Object.freeze({
-  make: ({ onBegin = Function2.constant(Effect2.void), onPart = Function2.constant(Effect2.void), onBlock = Function2.constant(Effect2.void), onEnd = Function2.constant(Effect2.void), onMessage = Function2.constant(Effect2.void) } = {}) => ({
-    onBegin,
-    onPart,
-    onBlock,
-    onEnd,
-    onMessage
-  }),
-  noop: () => GenerationObserver.make(),
+  _isToolCallCommit(commit) {
+    return commit.message.includes("Calling tool");
+  }
   /**
-  * Debug printer to be used in unit-tests and browser devtools.
+  * Checks if a commit is a tool result commit.
   */
-  fromPrinter: (printer) => GenerationObserver.make({
-    onBlock: (block) => Effect2.sync(() => {
-      if (block.pending) {
-        return;
-      }
-      printer.printContentBlock(block);
-    }),
-    onMessage: (message) => Effect2.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 Effect4 from "effect/Effect";
-import * as Stream from "effect/Stream";
-import { AiParser, AiPreprocessor, AiSummarizer, callTool, withoutToolCallParising } from "@dxos/ai";
-import { Obj as Obj3 } from "@dxos/echo";
-import { TracingService } from "@dxos/functions";
-import { log as log3 } from "@dxos/log";
-import { Message as Message2 } from "@dxos/types";
-
-// src/session/format.ts
-import * as Effect3 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 { ObjectVersion } from "@dxos/echo-db";
-import { log as log2 } from "@dxos/log";
-import { Message } from "@dxos/types";
-import { trim } from "@dxos/util";
-
-// src/errors.ts
-import { BaseError } from "@dxos/errors";
-var AiModelError = class extends BaseError.extend("AiModelError", "AI model error") {
+  _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];
+  }
 };
-var AiAssistantError = class extends BaseError.extend("AiAssistantError", "AI assistant error") {
+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);
 };
-
-// src/session/format.ts
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/assistant/src/session/format.ts";
-var formatSystemPrompt = ({ system, blueprints = [], objects = [] }) => Effect3.gen(function* () {
-  const blueprintDefs = yield* Function3.pipe(blueprints, Effect3.forEach((blueprint) => Effect3.succeed(blueprint.instructions)), Effect3.flatMap(Effect3.forEach((template) => Effect3.gen(function* () {
-    return trim`
-            <blueprint>
-              ${yield* Template.processTemplate(template)}
-            </blueprint>
-          `;
-  }))), Effect3.map((blueprints2) => blueprints2.length > 0 ? [
-    "## Blueprints Definitions",
-    ...blueprints2
-  ].join("\n\n") : void 0));
-  const objectDefs = yield* Function3.pipe(objects, Effect3.forEach((object) => Effect3.succeed(trim`
-          <object>
-            <dxn>${Obj2.getDXN(object)}</dxn>
-            <typename>${Obj2.getTypename(object)}</typename>
-          </object>
-        `)), Effect3.map((objects2) => objects2.length > 0 ? [
-    "## Context Objects",
-    ...objects2
-  ].join("\n\n") : void 0));
-  return yield* Function3.pipe(Effect3.succeed([
-    system,
-    blueprintDefs,
-    objectDefs
-  ].filter((def) => def !== void 0)), Effect3.map((parts) => parts.join("\n\n")));
-});
-var formatUserPrompt = ({ prompt, history = [] }) => Effect3.gen(function* () {
+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);
+      }
+    }
+  } else {
+    if (previousBlockId) {
+      parents.push(previousBlockId);
+    } else {
+      const toolCallParent = getParentId(message);
+      if (toolCallParent) {
+        parents.push(toolCallParent);
+      }
+    }
+  }
+  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--drone--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 "stats":
+      return {
+        id: getGenericBlockId(message.id, idx),
+        branch,
+        parents,
+        timestamp,
+        icon: "ph--rocket--regular",
+        level: LogLevel.INFO,
+        message: ContentBlock.createStatsMessage(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 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 Obj2.getLabel(obj) ?? Obj2.getTypename(obj) ?? obj.id;
+};
+
+// src/util/tracing.ts
+import * as Schema3 from "effect/Schema";
+import { Trace } from "@dxos/compute";
+import { Obj as Obj3 } from "@dxos/echo";
+import { ContentBlock as ContentBlock2, Actor } from "@dxos/types";
+var PartialBlock = Trace.EventType("assistant.partialBlock", {
+  schema: Schema3.Struct({
+    messageId: Obj3.ID,
+    role: Actor.Role,
+    block: ContentBlock2.Any
+  }),
+  isEphemeral: true
+});
+var CompleteBlock = Trace.EventType("assistant.completeBlock", {
+  schema: Schema3.Struct({
+    messageId: Obj3.ID,
+    role: Actor.Role,
+    block: ContentBlock2.Any
+  }),
+  isEphemeral: false
+});
+var AgentRequestBegin = Trace.EventType("assistant.agentRequestBegin", {
+  schema: Schema3.Struct({}),
+  isEphemeral: false
+});
+var AgentRequestEnd = Trace.EventType("assistant.agentRequestEnd", {
+  schema: Schema3.Struct({}),
+  isEphemeral: false
+});
+var McpServerError = Trace.EventType("assistant.mcpServerError", {
+  schema: Schema3.Struct({
+    url: Schema3.String,
+    protocol: Schema3.Literal("sse", "http"),
+    message: Schema3.String
+  }),
+  isEphemeral: true
+});
+
+// src/functions/services.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/assistant/src/functions/services.ts";
+var makeToolResolverFromOperations = ({ toolkit: extraToolkit = OpaqueToolkit.empty } = {}) => {
+  return Layer.effect(ToolResolverService, Effect2.gen(function* () {
+    const toolkitProvider = yield* OpaqueToolkit.OpaqueToolkitProvider;
+    const operationRegistry = yield* OperationRegistry.Service;
+    return {
+      resolve: (id) => Effect2.gen(function* () {
+        const toolkit = OpaqueToolkit.merge(extraToolkit, toolkitProvider.getToolkit());
+        const tool = toolkit.toolkit.tools[id];
+        if (tool) {
+          return tool;
+        }
+        return yield* operationRegistry.resolve(id).pipe(Effect2.flatMap(Option.match({
+          onSome: (_) => Effect2.succeed(projectFunctionToTool(_)),
+          onNone: () => Effect2.fail(new AiToolNotFoundError(id))
+        })));
+      })
+    };
+  }));
+};
+var makeToolExecutionService = (opts) => Layer.effect(ToolExecutionService, Effect2.gen(function* () {
+  const toolkitProvider = yield* OpaqueToolkit.OpaqueToolkitProvider;
+  const toolkit = toolkitProvider.getToolkit();
+  const toolkitHandler = yield* toolkit.toolkit.pipe(Effect2.provide(toolkit.layer));
+  invariant(isHandlerLike(toolkitHandler), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 42, S: this, A: ["isHandlerLike(toolkitHandler)", ""] });
+  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");
+            }
+            const { result } = yield* toolkitHandler.handle(tool.name, input);
+            return result;
+          }
+          return yield* opts.invoke(tool, input).pipe(Effect2.catchAllDefect((defect) => Effect2.fail(defect)));
+        });
+      };
+      return toolkit2.of(Record.map(toolkit2.tools, (tool, _name) => Tool.isUserDefined(tool) ? makeHandler(tool) : null));
+    }
+  };
+}));
+var makeToolExecutionServiceFromOperationInvoker = () => {
+  return Layer.unwrapEffect(Effect2.gen(function* () {
+    const operationInvoker = yield* Operation.Service;
+    return makeToolExecutionService({
+      invoke: (tool, input) => Effect2.gen(function* () {
+        const operationDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
+        return yield* operationInvoker.invoke(operationDef, input).pipe(Effect2.orDie);
+      })
+    });
+  }));
+};
+var ToolExecutionServices = Layer.mergeAll(makeToolResolverFromOperations(), makeToolExecutionServiceFromOperationInvoker());
+var FunctionToolAnnotation = class extends Context.Tag("@dxos/assistant/FunctionToolAnnotation")() {
+};
+var getOperationFromTool = (tool) => {
+  return Context.getOption(FunctionToolAnnotation)(tool.annotations).pipe(Option.map(({ definition }) => definition));
+};
+var toolCache = /* @__PURE__ */ new WeakMap();
+var projectFunctionToTool = (fn2) => {
+  if (toolCache.has(fn2)) {
+    return toolCache.get(fn2);
+  }
+  const tool = Tool.make(makeToolName(fn2.meta.name ?? fn2.meta.key), {
+    description: fn2.meta.description,
+    parameters: createStructFieldsFromSchema(fn2.input),
+    failure: Schema4.Any
+  }).annotate(FunctionToolAnnotation, {
+    definition: fn2
+  });
+  toolCache.set(fn2, tool);
+  return tool;
+};
+var makeToolName = (name) => {
+  const toolName = name.toLowerCase().replace(/[^a-zA-Z0-9]/g, "-");
+  invariant(toolName.match(/^[a-z_][a-z0-9-_]*$/), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 100, S: void 0, A: ["toolName.match(/^[a-z_][a-z0-9-_]*$/)", ""] });
+  return toolName;
+};
+var createStructFieldsFromSchema = (schema) => {
+  switch (schema.ast._tag) {
+    case "TypeLiteral":
+      return Object.fromEntries(schema.ast.propertySignatures.map((prop) => [
+        prop.name,
+        Schema4.make(mapSchemaTypeForLLM(prop.type))
+      ]));
+    case "VoidKeyword":
+      return {};
+    default:
+      return todo(`Unsupported schema AST: ${schema.ast._tag}`);
+  }
+};
+var mapSchemaTypeForLLM = (ast) => {
+  if (Ref2.isRefType(ast)) {
+    const description = ast.annotations.description ? ast.annotations.description + "\n" + RefFromLLM.ast.annotations.description : RefFromLLM.ast.annotations.description;
+    return RefFromLLM.annotations({
+      description
+    }).ast;
+  } else if (SchemaAST.isTupleType(ast)) {
+    return new SchemaAST.TupleType(ast.elements.map((t) => new SchemaAST.OptionalType(mapSchemaTypeForLLM(t.type), t.isOptional, t.annotations)), ast.rest.map((t) => new SchemaAST.Type(mapSchemaTypeForLLM(t.type), t.annotations)), ast.isReadonly, ast.annotations);
+  } else if (SchemaAST.isTypeLiteral(ast)) {
+    return new SchemaAST.TypeLiteral(ast.propertySignatures.map((p) => new SchemaAST.PropertySignature(p.name, mapSchemaTypeForLLM(p.type), p.isOptional, p.isReadonly, p.annotations)), ast.indexSignatures, ast.annotations);
+  }
+  return ast;
+};
+var isHandlerLike = (value) => {
+  return typeof value.tools === "object" && typeof value.handle === "function";
+};
+
+// src/request/format.ts
+import * as Effect3 from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Option2 from "effect/Option";
+import { Template } from "@dxos/compute";
+import { Obj as Obj4 } from "@dxos/echo";
+import { ObjectVersion } from "@dxos/echo-db";
+import { log as log2 } from "@dxos/log";
+import { Message as Message2 } from "@dxos/types";
+import { trim as trim2 } from "@dxos/util";
+
+// src/request/artifact-diff.ts
+import * as Context2 from "effect/Context";
+var ArtifactDiffResolver = class extends Context2.Tag("@dxos/assistant/ArtifactDiffResolver")() {
+};
+
+// src/request/format.ts
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/compute/assistant/src/request/format.ts";
+var formatSystemPrompt = ({ system, blueprints = [], objects = [] }) => Effect3.gen(function* () {
+  const blueprintDefs = yield* Function.pipe(blueprints, Effect3.forEach((blueprint) => Effect3.succeed(blueprint.instructions)), Effect3.flatMap(Effect3.forEach((template) => Effect3.gen(function* () {
+    return trim2`
+            <blueprint>
+              ${yield* Template.processTemplate(template)}
+            </blueprint>
+          `;
+  }))), Effect3.map((blueprints2) => blueprints2.length > 0 ? [
+    "## Blueprints Definitions",
+    ...blueprints2
+  ].join("\n\n") : void 0));
+  const objectDefs = yield* Function.pipe(objects, Effect3.forEach((object) => Effect3.succeed(trim2`
+          <object>
+            <dxn>${Obj4.getDXN(object)}</dxn>
+            <typename>${Obj4.getTypename(object)}</typename>
+          </object>
+        `)), Effect3.map((objects2) => objects2.length > 0 ? [
+    "## Context Objects",
+    ...objects2
+  ].join("\n\n") : void 0));
+  return yield* Function.pipe(Effect3.succeed([
+    system,
+    blueprintDefs,
+    objectDefs
+  ].filter((def) => def !== void 0)), Effect3.map((parts) => parts.join("\n\n")));
+}).pipe(Effect3.withSpan("formatSystemPrompt"));
+var formatUserPrompt = ({ prompt, history = [] }) => Effect3.gen(function* () {
   const blocks = [];
   const artifactDiffResolver = yield* Effect3.serviceOption(ArtifactDiffResolver);
-  if (Option.isSome(artifactDiffResolver)) {
+  if (Option2.isSome(artifactDiffResolver)) {
     const versions = gatherObjectVersions(history);
     const artifactDiff = yield* Effect3.tryPromise({
       try: () => artifactDiffResolver.value.resolve([
@@ -401,12 +779,7 @@ var formatUserPrompt = ({ prompt, history = [] }) => Effect3.gen(function* () {
     log2("version", {
       artifactDiff,
       versions
-    }, {
-      F: __dxlog_file2,
-      L: 94,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 65, S: this });
     for (const [id, { version }] of [
       ...artifactDiff.entries()
     ]) {
@@ -424,20 +797,23 @@ var formatUserPrompt = ({ prompt, history = [] }) => Effect3.gen(function* () {
       blocks.push(createArtifactUpdateBlock(artifactDiff));
     }
   }
-  return Obj2.make(Message.Message, {
+  return Obj4.make(Message2.Message, {
     created: (/* @__PURE__ */ new Date()).toISOString(),
     sender: {
       role: "user"
     },
-    blocks: [
+    blocks: typeof prompt === "string" ? [
       ...blocks,
       {
         _tag: "text",
         text: prompt
       }
+    ] : [
+      ...blocks,
+      ...prompt
     ]
   });
-});
+}).pipe(Effect3.withSpan("formatUserPrompt"));
 var gatherObjectVersions = (messages) => {
   const artifactIds = /* @__PURE__ */ new Map();
   for (const message of messages) {
@@ -453,8 +829,8 @@ var createArtifactUpdateBlock = (artifactDiff) => {
   return {
     _tag: "text",
     // TODO(dmaretskyi): Does this need to be a special content-block?
-    disposition: "artifact-update",
-    text: trim`
+    disposition: "synthetic",
+    text: trim2`
       The following artifacts have been updated since the last message:
       ${[
       ...artifactDiff.entries()
@@ -464,153 +840,306 @@ ${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 = Effect4.runSync(Effect4.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 = [];
-  _started = 0;
-  _ended = 0;
-  _toolCalls = 0;
-  constructor(_options = {}) {
-    this._options = _options;
-  }
-  get duration() {
-    return this._ended - this._started;
-  }
-  get toolCalls() {
-    return this._toolCalls;
-  }
-  run = ({ prompt, system: systemTemplate, history = [], objects = [], blueprints = [], toolkit, observer = GenerationObserver.noop(), onOutput = () => Effect4.void }) => Effect4.gen(this, function* () {
-    this._started = Date.now();
-    this._history = [
-      ...history
-    ];
-    this._pending = [];
-    const submitMessage = (message) => Effect4.gen(this, function* () {
-      this._pending.push(message);
-      yield* observer.onMessage(message);
-      yield* TracingService.emitConverationMessage(message);
-      yield* onOutput(message);
-      return message;
-    });
-    const system = yield* formatSystemPrompt({
-      system: systemTemplate,
-      blueprints,
-      objects
-    }).pipe(Effect4.orDie);
-    if (this._options.summarizationThreshold !== void 0) {
-      const tokenCount = yield* AiPreprocessor.estimateTokens(yield* AiPreprocessor.preprocessPrompt([
-        ...this._history
-      ], {
-        system
-      }));
+// src/request/observer.ts
+import * as Effect4 from "effect/Effect";
+import * as Function2 from "effect/Function";
+var GenerationObserver = Object.freeze({
+  make: ({ onBegin = Function2.constant(Effect4.void), onPart = Function2.constant(Effect4.void), onBlock = Function2.constant(Effect4.void), onEnd = Function2.constant(Effect4.void), onMessage = Function2.constant(Effect4.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) => Effect4.sync(() => {
+      if (block.pending) {
+        return;
+      }
+      printer.printContentBlock(block);
+    }),
+    onMessage: (message) => Effect4.sync(() => {
+      if (message.sender.role === "assistant") {
+        return;
+      }
+      printer.printMessage(message);
+    })
+  })
+});
+
+// src/request/AiRequest.ts
+var AiRequest_exports = {};
+__export(AiRequest_exports, {
+  Request: () => Request
+});
+import * as LanguageModel from "@effect/ai/LanguageModel";
+import * as Array2 from "effect/Array";
+import * as Chunk from "effect/Chunk";
+import * as Effect5 from "effect/Effect";
+import { pipe as pipe2 } from "effect/Function";
+import * as Option3 from "effect/Option";
+import * as Stream from "effect/Stream";
+import { AiParser, AiPreprocessor, AiSummarizer, callTool, withoutToolCallParising } from "@dxos/ai";
+import { Trace as Trace2 } from "@dxos/compute";
+import { Obj as Obj5 } from "@dxos/echo";
+import { log as log3 } from "@dxos/log";
+import { ContentBlock as ContentBlock3, Message as Message3 } from "@dxos/types";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/compute/assistant/src/request/AiRequest.ts";
+var Request = class {
+  _options;
+  /** Prevents concurrent execution of session. */
+  _semaphore = Effect5.runSync(Effect5.makeSemaphore(1));
+  _observer;
+  _onOutput;
+  /** 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 = [];
+  _started = 0;
+  _ended = 0;
+  _toolCalls = 0;
+  constructor(_options = {}) {
+    this._options = _options;
+    this._observer = _options.observer ?? GenerationObserver.noop();
+    this._onOutput = _options.onOutput ?? (() => Effect5.void);
+  }
+  get duration() {
+    return this._ended - this._started;
+  }
+  get toolCalls() {
+    return this._toolCalls;
+  }
+  get pending() {
+    return this._pending;
+  }
+  _submitMessage = (message) => Effect5.gen(this, function* () {
+    this._pending.push(message);
+    yield* this._observer.onMessage(message);
+    for (const block of message.blocks) {
+      log3("write complete block", {
+        messageId: message.id,
+        role: message.sender.role,
+        block: JSON.stringify(block)
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 59, S: this });
+      yield* Trace2.write(CompleteBlock, {
+        messageId: message.id,
+        role: message.sender.role,
+        block
+      });
+    }
+    yield* this._onOutput(message);
+    return message;
+  });
+  getToolCalls = () => pipe2([
+    ...this._history,
+    ...this._pending
+  ], Array2.reverse, Array2.takeWhile((_) => _.sender.role === "assistant"), Array2.flatMap((_) => _.blocks.filter(ContentBlock3.is("toolCall")).map((block) => ({
+    block,
+    message: _
+  }))), Array2.filter((_) => !_.block.providerExecuted), Array2.reverse);
+  /**
+  * Initialize a session: set up history, perform summarization if needed, and submit the user prompt.
+  * Must be called before `runTurn()`.
+  */
+  begin = ({ prompt, system, history = [], blueprints = [], objects = [] }) => Effect5.gen(this, function* () {
+    this._started = Date.now();
+    this._history = [
+      ...history
+    ];
+    this._pending = [];
+    const systemPrompt = yield* formatSystemPrompt({
+      system,
+      blueprints,
+      objects
+    }).pipe(Effect5.orDie);
+    if (this._options.summarizationThreshold !== void 0) {
+      const tokenCount = yield* AiPreprocessor.estimateTokens(yield* AiPreprocessor.preprocessPrompt([
+        ...this._history
+      ], {
+        system: systemPrompt
+      }));
       if (tokenCount > this._options.summarizationThreshold) {
         const summary = yield* AiSummarizer.summarize([
           ...this._history
         ]);
-        yield* submitMessage(summary);
+        yield* this._submitMessage(summary);
       }
     }
-    const promptMessage = yield* submitMessage(yield* formatUserPrompt({
+    yield* this._submitMessage(yield* formatUserPrompt({
       prompt,
       history
     }));
+  }).pipe(Effect5.withSpan("AiRequest.begin"));
+  /**
+  * Execute a single turn: one LLM generation followed by tool execution.
+  * The toolkit and system prompt can be updated between turns to reflect context changes (e.g. dynamically enabled blueprints).
+  */
+  runAgentTurn = ({ system, toolkit: opaqueToolkit }) => Effect5.gen(this, function* () {
+    log3.info("request", {
+      system: {
+        snippet: createSnippet(system),
+        length: system.length
+      },
+      pending: this._pending.length,
+      history: this._history.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 116, S: this });
+    const prompt = yield* AiPreprocessor.preprocessPrompt([
+      ...this._history,
+      ...this._pending
+    ], {
+      system,
+      cacheControl: "ephemeral"
+    });
+    const toolkit = opaqueToolkit ? yield* opaqueToolkit.handlers : void 0;
+    const observer = this._observer;
+    let currentMessageId = null;
+    const messages = yield* LanguageModel.streamText({
+      prompt,
+      toolkit,
+      disableToolCallResolution: true
+    }).pipe(withoutToolCallParising, AiParser.parseResponse({
+      emitPartial: true,
+      onBegin: () => observer.onBegin(),
+      onBlock: (block) => observer.onBlock(block),
+      onPart: (part) => observer.onPart(part),
+      onEnd: (summary) => observer.onEnd(summary)
+    }), Stream.map((block) => enrichToolCallBlock(block, toolkit)), Stream.mapEffect((block) => Effect5.gen(this, function* () {
+      if (block.pending) {
+        currentMessageId ??= Obj5.ID.random();
+        log3("emit ephemeral message", {
+          id: currentMessageId,
+          type: block._tag
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 147, S: this });
+        yield* Trace2.write(PartialBlock, {
+          messageId: currentMessageId,
+          role: "assistant",
+          block
+        });
+        return Option3.none();
+      } else {
+        currentMessageId ??= Obj5.ID.random();
+        const id = currentMessageId;
+        currentMessageId = null;
+        log3("emit complete message", {
+          id,
+          type: block._tag
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 161, S: this });
+        const message = Obj5.make(Message3.Message, {
+          id,
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          sender: {
+            role: "assistant"
+          },
+          blocks: [
+            block
+          ]
+        });
+        return Option3.some(yield* this._submitMessage(message));
+      }
+    }), {
+      concurrency: 1,
+      unordered: false
+    }), Stream.filterMap((_) => _), Stream.runCollect, Effect5.map(Chunk.toArray));
+    log3.info("messages", {
+      messages
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 181, S: this });
+    const toolCalls = this.getToolCalls();
+    if (toolCalls.length === 0) {
+      this._ended = Date.now();
+      return {
+        messages,
+        done: true
+      };
+    } else if (!toolkit) {
+      throw new Error("No toolkit provided");
+    }
+    return {
+      messages,
+      done: false
+    };
+  }).pipe(Effect5.withSpan("AiRequest.runAgentTurn"));
+  runTools = ({ toolkit: opaqueToolkit }) => Effect5.gen(this, function* () {
+    const toolkit = opaqueToolkit ? yield* opaqueToolkit.handlers : void 0;
+    const toolCalls = this.getToolCalls();
+    const toolResults = yield* Effect5.forEach(toolCalls, ({ block, message }) => {
+      if (!toolkit) {
+        throw new Error("No toolkit provided");
+      }
+      return callTool(toolkit, block);
+    });
+    yield* this._submitMessage(Obj5.make(Message3.Message, {
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      sender: {
+        role: "tool"
+      },
+      blocks: toolResults
+    }));
+    this._toolCalls += toolResults.length;
+  }).pipe(Effect5.withSpan("AiRequest.runTools"));
+  /**
+  * Run a full conversation turn loop. Equivalent to calling `begin()` then `runTurn()` in a loop.
+  */
+  run = ({ prompt, system: systemTemplate, history = [], objects = [], blueprints = [], toolkit }) => Effect5.gen(this, function* () {
+    yield* this.begin({
+      prompt,
+      system: systemTemplate,
+      history,
+      objects,
+      blueprints
+    });
+    const system = yield* formatSystemPrompt({
+      system: systemTemplate,
+      blueprints,
+      objects
+    }).pipe(Effect5.orDie);
     do {
-      log3("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: 149,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const prompt2 = yield* AiPreprocessor.preprocessPrompt([
-        ...this._history,
-        ...this._pending
-      ], {
+      const { done } = yield* this.runAgentTurn({
         system,
-        cacheControl: "ephemeral"
+        toolkit
       });
-      const messages = yield* LanguageModel.streamText({
-        prompt: prompt2,
-        toolkit,
-        disableToolCallResolution: true
-      }).pipe(
-        // Disable tool call parsing so that we can handle parameter schema errors on a per-tool call basis.
-        withoutToolCallParising,
-        // 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.mapEffect((block) => Effect4.gen(function* () {
-          return yield* submitMessage(Obj3.make(Message2.Message, {
-            created: (/* @__PURE__ */ new Date()).toISOString(),
-            sender: {
-              role: "assistant"
-            },
-            blocks: [
-              block
-            ]
-          }));
-        })),
-        Stream.runCollect,
-        Effect4.map(Chunk.toArray)
-      );
-      const toolCalls = messages.flatMap((message) => message.blocks.filter((block) => block._tag === "toolCall" && block.providerExecuted === false).map((block) => ({
-        block,
-        message
-      })));
-      if (toolCalls.length === 0) {
+      if (done) {
         break;
-      } else if (!toolkit) {
-        throw new Error("No toolkit provided");
       }
-      const toolResults = yield* Effect4.forEach(toolCalls, ({ block, message }) => {
-        return callTool(toolkit, block).pipe(Effect4.provide(TracingService.layerSubframe((context) => ({
-          ...context,
-          parentMessage: message.id,
-          toolCallId: block.toolCallId
-        }))));
+      yield* this.runTools({
+        toolkit
       });
-      yield* submitMessage(Obj3.make(Message2.Message, {
-        created: (/* @__PURE__ */ new Date()).toISOString(),
-        sender: {
-          role: "tool"
-        },
-        blocks: toolResults
-      }));
-      this._toolCalls++;
     } while (true);
-    this._ended = Date.now();
     log3("done", {
       pending: this._pending.length,
       duration: this.duration,
       tools: this._toolCalls
-    }, {
-      F: __dxlog_file3,
-      L: 236,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 244, S: this });
     return this._pending;
-  }).pipe(this._semaphore.withPermits(1), Effect4.withSpan("AiSession.run"));
+  }).pipe(this._semaphore.withPermits(1), Effect5.withSpan("AiRequest.run"));
+};
+var enrichToolCallBlock = (block, toolkit) => {
+  if (block._tag !== "toolCall" || !toolkit) {
+    return block;
+  }
+  const tool = toolkit.tools[block.name];
+  if (!tool) {
+    return block;
+  }
+  let operationOpt;
+  try {
+    operationOpt = getOperationFromTool(tool);
+  } catch {
+    return block;
+  }
+  if (Option3.isNone(operationOpt)) {
+    return block;
+  }
+  const { meta } = operationOpt.value;
+  return {
+    ...block,
+    operationKey: meta.key,
+    operationName: meta.name
+  };
 };
 var createSnippet = (text, len = 32) => text.length <= len * 2 ? text : [
   text.slice(0, len),
@@ -620,699 +1149,618 @@ var createSnippet = (text, len = 32) => text.length <= len * 2 ? text : [
 
 // src/session/toolkit.ts
 import * as Toolkit from "@effect/ai/Toolkit";
-import * as Effect5 from "effect/Effect";
-import { GenericToolkit, ToolExecutionService, ToolResolverService } from "@dxos/ai";
-import { isTruthy as isTruthy2 } from "@dxos/util";
-var createToolkit = ({ toolkit: toolkitProp, blueprints = [], genericToolkits = [] }) => Effect5.gen(function* () {
-  const blueprintToolkit = yield* ToolResolverService.resolveToolkit(blueprints.flatMap(({ tools }) => tools));
-  const blueprintToolHandler = yield* blueprintToolkit.toContext(ToolExecutionService.handlersFor(blueprintToolkit));
-  const genericToolkit = GenericToolkit.merge(...genericToolkits);
-  const toolkit = Toolkit.merge(...[
-    toolkitProp,
+import * as Effect6 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import { OpaqueToolkit as OpaqueToolkit2, ToolExecutionService as ToolExecutionService2, ToolResolverService as ToolResolverService2 } from "@dxos/ai";
+import { isTruthy } from "@dxos/util";
+var createToolkit = ({ toolkit: toolkitProp, blueprints = [], opaqueToolkits = [] }) => Effect6.gen(function* () {
+  const blueprintToolkit = yield* ToolResolverService2.resolveToolkit(blueprints.flatMap(({ tools }) => tools));
+  const blueprintToolHandler = yield* blueprintToolkit.toContext(ToolExecutionService2.handlersFor(blueprintToolkit));
+  const opaqueToolkit = OpaqueToolkit2.merge(...opaqueToolkits);
+  const toolkitDefs = [
+    toolkitProp?.toolkit,
     blueprintToolkit,
-    genericToolkit.toolkit
-  ].filter(isTruthy2));
-  return yield* toolkit.pipe(Effect5.provide(blueprintToolHandler), Effect5.provide(genericToolkit.layer));
+    opaqueToolkit.toolkit
+  ].filter(isTruthy);
+  const mergedToolkit = Toolkit.merge(...toolkitDefs);
+  const combinedHandlerLayer = Layer2.mergeAll(Layer2.succeedContext(blueprintToolHandler), toolkitProp?.layer ?? OpaqueToolkit2.empty.layer, opaqueToolkit.layer);
+  return OpaqueToolkit2.make(mergedToolkit, combinedHandlerLayer);
 });
 
-// src/session/version-pin.ts
-import * as Schema2 from "effect/Schema";
-import { getVersion } from "@dxos/echo-db";
-import { ObjectId } from "@dxos/keys";
-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
+// src/session/AiContext.ts
+var AiContext_exports = {};
+__export(AiContext_exports, {
+  Binder: () => Binder,
+  Binding: () => Binding,
+  Bindings: () => Bindings,
+  Service: () => Service
 });
-var VersionPin = class extends VersionPinSchema {
-  static DISPOSITION = "version-pin";
-  static fromObject(object) {
-    return VersionPin.make({
-      objectId: object.id,
-      version: getVersion(object)
-    });
-  }
-  static createBlock(pin) {
+import { Atom, Registry } from "@effect-atom/atom-react";
+import * as EArray from "effect/Array";
+import * as Context3 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import * as Function3 from "effect/Function";
+import * as Runtime from "effect/Runtime";
+import * as Schema5 from "effect/Schema";
+import { Blueprint } from "@dxos/compute";
+import { Resource } from "@dxos/context";
+import { DXN as DXN2, Feed, Obj as Obj6, Query, Ref as Ref3, Type as Type2 } from "@dxos/echo";
+import { assertArgument } from "@dxos/invariant";
+import { log as log4 } from "@dxos/log";
+import { ComplexSet, isNonNullable as isNonNullable3 } from "@dxos/util";
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/compute/assistant/src/session/AiContext.ts";
+var Binding = Schema5.Struct({
+  blueprints: Schema5.Struct({
+    added: Schema5.Array(Ref3.Ref(Blueprint.Blueprint)),
+    removed: Schema5.Array(Ref3.Ref(Blueprint.Blueprint))
+  }),
+  objects: Schema5.Struct({
+    added: Schema5.Array(Ref3.Ref(Obj6.Unknown)),
+    removed: Schema5.Array(Ref3.Ref(Obj6.Unknown))
+  })
+}).pipe(Type2.object({
+  typename: "org.dxos.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 {
-      _tag: "json",
-      disposition: VersionPin.DISPOSITION,
-      data: JSON.stringify(pin)
+      blueprints: EArray.fromIterable(this.blueprints).map((ref) => ref.dxn.toString()),
+      objects: EArray.fromIterable(this.objects).map((ref) => ref.dxn.toString())
     };
   }
 };
-
-// src/conversation/conversation.ts
-var __dxlog_file4 = "/__w/dxos/dxos/packages/core/assistant/src/conversation/conversation.ts";
-var SUMMARY_THRESHOLD = 8e4;
-var AiConversation = class extends Resource2 {
-  /**
-  * Blueprints and objects bound to the conversation.
-  */
-  _binder;
-  _queue;
-  _toolkit;
+var Binder = class extends Resource {
+  _blueprints = Atom.make([]).pipe(Atom.keepAlive);
+  _objects = Atom.make([]).pipe(Atom.keepAlive);
+  _registry;
+  _feed;
+  _runtime;
+  #bindingsQuery;
   constructor(options) {
     super();
-    this._queue = options.queue;
-    this._toolkit = options.toolkit;
-    invariant(this._queue, void 0, {
-      F: __dxlog_file4,
-      L: 72,
-      S: this,
-      A: [
-        "this._queue",
-        ""
-      ]
-    });
-    this._binder = new AiContextBinder({
-      queue: this._queue,
-      registry: options.registry
-    });
-  }
-  async _open() {
-    await this._binder.open(this._ctx);
-  }
-  get queue() {
-    return this._queue;
-  }
-  get context() {
-    return this._binder;
+    assertArgument(options.feed, "options.feed", "Feed is required");
+    assertArgument(options.runtime, "options.runtime", "Feed runtime is required");
+    this._feed = options.feed;
+    this._runtime = options.runtime;
+    this._registry = options.registry ?? Registry.make();
   }
-  get toolkit() {
-    return this._toolkit;
+  /**
+  * Returns the blueprints atom for subscription.
+  */
+  get blueprints() {
+    return this._blueprints;
   }
-  async getHistory() {
-    const queueItems = await this._queue.queryObjects();
-    return queueItems.filter(Obj4.instanceOf(Message3.Message));
+  /**
+  * Returns the objects atom for subscription.
+  */
+  get objects() {
+    return this._objects;
   }
-  getTools() {
-    return Effect6.gen(this, function* () {
-      const blueprints = this.context.getBlueprints();
-      const tookit = yield* createToolkit({
-        toolkit: this._toolkit,
-        blueprints
-      });
-      return tookit.tools;
-    }).pipe(Effect6.orDie);
+  /**
+  * Gets the current blueprints value.
+  */
+  getBlueprints() {
+    return this._registry.get(this._blueprints);
   }
   /**
-  * Creates a new cancelable request effect.
+  * Gets the current objects value.
   */
-  createRequest(params) {
-    return Effect6.gen(this, function* () {
-      const history = yield* Effect6.promise(() => this.getHistory());
-      const blueprints = this.context.getBlueprints();
-      const mcps = yield* connectMcpServers(blueprints);
-      const toolkit = yield* createToolkit({
-        toolkit: this._toolkit,
-        blueprints,
-        genericToolkits: mcps
-      });
-      const objects = this.context.getObjects();
-      log4("run", {
-        history: history.length,
-        blueprints: blueprints.length,
-        tools: Object.keys(toolkit.tools).length,
-        objects: objects.length
-      }, {
-        F: __dxlog_file4,
-        L: 128,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const session = new AiSession({
-        summarizationThreshold: SUMMARY_THRESHOLD
-      });
-      const messages = yield* session.run({
-        history,
-        blueprints,
-        toolkit,
-        objects,
-        ...params,
-        onOutput: (message) => Effect6.promise(() => this._queue.append([
-          message
-        ]))
-      }).pipe(Effect6.provide(Layer.mergeAll(Layer.succeed(AiContextService, {
-        binder: this.context
-      }), Layer.succeed(AiConversationService, this))));
-      log4("result", {
-        messages: messages.length,
-        duration: session.duration,
-        toolCalls: session.toolCalls
-      }, {
-        F: __dxlog_file4,
-        L: 159,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return messages;
-    });
+  getObjects() {
+    return this._registry.get(this._objects);
   }
-};
-var AiConversationService = class _AiConversationService extends Context3.Tag("@dxos/assistant/AiConversationService")() {
   /**
-  * Create a new conversation layer from options.
+  * Subscribe to changes in blueprints.
   */
-  static layer = (options) => aiContextFromConversation.pipe(Layer.provideMerge(Layer.scoped(_AiConversationService, Effect6.gen(function* () {
-    const conversation = yield* acquireReleaseResource(() => new AiConversation(options));
-    return conversation;
-  }))));
+  subscribeBlueprints(cb) {
+    return this._registry.subscribe(this._blueprints, () => cb(this._registry.get(this._blueprints)));
+  }
   /**
-  * Create a new conversation with a new queue.
+  * Subscribe to changes in objects.
   */
-  static layerNewQueue = (options) => Layer.unwrapScoped(Effect6.gen(function* () {
-    return _AiConversationService.layer({
-      ...options,
-      queue: yield* QueueService.createQueue()
-    });
-  }));
+  subscribeObjects(cb) {
+    return this._registry.subscribe(this._objects, () => cb(this._registry.get(this._objects)));
+  }
+  async _open() {
+    this.#bindingsQuery = await Runtime.runPromise(this._runtime)(Feed.query(this._feed, Query.type(Binding)));
+    const initialResults = await this.#bindingsQuery.run();
+    await this._updateBindings(initialResults);
+    this._ctx.onDispose(this.#bindingsQuery.subscribe(async () => {
+      await this._updateBindings(this.#bindingsQuery.results);
+    }));
+  }
   /**
-  * Run a prompt in the current conversation.
+  * Re-reads bindings from the feed to pick up changes made by other processes.
   */
-  static run = (params) => Effect6.gen(function* () {
-    const conversation = yield* _AiConversationService;
-    return yield* conversation.createRequest(params);
-  });
-};
-var aiContextFromConversation = Layer.effect(AiContextService, Effect6.gen(function* () {
-  const conversation = yield* AiConversationService;
-  return {
-    binder: conversation.context
-  };
-}));
-var connectMcpServers = (blueprints) => pipe3(blueprints, Array3.flatMap((_) => _.mcpServers ?? []), Effect6.forEach(({ url, protocol }) => McpToolkit.make({
-  url,
-  kind: protocol
-}).pipe(
-  // NOTE: Type-inference fails here without explicit void return.
-  Effect6.tap((toolkit) => log4.info("Connected to MCP server", {
-    url,
-    tools: Object.keys(toolkit.toolkit.tools).length
-  }, {
-    F: __dxlog_file4,
-    L: 240,
-    S: void 0,
-    C: (f, a) => f(...a)
-  })),
-  Effect6.tapDefect((error) => Effect6.sync(() => log4.warn("Failed to connect to MCP server", {
-    error
-  }, {
-    F: __dxlog_file4,
-    L: 242,
-    S: void 0,
-    C: (f, a) => f(...a)
-  }))),
-  Effect6.either
-)), Effect6.map(Array3.filterMap((_) => Either.getRight(_))));
-
-// src/diff.ts
-import { next as A } from "@automerge/automerge";
-import { DocAccessor, toCursorRange } from "@dxos/echo-db";
-import { log as log5 } 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;
-      }
-      default: {
-        throw new Error(`Invalid diff format: each line must start with "- " or "+ ", got: ${JSON.stringify(diff)}`);
-      }
+  async sync() {
+    if (this.#bindingsQuery) {
+      const results = await this.#bindingsQuery.run();
+      log4("sync", {
+        bindingItems: results.length
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 107, S: this });
+      await this._updateBindings(results);
+      log4("sync complete", {
+        blueprints: this._registry.get(this._blueprints).length,
+        blueprintKeys: this._registry.get(this._blueprints).map((bp) => Blueprint.getKey(bp))
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 111, S: this });
     }
-  }, []);
-};
-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
-      };
+  }
+  async _updateBindings(items) {
+    if (items.length === 0) {
+      return;
     }
-  }).filter(isNonNullable);
-};
-var applyDiffs = (accessor, diffs, { errorOnNotFound = false } = {}) => {
-  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 {
-        if (errorOnNotFound) {
-          throw new Error(`Diff not found: ${diff.match}`);
-        } else {
-          log5.warn("diff not found", diff, {
-            F: __dxlog_file5,
-            L: 86,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
+    const bindings = this._reduce(items);
+    log4("_updateBindings", {
+      items: items.length,
+      blueprintRefs: [
+        ...bindings.blueprints
+      ].map((ref) => ({
+        dxn: ref.dxn.toString(),
+        available: ref.isAvailable
+      }))
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 123, S: this });
+    const currentBlueprints = this._registry.get(this._blueprints);
+    const currentObjects = this._registry.get(this._objects);
+    const resolvedBlueprints = await this._resolve(bindings.blueprints, currentBlueprints);
+    const resolvedObjects = await this._resolve(bindings.objects, currentObjects);
+    log4("_updateBindings resolved", {
+      resolvedBlueprints: resolvedBlueprints.length,
+      resolvedBlueprintKeys: resolvedBlueprints.map((bp) => Blueprint.getKey(bp))
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 137, S: this });
+    const reducedBlueprintDxns = new ComplexSet(DXN2.hash, [
+      ...bindings.blueprints
+    ].map((ref) => ref.dxn));
+    const reducedObjectDxns = new ComplexSet(DXN2.hash, [
+      ...bindings.objects
+    ].map((ref) => ref.dxn));
+    const filteredBlueprints = currentBlueprints.filter((obj) => reducedBlueprintDxns.has(Obj6.getDXN(obj)));
+    const filteredObjects = currentObjects.filter((obj) => reducedObjectDxns.has(Obj6.getDXN(obj)));
+    const mergedBlueprints = this._mergeInto(filteredBlueprints, resolvedBlueprints);
+    const mergedObjects = this._mergeInto(filteredObjects, resolvedObjects);
+    this._registry.set(this._blueprints, mergedBlueprints);
+    this._registry.set(this._objects, mergedObjects);
+    log4("updated bindings", {
+      blueprints: mergedBlueprints.length,
+      objects: mergedObjects.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 155, S: this });
+  }
+  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);
+    log4("bind", {
+      blueprints: addedBlueprints.length,
+      objects: addedObjects.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 176, S: this });
+    await Runtime.runPromise(this._runtime)(Feed.append(this._feed, [
+      Obj6.make(Binding, {
+        blueprints: {
+          added: addedBlueprints,
+          removed: []
+        },
+        objects: {
+          added: addedObjects,
+          removed: []
         }
-      }
-    });
+      })
+    ]));
   }
-  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;
+  async unbind({ blueprints, objects }) {
+    if (!blueprints?.length && !objects?.length) {
+      return;
+    }
+    const removedBlueprintDxns = (blueprints ?? []).map((ref) => ref.dxn);
+    const removedObjectDxns = (objects ?? []).map((ref) => ref.dxn);
+    if (removedBlueprintDxns.length > 0) {
+      const current = this._registry.get(this._blueprints);
+      this._registry.set(this._blueprints, current.filter((obj) => !removedBlueprintDxns.some((dxn) => DXN2.equalsEchoId(Obj6.getDXN(obj), dxn))));
+    }
+    if (removedObjectDxns.length > 0) {
+      const current = this._registry.get(this._objects);
+      this._registry.set(this._objects, current.filter((obj) => !removedObjectDxns.some((dxn) => DXN2.equalsEchoId(Obj6.getDXN(obj), dxn))));
+    }
+    log4("unbind", {
+      blueprints: blueprints?.length,
+      objects: objects?.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 208, S: this });
+    await Runtime.runPromise(this._runtime)(Feed.append(this._feed, [
+      Obj6.make(Binding, {
+        blueprints: {
+          added: [],
+          removed: blueprints ?? []
+        },
+        objects: {
+          added: [],
+          removed: objects ?? []
+        }
+      })
+    ]));
   }
   /**
-  * Adds events to the graph.
+  * Process bindings to filter duplicates and determine next state.
   */
-  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);
+  _processBindings(refs, current) {
+    const next = [
+      ...current
+    ];
+    const added = [];
+    if (!refs?.length) {
+      return {
+        added,
+        next
+      };
+    }
+    const seen = new Set(current.map((obj) => Obj6.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
+    };
   }
   /**
-  * Processes a message event and creates commits for its blocks.
+  * Reduce results into sets of blueprints and objects.
   */
-  _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;
-    }
+  _reduce(items) {
+    return Function3.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 (DXN2.equalsEchoId(obj.dxn, ref.dxn)) {
+            context.objects.delete(obj);
+          }
+        }
+      });
+      return context;
+    }));
   }
   /**
-  * Processes an AgentStatus event.
+  * Merge resolved items into the current set, adding only items not already present (by DXN).
   */
-  _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);
+  _mergeInto(current, resolved) {
+    const seen = new Set(current.map((obj) => Obj6.getDXN(obj).toString()));
+    const merged = [
+      ...current
+    ];
+    for (const obj of resolved) {
+      const dxn = Obj6.getDXN(obj).toString();
+      if (!seen.has(dxn)) {
+        seen.add(dxn);
+        merged.push(obj);
+      }
     }
+    return merged;
   }
   /**
-  * Stable sort: objects with 'created' field are sorted by it, others remain in place.
+  * Resolve references to objects, loading them first if needed and falling back to existing objects.
   */
-  sortObjectsByCreated(objects) {
-    const sortedObjects = objects.slice();
-    const createdObjects = [];
-    sortedObjects.forEach((obj, idx) => {
-      if (obj && typeof obj.created === "string") {
-        createdObjects.push({
-          idx,
-          obj
-        });
+  async _resolve(refs, current) {
+    const refArray = [
+      ...refs
+    ];
+    await Promise.all(refArray.map((ref) => ref.tryLoad()));
+    return refArray.map((ref) => {
+      let target;
+      if (ref.isAvailable) {
+        target = ref.target;
       }
+      return target ?? current.find((obj) => Obj6.getDXN(obj).toString() === ref.dxn.toString());
+    }).filter(isNonNullable3);
+  }
+};
+var Service = class _Service extends Context3.Tag("@dxos/assistant/AiContextService")() {
+  static bindContext = ({ blueprints, objects }) => Effect7.gen(function* () {
+    const { binder } = yield* _Service;
+    yield* Effect7.promise(() => binder.bind({
+      blueprints,
+      objects
+    }));
+  });
+  static findObjects = (type) => {
+    return Effect7.gen(function* () {
+      const { binder } = yield* _Service;
+      return binder.getObjects().filter(Obj6.instanceOf(type));
     });
-    createdObjects.sort((a, b) => {
-      const aDate = new Date(a.obj.created).getTime();
-      const bDate = new Date(b.obj.created).getTime();
-      return aDate - bDate;
-    });
-    let createdIdx = 0;
-    return sortedObjects.map((obj, _idx) => {
-      if (obj && typeof obj.created === "string") {
-        return createdObjects[createdIdx++].obj;
-      }
-      return obj;
+  };
+};
+
+// src/session/AiSession.ts
+var AiSession_exports = {};
+__export(AiSession_exports, {
+  Service: () => Service2,
+  Session: () => Session
+});
+import * as Array4 from "effect/Array";
+import * as Context4 from "effect/Context";
+import * as Effect8 from "effect/Effect";
+import * as Either from "effect/Either";
+import { pipe as pipe4 } from "effect/Function";
+import * as Layer3 from "effect/Layer";
+import * as Record2 from "effect/Record";
+import * as Runtime2 from "effect/Runtime";
+import { Operation as Operation2, Trace as Trace3 } from "@dxos/compute";
+import { Resource as Resource2 } from "@dxos/context";
+import { Database as Database2, Feed as Feed2, Filter, Obj as Obj7 } from "@dxos/echo";
+import { acquireReleaseResource } from "@dxos/effect";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log5 } from "@dxos/log";
+import { McpToolkit } from "@dxos/mcp-client";
+import { Message as Message4 } from "@dxos/types";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/core/compute/assistant/src/session/AiSession.ts";
+var SUMMARY_THRESHOLD = 8e4;
+var Session = class extends Resource2 {
+  /**
+  * Blueprints and objects bound to the session.
+  */
+  _binder;
+  _feed;
+  _runtime;
+  constructor(options) {
+    super();
+    this._feed = options.feed;
+    this._runtime = options.runtime;
+    invariant2(this._feed, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 43, S: this, A: ["this._feed", ""] });
+    invariant2(this._runtime, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 44, S: this, A: ["this._runtime", ""] });
+    this._binder = new Binder({
+      feed: this._feed,
+      runtime: this._runtime,
+      registry: options.registry
     });
   }
+  async _open() {
+    await this._binder.open(this._ctx);
+  }
+  get feed() {
+    return this._feed;
+  }
+  get context() {
+    return this._binder;
+  }
+  async getHistory() {
+    const queryResult = await Runtime2.runPromise(this._runtime)(Feed2.query(this._feed, Filter.type(Message4.Message)));
+    const items = await queryResult.run();
+    return items.filter(Obj7.instanceOf(Message4.Message));
+  }
+  getTools() {
+    return Effect8.gen(this, function* () {
+      const toolkit = yield* createToolkit({
+        blueprints: this.context.getBlueprints()
+      });
+      return toolkit.toolkit.tools;
+    }).pipe(Effect8.orDie);
+  }
   /**
-  * Returns the current state of the graph.
+  * Not provided by default, since users might want to override them.
   */
-  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
-    };
+  makeToolExecutionServices() {
+    return ToolExecutionServices.pipe(Layer3.provide(Operation2.withInvocationOptions({
+      conversation: Obj7.getDXN(this._feed).toString()
+    })));
   }
   /**
-  * Tracks tool calls and handles pending tool result updates.
+  * Creates a new cancelable request effect.
   */
-  _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;
+  createRequest(params) {
+    return Effect8.gen(this, function* () {
+      const history = yield* Effect8.promise(() => this.getHistory());
+      const blueprints = this.context.getBlueprints();
+      const objects = this.context.getObjects();
+      log5("run", {
+        history: history.length,
+        blueprints: blueprints.length,
+        objects: objects.length
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 87, S: this });
+      const request = new AiRequest_exports.Request({
+        summarizationThreshold: SUMMARY_THRESHOLD,
+        observer: params.observer,
+        onOutput: (message) => Effect8.promise(() => Runtime2.runPromise(this._runtime)(Feed2.append(this._feed, [
+          message
+        ])))
+      });
+      yield* request.begin({
+        history,
+        blueprints,
+        objects,
+        prompt: params.prompt,
+        system: params.system
+      });
+      do {
+        yield* Effect8.promise(() => this.context.sync());
+        const currentBlueprints = this.context.getBlueprints();
+        const mcps = yield* connectMcpServers(currentBlueprints, params.mcpServers);
+        const toolkit = yield* createToolkit({
+          toolkit: params.toolkit,
+          blueprints: currentBlueprints,
+          opaqueToolkits: mcps
+        });
+        log5("toolkit", {
+          tools: Record2.keys(toolkit.toolkit.tools)
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 116, S: this });
+        const system = yield* formatSystemPrompt({
+          system: params.system,
+          blueprints: currentBlueprints,
+          objects: this.context.getObjects()
+        }).pipe(Effect8.orDie);
+        const { done } = yield* request.runAgentTurn({
+          system,
+          toolkit
+        });
+        if (done) {
+          break;
         }
-      }
-      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) {
+        yield* request.runTools({
+          toolkit
+        });
+      } while (true);
+      log5("result", {
+        messages: request.pending.length,
+        duration: request.duration,
+        toolCalls: request.toolCalls
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 135, S: this });
       return [
-        getToolCallId(event.parentMessage, event.toolCallId)
+        ...request.pending
       ];
-    }
-    return [];
+    }).pipe(Effect8.provide(Layer3.mergeAll(Layer3.succeed(Service, {
+      binder: this.context
+    }), Layer3.succeed(Service2, this), Operation2.withInvocationOptions({
+      conversation: Obj7.getDXN(this._feed).toString()
+    }))), Effect8.withSpan("AiSession.createRequest"));
   }
+};
+var Service2 = class _Service extends Context4.Tag("@dxos/assistant/AiSessionService")() {
   /**
-  * Checks if a commit is a tool call commit.
+  * Create a new session layer from options.
   */
-  _isToolCallCommit(commit) {
-    return commit.message.includes("Calling tool");
-  }
+  static layer = (options) => aiContextFromSession.pipe(Layer3.provideMerge(Layer3.scoped(_Service, Effect8.gen(function* () {
+    const session = yield* acquireReleaseResource(() => new Session(options));
+    return session;
+  }))));
   /**
-  * Checks if a commit is a tool result commit.
+  * Create a new session with a new feed.
   */
-  _isToolResultCommit(commit) {
-    return commit.message.includes("Tool call succeeded") || commit.message.includes("Tool error:");
-  }
+  static layerNewFeed = (options) => Layer3.unwrapScoped(Effect8.gen(function* () {
+    const feed = yield* Database2.add(Feed2.make());
+    const runtime2 = yield* Effect8.runtime();
+    return _Service.layer({
+      ...options,
+      feed,
+      runtime: runtime2
+    });
+  }));
   /**
-  * Extracts tool call ID from a commit ID.
+  * Run a prompt in the current session.
   */
-  _extractToolCallId(commitId) {
-    const toolCallMatch = commitId.match(/_toolCall_(.+)$/);
-    const toolResultMatch = commitId.match(/_toolResult_(.+)$/);
-    return toolCallMatch?.[1] || toolResultMatch?.[1];
-  }
-};
-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);
-      }
-    }
-  } else {
-    if (previousBlockId) {
-      parents.push(previousBlockId);
-    } else {
-      const toolCallParent = getParentId(message);
-      if (toolCallParent) {
-        parents.push(toolCallParent);
-      }
-    }
-  }
-  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 "stats":
-      return {
-        id: getGenericBlockId(message.id, idx),
-        branch,
-        parents,
-        timestamp,
-        icon: "ph--rocket--regular",
-        level: LogLevel.INFO,
-        message: ContentBlock.createStatsMessage(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]
+  static run = (params) => Effect8.gen(function* () {
+    const session = yield* _Service;
+    return yield* session.createRequest(params);
   });
 };
-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;
+var aiContextFromSession = Layer3.effect(Service, Effect8.gen(function* () {
+  const session = yield* Service2;
+  return {
+    binder: session.context
+  };
+}));
+var connectMcpServers = (blueprints, spaceMcpServers = []) => {
+  const blueprintServers = pipe4(blueprints, Array4.flatMap((_) => _.mcpServers ?? []), Array4.map(({ url, protocol, apiKey }) => ({
+    url,
+    protocol,
+    apiKey
+  })));
+  const spaceServers = spaceMcpServers.map(({ url, protocol, apiKey }) => ({
+    url,
+    protocol,
+    apiKey
+  }));
+  const allServers = [
+    ...blueprintServers,
+    ...spaceServers
+  ];
+  return pipe4(allServers, Effect8.forEach((options) => McpToolkit.make(options).pipe(
+    // NOTE: Type-inference fails here without explicit void return.
+    Effect8.tap((toolkit) => log5.info("Connected to MCP server", {
+      url: options.url,
+      tools: Object.keys(toolkit.toolkit.tools).length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 199, S: void 0 })),
+    // Surface typed connection failures via ephemeral trace + warn log, then drop the server.
+    Effect8.tapError((error) => Effect8.gen(function* () {
+      log5.warn("Failed to connect to MCP server", {
+        url: error.url,
+        protocol: error.protocol,
+        message: error.message
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 204, S: this });
+      yield* Trace3.write(McpServerError, {
+        url: error.url,
+        protocol: error.protocol,
+        message: error.message
+      });
+    })),
+    // Catch unexpected defects too (e.g. malformed tool schemas) so a single broken
+    // server can never abort the whole turn — surface them through the same channel.
+    Effect8.catchAllDefect((defect) => Effect8.gen(function* () {
+      const message = defect instanceof Error ? defect.message : String(defect);
+      log5.warn("Unexpected MCP defect", {
+        url: options.url,
+        message
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 218, S: this });
+      yield* Trace3.write(McpServerError, {
+        url: options.url,
+        protocol: options.protocol,
+        message: `Unexpected MCP failure: ${message}`
+      });
+      return yield* Effect8.fail(new McpToolkit.McpConnectionError({
+        url: options.url,
+        protocol: options.protocol,
+        message
+      }));
+    })),
+    Effect8.either
+  )), Effect8.map(Array4.filterMap((_) => Either.getRight(_))));
 };
 
 // src/templates/system.ts
 import defaultsDeep from "lodash.defaultsdeep";
-import { Template as Template2 } from "@dxos/blueprints";
+import { Template as Template2 } from "@dxos/compute";
 
-// raw-loader:/__w/dxos/dxos/packages/core/assistant/src/templates/instructions/format.tpl?raw
+// raw-loader:/__w/dxos/dxos/packages/core/compute/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/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";
+// raw-loader:/__w/dxos/dxos/packages/core/compute/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## Navigation\n\n- When the user asks to open, go to, navigate to, or show a specific document, page, or object, use the navigation tools instead of loading content inline.\n- First, call the Resolve navigation targets tool to find the navigation path for the requested item.\n  - Without arguments, it returns available pages that can be navigated to.\n  - With a DXN in the query, it resolves that specific object to a navigation path.\n- If you know the object's DXN (e.g. from a database query or context objects), pass it in the query to get the exact navigation path.\n- Then, call the Open tool with the resolved navigation path(s) in the subject array to navigate the user to that item.\n- Do not respond with the document's content when the user asks to open it \u2014 open it in the main content area instead.\n- If multiple targets match, present the options to the user and let them choose which to open.\n\n## Response format\n\n- NEVER output narration text outside `<status>` tags or the final user-facing answer. Any progress update, transition sentence, or \"let me\u2026\" lead-in MUST be wrapped in `<status>...</status>`. Violating this is an error.\n- When updating the user about the progress of the work you are doing, put the update in a <status> XML tag.\n- Only when you need to show the result to the user or ask a question use a text block without status tags.\n- After a `</status>` tag, the next output must be either another `<status>` tag, a tool call, or the final user-facing answer \u2014 never a transition sentence.\n\n<example>\n// reasoning...\n<status>Looking for emails from Depot</status>\n// tool call..\n<status>Found 2 emails from Depot.</status>\n<status>Loading email details</status>\n// tool call\n<status>Located mailbox</status>\nI found **2 emails from Depot**:\n</example>\n\nDo not do (no status tags):\n\n<incorrect_example>\n// reasoning...\n// tool call..\nI found 2 emails from Depot. Let me load their details:\n// tool call\nI found **2 emails from Depot**:\n</incorrect_example>\n\nDo not do (transition sentence after a status tag, before tool calls):\n\n<incorrect_example>\n<status>Doing X</status>\nLet me start by doing X:\n// tool call\n</incorrect_example>\n\n- NEVER write a lead-in sentence before a tool call. Use a `<status>` tag instead.\n- Avoid using plain text to tell the user what you are about to do; instead, use status blocks.\n- WRONG: Let me get...\n- CORRECT: <status>Getting...</status>";
 
 // src/templates/system.ts
 var createSystemPrompt = (options = {}) => Template2.process(format_default, defaultsDeep(options, {
   DATETIME: (/* @__PURE__ */ new Date()).toISOString()
 }));
+var SYSTEM_ID = "01K2J2FZWH39F55CS7B26GP1Q3";
 var templates = {
-  /** 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",
+    id: SYSTEM_ID,
     source: system_default
   })
 };
 export {
+  AgentRequestBegin,
+  AgentRequestEnd,
   AiAssistantError,
-  AiContextBinder,
-  AiContextService,
-  AiConversation,
-  AiConversationService,
+  AiContext_exports as AiContext,
   AiModelError,
-  AiSession,
-  ArtifactDiffResolver,
+  AiRequest_exports as AiRequest,
+  AiSession_exports as AiSession,
   ArtifactId,
-  Bindings,
-  ContextBinding,
+  CompleteBlock,
   ExecutionGraph,
   GenerationObserver,
+  McpServerError,
+  PartialBlock,
   RefFromLLM,
   ToolExecutionServices,
-  VersionPin,
   applyDiffs,
   computeDiffsWithCursors,
   createArtifactElement,
@@ -1320,8 +1768,11 @@ export {
   createToolkit,
   formatSystemPrompt,
   formatUserPrompt,
-  makeToolExecutionServiceFromFunctions,
-  makeToolResolverFromFunctions,
+  getOperationFromTool,
+  makeToolExecutionService,
+  makeToolExecutionServiceFromOperationInvoker,
+  makeToolResolverFromOperations,
+  mapAiError,
   reduceDiffs,
   templates
 };