@athenaintel/react 0.28.1 → 0.30.0

package/dist/chat-ui/composer/composer-message.js

@@ -0,0 +1,284 @@
+import { Extension } from "@tiptap/core";
+import { Fragment } from "@tiptap/pm/model";
+import { getMarkdownStorage } from "../markdown-storage.js";
+import { stageComposerMarkdown, trimComposerDraft } from "../../agent-runtime/src/composer-markdown.js";
+function serializeComposerMessage(editor) {
+  const storage = getMarkdownStorage(editor);
+  const serializer = storage.serializer;
+  if (!isTiptapMarkdownSerializer(serializer)) {
+    return storage.getMarkdown();
+  }
+  return verbatimTextSerializer(serializer).serialize(editor.state.doc);
+}
+const isRecord = (value) => typeof value === "object" && value !== null;
+function isTiptapMarkdownSerializer(value) {
+  if (!isRecord(value) || typeof Reflect.get(value, "serialize") !== "function") return false;
+  const nodes = Reflect.get(value, "nodes");
+  return isRecord(nodes) && typeof nodes.text === "function";
+}
+const writeTextVerbatim = (state, node) => {
+  state.text(node.text ?? "", false);
+};
+function writeLineBreak(draftLineBreak) {
+  return (state, node, parent, index) => {
+    if (state.inTable) {
+      draftLineBreak(state, node, parent, index);
+      return;
+    }
+    for (let next = index + 1; next < parent.childCount; next++) {
+      if (parent.child(next).type !== node.type) {
+        state.write("\n");
+        return;
+      }
+    }
+  };
+}
+function verbatimTextSerializer(serializer) {
+  const nodes = serializer.nodes;
+  const draftLineBreak = nodes.hardBreak;
+  return Object.create(serializer, {
+    nodes: {
+      value: {
+        ...nodes,
+        text: writeTextVerbatim,
+        ...draftLineBreak && { hardBreak: writeLineBreak(draftLineBreak) }
+      }
+    }
+  });
+}
+function escapeBareUnderscores(text) {
+  let escaped = "";
+  let backslashes = 0;
+  for (const character of text) {
+    if (character === "_" && backslashes % 2 === 0) escaped += "\\";
+    escaped += character;
+    backslashes = character === "\\" ? backslashes + 1 : 0;
+  }
+  return escaped;
+}
+const CHARACTER_REFERENCE_AMPERSAND = /&(?=(?:[A-Za-z][A-Za-z0-9]*|#[0-9]+|#[xX][0-9A-Fa-f]+);)/g;
+function escapeCharacterReferences(text) {
+  return text.replace(CHARACTER_REFERENCE_AMPERSAND, "&amp;");
+}
+function writeTextForDraft(draftText) {
+  return (state, node, parent, index) => {
+    if (state.inAutolink) {
+      state.text(node.text ?? "", false);
+      return;
+    }
+    const typed = node.text ?? "";
+    const referencesKept = escapeCharacterReferences(typed);
+    const textNode = referencesKept === typed ? node : node.type.schema.text(referencesKept, node.marks);
+    const escapeText = state.esc;
+    state.esc = (text, startOfLine) => escapeBareUnderscores(escapeText.call(state, text, startOfLine));
+    try {
+      draftText(state, textNode, parent, index);
+    } finally {
+      state.esc = escapeText;
+    }
+  };
+}
+function draftTextSerializer(serializer) {
+  const nodes = serializer.nodes;
+  const draftText = nodes.text;
+  if (!draftText) return serializer;
+  return Object.create(serializer, {
+    nodes: { value: { ...nodes, text: writeTextForDraft(draftText) } }
+  });
+}
+const LINE_START_REFERENCES = { " ": "&#32;", "	": "&#9;" };
+const STAND_IN_CANDIDATES = [
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  "　"
+];
+function standInsFor(doc) {
+  const held = JSON.stringify(doc.toJSON());
+  const [space, tab] = STAND_IN_CANDIDATES.filter((candidate) => !held.includes(candidate));
+  return space !== void 0 && tab !== void 0 ? { " ": space, "	": tab } : null;
+}
+const isLineStartWhitespace = (character) => character === " " || character === "	";
+function withLineStandIns({
+  textblock,
+  standIns
+}) {
+  const { schema } = textblock.type;
+  const lineBreak = schema.linebreakReplacement;
+  const isBlank = (child) => child.isText ? !/\S/.test(child.text ?? "") : child.type === lineBreak;
+  let blank = true;
+  textblock.forEach((child) => {
+    blank && (blank = isBlank(child));
+  });
+  if (blank) return { node: textblock, replaced: 0 };
+  const children = [];
+  let replaced = 0;
+  let atLineStart = true;
+  textblock.forEach((child) => {
+    const lineStart = atLineStart;
+    atLineStart = child.type === lineBreak;
+    const text = child.isText ? child.text ?? "" : "";
+    const first = text.charAt(0);
+    if (lineStart && isLineStartWhitespace(first) && !child.marks.some((mark) => mark.type.spec.code)) {
+      replaced += 1;
+      children.push(schema.text(standIns[first] + text.slice(1), child.marks));
+    } else {
+      children.push(child);
+    }
+  });
+  return replaced > 0 ? { node: textblock.copy(Fragment.from(children)), replaced } : { node: textblock, replaced: 0 };
+}
+function withLeadingWhitespaceStandIns({
+  doc,
+  standIns
+}) {
+  let replaced = 0;
+  const map = (node) => {
+    if (node.isTextblock) {
+      if (node.type.spec.code) return node;
+      const lines = withLineStandIns({ textblock: node, standIns });
+      replaced += lines.replaced;
+      return lines.node;
+    }
+    if (node.isLeaf) return node;
+    const children = [];
+    let changed = false;
+    node.forEach((child) => {
+      const mapped2 = map(child);
+      changed || (changed = mapped2 !== child);
+      children.push(mapped2);
+    });
+    return changed ? node.copy(Fragment.from(children)) : node;
+  };
+  const mapped = map(doc);
+  return { doc: mapped, replaced };
+}
+function serializeComposerDraft(editor) {
+  const storage = getMarkdownStorage(editor);
+  const serializer = storage.serializer;
+  if (!isTiptapMarkdownSerializer(serializer)) return storage.getMarkdown();
+  const draft = draftTextSerializer(serializer);
+  const source = editor.state.doc;
+  const standIns = standInsFor(source);
+  if (standIns === null) return draft.serialize(source);
+  const lines = withLeadingWhitespaceStandIns({ doc: source, standIns });
+  if (lines.replaced === 0) return draft.serialize(source);
+  const written = draft.serialize(lines.doc);
+  const references = /* @__PURE__ */ new Map([
+    [standIns[" "], LINE_START_REFERENCES[" "]],
+    [standIns["	"], LINE_START_REFERENCES["	"]]
+  ]);
+  const characters = Array.from(written);
+  const standInCount = characters.filter((character) => references.has(character)).length;
+  if (standInCount !== lines.replaced) return draft.serialize(source);
+  return characters.map((character) => references.get(character) ?? character).join("");
+}
+const LINE_START_WHITESPACE_REFERENCES = new Set(
+  Object.values(LINE_START_REFERENCES)
+);
+const KEPT_WHITESPACE_TOKEN = "athena_kept_whitespace";
+const COLLAPSIBLE_WHITESPACE = /[ \t]{2,}|\t/g;
+const keptWhitespace = (whitespace) => `<athena-whitespace style="white-space: pre-wrap">${whitespace}</athena-whitespace>`;
+const draftWhitespaceParsers = /* @__PURE__ */ new WeakSet();
+function keepDraftWhitespace(markdownit) {
+  if (draftWhitespaceParsers.has(markdownit)) return;
+  draftWhitespaceParsers.add(markdownit);
+  markdownit.core.ruler.before("text_join", "athena_kept_whitespace", (state) => {
+    for (const block of state.tokens) {
+      const inline = block.children ?? [];
+      inline.forEach((token, index) => {
+        var _a;
+        if (token.type !== "text_special" || token.info !== "entity") return;
+        if (!LINE_START_WHITESPACE_REFERENCES.has(token.markup)) return;
+        token.type = KEPT_WHITESPACE_TOKEN;
+        const next = inline[index + 1];
+        if ((next == null ? void 0 : next.type) !== "text") return;
+        const run = ((_a = /^[ \t]*/.exec(next.content)) == null ? void 0 : _a[0]) ?? "";
+        token.content += run;
+        next.content = next.content.slice(run.length);
+      });
+    }
+  });
+  const { rules } = markdownit.renderer;
+  rules[KEPT_WHITESPACE_TOKEN] = (tokens, index) => {
+    var _a;
+    return keptWhitespace(((_a = tokens[index]) == null ? void 0 : _a.content) ?? "");
+  };
+  for (const name of ["text", "code_inline"]) {
+    const render = rules[name];
+    if (!render) continue;
+    rules[name] = (...args) => render(...args).replace(COLLAPSIBLE_WHITESPACE, keptWhitespace);
+  }
+}
+const ComposerDraftWhitespace = Extension.create({
+  name: "athenaComposerDraftWhitespace",
+  addStorage() {
+    return { markdown: { parse: { setup: keepDraftWhitespace } } };
+  }
+});
+function captureComposerSend(editor) {
+  return {
+    text: serializeComposerMessage(editor).trim(),
+    draftMarkdown: trimComposerDraft(serializeComposerDraft(editor))
+  };
+}
+const REMEMBERED_SENDS = 50;
+const RETURNED_SEND_WINDOW_MS = 6e4;
+const sends = /* @__PURE__ */ new Map();
+const sendKey = ({ threadId, text }) => JSON.stringify([threadId, text]);
+const isFresh = (send, now) => now - send.sentAt <= RETURNED_SEND_WINDOW_MS;
+function rememberComposerSend({
+  threadId,
+  text,
+  draftMarkdown,
+  now = Date.now()
+}) {
+  const key = sendKey({ threadId, text });
+  const remembered = sends.get(key);
+  sends.delete(key);
+  const collides = remembered !== void 0 && isFresh(remembered, now) && remembered.draft !== draftMarkdown;
+  sends.set(key, { draft: collides ? null : draftMarkdown, sentAt: now });
+  while (sends.size > REMEMBERED_SENDS) {
+    const oldest = sends.keys().next();
+    if (oldest.done) break;
+    sends.delete(oldest.value);
+  }
+}
+function draftForReturnedSend({
+  threadId,
+  text,
+  now = Date.now()
+}) {
+  const remembered = sends.get(sendKey({ threadId, text }));
+  return remembered !== void 0 && isFresh(remembered, now) ? remembered.draft : null;
+}
+function prepareComposerSend({
+  threadId,
+  text,
+  draftMarkdown
+}) {
+  rememberComposerSend({ threadId, text, draftMarkdown });
+  stageComposerMarkdown({ threadId, text, markdown: draftMarkdown });
+}
+export {
+  ComposerDraftWhitespace,
+  RETURNED_SEND_WINDOW_MS,
+  captureComposerSend,
+  draftForReturnedSend,
+  escapeCharacterReferences,
+  prepareComposerSend,
+  rememberComposerSend,
+  serializeComposerDraft,
+  serializeComposerMessage
+};
+//# sourceMappingURL=composer-message.js.map

package/dist/chat-ui/composer/composer-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composer-message.js","sources":["../../../src/chat-ui/composer/composer-message.ts"],"sourcesContent":["import { stageComposerMarkdown, trimComposerDraft } from \"@athenaintel/agent-runtime\";\nimport { type Editor, Extension } from \"@tiptap/core\";\nimport { Fragment, type Node as ProseMirrorNode } from \"@tiptap/pm/model\";\nimport { getMarkdownStorage } from \"../markdown-storage\";\n\n/**\n * The composer's draft as it is sent: its Markdown with every plain-text run\n * written exactly as it was typed. The Olympus chat composer sends the same\n * way (`olympus/src/components/textbox/composer-message-markdown.ts`).\n *\n * `getMarkdown()` escapes plain text for Markdown: prosemirror-markdown's\n * `esc()` puts a backslash before `` ` * \\ ~ [ ] _ `` (and before `#`, `-`,\n * `+`, `>` and `1.` at the start of a line), and tiptap-markdown's text\n * serializer turns `<` and `>` into `&lt;` and `&gt;`. That is right for a\n * draft, which is parsed back, but the sent text is what the model reads, and\n * it reads it literally: `C:\\Users` arrived as `C:\\\\Users`, `arr[0]` as\n * `arr\\[0\\]` and `List<T>` as `List&lt;T&gt;`. A line break typed with\n * Shift+Enter is Markdown's hard break, `\\` before the newline, in the draft;\n * it goes out as the newline alone.\n *\n * Only the plain-text runs and line breaks change. Formatting still\n * serializes as Markdown (bold, italic, strike, inline code, code blocks,\n * lists, headings, links, tables), mention chips still write their `[@Name](url)`\n * links, and code spans and blocks were never escaped.\n */\nexport function serializeComposerMessage(editor: Editor): string {\n  const storage = getMarkdownStorage(editor);\n  const serializer: unknown = storage.serializer;\n  if (!isTiptapMarkdownSerializer(serializer)) {\n    // A tiptap-markdown upgrade that reshaped its serializer: keep sending (the\n    // escaped draft) rather than fail the send. The tests pin the verbatim\n    // output, so such an upgrade fails CI before it ships.\n    return storage.getMarkdown();\n  }\n  return verbatimTextSerializer(serializer).serialize(editor.state.doc);\n}\n\n/** What prosemirror-markdown's serializer state offers a node serializer, as far as text goes. */\ninterface MarkdownSerializerState {\n  /** Writes `text`, escaping it for Markdown unless `escapeMarkdown` is `false`. */\n  text(text: string, escapeMarkdown?: boolean): void;\n  /** The escape `text()` applies to each line (prosemirror-markdown 1.13's `esc()`). */\n  esc(text: string, startOfLine?: boolean): string;\n  /** Writes `content` as is, after the enclosing blocks' line prefix when a line starts. */\n  write(content?: string): void;\n  /** True while a table serializer writes a table. */\n  readonly inTable?: boolean;\n  /**\n   * True while prosemirror-markdown writes a link whose text is its URL as an\n   * autolink (`<https://…>`), where Markdown reads no backslash escapes.\n   */\n  readonly inAutolink?: boolean;\n}\n\ntype MarkdownNodeSerializer = (\n  state: MarkdownSerializerState,\n  node: ProseMirrorNode,\n  parent: ProseMirrorNode,\n  index: number,\n) => void;\n\n/**\n * The slice of tiptap-markdown 0.9.0's `MarkdownSerializer` this module uses.\n * `nodes` is a getter mapping every schema node type to its Markdown spec's\n * `serialize`, and `serialize(doc)` builds the serializer state from\n * `this.nodes` and `this.marks`, so an object whose prototype is the editor's\n * serializer and whose own `nodes` replaces `text` and `hardBreak` serializes\n * everything else exactly as `getMarkdown()` does.\n */\ninterface TiptapMarkdownSerializer {\n  readonly nodes: Readonly<Record<string, MarkdownNodeSerializer | undefined>>;\n  serialize(content: ProseMirrorNode): string;\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null;\n\nfunction isTiptapMarkdownSerializer(value: unknown): value is TiptapMarkdownSerializer {\n  if (!isRecord(value) || typeof Reflect.get(value, \"serialize\") !== \"function\") return false;\n  const nodes: unknown = Reflect.get(value, \"nodes\");\n  return isRecord(nodes) && typeof nodes.text === \"function\";\n}\n\nconst writeTextVerbatim: MarkdownNodeSerializer = (state, node) => {\n  state.text(node.text ?? \"\", false);\n};\n\n/**\n * A hard break as a plain newline. The draft's serializer (tiptap-markdown's\n * `hard-break.js`) keeps the rest: it writes nothing for a break with only\n * breaks after it, and inside a table, where a cell holds one line, it writes\n * a `<br>` tag.\n */\nfunction writeLineBreak(draftLineBreak: MarkdownNodeSerializer): MarkdownNodeSerializer {\n  return (state, node, parent, index) => {\n    if (state.inTable) {\n      draftLineBreak(state, node, parent, index);\n      return;\n    }\n    for (let next = index + 1; next < parent.childCount; next++) {\n      if (parent.child(next).type !== node.type) {\n        state.write(\"\\n\");\n        return;\n      }\n    }\n  };\n}\n\nfunction verbatimTextSerializer(serializer: TiptapMarkdownSerializer): TiptapMarkdownSerializer {\n  const nodes = serializer.nodes;\n  const draftLineBreak = nodes.hardBreak;\n  return Object.create(serializer, {\n    nodes: {\n      value: {\n        ...nodes,\n        text: writeTextVerbatim,\n        ...(draftLineBreak && { hardBreak: writeLineBreak(draftLineBreak) }),\n      },\n    },\n  });\n}\n\n/**\n * `text` with every underscore that is not already escaped escaped:\n * prosemirror-markdown's `esc()` leaves an underscore between two word\n * characters bare, and an underscore after an odd run of backslashes is one it\n * escaped itself.\n */\nfunction escapeBareUnderscores(text: string): string {\n  let escaped = \"\";\n  let backslashes = 0;\n  for (const character of text) {\n    if (character === \"_\" && backslashes % 2 === 0) escaped += \"\\\\\";\n    escaped += character;\n    backslashes = character === \"\\\\\" ? backslashes + 1 : 0;\n  }\n  return escaped;\n}\n\n/**\n * An `&` that starts a character reference (`&lt;`, `&copy;`, `&#60;`,\n * `&#x3C;`): Markdown decodes those, so typed `&lt;` read back as `<`.\n */\nconst CHARACTER_REFERENCE_AMPERSAND = /&(?=(?:[A-Za-z][A-Za-z0-9]*|#[0-9]+|#[xX][0-9A-Fa-f]+);)/g;\n\n/** `text` with every `&` that starts a character reference written `&amp;`, which reads back as `&`. */\nexport function escapeCharacterReferences(text: string): string {\n  return text.replace(CHARACTER_REFERENCE_AMPERSAND, \"&amp;\");\n}\n\n/**\n * The draft's text serializer with every underscore escaped. `esc()` leaves an\n * underscore between word characters bare, so `obj.__init__` was written\n * `obj.\\__init_\\_` and read back as `obj._` + italic `init` + `_` (markdown-it\n * opens emphasis on the inner pair). Every underscore in a text node is typed\n * text (emphasis is a mark, written with `*`), so escaping all of them keeps\n * the round trip exact. Code is written raw and never reaches `esc()`. A typed\n * character reference keeps its `&` too (`&amp;lt;`), so `&lt;` reads back as\n * typed instead of as `<`; tiptap-markdown turns `<` and `>` into `&lt;` and\n * `&gt;` only after that.\n *\n * The text of an autolink (`<https://…>`, a link whose text is its URL) is\n * written raw. Markdown reads no escapes there, so `getMarkdown()`'s own\n * escaping (tiptap-markdown escapes it like any text) read a URL with `~`, `*`\n * or `[` back as another address, and an escaped underscore would too.\n */\nfunction writeTextForDraft(draftText: MarkdownNodeSerializer): MarkdownNodeSerializer {\n  return (state, node, parent, index) => {\n    if (state.inAutolink) {\n      state.text(node.text ?? \"\", false);\n      return;\n    }\n    const typed: string = node.text ?? \"\";\n    const referencesKept: string = escapeCharacterReferences(typed);\n    const textNode: ProseMirrorNode =\n      referencesKept === typed ? node : node.type.schema.text(referencesKept, node.marks);\n    const escapeText = state.esc;\n    state.esc = (text, startOfLine) =>\n      escapeBareUnderscores(escapeText.call(state, text, startOfLine));\n    try {\n      draftText(state, textNode, parent, index);\n    } finally {\n      state.esc = escapeText;\n    }\n  };\n}\n\nfunction draftTextSerializer(serializer: TiptapMarkdownSerializer): TiptapMarkdownSerializer {\n  const nodes = serializer.nodes;\n  const draftText = nodes.text;\n  if (!draftText) return serializer;\n  return Object.create(serializer, {\n    nodes: { value: { ...nodes, text: writeTextForDraft(draftText) } },\n  });\n}\n\n/**\n * What a line's first space or tab is written as in the draft. Agent-runtime's\n * `isComposerMarkdownOfText` and agora's `is_composer_markdown_of_text` decode\n * the same two references.\n */\nconst LINE_START_REFERENCES = { \" \": \"&#32;\", \"\\t\": \"&#9;\" } as const;\n\ntype LineStartWhitespace = keyof typeof LINE_START_REFERENCES;\n\n/** The characters standing in for a line's first space and tab while one draft is written. */\ntype LineStartStandIns = Readonly<Record<LineStartWhitespace, string>>;\n\n/**\n * Characters that can stand in for a line's first space or tab while the draft\n * is written: each is whitespace to the serializer (`\\s`), which moves it out\n * of bold and italic like a space, as the sent text does, and none is a space\n * or tab itself. A draft uses two its document does not already hold.\n */\nconst STAND_IN_CANDIDATES: readonly string[] = [\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \"　\",\n];\n\n/** Two stand-ins `doc` holds nowhere (text or attributes); `null` in the unlikely case it holds them all. */\nfunction standInsFor(doc: ProseMirrorNode): LineStartStandIns | null {\n  const held: string = JSON.stringify(doc.toJSON());\n  const [space, tab] = STAND_IN_CANDIDATES.filter((candidate) => !held.includes(candidate));\n  return space !== undefined && tab !== undefined ? { \" \": space, \"\\t\": tab } : null;\n}\n\nconst isLineStartWhitespace = (character: string): character is LineStartWhitespace =>\n  character === \" \" || character === \"\\t\";\n\n/**\n * `textblock` with the first space or tab of each of its lines replaced by its\n * stand-in, and how many it replaced. A line is the textblock's start or what\n * follows a line break; its whitespace is in the text there (not in code,\n * which Markdown keeps as written). A block of nothing but whitespace is left\n * as it is: Markdown reads it as a blank line, as before, and a composer\n * holding only spaces stays empty to every `trim()`.\n */\nfunction withLineStandIns({\n  textblock,\n  standIns,\n}: {\n  textblock: ProseMirrorNode;\n  standIns: LineStartStandIns;\n}): {\n  node: ProseMirrorNode;\n  replaced: number;\n} {\n  const { schema } = textblock.type;\n  const lineBreak = schema.linebreakReplacement;\n  const isBlank = (child: ProseMirrorNode): boolean =>\n    child.isText ? !/\\S/.test(child.text ?? \"\") : child.type === lineBreak;\n  let blank = true;\n  textblock.forEach((child) => {\n    blank &&= isBlank(child);\n  });\n  if (blank) return { node: textblock, replaced: 0 };\n\n  const children: ProseMirrorNode[] = [];\n  let replaced = 0;\n  let atLineStart = true;\n  textblock.forEach((child) => {\n    const lineStart: boolean = atLineStart;\n    atLineStart = child.type === lineBreak;\n    const text: string = child.isText ? (child.text ?? \"\") : \"\";\n    const first: string = text.charAt(0);\n    if (\n      lineStart &&\n      isLineStartWhitespace(first) &&\n      !child.marks.some((mark) => mark.type.spec.code)\n    ) {\n      replaced += 1;\n      children.push(schema.text(standIns[first] + text.slice(1), child.marks));\n    } else {\n      children.push(child);\n    }\n  });\n  return replaced > 0\n    ? { node: textblock.copy(Fragment.from(children)), replaced }\n    : { node: textblock, replaced: 0 };\n}\n\n/**\n * `doc` with the first space or tab of every line in its text replaced by its\n * stand-in, and how many it replaced (see {@link serializeComposerDraft}).\n */\nfunction withLeadingWhitespaceStandIns({\n  doc,\n  standIns,\n}: {\n  doc: ProseMirrorNode;\n  standIns: LineStartStandIns;\n}): {\n  doc: ProseMirrorNode;\n  replaced: number;\n} {\n  let replaced = 0;\n  const map = (node: ProseMirrorNode): ProseMirrorNode => {\n    if (node.isTextblock) {\n      if (node.type.spec.code) return node;\n      const lines = withLineStandIns({ textblock: node, standIns });\n      replaced += lines.replaced;\n      return lines.node;\n    }\n    if (node.isLeaf) return node;\n    const children: ProseMirrorNode[] = [];\n    let changed = false;\n    node.forEach((child) => {\n      const mapped = map(child);\n      changed ||= mapped !== child;\n      children.push(mapped);\n    });\n    return changed ? node.copy(Fragment.from(children)) : node;\n  };\n  const mapped = map(doc);\n  return { doc: mapped, replaced };\n}\n\n/**\n * The composer's draft: Markdown that reads back into the same document, as\n * the Olympus chat composer writes it\n * (`olympus/src/components/textbox/composer-message-markdown.ts`).\n * `getMarkdown()`, except that every underscore in plain text is escaped, a\n * typed character reference keeps its `&`, and an autolink's URL is written\n * raw (see {@link writeTextForDraft}), and the first space or tab of a line is\n * written as a character reference. The composer mirrors its draft into the\n * composer runtime, remembers a send's draft and attaches it to the message\n * (`metadata.composer_markdown`) in this form.\n *\n * Markdown drops the whitespace a line starts with (four spaces or a tab even\n * start a code block), so pasted code came back without its indentation. The\n * first space or tab of each line is written `&#32;` / `&#9;` instead, which\n * Markdown reads back as that character in the line's text; the rest of the\n * run is no longer at the line's start, and the composer's parser keeps it\n * ({@link ComposerDraftWhitespace}). The draft is written with a stand-in for\n * each, a character the document holds nowhere else ({@link standInsFor}),\n * that becomes the reference afterwards; should the serializer ever write a\n * different number of them, the draft is written without them.\n */\nexport function serializeComposerDraft(editor: Editor): string {\n  const storage = getMarkdownStorage(editor);\n  const serializer: unknown = storage.serializer;\n  if (!isTiptapMarkdownSerializer(serializer)) return storage.getMarkdown();\n  const draft = draftTextSerializer(serializer);\n  const source: ProseMirrorNode = editor.state.doc;\n  const standIns = standInsFor(source);\n  if (standIns === null) return draft.serialize(source);\n  const lines = withLeadingWhitespaceStandIns({ doc: source, standIns });\n  if (lines.replaced === 0) return draft.serialize(source);\n  const written: string = draft.serialize(lines.doc);\n  const references = new Map<string, string>([\n    [standIns[\" \"], LINE_START_REFERENCES[\" \"]],\n    [standIns[\"\\t\"], LINE_START_REFERENCES[\"\\t\"]],\n  ]);\n  const characters: string[] = Array.from(written);\n  const standInCount: number = characters.filter((character) => references.has(character)).length;\n  if (standInCount !== lines.replaced) return draft.serialize(source);\n  return characters.map((character) => references.get(character) ?? character).join(\"\");\n}\n\n/** The slice of a markdown-it token {@link keepDraftWhitespace} reads and rewrites. */\ninterface MarkdownItToken {\n  type: string;\n  info: string;\n  markup: string;\n  content: string;\n  children: MarkdownItToken[] | null;\n}\n\ntype MarkdownItRenderRule = (tokens: MarkdownItToken[], index: number, ...rest: unknown[]) => string;\n\n/** The slice of markdown-it (the instance tiptap-markdown parses with) {@link keepDraftWhitespace} configures. */\ninterface MarkdownIt {\n  core: {\n    ruler: {\n      before(\n        beforeName: string,\n        ruleName: string,\n        rule: (state: { tokens: MarkdownItToken[] }) => void,\n      ): void;\n    };\n  };\n  renderer: { rules: Record<string, MarkdownItRenderRule | undefined> };\n}\n\nconst LINE_START_WHITESPACE_REFERENCES: ReadonlySet<string> = new Set(\n  Object.values(LINE_START_REFERENCES),\n);\n\nconst KEPT_WHITESPACE_TOKEN = \"athena_kept_whitespace\";\n\n/** Whitespace ProseMirror's parser would collapse into one space: a run of two or more, or a tab. */\nconst COLLAPSIBLE_WHITESPACE = /[ \\t]{2,}|\\t/g;\n\n/**\n * `whitespace` in an element ProseMirror's parser keeps the whitespace of\n * (`white-space: pre-wrap` is what it reads as \"preserve\"). No node or mark\n * parses the tag, so its text joins the text around it.\n */\nconst keptWhitespace = (whitespace: string): string =>\n  `<athena-whitespace style=\"white-space: pre-wrap\">${whitespace}</athena-whitespace>`;\n\nconst draftWhitespaceParsers = new WeakSet<MarkdownIt>();\n\n/**\n * Markdown read into the composer keeps the spaces and tabs in its text, as\n * the Olympus chat composer's parser does (`ComposerVerbatimTextPaste`).\n * markdown-it keeps a run of spaces inside a line, but ProseMirror's DOM parser\n * collapsed it to one space, and a tab to a space. The draft writes a line's\n * first space or tab as `&#32;` / `&#9;` ({@link serializeComposerDraft});\n * that reference and the whitespace after it, every other run and every tab\n * are rendered in an element that keeps them. Any other single space stays as\n * Markdown reads it, so a task list's space after its checkbox still goes.\n */\nfunction keepDraftWhitespace(markdownit: MarkdownIt): void {\n  if (draftWhitespaceParsers.has(markdownit)) return;\n  draftWhitespaceParsers.add(markdownit);\n  // Before `text_join`, which folds references back into the text around them.\n  markdownit.core.ruler.before(\"text_join\", \"athena_kept_whitespace\", (state) => {\n    for (const block of state.tokens) {\n      const inline: MarkdownItToken[] = block.children ?? [];\n      inline.forEach((token, index) => {\n        if (token.type !== \"text_special\" || token.info !== \"entity\") return;\n        if (!LINE_START_WHITESPACE_REFERENCES.has(token.markup)) return;\n        token.type = KEPT_WHITESPACE_TOKEN;\n        const next: MarkdownItToken | undefined = inline[index + 1];\n        if (next?.type !== \"text\") return;\n        const run: string = /^[ \\t]*/.exec(next.content)?.[0] ?? \"\";\n        token.content += run;\n        next.content = next.content.slice(run.length);\n      });\n    }\n  });\n  const { rules } = markdownit.renderer;\n  rules[KEPT_WHITESPACE_TOKEN] = (tokens, index) => keptWhitespace(tokens[index]?.content ?? \"\");\n  for (const name of [\"text\", \"code_inline\"]) {\n    const render: MarkdownItRenderRule | undefined = rules[name];\n    if (!render) continue;\n    rules[name] = (...args) => render(...args).replace(COLLAPSIBLE_WHITESPACE, keptWhitespace);\n  }\n}\n\n/**\n * The composer's own Markdown reading: a draft restored into it (a returned\n * send, {@link draftForReturnedSend}) keeps its whitespace\n * ({@link keepDraftWhitespace}). The message bubbles read with the chat\n * schema alone.\n */\nexport const ComposerDraftWhitespace = Extension.create({\n  name: \"athenaComposerDraftWhitespace\",\n  addStorage() {\n    return { markdown: { parse: { setup: keepDraftWhitespace } } };\n  },\n});\n\n/** What one send captured: the text it delivers and the draft Markdown that text came from. */\nexport interface ComposerSend {\n  /** Plain text exactly as typed, formatting as Markdown: what the model reads. */\n  readonly text: string;\n  /** The same document as a draft ({@link serializeComposerDraft}). */\n  readonly draftMarkdown: string;\n}\n\n/**\n * The editor's draft as one send would deliver it, both forms trimmed (the\n * draft as agent-runtime's `trimComposerDraft` trims it, so the `&#32;` a\n * first line starts with goes with the space the text loses).\n */\nexport function captureComposerSend(editor: Editor): ComposerSend {\n  return {\n    text: serializeComposerMessage(editor).trim(),\n    draftMarkdown: trimComposerDraft(serializeComposerDraft(editor)),\n  };\n}\n\n/** How many sends {@link rememberComposerSend} keeps the draft of. */\nconst REMEMBERED_SENDS = 50;\n\n/**\n * How long a send's draft stays restorable. Statewire hands a refused send\n * back while it reconnects, soon after the send; past this window a matching\n * text is a host's own write (`useAppendToComposer`), parsed as Markdown.\n */\nexport const RETURNED_SEND_WINDOW_MS = 60_000;\n\ninterface RememberedSend {\n  /** `null` once two different drafts sent the same text in the thread. */\n  readonly draft: string | null;\n  readonly sentAt: number;\n}\n\n/**\n * A sent text in a thread → the draft Markdown it was serialized from, newest\n * last. The draft is withheld once two different drafts sent the same text in\n * that thread within the window: literal `**strong**` and bold `strong` both\n * send `**strong**`, and the text alone cannot say which message is which.\n */\nconst sends = new Map<string, RememberedSend>();\n\nconst sendKey = ({ threadId, text }: { threadId: string; text: string }): string =>\n  JSON.stringify([threadId, text]);\n\nconst isFresh = (send: RememberedSend, now: number): boolean =>\n  now - send.sentAt <= RETURNED_SEND_WINDOW_MS;\n\n/**\n * Remember the draft behind a sent text, so a send that comes back to the\n * composer (statewire puts a send it refuses during a reconnect back into an\n * empty composer) is restored from the draft it was sent from rather than\n * parsed from its verbatim text, where Markdown would read a backslash before\n * punctuation, a tag-like `<x>` or `2*3*4` differently.\n */\nexport function rememberComposerSend({\n  threadId,\n  text,\n  draftMarkdown,\n  now = Date.now(),\n}: {\n  threadId: string;\n  text: string;\n  draftMarkdown: string;\n  /** Test seam: the time of the send. */\n  now?: number;\n}): void {\n  const key = sendKey({ threadId, text });\n  const remembered = sends.get(key);\n  sends.delete(key);\n  const collides =\n    remembered !== undefined && isFresh(remembered, now) && remembered.draft !== draftMarkdown;\n  sends.set(key, { draft: collides ? null : draftMarkdown, sentAt: now });\n  while (sends.size > REMEMBERED_SENDS) {\n    const oldest = sends.keys().next();\n    if (oldest.done) break;\n    sends.delete(oldest.value);\n  }\n}\n\n/**\n * The draft to load for a text that came back to an empty composer: the draft\n * this composer sent it from within {@link RETURNED_SEND_WINDOW_MS}, when that\n * is the only draft that sent this text in the thread; else `null`, and the\n * text is parsed as Markdown (a host's prefill, a send from before a reload).\n */\nexport function draftForReturnedSend({\n  threadId,\n  text,\n  now = Date.now(),\n}: {\n  threadId: string;\n  text: string;\n  /** Test seam: the time the text came back. */\n  now?: number;\n}): string | null {\n  const remembered = sends.get(sendKey({ threadId, text }));\n  return remembered !== undefined && isFresh(remembered, now) ? remembered.draft : null;\n}\n\n/** Test seam: forget every remembered send. */\nexport function resetRememberedComposerSends(): void {\n  sends.clear();\n}\n\n/**\n * Get a send ready right before the composer runtime sends its `text`:\n * remember its draft, so a send statewire hands back is restored from it\n * ({@link rememberComposerSend}), and stage the draft as the message's composer\n * markdown (`metadata.composer_markdown`, only when it differs from the text),\n * which the runtime's `getMessageMetadata` (agent-runtime's\n * `withStagedComposerMarkdown`) puts on the submission that follows, as the\n * Olympus composer does.\n */\nexport function prepareComposerSend({\n  threadId,\n  text,\n  draftMarkdown,\n}: {\n  threadId: string;\n} & ComposerSend): void {\n  rememberComposerSend({ threadId, text, draftMarkdown });\n  stageComposerMarkdown({ threadId, text, markdown: draftMarkdown });\n}\n"],"names":["mapped"],"mappings":"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"}

package/dist/chat-ui/composer/tiptap-composer.cjs

@@ -11,14 +11,15 @@ const react$1 = require("@assistant-ui/react");
 const composerHandoff = require("../../composer/composer-handoff.cjs");
 const lucideReact = require("lucide-react");
 const chatTextSchema = require("../rich-text/chat-text-schema.cjs");
-const markdownStorage = require("../markdown-storage.cjs");
 const mentionSuggestions_extension = require("../mentions/suggestions/mention-suggestions.extension.cjs");
 const mentionSuggestionPopup = require("../mentions/suggestions/components/mention-suggestion-popup.cjs");
 const mentionSuggestionList = require("../mentions/suggestions/components/mention-suggestion-list.cjs");
 const useMentionSuggestions = require("../mentions/suggestions/data/use-mention-suggestions.cjs");
+const state = require("@tiptap/pm/state");
+const composerMessage = require("./composer-message.cjs");
 const pendingAttachmentUploads = require("./pending-attachment-uploads.cjs");
 const runInputRulesOnEnter = require("./run-input-rules-on-enter.cjs");
-const assetAttachment = require("../../packages/agent-runtime/src/asset-attachment.cjs");
+const assetAttachment = require("../../agent-runtime/src/asset-attachment.cjs");
 const cnfast = require("cnfast");
 const SubmitKeybind = core.Extension.create({
   name: "submitKeybind",
@@ -76,7 +77,16 @@ const MENTION_STYLES = `
   }
 `;
 function serializeDraft(editor) {
-  return markdownStorage.getMarkdownStorage(editor).getMarkdown();
+  return composerMessage.serializeComposerDraft(editor);
+}
+function appendPlainText(editor, text) {
+  const words = text.trim();
+  if (!words || editor.isDestroyed) return false;
+  const end = state.Selection.atEnd(editor.state.doc);
+  const before = end.$from.nodeBefore;
+  const needsSpace = before !== null && before.type.name !== "hardBreak" && !(before.isText && /\s$/.test(before.text ?? ""));
+  editor.chain().setTextSelection(end.from).insertContent({ type: "text", text: needsSpace ? ` ${words}` : words }).run();
+  return true;
 }
 const NO_WEBPAGES = [];
 function revokeImagePreview(src) {
@@ -158,6 +168,7 @@ const TiptapComposer = react.forwardRef(
     const handoff = composerHandoff.useComposerHandoffStore();
     const applyingRuntimeTextRef = react.useRef(false);
     const lastEmittedMarkdownRef = react.useRef(null);
+    const restoredSendRef = react.useRef(null);
     const listRef = react.useRef(null);
     const pendingUploadsRef = react.useRef(new pendingAttachmentUploads.PendingAttachmentUploads());
     const submitInFlightRef = react.useRef(false);
@@ -228,10 +239,10 @@ const TiptapComposer = react.forwardRef(
         await (waitForHostUploads == null ? void 0 : waitForHostUploads());
         const ed = editorRef.current;
         if (!ed) return;
-        const text = serializeDraft(ed).trim();
+        const { text, draftMarkdown } = composerMessage.captureComposerSend(ed);
         if (interceptSubmit) {
           const hasAttachments = (((_a = aui.composer.getState().attachments) == null ? void 0 : _a.length) ?? 0) > 0;
-          if (!hasAttachments && await interceptSubmit(text)) {
+          if (!hasAttachments && await interceptSubmit(text, draftMarkdown)) {
             ed.commands.clearContent(false);
             clearImagePreviews();
             onDraftStateChange == null ? void 0 : onDraftStateChange(false);
@@ -241,6 +252,7 @@ const TiptapComposer = react.forwardRef(
         }
         if (!text) return;
         if (!composerInput.canSend) return;
+        composerMessage.prepareComposerSend({ threadId, text, draftMarkdown });
         composerInput.setText(text);
         composerInput.send({ steer: false });
         ed.commands.clearContent(false);
@@ -257,6 +269,7 @@ const TiptapComposer = react.forwardRef(
       interceptSubmit,
       onDraftStateChange,
       onSubmitted,
+      threadId,
       waitForHostUploads
     ]);
     const handleSubmitRef = react.useRef(handleSubmit);
@@ -362,11 +375,14 @@ const TiptapComposer = react.forwardRef(
       },
       [addDroppedImages]
     );
+    const placeholderRef = react.useRef(placeholder);
+    placeholderRef.current = placeholder;
     const editor = react$2.useEditor({
       editable: !disabled,
       extensions: [
         ...chatTextSchema.createChatTextExtensions(),
-        Placeholder.configure({ placeholder }),
+        composerMessage.ComposerDraftWhitespace,
+        Placeholder.configure({ placeholder: () => placeholderRef.current }),
         mentionSuggestions_extension.MentionSuggestionsExtension.configure({
           store,
           callbacks: callbacksRef.current
@@ -409,20 +425,29 @@ const TiptapComposer = react.forwardRef(
     react.useEffect(() => {
       editor == null ? void 0 : editor.setEditable(!disabled);
     }, [disabled, editor]);
+    react.useEffect(() => {
+      if (!editor || editor.isDestroyed) return;
+      editor.view.dispatch(editor.state.tr.setMeta("addToHistory", false));
+    }, [editor, placeholder]);
     react.useEffect(() => {
       if (!editor) return;
       const value = composerInput.value;
       if (value === lastEmittedMarkdownRef.current) return;
+      if (value === restoredSendRef.current) return;
+      restoredSendRef.current = null;
       const currentMarkdown = serializeDraft(editor);
       lastEmittedMarkdownRef.current = currentMarkdown;
-      if (value === currentMarkdown) return;
+      const returnedDraft = editor.isEmpty ? composerMessage.draftForReturnedSend({ threadId, text: value }) : null;
+      const restored = returnedDraft ?? value;
+      if (restored === currentMarkdown) return;
       let cancelled = false;
       queueMicrotask(() => {
         if (cancelled || editor.isDestroyed) return;
         applyingRuntimeTextRef.current = true;
         try {
-          editor.commands.setContent(value, { emitUpdate: false });
+          editor.commands.setContent(restored, { emitUpdate: false });
           lastEmittedMarkdownRef.current = serializeDraft(editor);
+          if (returnedDraft !== null) restoredSendRef.current = value;
         } finally {
           applyingRuntimeTextRef.current = false;
         }
@@ -435,12 +460,16 @@ const TiptapComposer = react.forwardRef(
       return () => {
         cancelled = true;
       };
-    }, [composerInput.value, editor, handoff, onDraftStateChange]);
+    }, [composerInput.value, editor, handoff, onDraftStateChange, threadId]);
     react.useEffect(() => {
       if (!editor || !handoff) return;
       handoff.focusEnd = () => {
         if (!editor.isDestroyed) editor.commands.focus("end");
       };
+      if (handoff.focusOnMount) {
+        handoff.focusOnMount = false;
+        handoff.focusEnd();
+      }
       return () => {
         handoff.focusEnd = null;
       };
@@ -523,15 +552,32 @@ const TiptapComposer = react.forwardRef(
       const needsSpace = before.length > 0 && !/[\s([{"']/.test(before);
       currentEditor.chain().focus().insertContent({ type: "text", text: needsSpace ? " @" : "@" }).run();
     }, [disabled]);
+    const appendText = react.useCallback((text) => {
+      const currentEditor = editorRef.current;
+      if (currentEditor) appendPlainText(currentEditor, text);
+    }, []);
+    const captureSend = react.useCallback(() => {
+      const currentEditor = editorRef.current;
+      return currentEditor && !currentEditor.isDestroyed ? composerMessage.captureComposerSend(currentEditor) : null;
+    }, []);
     react.useImperativeHandle(
       outerRef,
       () => ({
         submit: handleSubmit,
         addAttachment,
         insertAssetMention,
-        openMentionMenu
+        openMentionMenu,
+        appendText,
+        captureSend
       }),
-      [addAttachment, handleSubmit, insertAssetMention, openMentionMenu]
+      [
+        addAttachment,
+        appendText,
+        captureSend,
+        handleSubmit,
+        insertAssetMention,
+        openMentionMenu
+      ]
     );
     return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
       /* @__PURE__ */ jsxRuntime.jsx("style", { children: MENTION_STYLES }),