@dxos/assistant 0.8.4-main.b97322e → 0.8.4-main.bcb3aa67d6

package/dist/lib/neutral/chunk-KVYJFFLF.mjs

@@ -0,0 +1,1805 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/conversation/context.ts
+import { Atom, Registry } from "@effect-atom/atom-react";
+import * as EArray from "effect/Array";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+import { Blueprint } from "@dxos/blueprints";
+import { Resource } from "@dxos/context";
+import { DXN, Obj, Query, Ref, Type } from "@dxos/echo";
+import { assertArgument } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { ComplexSet, isNonNullable } 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.contextBinding",
+  version: "0.1.0"
+}));
+var Bindings = class {
+  blueprints = new ComplexSet((ref) => ref.dxn.toString());
+  // TODO(burdon): Some DXNs have the Space prefix so only compare the object ID.
+  objects = new ComplexSet((ref) => ref.dxn.asEchoDXN()?.echoId);
+  toJSON() {
+    return {
+      blueprints: EArray.fromIterable(this.blueprints).map((ref) => ref.dxn.toString()),
+      objects: EArray.fromIterable(this.objects).map((ref) => ref.dxn.toString())
+    };
+  }
+};
+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();
+  }
+  /**
+  * Returns the blueprints atom for subscription.
+  */
+  get blueprints() {
+    return this._blueprints;
+  }
+  /**
+  * Returns the objects atom for subscription.
+  */
+  get objects() {
+    return this._objects;
+  }
+  /**
+  * Gets the current blueprints value.
+  */
+  getBlueprints() {
+    return this._registry.get(this._blueprints);
+  }
+  /**
+  * Gets the current objects value.
+  */
+  getObjects() {
+    return this._registry.get(this._objects);
+  }
+  /**
+  * Subscribe to changes in blueprints.
+  */
+  subscribeBlueprints(cb) {
+    return this._registry.subscribe(this._blueprints, () => cb(this._registry.get(this._blueprints)));
+  }
+  /**
+  * Subscribe to changes in objects.
+  */
+  subscribeObjects(cb) {
+    return this._registry.subscribe(this._objects, () => cb(this._registry.get(this._objects)));
+  }
+  async _open() {
+    const query = this._queue.query(Query.type(ContextBinding));
+    const initialResults = await query.run();
+    await this._updateBindings(initialResults);
+    this._ctx.onDispose(query.subscribe(async () => {
+      await this._updateBindings(query.results);
+    }));
+  }
+  async _updateBindings(items) {
+    if (items.length === 0) {
+      return;
+    }
+    const bindings = this._reduce(items);
+    const currentBlueprints = this._registry.get(this._blueprints);
+    const currentObjects = this._registry.get(this._objects);
+    const resolvedBlueprints = await this._resolve(bindings.blueprints, currentBlueprints);
+    const resolvedObjects = await this._resolve(bindings.objects, currentObjects);
+    const reducedBlueprintDxns = new ComplexSet(DXN.hash, [
+      ...bindings.blueprints
+    ].map((ref) => ref.dxn));
+    const reducedObjectDxns = new ComplexSet(DXN.hash, [
+      ...bindings.objects
+    ].map((ref) => ref.dxn));
+    const filteredBlueprints = currentBlueprints.filter((obj) => reducedBlueprintDxns.has(Obj.getDXN(obj)));
+    const filteredObjects = currentObjects.filter((obj) => reducedObjectDxns.has(Obj.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);
+    log("updated bindings", {
+      blueprints: mergedBlueprints.length,
+      objects: mergedObjects.length
+    }, {
+      F: __dxlog_file,
+      L: 173,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async _close() {
+    this._registry.set(this._blueprints, []);
+    this._registry.set(this._objects, []);
+  }
+  async bind({ blueprints, objects }) {
+    const currentBlueprints = this._registry.get(this._blueprints);
+    const currentObjects = this._registry.get(this._objects);
+    const { added: addedBlueprints, next: nextBlueprints } = this._processBindings(blueprints, currentBlueprints);
+    const { added: addedObjects, next: nextObjects } = this._processBindings(objects, currentObjects);
+    if (!addedBlueprints.length && !addedObjects.length) {
+      return;
+    }
+    this._registry.set(this._blueprints, nextBlueprints);
+    this._registry.set(this._objects, nextObjects);
+    log("bind", {
+      blueprints: addedBlueprints.length,
+      objects: addedObjects.length
+    }, {
+      F: __dxlog_file,
+      L: 199,
+      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) {
+      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) => DXN.equalsEchoId(Obj.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) => DXN.equalsEchoId(Obj.getDXN(obj), dxn))));
+    }
+    log("unbind", {
+      blueprints: blueprints?.length,
+      objects: objects?.length
+    }, {
+      F: __dxlog_file,
+      L: 237,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._queue.append([
+      Obj.make(ContextBinding, {
+        blueprints: {
+          added: [],
+          removed: blueprints ?? []
+        },
+        objects: {
+          added: [],
+          removed: objects ?? []
+        }
+      })
+    ]);
+  }
+  /**
+  * Process bindings to filter duplicates and determine next state.
+  */
+  _processBindings(refs, current) {
+    const next = [
+      ...current
+    ];
+    const added = [];
+    if (!refs?.length) {
+      return {
+        added,
+        next
+      };
+    }
+    const seen = new Set(current.map((obj) => Obj.getDXN(obj).toString()));
+    for (const ref of refs) {
+      const dxn = ref.dxn.toString();
+      if (!seen.has(dxn)) {
+        seen.add(dxn);
+        added.push(ref);
+        if (ref.isAvailable) {
+          const target = ref.target;
+          if (target) {
+            next.push(target);
+          }
+        }
+      }
+    }
+    return {
+      added,
+      next
+    };
+  }
+  /**
+  * Reduce results into sets of blueprints and objects.
+  */
+  _reduce(items) {
+    return Function.pipe(items, 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;
+    }));
+  }
+  /**
+  * Merge resolved items into the current set, adding only items not already present (by DXN).
+  */
+  _mergeInto(current, resolved) {
+    const seen = new Set(current.map((obj) => Obj.getDXN(obj).toString()));
+    const merged = [
+      ...current
+    ];
+    for (const obj of resolved) {
+      const dxn = Obj.getDXN(obj).toString();
+      if (!seen.has(dxn)) {
+        seen.add(dxn);
+        merged.push(obj);
+      }
+    }
+    return merged;
+  }
+  /**
+  * Resolve references to objects, loading them first if needed and falling back to existing objects.
+  */
+  async _resolve(refs, current) {
+    const refArray = [
+      ...refs
+    ];
+    await Promise.all(refArray.map((ref) => ref.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(isNonNullable);
+  }
+};
+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));
+    });
+  };
+};
+
+// 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(),
+  /**
+  * Debug printer to be used in unit-tests and browser devtools.
+  */
+  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/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/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";
+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* () {
+  const blocks = [];
+  const artifactDiffResolver = yield* Effect3.serviceOption(ArtifactDiffResolver);
+  if (Option.isSome(artifactDiffResolver)) {
+    const versions = gatherObjectVersions(history);
+    const artifactDiff = yield* Effect3.tryPromise({
+      try: () => artifactDiffResolver.value.resolve([
+        ...versions.entries()
+      ].map(([id, version]) => ({
+        id,
+        lastVersion: version
+      }))),
+      catch: AiAssistantError.wrap({
+        message: "Artifact diff resolution error"
+      })
+    });
+    log2("version", {
+      artifactDiff,
+      versions
+    }, {
+      F: __dxlog_file2,
+      L: 94,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    for (const [id, { version }] of [
+      ...artifactDiff.entries()
+    ]) {
+      if (ObjectVersion.equals(version, versions.get(id))) {
+        artifactDiff.delete(id);
+        continue;
+      }
+      blocks.push({
+        _tag: "anchor",
+        objectId: id,
+        version
+      });
+    }
+    if (artifactDiff.size > 0) {
+      blocks.push(createArtifactUpdateBlock(artifactDiff));
+    }
+  }
+  return Obj2.make(Message.Message, {
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    sender: {
+      role: "user"
+    },
+    blocks: [
+      ...blocks,
+      {
+        _tag: "text",
+        text: prompt
+      }
+    ]
+  });
+});
+var gatherObjectVersions = (messages) => {
+  const artifactIds = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const block of message.blocks) {
+      if (block._tag === "anchor") {
+        artifactIds.set(block.objectId, block.version);
+      }
+    }
+  }
+  return artifactIds;
+};
+var createArtifactUpdateBlock = (artifactDiff) => {
+  return {
+    _tag: "text",
+    // TODO(dmaretskyi): Does this need to be a special content-block?
+    disposition: "artifact-update",
+    text: trim`
+      The following artifacts have been updated since the last message:
+      ${[
+      ...artifactDiff.entries()
+    ].map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `
+${diff}` : ""}</changed-artifact>`).join("\n")}
+    `
+  };
+};
+
+// src/tracing.ts
+import { Trace } from "@dxos/functions";
+import { Obj as Obj3 } from "@dxos/echo";
+import { ContentBlock, Actor } from "@dxos/types";
+import * as Schema2 from "effect/Schema";
+var PartialBlock = Trace.EventType("assistant.partialBlock", {
+  schema: Schema2.Struct({
+    messageId: Obj3.ID,
+    role: Actor.Role,
+    block: ContentBlock.Any
+  }),
+  isEphemeral: true
+});
+var CompleteBlock = Trace.EventType("assistant.completeBlock", {
+  schema: Schema2.Struct({
+    messageId: Obj3.ID,
+    role: Actor.Role,
+    block: ContentBlock.Any
+  }),
+  isEphemeral: false
+});
+var AgentTurnStarted = Trace.EventType("assistant.agentTurnStarted", {
+  schema: Schema2.Struct({
+    /** Number of history messages. */
+    historyLength: Schema2.Number,
+    /** Number of pending messages. */
+    pendingLength: Schema2.Number,
+    /** System prompt length in characters. */
+    systemPromptLength: Schema2.Number
+  }),
+  isEphemeral: false
+});
+var AgentTurnCompleted = Trace.EventType("assistant.agentTurnCompleted", {
+  schema: Schema2.Struct({
+    /** Number of messages produced in this turn. */
+    messageCount: Schema2.Number,
+    /** Whether the agent is done (no more tool calls). */
+    done: Schema2.Boolean
+  }),
+  isEphemeral: false
+});
+var ToolCallStarted = Trace.EventType("assistant.toolCallStarted", {
+  schema: Schema2.Struct({
+    /** Tool name. */
+    name: Schema2.String,
+    /** Tool call ID. */
+    toolCallId: Schema2.String
+  }),
+  isEphemeral: false
+});
+var ToolCallCompleted = Trace.EventType("assistant.toolCallCompleted", {
+  schema: Schema2.Struct({
+    /** Tool name. */
+    name: Schema2.String,
+    /** Tool call ID. */
+    toolCallId: Schema2.String,
+    /** Whether the tool call resulted in an error. */
+    isError: Schema2.Boolean
+  }),
+  isEphemeral: false
+});
+var AgentInputReceived = Trace.EventType("assistant.agentInputReceived", {
+  schema: Schema2.Struct({
+    /** Type of input: 'prompt' or 'tool_result'. */
+    inputType: Schema2.String,
+    /** Length of input content. */
+    contentLength: Schema2.Number
+  }),
+  isEphemeral: false
+});
+var AgentRequestCompleted = Trace.EventType("assistant.agentRequestCompleted", {
+  schema: Schema2.Struct({
+    /** Number of pending items remaining in queue. */
+    pendingItems: Schema2.Number
+  }),
+  isEphemeral: false
+});
+
+// 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 * as Array2 from "effect/Array";
+import * as Option2 from "effect/Option";
+import { AiParser, AiPreprocessor, AiSummarizer, callTool, withoutToolCallParising } from "@dxos/ai";
+import { Obj as Obj4 } from "@dxos/echo";
+import { Trace as Trace2, TracingService } from "@dxos/functions";
+import { log as log3 } from "@dxos/log";
+import { ContentBlock as ContentBlock2, Message as Message2 } from "@dxos/types";
+import { pipe as pipe3 } from "effect/Function";
+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));
+  _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 ?? (() => Effect4.void);
+  }
+  get duration() {
+    return this._ended - this._started;
+  }
+  get toolCalls() {
+    return this._toolCalls;
+  }
+  get pending() {
+    return this._pending;
+  }
+  _submitMessage = (message) => Effect4.gen(this, function* () {
+    this._pending.push(message);
+    yield* this._observer.onMessage(message);
+    for (const block of message.blocks) {
+      yield* Trace2.write(CompleteBlock, {
+        messageId: message.id,
+        role: message.sender.role,
+        block
+      });
+    }
+    yield* this._onOutput(message);
+    return message;
+  });
+  getToolCalls = () => pipe3([
+    ...this._history,
+    ...this._pending
+  ], Array2.reverse, Array2.takeWhile((_) => _.sender.role === "assistant"), Array2.flatMap((_) => _.blocks.filter(ContentBlock2.is("toolCall")).map((block) => ({
+    block,
+    message: _
+  }))), Array2.filter((_) => !_.block.providerExecuted));
+  /**
+  * 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 = [] }) => Effect4.gen(this, function* () {
+    this._started = Date.now();
+    this._history = [
+      ...history
+    ];
+    this._pending = [];
+    const systemPrompt = yield* formatSystemPrompt({
+      system,
+      blueprints,
+      objects
+    }).pipe(Effect4.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* this._submitMessage(summary);
+      }
+    }
+    yield* this._submitMessage(yield* formatUserPrompt({
+      prompt,
+      history
+    }));
+  });
+  /**
+  * 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 }) => Effect4.gen(this, function* () {
+    log3("request", {
+      system: {
+        snippet: createSnippet(system),
+        length: system.length
+      },
+      pending: this._pending.length,
+      history: this._history.length
+    }, {
+      F: __dxlog_file3,
+      L: 207,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const prompt = yield* AiPreprocessor.preprocessPrompt([
+      ...this._history,
+      ...this._pending
+    ], {
+      system,
+      cacheControl: "ephemeral"
+    });
+    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.mapEffect((block) => Effect4.gen(this, function* () {
+      if (block.pending) {
+        currentMessageId ??= Obj4.ID.random();
+        log3("emit ephemeral message", {
+          id: currentMessageId,
+          type: block._tag
+        }, {
+          F: __dxlog_file3,
+          L: 238,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        yield* Trace2.write(PartialBlock, {
+          messageId: currentMessageId,
+          role: "assistant",
+          block
+        });
+        return Option2.none();
+      } else {
+        currentMessageId ??= Obj4.ID.random();
+        const id = currentMessageId;
+        currentMessageId = null;
+        log3("emit complete message", {
+          id,
+          type: block._tag
+        }, {
+          F: __dxlog_file3,
+          L: 249,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        const message = Obj4.make(Message2.Message, {
+          id,
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          sender: {
+            role: "assistant"
+          },
+          blocks: [
+            block
+          ]
+        });
+        return Option2.some(yield* this._submitMessage(message));
+      }
+    }), {
+      concurrency: 1,
+      unordered: false
+    }), Stream.filterMap((_) => _), Stream.runCollect, Effect4.map(Chunk.toArray));
+    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
+    };
+  });
+  runTools = ({ toolkit }) => Effect4.gen(this, function* () {
+    const toolCalls = this.getToolCalls();
+    const toolResults = yield* Effect4.forEach(toolCalls, ({ block, message }) => {
+      if (!toolkit) {
+        throw new Error("No toolkit provided");
+      }
+      return callTool(toolkit, block).pipe(Effect4.provide(TracingService.layerSubframe((context) => ({
+        ...context,
+        parentMessage: message.id,
+        toolCallId: block.toolCallId
+      }))));
+    });
+    yield* this._submitMessage(Obj4.make(Message2.Message, {
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      sender: {
+        role: "tool"
+      },
+      blocks: toolResults
+    }));
+    this._toolCalls += toolResults.length;
+  });
+  /**
+  * Run a full conversation turn loop. Equivalent to calling `begin()` then `runTurn()` in a loop.
+  */
+  run = ({ prompt, system: systemTemplate, history = [], objects = [], blueprints = [], toolkit }) => Effect4.gen(this, function* () {
+    yield* this.begin({
+      prompt,
+      system: systemTemplate,
+      history,
+      objects,
+      blueprints
+    });
+    const system = yield* formatSystemPrompt({
+      system: systemTemplate,
+      blueprints,
+      objects
+    }).pipe(Effect4.orDie);
+    do {
+      const { done } = yield* this.runAgentTurn({
+        system,
+        toolkit
+      });
+      if (done) {
+        break;
+      }
+      yield* this.runTools({
+        toolkit
+      });
+    } while (true);
+    log3("done", {
+      pending: this._pending.length,
+      duration: this.duration,
+      tools: this._toolCalls
+    }, {
+      F: __dxlog_file3,
+      L: 333,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return this._pending;
+  }).pipe(this._semaphore.withPermits(1), Effect4.withSpan("AiSession.run"));
+};
+var createSnippet = (text, len = 32) => text.length <= len * 2 ? text : [
+  text.slice(0, len),
+  "...",
+  text.slice(-len)
+].join("");
+
+// src/session/toolkit.ts
+import * as Toolkit from "@effect/ai/Toolkit";
+import * as Effect5 from "effect/Effect";
+import { GenericToolkit, ToolExecutionService, ToolResolverService } from "@dxos/ai";
+import { isTruthy } 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,
+    blueprintToolkit,
+    genericToolkit.toolkit
+  ].filter(isTruthy));
+  return yield* toolkit.pipe(Effect5.provide(blueprintToolHandler), Effect5.provide(genericToolkit.layer));
+});
+
+// src/session/version-pin.ts
+import * as Schema3 from "effect/Schema";
+import { getVersion } from "@dxos/echo-db";
+import { ObjectId } from "@dxos/keys";
+var ObjectVersionSchema = Schema3.Unknown;
+var VersionPinSchema = Schema3.Struct({
+  // TODO(dmaretskyi): Use Ref when those support encoding.
+  objectId: ObjectId,
+  // TODO(dmaretskyi): Could be opaque.
+  version: ObjectVersionSchema
+});
+var VersionPin = class extends VersionPinSchema {
+  static DISPOSITION = "version-pin";
+  static fromObject(object) {
+    return VersionPin.make({
+      objectId: object.id,
+      version: getVersion(object)
+    });
+  }
+  static createBlock(pin) {
+    return {
+      _tag: "json",
+      disposition: VersionPin.DISPOSITION,
+      data: JSON.stringify(pin)
+    };
+  }
+};
+
+// src/conversation/conversation.ts
+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 pipe4 } from "effect/Function";
+import * as Layer from "effect/Layer";
+import { Resource as Resource2 } from "@dxos/context";
+import { Obj as Obj5 } 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";
+import * as Record from "effect/Record";
+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;
+  constructor(options) {
+    super();
+    this._queue = options.queue;
+    invariant(this._queue, void 0, {
+      F: __dxlog_file4,
+      L: 73,
+      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;
+  }
+  get toolkit() {
+    return this._toolkit;
+  }
+  async getHistory() {
+    const queueItems = await this._queue.queryObjects();
+    return queueItems.filter(Obj5.instanceOf(Message3.Message));
+  }
+  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);
+  }
+  /**
+  * Creates a new cancelable request effect.
+  */
+  createRequest(params) {
+    return Effect6.gen(this, function* () {
+      const history = yield* Effect6.promise(() => this.getHistory());
+      const blueprints = this.context.getBlueprints();
+      const objects = this.context.getObjects();
+      log4("run", {
+        history: history.length,
+        blueprints: blueprints.length,
+        objects: objects.length
+      }, {
+        F: __dxlog_file4,
+        L: 117,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const session = new AiSession({
+        summarizationThreshold: SUMMARY_THRESHOLD,
+        observer: params.observer,
+        onOutput: (message) => Effect6.promise(() => this._queue.append([
+          message
+        ]))
+      });
+      yield* session.begin({
+        history,
+        blueprints,
+        objects,
+        prompt: params.prompt,
+        system: params.system
+      });
+      do {
+        const currentBlueprints = this.context.getBlueprints();
+        const mcps = yield* connectMcpServers(currentBlueprints);
+        const toolkit = yield* createToolkit({
+          toolkit: params.toolkit,
+          blueprints: currentBlueprints,
+          genericToolkits: mcps
+        });
+        log4("toolkit", {
+          tools: Record.keys(toolkit.tools)
+        }, {
+          F: __dxlog_file4,
+          L: 146,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        const system = yield* formatSystemPrompt({
+          system: params.system,
+          blueprints: currentBlueprints,
+          objects: this.context.getObjects()
+        }).pipe(Effect6.orDie);
+        const { done } = yield* session.runAgentTurn({
+          system,
+          toolkit
+        });
+        if (done) {
+          break;
+        }
+        yield* session.runTools({
+          toolkit
+        });
+      } while (true);
+      log4("result", {
+        messages: session.pending.length,
+        duration: session.duration,
+        toolCalls: session.toolCalls
+      }, {
+        F: __dxlog_file4,
+        L: 165,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return [
+        ...session.pending
+      ];
+    }).pipe(Effect6.provide(Layer.mergeAll(Layer.succeed(AiContextService, {
+      binder: this.context
+    }), Layer.succeed(AiConversationService, this))));
+  }
+};
+var AiConversationService = class _AiConversationService extends Context3.Tag("@dxos/assistant/AiConversationService")() {
+  /**
+  * Create a new conversation layer from options.
+  */
+  static layer = (options) => aiContextFromConversation.pipe(Layer.provideMerge(Layer.scoped(_AiConversationService, Effect6.gen(function* () {
+    const conversation = yield* acquireReleaseResource(() => new AiConversation(options));
+    return conversation;
+  }))));
+  /**
+  * Create a new conversation with a new queue.
+  */
+  static layerNewQueue = (options) => Layer.unwrapScoped(Effect6.gen(function* () {
+    return _AiConversationService.layer({
+      ...options,
+      queue: yield* QueueService.createQueue()
+    });
+  }));
+  /**
+  * Run a prompt in the current conversation.
+  */
+  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) => pipe4(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: 259,
+    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: 261,
+    S: void 0,
+    C: (f, a) => f(...a)
+  }))),
+  Effect6.either
+)), Effect6.map(Array3.filterMap((_) => Either.getRight(_))));
+
+// src/types/artifact.ts
+import * as Schema4 from "effect/Schema";
+import { Obj as Obj6, Ref as Ref2 } from "@dxos/echo";
+import { Database } from "@dxos/echo";
+import { EncodedReference } from "@dxos/echo-protocol";
+import { DXN as DXN2, LOCAL_SPACE_TAG } from "@dxos/keys";
+import { trim as trim2 } from "@dxos/util";
+var createArtifactElement = (id) => `<artifact id=${id} />`;
+var ArtifactId = class extends Schema4.String.annotations({
+  // TODO(dmaretskyi): This section gets overriden.
+  description: trim2`
+    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 DXN2.parse(reference.slice(1));
+    } else if (reference.startsWith("dxn:")) {
+      return DXN2.parse(reference);
+    } else if (/^[A-Z0-9]+:[A-Z0-9]+$/.test(reference)) {
+      const [spaceId, objectId] = reference.split(":");
+      return new DXN2(DXN2.kind.ECHO, [
+        spaceId === owningSpaceId ? LOCAL_SPACE_TAG : spaceId,
+        objectId
+      ]);
+    } else if (/^[A-Z0-9]+$/.test(reference)) {
+      return DXN2.fromLocalObjectId(reference);
+    } else {
+      throw new Error(`Unable to parse object reference: ${reference}`);
+    }
+  }
+  /**
+  * Resolves an artifact ID to an object.
+  */
+  static resolve(schema, ref) {
+    const dxn = ArtifactId.toDXN(ref);
+    return Database.resolve(dxn, schema);
+  }
+};
+var RefFromLLM = Schema4.transform(ArtifactId, Ref2.Ref(Obj6.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/functions/services.ts
+import * as Tool from "@effect/ai/Tool";
+import * as Context4 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import * as Record2 from "effect/Record";
+import * as Schema5 from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { AiToolNotFoundError, ToolExecutionService as ToolExecutionService2, ToolResolverService as ToolResolverService2 } from "@dxos/ai";
+import { GenericToolkit as GenericToolkit2 } from "@dxos/ai";
+import { todo } from "@dxos/debug";
+import { Ref as Ref3 } from "@dxos/echo";
+import { FunctionInvocationService, FunctionNotFoundError } from "@dxos/functions";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { Operation, OperationRegistry } from "@dxos/operation";
+import * as Option3 from "effect/Option";
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/assistant/src/functions/services.ts";
+var makeToolResolverFromFunctions = () => {
+  return Layer2.effect(ToolResolverService2, Effect7.gen(function* () {
+    const toolkitProvider = yield* GenericToolkit2.GenericToolkitProvider;
+    const functionInvocationService = yield* FunctionInvocationService;
+    return {
+      resolve: (id) => Effect7.gen(function* () {
+        const toolkit = toolkitProvider.getToolkit();
+        const tool = toolkit.toolkit.tools[id];
+        if (tool) {
+          return tool;
+        }
+        return yield* functionInvocationService.resolveFunction(id).pipe(Effect7.map(projectFunctionToTool), Effect7.catchTag("FunctionNotFound", () => Effect7.fail(new AiToolNotFoundError(id))));
+      })
+    };
+  }));
+};
+var makeToolExecutionServiceFromFunctions = () => {
+  return Layer2.effect(ToolExecutionService2, Effect7.gen(function* () {
+    const toolkitProvider = yield* GenericToolkit2.GenericToolkitProvider;
+    const toolkit = toolkitProvider.getToolkit();
+    const toolkitHandler = yield* toolkit.toolkit.pipe(Effect7.provide(toolkit.layer));
+    invariant2(isHandlerLike(toolkitHandler), void 0, {
+      F: __dxlog_file5,
+      L: 82,
+      S: this,
+      A: [
+        "isHandlerLike(toolkitHandler)",
+        ""
+      ]
+    });
+    const functionInvocationService = yield* FunctionInvocationService;
+    return {
+      handlersFor: (toolkit2) => {
+        const makeHandler = (tool) => {
+          return Effect7.fn(`toolFunctionHandler ${tool.name}`)(function* (input) {
+            if (toolkitHandler.tools[tool.name]) {
+              if (Tool.isProviderDefined(tool)) {
+                throw new Error("Attempted to call a provider-defined tool");
+              }
+              const { result } = yield* toolkitHandler.handle(tool.name, input);
+              return result;
+            }
+            const functionDef = getOperationFromTool(tool).pipe(Option3.getOrThrow);
+            return yield* functionInvocationService.invokeFunction(functionDef, input).pipe(Effect7.catchAllDefect((defect) => Effect7.fail(defect)));
+          });
+        };
+        return toolkit2.of(Record2.map(toolkit2.tools, (tool, _name) => Tool.isUserDefined(tool) ? makeHandler(tool) : null));
+      }
+    };
+  }));
+};
+var makeToolResolverFromOperations = ({ toolkit: extraToolkit = GenericToolkit2.empty } = {}) => {
+  return Layer2.effect(ToolResolverService2, Effect7.gen(function* () {
+    const toolkitProvider = yield* GenericToolkit2.GenericToolkitProvider;
+    const operationRegistry = yield* OperationRegistry.Service;
+    return {
+      resolve: (id) => Effect7.gen(function* () {
+        const toolkit = GenericToolkit2.merge(extraToolkit, toolkitProvider.getToolkit());
+        const tool = toolkit.toolkit.tools[id];
+        if (tool) {
+          return tool;
+        }
+        return yield* operationRegistry.resolve(id).pipe(Effect7.flatMap(Option3.match({
+          onSome: (_) => Effect7.succeed(projectFunctionToTool(_)),
+          onNone: () => Effect7.fail(new AiToolNotFoundError(id))
+        })));
+      })
+    };
+  }));
+};
+var makeToolExecutionService = (opts) => Layer2.effect(ToolExecutionService2, Effect7.gen(function* () {
+  const toolkitProvider = yield* GenericToolkit2.GenericToolkitProvider;
+  const toolkit = toolkitProvider.getToolkit();
+  const toolkitHandler = yield* toolkit.toolkit.pipe(Effect7.provide(toolkit.layer));
+  invariant2(isHandlerLike(toolkitHandler), void 0, {
+    F: __dxlog_file5,
+    L: 162,
+    S: this,
+    A: [
+      "isHandlerLike(toolkitHandler)",
+      ""
+    ]
+  });
+  return {
+    handlersFor: (toolkit2) => {
+      const makeHandler = (tool) => {
+        return Effect7.fn(`toolFunctionHandler ${tool.name}`)(function* (input) {
+          if (toolkitHandler.tools[tool.name]) {
+            if (Tool.isProviderDefined(tool)) {
+              throw new Error("Attempted to call a provider-defined tool");
+            }
+            const { result } = yield* toolkitHandler.handle(tool.name, input);
+            return result;
+          }
+          return yield* opts.invoke(tool, input).pipe(Effect7.catchAllDefect((defect) => Effect7.fail(defect)));
+        });
+      };
+      return toolkit2.of(Record2.map(toolkit2.tools, (tool, _name) => Tool.isUserDefined(tool) ? makeHandler(tool) : null));
+    }
+  };
+}));
+var makeToolExecutionServiceFromOperationInvoker = () => {
+  return Layer2.unwrapEffect(Effect7.gen(function* () {
+    const operationInvoker = yield* Operation.Service;
+    return makeToolExecutionService({
+      invoke: (tool, input) => Effect7.gen(function* () {
+        const operationDef = getOperationFromTool(tool).pipe(Option3.getOrThrow);
+        return yield* operationInvoker.invoke(operationDef, input).pipe(Effect7.orDie);
+      })
+    });
+  }));
+};
+var functionInvocationServiceFromOperations = Layer2.effect(FunctionInvocationService, Effect7.gen(function* () {
+  const operationRegistry = yield* OperationRegistry.Service;
+  const operationInvoker = yield* Operation.Service;
+  return {
+    invokeFunction: (operationDef, input) => operationInvoker.invoke(operationDef, input).pipe(Effect7.orDie),
+    resolveFunction: (key) => operationRegistry.resolve(key).pipe(Effect7.flatten, Effect7.catchTag("NoSuchElementException", () => Effect7.fail(new FunctionNotFoundError(key))))
+  };
+}));
+var ToolExecutionServices = Layer2.mergeAll(makeToolResolverFromFunctions(), makeToolExecutionServiceFromFunctions());
+var FunctionToolAnnotation = class extends Context4.Tag("@dxos/assistant/FunctionToolAnnotation")() {
+};
+var getOperationFromTool = (tool) => {
+  return Context4.getOption(FunctionToolAnnotation)(tool.annotations).pipe(Option3.map(({ definition }) => definition));
+};
+var toolCache = /* @__PURE__ */ new WeakMap();
+var projectFunctionToTool = (fn3) => {
+  if (toolCache.has(fn3)) {
+    return toolCache.get(fn3);
+  }
+  const tool = Tool.make(makeToolName(fn3.meta.name ?? fn3.meta.key), {
+    description: fn3.meta.description,
+    parameters: createStructFieldsFromSchema(fn3.input),
+    failure: Schema5.Any
+  }).annotate(FunctionToolAnnotation, {
+    definition: fn3
+  });
+  toolCache.set(fn3, tool);
+  return tool;
+};
+var makeToolName = (name) => {
+  const toolName = name.toLowerCase().replace(/[^a-zA-Z0-9]/g, "-");
+  invariant2(toolName.match(/^[a-z_][a-z0-9-_]*$/), void 0, {
+    F: __dxlog_file5,
+    L: 272,
+    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,
+        Schema5.make(mapSchemaTypeForLLM(prop.type))
+      ]));
+    case "VoidKeyword":
+      return {};
+    default:
+      return todo(`Unsupported schema AST: ${schema.ast._tag}`);
+  }
+};
+var mapSchemaTypeForLLM = (ast) => {
+  if (Ref3.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 = (value2) => {
+  return typeof value2.tools === "object" && typeof value2.handle === "function";
+};
+
+// src/service/agent-process.ts
+import * as Effect8 from "effect/Effect";
+import * as Schema6 from "effect/Schema";
+import { AiService, GenericToolkit as GenericToolkit3 } from "@dxos/ai";
+import { Database as Database2, DXN as DXN3, Feed, Obj as Obj7 } from "@dxos/echo";
+import { QueueService as QueueService2, TracingService as TracingService2 } from "@dxos/functions";
+import { Process, ProcessManager, StorageService } from "@dxos/functions-runtime";
+import { Operation as Operation2, OperationRegistry as OperationRegistry2 } from "@dxos/operation";
+import { trim as trim3 } from "@dxos/util";
+import * as Tool2 from "@effect/ai/Tool";
+import * as Toolkit2 from "@effect/ai/Toolkit";
+import * as Duration from "effect/Duration";
+import * as Exit from "effect/Exit";
+import * as Layer3 from "effect/Layer";
+import * as Option4 from "effect/Option";
+import { acquireReleaseResource as acquireReleaseResource2 } from "@dxos/effect";
+import { log as log5 } from "@dxos/log";
+import * as Match from "effect/Match";
+import * as Cause from "effect/Cause";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/core/assistant/src/service/agent-process.ts";
+var AGENT_PROCESS_KEY = "org.dxos.testing.process.agent";
+var AgentProcess = (options) => Process.make({
+  key: AGENT_PROCESS_KEY,
+  input: Schema6.String,
+  output: Schema6.Void,
+  services: [
+    Database2.Service,
+    GenericToolkit3.GenericToolkitProvider,
+    Operation2.Service,
+    OperationRegistry2.Service,
+    StorageService.StorageService,
+    QueueService2,
+    ProcessManager.ProcessOperationInvoker.Service,
+    AiService.AiService,
+    // @deprecated Required by AiSessionRunRequirements for backward compat with tool handlers.
+    TracingService2
+  ]
+}, (ctx) => Effect8.gen(function* () {
+  const feedDxn = ctx.params.target;
+  if (feedDxn == null) {
+    return yield* Effect8.die(new Error("Agent executable requires spawn options.target set to a queue DXN."));
+  }
+  const feed = yield* Database2.resolve(DXN3.parse(feedDxn), Feed.Feed).pipe(Effect8.orDie);
+  const queue = yield* QueueService2.getQueue(Feed.getQueueDxn(feed));
+  const conversation = yield* acquireReleaseResource2(() => new AiConversation({
+    queue
+  }));
+  let inputQueue = [
+    ...yield* AgentEventsKey.get
+  ];
+  const storageService = yield* StorageService.StorageService;
+  const toolCallManager = new ToolCallManager(storageService);
+  yield* toolCallManager.load();
+  return {
+    onInput: Effect8.fnUntraced(function* (prompt) {
+      log5("agent onInput received", {
+        promptLength: prompt.length,
+        backlog: inputQueue.length
+      }, {
+        F: __dxlog_file6,
+        L: 80,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      inputQueue.push({
+        _tag: "prompt",
+        content: prompt
+      });
+      log5("agent onInput persisting queue", {
+        depth: inputQueue.length
+      }, {
+        F: __dxlog_file6,
+        L: 82,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      yield* AgentEventsKey.set(inputQueue);
+      log5("agent onInput persisted", {
+        depth: inputQueue.length
+      }, {
+        F: __dxlog_file6,
+        L: 84,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      ctx.setAlarm();
+      log5("agent onInput alarm scheduled", void 0, {
+        F: __dxlog_file6,
+        L: 86,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }),
+    onAlarm: Effect8.fnUntraced(function* () {
+      log5("agent onAlarm fired", {
+        pending: inputQueue.length
+      }, {
+        F: __dxlog_file6,
+        L: 90,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const item = inputQueue.shift();
+      if (!item) {
+        log5("agent onAlarm empty queue", {}, {
+          F: __dxlog_file6,
+          L: 93,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      if (item._tag === "tool_result" && toolCallManager.isReported(item.pid)) {
+        log5.info("skip tool result that was reported synchronously", {
+          pid: item.pid
+        }, {
+          F: __dxlog_file6,
+          L: 98,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      log5("agent onAlarm handling", {
+        tag: item._tag
+      }, {
+        F: __dxlog_file6,
+        L: 103,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const prompt = Match.value(item).pipe(Match.tag("prompt", (item2) => item2.content), Match.tag("tool_result", (item2) => item2.isError ? toolErrorResponse(item2.pid, item2.result) : toolResultResponse(item2.pid, item2.result)), Match.exhaustive);
+      log5("begin request", {
+        prompt
+      }, {
+        F: __dxlog_file6,
+        L: 115,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      yield* conversation.createRequest({
+        prompt,
+        // TODO(dmaretskyi): Polling currently broken, agent relies on completion notifications being delivered.
+        // toolkit: AsynchronousExectionToolkit,
+        system: options.systemPrompt
+      });
+      log5("end request", void 0, {
+        F: __dxlog_file6,
+        L: 122,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      yield* AgentEventsKey.set(inputQueue);
+      if (inputQueue.length > 0) {
+        ctx.setAlarm();
+      }
+    }, Effect8.orDie, Effect8.provide(Layer3.mergeAll(makeToolResolverFromOperations(), ToolExecutionService3({
+      toolCallManager,
+      feed
+    }), functionInvocationServiceFromOperations, AsynchronousExectionToolkitLayer, AiService.model(options.model ?? "@anthropic/claude-opus-4-6")).pipe(Layer3.orDie))),
+    onChildEvent: Effect8.fnUntraced(function* (event) {
+      log5.info("childEvent", {
+        event
+      }, {
+        F: __dxlog_file6,
+        L: 143,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (event._tag === "exited") {
+        if (!toolCallManager.isToolCall(event.pid)) {
+          log5.verbose("childEvent ignored non-tool call", {
+            pid: event.pid
+          }, {
+            F: __dxlog_file6,
+            L: 146,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return;
+        }
+        const operationInvoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+        const fiber = yield* operationInvoker.attachFiber(event.pid).pipe(Effect8.orDie);
+        const result = yield* fiber.await.pipe(Effect8.orDie).pipe(Effect8.map(Exit.match({
+          onSuccess: (value2) => ({
+            _tag: "tool_result",
+            pid: event.pid,
+            result: value2,
+            isError: false
+          }),
+          onFailure: (cause) => ({
+            _tag: "tool_result",
+            pid: event.pid,
+            result: Cause.pretty(cause),
+            isError: true
+          })
+        })));
+        inputQueue.push(result);
+        log5("agent onChildEvent persisted tool result", {
+          depth: inputQueue.length,
+          childPid: event.pid
+        }, {
+          F: __dxlog_file6,
+          L: 171,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        yield* AgentEventsKey.set(inputQueue);
+        ctx.setAlarm();
+        log5("agent onChildEvent alarm scheduled", {
+          depth: inputQueue.length
+        }, {
+          F: __dxlog_file6,
+          L: 174,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    })
+  };
+}));
+var AgentEvent = Schema6.Union(Schema6.TaggedStruct("prompt", {
+  content: Schema6.String
+}), Schema6.TaggedStruct("tool_result", {
+  pid: Process.ID,
+  result: Schema6.Unknown,
+  isError: Schema6.Boolean
+}));
+var AgentEventsKey = StorageService.key(Schema6.parseJson(Schema6.Array(AgentEvent).pipe(Schema6.mutable)), "inputQueue").pipe(StorageService.withDefault(() => []));
+var ToolCallState = Schema6.Struct({
+  activeCalls: Schema6.Array(Schema6.Struct({
+    pid: Process.ID,
+    // Whether the result was reported to the agent.
+    reported: Schema6.Boolean
+  }).pipe(Schema6.mutable)).pipe(Schema6.mutable)
+});
+var ToolCallStateKey = StorageService.key(Schema6.parseJson(ToolCallState.pipe(Schema6.mutable)), "toolCallState").pipe(StorageService.withDefault(() => ({
+  activeCalls: []
+})));
+var ToolCallManager = class {
+  #storageService;
+  #state = {
+    activeCalls: []
+  };
+  constructor(storageService) {
+    this.#storageService = storageService;
+  }
+  load() {
+    return Effect8.gen(this, function* () {
+      this.#state = yield* ToolCallStateKey.get;
+    }).pipe(Effect8.provideService(StorageService.StorageService, this.#storageService));
+  }
+  beginCall(pid) {
+    return Effect8.gen(this, function* () {
+      this.#state.activeCalls.push({
+        pid,
+        reported: false
+      });
+      yield* ToolCallStateKey.set(this.#state);
+    }).pipe(Effect8.provideService(StorageService.StorageService, this.#storageService));
+  }
+  markAsReported(pid) {
+    return Effect8.gen(this, function* () {
+      const call = this.#state.activeCalls.find((call2) => call2.pid === pid);
+      if (!call) {
+        return;
+      }
+      call.reported = true;
+      yield* ToolCallStateKey.set(this.#state);
+    }).pipe(Effect8.provideService(StorageService.StorageService, this.#storageService));
+  }
+  isToolCall(pid) {
+    return this.#state.activeCalls.some((call) => call.pid === pid);
+  }
+  isReported(pid) {
+    return this.#state.activeCalls.some((call) => call.pid === pid && call.reported);
+  }
+};
+var ToolExecutionService3 = ({ backgroundThreshold = Duration.seconds(1), toolCallManager, feed }) => Layer3.unwrapEffect(Effect8.gen(function* () {
+  const operationInvoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+  return makeToolExecutionService({
+    invoke: (tool, input) => Effect8.gen(function* () {
+      const operationDef = getOperationFromTool(tool).pipe(Option4.getOrThrow);
+      log5("invoking operation", {
+        operationDef,
+        input
+      }, {
+        F: __dxlog_file6,
+        L: 278,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const fiber = yield* operationInvoker.invokeFiber(operationDef, input, {
+        environment: {
+          conversation: Obj7.getDXN(feed).toString()
+        }
+      });
+      toolCallManager.beginCall(fiber.pid);
+      log5("invoked operation", {
+        operationDef,
+        input,
+        fiber
+      }, {
+        F: __dxlog_file6,
+        L: 285,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const result = yield* fiber.await.pipe(Effect8.tap(() => toolCallManager.markAsReported(fiber.pid)), Effect8.timeout(backgroundThreshold), Effect8.catchTag("TimeoutException", () => Effect8.succeed(toolIsRunningInBackgroundResponse(fiber.pid))));
+      log5("result", {
+        result
+      }, {
+        F: __dxlog_file6,
+        L: 292,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return result;
+    })
+  });
+}));
+var AsynchronousExectionToolkit = class extends Toolkit2.make(Tool2.make("poll-tools", {
+  description: trim3`
+      Poll tool calls running in the background.
+      Set wait to true to wait for the tool call to complete before returning.
+      Only set wait to true if you dont have other tasks to perform in parallel.
+      Set an appropriate timeout to avoid waiting forever.
+      You will also be notified about the job completion separatelly, so you do not always need to inspect the job if you dont need the result right now.
+    `,
+  parameters: {
+    ids: Schema6.Array(Schema6.String).annotations({
+      description: "The IDs of the jobs to inspect."
+    }),
+    wait: Schema6.optional(Schema6.Boolean).annotations({
+      description: "Whether to wait for the job to complete before returning.",
+      default: false
+    }),
+    timeout: Schema6.optional(Schema6.Number).annotations({
+      description: "Maximum time to wait for the job to complete. If the job does not complete within the timeout, the current state is returned.",
+      default: 1e4
+    })
+  }
+})) {
+};
+var AsynchronousExectionToolkitLayer = AsynchronousExectionToolkit.toLayer(Effect8.gen(function* () {
+  const invoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+  return {
+    "poll-tools": ({ ids, wait, timeout: timeout2 = 1e4 }) => Effect8.gen(function* () {
+      return yield* Effect8.forEach(ids, (pid) => invoker.attachFiber(Process.ID.make(pid)).pipe(Effect8.flatMap((_) => _.await), Effect8.timeout(Duration.millis(timeout2)), Effect8.flatMap(Exit.match({
+        onSuccess: (value2) => Effect8.succeed(toolResultResponse(pid, value2)),
+        onFailure: (cause) => Effect8.succeed(toolErrorResponse(pid, Cause.pretty(cause)))
+      })), Effect8.catchTag("ProcessNotFoundError", () => Effect8.succeed(`Process not found: ${pid}`)), Effect8.catchTag("TimeoutException", () => Effect8.succeed(`Process still running: ${pid}`))));
+    })
+  };
+}));
+var toolIsRunningInBackgroundResponse = (pid) => `Tool is running in the background id=${pid}; wait for the completion notification to get the result.`;
+var toolResultResponse = (pid, value2) => `<result pid=${pid}>${JSON.stringify(value2)}</result>`;
+var toolErrorResponse = (pid, cause) => `<error pid=${pid}>${cause}</error>`;
+
+// src/service/AgentService.ts
+var AgentService_exports = {};
+__export(AgentService_exports, {
+  AgentService: () => AgentService,
+  createSession: () => createSession,
+  getSession: () => getSession,
+  layer: () => layer
+});
+import { Database as Database3, Feed as Feed2, Obj as Obj8 } from "@dxos/echo";
+import * as Context5 from "effect/Context";
+import * as Effect9 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
+import { Blueprint as Blueprint2 } from "@dxos/blueprints";
+import { ProcessManager as ProcessManager2 } from "@dxos/functions-runtime";
+import { failedInvariant } from "@dxos/invariant";
+import { Ref as Ref4 } from "@dxos/echo";
+import { QueueService as QueueService3 } from "@dxos/functions";
+import { acquireReleaseResource as acquireReleaseResource3 } from "@dxos/effect";
+var AgentService = class extends Context5.Tag("@dxos/assistant/AgentService")() {
+};
+var getSession = Effect9.serviceFunctionEffect(AgentService, (service) => service.getSession);
+var createSession = Effect9.fn("createSession")(function* (opts) {
+  const blueprints = yield* Effect9.forEach(opts?.blueprints ?? [], (blueprint) => Blueprint2.upsert(blueprint.key).pipe(Effect9.map(Ref4.make)));
+  const feed = yield* Database3.add(Feed2.make());
+  const queueDxn = Feed2.getQueueDxn(feed) ?? failedInvariant();
+  const queue = yield* QueueService3.getQueue(queueDxn);
+  const binder = yield* acquireReleaseResource3(() => new AiContextBinder({
+    queue
+  }));
+  yield* Effect9.promise(() => binder.bind({
+    blueprints,
+    objects: opts?.context ?? []
+  }));
+  return yield* getSession(feed);
+}, Effect9.scoped);
+var layer = (opts) => Layer4.effect(AgentService, Effect9.gen(function* () {
+  const processManager = yield* ProcessManager2.ProcessManagerService;
+  const sessionCache = /* @__PURE__ */ new Map();
+  return {
+    getSession: (feed) => Effect9.gen(function* () {
+      const cached = sessionCache.get(feed.id);
+      if (cached) {
+        return cached;
+      }
+      const target = Obj8.getDXN(feed).toString();
+      const executable = AgentProcess({
+        systemPrompt: opts?.systemPrompt
+      });
+      const processes = yield* processManager.list({
+        target,
+        key: executable.key
+      });
+      let handle;
+      if (processes.length > 0) {
+        handle = processes[0];
+      } else {
+        handle = yield* processManager.spawn(executable, {
+          name: "agent",
+          target,
+          traceMeta: {
+            conversationId: feed.id
+          }
+        });
+      }
+      const session = makeSession(handle, feed);
+      sessionCache.set(feed.id, session);
+      return session;
+    })
+  };
+}));
+var makeSession = (process, feed) => ({
+  feed,
+  submitPrompt: (prompt) => process.submitInput(prompt),
+  waitForCompletion: () => process.runToCompletion(),
+  subscribeEphemeral: () => process.subscribeEphemeral(),
+  addContext: (context) => Effect9.gen(function* () {
+    const queueDxn = Feed2.getQueueDxn(feed) ?? failedInvariant();
+    const queue = yield* QueueService3.getQueue(queueDxn);
+    const binder = yield* acquireReleaseResource3(() => new AiContextBinder({
+      queue
+    }));
+    yield* Effect9.promise(() => binder.bind({
+      blueprints: [],
+      objects: context
+    }));
+  }).pipe(Effect9.scoped),
+  getContext: () => Effect9.gen(function* () {
+    const queueDxn = Feed2.getQueueDxn(feed) ?? failedInvariant();
+    const queue = yield* QueueService3.getQueue(queueDxn);
+    const binder = yield* acquireReleaseResource3(() => new AiContextBinder({
+      queue
+    }));
+    return binder.getObjects().map((object) => Ref4.make(object));
+  }).pipe(Effect9.scoped)
+});
+
+export {
+  ContextBinding,
+  Bindings,
+  AiContextBinder,
+  AiContextService,
+  ArtifactDiffResolver,
+  GenerationObserver,
+  AiModelError,
+  AiAssistantError,
+  formatSystemPrompt,
+  formatUserPrompt,
+  PartialBlock,
+  CompleteBlock,
+  AgentTurnStarted,
+  AgentTurnCompleted,
+  ToolCallStarted,
+  ToolCallCompleted,
+  AgentInputReceived,
+  AgentRequestCompleted,
+  AiSession,
+  createToolkit,
+  VersionPin,
+  AiConversation,
+  AiConversationService,
+  createArtifactElement,
+  ArtifactId,
+  RefFromLLM,
+  makeToolResolverFromFunctions,
+  makeToolExecutionServiceFromFunctions,
+  makeToolResolverFromOperations,
+  makeToolExecutionService,
+  makeToolExecutionServiceFromOperationInvoker,
+  functionInvocationServiceFromOperations,
+  ToolExecutionServices,
+  getOperationFromTool,
+  AGENT_PROCESS_KEY,
+  AgentService_exports
+};
+//# sourceMappingURL=chunk-KVYJFFLF.mjs.map