@dxos/assistant 0.8.2-main.fbd8ed0 → 0.8.2-staging.4d6ad0f

package/dist/lib/browser/chunk-B4HAWUFW.mjs

@@ -1,2786 +0,0 @@
-// packages/experimental/assistant/src/ai-service/defs.ts
-var DEFAULT_EDGE_MODEL = "@anthropic/claude-3-5-sonnet-20241022";
-var DEFAULT_EDGE_MODELS = [
-  // AI Gateway.
-  // https://developers.cloudflare.com/ai-gateway
-  "@anthropic/claude-3-5-haiku-20241022",
-  "@anthropic/claude-3-5-sonnet-20241022",
-  "@anthropic/claude-3-7-sonnet-20250219",
-  // Workers AI.
-  // https://developers.cloudflare.com/workers-ai/models
-  "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b",
-  "@hf/nousresearch/hermes-2-pro-mistral-7b",
-  "@ollama/llama-3-1-nemotron-70b-instruct",
-  "@ollama/llama-3-1-nemotron-mini-4b-instruct",
-  "@ollama/llama-3-2-3b"
-];
-var DEFAULT_OLLAMA_ENDPOINT = "http://localhost:11434";
-var DEFAULT_OLLAMA_MODEL = "llama3.2:1b";
-var DEFAULT_OLLAMA_MODELS = [
-  //
-  "llama3.2:1b",
-  "llama3:70b",
-  "deepseek-r1:latest"
-];
-
-// packages/experimental/assistant/src/ai-service/stream.ts
-import { Trigger } from "@dxos/async";
-import { log } from "@dxos/log";
-
-// packages/experimental/assistant/src/ai-service/util/sse.ts
-async function* iterSSEMessages(response, controller) {
-  if (!response.body) {
-    controller.abort();
-    throw new Error("Attempted to iterate over a response with no body");
-  }
-  const sseDecoder = new SSEDecoder();
-  const lineDecoder = new LineDecoder();
-  const iter = readableStreamAsyncIterable(response.body);
-  for await (const sseChunk of iterSSEChunks(iter)) {
-    for (const line of lineDecoder.decode(sseChunk)) {
-      const sse = sseDecoder.decode(line);
-      if (sse) {
-        yield sse;
-      }
-    }
-  }
-  for (const line of lineDecoder.flush()) {
-    const sse = sseDecoder.decode(line);
-    if (sse) {
-      yield sse;
-    }
-  }
-}
-async function* iterSSEChunks(iterator) {
-  let data = new Uint8Array();
-  for await (const chunk of iterator) {
-    if (chunk == null) {
-      continue;
-    }
-    const binaryChunk = chunk instanceof ArrayBuffer ? new Uint8Array(chunk) : typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
-    const newData = new Uint8Array(data.length + binaryChunk.length);
-    newData.set(data);
-    newData.set(binaryChunk, data.length);
-    data = newData;
-    let patternIndex;
-    while ((patternIndex = findDoubleNewlineIndex(data)) !== -1) {
-      yield data.slice(0, patternIndex);
-      data = data.slice(patternIndex);
-    }
-  }
-  if (data.length > 0) {
-    yield data;
-  }
-}
-var findDoubleNewlineIndex = (buffer) => {
-  const newline = 10;
-  const carriage = 13;
-  for (let i = 0; i < buffer.length - 2; i++) {
-    if (buffer[i] === newline && buffer[i + 1] === newline) {
-      return i + 2;
-    }
-    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
-      return i + 2;
-    }
-    if (buffer[i] === carriage && buffer[i + 1] === newline && i + 3 < buffer.length && buffer[i + 2] === carriage && buffer[i + 3] === newline) {
-      return i + 4;
-    }
-  }
-  return -1;
-};
-var SSEDecoder = class {
-  constructor() {
-    this.event = null;
-    this.data = [];
-    this.chunks = [];
-  }
-  decode(line) {
-    if (line.endsWith("\r")) {
-      line = line.substring(0, line.length - 1);
-    }
-    if (!line) {
-      if (!this.event && !this.data.length) {
-        return null;
-      }
-      const sse = {
-        event: this.event,
-        data: this.data.join("\n"),
-        raw: this.chunks
-      };
-      this.event = null;
-      this.data = [];
-      this.chunks = [];
-      return sse;
-    }
-    this.chunks.push(line);
-    if (line.startsWith(":")) {
-      return null;
-    }
-    let [fieldname, _, value] = partition(line, ":");
-    if (value.startsWith(" ")) {
-      value = value.substring(1);
-    }
-    if (fieldname === "event") {
-      this.event = value;
-    } else if (fieldname === "data") {
-      this.data.push(value);
-    }
-    return null;
-  }
-};
-var partition = (str, delimiter) => {
-  const index = str.indexOf(delimiter);
-  if (index !== -1) {
-    return [
-      str.substring(0, index),
-      delimiter,
-      str.substring(index + delimiter.length)
-    ];
-  }
-  return [
-    str,
-    "",
-    ""
-  ];
-};
-function readableStreamAsyncIterable(stream) {
-  if (stream[Symbol.asyncIterator]) {
-    return stream;
-  }
-  const reader = stream.getReader();
-  return {
-    next: async () => {
-      try {
-        const result = await reader.read();
-        if (result?.done) {
-          reader.releaseLock();
-        }
-        return result;
-      } catch (e) {
-        reader.releaseLock();
-        throw e;
-      }
-    },
-    return: async () => {
-      const cancelPromise = reader.cancel();
-      reader.releaseLock();
-      await cancelPromise;
-      return {
-        done: true,
-        value: void 0
-      };
-    },
-    [Symbol.asyncIterator]() {
-      return this;
-    }
-  };
-}
-var LineDecoder = class _LineDecoder {
-  static {
-    // prettier-ignore
-    this.NEWLINE_CHARS = /* @__PURE__ */ new Set([
-      "\n",
-      "\r"
-    ]);
-  }
-  static {
-    this.NEWLINE_REGEXP = /\r\n|[\n\r]/g;
-  }
-  constructor() {
-    this.buffer = [];
-    this.trailingCR = false;
-  }
-  decode(chunk) {
-    let text = this.decodeText(chunk);
-    if (this.trailingCR) {
-      text = "\r" + text;
-      this.trailingCR = false;
-    }
-    if (text.endsWith("\r")) {
-      this.trailingCR = true;
-      text = text.slice(0, -1);
-    }
-    if (!text) {
-      return [];
-    }
-    const trailingNewline = _LineDecoder.NEWLINE_CHARS.has(text[text.length - 1] || "");
-    let lines = text.split(_LineDecoder.NEWLINE_REGEXP);
-    if (trailingNewline) {
-      lines.pop();
-    }
-    if (lines.length === 1 && !trailingNewline) {
-      this.buffer.push(lines[0]);
-      return [];
-    }
-    if (this.buffer.length > 0) {
-      lines = [
-        this.buffer.join("") + lines[0],
-        ...lines.slice(1)
-      ];
-      this.buffer = [];
-    }
-    if (!trailingNewline) {
-      this.buffer = [
-        lines.pop() || ""
-      ];
-    }
-    return lines;
-  }
-  decodeText(bytes) {
-    if (bytes == null) {
-      return "";
-    }
-    if (typeof bytes === "string") {
-      return bytes;
-    }
-    if (typeof Buffer !== "undefined") {
-      if (bytes instanceof Buffer) {
-        return bytes.toString();
-      }
-      if (bytes instanceof Uint8Array) {
-        return Buffer.from(bytes).toString();
-      }
-      throw new Error(`Unexpected: received non-Uint8Array (${bytes.constructor.name}) stream chunk in an environment with a global "Buffer" defined, which this library assumes to be Node. Please report this error.`);
-    }
-    if (typeof TextDecoder !== "undefined") {
-      if (bytes instanceof Uint8Array || bytes instanceof ArrayBuffer) {
-        this.textDecoder ??= new TextDecoder("utf8");
-        return this.textDecoder.decode(bytes);
-      }
-      throw new Error(`Unexpected: received non-Uint8Array/ArrayBuffer (${bytes.constructor.name}) in a web platform. Please report this error.`);
-    }
-    throw new Error("Unexpected: neither Buffer nor TextDecoder are available as globals. Please report this error.");
-  }
-  flush() {
-    if (!this.buffer.length && !this.trailingCR) {
-      return [];
-    }
-    const lines = [
-      this.buffer.join("")
-    ];
-    this.buffer = [];
-    this.trailingCR = false;
-    return lines;
-  }
-};
-
-// packages/experimental/assistant/src/ai-service/stream.ts
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/ai-service/stream.ts";
-var createGenerationStream = (response, controller = new AbortController()) => {
-  const iterator = async function* () {
-    for await (const sse of iterSSEMessages(response, controller)) {
-      if (sse.event === "completion") {
-        try {
-          yield JSON.parse(sse.data);
-        } catch (err) {
-          log.error("could not parse message into JSON:", {
-            data: sse.data,
-            raw: sse.raw
-          }, {
-            F: __dxlog_file,
-            L: 22,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          throw err;
-        }
-      }
-      if (sse.event === "message_start" || sse.event === "message_delta" || sse.event === "message_stop" || sse.event === "content_block_start" || sse.event === "content_block_delta" || sse.event === "content_block_stop") {
-        try {
-          yield JSON.parse(sse.data);
-        } catch (err) {
-          log.error("could not parse message into JSON:", {
-            data: sse.data,
-            raw: sse.raw
-          }, {
-            F: __dxlog_file,
-            L: 38,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          throw err;
-        }
-      }
-      if (sse.event === "ping") {
-        continue;
-      }
-      if (sse.event === "error") {
-        throw new Error(`Message generation error: ${sse.data}`);
-      }
-    }
-  };
-  return new GenerationStreamImpl(controller, iterator);
-};
-var GenerationStreamImpl = class {
-  constructor(_controller, _getIterator) {
-    this._controller = _controller;
-    this._getIterator = _getIterator;
-    this._done = new Trigger();
-    this._iterator = void 0;
-  }
-  /**
-  * Returns an iterator over the stream.
-  */
-  [Symbol.asyncIterator]() {
-    return this._createIterator();
-  }
-  /**
-  * Aborts the stream.
-  */
-  abort() {
-    this._controller.abort();
-  }
-  /**
-  * Returns the complete message list generated by the AI service.
-  */
-  async complete() {
-    await this._done.wait();
-  }
-  /**
-  * Creates an iterator over the stream.
-  */
-  _createIterator() {
-    const self = this;
-    return this._iterator ??= (() => {
-      const generator = async function* () {
-        try {
-          for await (const event of self._getIterator()) {
-            yield event;
-          }
-          this._done.wake();
-        } catch (err) {
-          this._done.throw(err);
-          throw err;
-        }
-      };
-      return generator.call(this);
-    })();
-  }
-};
-
-// packages/experimental/assistant/src/ai-service/edge-client.ts
-import { assertArgument, invariant } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/ai-service/edge-client.ts";
-var AIServiceEdgeClient = class {
-  constructor({ endpoint }) {
-    invariant(endpoint, "endpoint is required", {
-      F: __dxlog_file2,
-      L: 20,
-      S: this,
-      A: [
-        "endpoint",
-        "'endpoint is required'"
-      ]
-    });
-    this._endpoint = endpoint;
-  }
-  /**
-  * Generate non-streaming response.
-  */
-  async exec(request) {
-    throw new Error("Not implemented");
-  }
-  /**
-  * Process request and open message stream.
-  */
-  async execStream(request) {
-    assertArgument(typeof request.model === "string", "model is required");
-    log2("requesting", {
-      endpoint: this._endpoint
-    }, {
-      F: __dxlog_file2,
-      L: 36,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const controller = new AbortController();
-    const response = await fetch(`${this._endpoint}/generate`, {
-      signal: controller.signal,
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        // TODO(dmaretskyi): Errors if tools are not provided.
-        tools: request.tools ?? [],
-        ...request
-      })
-    });
-    if (!response.ok) {
-      throw await parseErrorResponse(response);
-    }
-    invariant(response.body instanceof ReadableStream, void 0, {
-      F: __dxlog_file2,
-      L: 53,
-      S: this,
-      A: [
-        "response.body instanceof ReadableStream",
-        ""
-      ]
-    });
-    return createGenerationStream(response, controller);
-  }
-};
-var parseErrorResponse = async (response) => {
-  throw new Error(`AI Service error: ${response.status} ${response.statusText} ${await response.text()}`);
-};
-
-// packages/experimental/assistant/src/ai-service/message-collector.ts
-var MessageCollector = class {
-  constructor() {
-    this._messages = [];
-    this._pendingMessage = void 0;
-  }
-  get messages() {
-    return this._messages;
-  }
-  get pendingMessage() {
-    return this._pendingMessage;
-  }
-  push(event) {
-    switch (event.type) {
-      case "message_start":
-        this._pendingMessage = event.message;
-        break;
-      case "message_stop":
-        if (this._pendingMessage) {
-          this._messages.push(this._pendingMessage);
-          this._pendingMessage = void 0;
-        }
-        break;
-      case "content_block_start":
-        if (this._pendingMessage) {
-          this._pendingMessage.content = this._pendingMessage.content || [];
-          this._pendingMessage.content[event.index] = event.content;
-        }
-        break;
-      case "content_block_delta":
-        if (this._pendingMessage && this._pendingMessage.content) {
-          const block = this._pendingMessage.content[event.index];
-          if (block && event.delta.type === "text_delta" && block.type === "text") {
-            block.text = (block.text || "") + event.delta.text;
-          }
-        }
-        break;
-      case "content_block_stop":
-        if (this._pendingMessage && this._pendingMessage.content) {
-          const block = this._pendingMessage.content[event.index];
-          if (block) {
-            block.pending = false;
-          }
-        }
-        break;
-      case "message_delta":
-        if (this._pendingMessage && event.delta) {
-          Object.assign(this._pendingMessage, event.delta);
-        }
-        break;
-    }
-  }
-  pushMessage(message) {
-    this._messages.push(message);
-  }
-};
-function* emitMessageAsEvents(message) {
-  yield {
-    type: "message_start",
-    message
-  };
-  yield {
-    type: "message_stop"
-  };
-}
-
-// packages/experimental/assistant/src/ai-service/types.ts
-import { Schema } from "effect";
-import { Tool, Message } from "@dxos/artifact";
-var createArtifactElement = (id) => `<artifact id=${id} />`;
-var LLMModel = Schema.Literal(...DEFAULT_EDGE_MODELS, ...DEFAULT_OLLAMA_MODELS);
-var ToolTypes = Object.freeze({
-  // TODO(dmaretskyi): Not implemented yet.
-  // DatabaseQuery: 'database_query',
-  TextToImage: "text_to_image"
-});
-var GenerateRequest = Schema.Struct({
-  /**
-  * Preferred model or system default.
-  */
-  model: Schema.optional(LLMModel),
-  /**
-  * Tools available for the LLM.
-  */
-  tools: Schema.optional(Schema.Array(Tool).pipe(Schema.mutable)),
-  /**
-  * System instructions to the LLM.
-  */
-  systemPrompt: Schema.optional(Schema.String),
-  /**
-  * History of messages to include in the context window.
-  */
-  // TODO(burdon): Rename messages.
-  history: Schema.optional(Schema.Array(Message)),
-  /**
-  * Current request.
-  */
-  prompt: Schema.optional(Message)
-});
-var GenerateResponse = Schema.Struct({
-  messages: Schema.Array(Message),
-  /**
-  * Number of tokens used in the response.
-  */
-  tokenCount: Schema.optional(Schema.Number)
-});
-
-// packages/experimental/assistant/src/session/tools.ts
-import { Message as Message2, ToolResult } from "@dxos/artifact";
-import { create } from "@dxos/echo-schema";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { log as log3 } from "@dxos/log";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/session/tools.ts";
-var isToolUse = (message, { onlyToolNames } = {}) => {
-  const block = message.content.at(-1);
-  invariant2(block, void 0, {
-    F: __dxlog_file3,
-    L: 12,
-    S: void 0,
-    A: [
-      "block",
-      ""
-    ]
-  });
-  return block.type === "tool_use" && (!onlyToolNames || onlyToolNames.includes(block.name));
-};
-var runTools = async ({ message, tools, extensions }) => {
-  const toolCalls = message.content.filter((block) => block.type === "tool_use");
-  invariant2(toolCalls.length === 1, void 0, {
-    F: __dxlog_file3,
-    L: 34,
-    S: void 0,
-    A: [
-      "toolCalls.length === 1",
-      ""
-    ]
-  });
-  const toolCall = toolCalls[0];
-  const tool = tools.find((tool2) => tool2.name === toolCall.name);
-  if (!tool) {
-    const resultMessage = create(Message2, {
-      role: "user",
-      content: [
-        {
-          type: "tool_result",
-          toolUseId: toolCall.id,
-          content: `Tool not found: ${toolCall.name}`,
-          isError: true
-        }
-      ]
-    });
-    return {
-      type: "continue",
-      message: resultMessage
-    };
-  }
-  let toolResult;
-  try {
-    invariant2(tool.execute, void 0, {
-      F: __dxlog_file3,
-      L: 59,
-      S: void 0,
-      A: [
-        "tool.execute",
-        ""
-      ]
-    });
-    toolResult = await tool.execute(toolCall.input, {
-      extensions
-    });
-  } catch (error) {
-    log3("tool error", {
-      error
-    }, {
-      F: __dxlog_file3,
-      L: 62,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    toolResult = ToolResult.Error(error.message);
-  }
-  switch (toolResult.kind) {
-    case "error": {
-      log3("tool error", {
-        message: toolResult.message
-      }, {
-        F: __dxlog_file3,
-        L: 68,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      const resultMessage = create(Message2, {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            toolUseId: toolCall.id,
-            content: toolResult.message,
-            isError: true
-          }
-        ]
-      });
-      return {
-        type: "continue",
-        message: resultMessage
-      };
-    }
-    case "success": {
-      log3("tool success", {
-        result: toolResult.result
-      }, {
-        F: __dxlog_file3,
-        L: 89,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      const resultMessage = create(Message2, {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            toolUseId: toolCall.id,
-            content: typeof toolResult.result === "string" ? toolResult.result : JSON.stringify(toolResult.result) ?? ""
-          },
-          ...toolResult.extractContentBlocks ?? []
-        ]
-      });
-      return {
-        type: "continue",
-        message: resultMessage
-      };
-    }
-    case "break": {
-      log3("tool break", {
-        result: toolResult.result
-      }, {
-        F: __dxlog_file3,
-        L: 110,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      return {
-        type: "break",
-        result: toolResult.result
-      };
-    }
-  }
-};
-
-// packages/experimental/assistant/src/session/version-pin.ts
-import { Schema as Schema2 } from "effect";
-import { getVersion } from "@dxos/echo-db";
-import { ObjectId } from "@dxos/echo-schema";
-var ObjectVersionSchema = Schema2.Unknown;
-var VersionPinSchema = Schema2.Struct({
-  // TODO(dmaretskyi): Use Ref when those support encoding.
-  objectId: ObjectId,
-  // TODO(dmaretskyi): Could be opaque
-  version: ObjectVersionSchema
-});
-var VersionPin = class extends VersionPinSchema {
-  static {
-    this.DISPOSITION = "version-pin";
-  }
-  static fromObject(object) {
-    return VersionPin.make({
-      objectId: object.id,
-      version: getVersion(object)
-    });
-  }
-  static createBlock(pin) {
-    return {
-      type: "json",
-      disposition: VersionPin.DISPOSITION,
-      json: JSON.stringify(pin)
-    };
-  }
-};
-
-// packages/experimental/assistant/src/session/session.ts
-import { Option, Schema as Schema4 } from "effect";
-import { defineTool as defineTool2, Message as Message4, structuredOutputParser, ToolResult as ToolResult3 } from "@dxos/artifact";
-import { Event as Event2, synchronized } from "@dxos/async";
-import { ObjectVersion } from "@dxos/echo-db";
-import { create as create3 } from "@dxos/echo-schema";
-import { invariant as invariant5 } from "@dxos/invariant";
-import { log as log6 } from "@dxos/log";
-
-// packages/experimental/assistant/src/ai-service/ollama-client.ts
-import { Schema as Schema3 } from "effect";
-import { defineTool, ToolResult as ToolResult2 } from "@dxos/artifact";
-import { ObjectId as ObjectId2 } from "@dxos/echo-schema";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { log as log4 } from "@dxos/log";
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/ai-service/ollama-client.ts";
-var OllamaClient = class {
-  /**
-  * Check if Ollama server is running and accessible.
-  * @returns Promise that resolves to true if Ollama is running, false otherwise.
-  */
-  static async isRunning() {
-    try {
-      const response = await fetch(`${DEFAULT_OLLAMA_ENDPOINT}/api/version`, {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        signal: AbortSignal.timeout(100)
-      });
-      return response.ok;
-    } catch (error) {
-      return false;
-    }
-  }
-  constructor({ endpoint, tools, overrides, maxToolInvocations } = {}) {
-    this._endpoint = endpoint ?? DEFAULT_OLLAMA_ENDPOINT;
-    this._tools = tools ?? [];
-    this._modelOverride = overrides?.model;
-    this._temperatureOverride = overrides?.temperature;
-    this._maxToolInvocations = maxToolInvocations ?? 3;
-  }
-  _getEmbededTools(clientTools) {
-    return [
-      ...this._tools,
-      ...clientTools.filter((tool) => tool.type !== void 0 && WELL_KNOWN_TOOLS[tool.type]).map((tool) => WELL_KNOWN_TOOLS[tool.type])
-    ];
-  }
-  async *_generateStream(request, signal) {
-    invariant3(request.prompt === void 0, "Prompt must be in history", {
-      F: __dxlog_file4,
-      L: 88,
-      S: this,
-      A: [
-        "request.prompt === undefined",
-        "'Prompt must be in history'"
-      ]
-    });
-    const ollamaRequest = {
-      model: this._modelOverride ?? request.model ?? "llama3",
-      messages: [],
-      stream: true,
-      options: {
-        temperature: this._temperatureOverride
-      }
-    };
-    if (request.systemPrompt) {
-      ollamaRequest.messages.push({
-        role: "system",
-        content: request.systemPrompt
-      });
-    }
-    if (request.history?.length) {
-      for (const message of request.history) {
-        const role = message.role === "assistant" ? "assistant" : "user";
-        if (message.content.length === 0) {
-          continue;
-        }
-        for (const content of message.content) {
-          switch (content.type) {
-            case "text": {
-              ollamaRequest.messages.push({
-                role,
-                content: content.text
-              });
-              break;
-            }
-            case "tool_use": {
-              ollamaRequest.messages.push({
-                role: "assistant",
-                content: "",
-                tool_calls: [
-                  {
-                    function: {
-                      name: content.name,
-                      arguments: content.input
-                    }
-                  }
-                ]
-              });
-              break;
-            }
-            case "tool_result": {
-              ollamaRequest.messages.push({
-                role: "tool",
-                content: JSON.stringify({
-                  type: "tool_result",
-                  toolUseId: content.toolUseId,
-                  content: content.content
-                })
-              });
-              break;
-            }
-          }
-        }
-      }
-    }
-    if (request.tools?.length || this._tools.length) {
-      const allTools = [
-        ...request.tools ?? [],
-        ...this._tools
-      ];
-      const withWellKnownTools = allTools.map((tool) => tool.type !== void 0 && WELL_KNOWN_TOOLS[tool.type] ? WELL_KNOWN_TOOLS[tool.type] : tool);
-      if (withWellKnownTools.length > 0) {
-        ollamaRequest.tools = withWellKnownTools.map((tool) => ({
-          type: "function",
-          function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: {
-              type: "object",
-              properties: tool.parameters?.properties,
-              required: tool.parameters?.required
-            }
-          }
-        }));
-      }
-    }
-    log4("generate request", {
-      history: request.history,
-      prompt: request.prompt,
-      ollamaRequest
-    }, {
-      F: __dxlog_file4,
-      L: 182,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const response = await fetch(`${this._endpoint}/api/chat`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(ollamaRequest),
-      signal
-    });
-    if (!response.ok) {
-      throw await parseErrorResponse2(response);
-    }
-    if (!response.body) {
-      throw new Error("Ollama API returned no response body");
-    }
-    const reader = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new OllamaDecoderStream()).getReader();
-    try {
-      const messageId = ObjectId2.random();
-      yield {
-        type: "message_start",
-        message: {
-          id: messageId,
-          role: "assistant",
-          content: []
-        }
-      };
-      const textBlock = {
-        type: "text",
-        text: ""
-      };
-      let currentBlockIndex = 0;
-      yield {
-        type: "content_block_start",
-        index: currentBlockIndex,
-        content: textBlock
-      };
-      while (true) {
-        const { done, value: data } = await reader.read();
-        if (done) {
-          break;
-        }
-        log4("ollama data", {
-          data
-        }, {
-          F: __dxlog_file4,
-          L: 244,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (data.message?.content) {
-          yield {
-            type: "content_block_delta",
-            index: 0,
-            delta: {
-              type: "text_delta",
-              text: data.message.content
-            }
-          };
-        }
-        if (data.message?.tool_calls && data.message?.tool_calls?.length > 0) {
-          if (data.message.tool_calls.length > 1) {
-            log4.warn("Ollama returned multiple tool calls. Only the first one will be used.", void 0, {
-              F: __dxlog_file4,
-              L: 261,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-          yield {
-            type: "content_block_stop",
-            index: currentBlockIndex++
-          };
-          yield {
-            type: "content_block_start",
-            index: currentBlockIndex,
-            content: {
-              type: "tool_use",
-              id: ObjectId2.random(),
-              name: data.message.tool_calls[0].function.name,
-              input: sanitizeToolArguments(data.message.tool_calls[0].function.arguments)
-            }
-          };
-          yield {
-            type: "message_delta",
-            delta: {
-              stopReason: "tool_use"
-            }
-          };
-        }
-      }
-      yield {
-        type: "content_block_stop",
-        index: currentBlockIndex
-      };
-      yield {
-        type: "message_stop"
-      };
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  /**
-  * Generate non-streaming response.
-  */
-  async exec(request) {
-    throw new Error("Not implemented");
-  }
-  async execStream(request) {
-    const controller = new AbortController();
-    try {
-      return new GenerationStreamImpl(controller, async function* () {
-        const collector = new MessageCollector();
-        let toolInvocations = 0;
-        while (true) {
-          for await (const event of this._generateStream({
-            ...request,
-            history: [
-              ...request.history ?? [],
-              ...request.prompt ? [
-                request.prompt
-              ] : [],
-              ...collector.messages
-            ],
-            prompt: void 0
-          }, controller.signal)) {
-            collector.push(event);
-            yield event;
-          }
-          if (collector.messages.length > 0 && !isToolUse(collector.messages.at(-1), {
-            onlyToolNames: this._getEmbededTools(request.tools ?? []).map((tool) => tool.name)
-          })) {
-            break;
-          }
-          if (++toolInvocations > this._maxToolInvocations) {
-            throw new Error("Maximum number of tool invocations reached");
-          }
-          const result = await runTools({
-            message: collector.messages.at(-1),
-            tools: this._getEmbededTools(request.tools ?? [])
-          });
-          switch (result.type) {
-            case "continue": {
-              collector.pushMessage(result.message);
-              yield* emitMessageAsEvents(result.message);
-              break;
-            }
-            case "break": {
-              throw new Error("Tool use breaks not allowed");
-            }
-          }
-        }
-      }.bind(this));
-    } catch (error) {
-      controller.abort();
-      throw error;
-    }
-  }
-};
-var sanitizeToolArguments = (args) => {
-  if (args.type === "object" && typeof args.properties === "object" && Array.isArray(args.required)) {
-    return args.properties;
-  }
-  return args;
-};
-var SAMPLE_IMAGE_URL = "https://images.nightcafe.studio/jobs/BNmcRhHCM1JRKoUtqSei/BNmcRhHCM1JRKoUtqSei--1--5b9rv.jpg";
-var WELL_KNOWN_TOOLS = {
-  [ToolTypes.TextToImage]: defineTool("system", {
-    name: "text-to-image",
-    description: "Generate an image from a text prompt",
-    schema: Schema3.Struct({
-      prompt: Schema3.String.annotations({
-        description: "The text prompt describing the image to generate"
-      })
-    }),
-    execute: async ({ prompt }) => {
-      const image = await fetch(SAMPLE_IMAGE_URL).then(async (res) => Buffer.from(await res.arrayBuffer()));
-      const imageBase64 = image.toString("base64");
-      const id = ObjectId2.random();
-      return ToolResult2.Success(`The generation was successful. Image ID: ${id} Prompt: ${prompt}`, [
-        {
-          type: "image",
-          id,
-          source: {
-            type: "base64",
-            mediaType: "image/jpeg",
-            data: imageBase64
-          }
-        }
-      ]);
-    }
-  })
-};
-var OllamaDecoderStream = class extends TransformStream {
-  constructor() {
-    super({
-      transform: (chunk, controller) => {
-        this._buffer += chunk;
-        const lines = this._buffer.split("\n");
-        this._buffer = lines.pop() || "";
-        for (const line of lines) {
-          controller.enqueue(JSON.parse(line.trim()));
-        }
-      },
-      flush: (controller) => {
-        this._buffer = this._buffer.trim();
-        if (this._buffer.length > 0) {
-          controller.enqueue(JSON.parse(this._buffer));
-        }
-      }
-    });
-    this._buffer = "";
-  }
-};
-var ModelDoesNotSupportToolsError = class extends Schema3.TaggedError()("ModelDoesNotSupportToolsError", {
-  model: Schema3.String
-}) {
-};
-var ModelNotFoundError = class extends Schema3.TaggedError()("ModelNotFoundError", {
-  model: Schema3.String
-}) {
-};
-var parseOllamaError = (error) => {
-  {
-    const match = error.match(/^([^']+) does not support tools$/);
-    if (match) {
-      return new ModelDoesNotSupportToolsError({
-        model: match[1]
-      });
-    }
-  }
-  {
-    const match = error.match(/^model "([^"]+)" not found, try pulling it first$/);
-    if (match) {
-      return new ModelNotFoundError({
-        model: match[1]
-      });
-    }
-  }
-  throw new Error(`Ollama API error: ${error}`);
-};
-var parseErrorResponse2 = async (response) => {
-  if (response.headers.get("content-type")?.includes("application/json")) {
-    const body = await response.json();
-    return parseOllamaError(body.error);
-  }
-  throw new Error(`Ollama API error: ${response.status} ${response.statusText} ${await response.text()}`);
-};
-
-// packages/experimental/assistant/src/ai-service/parser.ts
-import { Message as Message3 } from "@dxos/artifact";
-import { Event } from "@dxos/async";
-import { create as create2 } from "@dxos/echo-schema";
-import { invariant as invariant4 } from "@dxos/invariant";
-import { log as log5 } from "@dxos/log";
-import { isNotFalsy, safeParseJson } from "@dxos/util";
-
-// packages/experimental/assistant/src/ai-service/transform.ts
-import * as P from "parsimmon";
-var textChunk = P.regexp(/[^<]+/).map((content) => ({
-  type: "text",
-  content
-}));
-var attribute = P.seq(P.regexp(/[a-zA-Z_][a-zA-Z0-9_-]*/), P.string("=").trim(P.optWhitespace), P.alt(P.regexp(/"[^"]*"/).map((s) => s.slice(1, -1)), P.regexp(/'[^']*'/).map((s) => s.slice(1, -1)))).map(([name, _, value]) => [
-  name,
-  value
-]);
-var tagName = P.regexp(/[a-zA-Z_][a-zA-Z0-9_-]*/);
-var selfClosingTag = P.seqMap(
-  //
-  P.string("<"),
-  tagName,
-  P.optWhitespace.then(attribute).many(),
-  P.optWhitespace.then(P.string("/>")),
-  P.optWhitespace,
-  (_, tag, attributes, __) => ({
-    type: "tag",
-    tag,
-    attributes: Object.fromEntries(attributes),
-    content: [],
-    selfClosing: true
-  })
-);
-var openTag = P.seqMap(
-  //
-  P.string("<"),
-  tagName,
-  P.optWhitespace.then(attribute).many(),
-  P.string(">"),
-  P.regexp(/[^<]*/),
-  (_, tag, attributes, __, content) => ({
-    type: "tag",
-    tag,
-    attributes: Object.fromEntries(attributes),
-    content: content.length ? [
-      {
-        type: "text",
-        content
-      }
-    ] : []
-  })
-);
-var closeTag = P.seqMap(
-  //
-  P.string("</"),
-  tagName,
-  P.string(">"),
-  P.optWhitespace,
-  (_, tag) => ({
-    type: "tag",
-    tag,
-    content: [],
-    closing: true
-  })
-);
-var mixedChunk = P.alt(selfClosingTag, openTag, closeTag, textChunk);
-var StreamTransform = class {
-  constructor() {
-    this._buffer = "";
-  }
-  transform(chunk) {
-    this._buffer += chunk;
-    const results = [];
-    const parser = mixedChunk.many().skip(P.optWhitespace);
-    const result = parser.parse(this._buffer);
-    if (result.status) {
-      for (const chunk2 of result.value) {
-        results.push(chunk2);
-      }
-      this._buffer = "";
-    }
-    return results;
-  }
-  // TODO(burdon): Process remaining buffer?
-  flush() {
-    const remaining = this._buffer;
-    this._buffer = "";
-    return remaining.length > 0 ? [
-      {
-        type: "text",
-        content: remaining
-      }
-    ] : [];
-  }
-};
-
-// packages/experimental/assistant/src/ai-service/parser.ts
-var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/ai-service/parser.ts";
-var MixedStreamParser = class {
-  constructor() {
-    /**
-    * New message.
-    */
-    this.message = new Event();
-    /**
-    * Complete block added to Message.
-    */
-    this.block = new Event();
-    /**
-    * Update partial block (while streaming).
-    */
-    this.update = new Event();
-    this.streamEvent = new Event();
-  }
-  _emitBlock(contentBlock, streamBlock) {
-    const messageBlock = streamBlock ? mergeMessageBlock(contentBlock, streamBlock) : contentBlock;
-    if (messageBlock) {
-      if (messageBlock.type === "text" && messageBlock.text.length === 0) {
-        return;
-      }
-      invariant4(this._message, void 0, {
-        F: __dxlog_file5,
-        L: 49,
-        S: this,
-        A: [
-          "this._message",
-          ""
-        ]
-      });
-      this._message.content.push(messageBlock);
-      this.block.emit(messageBlock);
-    }
-  }
-  _emitUpdate(contentBlock, streamBlock) {
-    const messageBlock = mergeMessageBlock(contentBlock, streamBlock);
-    if (messageBlock) {
-      messageBlock.pending = true;
-      this.update.emit(messageBlock);
-    }
-  }
-  /**
-  * Parse stream until end.
-  */
-  async parse(stream) {
-    const transformer = new StreamTransform();
-    let contentBlock;
-    let streamBlock;
-    const stack = [];
-    const messagesCollected = [];
-    for await (const event of stream) {
-      log5("streamEvent", {
-        event
-      }, {
-        F: __dxlog_file5,
-        L: 83,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this.streamEvent.emit(event);
-      switch (event.type) {
-        //
-        // Messages.
-        //
-        case "message_start": {
-          if (this._message) {
-            log5.warn("unexpected message_start", void 0, {
-              F: __dxlog_file5,
-              L: 94,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-          this._message = create2(Message3, {
-            role: event.message.role,
-            content: [
-              ...event.message.content
-            ]
-          });
-          this.message.emit(this._message);
-          break;
-        }
-        case "message_delta": {
-          if (!this._message) {
-            log5.warn("unexpected message_delta", void 0, {
-              F: __dxlog_file5,
-              L: 104,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-          break;
-        }
-        case "message_stop": {
-          if (!this._message) {
-            log5.warn("unexpected message_stop", void 0, {
-              F: __dxlog_file5,
-              L: 112,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          } else {
-            messagesCollected.push(this._message);
-            this._message = void 0;
-          }
-          break;
-        }
-        //
-        // Content blocks.
-        //
-        case "content_block_start": {
-          if (contentBlock) {
-            log5.warn("unexpected content_block_start", {
-              content: contentBlock
-            }, {
-              F: __dxlog_file5,
-              L: 126,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-          contentBlock = event.content;
-          break;
-        }
-        case "content_block_delta": {
-          if (!contentBlock) {
-            log5.warn("unexpected content_block_delta", void 0, {
-              F: __dxlog_file5,
-              L: 136,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            break;
-          }
-          switch (event.delta.type) {
-            //
-            // Text
-            //
-            case "text_delta": {
-              const chunks = transformer.transform(event.delta.text);
-              for (const chunk of chunks) {
-                log5("text_delta", {
-                  chunk
-                }, {
-                  F: __dxlog_file5,
-                  L: 147,
-                  S: this,
-                  C: (f, a) => f(...a)
-                });
-                switch (streamBlock?.type) {
-                  //
-                  // XML Fragment.
-                  //
-                  case "tag": {
-                    if (chunk.type === "tag") {
-                      if (chunk.selfClosing) {
-                        streamBlock.content.push(chunk);
-                      } else if (chunk.closing) {
-                        if (stack.length > 0) {
-                          const top = stack.pop();
-                          invariant4(top && top.type === "tag", void 0, {
-                            F: __dxlog_file5,
-                            L: 160,
-                            S: this,
-                            A: [
-                              "top && top.type === 'tag'",
-                              ""
-                            ]
-                          });
-                          log5("pop", {
-                            top
-                          }, {
-                            F: __dxlog_file5,
-                            L: 161,
-                            S: this,
-                            C: (f, a) => f(...a)
-                          });
-                          top.content.push(streamBlock);
-                          streamBlock = top;
-                        } else {
-                          this._emitBlock(contentBlock, streamBlock);
-                          streamBlock = void 0;
-                        }
-                      } else {
-                        stack.push(streamBlock);
-                        streamBlock = chunk;
-                      }
-                    } else {
-                      if (streamBlock.content.length === 0) {
-                        streamBlock.content.push(chunk);
-                      } else {
-                        const last = streamBlock.content.at(-1);
-                        invariant4(last, void 0, {
-                          F: __dxlog_file5,
-                          L: 178,
-                          S: this,
-                          A: [
-                            "last",
-                            ""
-                          ]
-                        });
-                        if (last.type === "text") {
-                          last.content += chunk.content;
-                        } else {
-                          streamBlock.content.push(chunk);
-                        }
-                      }
-                    }
-                    break;
-                  }
-                  //
-                  // Text Fragment.
-                  //
-                  case "text": {
-                    if (chunk.type === "tag") {
-                      this._emitBlock(contentBlock, streamBlock);
-                      if (chunk.selfClosing) {
-                        this._emitBlock(contentBlock, chunk);
-                        streamBlock = void 0;
-                      } else {
-                        streamBlock = chunk;
-                      }
-                    } else {
-                      streamBlock.content += chunk.content;
-                    }
-                    break;
-                  }
-                  //
-                  // No current chunk.
-                  //
-                  default: {
-                    if (chunk.type === "tag" && chunk.selfClosing) {
-                      this._emitBlock(contentBlock, chunk);
-                    } else {
-                      streamBlock = chunk;
-                    }
-                  }
-                }
-              }
-              break;
-            }
-            //
-            // JSON
-            //
-            case "input_json_delta": {
-              if (!contentBlock) {
-                log5.warn("unexpected input_json_delta", {
-                  contentBlock
-                }, {
-                  F: __dxlog_file5,
-                  L: 228,
-                  S: this,
-                  C: (f, a) => f(...a)
-                });
-                break;
-              }
-              if (streamBlock?.type === "json") {
-                streamBlock.content += event.delta.partial_json;
-              } else {
-                streamBlock = {
-                  type: "json",
-                  content: event.delta.partial_json
-                };
-              }
-              break;
-            }
-          }
-          break;
-        }
-        case "content_block_stop": {
-          if (!contentBlock) {
-            log5.warn("unexpected content_block_stop", void 0, {
-              F: __dxlog_file5,
-              L: 245,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            break;
-          }
-          this._emitBlock(contentBlock, streamBlock);
-          contentBlock = void 0;
-          streamBlock = void 0;
-          break;
-        }
-      }
-      if (contentBlock && streamBlock) {
-        this._emitUpdate(contentBlock, streamBlock);
-      }
-    }
-    return messagesCollected;
-  }
-};
-var mergeMessageBlock = (contentBlock, streamBlock) => {
-  log5("mergeMessageBlock", {
-    contentBlock,
-    streamBlock
-  }, {
-    F: __dxlog_file5,
-    L: 272,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  switch (streamBlock.type) {
-    //
-    // Text
-    //
-    case "text": {
-      return {
-        ...contentBlock,
-        type: "text",
-        text: streamBlock.content
-      };
-    }
-    //
-    // XML
-    //
-    case "tag": {
-      switch (streamBlock.tag) {
-        case "cot": {
-          const content = streamBlock.content.map((block) => {
-            switch (block.type) {
-              case "text":
-                return block.content;
-              default:
-                return null;
-            }
-          }).filter(isNotFalsy).join("\n");
-          return {
-            ...contentBlock,
-            type: "text",
-            disposition: "cot",
-            text: content
-          };
-        }
-        case "artifact": {
-          const { attributes } = streamBlock;
-          return {
-            type: "json",
-            disposition: "artifact",
-            json: JSON.stringify(attributes)
-          };
-        }
-        case "suggest": {
-          if (streamBlock.content.length === 1 && streamBlock.content[0].type === "text") {
-            return {
-              type: "json",
-              disposition: "suggest",
-              json: JSON.stringify({
-                text: streamBlock.content[0].content
-              })
-            };
-          }
-          break;
-        }
-        case "proposal": {
-          if (streamBlock.content.length === 1 && streamBlock.content[0].type === "text") {
-            return {
-              type: "json",
-              disposition: "proposal",
-              json: JSON.stringify({
-                text: streamBlock.content[0].content
-              })
-            };
-          }
-          break;
-        }
-        case "select": {
-          return {
-            type: "json",
-            disposition: "select",
-            json: JSON.stringify({
-              options: streamBlock.content.flatMap((content) => content.type === "tag" && content.content.length === 1 && content.content[0].type === "text" ? [
-                content.content[0].content
-              ] : [])
-            })
-          };
-        }
-        case "tool-list": {
-          return {
-            type: "json",
-            disposition: "tool_list",
-            json: JSON.stringify({})
-          };
-        }
-      }
-      break;
-    }
-    //
-    // JSON
-    //
-    case "json": {
-      switch (contentBlock.type) {
-        case "tool_use": {
-          return {
-            ...contentBlock,
-            input: safeParseJson(streamBlock.content) ?? {}
-          };
-        }
-      }
-      return {
-        ...contentBlock,
-        type: "json",
-        disposition: "artifact",
-        json: streamBlock.content
-      };
-    }
-  }
-};
-
-// packages/experimental/assistant/src/session/session.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/session/session.ts";
-var AISession = class _AISession {
-  constructor(_options) {
-    this._options = _options;
-    this._parser = new MixedStreamParser();
-    this._pending = [];
-    this._history = [];
-    this.message = this._parser.message;
-    this.block = this._parser.block;
-    this.update = this._parser.update;
-    this.streamEvent = this._parser.streamEvent;
-    this.userMessage = new Event2();
-    this._parser.message.on((message) => {
-      this._pending.push(message);
-    });
-  }
-  async run(options) {
-    const systemTools = [];
-    switch (this._options.operationModel) {
-      case "planning":
-        systemTools.push(this._createQueryArtifactsTool(options.artifacts), this._createPlanningTool(options));
-        break;
-      case "importing":
-        systemTools.push(this._createQueryArtifactsTool(options.artifacts), this._createRequireTool(options.artifacts, (artifactDefinitionIds) => {
-          for (const artifactDefinitionId of artifactDefinitionIds) {
-            requiredArtifactIds.add(artifactDefinitionId);
-          }
-        }));
-        break;
-      case "configured":
-        break;
-      default:
-        throw new TypeError(`Invalid operation model: ${this._options.operationModel}`);
-    }
-    this._history = [
-      ...options.history
-    ];
-    this._pending = [
-      await this._formatUserPrompt(options.artifactDiffResolver, options.prompt, options.history)
-    ];
-    this.userMessage.emit(this._pending.at(-1));
-    this._stream = void 0;
-    let error;
-    const requiredArtifactIds = new Set(options.requiredArtifactIds ?? []);
-    try {
-      let more = false;
-      do {
-        const tools = [
-          ...systemTools,
-          ...options.tools,
-          ...options.artifacts.filter((artifact) => requiredArtifactIds.has(artifact.id)).flatMap((artifact) => artifact.tools)
-        ];
-        log6("request", {
-          pending: this._pending.length,
-          history: this._history.length,
-          tools: tools.map((tool) => tool.name)
-        }, {
-          F: __dxlog_file6,
-          L: 181,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._stream = await options.client.execStream({
-          ...options.generationOptions ?? {},
-          // TODO(burdon): Rename messages or separate history/message.
-          history: [
-            ...this._history,
-            ...this._pending
-          ],
-          tools,
-          systemPrompt: options.systemPrompt ?? createBaseInstructions({
-            availableArtifacts: Array.from(requiredArtifactIds),
-            operationModel: this._options.operationModel
-          })
-        });
-        await this._parser.parse(this._stream);
-        await this._stream.complete();
-        log6("response", {
-          pending: this._pending
-        }, {
-          F: __dxlog_file6,
-          L: 206,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        more = false;
-        const message = this._pending.at(-1);
-        invariant5(message, void 0, {
-          F: __dxlog_file6,
-          L: 211,
-          S: this,
-          A: [
-            "message",
-            ""
-          ]
-        });
-        if (isToolUse(message)) {
-          log6("tool request...", void 0, {
-            F: __dxlog_file6,
-            L: 213,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          const response = await runTools({
-            message: this._pending.at(-1),
-            tools,
-            extensions: options.extensions ?? {}
-          });
-          log6("tool response", {
-            response
-          }, {
-            F: __dxlog_file6,
-            L: 220,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          switch (response.type) {
-            case "continue": {
-              this._pending = [
-                ...this._pending,
-                response.message
-              ];
-              this.userMessage.emit(response.message);
-              more = true;
-              break;
-            }
-          }
-        }
-      } while (more);
-    } catch (err) {
-      log6.catch(err, void 0, {
-        F: __dxlog_file6,
-        L: 232,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      if (err instanceof Error && err.message.includes("Overloaded")) {
-        error = new AIServiecOverloadedError("AI service overloaded", {
-          cause: err
-        });
-      } else {
-        error = new Error("AI service error", {
-          cause: err
-        });
-      }
-    } finally {
-      this._stream = void 0;
-    }
-    if (error) {
-      throw error;
-    }
-    return this._pending;
-  }
-  async runStructured(schema, options) {
-    const parser = structuredOutputParser(schema);
-    const result = await this.run({
-      ...options,
-      tools: [
-        ...options.tools,
-        parser.tool
-      ]
-    });
-    return parser.getResult(result);
-  }
-  async _formatUserPrompt(artifactDiffResolver, prompt, history) {
-    const prelude = [];
-    if (artifactDiffResolver) {
-      const versions = gatherObjectVersions(history);
-      const artifactDiff = await artifactDiffResolver(Array.from(versions.entries()).map(([id, version]) => ({
-        id,
-        lastVersion: version
-      })));
-      log6.info("vision", {
-        artifactDiff,
-        versions
-      }, {
-        F: __dxlog_file6,
-        L: 272,
-        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;
-        }
-        prelude.push(VersionPin.createBlock(VersionPin.make({
-          objectId: id,
-          version
-        })));
-      }
-      if (artifactDiff.size > 0) {
-        prelude.push(createArtifactUpdateBlock(artifactDiff));
-      }
-    }
-    return create3(Message4, {
-      role: "user",
-      content: [
-        ...prelude,
-        {
-          type: "text",
-          text: prompt
-        }
-      ]
-    });
-  }
-  _createQueryArtifactsTool(artifacts) {
-    return defineTool2("system", {
-      name: "query_artifact_definitions",
-      description: "Query the available artifact definitions",
-      schema: Schema4.Struct({}),
-      execute: async () => {
-        return ToolResult3.Success({
-          artifactDefinitions: artifacts.map((artifact) => ({
-            id: artifact.id,
-            name: artifact.name,
-            description: artifact.description
-          }))
-        });
-      }
-    });
-  }
-  _createRequireTool(artifacts, onRequire) {
-    return defineTool2("system", {
-      name: "require_artifact_definitions",
-      description: "Require the use of specific artifact definitions. This will allow the model to interact with artifact definitions and use their tools.",
-      schema: Schema4.Struct({
-        artifactDefinitionIds: Schema4.Array(Schema4.String).annotations({
-          description: "The ids of the artifact definitions to require",
-          examples: [
-            [
-              "artifact:dxos.org/example/Test"
-            ]
-          ]
-        })
-      }),
-      execute: async ({ artifactDefinitionIds }) => {
-        const missingArtifactDefinitionIds = artifactDefinitionIds.filter((artifactId) => !artifacts.some((artifact) => artifact.id === artifactId));
-        if (missingArtifactDefinitionIds.length > 0) {
-          return ToolResult3.Error(`One or more artifact definition ids are invalid: ${missingArtifactDefinitionIds.join(", ")}`);
-        }
-        onRequire(artifactDefinitionIds);
-        return ToolResult3.Success({});
-      }
-    });
-  }
-  _createPlanningTool(options) {
-    return defineTool2("system", {
-      name: "create_plan",
-      description: "Create a plan. Make sure that each step is independent and can be executed solely on the data returned by the previous step. The steps only share the data that is specified in the plan.",
-      schema: Schema4.Struct({
-        goal: Schema4.String.annotations({
-          description: "The goal that the plan will achieve."
-        }),
-        steps: Schema4.Array(Schema4.Struct({
-          action: Schema4.String.annotations({
-            description: "Complete, detailed action to perform."
-          }),
-          input: Schema4.String.annotations({
-            description: "The required input data for this step. First step must not require any data."
-          }),
-          output: Schema4.String.annotations({
-            description: "The output data from this step. This is passed to the next step as input."
-          }),
-          requiredArtifactIds: Schema4.Array(Schema4.String).annotations({
-            description: "The ids of the artifacts required to perform this step.",
-            examples: [
-              [
-                "artifact:dxos.org/example/Test"
-              ]
-            ]
-          })
-        })).annotations({
-          description: "Steps"
-        })
-      }),
-      execute: async ({ goal, steps }) => {
-        const missingArtifactIds = steps.flatMap((step) => step.requiredArtifactIds).filter((artifactId) => !options.artifacts.some((artifact) => artifact.id === artifactId));
-        if (missingArtifactIds.length > 0) {
-          return ToolResult3.Error(`One or more artifact ids are invalid: ${missingArtifactIds.join(", ")}`);
-        }
-        const stepResults = [];
-        for (const step of steps) {
-          log6("executing step", {
-            action: step.action
-          }, {
-            F: __dxlog_file6,
-            L: 379,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          const session = new _AISession({
-            operationModel: "importing"
-          });
-          session.message.on((ev) => this.message.emit(ev));
-          session.block.on((ev) => this.block.emit(ev));
-          session.update.on((ev) => this.update.emit(ev));
-          session.streamEvent.on((ev) => this.streamEvent.emit(ev));
-          session.userMessage.on((ev) => this.userMessage.emit(ev));
-          const messages = await session.run({
-            client: options.client,
-            artifacts: options.artifacts,
-            tools: options.tools,
-            history: options.history,
-            extensions: options.extensions,
-            generationOptions: options.generationOptions,
-            requiredArtifactIds: step.requiredArtifactIds.slice(),
-            artifactDiffResolver: options.artifactDiffResolver,
-            prompt: `
-              You are an agent that executes the subtask in a plan.
-              
-              While you know the plan's goal only focus on your subtask
-              Use the data from the previous step to complete your task.
-              Return all of the data from "output" in your last message.
-              
-              Current step (that you need to complete):
-              ${JSON.stringify({
-              goal,
-              input: step.input,
-              output: step.output,
-              yourTask: step.action
-            }, null, 2)}
-              
-              Previous step results:
-              ${JSON.stringify(stepResults.at(-1))}.
-            `
-          });
-          const result = messages.at(-1);
-          stepResults.push(result);
-        }
-        return ToolResult3.Success({
-          stepResults
-        });
-      }
-    });
-  }
-  abort() {
-    this._stream?.abort();
-  }
-};
-_ts_decorate([
-  synchronized
-], AISession.prototype, "run", null);
-var createBaseInstructions = ({ availableArtifacts, operationModel }) => `
-  You are a friendly, advanced AI assistant capable of creating and managing artifacts from available data and tools. 
-  Your task is to process user commands and questions and decide how best to respond.
-  In some cases, you will need to create or reference data objects called artifacts.
-
-  Follow these guidelines carefully:
-
-  Decision-making:
-
-  - Analyze the structure and type of the content in the user's message.
-  
-  
-  ${operationModel === "planning" ? `
-      - Can you complete the task using the available artifacts?
-      - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
-      - Identify which artifacts are relevant to the user's request.
-        - Break down the user's request into a step-by-step plan that you will use to execute the user's request, the plan items should include artifacts which will be used to perform the actions.
-      ` : ""}
-  ${operationModel === "importing" ? `
-      - Can you complete the task using the available artifacts?
-      - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
-      - Identify which artifacts are relevant to the user's request.
-    - Are the required artifacts already available?
-    - If not, select which artifact(s) will be the most relevant and require them using the require_artifacts tool.
-    - The require'd artifact tools will be available for use after require.
-  ` : ""}
-  ${operationModel === "configured" ? `
-    - Select the most relevant artifact(s) to complete the task.
-    - Call the appropriate tool to use the artifact(s).
-  ` : ""}
-
-  ${availableArtifacts.length > 0 ? `Artifacts already in context: ${availableArtifacts.join("\n")}` : ""}
-`;
-var AIServiecOverloadedError = class extends Schema4.TaggedError()("AIServiecOverloadedError", {}) {
-};
-var gatherObjectVersions = (messages) => {
-  const artifactIds = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    for (const block of message.content) {
-      if (block.type === "json" && block.disposition === VersionPin.DISPOSITION) {
-        const pin = VersionPin.pipe(Schema4.decodeOption)(JSON.parse(block.json)).pipe(Option.getOrUndefined);
-        if (!pin) {
-          continue;
-        }
-        artifactIds.set(pin.objectId, pin.version);
-      }
-    }
-  }
-  return artifactIds;
-};
-var createArtifactUpdateBlock = (artifactDiff) => {
-  return {
-    type: "text",
-    disposition: "artifact-update",
-    text: `
-      The following artifacts have been updated since the last message:
-      ${Array.from(artifactDiff.entries()).map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `
-${diff}` : ""}</changed-artifact>`).join("\n")}
-    `
-  };
-};
-
-// packages/experimental/assistant/src/experimental/conversation/conversation.ts
-import { ObjectId as ObjectId3 } from "@dxos/echo-schema";
-import { invariant as invariant6 } from "@dxos/invariant";
-import { log as log7 } from "@dxos/log";
-var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/experimental/conversation/conversation.ts";
-var runLLM = async (params) => {
-  let conversationResult = null;
-  const history = params.history ?? [];
-  const generate = async () => {
-    log7("llm generate", {
-      tools: params.tools
-    }, {
-      F: __dxlog_file7,
-      L: 44,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    const beginTs = Date.now();
-    const stream = await params.client.execStream({
-      model: params.model,
-      history,
-      systemPrompt: params.system,
-      tools: params.tools
-    });
-    for await (const event of stream) {
-      params.logger?.(event);
-    }
-    await stream.complete();
-    const messages = [];
-    const message = messages.at(-1);
-    invariant6(message, void 0, {
-      F: __dxlog_file7,
-      L: 61,
-      S: void 0,
-      A: [
-        "message",
-        ""
-      ]
-    });
-    log7("llm result", {
-      time: Date.now() - beginTs,
-      message
-    }, {
-      F: __dxlog_file7,
-      L: 63,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    invariant6(message, void 0, {
-      F: __dxlog_file7,
-      L: 64,
-      S: void 0,
-      A: [
-        "message",
-        ""
-      ]
-    });
-    params.logger?.({
-      type: "message",
-      message
-    });
-    history.push(...messages.map((message2) => ({
-      ...message2,
-      content: message2.content.filter((block) => block.type !== "image")
-    })));
-    const isToolUse2 = message.content.at(-1)?.type === "tool_use";
-    if (isToolUse2) {
-      const toolCalls = message.content.filter((block) => block.type === "tool_use");
-      invariant6(toolCalls.length === 1, void 0, {
-        F: __dxlog_file7,
-        L: 75,
-        S: void 0,
-        A: [
-          "toolCalls.length === 1",
-          ""
-        ]
-      });
-      const toolCall = toolCalls[0];
-      const tool = params.tools.find((tool2) => tool2.name === toolCall.name);
-      if (!tool) {
-        throw new Error(`Tool not found: ${toolCall.name}`);
-      }
-      invariant6(tool.execute, void 0, {
-        F: __dxlog_file7,
-        L: 82,
-        S: void 0,
-        A: [
-          "tool.execute",
-          ""
-        ]
-      });
-      const toolResult = await tool.execute(toolCall.input);
-      switch (toolResult.kind) {
-        case "error": {
-          log7.warn("tool error", {
-            message: toolResult.message
-          }, {
-            F: __dxlog_file7,
-            L: 86,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          const resultMessage = {
-            id: ObjectId3.random(),
-            role: "user",
-            content: [
-              {
-                type: "tool_result",
-                toolUseId: toolCall.id,
-                content: toolResult.message,
-                isError: true
-              }
-            ]
-          };
-          params.logger?.({
-            type: "message",
-            message: resultMessage
-          });
-          history.push(resultMessage);
-          return true;
-        }
-        case "success": {
-          log7("tool success", {
-            result: toolResult.result
-          }, {
-            F: __dxlog_file7,
-            L: 106,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          const resultMessage = {
-            id: ObjectId3.random(),
-            role: "user",
-            content: [
-              {
-                type: "tool_result",
-                toolUseId: toolCall.id,
-                content: JSON.stringify(toolResult.result)
-              }
-            ]
-          };
-          params.logger?.({
-            type: "message",
-            message: resultMessage
-          });
-          history.push(resultMessage);
-          return true;
-        }
-        case "break": {
-          log7("tool break", {
-            result: toolResult.result
-          }, {
-            F: __dxlog_file7,
-            L: 125,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          conversationResult = toolResult.result;
-          return false;
-        }
-      }
-    }
-    return false;
-  };
-  while (await generate()) {
-  }
-  return {
-    result: conversationResult,
-    history
-  };
-};
-
-// packages/experimental/assistant/src/experimental/cypher/parjs.ts
-import { parjsCombinators, parjs } from "#parjs";
-
-// packages/experimental/assistant/src/experimental/cypher/combinators.ts
-var ws = parjs.whitespace();
-var nothing = parjs.string("").pipe(parjsCombinators.map(() => null));
-var optional = (parser) => parser.pipe(parjsCombinators.recover(() => ({
-  kind: "Soft"
-})), parjsCombinators.or(nothing));
-var keyword = (word) => parjs.string(word).pipe(parjsCombinators.map(() => word));
-var identifier = parjs.regexp(/[a-zA-Z_][a-zA-Z0-9_]*/).pipe(parjsCombinators.map((match) => ({
-  astKind: "Identifier",
-  name: match[0]
-})));
-var numberLiteral = parjs.regexp(/-?\d+(\.\d+)?/).pipe(parjsCombinators.map(Number));
-var stringLiteral = parjs.regexp(/"([^"]*)"|'([^']*)'/).pipe(parjsCombinators.map((match) => ({
-  astKind: "StringLiteral",
-  value: match[1] || match[2]
-})));
-var variableTag = identifier.pipe(parjsCombinators.map((variable) => variable)).expects("variable tag");
-var label = identifier.pipe(parjsCombinators.map((name) => name));
-var property = identifier.pipe(parjsCombinators.then(parjs.string(":"), ws, stringLiteral), parjsCombinators.map(([key, , , value]) => ({
-  key,
-  value
-})));
-var properties = property.pipe(parjsCombinators.manySepBy(","), parjsCombinators.between("{", "}"), parjsCombinators.map((properties2) => ({
-  astKind: "Properties",
-  properties: properties2
-})));
-var nodePattern = optional(variableTag).pipe(parjsCombinators.then(":"), parjsCombinators.then(ws, label, ws), parjsCombinators.then(optional(properties)), parjsCombinators.between("(", ")"), parjsCombinators.map(([[[variable], _, label2], properties2]) => ({
-  astKind: "NodePattern",
-  variable,
-  label: label2,
-  properties: properties2
-})));
-var relationshipPattern = optional(variableTag).pipe(parjsCombinators.then(":"), parjsCombinators.then(ws, label, ws), parjsCombinators.then(optional(properties)), parjsCombinators.between("[", "]"), parjsCombinators.map(([[[variable], _, label2], properties2]) => ({
-  astKind: "RelationshipPattern",
-  variable,
-  label: label2,
-  properties: properties2
-})));
-var graphPatternConnector = parjs.string("->").pipe(parjsCombinators.or("<-", "-"), parjsCombinators.map((x) => ({
-  astKind: "GraphPatternConnector",
-  direction: x
-})));
-var graphPattern = nodePattern.pipe(parjsCombinators.or(relationshipPattern), parjsCombinators.manySepBy(graphPatternConnector), parjsCombinators.map((segments) => ({
-  astKind: "GraphPattern",
-  segments
-})));
-var matchClause = keyword("MATCH").pipe(parjsCombinators.then(ws), parjsCombinators.then(graphPattern), parjsCombinators.map(([, pattern]) => ({
-  astKind: "MatchClause",
-  pattern
-})));
-var memberExpression = identifier.pipe(parjsCombinators.manySepBy("."), parjsCombinators.map((path) => ({
-  astKind: "MemberExpression",
-  path
-})));
-var equalsPredicate = memberExpression.pipe(parjsCombinators.then(ws, parjs.string("="), ws, stringLiteral), parjsCombinators.map(([left, , , , right]) => ({
-  astKind: "EqualsPredicate",
-  left,
-  right
-})));
-var whereClause = keyword("WHERE").pipe(parjsCombinators.then(ws, equalsPredicate.pipe(parjsCombinators.between(ws, ws), parjsCombinators.manySepBy(parjs.string("AND"))), ws), parjsCombinators.map(([, , predicates]) => ({
-  astKind: "WhereClause",
-  predicates
-})));
-var returnClause = keyword("RETURN").pipe(parjsCombinators.then(ws, memberExpression.pipe(parjsCombinators.then(optional(parjs.string("AS").pipe(parjsCombinators.between(ws), parjsCombinators.then(identifier))), ws), parjsCombinators.manySepBy(parjs.string(",").pipe(parjsCombinators.then(ws)))), ws), parjsCombinators.map(([, , fields]) => ({
-  astKind: "ReturnClause",
-  fields: fields.map(([f]) => f)
-})));
-var cypherQuery = ws.pipe(parjsCombinators.then(matchClause, ws, optional(whereClause), ws, returnClause, ws), parjsCombinators.map(([, matchClause2, , whereClause2, , returnClause2]) => ({
-  astKind: "CypherQuery",
-  matchClause: matchClause2,
-  whereClause: whereClause2,
-  returnClause: returnClause2
-})));
-
-// packages/experimental/assistant/src/experimental/cypher/parser.ts
-var parseCypherQuery = (query) => {
-  const parseResult = cypherQuery.parse(query);
-  if (parseResult.isOk) {
-    return {
-      ast: parseResult.value
-    };
-  } else {
-    throw new Error(`Failed to parse query: ${parseResult}`);
-  }
-};
-
-// packages/experimental/assistant/src/experimental/cypher/query-executor.ts
-import { log as log9 } from "@dxos/log";
-import { mapValues } from "@dxos/util";
-
-// packages/experimental/assistant/src/experimental/cypher/execution-plan.ts
-import { invariant as invariant7 } from "@dxos/invariant";
-import { log as log8 } from "@dxos/log";
-var __dxlog_file8 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/experimental/cypher/execution-plan.ts";
-var createExecutionPlan = (query) => {
-  return new ExecutionPlanBuilder().build(query);
-};
-var ExecutionPlanBuilder = class {
-  constructor() {
-    this.counter = 0;
-  }
-  newVariable() {
-    return `anon_${this.counter++}`;
-  }
-  build(query) {
-    log8("Creating execution plan for query", {
-      query
-    }, {
-      F: __dxlog_file8,
-      L: 76,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return {
-      steps: [
-        ...this.createStepsForMatchClause(query.ast.matchClause),
-        ...query.ast.whereClause ? this.createStepsForWhereClause(query.ast.whereClause) : [],
-        ...this.createStepsForReturnClause(query.ast.returnClause)
-      ],
-      output: {
-        fields: this.getOutputFields(query.ast.returnClause)
-      }
-    };
-  }
-  createStepsForMatchClause(match) {
-    invariant7(match.pattern.segments.length > 0, void 0, {
-      F: __dxlog_file8,
-      L: 90,
-      S: this,
-      A: [
-        "match.pattern.segments.length > 0",
-        ""
-      ]
-    });
-    const firstSegment = match.pattern.segments[0];
-    invariant7(firstSegment.astKind === "NodePattern", void 0, {
-      F: __dxlog_file8,
-      L: 92,
-      S: this,
-      A: [
-        "firstSegment.astKind === 'NodePattern'",
-        ""
-      ]
-    });
-    let lastNodeVariable = firstSegment.variable?.name ?? this.newVariable();
-    const steps = [];
-    steps.push({
-      type: "NodeScan",
-      label: firstSegment.label.name,
-      into: lastNodeVariable
-    });
-    if (firstSegment.properties) {
-      for (const property2 of firstSegment.properties.properties) {
-        steps.push({
-          type: "FilterByProperty",
-          variable: lastNodeVariable,
-          property: property2.key.name,
-          value: property2.value.value
-        });
-      }
-    }
-    for (let i = 1; i < match.pattern.segments.length; i++) {
-      const relationshipSegment = match.pattern.segments[i++];
-      invariant7(relationshipSegment.astKind === "RelationshipPattern", void 0, {
-        F: __dxlog_file8,
-        L: 115,
-        S: this,
-        A: [
-          "relationshipSegment.astKind === 'RelationshipPattern'",
-          ""
-        ]
-      });
-      const nodeSegment = match.pattern.segments[i];
-      invariant7(nodeSegment.astKind === "NodePattern", void 0, {
-        F: __dxlog_file8,
-        L: 117,
-        S: this,
-        A: [
-          "nodeSegment.astKind === 'NodePattern'",
-          ""
-        ]
-      });
-      const leftSeparator = match.pattern.segments.separators[i - 2];
-      const rightSeparator = match.pattern.segments.separators[i - 1];
-      const direction = getDirection(leftSeparator.direction, rightSeparator.direction);
-      const relationshipVariable = relationshipSegment.variable?.name ?? this.newVariable();
-      const nodeVariable = nodeSegment.variable?.name ?? this.newVariable();
-      steps.push({
-        type: "RelationshipScan",
-        label: relationshipSegment.label.name,
-        direction,
-        anchor: lastNodeVariable,
-        relationshipInto: relationshipVariable,
-        nodeInto: nodeVariable
-      });
-      if (relationshipSegment.properties) {
-        for (const property2 of relationshipSegment.properties.properties) {
-          steps.push({
-            type: "FilterByProperty",
-            variable: relationshipVariable,
-            property: property2.key.name,
-            value: property2.value.value
-          });
-        }
-      }
-      if (nodeSegment.label) {
-        steps.push({
-          type: "FilterByLabel",
-          variable: nodeVariable,
-          label: nodeSegment.label.name
-        });
-      }
-      if (nodeSegment.properties) {
-        for (const property2 of nodeSegment.properties.properties) {
-          steps.push({
-            type: "FilterByProperty",
-            variable: nodeVariable,
-            property: property2.key.name,
-            value: property2.value.value
-          });
-        }
-      }
-      lastNodeVariable = nodeVariable;
-    }
-    return steps;
-  }
-  createStepsForWhereClause(where) {
-    return [];
-  }
-  createStepsForReturnClause(returnClause2) {
-    return [
-      {
-        type: "ProduceResults",
-        fields: returnClause2.fields.map((field) => ({
-          name: field.path.map((p) => p.name).join("_"),
-          variable: field.path[0].name,
-          path: field.path.length > 1 ? field.path.slice(1).map((p) => p.name).join(".") : "$"
-        }))
-      }
-    ];
-  }
-  getOutputFields(returnClause2) {
-    return returnClause2.fields.map((field) => field.path.map((p) => p.name).join("_"));
-  }
-};
-var getDirection = (left, right) => {
-  if (left === "-" && right === "->") {
-    return "out";
-  } else if (left === "<-" && right === "-") {
-    return "in";
-  } else if (left === "-" && right === "-") {
-    return "both";
-  }
-  throw new Error(`Invalid direction: ()${left}[]${right}()`);
-};
-
-// packages/experimental/assistant/src/experimental/cypher/query-executor.ts
-var __dxlog_file9 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/experimental/cypher/query-executor.ts";
-var executeQueryPlan = async (dataSource, plan) => {
-  let buffer = [];
-  const results = [];
-  for (const step of plan.steps) {
-    log9("begin step", {
-      step
-    }, {
-      F: __dxlog_file9,
-      L: 41,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    switch (step.type) {
-      case "NodeScan": {
-        const nodes = await dataSource.getNodes({
-          label: step.label
-        });
-        buffer.push(...nodes.map((node) => ({
-          [step.into]: node
-        })));
-        break;
-      }
-      case "FilterByLabel": {
-        buffer = buffer.filter((item) => {
-          const node = item[step.variable];
-          return node && node.kind === "node" && node.label === step.label;
-        });
-        break;
-      }
-      case "FilterByProperty": {
-        buffer = buffer.filter((item) => {
-          const node = item[step.variable];
-          return node && node.kind === "node" && node.properties[step.property] === step.value;
-        });
-        break;
-      }
-      case "RelationshipScan": {
-        const relationships = await dataSource.getRelationships({
-          label: step.label
-        });
-        for (const tuple of [
-          ...buffer
-        ]) {
-          if (tuple[step.anchor].kind !== "node") {
-            continue;
-          }
-          const filteredRelationships = relationships.filter((relationship) => {
-            switch (step.direction) {
-              case "in":
-                return relationship.target.id === tuple[step.anchor].id;
-              case "out":
-                return relationship.source.id === tuple[step.anchor].id;
-              case "both":
-                return relationship.source.id === tuple[step.anchor].id || relationship.target.id === tuple[step.anchor].id;
-              default:
-                throw new Error(`Unknown direction: ${step.direction}`);
-            }
-          });
-          for (let i = 0; i < filteredRelationships.length; i++) {
-            const relationship = filteredRelationships[i];
-            const newTuple = i === 0 ? tuple : {
-              ...tuple
-            };
-            if (newTuple !== tuple) {
-              buffer.push(newTuple);
-            }
-            newTuple[step.relationshipInto] = relationship;
-            switch (step.direction) {
-              case "in":
-                newTuple[step.nodeInto] = relationship.source;
-                break;
-              case "out":
-                newTuple[step.nodeInto] = relationship.target;
-                break;
-              case "both":
-                newTuple[step.nodeInto] = relationship.source.id === newTuple[step.anchor].id ? relationship.target : relationship.source;
-                break;
-            }
-          }
-        }
-        break;
-      }
-      case "ProduceResults": {
-        for (const tuple of buffer) {
-          const result = {};
-          for (const field of step.fields) {
-            result[field.name] = jsonPathGet(tuple[field.variable].properties, field.path);
-          }
-          results.push(result);
-        }
-        break;
-      }
-    }
-    log9("finish step", {
-      buffer: buffer.map((tuple) => mapValues(tuple, (x) => x.id)),
-      results
-    }, {
-      F: __dxlog_file9,
-      L: 118,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-  }
-  return results;
-};
-var executeQuery = (dataSource, query) => {
-  const plan = createExecutionPlan(parseCypherQuery(query));
-  return executeQueryPlan(dataSource, plan);
-};
-var jsonPathGet = (obj, path) => {
-  if (path === "" || path === "$") {
-    return obj;
-  }
-  const parts = path.split(".");
-  if (parts[0] === "$") {
-    parts.shift();
-  }
-  let result = obj;
-  for (const part of parts) {
-    result = result?.[part];
-  }
-  return result;
-};
-
-// packages/experimental/assistant/src/experimental/cypher/schema.ts
-import { raise } from "@dxos/debug";
-import { JSON_SCHEMA_ECHO_REF_ID } from "@dxos/echo-schema";
-
-// packages/experimental/assistant/src/util/trim.ts
-var trim = (strings, ...values) => {
-  const combined = strings.reduce((acc, str, i) => {
-    return acc + str + (values[i] || "");
-  }, "");
-  return combined.replace("/^\n/", "").replace(/\n$/, "");
-};
-
-// packages/experimental/assistant/src/experimental/cypher/schema.ts
-var formatJsonSchemaForLLM = (schemaTypes) => {
-  return schemaTypes.flatMap((schema) => [
-    formatNodeSchema(schema),
-    ...formatInferredRelationships(schema, schemaTypes)
-  ]);
-};
-var formatNodeSchema = (schema) => {
-  const label2 = formatNodeLabel(schema.typename ?? raise(new Error("Schema must have $id")));
-  const properties2 = Object.entries(schema.properties).filter(([key, prop]) => key !== "id" && !isReference(prop));
-  return trim`
-    <node>
-      (:${label2})
-
-      <description>${schema.description}</description>
-
-      <properties>
-        ${properties2.map(([key, value]) => {
-    return trim`
-            <${key}>
-              <type>${value.type}</type>
-              <description>${value.description}</description>
-            </${key}>
-          `;
-  })}
-      </properties>
-    </node>
-  `;
-};
-var formatInferredRelationships = (schema, allSchema) => {
-  const nodeLabel = formatNodeLabel(schema.typename ?? raise(new Error("Schema must have $id")));
-  const relationships = Object.entries(schema.properties).filter(([key, prop]) => isReference(prop));
-  return relationships.map(([key, value]) => {
-    const relationshipLabel = formatInferredRelationshipLabel(schema.typename ?? raise(new Error("Schema must have $id")), key);
-    const targetSchema = allSchema.find((schema2) => `dxn:type/${schema2.typename}` === value.reference?.schema.$ref);
-    const targetLabel = targetSchema ? formatNodeLabel(targetSchema?.typename ?? "") : "";
-    return trim`
-      <relationship>
-        (:${nodeLabel})-[:${relationshipLabel}]->(:${targetLabel})
-
-        <description>${value.description}</description>
-      </relationship>
-    `;
-  });
-};
-var formatNodeLabel = (typename) => {
-  return typename.replace(/^example\.com\/type\//g, "");
-};
-var formatInferredRelationshipLabel = (typename, property2) => {
-  const nodeLabel = formatNodeLabel(typename);
-  return `${nodeLabel}_${property2}`.toUpperCase();
-};
-var isReference = (schema) => schema.$id === JSON_SCHEMA_ECHO_REF_ID || schema.type === "array" && !Array.isArray(schema.items) && typeof schema.items === "object" && "$id" in schema.items && schema.items.$id === JSON_SCHEMA_ECHO_REF_ID;
-
-// packages/experimental/assistant/src/experimental/cypher/echo-data-source.ts
-import { raise as raise2 } from "@dxos/debug";
-import { Filter } from "@dxos/echo-db";
-import { getSchema, getSchemaTypename, StoredSchema, toJsonSchema } from "@dxos/echo-schema";
-import { log as log10 } from "@dxos/log";
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file10 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/experimental/cypher/echo-data-source.ts";
-var EchoDataSource = class {
-  constructor(_db) {
-    this._db = _db;
-  }
-  async getNodes({ label: label2 }) {
-    if (!label2) {
-      const { objects: objects2 } = await this._db.query().run();
-      return objects2.map(this._objectToNode);
-    }
-    const schema = (await this._getAllSchema()).find((schema2) => getSchemaTypename(schema2)?.endsWith(label2));
-    if (!schema) {
-      return [];
-    }
-    const { objects } = await this._db.query(Filter.type(schema)).run();
-    return objects.map(this._objectToNode);
-  }
-  async getRelationships({ label: label2 }) {
-    const syntheticRefRelationships = (await this._getAllSchema()).filter((schema) => getSchemaTypename(schema) !== StoredSchema.typename).flatMap((schema) => {
-      const jsonSchema = toJsonSchema(schema);
-      const relationships = Object.entries(jsonSchema.properties).filter(([key, prop]) => isReference(prop));
-      return relationships.map(([key, value]) => {
-        const relationshipLabel = formatInferredRelationshipLabel(jsonSchema.typename ?? raise2(new Error("Schema must have typename")), key);
-        return {
-          label: relationshipLabel,
-          schema,
-          property: key
-        };
-      });
-    });
-    const relationship = syntheticRefRelationships.find((r) => r.label === label2);
-    if (!relationship) {
-      return [];
-    }
-    const { objects } = await this._db.query(Filter.type(relationship.schema)).run();
-    return (await Promise.all(objects.map((object) => this._projectRefRelationship(object, relationship.property)))).flat();
-  }
-  async _getAllSchema() {
-    return [
-      ...await this._db.schemaRegistry.query().run(),
-      // TODO(dmaretskyi): Remove once we can serialize recursive schema.
-      ...this._db.graph.schemaRegistry.schemas.filter((schema) => getSchemaTypename(schema)?.startsWith("example.org"))
-    ].filter((schema) => getSchemaTypename(schema) !== StoredSchema.typename);
-  }
-  _objectToNode(object) {
-    const { id, ...properties2 } = object;
-    return {
-      id,
-      kind: "node",
-      label: formatNodeLabel(getSchemaTypename(getSchema(object))),
-      properties: properties2
-    };
-  }
-  async _projectRefRelationship(object, prop) {
-    if (!object[prop]) {
-      return [];
-    }
-    const value = Array.isArray(object[prop]) ? object[prop] : [
-      object[prop]
-    ];
-    return Promise.all(value.map(async (ref) => {
-      const target = await ref.load();
-      return {
-        id: `${object.id}-${prop}-${target.id}`,
-        kind: "relationship",
-        label: formatInferredRelationshipLabel(getSchemaTypename(getSchema(object)), prop),
-        properties: {},
-        source: this._objectToNode(object),
-        target: this._objectToNode(target)
-      };
-    }));
-  }
-};
-_ts_decorate2([
-  log10.method(void 0, void 0, {
-    F: __dxlog_file10,
-    L: 18,
-    S: void 0,
-    C: (f, a) => f(...a)
-  })
-], EchoDataSource.prototype, "getNodes", null);
-_ts_decorate2([
-  log10.method(void 0, void 0, {
-    F: __dxlog_file10,
-    L: 34,
-    S: void 0,
-    C: (f, a) => f(...a)
-  })
-], EchoDataSource.prototype, "getRelationships", null);
-
-export {
-  DEFAULT_EDGE_MODEL,
-  DEFAULT_EDGE_MODELS,
-  DEFAULT_OLLAMA_ENDPOINT,
-  DEFAULT_OLLAMA_MODEL,
-  DEFAULT_OLLAMA_MODELS,
-  createGenerationStream,
-  GenerationStreamImpl,
-  AIServiceEdgeClient,
-  MessageCollector,
-  emitMessageAsEvents,
-  createArtifactElement,
-  LLMModel,
-  ToolTypes,
-  GenerateRequest,
-  GenerateResponse,
-  isToolUse,
-  runTools,
-  VersionPin,
-  AISession,
-  AIServiecOverloadedError,
-  OllamaClient,
-  StreamTransform,
-  MixedStreamParser,
-  mergeMessageBlock,
-  runLLM,
-  parseCypherQuery,
-  executeQueryPlan,
-  executeQuery,
-  trim,
-  formatJsonSchemaForLLM,
-  formatNodeLabel,
-  formatInferredRelationshipLabel,
-  isReference,
-  EchoDataSource
-};
-//# sourceMappingURL=chunk-B4HAWUFW.mjs.map