@dxos/assistant 0.8.0 → 0.8.1-main.81238a8

package/dist/lib/node-esm/chunk-JUVGBQBL.mjs

@@ -0,0 +1,2278 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// 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 { Schema as S } from "effect";
+import { Message } from "@dxos/artifact";
+import { 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: 23,
+      S: this,
+      A: [
+        "endpoint",
+        "'endpoint is required'"
+      ]
+    });
+    this._endpoint = endpoint;
+  }
+  /**
+  * @deprecated
+  */
+  // TODO(burdon): Remove.
+  async appendMessages(messages) {
+    const url = `${this._endpoint}/message`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        messages: await S.encodePromise(S.Array(Message))(messages)
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`${await res.text()} [${url}]`);
+    }
+  }
+  /**
+  * Process request and open message stream.
+  */
+  async exec(request) {
+    log2.info("requesting", {
+      endpoint: this._endpoint
+    }, {
+      F: __dxlog_file2,
+      L: 50,
+      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
+      })
+    });
+    invariant(response.body instanceof ReadableStream, void 0, {
+      F: __dxlog_file2,
+      L: 63,
+      S: this,
+      A: [
+        "response.body instanceof ReadableStream",
+        ""
+      ]
+    });
+    return createGenerationStream(response, controller);
+  }
+};
+
+// 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 as S2 } from "effect";
+import { Tool, Message as Message2, SpaceIdSchema } from "@dxos/artifact";
+import { ObjectId } from "@dxos/echo-schema";
+var createArtifactElement = (id) => `<artifact id=${id} />`;
+var LLMModel = S2.Literal(...DEFAULT_EDGE_MODELS);
+var ToolTypes = Object.freeze({
+  // TODO(dmaretskyi): Not implemented yet.
+  // DatabaseQuery: 'database_query',
+  TextToImage: "text_to_image"
+});
+var GenerateRequest = S2.Struct({
+  spaceId: S2.optional(SpaceIdSchema),
+  threadId: S2.optional(ObjectId),
+  /**
+  * Preferred model or system default.
+  */
+  model: S2.optional(LLMModel),
+  /**
+  * Tools available for the LLM.
+  */
+  tools: S2.optional(S2.Array(Tool).pipe(S2.mutable)),
+  /**
+  * System instructions to the LLM.
+  */
+  systemPrompt: S2.optional(S2.String),
+  /**
+  * History of messages to include in the context window.
+  */
+  // TODO(burdon): Rename messages.
+  history: S2.optional(S2.Array(Message2)),
+  /**
+  * Current request.
+  */
+  prompt: S2.optional(Message2)
+});
+
+// packages/experimental/assistant/src/conversation/conversation.ts
+import { ToolResult, Message as Message3 } from "@dxos/artifact";
+import { createStatic, ObjectId as ObjectId2 } 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/conversation/conversation.ts";
+var runLLM = async (params) => {
+  let conversationResult = null;
+  const history = params.history ?? [];
+  const generate = async () => {
+    log3("llm generate", {
+      tools: params.tools
+    }, {
+      F: __dxlog_file3,
+      L: 44,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    const beginTs = Date.now();
+    const stream = await params.client.exec({
+      model: params.model,
+      spaceId: params.spaceId,
+      threadId: params.threadId,
+      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);
+    invariant2(message, void 0, {
+      F: __dxlog_file3,
+      L: 63,
+      S: void 0,
+      A: [
+        "message",
+        ""
+      ]
+    });
+    log3("llm result", {
+      time: Date.now() - beginTs,
+      message
+    }, {
+      F: __dxlog_file3,
+      L: 65,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    invariant2(message, void 0, {
+      F: __dxlog_file3,
+      L: 66,
+      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");
+      invariant2(toolCalls.length === 1, void 0, {
+        F: __dxlog_file3,
+        L: 77,
+        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}`);
+      }
+      invariant2(tool.execute, void 0, {
+        F: __dxlog_file3,
+        L: 84,
+        S: void 0,
+        A: [
+          "tool.execute",
+          ""
+        ]
+      });
+      const toolResult = await tool.execute(toolCall.input);
+      switch (toolResult.kind) {
+        case "error": {
+          log3.warn("tool error", {
+            message: toolResult.message
+          }, {
+            F: __dxlog_file3,
+            L: 88,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          const resultMessage = {
+            id: ObjectId2.random(),
+            spaceId: params.spaceId,
+            threadId: params.threadId,
+            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": {
+          log3("tool success", {
+            result: toolResult.result
+          }, {
+            F: __dxlog_file3,
+            L: 110,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          const resultMessage = {
+            id: ObjectId2.random(),
+            spaceId: params.spaceId,
+            threadId: params.threadId,
+            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": {
+          log3("tool break", {
+            result: toolResult.result
+          }, {
+            F: __dxlog_file3,
+            L: 131,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          conversationResult = toolResult.result;
+          return false;
+        }
+      }
+    }
+    return false;
+  };
+  while (await generate()) {
+  }
+  return {
+    result: conversationResult,
+    history
+  };
+};
+var isToolUse = (message, { onlyToolNames } = {}) => {
+  const block = message.content.at(-1);
+  invariant2(block, void 0, {
+    F: __dxlog_file3,
+    L: 152,
+    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: 174,
+    S: void 0,
+    A: [
+      "toolCalls.length === 1",
+      ""
+    ]
+  });
+  const toolCall = toolCalls[0];
+  const tool = tools.find((tool2) => tool2.name === toolCall.name);
+  if (!tool) {
+    throw new Error(`Tool not found: ${toolCall.name}`);
+  }
+  let toolResult;
+  try {
+    invariant2(tool.execute, void 0, {
+      F: __dxlog_file3,
+      L: 183,
+      S: void 0,
+      A: [
+        "tool.execute",
+        ""
+      ]
+    });
+    toolResult = await tool.execute(toolCall.input, {
+      extensions
+    });
+  } catch (error) {
+    log3("tool error", {
+      error
+    }, {
+      F: __dxlog_file3,
+      L: 186,
+      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: 192,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      const resultMessage = createStatic(Message3, {
+        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: 213,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      const resultMessage = createStatic(Message3, {
+        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: 234,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return {
+        type: "break",
+        result: toolResult.result
+      };
+    }
+  }
+};
+
+// packages/experimental/assistant/src/ai-service/ollama-client.ts
+import { Schema as S3 } from "effect";
+import { defineTool, ToolResult as ToolResult2 } from "@dxos/artifact";
+import { ObjectId as ObjectId3 } 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.info("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 parseErrorResponse(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 = ObjectId3.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.info("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: ObjectId3.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();
+    }
+  }
+  async exec(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: S3.Struct({
+      prompt: S3.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 = ObjectId3.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 S3.TaggedError()("ModelDoesNotSupportToolsError", {
+  model: S3.String
+}) {
+};
+var ModelNotFoundError = class extends S3.TaggedError()("ModelNotFoundError", {
+  model: S3.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 parseErrorResponse = 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/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
+import { Message as Message4 } from "@dxos/artifact";
+import { Event } from "@dxos/async";
+import { createStatic as createStatic2 } from "@dxos/echo-schema";
+import { invariant as invariant4 } from "@dxos/invariant";
+import { log as log5 } from "@dxos/log";
+import { isNotFalsy, safeParseJson } from "@dxos/util";
+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) {
+      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: 93,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
+          this._message = createStatic2(Message4, {
+            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: 103,
+              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: 111,
+              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: 125,
+              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: 135,
+              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) {
+                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: 159,
+                            S: this,
+                            A: [
+                              "top && top.type === 'tag'",
+                              ""
+                            ]
+                          });
+                          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: 176,
+                          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: 226,
+                  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: 243,
+              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: 270,
+    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 "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/cypher/parjs.ts
+import { parjsCombinators, parjs } from "#parjs";
+
+// packages/experimental/assistant/src/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/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/cypher/query-executor.ts
+import { log as log7 } from "@dxos/log";
+import { mapValues } from "@dxos/util";
+
+// packages/experimental/assistant/src/cypher/execution-plan.ts
+import { invariant as invariant5 } from "@dxos/invariant";
+import { log as log6 } from "@dxos/log";
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/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) {
+    log6("Creating execution plan for query", {
+      query
+    }, {
+      F: __dxlog_file6,
+      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) {
+    invariant5(match.pattern.segments.length > 0, void 0, {
+      F: __dxlog_file6,
+      L: 90,
+      S: this,
+      A: [
+        "match.pattern.segments.length > 0",
+        ""
+      ]
+    });
+    const firstSegment = match.pattern.segments[0];
+    invariant5(firstSegment.astKind === "NodePattern", void 0, {
+      F: __dxlog_file6,
+      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++];
+      invariant5(relationshipSegment.astKind === "RelationshipPattern", void 0, {
+        F: __dxlog_file6,
+        L: 115,
+        S: this,
+        A: [
+          "relationshipSegment.astKind === 'RelationshipPattern'",
+          ""
+        ]
+      });
+      const nodeSegment = match.pattern.segments[i];
+      invariant5(nodeSegment.astKind === "NodePattern", void 0, {
+        F: __dxlog_file6,
+        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/cypher/query-executor.ts
+var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/cypher/query-executor.ts";
+var executeQueryPlan = async (dataSource, plan) => {
+  let buffer = [];
+  const results = [];
+  for (const step of plan.steps) {
+    log7("begin step", {
+      step
+    }, {
+      F: __dxlog_file7,
+      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;
+      }
+    }
+    log7("finish step", {
+      buffer: buffer.map((tuple) => mapValues(tuple, (x) => x.id)),
+      results
+    }, {
+      F: __dxlog_file7,
+      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/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/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/cypher/echo-data-source.ts
+import { raise as raise2 } from "@dxos/debug";
+import { Filter } from "@dxos/echo-db";
+import { getSchemaTypename, StoredSchema, toJsonSchema } from "@dxos/echo-schema";
+import { getSchema } from "@dxos/live-object";
+import { log as log8 } from "@dxos/log";
+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_file8 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/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((s) => getSchemaTypename(s)?.endsWith(label2));
+    if (!schema) {
+      return [];
+    }
+    const { objects } = await this._db.query(Filter.schema(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.schema(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((s) => getSchemaTypename(s)?.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_decorate([
+  log8.method(void 0, void 0, {
+    F: __dxlog_file8,
+    L: 17,
+    S: void 0,
+    C: (f, a) => f(...a)
+  })
+], EchoDataSource.prototype, "getNodes", null);
+_ts_decorate([
+  log8.method(void 0, void 0, {
+    F: __dxlog_file8,
+    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,
+  runLLM,
+  isToolUse,
+  runTools,
+  OllamaClient,
+  StreamTransform,
+  MixedStreamParser,
+  mergeMessageBlock,
+  parseCypherQuery,
+  executeQueryPlan,
+  executeQuery,
+  trim,
+  formatJsonSchemaForLLM,
+  formatNodeLabel,
+  formatInferredRelationshipLabel,
+  isReference,
+  EchoDataSource
+};
+//# sourceMappingURL=chunk-JUVGBQBL.mjs.map