@dxos/assistant 0.7.4 → 0.7.5-labs.5f04cf6

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

@@ -1,1394 +0,0 @@
-// packages/experimental/assistant/src/ai-service/schema.ts
-import { Schema as S } from "@effect/schema";
-import { ulid } from "ulidx";
-import { JsonSchemaType } from "@dxos/echo-schema";
-import { SpaceId } from "@dxos/keys";
-var SpaceIdSchema = S.String.pipe(S.filter(SpaceId.isValid));
-var ObjectIdBrand = Symbol("@dxos/echo/ObjectId");
-var ObjectIdSchema = S.ULID.pipe(S.brand(ObjectIdBrand));
-var ObjectId = class extends ObjectIdSchema {
-  static random() {
-    return ulid();
-  }
-};
-var Space = S.Struct({
-  id: SpaceIdSchema
-});
-var Thread = S.Struct({
-  id: ObjectId,
-  spaceId: SpaceIdSchema
-});
-var MessageRole = S.String.pipe(S.filter((role) => role === "user" || role === "assistant"));
-var MessageTextContentBlock = S.Struct({
-  type: S.Literal("text"),
-  text: S.String
-}).pipe(S.mutable);
-var ImageSource = S.Struct({
-  type: S.Literal("base64"),
-  media_type: S.Literal("image/jpeg", "image/png", "image/gif", "image/webp"),
-  data: S.String
-}).pipe(S.mutable);
-var MessageImageContentBlock = S.Struct({
-  type: S.Literal("image"),
-  id: S.optional(S.String),
-  source: S.optional(ImageSource)
-}).pipe(S.mutable);
-var MessageToolUseContentBlock = S.Struct({
-  type: S.Literal("tool_use"),
-  /**
-  * Opaque service-defined ID of the tool invocation.
-  * Used to match the tool result block.
-  */
-  id: S.String,
-  /**
-  * Tool name.
-  */
-  name: S.String,
-  input: S.Unknown,
-  /**
-  * Used to accumulate the partial tool input JSON in streaming mode.
-  */
-  inputJson: S.optional(S.String)
-}).pipe(S.mutable);
-var MessageToolResultContentBlock = S.Struct({
-  type: S.Literal("tool_result"),
-  toolUseId: S.String,
-  content: S.String,
-  isError: S.optional(S.Boolean)
-});
-var MessageContentBlock = S.Union(MessageTextContentBlock, MessageImageContentBlock, MessageToolUseContentBlock, MessageToolResultContentBlock);
-var Message = S.Struct({
-  id: ObjectId,
-  threadId: S.optional(ObjectId),
-  spaceId: S.optional(SpaceIdSchema),
-  role: MessageRole,
-  content: S.Array(MessageContentBlock).pipe(S.mutable),
-  /**
-  * ID of the message from the foreign provider.
-  */
-  // TODO(dmaretskyi): Should be in meta/keys.
-  foreignId: S.optional(S.String)
-});
-var MessageFromDb = S.Struct({
-  ...Message.fields,
-  content: S.propertySignature(Message.fields.content.pipe((schema) => S.parseJson(schema))).pipe(S.fromKey("contentJson"))
-});
-var LLMModel = S.Literal("@hf/nousresearch/hermes-2-pro-mistral-7b", "@anthropic/claude-3-5-sonnet-20241022", "@anthropic/claude-3-5-haiku-20241022", "@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 LLMTool = S.Struct({
-  name: S.String,
-  /**
-  * If the tool is implemented by the service a type should be provided.
-  * For user-implemented tools, this field should be omitted.
-  * See {@link ToolTypes} for the list of supported types.
-  */
-  type: S.optional(S.String),
-  /**
-  * Required for user-implemented tools.
-  */
-  description: S.optional(S.String),
-  /**
-  * Input schema for the tool in the JSON Schema format.
-  * Required for user-implemented tools.
-  */
-  parameters: S.optional(JsonSchemaType),
-  /**
-  * Tool-specific options.
-  */
-  options: S.optional(S.Any),
-  /**
-  * Javascript function to execute the tool.
-  */
-  execute: S.optional(S.Any)
-});
-var GenerateRequest = S.Struct({
-  model: LLMModel,
-  spaceId: SpaceIdSchema,
-  threadId: ObjectId,
-  /**
-  * System instructions to the LLM.
-  */
-  // TODO(dmaretskyi): Should this be part of the thread?.
-  systemPrompt: S.optional(S.String),
-  /**
-  * Tools available for the LLM.
-  */
-  tools: S.Array(LLMTool).pipe(S.mutable)
-});
-
-// packages/experimental/assistant/src/ai-service/client.ts
-import { Schema as S2 } from "@effect/schema";
-import { Trigger } from "@dxos/async";
-import { invariant } from "@dxos/invariant";
-
-// packages/experimental/assistant/src/ai-service/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/client.ts
-var __dxlog_file = "/Users/yarolegovich/Documents/Workspace/dxos/packages/experimental/assistant/src/ai-service/client.ts";
-var AIServiceClientImpl = class {
-  constructor({ endpoint }) {
-    this._endpoint = endpoint;
-  }
-  async getSpace(spaceId) {
-    throw new Error("Not implemented");
-  }
-  async getThread(spaceId, threadId) {
-    throw new Error("Not implemented");
-  }
-  async getMessagesInThread(spaceId, threadId) {
-    const res = await fetch(`${this._endpoint}/space/${spaceId}/thread/${threadId}/message`);
-    return S2.decodePromise(S2.Array(Message).pipe(S2.mutable))((await res.json()).data.results);
-  }
-  async insertMessages(messages) {
-    const res = await fetch(`${this._endpoint}/message`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        messages: await S2.encodePromise(S2.Array(Message))(messages)
-      })
-    });
-    if (!res.ok) {
-      throw new Error(await res.text());
-    }
-  }
-  // TODO(dmaretskyi): Accept partial message schema.
-  async updateMessage(spaceId, threadId, messageId, message) {
-    throw new Error("Not implemented");
-  }
-  async generate(request) {
-    const response = await fetch(`${this._endpoint}/generate`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request)
-    });
-    invariant(response.body instanceof ReadableStream, void 0, {
-      F: __dxlog_file,
-      L: 81,
-      S: this,
-      A: [
-        "response.body instanceof ReadableStream",
-        ""
-      ]
-    });
-    return GenerationStream.fromSSEResponse({
-      spaceId: request.spaceId,
-      threadId: request.threadId
-    }, response);
-  }
-};
-var GenerationStream = class _GenerationStream {
-  static fromSSEResponse(params, response) {
-    const 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 (e) {
-            console.error("Could not parse message into JSON:", sse.data);
-            console.error("From chunk:", sse.raw);
-            throw e;
-          }
-        }
-        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 (e) {
-            console.error("Could not parse message into JSON:", sse.data);
-            console.error("From chunk:", sse.raw);
-            throw e;
-          }
-        }
-        if (sse.event === "ping") {
-          continue;
-        }
-        if (sse.event === "error") {
-          throw new Error(`Message generation error: ${sse.data}`);
-        }
-      }
-    };
-    return new _GenerationStream(params, iterator);
-  }
-  constructor(_params, _getIterator) {
-    this._params = _params;
-    this._getIterator = _getIterator;
-    this._previousMessages = [];
-    this._accumulatedMessage = void 0;
-    this._done = new Trigger();
-    this._iterator = void 0;
-  }
-  [Symbol.asyncIterator]() {
-    return this._createIterator();
-  }
-  cancel() {
-    throw new Error("Not implemented");
-  }
-  get accumulatedMessages() {
-    return [
-      ...this._previousMessages,
-      ...this._accumulatedMessage == null ? [] : [
-        this._accumulatedMessage
-      ]
-    ];
-  }
-  /**
-  * Returns the complete message list generated by the AI service.
-  */
-  async complete() {
-    await this._done.wait();
-    return this.accumulatedMessages;
-  }
-  _createIterator() {
-    const self = this;
-    return this._iterator ??= async function* () {
-      for await (const event of self._getIterator()) {
-        self._processEvent(event);
-        yield event;
-      }
-    }();
-  }
-  _processEvent(event) {
-    switch (event.type) {
-      case "message_start": {
-        if (this._accumulatedMessage) {
-          this._previousMessages.push(this._accumulatedMessage);
-          this._accumulatedMessage = void 0;
-        }
-        this._accumulatedMessage = {
-          ...event.message,
-          threadId: this._params.threadId,
-          spaceId: this._params.spaceId
-        };
-        break;
-      }
-      case "message_delta": {
-        if (this._accumulatedMessage === void 0) {
-          throw new Error("Received message delta without a message start");
-        }
-        break;
-      }
-      case "message_stop": {
-        if (this._accumulatedMessage === void 0) {
-          throw new Error("Received message stop without a message start");
-        }
-        break;
-      }
-      case "content_block_start": {
-        invariant(this._accumulatedMessage, void 0, {
-          F: __dxlog_file,
-          L: 212,
-          S: this,
-          A: [
-            "this._accumulatedMessage",
-            ""
-          ]
-        });
-        this._accumulatedMessage.content.push(event.content);
-        break;
-      }
-      case "content_block_delta": {
-        invariant(this._accumulatedMessage, void 0, {
-          F: __dxlog_file,
-          L: 217,
-          S: this,
-          A: [
-            "this._accumulatedMessage",
-            ""
-          ]
-        });
-        const snapshotContent = this._accumulatedMessage.content.at(event.index);
-        if (snapshotContent?.type === "text" && event.delta.type === "text_delta") {
-          snapshotContent.text += event.delta.text;
-        } else if (snapshotContent?.type === "tool_use" && event.delta.type === "input_json_delta") {
-          snapshotContent.inputJson ??= "";
-          snapshotContent.inputJson += event.delta.partial_json;
-        }
-        break;
-      }
-      case "content_block_stop": {
-        invariant(this._accumulatedMessage, void 0, {
-          F: __dxlog_file,
-          L: 233,
-          S: this,
-          A: [
-            "this._accumulatedMessage",
-            ""
-          ]
-        });
-        const lastBlock = this._accumulatedMessage.content.at(-1);
-        if (lastBlock?.type === "tool_use") {
-          lastBlock.input = JSON.parse(lastBlock.inputJson ?? "");
-        }
-        break;
-      }
-    }
-    this._done.wake();
-  }
-};
-
-// packages/experimental/assistant/src/cypher/parjs.ts
-import { parjsCombinators, parjs } from "#parjs";
-
-// packages/experimental/assistant/src/cypher/combinators.ts
-var ws = parjs.whitespace();
-var nothing = parjs.string("").pipe(parjsCombinators.map(() => null));
-var optional = (parser) => parser.pipe(parjsCombinators.recover(() => ({
-  kind: "Soft"
-})), parjsCombinators.or(nothing));
-var keyword = (word) => parjs.string(word).pipe(parjsCombinators.map(() => word));
-var identifier = parjs.regexp(/[a-zA-Z_][a-zA-Z0-9_]*/).pipe(parjsCombinators.map((match) => ({
-  astKind: "Identifier",
-  name: match[0]
-})));
-var numberLiteral = parjs.regexp(/-?\d+(\.\d+)?/).pipe(parjsCombinators.map(Number));
-var stringLiteral = parjs.regexp(/"([^"]*)"|'([^']*)'/).pipe(parjsCombinators.map((match) => ({
-  astKind: "StringLiteral",
-  value: match[1] || match[2]
-})));
-var variableTag = identifier.pipe(parjsCombinators.map((variable) => variable)).expects("variable tag");
-var label = identifier.pipe(parjsCombinators.map((name) => name));
-var property = identifier.pipe(parjsCombinators.then(parjs.string(":"), ws, stringLiteral), parjsCombinators.map(([key, , , value]) => ({
-  key,
-  value
-})));
-var properties = property.pipe(parjsCombinators.manySepBy(","), parjsCombinators.between("{", "}"), parjsCombinators.map((properties2) => ({
-  astKind: "Properties",
-  properties: properties2
-})));
-var nodePattern = optional(variableTag).pipe(parjsCombinators.then(":"), parjsCombinators.then(ws, label, ws), parjsCombinators.then(optional(properties)), parjsCombinators.between("(", ")"), parjsCombinators.map(([[[variable], _, label2], properties2]) => ({
-  astKind: "NodePattern",
-  variable,
-  label: label2,
-  properties: properties2
-})));
-var relationshipPattern = optional(variableTag).pipe(parjsCombinators.then(":"), parjsCombinators.then(ws, label, ws), parjsCombinators.then(optional(properties)), parjsCombinators.between("[", "]"), parjsCombinators.map(([[[variable], _, label2], properties2]) => ({
-  astKind: "RelationshipPattern",
-  variable,
-  label: label2,
-  properties: properties2
-})));
-var graphPatternConnector = parjs.string("->").pipe(parjsCombinators.or("<-", "-"), parjsCombinators.map((x) => ({
-  astKind: "GraphPatternConnector",
-  direction: x
-})));
-var graphPattern = nodePattern.pipe(parjsCombinators.or(relationshipPattern), parjsCombinators.manySepBy(graphPatternConnector), parjsCombinators.map((segments) => ({
-  astKind: "GraphPattern",
-  segments
-})));
-var matchClause = keyword("MATCH").pipe(parjsCombinators.then(ws), parjsCombinators.then(graphPattern), parjsCombinators.map(([, pattern]) => ({
-  astKind: "MatchClause",
-  pattern
-})));
-var memberExpression = identifier.pipe(parjsCombinators.manySepBy("."), parjsCombinators.map((path) => ({
-  astKind: "MemberExpression",
-  path
-})));
-var equalsPredicate = memberExpression.pipe(parjsCombinators.then(ws, parjs.string("="), ws, stringLiteral), parjsCombinators.map(([left, , , , right]) => ({
-  astKind: "EqualsPredicate",
-  left,
-  right
-})));
-var whereClause = keyword("WHERE").pipe(parjsCombinators.then(ws, equalsPredicate.pipe(parjsCombinators.between(ws, ws), parjsCombinators.manySepBy(parjs.string("AND"))), ws), parjsCombinators.map(([, , predicates]) => ({
-  astKind: "WhereClause",
-  predicates
-})));
-var returnClause = keyword("RETURN").pipe(parjsCombinators.then(ws, memberExpression.pipe(parjsCombinators.then(optional(parjs.string("AS").pipe(parjsCombinators.between(ws), parjsCombinators.then(identifier))), ws), parjsCombinators.manySepBy(parjs.string(",").pipe(parjsCombinators.then(ws)))), ws), parjsCombinators.map(([, , fields]) => ({
-  astKind: "ReturnClause",
-  fields: fields.map(([f]) => f)
-})));
-var cypherQuery = ws.pipe(parjsCombinators.then(matchClause, ws, optional(whereClause), ws, returnClause, ws), parjsCombinators.map(([, matchClause2, , whereClause2, , returnClause2]) => ({
-  astKind: "CypherQuery",
-  matchClause: matchClause2,
-  whereClause: whereClause2,
-  returnClause: returnClause2
-})));
-
-// packages/experimental/assistant/src/cypher/parser.ts
-var parseCypherQuery = (query) => {
-  const parseResult = cypherQuery.parse(query);
-  if (parseResult.isOk) {
-    return {
-      ast: parseResult.value
-    };
-  } else {
-    throw new Error(`Failed to parse query: ${parseResult}`);
-  }
-};
-
-// packages/experimental/assistant/src/cypher/query-executor.ts
-import { log as log2 } from "@dxos/log";
-import { mapValues } from "@dxos/util";
-
-// packages/experimental/assistant/src/cypher/execution-plan.ts
-import { invariant as invariant2 } from "@dxos/invariant";
-import { log } from "@dxos/log";
-var __dxlog_file2 = "/Users/yarolegovich/Documents/Workspace/dxos/packages/experimental/assistant/src/cypher/execution-plan.ts";
-var createExecutionPlan = (query) => {
-  return new ExecutionPlanBuilder().build(query);
-};
-var ExecutionPlanBuilder = class {
-  constructor() {
-    this.counter = 0;
-  }
-  newVariable() {
-    return `anon_${this.counter++}`;
-  }
-  build(query) {
-    log("Creating execution plan for query", {
-      query
-    }, {
-      F: __dxlog_file2,
-      L: 76,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return {
-      steps: [
-        ...this.createStepsForMatchClause(query.ast.matchClause),
-        ...query.ast.whereClause ? this.createStepsForWhereClause(query.ast.whereClause) : [],
-        ...this.createStepsForReturnClause(query.ast.returnClause)
-      ],
-      output: {
-        fields: this.getOutputFields(query.ast.returnClause)
-      }
-    };
-  }
-  createStepsForMatchClause(match) {
-    invariant2(match.pattern.segments.length > 0, void 0, {
-      F: __dxlog_file2,
-      L: 90,
-      S: this,
-      A: [
-        "match.pattern.segments.length > 0",
-        ""
-      ]
-    });
-    const firstSegment = match.pattern.segments[0];
-    invariant2(firstSegment.astKind === "NodePattern", void 0, {
-      F: __dxlog_file2,
-      L: 92,
-      S: this,
-      A: [
-        "firstSegment.astKind === 'NodePattern'",
-        ""
-      ]
-    });
-    let lastNodeVariable = firstSegment.variable?.name ?? this.newVariable();
-    const steps = [];
-    steps.push({
-      type: "NodeScan",
-      label: firstSegment.label.name,
-      into: lastNodeVariable
-    });
-    if (firstSegment.properties) {
-      for (const property2 of firstSegment.properties.properties) {
-        steps.push({
-          type: "FilterByProperty",
-          variable: lastNodeVariable,
-          property: property2.key.name,
-          value: property2.value.value
-        });
-      }
-    }
-    for (let i = 1; i < match.pattern.segments.length; i++) {
-      const relationshipSegment = match.pattern.segments[i++];
-      invariant2(relationshipSegment.astKind === "RelationshipPattern", void 0, {
-        F: __dxlog_file2,
-        L: 115,
-        S: this,
-        A: [
-          "relationshipSegment.astKind === 'RelationshipPattern'",
-          ""
-        ]
-      });
-      const nodeSegment = match.pattern.segments[i];
-      invariant2(nodeSegment.astKind === "NodePattern", void 0, {
-        F: __dxlog_file2,
-        L: 117,
-        S: this,
-        A: [
-          "nodeSegment.astKind === 'NodePattern'",
-          ""
-        ]
-      });
-      const leftSeparator = match.pattern.segments.separators[i - 2];
-      const rightSeparator = match.pattern.segments.separators[i - 1];
-      const direction = getDirection(leftSeparator.direction, rightSeparator.direction);
-      const relationshipVariable = relationshipSegment.variable?.name ?? this.newVariable();
-      const nodeVariable = nodeSegment.variable?.name ?? this.newVariable();
-      steps.push({
-        type: "RelationshipScan",
-        label: relationshipSegment.label.name,
-        direction,
-        anchor: lastNodeVariable,
-        relationshipInto: relationshipVariable,
-        nodeInto: nodeVariable
-      });
-      if (relationshipSegment.properties) {
-        for (const property2 of relationshipSegment.properties.properties) {
-          steps.push({
-            type: "FilterByProperty",
-            variable: relationshipVariable,
-            property: property2.key.name,
-            value: property2.value.value
-          });
-        }
-      }
-      if (nodeSegment.label) {
-        steps.push({
-          type: "FilterByLabel",
-          variable: nodeVariable,
-          label: nodeSegment.label.name
-        });
-      }
-      if (nodeSegment.properties) {
-        for (const property2 of nodeSegment.properties.properties) {
-          steps.push({
-            type: "FilterByProperty",
-            variable: nodeVariable,
-            property: property2.key.name,
-            value: property2.value.value
-          });
-        }
-      }
-      lastNodeVariable = nodeVariable;
-    }
-    return steps;
-  }
-  createStepsForWhereClause(where) {
-    return [];
-  }
-  createStepsForReturnClause(returnClause2) {
-    return [
-      {
-        type: "ProduceResults",
-        fields: returnClause2.fields.map((field) => ({
-          name: field.path.map((p) => p.name).join("_"),
-          variable: field.path[0].name,
-          path: field.path.length > 1 ? field.path.slice(1).map((p) => p.name).join(".") : "$"
-        }))
-      }
-    ];
-  }
-  getOutputFields(returnClause2) {
-    return returnClause2.fields.map((field) => field.path.map((p) => p.name).join("_"));
-  }
-};
-var getDirection = (left, right) => {
-  if (left === "-" && right === "->") {
-    return "out";
-  } else if (left === "<-" && right === "-") {
-    return "in";
-  } else if (left === "-" && right === "-") {
-    return "both";
-  }
-  throw new Error(`Invalid direction: ()${left}[]${right}()`);
-};
-
-// packages/experimental/assistant/src/cypher/query-executor.ts
-var __dxlog_file3 = "/Users/yarolegovich/Documents/Workspace/dxos/packages/experimental/assistant/src/cypher/query-executor.ts";
-var executeQueryPlan = async (dataSource, plan) => {
-  let buffer = [];
-  const results = [];
-  for (const step of plan.steps) {
-    log2("begin step", {
-      step
-    }, {
-      F: __dxlog_file3,
-      L: 41,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    switch (step.type) {
-      case "NodeScan": {
-        const nodes = await dataSource.getNodes({
-          label: step.label
-        });
-        buffer.push(...nodes.map((node) => ({
-          [step.into]: node
-        })));
-        break;
-      }
-      case "FilterByLabel": {
-        buffer = buffer.filter((item) => {
-          const node = item[step.variable];
-          return node && node.kind === "node" && node.label === step.label;
-        });
-        break;
-      }
-      case "FilterByProperty": {
-        buffer = buffer.filter((item) => {
-          const node = item[step.variable];
-          return node && node.kind === "node" && node.properties[step.property] === step.value;
-        });
-        break;
-      }
-      case "RelationshipScan": {
-        const relationships = await dataSource.getRelationships({
-          label: step.label
-        });
-        for (const tuple of [
-          ...buffer
-        ]) {
-          if (tuple[step.anchor].kind !== "node") {
-            continue;
-          }
-          const filteredRelationships = relationships.filter((relationship) => {
-            switch (step.direction) {
-              case "in":
-                return relationship.target.id === tuple[step.anchor].id;
-              case "out":
-                return relationship.source.id === tuple[step.anchor].id;
-              case "both":
-                return relationship.source.id === tuple[step.anchor].id || relationship.target.id === tuple[step.anchor].id;
-              default:
-                throw new Error(`Unknown direction: ${step.direction}`);
-            }
-          });
-          for (let i = 0; i < filteredRelationships.length; i++) {
-            const relationship = filteredRelationships[i];
-            const newTuple = i === 0 ? tuple : {
-              ...tuple
-            };
-            if (newTuple !== tuple) {
-              buffer.push(newTuple);
-            }
-            newTuple[step.relationshipInto] = relationship;
-            switch (step.direction) {
-              case "in":
-                newTuple[step.nodeInto] = relationship.source;
-                break;
-              case "out":
-                newTuple[step.nodeInto] = relationship.target;
-                break;
-              case "both":
-                newTuple[step.nodeInto] = relationship.source.id === newTuple[step.anchor].id ? relationship.target : relationship.source;
-                break;
-            }
-          }
-        }
-        break;
-      }
-      case "ProduceResults": {
-        for (const tuple of buffer) {
-          const result = {};
-          for (const field of step.fields) {
-            result[field.name] = jsonPathGet(tuple[field.variable].properties, field.path);
-          }
-          results.push(result);
-        }
-        break;
-      }
-    }
-    log2("finish step", {
-      buffer: buffer.map((tuple) => mapValues(tuple, (x) => x.id)),
-      results
-    }, {
-      F: __dxlog_file3,
-      L: 118,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-  }
-  return results;
-};
-var executeQuery = (dataSource, query) => {
-  const plan = createExecutionPlan(parseCypherQuery(query));
-  return executeQueryPlan(dataSource, plan);
-};
-var jsonPathGet = (obj, path) => {
-  if (path === "" || path === "$") {
-    return obj;
-  }
-  const parts = path.split(".");
-  if (parts[0] === "$") {
-    parts.shift();
-  }
-  let result = obj;
-  for (const part of parts) {
-    result = result?.[part];
-  }
-  return result;
-};
-
-// packages/experimental/assistant/src/cypher/schema.ts
-import { raise } from "@dxos/debug";
-import { JSON_SCHEMA_ECHO_REF_ID } from "@dxos/echo-schema";
-
-// packages/experimental/assistant/src/util/trim.ts
-var trim = (strings, ...values) => {
-  const combined = strings.reduce((acc, str, i) => {
-    return acc + str + (values[i] || "");
-  }, "");
-  return combined.replace("/^\n/", "").replace(/\n$/, "");
-};
-
-// packages/experimental/assistant/src/cypher/schema.ts
-var formatJsonSchemaForLLM = (schemaTypes) => {
-  return schemaTypes.flatMap((schema) => [
-    formatNodeSchema(schema),
-    ...formatInferredRelationships(schema, schemaTypes)
-  ]);
-};
-var formatNodeSchema = (schema) => {
-  const label2 = formatNodeLabel(schema.typename ?? raise(new Error("Schema must have $id")));
-  const properties2 = Object.entries(schema.properties).filter(([key, prop]) => key !== "id" && !isReference(prop));
-  return trim`
-    <node>
-      (:${label2})
-
-      <description>${schema.description}</description>
-
-      <properties>
-        ${properties2.map(([key, value]) => {
-    return trim`
-            <${key}>
-              <type>${value.type}</type>
-              <description>${value.description}</description>
-            </${key}>
-          `;
-  })}
-      </properties>
-    </node>
-  `;
-};
-var formatInferredRelationships = (schema, allSchema) => {
-  const nodeLabel = formatNodeLabel(schema.typename ?? raise(new Error("Schema must have $id")));
-  const relationships = Object.entries(schema.properties).filter(([key, prop]) => isReference(prop));
-  return relationships.map(([key, value]) => {
-    const relationshipLabel = formatInferredRelationshipLabel(schema.typename ?? raise(new Error("Schema must have $id")), key);
-    const targetSchema = allSchema.find((schema2) => `dxn:type/${schema2.typename}` === value.reference?.schema.$ref);
-    const targetLabel = targetSchema ? formatNodeLabel(targetSchema?.typename ?? "") : "";
-    return trim`
-      <relationship>
-        (:${nodeLabel})-[:${relationshipLabel}]->(:${targetLabel})
-
-        <description>${value.description}</description>
-      </relationship>
-    `;
-  });
-};
-var formatNodeLabel = (typename) => {
-  return typename.replace(/^example\.com\/type\//g, "");
-};
-var formatInferredRelationshipLabel = (typename, property2) => {
-  const nodeLabel = formatNodeLabel(typename);
-  return `${nodeLabel}_${property2}`.toUpperCase();
-};
-var isReference = (schema) => schema.$id === JSON_SCHEMA_ECHO_REF_ID || schema.type === "array" && schema.items?.$id === JSON_SCHEMA_ECHO_REF_ID;
-
-// packages/experimental/assistant/src/cypher/echo-data-source.ts
-import { raise as raise2 } from "@dxos/debug";
-import { Filter } from "@dxos/echo-db";
-import { getSchemaTypename, StoredSchema, toJsonSchema } from "@dxos/echo-schema";
-import { getSchema } from "@dxos/live-object";
-import { log as log3 } from "@dxos/log";
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file4 = "/Users/yarolegovich/Documents/Workspace/dxos/packages/experimental/assistant/src/cypher/echo-data-source.ts";
-var EchoDataSource = class {
-  constructor(_db) {
-    this._db = _db;
-  }
-  async getNodes({ label: label2 }) {
-    if (!label2) {
-      const { objects: objects2 } = await this._db.query().run();
-      return objects2.map(this._objectToNode);
-    }
-    const schema = (await this._getAllSchema()).find((s) => getSchemaTypename(s)?.endsWith(label2));
-    if (!schema) {
-      return [];
-    }
-    const { objects } = await this._db.query(Filter.schema(schema)).run();
-    return objects.map(this._objectToNode);
-  }
-  async getRelationships({ label: label2 }) {
-    const syntheticRefRelationships = (await this._getAllSchema()).filter((schema) => getSchemaTypename(schema) !== StoredSchema.typename).flatMap((schema) => {
-      const jsonSchema = toJsonSchema(schema);
-      const relationships = Object.entries(jsonSchema.properties).filter(([key, prop]) => isReference(prop));
-      return relationships.map(([key, value]) => {
-        const relationshipLabel = formatInferredRelationshipLabel(jsonSchema.typename ?? raise2(new Error("Schema must have typename")), key);
-        return {
-          label: relationshipLabel,
-          schema,
-          property: key
-        };
-      });
-    });
-    const relationship = syntheticRefRelationships.find((r) => r.label === label2);
-    if (!relationship) {
-      return [];
-    }
-    const { objects } = await this._db.query(Filter.schema(relationship.schema)).run();
-    return (await Promise.all(objects.map((object) => this._projectRefRelationship(object, relationship.property)))).flat();
-  }
-  async _getAllSchema() {
-    return [
-      ...await this._db.schemaRegistry.query().run(),
-      // TODO(dmaretskyi): Remove once we can serialize recursive schema.
-      ...this._db.graph.schemaRegistry.schemas.filter((s) => getSchemaTypename(s)?.startsWith("example.org"))
-    ].filter((schema) => getSchemaTypename(schema) !== StoredSchema.typename);
-  }
-  _objectToNode(object) {
-    const { id, ...properties2 } = object;
-    return {
-      id,
-      kind: "node",
-      label: formatNodeLabel(getSchemaTypename(getSchema(object))),
-      properties: properties2
-    };
-  }
-  async _projectRefRelationship(object, prop) {
-    if (!object[prop]) {
-      return [];
-    }
-    const value = Array.isArray(object[prop]) ? object[prop] : [
-      object[prop]
-    ];
-    return Promise.all(value.map(async (ref) => {
-      const target = await ref.load();
-      return {
-        id: `${object.id}-${prop}-${target.id}`,
-        kind: "relationship",
-        label: formatInferredRelationshipLabel(getSchemaTypename(getSchema(object)), prop),
-        properties: {},
-        source: this._objectToNode(object),
-        target: this._objectToNode(target)
-      };
-    }));
-  }
-};
-_ts_decorate([
-  log3.method(void 0, void 0, {
-    F: __dxlog_file4,
-    L: 17,
-    S: void 0,
-    C: (f, a) => f(...a)
-  })
-], EchoDataSource.prototype, "getNodes", null);
-_ts_decorate([
-  log3.method(void 0, void 0, {
-    F: __dxlog_file4,
-    L: 34,
-    S: void 0,
-    C: (f, a) => f(...a)
-  })
-], EchoDataSource.prototype, "getRelationships", null);
-
-// packages/experimental/assistant/src/conversation/conversation.ts
-import { invariant as invariant3 } from "@dxos/invariant";
-import { log as log4 } from "@dxos/log";
-var __dxlog_file5 = "/Users/yarolegovich/Documents/Workspace/dxos/packages/experimental/assistant/src/conversation/conversation.ts";
-var runLLM = async (params) => {
-  let conversationResult = null;
-  const generate = async () => {
-    log4("llm generate", {
-      tools: params.tools
-    }, {
-      F: __dxlog_file5,
-      L: 42,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    const beginTs = Date.now();
-    const result = await params.client.generate({
-      model: params.model,
-      spaceId: params.spaceId,
-      threadId: params.threadId,
-      systemPrompt: params.system,
-      tools: params.tools
-    });
-    for await (const event of result) {
-      params.logger?.(event);
-    }
-    const messages = await result.complete();
-    const message = messages.at(-1);
-    log4("llm result", {
-      time: Date.now() - beginTs,
-      message
-    }, {
-      F: __dxlog_file5,
-      L: 58,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    invariant3(message, void 0, {
-      F: __dxlog_file5,
-      L: 59,
-      S: void 0,
-      A: [
-        "message",
-        ""
-      ]
-    });
-    params.logger?.({
-      type: "message",
-      message
-    });
-    await params.client.insertMessages(messages.map((msg) => ({
-      ...msg,
-      content: msg.content.filter((c) => c.type !== "image")
-    })));
-    const isToolUse = message.content.at(-1)?.type === "tool_use";
-    if (isToolUse) {
-      const toolCalls = message.content.filter((c) => c.type === "tool_use");
-      invariant3(toolCalls.length === 1, void 0, {
-        F: __dxlog_file5,
-        L: 68,
-        S: void 0,
-        A: [
-          "toolCalls.length === 1",
-          ""
-        ]
-      });
-      const toolCall = toolCalls[0];
-      const tool = params.tools.find((t) => t.name === toolCall.name);
-      if (!tool) {
-        throw new Error(`Tool not found: ${toolCall.name}`);
-      }
-      const toolResult = await tool.execute(toolCall.input, {});
-      switch (toolResult.kind) {
-        case "error": {
-          log4("tool error", {
-            message: toolResult.message
-          }, {
-            F: __dxlog_file5,
-            L: 78,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          const resultMessage = {
-            id: 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
-          });
-          await params.client.insertMessages([
-            resultMessage
-          ]);
-          return true;
-        }
-        case "success": {
-          log4("tool success", {
-            result: toolResult.result
-          }, {
-            F: __dxlog_file5,
-            L: 99,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          const resultMessage = {
-            id: 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
-          });
-          await params.client.insertMessages([
-            resultMessage
-          ]);
-          return true;
-        }
-        case "break": {
-          log4("tool break", {
-            result: toolResult.result
-          }, {
-            F: __dxlog_file5,
-            L: 119,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          conversationResult = toolResult.result;
-          return false;
-        }
-      }
-    }
-    return false;
-  };
-  while (await generate()) {
-  }
-  return {
-    result: conversationResult
-  };
-};
-
-// packages/experimental/assistant/src/conversation/types.ts
-import { Schema as S3 } from "@effect/schema";
-import { toJsonSchema as toJsonSchema2 } from "@dxos/echo-schema";
-import { JsonSchemaType as JsonSchemaType2 } from "@dxos/echo-schema";
-import { log as log5 } from "@dxos/log";
-var __dxlog_file6 = "/Users/yarolegovich/Documents/Workspace/dxos/packages/experimental/assistant/src/conversation/types.ts";
-var createUserMessage = (spaceId, threadId, text) => ({
-  id: ObjectId.random(),
-  spaceId,
-  threadId,
-  role: "user",
-  content: [
-    {
-      type: "text",
-      text
-    }
-  ]
-});
-var LLMToolDefinition = S3.Struct({
-  name: S3.String,
-  description: S3.String,
-  parameters: JsonSchemaType2,
-  execute: S3.Any
-});
-var LLMToolResult = Object.freeze({
-  /**
-  * The tool execution was successful.
-  * Gives the result back to the LLM.
-  */
-  Success: (result) => ({
-    kind: "success",
-    result
-  }),
-  Error: (message) => ({
-    kind: "error",
-    message
-  }),
-  /**
-  * Stop the conversation and return the result.
-  */
-  Break: (result) => ({
-    kind: "break",
-    result
-  })
-});
-var defineTool = ({ name, description, schema, execute }) => {
-  return {
-    name,
-    description,
-    parameters: toFunctionParameterSchema(schema),
-    execute: (params, context) => {
-      const sanitized = S3.decodeSync(schema)(params);
-      return execute(sanitized, context);
-    }
-  };
-};
-var toFunctionParameterSchema = (schema) => {
-  const jsonSchema = toJsonSchema2(schema);
-  log5("tool schema", {
-    jsonSchema
-  }, {
-    F: __dxlog_file6,
-    L: 83,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  for (const key in jsonSchema.properties) {
-    if (typeof jsonSchema.properties[key].description !== "string") {
-      throw new Error(`Property missing description: ${key}`);
-    }
-  }
-  return jsonSchema;
-};
-
-export {
-  SpaceIdSchema,
-  ObjectIdBrand,
-  ObjectId,
-  Space,
-  Thread,
-  MessageRole,
-  MessageTextContentBlock,
-  ImageSource,
-  MessageImageContentBlock,
-  MessageToolUseContentBlock,
-  MessageToolResultContentBlock,
-  MessageContentBlock,
-  Message,
-  MessageFromDb,
-  LLMModel,
-  ToolTypes,
-  LLMTool,
-  GenerateRequest,
-  AIServiceClientImpl,
-  GenerationStream,
-  parseCypherQuery,
-  executeQueryPlan,
-  executeQuery,
-  trim,
-  formatJsonSchemaForLLM,
-  formatNodeLabel,
-  formatInferredRelationshipLabel,
-  isReference,
-  EchoDataSource,
-  runLLM,
-  createUserMessage,
-  LLMToolDefinition,
-  LLMToolResult,
-  defineTool
-};
-//# sourceMappingURL=chunk-AKP45LQH.mjs.map