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

package/dist/lib/node-esm/index.mjs

@@ -1,1257 +1,54 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
+  AIServiceEdgeClient,
+  DEFAULT_EDGE_MODEL,
+  DEFAULT_EDGE_MODELS,
+  DEFAULT_OLLAMA_ENDPOINT,
+  DEFAULT_OLLAMA_MODEL,
+  DEFAULT_OLLAMA_MODELS,
   EchoDataSource,
+  GenerateRequest,
+  GenerationStreamImpl,
+  LLMModel,
+  MessageCollector,
+  MixedStreamParser,
+  OllamaClient,
+  StreamTransform,
+  ToolTypes,
+  createArtifactElement,
+  createGenerationStream,
+  emitMessageAsEvents,
   executeQuery,
   executeQueryPlan,
   formatInferredRelationshipLabel,
   formatJsonSchemaForLLM,
   formatNodeLabel,
   isReference,
-  parseCypherQuery
-} from "./chunk-GOVFOBIB.mjs";
-
-// packages/experimental/assistant/src/ai-service/client.ts
-import { Schema as S } from "@effect/schema";
-import { Message } from "@dxos/artifact";
-import { invariant } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
-
-// 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: 21,
-            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: 37,
-            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 GenerationStream(controller, iterator);
-};
-var GenerationStream = 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);
-        }
-      };
-      return generator.call(this);
-    })();
-  }
-};
-
-// packages/experimental/assistant/src/ai-service/client.ts
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/ai-service/client.ts";
-var AIServiceClientImpl = class {
-  constructor({ endpoint }) {
-    invariant(endpoint, "endpoint is required", {
-      F: __dxlog_file2,
-      L: 34,
-      S: this,
-      A: [
-        "endpoint",
-        "'endpoint is required'"
-      ]
-    });
-    this._endpoint = endpoint;
-  }
-  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) {
-    request = {
-      tools: request.tools ?? [],
-      ...request
-    };
-    log2.info("requesting", {
-      endpoint: this._endpoint
-    }, {
-      F: __dxlog_file2,
-      L: 63,
-      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(request)
-    });
-    invariant(response.body instanceof ReadableStream, void 0, {
-      F: __dxlog_file2,
-      L: 72,
-      S: this,
-      A: [
-        "response.body instanceof ReadableStream",
-        ""
-      ]
-    });
-    return createGenerationStream(response, controller);
-  }
-};
-
-// packages/experimental/assistant/src/ai-service/defs.ts
-var DEFAULT_LLM_MODEL = "@anthropic/claude-3-5-sonnet-20241022";
-var DEFAULT_LLM_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"
-];
-
-// packages/experimental/assistant/src/ai-service/parser.ts
-import { Message as Message2 } from "@dxos/artifact";
-import { Event } from "@dxos/async";
-import { createStatic } from "@dxos/echo-schema";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { log as log3 } 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_file3 = "/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();
-  }
-  _emitBlock(contentBlock, streamBlock) {
-    const messageBlock = streamBlock ? mergeMessageBlock(contentBlock, streamBlock) : contentBlock;
-    if (messageBlock) {
-      if (messageBlock.type === "text" && messageBlock.text.length === 0) {
-        return;
-      }
-      invariant2(this._message, void 0, {
-        F: __dxlog_file3,
-        L: 46,
-        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) {
-      switch (event.type) {
-        //
-        // Messages.
-        //
-        case "message_start": {
-          if (this._message) {
-            log3.warn("unexpected message_start", void 0, {
-              F: __dxlog_file3,
-              L: 88,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-          this._message = createStatic(Message2, {
-            role: "assistant",
-            content: []
-          });
-          this.message.emit(this._message);
-          break;
-        }
-        case "message_delta": {
-          if (!this._message) {
-            log3.warn("unexpected message_delta", void 0, {
-              F: __dxlog_file3,
-              L: 98,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-          break;
-        }
-        case "message_stop": {
-          if (!this._message) {
-            log3.warn("unexpected message_stop", void 0, {
-              F: __dxlog_file3,
-              L: 106,
-              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) {
-            log3.warn("unexpected content_block_start", {
-              content: contentBlock
-            }, {
-              F: __dxlog_file3,
-              L: 120,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-          contentBlock = event.content;
-          break;
-        }
-        case "content_block_delta": {
-          if (!contentBlock) {
-            log3.warn("unexpected content_block_delta", void 0, {
-              F: __dxlog_file3,
-              L: 130,
-              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();
-                          invariant2(top && top.type === "tag", void 0, {
-                            F: __dxlog_file3,
-                            L: 154,
-                            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);
-                        invariant2(last, void 0, {
-                          F: __dxlog_file3,
-                          L: 171,
-                          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) {
-                log3.warn("unexpected input_json_delta", {
-                  contentBlock
-                }, {
-                  F: __dxlog_file3,
-                  L: 221,
-                  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) {
-            log3.warn("unexpected content_block_stop", void 0, {
-              F: __dxlog_file3,
-              L: 238,
-              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) => {
-  log3("mergeMessageBlock", {
-    contentBlock,
-    streamBlock
-  }, {
-    F: __dxlog_file3,
-    L: 265,
-    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/ai-service/types.ts
-import { Schema as S2 } from "@effect/schema";
-import { Tool, Message as Message3, SpaceIdSchema } from "@dxos/artifact";
-import { ObjectId } from "@dxos/echo-schema";
-var createArtifactElement = (id) => `<artifact id=${id} />`;
-var LLMModel = S2.Literal(...DEFAULT_LLM_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(Message3)),
-  /**
-  * Current request.
-  */
-  prompt: S2.optional(Message3)
-});
-
-// packages/experimental/assistant/src/conversation/conversation.ts
-import { ToolResult, Message as Message4 } from "@dxos/artifact";
-import { createStatic as createStatic2, 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/conversation/conversation.ts";
-var runLLM = async (params) => {
-  let conversationResult = null;
-  const history = params.history ?? [];
-  const generate = async () => {
-    log4("llm generate", {
-      tools: params.tools
-    }, {
-      F: __dxlog_file4,
-      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);
-    invariant3(message, void 0, {
-      F: __dxlog_file4,
-      L: 63,
-      S: void 0,
-      A: [
-        "message",
-        ""
-      ]
-    });
-    log4("llm result", {
-      time: Date.now() - beginTs,
-      message
-    }, {
-      F: __dxlog_file4,
-      L: 65,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    invariant3(message, void 0, {
-      F: __dxlog_file4,
-      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");
-      invariant3(toolCalls.length === 1, void 0, {
-        F: __dxlog_file4,
-        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}`);
-      }
-      invariant3(tool.execute, void 0, {
-        F: __dxlog_file4,
-        L: 84,
-        S: void 0,
-        A: [
-          "tool.execute",
-          ""
-        ]
-      });
-      const toolResult = await tool.execute(toolCall.input);
-      switch (toolResult.kind) {
-        case "error": {
-          log4.warn("tool error", {
-            message: toolResult.message
-          }, {
-            F: __dxlog_file4,
-            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": {
-          log4("tool success", {
-            result: toolResult.result
-          }, {
-            F: __dxlog_file4,
-            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": {
-          log4("tool break", {
-            result: toolResult.result
-          }, {
-            F: __dxlog_file4,
-            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) => {
-  const block = message.content.at(-1);
-  invariant3(block, void 0, {
-    F: __dxlog_file4,
-    L: 152,
-    S: void 0,
-    A: [
-      "block",
-      ""
-    ]
-  });
-  return block.type === "tool_use";
-};
-var runTools = async ({ message, tools, extensions }) => {
-  const toolCalls = message.content.filter((block) => block.type === "tool_use");
-  invariant3(toolCalls.length === 1, void 0, {
-    F: __dxlog_file4,
-    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 {
-    invariant3(tool.execute, void 0, {
-      F: __dxlog_file4,
-      L: 183,
-      S: void 0,
-      A: [
-        "tool.execute",
-        ""
-      ]
-    });
-    toolResult = await tool.execute(toolCall.input, {
-      extensions
-    });
-  } catch (error) {
-    log4("tool error", {
-      error
-    }, {
-      F: __dxlog_file4,
-      L: 186,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    toolResult = ToolResult.Error(error.message);
-  }
-  switch (toolResult.kind) {
-    case "error": {
-      log4("tool error", {
-        message: toolResult.message
-      }, {
-        F: __dxlog_file4,
-        L: 192,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      const resultMessage = createStatic2(Message4, {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            toolUseId: toolCall.id,
-            content: toolResult.message,
-            isError: true
-          }
-        ]
-      });
-      return {
-        type: "continue",
-        message: resultMessage
-      };
-    }
-    case "success": {
-      log4("tool success", {
-        result: toolResult.result
-      }, {
-        F: __dxlog_file4,
-        L: 213,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      const resultMessage = createStatic2(Message4, {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            toolUseId: toolCall.id,
-            content: typeof toolResult.result === "string" ? toolResult.result : JSON.stringify(toolResult.result) ?? ""
-          }
-        ]
-      });
-      return {
-        type: "continue",
-        message: resultMessage
-      };
-    }
-    case "break": {
-      log4("tool break", {
-        result: toolResult.result
-      }, {
-        F: __dxlog_file4,
-        L: 233,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      return {
-        type: "break",
-        result: toolResult.result
-      };
-    }
-  }
-};
+  isToolUse,
+  mergeMessageBlock,
+  parseCypherQuery,
+  runLLM,
+  runTools
+} from "./chunk-JUVGBQBL.mjs";
 export {
-  AIServiceClientImpl,
-  DEFAULT_LLM_MODEL,
-  DEFAULT_LLM_MODELS,
+  AIServiceEdgeClient,
+  DEFAULT_EDGE_MODEL,
+  DEFAULT_EDGE_MODELS,
+  DEFAULT_OLLAMA_ENDPOINT,
+  DEFAULT_OLLAMA_MODEL,
+  DEFAULT_OLLAMA_MODELS,
   EchoDataSource,
   GenerateRequest,
-  GenerationStream,
+  GenerationStreamImpl,
   LLMModel,
+  MessageCollector,
   MixedStreamParser,
+  OllamaClient,
   StreamTransform,
   ToolTypes,
   createArtifactElement,
   createGenerationStream,
+  emitMessageAsEvents,
   executeQuery,
   executeQueryPlan,
   formatInferredRelationshipLabel,