@dxos/assistant 0.7.4 → 0.7.5-labs.071a3e2

package/dist/lib/node/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,79 +17,1235 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
-  AIServiceClientImpl: () => import_chunk_G6CGWEMO.AIServiceClientImpl,
-  EchoDataSource: () => import_chunk_G6CGWEMO.EchoDataSource,
-  GenerateRequest: () => import_chunk_G6CGWEMO.GenerateRequest,
-  GenerationStream: () => import_chunk_G6CGWEMO.GenerationStream,
-  ImageSource: () => import_chunk_G6CGWEMO.ImageSource,
-  LLMModel: () => import_chunk_G6CGWEMO.LLMModel,
-  LLMTool: () => import_chunk_G6CGWEMO.LLMTool,
-  LLMToolDefinition: () => import_chunk_G6CGWEMO.LLMToolDefinition,
-  LLMToolResult: () => import_chunk_G6CGWEMO.LLMToolResult,
-  Message: () => import_chunk_G6CGWEMO.Message,
-  MessageContentBlock: () => import_chunk_G6CGWEMO.MessageContentBlock,
-  MessageFromDb: () => import_chunk_G6CGWEMO.MessageFromDb,
-  MessageImageContentBlock: () => import_chunk_G6CGWEMO.MessageImageContentBlock,
-  MessageRole: () => import_chunk_G6CGWEMO.MessageRole,
-  MessageTextContentBlock: () => import_chunk_G6CGWEMO.MessageTextContentBlock,
-  MessageToolResultContentBlock: () => import_chunk_G6CGWEMO.MessageToolResultContentBlock,
-  MessageToolUseContentBlock: () => import_chunk_G6CGWEMO.MessageToolUseContentBlock,
-  ObjectId: () => import_chunk_G6CGWEMO.ObjectId,
-  ObjectIdBrand: () => import_chunk_G6CGWEMO.ObjectIdBrand,
-  Space: () => import_chunk_G6CGWEMO.Space,
-  SpaceIdSchema: () => import_chunk_G6CGWEMO.SpaceIdSchema,
-  Thread: () => import_chunk_G6CGWEMO.Thread,
-  ToolTypes: () => import_chunk_G6CGWEMO.ToolTypes,
-  createUserMessage: () => import_chunk_G6CGWEMO.createUserMessage,
-  defineTool: () => import_chunk_G6CGWEMO.defineTool,
-  executeQuery: () => import_chunk_G6CGWEMO.executeQuery,
-  executeQueryPlan: () => import_chunk_G6CGWEMO.executeQueryPlan,
-  formatInferredRelationshipLabel: () => import_chunk_G6CGWEMO.formatInferredRelationshipLabel,
-  formatJsonSchemaForLLM: () => import_chunk_G6CGWEMO.formatJsonSchemaForLLM,
-  formatNodeLabel: () => import_chunk_G6CGWEMO.formatNodeLabel,
-  isReference: () => import_chunk_G6CGWEMO.isReference,
-  parseCypherQuery: () => import_chunk_G6CGWEMO.parseCypherQuery,
-  runLLM: () => import_chunk_G6CGWEMO.runLLM
+  AIServiceClientImpl: () => AIServiceClientImpl,
+  EchoDataSource: () => import_chunk_QPHGQINW.EchoDataSource,
+  GenerateRequest: () => GenerateRequest,
+  GenerationStream: () => GenerationStream,
+  LLMModel: () => LLMModel,
+  MixedStreamParser: () => MixedStreamParser,
+  StreamTransform: () => StreamTransform,
+  ToolTypes: () => ToolTypes,
+  createArtifactElement: () => createArtifactElement,
+  createGenerationStream: () => createGenerationStream,
+  executeQuery: () => import_chunk_QPHGQINW.executeQuery,
+  executeQueryPlan: () => import_chunk_QPHGQINW.executeQueryPlan,
+  formatInferredRelationshipLabel: () => import_chunk_QPHGQINW.formatInferredRelationshipLabel,
+  formatJsonSchemaForLLM: () => import_chunk_QPHGQINW.formatJsonSchemaForLLM,
+  formatNodeLabel: () => import_chunk_QPHGQINW.formatNodeLabel,
+  isReference: () => import_chunk_QPHGQINW.isReference,
+  isToolUse: () => isToolUse,
+  mergeMessageBlock: () => mergeMessageBlock,
+  parseCypherQuery: () => import_chunk_QPHGQINW.parseCypherQuery,
+  runLLM: () => runLLM,
+  runTools: () => runTools
 });
 module.exports = __toCommonJS(node_exports);
-var import_chunk_G6CGWEMO = require("./chunk-G6CGWEMO.cjs");
+var import_chunk_QPHGQINW = require("./chunk-QPHGQINW.cjs");
+var import_schema = require("@effect/schema");
+var import_artifact = require("@dxos/artifact");
+var import_invariant = require("@dxos/invariant");
+var import_async = require("@dxos/async");
+var import_log = require("@dxos/log");
+var import_artifact2 = require("@dxos/artifact");
+var import_async2 = require("@dxos/async");
+var import_echo_schema = require("@dxos/echo-schema");
+var import_invariant2 = require("@dxos/invariant");
+var import_log2 = require("@dxos/log");
+var import_util = require("@dxos/util");
+var P = __toESM(require("parsimmon"));
+var import_schema2 = require("@effect/schema");
+var import_artifact3 = require("@dxos/artifact");
+var import_echo_schema2 = require("@dxos/echo-schema");
+var import_artifact4 = require("@dxos/artifact");
+var import_echo_schema3 = require("@dxos/echo-schema");
+var import_invariant3 = require("@dxos/invariant");
+var import_log3 = require("@dxos/log");
+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 {
+    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;
+  }
+};
+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) {
+          import_log.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) {
+          import_log.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 import_async.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);
+    })();
+  }
+};
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/ai-service/client.ts";
+var AIServiceClientImpl = class {
+  constructor({ endpoint }) {
+    (0, import_invariant.invariant)(endpoint, "endpoint is required", {
+      F: __dxlog_file2,
+      L: 36,
+      S: this,
+      A: [
+        "endpoint",
+        "'endpoint is required'"
+      ]
+    });
+    this._endpoint = endpoint;
+  }
+  async getSpace(spaceId) {
+    throw new Error("Not implemented");
+  }
+  async getThread(spaceId, threadId) {
+    throw new Error("Not implemented");
+  }
+  async getMessages(spaceId, threadId) {
+    const res = await fetch(`${this._endpoint}/space/${spaceId}/thread/${threadId}/message`);
+    return import_schema.Schema.decodePromise(import_schema.Schema.Array(import_artifact.Message).pipe(import_schema.Schema.mutable))((await res.json()).data.results);
+  }
+  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 import_schema.Schema.encodePromise(import_schema.Schema.Array(import_artifact.Message))(messages)
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`${await res.text()} [${url}]`);
+    }
+  }
+  // TODO(dmaretskyi): Accept partial message schema.
+  async updateMessage(spaceId, threadId, messageId, message) {
+    throw new Error("Not implemented");
+  }
+  /**
+  * Open message stream.
+  */
+  async generate(request) {
+    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)
+    });
+    (0, import_invariant.invariant)(response.body instanceof ReadableStream, void 0, {
+      F: __dxlog_file2,
+      L: 85,
+      S: this,
+      A: [
+        "response.body instanceof ReadableStream",
+        ""
+      ]
+    });
+    return createGenerationStream(response, controller);
+  }
+};
+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
+      }
+    ] : [];
+  }
+};
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/ai-service/parser.ts";
+var MixedStreamParser = class {
+  constructor() {
+    this.message = new import_async2.Event();
+    this.block = new import_async2.Event();
+    this.update = new import_async2.Event();
+  }
+  _emitBlock(contentBlock, streamBlock) {
+    const messageBlock = streamBlock ? mergeMessageBlock(contentBlock, streamBlock) : contentBlock;
+    if (messageBlock) {
+      if (messageBlock.type === "text" && messageBlock.text.length === 0) {
+        return;
+      }
+      (0, import_invariant2.invariant)(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 = [];
+    for await (const event of stream) {
+      switch (event.type) {
+        //
+        // Messages.
+        //
+        case "message_start": {
+          if (this._message) {
+            import_log2.log.warn("unexpected message_start", void 0, {
+              F: __dxlog_file3,
+              L: 86,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
+          this._message = (0, import_echo_schema.createStatic)(import_artifact2.Message, {
+            role: "assistant",
+            content: []
+          });
+          this.message.emit(this._message);
+          break;
+        }
+        case "message_delta": {
+          if (!this._message) {
+            import_log2.log.warn("unexpected message_delta", void 0, {
+              F: __dxlog_file3,
+              L: 96,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
+          break;
+        }
+        case "message_stop": {
+          if (!this._message) {
+            import_log2.log.warn("unexpected message_stop", void 0, {
+              F: __dxlog_file3,
+              L: 104,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          } else {
+            this._message = void 0;
+          }
+          break;
+        }
+        //
+        // Content blocks.
+        //
+        case "content_block_start": {
+          if (contentBlock) {
+            import_log2.log.warn("unexpected content_block_start", {
+              content: contentBlock
+            }, {
+              F: __dxlog_file3,
+              L: 117,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
+          contentBlock = event.content;
+          break;
+        }
+        case "content_block_delta": {
+          if (!contentBlock) {
+            import_log2.log.warn("unexpected content_block_delta", void 0, {
+              F: __dxlog_file3,
+              L: 127,
+              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();
+                          (0, import_invariant2.invariant)(top && top.type === "tag", void 0, {
+                            F: __dxlog_file3,
+                            L: 151,
+                            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);
+                        (0, import_invariant2.invariant)(last, void 0, {
+                          F: __dxlog_file3,
+                          L: 168,
+                          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) {
+                import_log2.log.warn("unexpected input_json_delta", {
+                  contentBlock
+                }, {
+                  F: __dxlog_file3,
+                  L: 218,
+                  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) {
+            import_log2.log.warn("unexpected content_block_stop", void 0, {
+              F: __dxlog_file3,
+              L: 235,
+              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);
+      }
+    }
+  }
+};
+var mergeMessageBlock = (contentBlock, streamBlock) => {
+  (0, import_log2.log)("mergeMessageBlock", {
+    contentBlock,
+    streamBlock
+  }, {
+    F: __dxlog_file3,
+    L: 260,
+    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(import_util.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
+              ] : [])
+            })
+          };
+        }
+      }
+      break;
+    }
+    //
+    // JSON
+    //
+    case "json": {
+      switch (contentBlock.type) {
+        case "tool_use": {
+          return {
+            ...contentBlock,
+            input: (0, import_util.safeParseJson)(streamBlock.content) ?? {}
+          };
+        }
+      }
+      return {
+        ...contentBlock,
+        type: "json",
+        disposition: "artifact",
+        json: streamBlock.content
+      };
+    }
+  }
+};
+var createArtifactElement = (id) => `<artifact id=${id} />`;
+var LLMModel = import_schema2.Schema.Literal("@anthropic/claude-3-5-haiku-20241022", "@anthropic/claude-3-5-sonnet-20241022", "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b", "@hf/nousresearch/hermes-2-pro-mistral-7b", "@ollama/llama-3-2-3b", "@ollama/llama-3-1-nemotron-70b-instruct", "@ollama/llama-3-1-nemotron-mini-4b-instruct");
+var ToolTypes = Object.freeze({
+  // TODO(dmaretskyi): Not implemented yet.
+  // DatabaseQuery: 'database_query',
+  TextToImage: "text_to_image"
+});
+var GenerateRequest = import_schema2.Schema.Struct({
+  spaceId: import_schema2.Schema.optional(import_artifact3.SpaceIdSchema),
+  threadId: import_schema2.Schema.optional(import_echo_schema2.ObjectId),
+  // TODO(burdon): Make optional with default.
+  model: LLMModel,
+  /**
+  * Current request.
+  */
+  // TODO(burdon): Remove from history.
+  // prompt: Message,
+  /**
+  * System instructions to the LLM.
+  */
+  systemPrompt: import_schema2.Schema.optional(import_schema2.Schema.String),
+  /**
+  * History of messages to include in the context window.
+  */
+  history: import_schema2.Schema.optional(import_schema2.Schema.Array(import_artifact3.Message)),
+  /**
+  * Tools available for the LLM.
+  */
+  tools: import_schema2.Schema.optional(import_schema2.Schema.Array(import_artifact3.Tool).pipe(import_schema2.Schema.mutable))
+});
+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 () => {
+    (0, import_log3.log)("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.generate({
+      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);
+    (0, import_invariant3.invariant)(message, void 0, {
+      F: __dxlog_file4,
+      L: 63,
+      S: void 0,
+      A: [
+        "message",
+        ""
+      ]
+    });
+    (0, import_log3.log)("llm result", {
+      time: Date.now() - beginTs,
+      message
+    }, {
+      F: __dxlog_file4,
+      L: 65,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    (0, import_invariant3.invariant)(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");
+      (0, import_invariant3.invariant)(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}`);
+      }
+      (0, import_invariant3.invariant)(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": {
+          import_log3.log.warn("tool error", {
+            message: toolResult.message
+          }, {
+            F: __dxlog_file4,
+            L: 88,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          const resultMessage = {
+            id: import_echo_schema3.ObjectId.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": {
+          (0, import_log3.log)("tool success", {
+            result: toolResult.result
+          }, {
+            F: __dxlog_file4,
+            L: 110,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          const resultMessage = {
+            id: import_echo_schema3.ObjectId.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": {
+          (0, import_log3.log)("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);
+  (0, import_invariant3.invariant)(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");
+  (0, import_invariant3.invariant)(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 {
+    (0, import_invariant3.invariant)(tool.execute, void 0, {
+      F: __dxlog_file4,
+      L: 183,
+      S: void 0,
+      A: [
+        "tool.execute",
+        ""
+      ]
+    });
+    toolResult = await tool.execute(toolCall.input, {
+      extensions
+    });
+  } catch (error) {
+    (0, import_log3.log)("tool error", {
+      error
+    }, {
+      F: __dxlog_file4,
+      L: 186,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    toolResult = import_artifact4.ToolResult.Error(error.message);
+  }
+  switch (toolResult.kind) {
+    case "error": {
+      (0, import_log3.log)("tool error", {
+        message: toolResult.message
+      }, {
+        F: __dxlog_file4,
+        L: 192,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      const resultMessage = (0, import_echo_schema3.createStatic)(import_artifact4.Message, {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            toolUseId: toolCall.id,
+            content: toolResult.message,
+            isError: true
+          }
+        ]
+      });
+      return {
+        type: "continue",
+        message: resultMessage
+      };
+    }
+    case "success": {
+      (0, import_log3.log)("tool success", {
+        result: toolResult.result
+      }, {
+        F: __dxlog_file4,
+        L: 213,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      const resultMessage = (0, import_echo_schema3.createStatic)(import_artifact4.Message, {
+        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": {
+      (0, import_log3.log)("tool break", {
+        result: toolResult.result
+      }, {
+        F: __dxlog_file4,
+        L: 233,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return {
+        type: "break",
+        result: toolResult.result
+      };
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AIServiceClientImpl,
   EchoDataSource,
   GenerateRequest,
   GenerationStream,
-  ImageSource,
   LLMModel,
-  LLMTool,
-  LLMToolDefinition,
-  LLMToolResult,
-  Message,
-  MessageContentBlock,
-  MessageFromDb,
-  MessageImageContentBlock,
-  MessageRole,
-  MessageTextContentBlock,
-  MessageToolResultContentBlock,
-  MessageToolUseContentBlock,
-  ObjectId,
-  ObjectIdBrand,
-  Space,
-  SpaceIdSchema,
-  Thread,
+  MixedStreamParser,
+  StreamTransform,
   ToolTypes,
-  createUserMessage,
-  defineTool,
+  createArtifactElement,
+  createGenerationStream,
   executeQuery,
   executeQueryPlan,
   formatInferredRelationshipLabel,
   formatJsonSchemaForLLM,
   formatNodeLabel,
   isReference,
+  isToolUse,
+  mergeMessageBlock,
   parseCypherQuery,
-  runLLM
+  runLLM,
+  runTools
 });
 //# sourceMappingURL=index.cjs.map