@haklex/rich-agent-core 0.0.94

package/dist/index.mjs

@@ -0,0 +1,1143 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _get, _set;
+import { createDefaultRegistry, deserializeNodesFromXml, serializeToXml } from "@haklex/rich-litexml";
+import { nanoid } from "nanoid";
+import { createStore } from "zustand/vanilla";
+function extractText(node) {
+  const n = node;
+  if (n.text) return n.text;
+  if (n.children) return n.children.map(extractText).join("");
+  return "";
+}
+function createDocumentTools(snapshot, operations) {
+  const registry = createDefaultRegistry();
+  const insertNodeTool = {
+    name: "insert_node",
+    description: "Insert one or more block nodes at a position relative to an existing block. The xml parameter should contain XML elements like <p>, <h2>, <ul>, <codeblock>, <img />, etc.",
+    parameters: {
+      type: "object",
+      properties: {
+        position: {
+          type: "object",
+          properties: {
+            type: { type: "string", enum: ["after", "before", "root"] },
+            blockId: { type: "string" },
+            index: { type: "number" }
+          },
+          required: ["type"]
+        },
+        xml: { type: "string", description: "XML string containing block elements to insert" }
+      },
+      required: ["position", "xml"]
+    },
+    describeCall: (params) => {
+      const p = params;
+      const pos = p.position;
+      return pos?.blockId ? `inserting ${pos.type} block "${pos.blockId}"` : "inserting node";
+    },
+    execute: async (params) => {
+      const { position, xml } = params;
+      if (!xml || typeof xml !== "string") {
+        return {
+          ok: false,
+          error: {
+            error: "invalid_xml",
+            message: 'Missing or invalid "xml" parameter. Must be an XML string.'
+          }
+        };
+      }
+      if (position.type !== "root" && !snapshot.getBlock(position.blockId)) {
+        return {
+          ok: false,
+          error: {
+            error: "block_not_found",
+            blockId: position.blockId,
+            message: `Block "${position.blockId}" not found.`
+          }
+        };
+      }
+      let nodes;
+      try {
+        nodes = deserializeNodesFromXml(xml, registry);
+      } catch {
+        return {
+          ok: false,
+          error: { error: "xml_parse_error", message: "Failed to parse XML string." }
+        };
+      }
+      if (nodes.length === 0) {
+        return { ok: false, error: { error: "empty_xml", message: "XML produced no nodes." } };
+      }
+      for (let i = 0; i < nodes.length; i++) {
+        const pos = i === 0 ? position : { ...position, _insertIndex: i };
+        operations.push({ op: "insert", position: pos, node: nodes[i] });
+      }
+      return {
+        ok: true,
+        content: `Inserted ${nodes.length} node(s) ${position.type} block "${position.blockId ?? "root"}"`
+      };
+    }
+  };
+  const replaceNodeTool = {
+    name: "replace_node",
+    description: "Replace an existing block node by its blockId with new XML content. The xml should contain exactly one block element.",
+    parameters: {
+      type: "object",
+      properties: {
+        blockId: { type: "string" },
+        xml: { type: "string", description: "XML string containing one block element" }
+      },
+      required: ["blockId", "xml"]
+    },
+    describeCall: (params) => {
+      const p = params;
+      return p.blockId ? `replacing block "${p.blockId}"` : "replacing node";
+    },
+    execute: async (params) => {
+      const { blockId, xml } = params;
+      if (!xml || typeof xml !== "string") {
+        return {
+          ok: false,
+          error: { error: "invalid_xml", message: 'Missing or invalid "xml" parameter.' }
+        };
+      }
+      const existing = snapshot.getBlock(blockId);
+      if (!existing) {
+        return {
+          ok: false,
+          error: { error: "block_not_found", blockId, message: `Block "${blockId}" not found.` }
+        };
+      }
+      let nodes;
+      try {
+        nodes = deserializeNodesFromXml(xml, registry);
+      } catch {
+        return {
+          ok: false,
+          error: { error: "xml_parse_error", message: "Failed to parse XML string." }
+        };
+      }
+      if (nodes.length === 0) {
+        return { ok: false, error: { error: "empty_xml", message: "XML produced no nodes." } };
+      }
+      const primaryNode = { ...nodes[0], $: { ...nodes[0].$, blockId } };
+      operations.push({ op: "replace", blockId, node: primaryNode });
+      for (let i = 1; i < nodes.length; i++) {
+        operations.push({ op: "insert", position: { type: "after", blockId }, node: nodes[i] });
+      }
+      return { ok: true, content: `Replaced block "${blockId}" (${nodes.length} node(s))` };
+    }
+  };
+  const deleteNodeTool = {
+    name: "delete_node",
+    description: "Delete an existing block node by its blockId",
+    parameters: {
+      type: "object",
+      properties: { blockId: { type: "string" } },
+      required: ["blockId"]
+    },
+    describeCall: (params) => {
+      const p = params;
+      return p.blockId ? `deleting block "${p.blockId}"` : "deleting node";
+    },
+    execute: async (params) => {
+      const { blockId } = params;
+      if (!snapshot.getBlock(blockId)) {
+        return {
+          ok: false,
+          error: { error: "block_not_found", blockId, message: `Block "${blockId}" not found.` }
+        };
+      }
+      operations.push({ op: "delete", blockId });
+      return { ok: true, content: `Deleted block "${blockId}"` };
+    }
+  };
+  const searchDocumentTool = {
+    name: "search_document",
+    description: "Search for blocks in the document by text content or block type",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string" },
+        blockType: { type: "string" }
+      },
+      required: ["query"]
+    },
+    describeCall: (params) => {
+      const p = params;
+      const parts = [];
+      if (p.query) parts.push(`"${p.query}"`);
+      if (p.blockType) parts.push(`type=${p.blockType}`);
+      return `searching ${parts.join(", ") || "document"}`;
+    },
+    execute: async (params) => {
+      const { query, blockType } = params;
+      const matches = [];
+      for (const blockId of snapshot.blockIds) {
+        const block = snapshot.getBlock(blockId);
+        const nodeType = block.type ?? "unknown";
+        if (blockType && nodeType !== blockType) continue;
+        const text = extractText(block);
+        if (query && !text.toLowerCase().includes(query.toLowerCase())) continue;
+        matches.push({ blockId, nodeType, textContent: text });
+      }
+      return { ok: true, content: JSON.stringify(matches) };
+    }
+  };
+  return [insertNodeTool, replaceNodeTool, deleteNodeTool, searchDocumentTool];
+}
+function appendText(base, next) {
+  if (!next) return base;
+  if (!base) return next;
+  return `${base}
+
+${next}`;
+}
+function normalizeMessageList(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function getLastItem(items) {
+  return items.length > 0 ? items[items.length - 1] : void 0;
+}
+function createInitialDraft(context) {
+  return {
+    systemMessages: [],
+    messages: [...context.messages]
+  };
+}
+function draftToPreparedMessages(draft) {
+  return {
+    systemMessages: draft.systemMessages,
+    preambleMessages: draft.messages,
+    turns: []
+  };
+}
+class MessagesEngine {
+  constructor(processors) {
+    this.processors = processors;
+  }
+  process(context) {
+    const draft = this.processors.reduce(
+      (nextDraft, processor) => processor.process(nextDraft, context),
+      createInitialDraft(context)
+    );
+    return draftToPreparedMessages(draft);
+  }
+}
+function buildMessages(preparedMessages) {
+  return [
+    ...preparedMessages.systemMessages,
+    ...preparedMessages.preambleMessages,
+    ...preparedMessages.turns
+  ];
+}
+class BaseMessageEngineProcessor {
+  process(draft, context) {
+    if (!this.shouldProcess(context, draft)) {
+      return draft;
+    }
+    return this.doProcess(this.cloneDraft(draft), context);
+  }
+  shouldProcess(_context, _draft) {
+    return true;
+  }
+  cloneDraft(draft) {
+    return {
+      systemMessages: [...draft.systemMessages],
+      messages: draft.messages.map(
+        (message) => message.role === "user" || message.role === "system" || message.role === "assistant" ? { ...message } : message.role === "assistant_tool_call" ? { ...message, toolCalls: [...message.toolCalls] } : { ...message }
+      )
+    };
+  }
+}
+const SYSTEM_CONTEXT_START = "<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->";
+const SYSTEM_CONTEXT_END = "<!-- END SYSTEM CONTEXT -->";
+const CONTEXT_INSTRUCTION = `<context.instruction>following part contains context information injected by the system. Please follow these instructions:
+
+1. Always prioritize handling user-visible content.
+2. the context is only required when user's queries rely on it.
+</context.instruction>`;
+function getUserMessageLocations(draft) {
+  const locations = [];
+  for (let i = 0; i < draft.messages.length; i++) {
+    if (draft.messages[i].role === "user") {
+      locations.push({ scope: "messages", index: i });
+    }
+  }
+  return locations;
+}
+function getUserMessage(draft, location) {
+  return draft.messages[location.index];
+}
+function setUserMessage(draft, location, message) {
+  draft.messages[location.index] = message;
+}
+function hasSystemContextWrapper(content) {
+  return content.includes(SYSTEM_CONTEXT_START) && content.includes(SYSTEM_CONTEXT_END);
+}
+function createContextBlock(content, contextType) {
+  return `<${contextType}>
+${content}
+</${contextType}>`;
+}
+function wrapWithSystemContext(content, contextType) {
+  return `${SYSTEM_CONTEXT_START}
+${CONTEXT_INSTRUCTION}
+<${contextType}>
+${content}
+</${contextType}>
+${SYSTEM_CONTEXT_END}`;
+}
+function insertIntoExistingWrapper(existingContent, newContextBlock) {
+  const endMarkerIndex = existingContent.lastIndexOf(SYSTEM_CONTEXT_END);
+  if (endMarkerIndex === -1) {
+    return appendText(existingContent, newContextBlock);
+  }
+  const beforeEnd = existingContent.slice(0, endMarkerIndex);
+  const afterEnd = existingContent.slice(endMarkerIndex);
+  return `${beforeEnd}${newContextBlock}
+${afterEnd}`;
+}
+function appendSystemContextToUserMessage(message, content, contextType) {
+  const currentContent = message.content;
+  if (hasSystemContextWrapper(currentContent)) {
+    return {
+      ...message,
+      content: insertIntoExistingWrapper(currentContent, createContextBlock(content, contextType))
+    };
+  }
+  return {
+    ...message,
+    content: appendText(currentContent, wrapWithSystemContext(content, contextType))
+  };
+}
+class BaseEveryUserContentProvider extends BaseMessageEngineProcessor {
+  doProcess(draft, context) {
+    const locations = getUserMessageLocations(draft);
+    const lastIndex = locations.length - 1;
+    for (let i = 0; i < locations.length; i++) {
+      const location = locations[i];
+      const message = getUserMessage(draft, location);
+      const nextContent = this.buildContentForMessage(message, i, i === lastIndex, context);
+      if (!nextContent) continue;
+      setUserMessage(
+        draft,
+        location,
+        appendSystemContextToUserMessage(message, nextContent.content, nextContent.contextType)
+      );
+    }
+    return draft;
+  }
+}
+class BaseFirstUserContentProvider extends BaseMessageEngineProcessor {
+  doProcess(draft, context) {
+    const messages = this.buildMessages(context);
+    if (!messages) return draft;
+    const firstUserIndex = draft.messages.findIndex((message) => message.role === "user");
+    if (firstUserIndex === -1) return draft;
+    draft.messages.splice(firstUserIndex, 0, ...normalizeMessageList(messages));
+    return draft;
+  }
+}
+class BaseLastUserContentProvider extends BaseMessageEngineProcessor {
+  doProcess(draft, context) {
+    const locations = getUserMessageLocations(draft);
+    const lastLocation = getLastItem(locations);
+    if (!lastLocation) return draft;
+    const nextContent = this.buildContent(context);
+    if (!nextContent) return draft;
+    const message = getUserMessage(draft, lastLocation);
+    setUserMessage(
+      draft,
+      lastLocation,
+      appendSystemContextToUserMessage(message, nextContent.content, nextContent.contextType)
+    );
+    return draft;
+  }
+  hasExistingSystemContext(draft) {
+    const locations = getUserMessageLocations(draft);
+    const lastLocation = getLastItem(locations);
+    if (!lastLocation) return false;
+    return hasSystemContextWrapper(getUserMessage(draft, lastLocation).content);
+  }
+  wrapWithSystemContext(content, contextType) {
+    return wrapWithSystemContext(content, contextType);
+  }
+  createContextBlock(content, contextType) {
+    return createContextBlock(content, contextType);
+  }
+}
+class BaseSystemRoleProvider extends BaseMessageEngineProcessor {
+  doProcess(draft, context) {
+    const content = this.buildContent(context)?.trim();
+    if (!content) return draft;
+    const lastSystemMessage = getLastItem(draft.systemMessages);
+    if (!lastSystemMessage) {
+      draft.systemMessages = [{ role: "system", content }];
+      return draft;
+    }
+    draft.systemMessages[draft.systemMessages.length - 1] = {
+      ...lastSystemMessage,
+      content: appendText(lastSystemMessage.content, content)
+    };
+    return draft;
+  }
+}
+class BaseSystemRootProvider extends BaseMessageEngineProcessor {
+  doProcess(draft, context) {
+    const messages = this.buildMessages(context);
+    if (!messages) return draft;
+    draft.systemMessages = normalizeMessageList(messages);
+    return draft;
+  }
+}
+function describeToolCall(tool, params) {
+  if (tool?.describeCall) {
+    try {
+      return tool.describeCall(params);
+    } catch {
+    }
+  }
+  const firstVal = Object.values(params)[0];
+  return firstVal !== void 0 ? String(firstVal).slice(0, 40) : void 0;
+}
+function splitSteps(text) {
+  return text.split(/\n{2,}/).map((s) => s.trim()).filter(Boolean);
+}
+let groupCounter = 0;
+function nextGroupId() {
+  return `tcg-${++groupCounter}-${Date.now()}`;
+}
+let thinkingCounter = 0;
+function nextThinkingId() {
+  return `th-${++thinkingCounter}-${Date.now()}`;
+}
+function toolConfigToSchema(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  };
+}
+function createAgentExecutor(config) {
+  const { provider, snapshot, store, signal, onOperationsChanged } = config;
+  const operations = [];
+  let lastOpsLength = 0;
+  const documentTools = createDocumentTools(snapshot, operations);
+  const allTools = [...documentTools, ...config.tools];
+  const toolMap = new Map(allTools.map((t) => [t.name, t]));
+  const toolSchemas = allTools.map(toolConfigToSchema);
+  async function executeTool(name, args) {
+    const tool = toolMap.get(name);
+    if (!tool) {
+      return { ok: false, error: { error: "unknown_tool", message: `Tool "${name}" not found` } };
+    }
+    const params = JSON.parse(args);
+    return tool.execute(params);
+  }
+  async function run(initialMessages) {
+    const { addBubble, setStatus, updateLastBubble } = store.getState();
+    setStatus("running");
+    const turns = [];
+    const maxTurns = 20;
+    for (let turn = 0; turn < maxTurns; turn++) {
+      signal?.throwIfAborted();
+      const messages = buildMessages({
+        ...initialMessages,
+        turns
+      });
+      let textAccum = "";
+      let thinkingAccum = "";
+      let hasThinking = false;
+      let thinkingId = "";
+      const toolCalls = [];
+      setStatus("thinking");
+      addBubble({ type: "assistant", content: "", streaming: true });
+      for await (const chunk of provider.chat(messages, toolSchemas)) {
+        signal?.throwIfAborted();
+        if (chunk.type === "thinking") {
+          thinkingAccum += chunk.text;
+          if (!hasThinking) {
+            hasThinking = true;
+            thinkingId = nextThinkingId();
+            updateLastBubble({
+              type: "thinking",
+              content: chunk.text,
+              id: thinkingId,
+              rawText: chunk.text,
+              steps: [],
+              isStreaming: true
+            });
+          } else {
+            updateLastBubble({
+              type: "thinking",
+              content: thinkingAccum,
+              id: thinkingId,
+              rawText: thinkingAccum,
+              steps: [],
+              isStreaming: true
+            });
+          }
+          continue;
+        }
+        if (chunk.type === "text") {
+          if (hasThinking && textAccum === "") {
+            addBubble({ type: "assistant", content: chunk.text, streaming: true });
+            setStatus("writing");
+          } else if (textAccum === "") {
+            setStatus("writing");
+            updateLastBubble({ type: "assistant", content: chunk.text, streaming: true });
+          } else {
+            updateLastBubble({
+              type: "assistant",
+              content: textAccum + chunk.text,
+              streaming: true
+            });
+          }
+          textAccum += chunk.text;
+          continue;
+        }
+        if (chunk.type === "tool_call") {
+          toolCalls.push({ id: chunk.id, name: chunk.name, arguments: chunk.arguments });
+        }
+      }
+      if (hasThinking) {
+        const { bubbles } = store.getState();
+        const thinkingIdx = bubbles.findIndex(
+          (b) => b.type === "thinking" && "id" in b && b.id === thinkingId
+        );
+        if (thinkingIdx !== -1) {
+          const nextBubbles = [...bubbles];
+          nextBubbles[thinkingIdx] = {
+            type: "thinking",
+            content: thinkingAccum,
+            id: thinkingId,
+            rawText: thinkingAccum,
+            steps: splitSteps(thinkingAccum),
+            isStreaming: false
+          };
+          store.setState({ bubbles: nextBubbles });
+        }
+      }
+      updateLastBubble({ type: "assistant", content: textAccum, streaming: false });
+      if (toolCalls.length === 0) break;
+      turns.push({ role: "assistant_tool_call", toolCalls });
+      setStatus("calling_tool");
+      const groupId = nextGroupId();
+      const items = [];
+      for (const tc of toolCalls) {
+        let params;
+        try {
+          params = JSON.parse(tc.arguments);
+        } catch {
+          params = {};
+        }
+        items.push({
+          id: tc.id,
+          toolName: tc.name,
+          description: describeToolCall(toolMap.get(tc.name), params),
+          params,
+          status: "pending"
+        });
+      }
+      addBubble({ type: "tool_call_group", id: groupId, items });
+      const { updateToolCallItem } = store.getState();
+      for (let i = 0; i < toolCalls.length; i++) {
+        const tc = toolCalls[i];
+        updateToolCallItem(groupId, tc.id, {
+          status: "running",
+          startedAt: Date.now()
+        });
+        try {
+          JSON.parse(tc.arguments);
+        } catch (e) {
+          updateToolCallItem(groupId, tc.id, {
+            status: "error",
+            error: `JSON parse error: ${e.message}`,
+            finishedAt: Date.now()
+          });
+          turns.push({
+            role: "tool_result",
+            toolCallId: tc.id,
+            content: `JSON parse error: ${e.message}`,
+            isError: true
+          });
+          continue;
+        }
+        const result = await executeTool(tc.name, tc.arguments);
+        const content = result.ok ? result.content : JSON.stringify(result.error);
+        updateToolCallItem(groupId, tc.id, {
+          status: result.ok ? "completed" : "error",
+          result: result.ok ? result.content : void 0,
+          resultPreview: result.ok ? result.content.slice(0, 80) : void 0,
+          error: !result.ok ? content : void 0,
+          finishedAt: Date.now()
+        });
+        turns.push({
+          role: "tool_result",
+          toolCallId: tc.id,
+          content,
+          isError: !result.ok
+        });
+        if (operations.length > lastOpsLength) {
+          lastOpsLength = operations.length;
+          onOperationsChanged?.(operations);
+        }
+      }
+    }
+    setStatus("done");
+    return { operations };
+  }
+  return { run };
+}
+function createSnapshot(editorState) {
+  const root = editorState.root;
+  const children = root.children ?? [];
+  const blockMap = /* @__PURE__ */ new Map();
+  const blockIds = [];
+  for (const child of children) {
+    const blockId = child.$?.blockId;
+    if (blockId) {
+      blockMap.set(blockId, child);
+      blockIds.push(blockId);
+    }
+  }
+  return {
+    raw: editorState,
+    blockIds,
+    getBlock: (blockId) => blockMap.get(blockId)
+  };
+}
+function compareBlockContent(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function makeDiffState(entries) {
+  return {
+    entries,
+    getByBlockId(blockId) {
+      return entries.find((e) => {
+        if (e.op.op === "replace" || e.op.op === "delete") return e.op.blockId === blockId;
+        if (e.op.op === "insert" && e.op.position.type !== "root")
+          return e.op.position.blockId === blockId;
+        return false;
+      });
+    },
+    getPending() {
+      return entries.filter((e) => e.status === "pending");
+    }
+  };
+}
+function createDiffEngine(operations, editorState) {
+  const snap = createSnapshot(editorState);
+  const entries = operations.map((op) => {
+    let originalNode;
+    if (op.op === "replace" || op.op === "delete") {
+      originalNode = snap.getBlock(op.blockId);
+    }
+    return {
+      id: nanoid(8),
+      op,
+      status: "pending",
+      originalNode
+    };
+  });
+  return makeDiffState(entries);
+}
+function updateEntry(state, entryId, status) {
+  const entries = state.entries.map((e) => e.id === entryId ? { ...e, status } : e);
+  return makeDiffState(entries);
+}
+function acceptDiff(state, entryId) {
+  return updateEntry(state, entryId, "accepted");
+}
+function rejectDiff(state, entryId) {
+  return updateEntry(state, entryId, "rejected");
+}
+function acceptAllDiffs(state) {
+  const entries = state.entries.map(
+    (e) => e.status === "pending" ? { ...e, status: "accepted" } : e
+  );
+  return makeDiffState(entries);
+}
+function rejectAllDiffs(state) {
+  const entries = state.entries.map(
+    (e) => e.status === "pending" ? { ...e, status: "rejected" } : e
+  );
+  return makeDiffState(entries);
+}
+function buildDocumentContext(editorState, options) {
+  const registry = createDefaultRegistry();
+  return serializeToXml(editorState, registry, { compact: options.compact ?? true });
+}
+function createInitialAgentStoreState() {
+  return {
+    status: "idle",
+    bubbles: [],
+    diffState: null,
+    reviewState: null
+  };
+}
+function getBlockId(node) {
+  return node.$?.blockId;
+}
+function resolveRootInsertIndex(index, length) {
+  const resolved = index ?? length;
+  return Math.min(Math.max(resolved, 0), length);
+}
+function getChildBlockId(children, index) {
+  const child = children[index];
+  return child ? getBlockId(child) : void 0;
+}
+function getInsertAnchors(children, position) {
+  if (position.type === "root") {
+    const index2 = resolveRootInsertIndex(position.index, children.length);
+    const anchorBeforeId = getChildBlockId(children, index2 - 1);
+    const anchorAfterId = getChildBlockId(children, index2);
+    return {
+      targetBlockId: anchorAfterId ?? anchorBeforeId,
+      anchorBeforeId,
+      anchorAfterId
+    };
+  }
+  const index = children.findIndex((child) => getBlockId(child) === position.blockId);
+  if (index === -1) {
+    return {
+      targetBlockId: position.blockId,
+      anchorBeforeId: position.type === "after" ? position.blockId : void 0,
+      anchorAfterId: position.type === "before" ? position.blockId : void 0
+    };
+  }
+  if (position.type === "after") {
+    return {
+      targetBlockId: position.blockId,
+      anchorBeforeId: getChildBlockId(children, index),
+      anchorAfterId: getChildBlockId(children, index + 1)
+    };
+  }
+  return {
+    targetBlockId: position.blockId,
+    anchorBeforeId: getChildBlockId(children, index - 1),
+    anchorAfterId: getChildBlockId(children, index)
+  };
+}
+function cloneChildren(root) {
+  return [...root.children ?? []].map((c) => ({ ...c }));
+}
+function snapshotChildren(snapshot) {
+  return snapshot.root.children ?? [];
+}
+function snapshotHasBlock(snapshot, blockId) {
+  return snapshotChildren(snapshot).some((child) => getBlockId(child) === blockId);
+}
+function canApplyOpToSnapshot(snapshot, op) {
+  if (op.op === "insert") {
+    return op.position.type === "root" || snapshotHasBlock(snapshot, op.position.blockId);
+  }
+  return snapshotHasBlock(snapshot, op.blockId);
+}
+function applyOpsToSnapshot(base, ops) {
+  let children = cloneChildren(base.root);
+  for (const op of ops) {
+    if (op.op === "insert") {
+      if (!op.node?.type) continue;
+      const pos = op.position;
+      if (pos.type === "root") {
+        const idx = resolveRootInsertIndex(pos.index, children.length);
+        children.splice(idx, 0, op.node);
+      } else {
+        const idx = children.findIndex((c) => getBlockId(c) === pos.blockId);
+        if (idx === -1) continue;
+        const insertIdx = pos.type === "after" ? idx + 1 : idx;
+        children.splice(insertIdx, 0, op.node);
+      }
+    } else if (op.op === "replace") {
+      if (!op.node?.type) continue;
+      const idx = children.findIndex((c) => getBlockId(c) === op.blockId);
+      if (idx === -1) continue;
+      children[idx] = op.node;
+    } else if (op.op === "delete") {
+      children = children.filter((c) => getBlockId(c) !== op.blockId);
+    }
+  }
+  return {
+    root: { ...base.root, children }
+  };
+}
+function fingerprint(node) {
+  return JSON.stringify(node);
+}
+function extractTouchedBlockIds(entries) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.targetBlockId) ids.add(entry.targetBlockId);
+  }
+  return [...ids];
+}
+function updateResolvedBatch(state, batchId, status) {
+  return {
+    ...state,
+    batches: state.batches.map(
+      (batch) => batch.id === batchId ? {
+        ...batch,
+        status,
+        entries: batch.entries.map((entry) => ({ ...entry, status }))
+      } : batch
+    )
+  };
+}
+function batchEntriesMatch(left, right, predicate) {
+  for (const leftEntry of left.entries) {
+    for (const rightEntry of right.entries) {
+      if (predicate(leftEntry, rightEntry)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function createReviewBatch(ops, baseSnapshot, baseRevision) {
+  const previewSnapshot = applyOpsToSnapshot(baseSnapshot, ops);
+  const root = baseSnapshot.root;
+  const baseChildren = root.children ?? [];
+  const blockMap = /* @__PURE__ */ new Map();
+  for (const child of baseChildren) {
+    const id = getBlockId(child);
+    if (id) blockMap.set(id, child);
+  }
+  const entries = ops.filter((op) => {
+    if (op.op === "insert" || op.op === "replace") return !!op.node?.type;
+    return true;
+  }).map((op) => {
+    let targetBlockId;
+    let anchorBeforeId;
+    let anchorAfterId;
+    let fp = "";
+    if (op.op === "replace" || op.op === "delete") {
+      targetBlockId = op.blockId;
+      const orig = blockMap.get(op.blockId);
+      if (orig) fp = fingerprint(orig);
+    } else if (op.op === "insert") {
+      ({ targetBlockId, anchorBeforeId, anchorAfterId } = getInsertAnchors(
+        baseChildren,
+        op.position
+      ));
+    }
+    return {
+      id: nanoid(8),
+      op,
+      targetBlockId,
+      anchorBeforeId,
+      anchorAfterId,
+      originalFingerprint: fp,
+      status: "pending"
+    };
+  });
+  return {
+    id: nanoid(8),
+    baseRevision,
+    baseSnapshot,
+    previewSnapshot,
+    status: "pending",
+    entries,
+    touchedBlockIds: extractTouchedBlockIds(entries)
+  };
+}
+function acceptBatch(state, batchId) {
+  return updateResolvedBatch(state, batchId, "accepted");
+}
+function rejectBatch(state, batchId) {
+  return updateResolvedBatch(state, batchId, "rejected");
+}
+function batchesConflict(left, right) {
+  return batchEntriesMatch(left, right, entriesConflict);
+}
+function batchesAreOrderDependent(left, right) {
+  return batchEntriesMatch(left, right, entriesAreOrderDependent);
+}
+function entriesConflict(left, right) {
+  const leftOp = left.op;
+  const rightOp = right.op;
+  if (leftOp.op === "insert" && rightOp.op === "insert") {
+    return false;
+  }
+  if (leftOp.op === "delete") {
+    return conflictsWithDeletedBlock(leftOp.blockId, right);
+  }
+  if (rightOp.op === "delete") {
+    return conflictsWithDeletedBlock(rightOp.blockId, left);
+  }
+  if (leftOp.op === "replace" && rightOp.op === "replace") {
+    return leftOp.blockId === rightOp.blockId;
+  }
+  return false;
+}
+function entriesAreOrderDependent(left, right) {
+  if (left.op.op !== "insert" || right.op.op !== "insert") {
+    return false;
+  }
+  return left.anchorBeforeId === right.anchorBeforeId && left.anchorAfterId === right.anchorAfterId;
+}
+function conflictsWithDeletedBlock(deletedBlockId, entry) {
+  const op = entry.op;
+  if (op.op === "delete" || op.op === "replace") {
+    return op.blockId === deletedBlockId;
+  }
+  return entry.targetBlockId === deletedBlockId || entry.anchorBeforeId === deletedBlockId || entry.anchorAfterId === deletedBlockId;
+}
+function isFinalBatchStatus(status) {
+  return status === "accepted" || status === "rejected";
+}
+function getInitialBatchStatus(batch, documentRevision) {
+  return batch.baseRevision < documentRevision ? "conflicted" : "pending";
+}
+function updateStatusUnlessConflicted(statuses, batchId, status) {
+  if (statuses.get(batchId) === "conflicted") {
+    return;
+  }
+  statuses.set(batchId, status);
+}
+function rebaseBatch(batch, baseSnapshot, baseRevision) {
+  const ops = batch.entries.map((entry) => entry.op);
+  if (!ops.every((op) => canApplyOpToSnapshot(baseSnapshot, op))) {
+    return batch;
+  }
+  const rebased = createReviewBatch(ops, baseSnapshot, baseRevision);
+  return {
+    ...rebased,
+    id: batch.id
+  };
+}
+function reconcileReviewBatches(state) {
+  const nextStatuses = /* @__PURE__ */ new Map();
+  const activeBatches = state.batches.filter((batch) => !isFinalBatchStatus(batch.status));
+  const currentRevisionBatches = activeBatches.filter(
+    (batch) => batch.baseRevision === state.documentRevision
+  );
+  for (const batch of activeBatches) {
+    nextStatuses.set(batch.id, getInitialBatchStatus(batch, state.documentRevision));
+  }
+  for (let i = 0; i < currentRevisionBatches.length; i++) {
+    for (let j = i + 1; j < currentRevisionBatches.length; j++) {
+      const left = currentRevisionBatches[i];
+      const right = currentRevisionBatches[j];
+      if (batchesConflict(left, right)) {
+        nextStatuses.set(left.id, "conflicted");
+        nextStatuses.set(right.id, "conflicted");
+        continue;
+      }
+      if (batchesAreOrderDependent(left, right)) {
+        updateStatusUnlessConflicted(nextStatuses, left.id, "order_dependent");
+        updateStatusUnlessConflicted(nextStatuses, right.id, "order_dependent");
+      }
+    }
+  }
+  return {
+    ...state,
+    batches: state.batches.map(
+      (batch) => isFinalBatchStatus(batch.status) ? batch : { ...batch, status: nextStatuses.get(batch.id) ?? batch.status }
+    )
+  };
+}
+function acceptAndRebaseBatch(state, batchId) {
+  const acceptedState = acceptBatch(state, batchId);
+  const acceptedBatch = acceptedState.batches.find((batch) => batch.id === batchId);
+  if (!acceptedBatch) {
+    return state;
+  }
+  const nextRevision = state.documentRevision + 1;
+  const nextState = {
+    ...acceptedState,
+    documentRevision: nextRevision,
+    batches: acceptedState.batches.map((batch) => {
+      if (batch.id === batchId || isFinalBatchStatus(batch.status)) {
+        return batch;
+      }
+      return rebaseBatch(batch, acceptedBatch.previewSnapshot, nextRevision);
+    })
+  };
+  return reconcileReviewBatches(nextState);
+}
+function resolveReviewEntry(state, batchId, entryId, resolution) {
+  return {
+    ...state,
+    batches: state.batches.map((batch) => {
+      if (batch.id !== batchId) return batch;
+      const entries = batch.entries.map(
+        (entry) => entry.id === entryId ? { ...entry, status: resolution } : entry
+      );
+      const allResolved = entries.every((e) => e.status === "accepted" || e.status === "rejected");
+      let batchStatus = batch.status;
+      if (allResolved) {
+        const allRejected = entries.every((e) => e.status === "rejected");
+        batchStatus = allRejected ? "rejected" : "accepted";
+      }
+      return { ...batch, entries, status: batchStatus };
+    })
+  };
+}
+function detectConflicts(state) {
+  return reconcileReviewBatches(state);
+}
+const agentStoreSelectors = {
+  bubbles: (state) => state.bubbles,
+  diffState: (state) => state.diffState,
+  reviewState: (state) => state.reviewState,
+  status: (state) => state.status
+};
+function createAgentStoreSlice(set, get, api) {
+  return new AgentStoreActionImpl(set, get, api);
+}
+class AgentStoreActionImpl {
+  constructor(set, get, api) {
+    __privateAdd(this, _get);
+    __privateAdd(this, _set);
+    this.addBubble = (bubble) => {
+      __privateGet(this, _set).call(this, (state) => ({ bubbles: [...state.bubbles, bubble] }));
+    };
+    this.reset = () => {
+      __privateGet(this, _set).call(this, createInitialAgentStoreState());
+    };
+    this.setDiffState = (diffState) => {
+      __privateGet(this, _set).call(this, { diffState });
+    };
+    this.addReviewBatch = (batch) => {
+      __privateGet(this, _set).call(this, (state) => {
+        const current = state.reviewState ?? { documentRevision: 0, batches: [] };
+        const next = {
+          ...current,
+          batches: [...current.batches, batch]
+        };
+        return { reviewState: reconcileReviewBatches(next) };
+      });
+    };
+    this.acceptReviewBatch = (batchId) => {
+      __privateGet(this, _set).call(this, (state) => {
+        if (!state.reviewState) return {};
+        return { reviewState: acceptAndRebaseBatch(state.reviewState, batchId) };
+      });
+    };
+    this.acceptReviewEntry = (batchId, entryId) => {
+      __privateGet(this, _set).call(this, (state) => {
+        if (!state.reviewState) return {};
+        return { reviewState: resolveReviewEntry(state.reviewState, batchId, entryId, "accepted") };
+      });
+    };
+    this.rejectReviewBatch = (batchId) => {
+      __privateGet(this, _set).call(this, (state) => {
+        if (!state.reviewState) return {};
+        return { reviewState: reconcileReviewBatches(rejectBatch(state.reviewState, batchId)) };
+      });
+    };
+    this.rejectReviewEntry = (batchId, entryId) => {
+      __privateGet(this, _set).call(this, (state) => {
+        if (!state.reviewState) return {};
+        return { reviewState: resolveReviewEntry(state.reviewState, batchId, entryId, "rejected") };
+      });
+    };
+    this.setReviewState = (reviewState) => {
+      __privateGet(this, _set).call(this, { reviewState });
+    };
+    this.setStatus = (status) => {
+      __privateGet(this, _set).call(this, { status });
+    };
+    this.updateToolCallItem = (groupId, itemId, patch) => {
+      __privateGet(this, _set).call(this, (state) => {
+        const idx = state.bubbles.findIndex((b) => b.type === "tool_call_group" && b.id === groupId);
+        if (idx === -1) return {};
+        const group = state.bubbles[idx];
+        const itemIdx = group.items.findIndex((item) => item.id === itemId);
+        if (itemIdx === -1) return {};
+        const nextItems = [...group.items];
+        nextItems[itemIdx] = { ...nextItems[itemIdx], ...patch };
+        const nextBubbles = [...state.bubbles];
+        nextBubbles[idx] = { ...group, items: nextItems };
+        return { bubbles: nextBubbles };
+      });
+    };
+    this.updateLastBubble = (bubble) => {
+      const { bubbles } = __privateGet(this, _get).call(this);
+      if (bubbles.length === 0) return;
+      const nextBubbles = [...bubbles];
+      nextBubbles[nextBubbles.length - 1] = bubble;
+      __privateGet(this, _set).call(this, { bubbles: nextBubbles });
+    };
+    __privateSet(this, _set, set);
+    __privateSet(this, _get, get);
+  }
+}
+_get = new WeakMap();
+_set = new WeakMap();
+const flattenActions = (actions) => {
+  const result = {};
+  for (const action of actions) {
+    let current = action;
+    while (current && current !== Object.prototype) {
+      const keys = Object.getOwnPropertyNames(current);
+      for (const key of keys) {
+        if (key === "constructor") continue;
+        if (key in result) continue;
+        const descriptor = Object.getOwnPropertyDescriptor(current, key);
+        if (!descriptor) continue;
+        if (typeof descriptor.value === "function") {
+          result[key] = descriptor.value.bind(action);
+        } else {
+          Object.defineProperty(result, key, {
+            ...descriptor,
+            configurable: true,
+            enumerable: true
+          });
+        }
+      }
+      current = Object.getPrototypeOf(current);
+    }
+  }
+  return result;
+};
+const createAgentStoreState = (...params) => ({
+  ...createInitialAgentStoreState(),
+  ...flattenActions([createAgentStoreSlice(...params)])
+});
+function createAgentStore() {
+  return createStore()(createAgentStoreState);
+}
+export {
+  BaseEveryUserContentProvider,
+  BaseFirstUserContentProvider,
+  BaseFirstUserContentProvider as BaseFirstUserMessageProvider,
+  BaseLastUserContentProvider,
+  BaseMessageEngineProcessor,
+  BaseSystemRoleProvider as BaseSystemMessageProvider,
+  BaseSystemRoleProvider,
+  BaseSystemRootProvider,
+  MessagesEngine,
+  acceptAllDiffs,
+  acceptAndRebaseBatch,
+  acceptBatch,
+  acceptDiff,
+  agentStoreSelectors,
+  applyOpsToSnapshot,
+  buildDocumentContext,
+  compareBlockContent,
+  createAgentExecutor,
+  createAgentStore,
+  createAgentStoreSlice,
+  createDiffEngine,
+  createDocumentTools,
+  createInitialAgentStoreState,
+  createReviewBatch,
+  createSnapshot,
+  detectConflicts,
+  flattenActions,
+  reconcileReviewBatches,
+  rejectAllDiffs,
+  rejectBatch,
+  rejectDiff,
+  resolveReviewEntry
+};