@dxos/assistant 0.8.0 → 0.8.1-main.013e445

package/dist/lib/node/index.cjs

@@ -1,9 +1,7 @@
 "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)
@@ -17,1255 +15,386 @@ 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: () => AIServiceClientImpl,
-  DEFAULT_LLM_MODEL: () => DEFAULT_LLM_MODEL,
-  DEFAULT_LLM_MODELS: () => DEFAULT_LLM_MODELS,
-  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
+  AIServiceEdgeClient: () => import_chunk_A44NGSCM.AIServiceEdgeClient,
+  AIServiecOverloadedError: () => AIServiecOverloadedError,
+  AISession: () => AISession,
+  DEFAULT_EDGE_MODEL: () => import_chunk_A44NGSCM.DEFAULT_EDGE_MODEL,
+  DEFAULT_EDGE_MODELS: () => import_chunk_A44NGSCM.DEFAULT_EDGE_MODELS,
+  DEFAULT_OLLAMA_ENDPOINT: () => import_chunk_A44NGSCM.DEFAULT_OLLAMA_ENDPOINT,
+  DEFAULT_OLLAMA_MODEL: () => import_chunk_A44NGSCM.DEFAULT_OLLAMA_MODEL,
+  DEFAULT_OLLAMA_MODELS: () => import_chunk_A44NGSCM.DEFAULT_OLLAMA_MODELS,
+  EchoDataSource: () => import_chunk_A44NGSCM.EchoDataSource,
+  GenerateRequest: () => import_chunk_A44NGSCM.GenerateRequest,
+  GenerationStreamImpl: () => import_chunk_A44NGSCM.GenerationStreamImpl,
+  LLMModel: () => import_chunk_A44NGSCM.LLMModel,
+  MessageCollector: () => import_chunk_A44NGSCM.MessageCollector,
+  MixedStreamParser: () => import_chunk_A44NGSCM.MixedStreamParser,
+  OllamaClient: () => import_chunk_A44NGSCM.OllamaClient,
+  StreamTransform: () => import_chunk_A44NGSCM.StreamTransform,
+  ToolTypes: () => import_chunk_A44NGSCM.ToolTypes,
+  createArtifactElement: () => import_chunk_A44NGSCM.createArtifactElement,
+  createGenerationStream: () => import_chunk_A44NGSCM.createGenerationStream,
+  emitMessageAsEvents: () => import_chunk_A44NGSCM.emitMessageAsEvents,
+  executeQuery: () => import_chunk_A44NGSCM.executeQuery,
+  executeQueryPlan: () => import_chunk_A44NGSCM.executeQueryPlan,
+  formatInferredRelationshipLabel: () => import_chunk_A44NGSCM.formatInferredRelationshipLabel,
+  formatJsonSchemaForLLM: () => import_chunk_A44NGSCM.formatJsonSchemaForLLM,
+  formatNodeLabel: () => import_chunk_A44NGSCM.formatNodeLabel,
+  isReference: () => import_chunk_A44NGSCM.isReference,
+  isToolUse: () => import_chunk_A44NGSCM.isToolUse,
+  mergeMessageBlock: () => import_chunk_A44NGSCM.mergeMessageBlock,
+  parseCypherQuery: () => import_chunk_A44NGSCM.parseCypherQuery,
+  runLLM: () => import_chunk_A44NGSCM.runLLM,
+  runTools: () => import_chunk_A44NGSCM.runTools
 });
 module.exports = __toCommonJS(node_exports);
-var import_chunk_QPHGQINW = require("./chunk-QPHGQINW.cjs");
-var import_schema = require("@effect/schema");
+var import_chunk_A44NGSCM = require("./chunk-A44NGSCM.cjs");
+var import_effect = require("effect");
 var import_artifact = require("@dxos/artifact");
-var import_invariant = require("@dxos/invariant");
-var import_log = require("@dxos/log");
 var import_async = require("@dxos/async");
-var import_log2 = 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_log3 = 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_log4 = 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 import_invariant = require("@dxos/invariant");
+var import_log = require("@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 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_log2.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_log2.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: 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 import_schema.Schema.encodePromise(import_schema.Schema.Array(import_artifact.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
-    };
-    import_log.log.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)
-    });
-    (0, import_invariant.invariant)(response.body instanceof ReadableStream, void 0, {
-      F: __dxlog_file2,
-      L: 72,
-      S: this,
-      A: [
-        "response.body instanceof ReadableStream",
-        ""
-      ]
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/session/session.ts";
+var AISession = class _AISession {
+  constructor(_options) {
+    this._options = _options;
+    this._parser = new import_chunk_A44NGSCM.MixedStreamParser();
+    this._pending = [];
+    this._history = [];
+    this.message = this._parser.message;
+    this.block = this._parser.block;
+    this.update = this._parser.update;
+    this.streamEvent = this._parser.streamEvent;
+    this.userMessage = new import_async.Event();
+    this._parser.message.on((message) => {
+      this._pending.push(message);
     });
-    return createGenerationStream(response, controller);
-  }
-};
-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"
-];
-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 = [];
-    const messagesCollected = [];
-    for await (const event of stream) {
-      switch (event.type) {
-        //
-        // Messages.
-        //
-        case "message_start": {
-          if (this._message) {
-            import_log3.log.warn("unexpected message_start", void 0, {
-              F: __dxlog_file3,
-              L: 88,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-          this._message = (0, import_echo_schema.createStatic)(import_artifact2.Message, {
-            role: "assistant",
-            content: []
+  async run(options) {
+    const systemTools = [
+      (0, import_artifact.defineTool)("system", {
+        name: "query_artifacts",
+        description: "Query the available artifacts",
+        schema: import_effect.Schema.Struct({}),
+        execute: async () => {
+          return import_artifact.ToolResult.Success({
+            artifacts: options.artifacts.map((artifact) => ({
+              id: artifact.id,
+              name: artifact.name,
+              description: artifact.description
+            }))
           });
-          this.message.emit(this._message);
-          break;
-        }
-        case "message_delta": {
-          if (!this._message) {
-            import_log3.log.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) {
-            import_log3.log.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) {
-            import_log3.log.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) {
-            import_log3.log.warn("unexpected content_block_delta", void 0, {
-              F: __dxlog_file3,
-              L: 130,
-              S: this,
-              C: (f, a) => f(...a)
+      })
+    ];
+    switch (this._options.operationModel) {
+      case "planning":
+        systemTools.push((0, import_artifact.defineTool)("system", {
+          name: "create_plan",
+          description: "Create a plan. Make sure that each step is independent and can be executed solely on the data returned by the previous step. The steps only share the data that is specified in the plan.",
+          schema: import_effect.Schema.Struct({
+            goal: import_effect.Schema.String.annotations({
+              description: "The goal that the plan will achieve."
+            }),
+            steps: import_effect.Schema.Array(import_effect.Schema.Struct({
+              action: import_effect.Schema.String.annotations({
+                description: "Complete, detailed action to perform."
+              }),
+              input: import_effect.Schema.String.annotations({
+                description: "The required input data for this step. First step must not require any data."
+              }),
+              output: import_effect.Schema.String.annotations({
+                description: "The output data from this step. This is passed to the next step as input."
+              }),
+              requiredArtifactIds: import_effect.Schema.Array(import_effect.Schema.String).annotations({
+                description: "The ids of the artifacts required to perform this step.",
+                examples: [
+                  [
+                    "artifact:dxos.org/example/Test"
+                  ]
+                ]
+              })
+            })).annotations({
+              description: "Steps"
+            })
+          }),
+          execute: async ({ goal, steps }) => {
+            const missingArtifactIds = steps.flatMap((step) => step.requiredArtifactIds).filter((artifactId) => !options.artifacts.some((artifact) => artifact.id === artifactId));
+            if (missingArtifactIds.length > 0) {
+              return import_artifact.ToolResult.Error(`One or more artifact ids are invalid: ${missingArtifactIds.join(", ")}`);
+            }
+            const stepResults = [];
+            for (const step of steps) {
+              import_log.log.info("executing step", {
+                action: step.action
+              }, {
+                F: __dxlog_file,
+                L: 158,
+                S: this,
+                C: (f, a) => f(...a)
+              });
+              const session = new _AISession({
+                operationModel: "immediate"
+              });
+              session.message.on((ev) => this.message.emit(ev));
+              session.block.on((ev) => this.block.emit(ev));
+              session.update.on((ev) => this.update.emit(ev));
+              session.streamEvent.on((ev) => this.streamEvent.emit(ev));
+              session.userMessage.on((ev) => this.userMessage.emit(ev));
+              const messages = await session.run({
+                client: options.client,
+                artifacts: options.artifacts,
+                tools: options.tools,
+                history: options.history,
+                extensions: options.extensions,
+                generationOptions: options.generationOptions,
+                requiredArtifactIds: step.requiredArtifactIds.slice(),
+                prompt: `
+                    You are an agent that executes the subtask in a plan.
+                    
+                    While you know the plan's goal only focus on your subtask
+                    Use the data from the previous step to complete your task.
+                    Return all of the data from "output" in your last message.
+                    
+                    Current step (that you need to complete):
+                    ${JSON.stringify({
+                  goal,
+                  input: step.input,
+                  output: step.output,
+                  yourTask: step.action
+                }, null, 2)}
+                    
+                    Previous step results:
+                    ${JSON.stringify(stepResults.at(-1))}.
+                  `
+              });
+              const result = messages.at(-1);
+              stepResults.push(result);
+            }
+            return import_artifact.ToolResult.Success({
+              stepResults
             });
-            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: 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);
-                        (0, import_invariant2.invariant)(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;
+        }));
+        break;
+      case "immediate":
+        systemTools.push((0, import_artifact.defineTool)("system", {
+          name: "require_artifacts",
+          description: "Require the use of specific artifacts. This will allow the model to interact with artifacts and use their tools.",
+          schema: import_effect.Schema.Struct({
+            artifactIds: import_effect.Schema.Array(import_effect.Schema.String).annotations({
+              description: "The ids of the artifacts to require",
+              examples: [
+                [
+                  "artifact:dxos.org/example/Test"
+                ]
+              ]
+            })
+          }),
+          execute: async ({ artifactIds }) => {
+            const missingArtifactIds = artifactIds.filter((artifactId) => !options.artifacts.some((artifact) => artifact.id === artifactId));
+            if (missingArtifactIds.length > 0) {
+              return import_artifact.ToolResult.Error(`One or more artifact ids are invalid: ${missingArtifactIds.join(", ")}`);
             }
-            //
-            // JSON
-            //
-            case "input_json_delta": {
-              if (!contentBlock) {
-                import_log3.log.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;
+            for (const artifactId of artifactIds) {
+              requiredArtifactIds.add(artifactId);
             }
+            return import_artifact.ToolResult.Success({});
           }
-          break;
-        }
-        case "content_block_stop": {
-          if (!contentBlock) {
-            import_log3.log.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);
-      }
+        }));
+        break;
     }
-    return messagesCollected;
-  }
-};
-var mergeMessageBlock = (contentBlock, streamBlock) => {
-  (0, import_log3.log)("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(import_util.isNotFalsy).join("\n");
-          return {
-            ...contentBlock,
+    this._history = [
+      ...options.history
+    ];
+    this._pending = [
+      (0, import_echo_schema.createStatic)(import_artifact.Message, {
+        role: "user",
+        content: [
+          {
             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
-              })
-            };
+            text: options.prompt
           }
-          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: (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(...DEFAULT_LLM_MODELS);
-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),
-  /**
-  * Preferred model or system default.
-  */
-  model: import_schema2.Schema.optional(LLMModel),
-  /**
-  * Tools available for the LLM.
-  */
-  tools: import_schema2.Schema.optional(import_schema2.Schema.Array(import_artifact3.Tool).pipe(import_schema2.Schema.mutable)),
-  /**
-  * System instructions to the LLM.
-  */
-  systemPrompt: import_schema2.Schema.optional(import_schema2.Schema.String),
-  /**
-  * History of messages to include in the context window.
-  */
-  // TODO(burdon): Rename messages.
-  history: import_schema2.Schema.optional(import_schema2.Schema.Array(import_artifact3.Message)),
-  /**
-  * Current request.
-  */
-  prompt: import_schema2.Schema.optional(import_artifact3.Message)
-});
-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_log4.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.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);
-    (0, import_invariant3.invariant)(message, void 0, {
-      F: __dxlog_file4,
-      L: 63,
-      S: void 0,
-      A: [
-        "message",
-        ""
-      ]
-    });
-    (0, import_log4.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_log4.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_log4.log)("tool success", {
-            result: toolResult.result
-          }, {
-            F: __dxlog_file4,
-            L: 110,
-            S: void 0,
+      })
+    ];
+    this.userMessage.emit(this._pending.at(-1));
+    this._stream = void 0;
+    let error;
+    const requiredArtifactIds = new Set(options.requiredArtifactIds ?? []);
+    try {
+      let more = false;
+      do {
+        const tools = [
+          ...systemTools,
+          ...options.tools,
+          ...options.artifacts.filter((artifact) => requiredArtifactIds.has(artifact.id)).flatMap((artifact) => artifact.tools)
+        ];
+        (0, import_log.log)("request", {
+          pending: this._pending.length,
+          history: this._history.length,
+          tools: tools.map((tool) => tool.name)
+        }, {
+          F: __dxlog_file,
+          L: 260,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._stream = await options.client.exec({
+          ...options.generationOptions ?? {},
+          // TODO(burdon): Rename messages or separate history/message.
+          history: [
+            ...this._history,
+            ...this._pending
+          ],
+          tools,
+          systemPrompt: createBaseInstructions({
+            availableArtifacts: Array.from(requiredArtifactIds),
+            operationModel: this._options.operationModel
+          })
+        });
+        await this._parser.parse(this._stream);
+        await this._stream.complete();
+        (0, import_log.log)("response", {
+          pending: this._pending
+        }, {
+          F: __dxlog_file,
+          L: 283,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        more = false;
+        const message = this._pending.at(-1);
+        (0, import_invariant.invariant)(message, void 0, {
+          F: __dxlog_file,
+          L: 288,
+          S: this,
+          A: [
+            "message",
+            ""
+          ]
+        });
+        if ((0, import_chunk_A44NGSCM.isToolUse)(message)) {
+          (0, import_log.log)("tool request...", void 0, {
+            F: __dxlog_file,
+            L: 290,
+            S: this,
             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
+          const response = await (0, import_chunk_A44NGSCM.runTools)({
+            message: this._pending.at(-1),
+            tools,
+            extensions: options.extensions ?? {}
           });
-          history.push(resultMessage);
-          return true;
-        }
-        case "break": {
-          (0, import_log4.log)("tool break", {
-            result: toolResult.result
+          (0, import_log.log)("tool response", {
+            response
           }, {
-            F: __dxlog_file4,
-            L: 131,
-            S: void 0,
+            F: __dxlog_file,
+            L: 297,
+            S: this,
             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_log4.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_log4.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
+          switch (response.type) {
+            case "continue": {
+              this._pending = [
+                ...this._pending,
+                response.message
+              ];
+              this.userMessage.emit(response.message);
+              more = true;
+              break;
+            }
           }
-        ]
-      });
-      return {
-        type: "continue",
-        message: resultMessage
-      };
-    }
-    case "success": {
-      (0, import_log4.log)("tool success", {
-        result: toolResult.result
-      }, {
-        F: __dxlog_file4,
-        L: 213,
-        S: void 0,
+        }
+      } while (more);
+    } catch (err) {
+      import_log.log.catch(err, void 0, {
+        F: __dxlog_file,
+        L: 309,
+        S: this,
         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
-      };
+      if (err instanceof Error && err.message.includes("Overloaded")) {
+        error = new AIServiecOverloadedError("AI service overloaded", {
+          cause: err
+        });
+      } else {
+        error = new Error("AI service error", {
+          cause: err
+        });
+      }
+    } finally {
+      this._stream = void 0;
     }
-    case "break": {
-      (0, import_log4.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
-      };
+    if (error) {
+      throw error;
     }
+    return this._pending;
   }
+  abort() {
+    this._stream?.abort();
+  }
+};
+_ts_decorate([
+  import_async.synchronized
+], AISession.prototype, "run", null);
+var createBaseInstructions = ({ availableArtifacts, operationModel }) => `
+  You are a friendly, advanced AI assistant capable of creating and managing artifacts from available data and tools. 
+  Your task is to process user commands and questions and decide how best to respond.
+  In some cases, you will need to create or reference data objects called artifacts.
+
+  Follow these guidelines carefully:
+
+  Decision-making:
+
+  - Analyze the structure and type of the content in the user's message.
+  - Can you complete the task using the available artifacts?
+  - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
+  - Identify which artifacts are relevant to the user's request.
+  ${operationModel === "planning" ? `
+        - Break down the user's request into a step-by-step plan that you will use to execute the user's request, the plan items should include artifacts which will be used to perform the actions.
+      ` : `
+      - Are the required artifacts already available?
+      - If not, select which artifact(s) will be the most relevant and require them using the require_artifacts tool.
+      - The require'd artifact tools will be available for use after require.
+    `}
+
+  Artifacts already required: ${availableArtifacts.join("\n")}
+`;
+var AIServiecOverloadedError = class extends import_effect.Schema.TaggedError()("AIServiecOverloadedError", {}) {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AIServiceClientImpl,
-  DEFAULT_LLM_MODEL,
-  DEFAULT_LLM_MODELS,
+  AIServiceEdgeClient,
+  AIServiecOverloadedError,
+  AISession,
+  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,