@athenaintel/react 0.41.3 → 0.42.2

package/dist/composer/build-composed-message.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"build-composed-message.cjs","sources":["../../src/composer/build-composed-message.ts"],"sourcesContent":["import type { UploadedAsset } from './useFileUpload';\nimport type { QuoteData } from './QuoteContext';\nimport { buildAttachmentMarkdownWithAppUrl } from './AttachmentContext';\nimport {\n  type ComposerSend,\n  escapeCharacterReferences,\n} from '../chat-ui/composer/composer-message';\n\n/**\n * Assembles a composed message from attachments, a quote, and user text.\n * Used by both the TipTap Enter-key submit and the send-button click handler\n * to avoid duplicating the message-assembly logic.\n *\n * Returns an empty string if all inputs are empty.\n */\nexport function buildComposedMessage(opts: {\n  attachments?: UploadedAsset[];\n  quote?: QuoteData | null;\n  userText?: string;\n  appUrl?: string;\n}): string {\n  const parts: string[] = [];\n\n  if (opts.attachments && opts.attachments.length > 0) {\n    const attachmentMd = buildAttachmentMarkdownWithAppUrl({\n      attachments: opts.attachments,\n      appUrl: opts.appUrl,\n    });\n    if (attachmentMd) parts.push(attachmentMd);\n  }\n\n  if (opts.quote) {\n    const quotedLines = opts.quote.text.split('\\n').map((l) => `> ${l}`).join('\\n');\n    const sourceLabel = opts.quote.sourceTitle\n      ? `From \"${opts.quote.sourceTitle}\"`\n      : opts.quote.sourceRole === 'assistant'\n        ? 'Quoting assistant'\n        : 'Quoting';\n    parts.push(`${sourceLabel}:\\n${quotedLines}`);\n  }\n\n  const trimmed = opts.userText?.trim();\n  if (trimmed) parts.push(trimmed);\n\n  return parts.join('\\n\\n');\n}\n\n/**\n * The composed message a send delivers and the draft it came from: the same\n * attachments and quote around the editor's text as typed in one, and around\n * the editor's draft in the other (`ComposerSend`). `null` when there is\n * nothing to send.\n *\n * The quote and the attachment titles are text the person did not type in\n * the editor, and the message carries them as they are. The draft writes an\n * `&` in them that starts a character reference as `&amp;`, as the composer's\n * draft does for typed text, so it reads back as the message and stays a draft\n * of the message's own text (`isComposerMarkdownOfText`, which agora applies\n * too): a quoted `&lt;` would otherwise read as `<` in the draft and the\n * message would lose its composer markdown.\n */\nexport function buildComposedSend({\n  attachments,\n  quote,\n  send,\n  appUrl,\n}: {\n  attachments?: UploadedAsset[];\n  quote?: QuoteData | null;\n  send: ComposerSend;\n  appUrl?: string;\n}): ComposerSend | null {\n  const text = buildComposedMessage({ attachments, quote, userText: send.text, appUrl });\n  if (!text) return null;\n  const draftMarkdown = buildComposedMessage({\n    attachments: attachments?.map((attachment) => ({\n      ...attachment,\n      title: escapeCharacterReferences(attachment.title),\n    })),\n    quote: quote && {\n      ...quote,\n      text: escapeCharacterReferences(quote.text),\n      ...(quote.sourceTitle !== undefined && {\n        sourceTitle: escapeCharacterReferences(quote.sourceTitle),\n      }),\n    },\n    userText: send.draftMarkdown,\n    appUrl,\n  });\n  return { text, draftMarkdown };\n}\n"],"names":["buildAttachmentMarkdownWithAppUrl","escapeCharacterReferences"],"mappings":";;;;AAeO,SAAS,qBAAqB,MAK1B;;AACT,QAAM,QAAkB,CAAA;AAExB,MAAI,KAAK,eAAe,KAAK,YAAY,SAAS,GAAG;AACnD,UAAM,eAAeA,kBAAAA,kCAAkC;AAAA,MACrD,aAAa,KAAK;AAAA,MAClB,QAAQ,KAAK;AAAA,IAAA,CACd;AACD,QAAI,aAAc,OAAM,KAAK,YAAY;AAAA,EAC3C;AAEA,MAAI,KAAK,OAAO;AACd,UAAM,cAAc,KAAK,MAAM,KAAK,MAAM,IAAI,EAAE,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,EAAE,KAAK,IAAI;AAC9E,UAAM,cAAc,KAAK,MAAM,cAC3B,SAAS,KAAK,MAAM,WAAW,MAC/B,KAAK,MAAM,eAAe,cACxB,sBACA;AACN,UAAM,KAAK,GAAG,WAAW;AAAA,EAAM,WAAW,EAAE;AAAA,EAC9C;AAEA,QAAM,WAAU,UAAK,aAAL,mBAAe;AAC/B,MAAI,QAAS,OAAM,KAAK,OAAO;AAE/B,SAAO,MAAM,KAAK,MAAM;AAC1B;AAgBO,SAAS,kBAAkB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAKwB;AACtB,QAAM,OAAO,qBAAqB,EAAE,aAAa,OAAO,UAAU,KAAK,MAAM,QAAQ;AACrF,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,gBAAgB,qBAAqB;AAAA,IACzC,aAAa,2CAAa,IAAI,CAAC,gBAAgB;AAAA,MAC7C,GAAG;AAAA,MACH,OAAOC,gBAAAA,0BAA0B,WAAW,KAAK;AAAA,IAAA;AAAA,IAEnD,OAAO,SAAS;AAAA,MACd,GAAG;AAAA,MACH,MAAMA,gBAAAA,0BAA0B,MAAM,IAAI;AAAA,MAC1C,GAAI,MAAM,gBAAgB,UAAa;AAAA,QACrC,aAAaA,gBAAAA,0BAA0B,MAAM,WAAW;AAAA,MAAA;AAAA,IAC1D;AAAA,IAEF,UAAU,KAAK;AAAA,IACf;AAAA,EAAA,CACD;AACD,SAAO,EAAE,MAAM,cAAA;AACjB;;;"}
+{"version":3,"file":"build-composed-message.cjs","sources":["../../src/composer/build-composed-message.ts"],"sourcesContent":["import {\n  type ChatOutbox,\n  type ChatOutboxAttachment,\n  type ChatOutboxEntry,\n  withDeepAgentComposerMarkdown,\n} from '@athenaintel/agent-runtime';\nimport type { UploadedAsset } from './useFileUpload';\nimport type { QuoteData } from './QuoteContext';\nimport { buildAttachmentMarkdownWithAppUrl } from './AttachmentContext';\nimport {\n  type ComposerSend,\n  escapeCharacterReferences,\n} from '../chat-ui/composer/composer-message';\n\n/**\n * Assembles a composed message from attachments, a quote, and user text.\n * Used by both the TipTap Enter-key submit and the send-button click handler\n * to avoid duplicating the message-assembly logic.\n *\n * Returns an empty string if all inputs are empty.\n */\nexport function buildComposedMessage(opts: {\n  attachments?: UploadedAsset[];\n  quote?: QuoteData | null;\n  userText?: string;\n  appUrl?: string;\n}): string {\n  const parts: string[] = [];\n\n  if (opts.attachments && opts.attachments.length > 0) {\n    const attachmentMd = buildAttachmentMarkdownWithAppUrl({\n      attachments: opts.attachments,\n      appUrl: opts.appUrl,\n    });\n    if (attachmentMd) parts.push(attachmentMd);\n  }\n\n  if (opts.quote) {\n    const quotedLines = opts.quote.text.split('\\n').map((l) => `> ${l}`).join('\\n');\n    const sourceLabel = opts.quote.sourceTitle\n      ? `From \"${opts.quote.sourceTitle}\"`\n      : opts.quote.sourceRole === 'assistant'\n        ? 'Quoting assistant'\n        : 'Quoting';\n    parts.push(`${sourceLabel}:\\n${quotedLines}`);\n  }\n\n  const trimmed = opts.userText?.trim();\n  if (trimmed) parts.push(trimmed);\n\n  return parts.join('\\n\\n');\n}\n\n/**\n * The composed message a send delivers and the draft it came from: the same\n * attachments and quote around the editor's text as typed in one, and around\n * the editor's draft in the other (`ComposerSend`). `null` when there is\n * nothing to send.\n *\n * The quote and the attachment titles are text the person did not type in\n * the editor, and the message carries them as they are. The draft writes an\n * `&` in them that starts a character reference as `&amp;`, as the composer's\n * draft does for typed text, so it reads back as the message and stays a draft\n * of the message's own text (`isComposerMarkdownOfText`, which agora applies\n * too): a quoted `&lt;` would otherwise read as `<` in the draft and the\n * message would lose its composer markdown.\n */\nexport function buildComposedSend({\n  attachments,\n  quote,\n  send,\n  appUrl,\n}: {\n  attachments?: UploadedAsset[];\n  quote?: QuoteData | null;\n  send: ComposerSend;\n  appUrl?: string;\n}): ComposerSend | null {\n  const text = buildComposedMessage({ attachments, quote, userText: send.text, appUrl });\n  if (!text) return null;\n  const draftMarkdown = buildComposedMessage({\n    attachments: attachments?.map((attachment) => ({\n      ...attachment,\n      title: escapeCharacterReferences(attachment.title),\n    })),\n    quote: quote && {\n      ...quote,\n      text: escapeCharacterReferences(quote.text),\n      ...(quote.sourceTitle !== undefined && {\n        sourceTitle: escapeCharacterReferences(quote.sourceTitle),\n      }),\n    },\n    userText: send.draftMarkdown,\n    appUrl,\n  });\n  return { text, draftMarkdown };\n}\n\n/**\n * Holds a composed message in the chat outbox while sends are on hold (Athena can't be reached, or\n * earlier messages still wait): the uploaded attachments and the quote around the editor's text,\n * exactly as {@link buildComposedSend} would send them, so it goes with them once Athena is back.\n * The attachments are files already in Athena (an upload that finished before the drop); they are\n * named on the held message so the outbox asks Athena, right before it goes, that each can still\n * be opened. Cancel or Edit gives back the composed draft: the attachments as mentions in the\n * editor, the quote as quoted lines, nothing lost. `carried` are files already in Athena the\n * editor's own draft carries (mentions a held message gave back), named with the pills. `null`\n * when there is nothing to hold.\n */\nexport function holdComposedSend({\n  outbox,\n  attachments,\n  carried = [],\n  quote,\n  send,\n  appUrl,\n}: {\n  outbox: ChatOutbox;\n  attachments?: UploadedAsset[];\n  carried?: readonly ChatOutboxAttachment[];\n  quote?: QuoteData | null;\n  send: ComposerSend;\n  appUrl?: string;\n}): ChatOutboxEntry | null {\n  const composed = buildComposedSend({ attachments, quote, send, appUrl });\n  if (!composed) return null;\n  const named = new Map<string, ChatOutboxAttachment>();\n  for (const attachment of attachments ?? []) {\n    named.set(attachment.id, {\n      assetId: attachment.id,\n      title: attachment.title,\n      ...(attachment.mediaType && { mediaType: attachment.mediaType }),\n    });\n  }\n  for (const attachment of carried) {\n    if (!named.has(attachment.assetId)) named.set(attachment.assetId, attachment);\n  }\n  return outbox.hold({\n    text: composed.text,\n    composerMarkdown: composed.draftMarkdown,\n    metadata: withDeepAgentComposerMarkdown({\n      metadata: undefined,\n      text: composed.text,\n      markdown: composed.draftMarkdown,\n    }),\n    attachments: [...named.values()],\n  });\n}\n"],"names":["buildAttachmentMarkdownWithAppUrl","escapeCharacterReferences","withDeepAgentComposerMarkdown"],"mappings":";;;;;AAqBO,SAAS,qBAAqB,MAK1B;;AACT,QAAM,QAAkB,CAAA;AAExB,MAAI,KAAK,eAAe,KAAK,YAAY,SAAS,GAAG;AACnD,UAAM,eAAeA,kBAAAA,kCAAkC;AAAA,MACrD,aAAa,KAAK;AAAA,MAClB,QAAQ,KAAK;AAAA,IAAA,CACd;AACD,QAAI,aAAc,OAAM,KAAK,YAAY;AAAA,EAC3C;AAEA,MAAI,KAAK,OAAO;AACd,UAAM,cAAc,KAAK,MAAM,KAAK,MAAM,IAAI,EAAE,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,EAAE,KAAK,IAAI;AAC9E,UAAM,cAAc,KAAK,MAAM,cAC3B,SAAS,KAAK,MAAM,WAAW,MAC/B,KAAK,MAAM,eAAe,cACxB,sBACA;AACN,UAAM,KAAK,GAAG,WAAW;AAAA,EAAM,WAAW,EAAE;AAAA,EAC9C;AAEA,QAAM,WAAU,UAAK,aAAL,mBAAe;AAC/B,MAAI,QAAS,OAAM,KAAK,OAAO;AAE/B,SAAO,MAAM,KAAK,MAAM;AAC1B;AAgBO,SAAS,kBAAkB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAKwB;AACtB,QAAM,OAAO,qBAAqB,EAAE,aAAa,OAAO,UAAU,KAAK,MAAM,QAAQ;AACrF,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,gBAAgB,qBAAqB;AAAA,IACzC,aAAa,2CAAa,IAAI,CAAC,gBAAgB;AAAA,MAC7C,GAAG;AAAA,MACH,OAAOC,gBAAAA,0BAA0B,WAAW,KAAK;AAAA,IAAA;AAAA,IAEnD,OAAO,SAAS;AAAA,MACd,GAAG;AAAA,MACH,MAAMA,gBAAAA,0BAA0B,MAAM,IAAI;AAAA,MAC1C,GAAI,MAAM,gBAAgB,UAAa;AAAA,QACrC,aAAaA,gBAAAA,0BAA0B,MAAM,WAAW;AAAA,MAAA;AAAA,IAC1D;AAAA,IAEF,UAAU,KAAK;AAAA,IACf;AAAA,EAAA,CACD;AACD,SAAO,EAAE,MAAM,cAAA;AACjB;AAaO,SAAS,iBAAiB;AAAA,EAC/B;AAAA,EACA;AAAA,EACA,UAAU,CAAA;AAAA,EACV;AAAA,EACA;AAAA,EACA;AACF,GAO2B;AACzB,QAAM,WAAW,kBAAkB,EAAE,aAAa,OAAO,MAAM,QAAQ;AACvE,MAAI,CAAC,SAAU,QAAO;AACtB,QAAM,4BAAY,IAAA;AAClB,aAAW,cAAc,eAAe,IAAI;AAC1C,UAAM,IAAI,WAAW,IAAI;AAAA,MACvB,SAAS,WAAW;AAAA,MACpB,OAAO,WAAW;AAAA,MAClB,GAAI,WAAW,aAAa,EAAE,WAAW,WAAW,UAAA;AAAA,IAAU,CAC/D;AAAA,EACH;AACA,aAAW,cAAc,SAAS;AAChC,QAAI,CAAC,MAAM,IAAI,WAAW,OAAO,EAAG,OAAM,IAAI,WAAW,SAAS,UAAU;AAAA,EAC9E;AACA,SAAO,OAAO,KAAK;AAAA,IACjB,MAAM,SAAS;AAAA,IACf,kBAAkB,SAAS;AAAA,IAC3B,UAAUC,iBAAAA,8BAA8B;AAAA,MACtC,UAAU;AAAA,MACV,MAAM,SAAS;AAAA,MACf,UAAU,SAAS;AAAA,IAAA,CACpB;AAAA,IACD,aAAa,CAAC,GAAG,MAAM,QAAQ;AAAA,EAAA,CAChC;AACH;;;;"}

package/dist/composer/build-composed-message.d.ts

@@ -1,3 +1,4 @@
+import { type ChatOutbox, type ChatOutboxAttachment, type ChatOutboxEntry } from '../agent-runtime/src/index';
 import type { UploadedAsset } from './useFileUpload';
 import type { QuoteData } from './QuoteContext';
 import { type ComposerSend } from '../chat-ui/composer/composer-message';
@@ -34,3 +35,22 @@ export declare function buildComposedSend({ attachments, quote, send, appUrl, }:
     send: ComposerSend;
     appUrl?: string;
 }): ComposerSend | null;
+/**
+ * Holds a composed message in the chat outbox while sends are on hold (Athena can't be reached, or
+ * earlier messages still wait): the uploaded attachments and the quote around the editor's text,
+ * exactly as {@link buildComposedSend} would send them, so it goes with them once Athena is back.
+ * The attachments are files already in Athena (an upload that finished before the drop); they are
+ * named on the held message so the outbox asks Athena, right before it goes, that each can still
+ * be opened. Cancel or Edit gives back the composed draft: the attachments as mentions in the
+ * editor, the quote as quoted lines, nothing lost. `carried` are files already in Athena the
+ * editor's own draft carries (mentions a held message gave back), named with the pills. `null`
+ * when there is nothing to hold.
+ */
+export declare function holdComposedSend({ outbox, attachments, carried, quote, send, appUrl, }: {
+    outbox: ChatOutbox;
+    attachments?: UploadedAsset[];
+    carried?: readonly ChatOutboxAttachment[];
+    quote?: QuoteData | null;
+    send: ComposerSend;
+    appUrl?: string;
+}): ChatOutboxEntry | null;

package/dist/composer/build-composed-message.js

@@ -1,5 +1,6 @@
 import { buildAttachmentMarkdownWithAppUrl } from "./AttachmentContext.js";
 import { escapeCharacterReferences } from "../chat-ui/composer/composer-message.js";
+import { withDeepAgentComposerMarkdown } from "../agent-runtime/src/composer-markdown.js";
 function buildComposedMessage(opts) {
   var _a;
   const parts = [];
@@ -45,8 +46,41 @@ function buildComposedSend({
   });
   return { text, draftMarkdown };
 }
+function holdComposedSend({
+  outbox,
+  attachments,
+  carried = [],
+  quote,
+  send,
+  appUrl
+}) {
+  const composed = buildComposedSend({ attachments, quote, send, appUrl });
+  if (!composed) return null;
+  const named = /* @__PURE__ */ new Map();
+  for (const attachment of attachments ?? []) {
+    named.set(attachment.id, {
+      assetId: attachment.id,
+      title: attachment.title,
+      ...attachment.mediaType && { mediaType: attachment.mediaType }
+    });
+  }
+  for (const attachment of carried) {
+    if (!named.has(attachment.assetId)) named.set(attachment.assetId, attachment);
+  }
+  return outbox.hold({
+    text: composed.text,
+    composerMarkdown: composed.draftMarkdown,
+    metadata: withDeepAgentComposerMarkdown({
+      metadata: void 0,
+      text: composed.text,
+      markdown: composed.draftMarkdown
+    }),
+    attachments: [...named.values()]
+  });
+}
 export {
   buildComposedMessage,
-  buildComposedSend
+  buildComposedSend,
+  holdComposedSend
 };
 //# sourceMappingURL=build-composed-message.js.map

package/dist/composer/build-composed-message.js.map

@@ -1 +1 @@
-{"version":3,"file":"build-composed-message.js","sources":["../../src/composer/build-composed-message.ts"],"sourcesContent":["import type { UploadedAsset } from './useFileUpload';\nimport type { QuoteData } from './QuoteContext';\nimport { buildAttachmentMarkdownWithAppUrl } from './AttachmentContext';\nimport {\n  type ComposerSend,\n  escapeCharacterReferences,\n} from '../chat-ui/composer/composer-message';\n\n/**\n * Assembles a composed message from attachments, a quote, and user text.\n * Used by both the TipTap Enter-key submit and the send-button click handler\n * to avoid duplicating the message-assembly logic.\n *\n * Returns an empty string if all inputs are empty.\n */\nexport function buildComposedMessage(opts: {\n  attachments?: UploadedAsset[];\n  quote?: QuoteData | null;\n  userText?: string;\n  appUrl?: string;\n}): string {\n  const parts: string[] = [];\n\n  if (opts.attachments && opts.attachments.length > 0) {\n    const attachmentMd = buildAttachmentMarkdownWithAppUrl({\n      attachments: opts.attachments,\n      appUrl: opts.appUrl,\n    });\n    if (attachmentMd) parts.push(attachmentMd);\n  }\n\n  if (opts.quote) {\n    const quotedLines = opts.quote.text.split('\\n').map((l) => `> ${l}`).join('\\n');\n    const sourceLabel = opts.quote.sourceTitle\n      ? `From \"${opts.quote.sourceTitle}\"`\n      : opts.quote.sourceRole === 'assistant'\n        ? 'Quoting assistant'\n        : 'Quoting';\n    parts.push(`${sourceLabel}:\\n${quotedLines}`);\n  }\n\n  const trimmed = opts.userText?.trim();\n  if (trimmed) parts.push(trimmed);\n\n  return parts.join('\\n\\n');\n}\n\n/**\n * The composed message a send delivers and the draft it came from: the same\n * attachments and quote around the editor's text as typed in one, and around\n * the editor's draft in the other (`ComposerSend`). `null` when there is\n * nothing to send.\n *\n * The quote and the attachment titles are text the person did not type in\n * the editor, and the message carries them as they are. The draft writes an\n * `&` in them that starts a character reference as `&amp;`, as the composer's\n * draft does for typed text, so it reads back as the message and stays a draft\n * of the message's own text (`isComposerMarkdownOfText`, which agora applies\n * too): a quoted `&lt;` would otherwise read as `<` in the draft and the\n * message would lose its composer markdown.\n */\nexport function buildComposedSend({\n  attachments,\n  quote,\n  send,\n  appUrl,\n}: {\n  attachments?: UploadedAsset[];\n  quote?: QuoteData | null;\n  send: ComposerSend;\n  appUrl?: string;\n}): ComposerSend | null {\n  const text = buildComposedMessage({ attachments, quote, userText: send.text, appUrl });\n  if (!text) return null;\n  const draftMarkdown = buildComposedMessage({\n    attachments: attachments?.map((attachment) => ({\n      ...attachment,\n      title: escapeCharacterReferences(attachment.title),\n    })),\n    quote: quote && {\n      ...quote,\n      text: escapeCharacterReferences(quote.text),\n      ...(quote.sourceTitle !== undefined && {\n        sourceTitle: escapeCharacterReferences(quote.sourceTitle),\n      }),\n    },\n    userText: send.draftMarkdown,\n    appUrl,\n  });\n  return { text, draftMarkdown };\n}\n"],"names":[],"mappings":";;AAeO,SAAS,qBAAqB,MAK1B;;AACT,QAAM,QAAkB,CAAA;AAExB,MAAI,KAAK,eAAe,KAAK,YAAY,SAAS,GAAG;AACnD,UAAM,eAAe,kCAAkC;AAAA,MACrD,aAAa,KAAK;AAAA,MAClB,QAAQ,KAAK;AAAA,IAAA,CACd;AACD,QAAI,aAAc,OAAM,KAAK,YAAY;AAAA,EAC3C;AAEA,MAAI,KAAK,OAAO;AACd,UAAM,cAAc,KAAK,MAAM,KAAK,MAAM,IAAI,EAAE,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,EAAE,KAAK,IAAI;AAC9E,UAAM,cAAc,KAAK,MAAM,cAC3B,SAAS,KAAK,MAAM,WAAW,MAC/B,KAAK,MAAM,eAAe,cACxB,sBACA;AACN,UAAM,KAAK,GAAG,WAAW;AAAA,EAAM,WAAW,EAAE;AAAA,EAC9C;AAEA,QAAM,WAAU,UAAK,aAAL,mBAAe;AAC/B,MAAI,QAAS,OAAM,KAAK,OAAO;AAE/B,SAAO,MAAM,KAAK,MAAM;AAC1B;AAgBO,SAAS,kBAAkB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAKwB;AACtB,QAAM,OAAO,qBAAqB,EAAE,aAAa,OAAO,UAAU,KAAK,MAAM,QAAQ;AACrF,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,gBAAgB,qBAAqB;AAAA,IACzC,aAAa,2CAAa,IAAI,CAAC,gBAAgB;AAAA,MAC7C,GAAG;AAAA,MACH,OAAO,0BAA0B,WAAW,KAAK;AAAA,IAAA;AAAA,IAEnD,OAAO,SAAS;AAAA,MACd,GAAG;AAAA,MACH,MAAM,0BAA0B,MAAM,IAAI;AAAA,MAC1C,GAAI,MAAM,gBAAgB,UAAa;AAAA,QACrC,aAAa,0BAA0B,MAAM,WAAW;AAAA,MAAA;AAAA,IAC1D;AAAA,IAEF,UAAU,KAAK;AAAA,IACf;AAAA,EAAA,CACD;AACD,SAAO,EAAE,MAAM,cAAA;AACjB;"}
+{"version":3,"file":"build-composed-message.js","sources":["../../src/composer/build-composed-message.ts"],"sourcesContent":["import {\n  type ChatOutbox,\n  type ChatOutboxAttachment,\n  type ChatOutboxEntry,\n  withDeepAgentComposerMarkdown,\n} from '@athenaintel/agent-runtime';\nimport type { UploadedAsset } from './useFileUpload';\nimport type { QuoteData } from './QuoteContext';\nimport { buildAttachmentMarkdownWithAppUrl } from './AttachmentContext';\nimport {\n  type ComposerSend,\n  escapeCharacterReferences,\n} from '../chat-ui/composer/composer-message';\n\n/**\n * Assembles a composed message from attachments, a quote, and user text.\n * Used by both the TipTap Enter-key submit and the send-button click handler\n * to avoid duplicating the message-assembly logic.\n *\n * Returns an empty string if all inputs are empty.\n */\nexport function buildComposedMessage(opts: {\n  attachments?: UploadedAsset[];\n  quote?: QuoteData | null;\n  userText?: string;\n  appUrl?: string;\n}): string {\n  const parts: string[] = [];\n\n  if (opts.attachments && opts.attachments.length > 0) {\n    const attachmentMd = buildAttachmentMarkdownWithAppUrl({\n      attachments: opts.attachments,\n      appUrl: opts.appUrl,\n    });\n    if (attachmentMd) parts.push(attachmentMd);\n  }\n\n  if (opts.quote) {\n    const quotedLines = opts.quote.text.split('\\n').map((l) => `> ${l}`).join('\\n');\n    const sourceLabel = opts.quote.sourceTitle\n      ? `From \"${opts.quote.sourceTitle}\"`\n      : opts.quote.sourceRole === 'assistant'\n        ? 'Quoting assistant'\n        : 'Quoting';\n    parts.push(`${sourceLabel}:\\n${quotedLines}`);\n  }\n\n  const trimmed = opts.userText?.trim();\n  if (trimmed) parts.push(trimmed);\n\n  return parts.join('\\n\\n');\n}\n\n/**\n * The composed message a send delivers and the draft it came from: the same\n * attachments and quote around the editor's text as typed in one, and around\n * the editor's draft in the other (`ComposerSend`). `null` when there is\n * nothing to send.\n *\n * The quote and the attachment titles are text the person did not type in\n * the editor, and the message carries them as they are. The draft writes an\n * `&` in them that starts a character reference as `&amp;`, as the composer's\n * draft does for typed text, so it reads back as the message and stays a draft\n * of the message's own text (`isComposerMarkdownOfText`, which agora applies\n * too): a quoted `&lt;` would otherwise read as `<` in the draft and the\n * message would lose its composer markdown.\n */\nexport function buildComposedSend({\n  attachments,\n  quote,\n  send,\n  appUrl,\n}: {\n  attachments?: UploadedAsset[];\n  quote?: QuoteData | null;\n  send: ComposerSend;\n  appUrl?: string;\n}): ComposerSend | null {\n  const text = buildComposedMessage({ attachments, quote, userText: send.text, appUrl });\n  if (!text) return null;\n  const draftMarkdown = buildComposedMessage({\n    attachments: attachments?.map((attachment) => ({\n      ...attachment,\n      title: escapeCharacterReferences(attachment.title),\n    })),\n    quote: quote && {\n      ...quote,\n      text: escapeCharacterReferences(quote.text),\n      ...(quote.sourceTitle !== undefined && {\n        sourceTitle: escapeCharacterReferences(quote.sourceTitle),\n      }),\n    },\n    userText: send.draftMarkdown,\n    appUrl,\n  });\n  return { text, draftMarkdown };\n}\n\n/**\n * Holds a composed message in the chat outbox while sends are on hold (Athena can't be reached, or\n * earlier messages still wait): the uploaded attachments and the quote around the editor's text,\n * exactly as {@link buildComposedSend} would send them, so it goes with them once Athena is back.\n * The attachments are files already in Athena (an upload that finished before the drop); they are\n * named on the held message so the outbox asks Athena, right before it goes, that each can still\n * be opened. Cancel or Edit gives back the composed draft: the attachments as mentions in the\n * editor, the quote as quoted lines, nothing lost. `carried` are files already in Athena the\n * editor's own draft carries (mentions a held message gave back), named with the pills. `null`\n * when there is nothing to hold.\n */\nexport function holdComposedSend({\n  outbox,\n  attachments,\n  carried = [],\n  quote,\n  send,\n  appUrl,\n}: {\n  outbox: ChatOutbox;\n  attachments?: UploadedAsset[];\n  carried?: readonly ChatOutboxAttachment[];\n  quote?: QuoteData | null;\n  send: ComposerSend;\n  appUrl?: string;\n}): ChatOutboxEntry | null {\n  const composed = buildComposedSend({ attachments, quote, send, appUrl });\n  if (!composed) return null;\n  const named = new Map<string, ChatOutboxAttachment>();\n  for (const attachment of attachments ?? []) {\n    named.set(attachment.id, {\n      assetId: attachment.id,\n      title: attachment.title,\n      ...(attachment.mediaType && { mediaType: attachment.mediaType }),\n    });\n  }\n  for (const attachment of carried) {\n    if (!named.has(attachment.assetId)) named.set(attachment.assetId, attachment);\n  }\n  return outbox.hold({\n    text: composed.text,\n    composerMarkdown: composed.draftMarkdown,\n    metadata: withDeepAgentComposerMarkdown({\n      metadata: undefined,\n      text: composed.text,\n      markdown: composed.draftMarkdown,\n    }),\n    attachments: [...named.values()],\n  });\n}\n"],"names":[],"mappings":";;;AAqBO,SAAS,qBAAqB,MAK1B;;AACT,QAAM,QAAkB,CAAA;AAExB,MAAI,KAAK,eAAe,KAAK,YAAY,SAAS,GAAG;AACnD,UAAM,eAAe,kCAAkC;AAAA,MACrD,aAAa,KAAK;AAAA,MAClB,QAAQ,KAAK;AAAA,IAAA,CACd;AACD,QAAI,aAAc,OAAM,KAAK,YAAY;AAAA,EAC3C;AAEA,MAAI,KAAK,OAAO;AACd,UAAM,cAAc,KAAK,MAAM,KAAK,MAAM,IAAI,EAAE,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,EAAE,KAAK,IAAI;AAC9E,UAAM,cAAc,KAAK,MAAM,cAC3B,SAAS,KAAK,MAAM,WAAW,MAC/B,KAAK,MAAM,eAAe,cACxB,sBACA;AACN,UAAM,KAAK,GAAG,WAAW;AAAA,EAAM,WAAW,EAAE;AAAA,EAC9C;AAEA,QAAM,WAAU,UAAK,aAAL,mBAAe;AAC/B,MAAI,QAAS,OAAM,KAAK,OAAO;AAE/B,SAAO,MAAM,KAAK,MAAM;AAC1B;AAgBO,SAAS,kBAAkB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAKwB;AACtB,QAAM,OAAO,qBAAqB,EAAE,aAAa,OAAO,UAAU,KAAK,MAAM,QAAQ;AACrF,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,gBAAgB,qBAAqB;AAAA,IACzC,aAAa,2CAAa,IAAI,CAAC,gBAAgB;AAAA,MAC7C,GAAG;AAAA,MACH,OAAO,0BAA0B,WAAW,KAAK;AAAA,IAAA;AAAA,IAEnD,OAAO,SAAS;AAAA,MACd,GAAG;AAAA,MACH,MAAM,0BAA0B,MAAM,IAAI;AAAA,MAC1C,GAAI,MAAM,gBAAgB,UAAa;AAAA,QACrC,aAAa,0BAA0B,MAAM,WAAW;AAAA,MAAA;AAAA,IAC1D;AAAA,IAEF,UAAU,KAAK;AAAA,IACf;AAAA,EAAA,CACD;AACD,SAAO,EAAE,MAAM,cAAA;AACjB;AAaO,SAAS,iBAAiB;AAAA,EAC/B;AAAA,EACA;AAAA,EACA,UAAU,CAAA;AAAA,EACV;AAAA,EACA;AAAA,EACA;AACF,GAO2B;AACzB,QAAM,WAAW,kBAAkB,EAAE,aAAa,OAAO,MAAM,QAAQ;AACvE,MAAI,CAAC,SAAU,QAAO;AACtB,QAAM,4BAAY,IAAA;AAClB,aAAW,cAAc,eAAe,IAAI;AAC1C,UAAM,IAAI,WAAW,IAAI;AAAA,MACvB,SAAS,WAAW;AAAA,MACpB,OAAO,WAAW;AAAA,MAClB,GAAI,WAAW,aAAa,EAAE,WAAW,WAAW,UAAA;AAAA,IAAU,CAC/D;AAAA,EACH;AACA,aAAW,cAAc,SAAS;AAChC,QAAI,CAAC,MAAM,IAAI,WAAW,OAAO,EAAG,OAAM,IAAI,WAAW,SAAS,UAAU;AAAA,EAC9E;AACA,SAAO,OAAO,KAAK;AAAA,IACjB,MAAM,SAAS;AAAA,IACf,kBAAkB,SAAS;AAAA,IAC3B,UAAU,8BAA8B;AAAA,MACtC,UAAU;AAAA,MACV,MAAM,SAAS;AAAA,MACf,UAAU,SAAS;AAAA,IAAA,CACpB;AAAA,IACD,aAAa,CAAC,GAAG,MAAM,QAAQ;AAAA,EAAA,CAChC;AACH;"}

package/dist/composer/composer-handoff.cjs

@@ -4,9 +4,41 @@ const react$1 = require("react");
 const react = require("@assistant-ui/react");
 const athenaDiagnostics = require("../diagnostics/athena-diagnostics.cjs");
 const errors = require("../diagnostics/errors.cjs");
+const statewireSessionLane = require("../runtime/statewire-session-lane.cjs");
 const statewireThreadList = require("../threads/statewire-thread-list.cjs");
 function createComposerHandoffStore() {
-  return { pending: [], focusOnNextMirror: false, focusEnd: null, focusOnMount: false };
+  return {
+    pending: [],
+    focusOnNextMirror: false,
+    focusEnd: null,
+    focusOnMount: false,
+    restoredAttachments: /* @__PURE__ */ new Map()
+  };
+}
+function rememberRestoredAttachments({
+  store,
+  threadId,
+  attachments
+}) {
+  if (attachments.length === 0) return;
+  store.restoredAttachments ?? (store.restoredAttachments = /* @__PURE__ */ new Map());
+  const kept = store.restoredAttachments.get(threadId) ?? [];
+  const known = new Set(kept.map((attachment) => attachment.assetId));
+  store.restoredAttachments.set(threadId, [
+    ...kept,
+    ...attachments.filter((attachment) => !known.has(attachment.assetId))
+  ]);
+}
+function takeRestoredAttachments({
+  store,
+  threadId,
+  assetIdsInDraft
+}) {
+  var _a, _b;
+  const kept = (_a = store == null ? void 0 : store.restoredAttachments) == null ? void 0 : _a.get(threadId);
+  if (!kept) return [];
+  (_b = store == null ? void 0 : store.restoredAttachments) == null ? void 0 : _b.delete(threadId);
+  return kept.filter((attachment) => assetIdsInDraft.has(attachment.assetId));
 }
 const ComposerHandoffContext = react$1.createContext(null);
 function useComposerHandoffStore() {
@@ -28,7 +60,8 @@ function useComposerReady() {
     var _a;
     return ((_a = s.optional.thread) == null ? void 0 : _a.isLoading) ?? false;
   });
-  return !((list == null ? void 0 : list.isLoading) ?? false) && !threadLoading;
+  const lanePending = statewireSessionLane.useStatewireSessionLanePending();
+  return !((list == null ? void 0 : list.isLoading) ?? false) && !threadLoading && !lanePending;
 }
 function mergeComposerDraft({
   current,
@@ -114,6 +147,8 @@ function clearComposerHandoff({
   store,
   reason
 }) {
+  var _a;
+  (_a = store.restoredAttachments) == null ? void 0 : _a.clear();
   const writes = store.pending;
   if (writes.length === 0) return;
   store.pending = [];
@@ -127,6 +162,8 @@ exports.drainComposerHandoff = drainComposerHandoff;
 exports.focusComposer = focusComposer;
 exports.mergeComposerDraft = mergeComposerDraft;
 exports.queueComposerWrite = queueComposerWrite;
+exports.rememberRestoredAttachments = rememberRestoredAttachments;
+exports.takeRestoredAttachments = takeRestoredAttachments;
 exports.useComposerHandoffStore = useComposerHandoffStore;
 exports.useComposerReady = useComposerReady;
 exports.useFocusComposer = useFocusComposer;

package/dist/composer/composer-handoff.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"composer-handoff.cjs","sources":["../../src/composer/composer-handoff.ts"],"sourcesContent":["/**\n * Composer handoff: writes to the chat composer from host UI that lives\n * outside `<AthenaChat>` (a sidebar, an agenda card, a workflow button).\n *\n * Two problems it solves for `useAppendToComposer` / `useSendMessage`:\n *\n * 1. A write before the chat is ready is lost. While the thread list is still\n *    resolving the active thread, or the thread's history is still loading,\n *    the composer the hooks write to belongs to a mount that is about to be\n *    replaced (thread-list mode keys the statewire subtree by thread), and\n *    the draft goes with it. The store below lives ABOVE that mount, so a\n *    write made too early waits here and the ready mount drains it.\n * 2. A prefilled draft should put the caret after the text so the user can\n *    keep typing or dictating. The Tiptap editor mirrors runtime text on a\n *    later tick; the `focusOnNextMirror` flag asks it to focus at the end\n *    right after that mirror lands, instead of the host guessing a delay.\n *\n * Every queued write is bound to the statewire thread it was made for and\n * drains only into that thread's mount; a thread switch, an identity change\n * or a provider unmount drops what waits with a `composer_write_dropped`\n * error, never into another user's or another thread's composer.\n */\nimport { createContext, useCallback, useContext } from 'react';\nimport { useAuiState } from '@assistant-ui/react';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport { AthenaSdkError } from '../diagnostics/errors';\nimport { useAthenaStatewireThreadList } from '../threads/statewire-thread-list';\n\n/** The slice of the assistant-ui client the handoff writes to. */\nexport interface ComposerTarget {\n  composer: {\n    getState: () => { text: string };\n    setText: (text: string) => void;\n    send: (options?: { steer?: boolean }) => unknown;\n  };\n}\n\nexport interface ComposerWrite {\n  text: string;\n  /** Replace the draft instead of appending on a new line. */\n  replace: boolean;\n  /** Submit right after writing. */\n  send: boolean;\n  /** Put the caret at the end of the draft once the editor shows it. */\n  focus: boolean;\n  /** The statewire thread the write was made for; it drains only into that thread's mount. */\n  threadId: string | null;\n  /** Settled once the write has been applied (and, for `send`, with the send's outcome). */\n  resolve?: (outcome: Promise<void> | void) => void;\n  /** Settled with `composer_write_dropped` when the write can no longer land. */\n  reject?: (error: AthenaSdkError) => void;\n}\n\nexport interface ComposerHandoffStore {\n  /** Writes waiting for a ready composer, oldest first. Adjacent plain appends fold together. */\n  pending: ComposerWrite[];\n  /** Set by a `focus` write; the editor consumes it after mirroring the draft. */\n  focusOnNextMirror: boolean;\n  /** Registered by the mounted editor: place the caret at the end of the draft. */\n  focusEnd: (() => void) | null;\n  /** Set by `useFocusComposer` before the editor mounted; the editor consumes it when it does. */\n  focusOnMount: boolean;\n}\n\nexport function createComposerHandoffStore(): ComposerHandoffStore {\n  return { pending: [], focusOnNextMirror: false, focusEnd: null, focusOnMount: false };\n}\n\nexport const ComposerHandoffContext = createContext<ComposerHandoffStore | null>(null);\n\n/** The provider's handoff store, or null outside `AthenaProvider`. */\nexport function useComposerHandoffStore(): ComposerHandoffStore | null {\n  return useContext(ComposerHandoffContext);\n}\n\n/**\n * Puts the caret at the end of the composer's draft and leaves the draft as it is; asked before the\n * editor has mounted, it focuses the editor as it mounts. For a host that shows the chat again and\n * wants typing to land in it (a launcher window a shortcut brings back).\n */\nexport function useFocusComposer(): () => void {\n  const store = useComposerHandoffStore();\n  return useCallback(() => {\n    if (store) focusComposer({ store });\n  }, [store]);\n}\n\n/** The caret to the end of the draft now, or, with no editor mounted yet, as one mounts. */\nexport function focusComposer({ store }: { store: ComposerHandoffStore }): void {\n  if (store.focusEnd) store.focusEnd();\n  else store.focusOnMount = true;\n}\n\n/**\n * Whether a composer write lands now: in thread-list mode the list has\n * resolved which thread is active, and that thread's history has loaded.\n * Until then the composer the hooks write to is the one of a mount that is\n * about to be replaced, and the draft goes with it.\n *\n * Deliberately not the socket status: a never-started chat sits in\n * `standby` until its first send and must still take a prefill.\n */\nexport function useComposerReady(): boolean {\n  const list = useAthenaStatewireThreadList();\n  const threadLoading = useAuiState((s) => s.optional.thread?.isLoading ?? false);\n  return !(list?.isLoading ?? false) && !threadLoading;\n}\n\n/** The draft after `write`: `replace` (or an empty draft) takes the text as is. */\nexport function mergeComposerDraft({\n  current,\n  write,\n}: {\n  current: string;\n  write: Pick<ComposerWrite, 'text' | 'replace'>;\n}): string {\n  if (write.replace || !current) return write.text;\n  return `${current}\\n${write.text}`;\n}\n\n/**\n * Write into the live composer. Returns the send's outcome for a `send`\n * write so callers can await it.\n */\nexport function applyComposerWrite({\n  target,\n  store,\n  write,\n}: {\n  target: ComposerTarget;\n  store: ComposerHandoffStore | null;\n  write: ComposerWrite;\n}): Promise<void> | void {\n  const current = target.composer.getState().text ?? '';\n  const next = mergeComposerDraft({ current, write });\n  target.composer.setText(next);\n  if (write.focus && store) {\n    // An unchanged draft never re-mirrors, so focus at once; otherwise the\n    // editor focuses itself right after it has shown the new text.\n    if (next === current) store.focusEnd?.();\n    else store.focusOnNextMirror = true;\n  }\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'debug',\n    data: { phase: 'applied', send: write.send, focus: write.focus, chars: next.length },\n  });\n  if (write.send) {\n    return Promise.resolve(target.composer.send({ steer: false })).then(() => undefined);\n  }\n  return undefined;\n}\n\n/**\n * Hold a write until the composer is ready. Writes keep their order; a plain\n * append folds into a directly preceding plain append for the same thread\n * (one draft, not two), while a replace or a send is kept as its own step so\n * no message is lost and every send settles on its own.\n */\nexport function queueComposerWrite({\n  store,\n  write,\n}: {\n  store: ComposerHandoffStore;\n  write: ComposerWrite;\n}): void {\n  const last = store.pending[store.pending.length - 1];\n  const foldable =\n    last !== undefined &&\n    !last.send &&\n    !write.send &&\n    !write.replace &&\n    last.threadId === write.threadId &&\n    last.resolve === undefined &&\n    write.resolve === undefined;\n  if (foldable) {\n    last.text = mergeComposerDraft({ current: last.text, write });\n    last.focus = last.focus || write.focus;\n  } else {\n    store.pending.push(write);\n  }\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'debug',\n    data: { phase: 'deferred', send: write.send, focus: write.focus, queued: store.pending.length },\n  });\n}\n\nfunction dropWrite({ write, reason }: { write: ComposerWrite; reason: string }): void {\n  const error = new AthenaSdkError({\n    code: 'composer_write_dropped',\n    message: `A composer ${write.send ? 'send' : 'draft'} queued before the chat was ready was dropped: ${reason}.`,\n    hint: 'Make the write again from the chat that is active now.',\n    context: { threadId: write.threadId, send: write.send },\n  });\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'warn',\n    error,\n    data: { phase: 'dropped', send: write.send, reason, threadId: write.threadId },\n  });\n  write.reject?.(error);\n}\n\n/**\n * Deliver the pending writes, in order, into a now-ready composer. A write\n * made for another thread is dropped (rejected), never applied here.\n */\nexport function drainComposerHandoff({\n  store,\n  target,\n  threadId,\n}: {\n  store: ComposerHandoffStore;\n  target: ComposerTarget;\n  /** The statewire thread of the mount that is draining. */\n  threadId: string | null;\n}): void {\n  const writes = store.pending;\n  if (writes.length === 0) return;\n  store.pending = [];\n  for (const write of writes) {\n    if (write.threadId !== null && threadId !== null && write.threadId !== threadId) {\n      dropWrite({ write, reason: `it was made for thread ${write.threadId}, thread ${threadId} is active` });\n      continue;\n    }\n    const outcome = applyComposerWrite({ target, store, write });\n    write.resolve?.(outcome);\n  }\n}\n\n/** Drop every pending write (identity changed, provider unmounted). */\nexport function clearComposerHandoff({\n  store,\n  reason,\n}: {\n  store: ComposerHandoffStore;\n  reason: string;\n}): void {\n  const writes = store.pending;\n  if (writes.length === 0) return;\n  store.pending = [];\n  for (const write of writes) dropWrite({ write, reason });\n}\n"],"names":["createContext","useContext","useCallback","useAthenaStatewireThreadList","useAuiState","athenaDiagnostics","AthenaSdkError"],"mappings":"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"}
+{"version":3,"file":"composer-handoff.cjs","sources":["../../src/composer/composer-handoff.ts"],"sourcesContent":["/**\n * Composer handoff: writes to the chat composer from host UI that lives\n * outside `<AthenaChat>` (a sidebar, an agenda card, a workflow button).\n *\n * Two problems it solves for `useAppendToComposer` / `useSendMessage`:\n *\n * 1. A write before the chat is ready is lost. While the thread list is still\n *    resolving the active thread, or the thread's history is still loading,\n *    the composer the hooks write to belongs to a mount that is about to be\n *    replaced (thread-list mode keys the statewire subtree by thread), and\n *    the draft goes with it. The store below lives ABOVE that mount, so a\n *    write made too early waits here and the ready mount drains it.\n * 2. A prefilled draft should put the caret after the text so the user can\n *    keep typing or dictating. The Tiptap editor mirrors runtime text on a\n *    later tick; the `focusOnNextMirror` flag asks it to focus at the end\n *    right after that mirror lands, instead of the host guessing a delay.\n *\n * Every queued write is bound to the statewire thread it was made for and\n * drains only into that thread's mount; a thread switch, an identity change\n * or a provider unmount drops what waits with a `composer_write_dropped`\n * error, never into another user's or another thread's composer.\n */\nimport { createContext, useCallback, useContext } from 'react';\nimport { useAuiState } from '@assistant-ui/react';\nimport type { ChatOutboxAttachment } from '@athenaintel/agent-runtime';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport { AthenaSdkError } from '../diagnostics/errors';\nimport { useStatewireSessionLanePending } from '../runtime/statewire-session-lane';\nimport { useAthenaStatewireThreadList } from '../threads/statewire-thread-list';\n\n/** The slice of the assistant-ui client the handoff writes to. */\nexport interface ComposerTarget {\n  composer: {\n    getState: () => { text: string };\n    setText: (text: string) => void;\n    send: (options?: { steer?: boolean }) => unknown;\n  };\n}\n\nexport interface ComposerWrite {\n  text: string;\n  /** Replace the draft instead of appending on a new line. */\n  replace: boolean;\n  /** Submit right after writing. */\n  send: boolean;\n  /** Put the caret at the end of the draft once the editor shows it. */\n  focus: boolean;\n  /** The statewire thread the write was made for; it drains only into that thread's mount. */\n  threadId: string | null;\n  /** Settled once the write has been applied (and, for `send`, with the send's outcome). */\n  resolve?: (outcome: Promise<void> | void) => void;\n  /** Settled with `composer_write_dropped` when the write can no longer land. */\n  reject?: (error: AthenaSdkError) => void;\n}\n\nexport interface ComposerHandoffStore {\n  /** Writes waiting for a ready composer, oldest first. Adjacent plain appends fold together. */\n  pending: ComposerWrite[];\n  /** Set by a `focus` write; the editor consumes it after mirroring the draft. */\n  focusOnNextMirror: boolean;\n  /** Registered by the mounted editor: place the caret at the end of the draft. */\n  focusEnd: (() => void) | null;\n  /** Set by `useFocusComposer` before the editor mounted; the editor consumes it when it does. */\n  focusOnMount: boolean;\n  /**\n   * Per thread, the attachments of messages the chat outbox gave back to the composer (Cancel, or\n   * Edit on one that couldn't be sent): files already in Athena, back in the draft as mentions. A\n   * message held again from that draft names those still in it, so the outbox asks Athena about\n   * them again before it goes ({@link rememberRestoredAttachments}, {@link takeRestoredAttachments}).\n   */\n  restoredAttachments?: Map<string, ChatOutboxAttachment[]>;\n}\n\nexport function createComposerHandoffStore(): ComposerHandoffStore {\n  return {\n    pending: [],\n    focusOnNextMirror: false,\n    focusEnd: null,\n    focusOnMount: false,\n    restoredAttachments: new Map(),\n  };\n}\n\n/** A held message given back to `threadId`'s composer: remember the attachments it carried. */\nexport function rememberRestoredAttachments({\n  store,\n  threadId,\n  attachments,\n}: {\n  store: ComposerHandoffStore;\n  threadId: string;\n  attachments: readonly ChatOutboxAttachment[];\n}): void {\n  if (attachments.length === 0) return;\n  store.restoredAttachments ??= new Map();\n  const kept = store.restoredAttachments.get(threadId) ?? [];\n  const known = new Set(kept.map((attachment) => attachment.assetId));\n  store.restoredAttachments.set(threadId, [\n    ...kept,\n    ...attachments.filter((attachment) => !known.has(attachment.assetId)),\n  ]);\n}\n\n/**\n * The remembered attachments of `threadId`'s draft whose mentions it still holds, for the message\n * leaving it now; the composer forgets them all (sent, held again, or removed from the draft).\n */\nexport function takeRestoredAttachments({\n  store,\n  threadId,\n  assetIdsInDraft,\n}: {\n  store: ComposerHandoffStore | null;\n  threadId: string;\n  assetIdsInDraft: ReadonlySet<string>;\n}): ChatOutboxAttachment[] {\n  const kept = store?.restoredAttachments?.get(threadId);\n  if (!kept) return [];\n  store?.restoredAttachments?.delete(threadId);\n  return kept.filter((attachment) => assetIdsInDraft.has(attachment.assetId));\n}\n\nexport const ComposerHandoffContext = createContext<ComposerHandoffStore | null>(null);\n\n/** The provider's handoff store, or null outside `AthenaProvider`. */\nexport function useComposerHandoffStore(): ComposerHandoffStore | null {\n  return useContext(ComposerHandoffContext);\n}\n\n/**\n * Puts the caret at the end of the composer's draft and leaves the draft as it is; asked before the\n * editor has mounted, it focuses the editor as it mounts. For a host that shows the chat again and\n * wants typing to land in it (a launcher window a shortcut brings back).\n */\nexport function useFocusComposer(): () => void {\n  const store = useComposerHandoffStore();\n  return useCallback(() => {\n    if (store) focusComposer({ store });\n  }, [store]);\n}\n\n/** The caret to the end of the draft now, or, with no editor mounted yet, as one mounts. */\nexport function focusComposer({ store }: { store: ComposerHandoffStore }): void {\n  if (store.focusEnd) store.focusEnd();\n  else store.focusOnMount = true;\n}\n\n/**\n * Whether a composer write lands now: in thread-list mode the list has\n * resolved which thread is active, that thread's history has loaded, and the\n * chat's session lane is known (the sign-in provider above has resolved who is\n * signed in; see `StatewireSessionLane`). Until then the composer the hooks\n * write to is the one of a mount that is about to be replaced, and the draft\n * goes with it, or a send would go into a parked lane that refuses it unsent.\n *\n * Deliberately not the socket status: a never-started chat sits in\n * `standby` until its first send and must still take a prefill.\n */\nexport function useComposerReady(): boolean {\n  const list = useAthenaStatewireThreadList();\n  const threadLoading = useAuiState((s) => s.optional.thread?.isLoading ?? false);\n  const lanePending = useStatewireSessionLanePending();\n  return !(list?.isLoading ?? false) && !threadLoading && !lanePending;\n}\n\n/** The draft after `write`: `replace` (or an empty draft) takes the text as is. */\nexport function mergeComposerDraft({\n  current,\n  write,\n}: {\n  current: string;\n  write: Pick<ComposerWrite, 'text' | 'replace'>;\n}): string {\n  if (write.replace || !current) return write.text;\n  return `${current}\\n${write.text}`;\n}\n\n/**\n * Write into the live composer. Returns the send's outcome for a `send`\n * write so callers can await it.\n */\nexport function applyComposerWrite({\n  target,\n  store,\n  write,\n}: {\n  target: ComposerTarget;\n  store: ComposerHandoffStore | null;\n  write: ComposerWrite;\n}): Promise<void> | void {\n  const current = target.composer.getState().text ?? '';\n  const next = mergeComposerDraft({ current, write });\n  target.composer.setText(next);\n  if (write.focus && store) {\n    // An unchanged draft never re-mirrors, so focus at once; otherwise the\n    // editor focuses itself right after it has shown the new text.\n    if (next === current) store.focusEnd?.();\n    else store.focusOnNextMirror = true;\n  }\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'debug',\n    data: { phase: 'applied', send: write.send, focus: write.focus, chars: next.length },\n  });\n  if (write.send) {\n    return Promise.resolve(target.composer.send({ steer: false })).then(() => undefined);\n  }\n  return undefined;\n}\n\n/**\n * Hold a write until the composer is ready. Writes keep their order; a plain\n * append folds into a directly preceding plain append for the same thread\n * (one draft, not two), while a replace or a send is kept as its own step so\n * no message is lost and every send settles on its own.\n */\nexport function queueComposerWrite({\n  store,\n  write,\n}: {\n  store: ComposerHandoffStore;\n  write: ComposerWrite;\n}): void {\n  const last = store.pending[store.pending.length - 1];\n  const foldable =\n    last !== undefined &&\n    !last.send &&\n    !write.send &&\n    !write.replace &&\n    last.threadId === write.threadId &&\n    last.resolve === undefined &&\n    write.resolve === undefined;\n  if (foldable) {\n    last.text = mergeComposerDraft({ current: last.text, write });\n    last.focus = last.focus || write.focus;\n  } else {\n    store.pending.push(write);\n  }\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'debug',\n    data: { phase: 'deferred', send: write.send, focus: write.focus, queued: store.pending.length },\n  });\n}\n\nfunction dropWrite({ write, reason }: { write: ComposerWrite; reason: string }): void {\n  const error = new AthenaSdkError({\n    code: 'composer_write_dropped',\n    message: `A composer ${write.send ? 'send' : 'draft'} queued before the chat was ready was dropped: ${reason}.`,\n    hint: 'Make the write again from the chat that is active now.',\n    context: { threadId: write.threadId, send: write.send },\n  });\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'warn',\n    error,\n    data: { phase: 'dropped', send: write.send, reason, threadId: write.threadId },\n  });\n  write.reject?.(error);\n}\n\n/**\n * Deliver the pending writes, in order, into a now-ready composer. A write\n * made for another thread is dropped (rejected), never applied here.\n */\nexport function drainComposerHandoff({\n  store,\n  target,\n  threadId,\n}: {\n  store: ComposerHandoffStore;\n  target: ComposerTarget;\n  /** The statewire thread of the mount that is draining. */\n  threadId: string | null;\n}): void {\n  const writes = store.pending;\n  if (writes.length === 0) return;\n  store.pending = [];\n  for (const write of writes) {\n    if (write.threadId !== null && threadId !== null && write.threadId !== threadId) {\n      dropWrite({ write, reason: `it was made for thread ${write.threadId}, thread ${threadId} is active` });\n      continue;\n    }\n    const outcome = applyComposerWrite({ target, store, write });\n    write.resolve?.(outcome);\n  }\n}\n\n/** Drop every pending write (identity changed, provider unmounted). */\nexport function clearComposerHandoff({\n  store,\n  reason,\n}: {\n  store: ComposerHandoffStore;\n  reason: string;\n}): void {\n  // Another identity, or no provider: the attachments given back belong to drafts that are gone.\n  store.restoredAttachments?.clear();\n  const writes = store.pending;\n  if (writes.length === 0) return;\n  store.pending = [];\n  for (const write of writes) dropWrite({ write, reason });\n}\n"],"names":["createContext","useContext","useCallback","useAthenaStatewireThreadList","useAuiState","useStatewireSessionLanePending","athenaDiagnostics","AthenaSdkError"],"mappings":"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"}

package/dist/composer/composer-handoff.d.ts

@@ -1,3 +1,4 @@
+import type { ChatOutboxAttachment } from '../agent-runtime/src/index';
 import { AthenaSdkError } from '../diagnostics/errors';
 /** The slice of the assistant-ui client the handoff writes to. */
 export interface ComposerTarget {
@@ -35,8 +36,30 @@ export interface ComposerHandoffStore {
     focusEnd: (() => void) | null;
     /** Set by `useFocusComposer` before the editor mounted; the editor consumes it when it does. */
     focusOnMount: boolean;
+    /**
+     * Per thread, the attachments of messages the chat outbox gave back to the composer (Cancel, or
+     * Edit on one that couldn't be sent): files already in Athena, back in the draft as mentions. A
+     * message held again from that draft names those still in it, so the outbox asks Athena about
+     * them again before it goes ({@link rememberRestoredAttachments}, {@link takeRestoredAttachments}).
+     */
+    restoredAttachments?: Map<string, ChatOutboxAttachment[]>;
 }
 export declare function createComposerHandoffStore(): ComposerHandoffStore;
+/** A held message given back to `threadId`'s composer: remember the attachments it carried. */
+export declare function rememberRestoredAttachments({ store, threadId, attachments, }: {
+    store: ComposerHandoffStore;
+    threadId: string;
+    attachments: readonly ChatOutboxAttachment[];
+}): void;
+/**
+ * The remembered attachments of `threadId`'s draft whose mentions it still holds, for the message
+ * leaving it now; the composer forgets them all (sent, held again, or removed from the draft).
+ */
+export declare function takeRestoredAttachments({ store, threadId, assetIdsInDraft, }: {
+    store: ComposerHandoffStore | null;
+    threadId: string;
+    assetIdsInDraft: ReadonlySet<string>;
+}): ChatOutboxAttachment[];
 export declare const ComposerHandoffContext: import("react").Context<ComposerHandoffStore | null>;
 /** The provider's handoff store, or null outside `AthenaProvider`. */
 export declare function useComposerHandoffStore(): ComposerHandoffStore | null;
@@ -52,9 +75,11 @@ export declare function focusComposer({ store }: {
 }): void;
 /**
  * Whether a composer write lands now: in thread-list mode the list has
- * resolved which thread is active, and that thread's history has loaded.
- * Until then the composer the hooks write to is the one of a mount that is
- * about to be replaced, and the draft goes with it.
+ * resolved which thread is active, that thread's history has loaded, and the
+ * chat's session lane is known (the sign-in provider above has resolved who is
+ * signed in; see `StatewireSessionLane`). Until then the composer the hooks
+ * write to is the one of a mount that is about to be replaced, and the draft
+ * goes with it, or a send would go into a parked lane that refuses it unsent.
  *
  * Deliberately not the socket status: a never-started chat sits in
  * `standby` until its first send and must still take a prefill.

package/dist/composer/composer-handoff.js

@@ -2,9 +2,41 @@ import { useCallback, createContext, useContext } from "react";
 import { useAuiState } from "@assistant-ui/react";
 import { athenaDiagnostics } from "../diagnostics/athena-diagnostics.js";
 import { AthenaSdkError } from "../diagnostics/errors.js";
+import { useStatewireSessionLanePending } from "../runtime/statewire-session-lane.js";
 import { useAthenaStatewireThreadList } from "../threads/statewire-thread-list.js";
 function createComposerHandoffStore() {
-  return { pending: [], focusOnNextMirror: false, focusEnd: null, focusOnMount: false };
+  return {
+    pending: [],
+    focusOnNextMirror: false,
+    focusEnd: null,
+    focusOnMount: false,
+    restoredAttachments: /* @__PURE__ */ new Map()
+  };
+}
+function rememberRestoredAttachments({
+  store,
+  threadId,
+  attachments
+}) {
+  if (attachments.length === 0) return;
+  store.restoredAttachments ?? (store.restoredAttachments = /* @__PURE__ */ new Map());
+  const kept = store.restoredAttachments.get(threadId) ?? [];
+  const known = new Set(kept.map((attachment) => attachment.assetId));
+  store.restoredAttachments.set(threadId, [
+    ...kept,
+    ...attachments.filter((attachment) => !known.has(attachment.assetId))
+  ]);
+}
+function takeRestoredAttachments({
+  store,
+  threadId,
+  assetIdsInDraft
+}) {
+  var _a, _b;
+  const kept = (_a = store == null ? void 0 : store.restoredAttachments) == null ? void 0 : _a.get(threadId);
+  if (!kept) return [];
+  (_b = store == null ? void 0 : store.restoredAttachments) == null ? void 0 : _b.delete(threadId);
+  return kept.filter((attachment) => assetIdsInDraft.has(attachment.assetId));
 }
 const ComposerHandoffContext = createContext(null);
 function useComposerHandoffStore() {
@@ -26,7 +58,8 @@ function useComposerReady() {
     var _a;
     return ((_a = s.optional.thread) == null ? void 0 : _a.isLoading) ?? false;
   });
-  return !((list == null ? void 0 : list.isLoading) ?? false) && !threadLoading;
+  const lanePending = useStatewireSessionLanePending();
+  return !((list == null ? void 0 : list.isLoading) ?? false) && !threadLoading && !lanePending;
 }
 function mergeComposerDraft({
   current,
@@ -112,6 +145,8 @@ function clearComposerHandoff({
   store,
   reason
 }) {
+  var _a;
+  (_a = store.restoredAttachments) == null ? void 0 : _a.clear();
   const writes = store.pending;
   if (writes.length === 0) return;
   store.pending = [];
@@ -126,6 +161,8 @@ export {
   focusComposer,
   mergeComposerDraft,
   queueComposerWrite,
+  rememberRestoredAttachments,
+  takeRestoredAttachments,
   useComposerHandoffStore,
   useComposerReady,
   useFocusComposer

package/dist/composer/composer-handoff.js.map

@@ -1 +1 @@
-{"version":3,"file":"composer-handoff.js","sources":["../../src/composer/composer-handoff.ts"],"sourcesContent":["/**\n * Composer handoff: writes to the chat composer from host UI that lives\n * outside `<AthenaChat>` (a sidebar, an agenda card, a workflow button).\n *\n * Two problems it solves for `useAppendToComposer` / `useSendMessage`:\n *\n * 1. A write before the chat is ready is lost. While the thread list is still\n *    resolving the active thread, or the thread's history is still loading,\n *    the composer the hooks write to belongs to a mount that is about to be\n *    replaced (thread-list mode keys the statewire subtree by thread), and\n *    the draft goes with it. The store below lives ABOVE that mount, so a\n *    write made too early waits here and the ready mount drains it.\n * 2. A prefilled draft should put the caret after the text so the user can\n *    keep typing or dictating. The Tiptap editor mirrors runtime text on a\n *    later tick; the `focusOnNextMirror` flag asks it to focus at the end\n *    right after that mirror lands, instead of the host guessing a delay.\n *\n * Every queued write is bound to the statewire thread it was made for and\n * drains only into that thread's mount; a thread switch, an identity change\n * or a provider unmount drops what waits with a `composer_write_dropped`\n * error, never into another user's or another thread's composer.\n */\nimport { createContext, useCallback, useContext } from 'react';\nimport { useAuiState } from '@assistant-ui/react';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport { AthenaSdkError } from '../diagnostics/errors';\nimport { useAthenaStatewireThreadList } from '../threads/statewire-thread-list';\n\n/** The slice of the assistant-ui client the handoff writes to. */\nexport interface ComposerTarget {\n  composer: {\n    getState: () => { text: string };\n    setText: (text: string) => void;\n    send: (options?: { steer?: boolean }) => unknown;\n  };\n}\n\nexport interface ComposerWrite {\n  text: string;\n  /** Replace the draft instead of appending on a new line. */\n  replace: boolean;\n  /** Submit right after writing. */\n  send: boolean;\n  /** Put the caret at the end of the draft once the editor shows it. */\n  focus: boolean;\n  /** The statewire thread the write was made for; it drains only into that thread's mount. */\n  threadId: string | null;\n  /** Settled once the write has been applied (and, for `send`, with the send's outcome). */\n  resolve?: (outcome: Promise<void> | void) => void;\n  /** Settled with `composer_write_dropped` when the write can no longer land. */\n  reject?: (error: AthenaSdkError) => void;\n}\n\nexport interface ComposerHandoffStore {\n  /** Writes waiting for a ready composer, oldest first. Adjacent plain appends fold together. */\n  pending: ComposerWrite[];\n  /** Set by a `focus` write; the editor consumes it after mirroring the draft. */\n  focusOnNextMirror: boolean;\n  /** Registered by the mounted editor: place the caret at the end of the draft. */\n  focusEnd: (() => void) | null;\n  /** Set by `useFocusComposer` before the editor mounted; the editor consumes it when it does. */\n  focusOnMount: boolean;\n}\n\nexport function createComposerHandoffStore(): ComposerHandoffStore {\n  return { pending: [], focusOnNextMirror: false, focusEnd: null, focusOnMount: false };\n}\n\nexport const ComposerHandoffContext = createContext<ComposerHandoffStore | null>(null);\n\n/** The provider's handoff store, or null outside `AthenaProvider`. */\nexport function useComposerHandoffStore(): ComposerHandoffStore | null {\n  return useContext(ComposerHandoffContext);\n}\n\n/**\n * Puts the caret at the end of the composer's draft and leaves the draft as it is; asked before the\n * editor has mounted, it focuses the editor as it mounts. For a host that shows the chat again and\n * wants typing to land in it (a launcher window a shortcut brings back).\n */\nexport function useFocusComposer(): () => void {\n  const store = useComposerHandoffStore();\n  return useCallback(() => {\n    if (store) focusComposer({ store });\n  }, [store]);\n}\n\n/** The caret to the end of the draft now, or, with no editor mounted yet, as one mounts. */\nexport function focusComposer({ store }: { store: ComposerHandoffStore }): void {\n  if (store.focusEnd) store.focusEnd();\n  else store.focusOnMount = true;\n}\n\n/**\n * Whether a composer write lands now: in thread-list mode the list has\n * resolved which thread is active, and that thread's history has loaded.\n * Until then the composer the hooks write to is the one of a mount that is\n * about to be replaced, and the draft goes with it.\n *\n * Deliberately not the socket status: a never-started chat sits in\n * `standby` until its first send and must still take a prefill.\n */\nexport function useComposerReady(): boolean {\n  const list = useAthenaStatewireThreadList();\n  const threadLoading = useAuiState((s) => s.optional.thread?.isLoading ?? false);\n  return !(list?.isLoading ?? false) && !threadLoading;\n}\n\n/** The draft after `write`: `replace` (or an empty draft) takes the text as is. */\nexport function mergeComposerDraft({\n  current,\n  write,\n}: {\n  current: string;\n  write: Pick<ComposerWrite, 'text' | 'replace'>;\n}): string {\n  if (write.replace || !current) return write.text;\n  return `${current}\\n${write.text}`;\n}\n\n/**\n * Write into the live composer. Returns the send's outcome for a `send`\n * write so callers can await it.\n */\nexport function applyComposerWrite({\n  target,\n  store,\n  write,\n}: {\n  target: ComposerTarget;\n  store: ComposerHandoffStore | null;\n  write: ComposerWrite;\n}): Promise<void> | void {\n  const current = target.composer.getState().text ?? '';\n  const next = mergeComposerDraft({ current, write });\n  target.composer.setText(next);\n  if (write.focus && store) {\n    // An unchanged draft never re-mirrors, so focus at once; otherwise the\n    // editor focuses itself right after it has shown the new text.\n    if (next === current) store.focusEnd?.();\n    else store.focusOnNextMirror = true;\n  }\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'debug',\n    data: { phase: 'applied', send: write.send, focus: write.focus, chars: next.length },\n  });\n  if (write.send) {\n    return Promise.resolve(target.composer.send({ steer: false })).then(() => undefined);\n  }\n  return undefined;\n}\n\n/**\n * Hold a write until the composer is ready. Writes keep their order; a plain\n * append folds into a directly preceding plain append for the same thread\n * (one draft, not two), while a replace or a send is kept as its own step so\n * no message is lost and every send settles on its own.\n */\nexport function queueComposerWrite({\n  store,\n  write,\n}: {\n  store: ComposerHandoffStore;\n  write: ComposerWrite;\n}): void {\n  const last = store.pending[store.pending.length - 1];\n  const foldable =\n    last !== undefined &&\n    !last.send &&\n    !write.send &&\n    !write.replace &&\n    last.threadId === write.threadId &&\n    last.resolve === undefined &&\n    write.resolve === undefined;\n  if (foldable) {\n    last.text = mergeComposerDraft({ current: last.text, write });\n    last.focus = last.focus || write.focus;\n  } else {\n    store.pending.push(write);\n  }\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'debug',\n    data: { phase: 'deferred', send: write.send, focus: write.focus, queued: store.pending.length },\n  });\n}\n\nfunction dropWrite({ write, reason }: { write: ComposerWrite; reason: string }): void {\n  const error = new AthenaSdkError({\n    code: 'composer_write_dropped',\n    message: `A composer ${write.send ? 'send' : 'draft'} queued before the chat was ready was dropped: ${reason}.`,\n    hint: 'Make the write again from the chat that is active now.',\n    context: { threadId: write.threadId, send: write.send },\n  });\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'warn',\n    error,\n    data: { phase: 'dropped', send: write.send, reason, threadId: write.threadId },\n  });\n  write.reject?.(error);\n}\n\n/**\n * Deliver the pending writes, in order, into a now-ready composer. A write\n * made for another thread is dropped (rejected), never applied here.\n */\nexport function drainComposerHandoff({\n  store,\n  target,\n  threadId,\n}: {\n  store: ComposerHandoffStore;\n  target: ComposerTarget;\n  /** The statewire thread of the mount that is draining. */\n  threadId: string | null;\n}): void {\n  const writes = store.pending;\n  if (writes.length === 0) return;\n  store.pending = [];\n  for (const write of writes) {\n    if (write.threadId !== null && threadId !== null && write.threadId !== threadId) {\n      dropWrite({ write, reason: `it was made for thread ${write.threadId}, thread ${threadId} is active` });\n      continue;\n    }\n    const outcome = applyComposerWrite({ target, store, write });\n    write.resolve?.(outcome);\n  }\n}\n\n/** Drop every pending write (identity changed, provider unmounted). */\nexport function clearComposerHandoff({\n  store,\n  reason,\n}: {\n  store: ComposerHandoffStore;\n  reason: string;\n}): void {\n  const writes = store.pending;\n  if (writes.length === 0) return;\n  store.pending = [];\n  for (const write of writes) dropWrite({ write, reason });\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"composer-handoff.js","sources":["../../src/composer/composer-handoff.ts"],"sourcesContent":["/**\n * Composer handoff: writes to the chat composer from host UI that lives\n * outside `<AthenaChat>` (a sidebar, an agenda card, a workflow button).\n *\n * Two problems it solves for `useAppendToComposer` / `useSendMessage`:\n *\n * 1. A write before the chat is ready is lost. While the thread list is still\n *    resolving the active thread, or the thread's history is still loading,\n *    the composer the hooks write to belongs to a mount that is about to be\n *    replaced (thread-list mode keys the statewire subtree by thread), and\n *    the draft goes with it. The store below lives ABOVE that mount, so a\n *    write made too early waits here and the ready mount drains it.\n * 2. A prefilled draft should put the caret after the text so the user can\n *    keep typing or dictating. The Tiptap editor mirrors runtime text on a\n *    later tick; the `focusOnNextMirror` flag asks it to focus at the end\n *    right after that mirror lands, instead of the host guessing a delay.\n *\n * Every queued write is bound to the statewire thread it was made for and\n * drains only into that thread's mount; a thread switch, an identity change\n * or a provider unmount drops what waits with a `composer_write_dropped`\n * error, never into another user's or another thread's composer.\n */\nimport { createContext, useCallback, useContext } from 'react';\nimport { useAuiState } from '@assistant-ui/react';\nimport type { ChatOutboxAttachment } from '@athenaintel/agent-runtime';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport { AthenaSdkError } from '../diagnostics/errors';\nimport { useStatewireSessionLanePending } from '../runtime/statewire-session-lane';\nimport { useAthenaStatewireThreadList } from '../threads/statewire-thread-list';\n\n/** The slice of the assistant-ui client the handoff writes to. */\nexport interface ComposerTarget {\n  composer: {\n    getState: () => { text: string };\n    setText: (text: string) => void;\n    send: (options?: { steer?: boolean }) => unknown;\n  };\n}\n\nexport interface ComposerWrite {\n  text: string;\n  /** Replace the draft instead of appending on a new line. */\n  replace: boolean;\n  /** Submit right after writing. */\n  send: boolean;\n  /** Put the caret at the end of the draft once the editor shows it. */\n  focus: boolean;\n  /** The statewire thread the write was made for; it drains only into that thread's mount. */\n  threadId: string | null;\n  /** Settled once the write has been applied (and, for `send`, with the send's outcome). */\n  resolve?: (outcome: Promise<void> | void) => void;\n  /** Settled with `composer_write_dropped` when the write can no longer land. */\n  reject?: (error: AthenaSdkError) => void;\n}\n\nexport interface ComposerHandoffStore {\n  /** Writes waiting for a ready composer, oldest first. Adjacent plain appends fold together. */\n  pending: ComposerWrite[];\n  /** Set by a `focus` write; the editor consumes it after mirroring the draft. */\n  focusOnNextMirror: boolean;\n  /** Registered by the mounted editor: place the caret at the end of the draft. */\n  focusEnd: (() => void) | null;\n  /** Set by `useFocusComposer` before the editor mounted; the editor consumes it when it does. */\n  focusOnMount: boolean;\n  /**\n   * Per thread, the attachments of messages the chat outbox gave back to the composer (Cancel, or\n   * Edit on one that couldn't be sent): files already in Athena, back in the draft as mentions. A\n   * message held again from that draft names those still in it, so the outbox asks Athena about\n   * them again before it goes ({@link rememberRestoredAttachments}, {@link takeRestoredAttachments}).\n   */\n  restoredAttachments?: Map<string, ChatOutboxAttachment[]>;\n}\n\nexport function createComposerHandoffStore(): ComposerHandoffStore {\n  return {\n    pending: [],\n    focusOnNextMirror: false,\n    focusEnd: null,\n    focusOnMount: false,\n    restoredAttachments: new Map(),\n  };\n}\n\n/** A held message given back to `threadId`'s composer: remember the attachments it carried. */\nexport function rememberRestoredAttachments({\n  store,\n  threadId,\n  attachments,\n}: {\n  store: ComposerHandoffStore;\n  threadId: string;\n  attachments: readonly ChatOutboxAttachment[];\n}): void {\n  if (attachments.length === 0) return;\n  store.restoredAttachments ??= new Map();\n  const kept = store.restoredAttachments.get(threadId) ?? [];\n  const known = new Set(kept.map((attachment) => attachment.assetId));\n  store.restoredAttachments.set(threadId, [\n    ...kept,\n    ...attachments.filter((attachment) => !known.has(attachment.assetId)),\n  ]);\n}\n\n/**\n * The remembered attachments of `threadId`'s draft whose mentions it still holds, for the message\n * leaving it now; the composer forgets them all (sent, held again, or removed from the draft).\n */\nexport function takeRestoredAttachments({\n  store,\n  threadId,\n  assetIdsInDraft,\n}: {\n  store: ComposerHandoffStore | null;\n  threadId: string;\n  assetIdsInDraft: ReadonlySet<string>;\n}): ChatOutboxAttachment[] {\n  const kept = store?.restoredAttachments?.get(threadId);\n  if (!kept) return [];\n  store?.restoredAttachments?.delete(threadId);\n  return kept.filter((attachment) => assetIdsInDraft.has(attachment.assetId));\n}\n\nexport const ComposerHandoffContext = createContext<ComposerHandoffStore | null>(null);\n\n/** The provider's handoff store, or null outside `AthenaProvider`. */\nexport function useComposerHandoffStore(): ComposerHandoffStore | null {\n  return useContext(ComposerHandoffContext);\n}\n\n/**\n * Puts the caret at the end of the composer's draft and leaves the draft as it is; asked before the\n * editor has mounted, it focuses the editor as it mounts. For a host that shows the chat again and\n * wants typing to land in it (a launcher window a shortcut brings back).\n */\nexport function useFocusComposer(): () => void {\n  const store = useComposerHandoffStore();\n  return useCallback(() => {\n    if (store) focusComposer({ store });\n  }, [store]);\n}\n\n/** The caret to the end of the draft now, or, with no editor mounted yet, as one mounts. */\nexport function focusComposer({ store }: { store: ComposerHandoffStore }): void {\n  if (store.focusEnd) store.focusEnd();\n  else store.focusOnMount = true;\n}\n\n/**\n * Whether a composer write lands now: in thread-list mode the list has\n * resolved which thread is active, that thread's history has loaded, and the\n * chat's session lane is known (the sign-in provider above has resolved who is\n * signed in; see `StatewireSessionLane`). Until then the composer the hooks\n * write to is the one of a mount that is about to be replaced, and the draft\n * goes with it, or a send would go into a parked lane that refuses it unsent.\n *\n * Deliberately not the socket status: a never-started chat sits in\n * `standby` until its first send and must still take a prefill.\n */\nexport function useComposerReady(): boolean {\n  const list = useAthenaStatewireThreadList();\n  const threadLoading = useAuiState((s) => s.optional.thread?.isLoading ?? false);\n  const lanePending = useStatewireSessionLanePending();\n  return !(list?.isLoading ?? false) && !threadLoading && !lanePending;\n}\n\n/** The draft after `write`: `replace` (or an empty draft) takes the text as is. */\nexport function mergeComposerDraft({\n  current,\n  write,\n}: {\n  current: string;\n  write: Pick<ComposerWrite, 'text' | 'replace'>;\n}): string {\n  if (write.replace || !current) return write.text;\n  return `${current}\\n${write.text}`;\n}\n\n/**\n * Write into the live composer. Returns the send's outcome for a `send`\n * write so callers can await it.\n */\nexport function applyComposerWrite({\n  target,\n  store,\n  write,\n}: {\n  target: ComposerTarget;\n  store: ComposerHandoffStore | null;\n  write: ComposerWrite;\n}): Promise<void> | void {\n  const current = target.composer.getState().text ?? '';\n  const next = mergeComposerDraft({ current, write });\n  target.composer.setText(next);\n  if (write.focus && store) {\n    // An unchanged draft never re-mirrors, so focus at once; otherwise the\n    // editor focuses itself right after it has shown the new text.\n    if (next === current) store.focusEnd?.();\n    else store.focusOnNextMirror = true;\n  }\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'debug',\n    data: { phase: 'applied', send: write.send, focus: write.focus, chars: next.length },\n  });\n  if (write.send) {\n    return Promise.resolve(target.composer.send({ steer: false })).then(() => undefined);\n  }\n  return undefined;\n}\n\n/**\n * Hold a write until the composer is ready. Writes keep their order; a plain\n * append folds into a directly preceding plain append for the same thread\n * (one draft, not two), while a replace or a send is kept as its own step so\n * no message is lost and every send settles on its own.\n */\nexport function queueComposerWrite({\n  store,\n  write,\n}: {\n  store: ComposerHandoffStore;\n  write: ComposerWrite;\n}): void {\n  const last = store.pending[store.pending.length - 1];\n  const foldable =\n    last !== undefined &&\n    !last.send &&\n    !write.send &&\n    !write.replace &&\n    last.threadId === write.threadId &&\n    last.resolve === undefined &&\n    write.resolve === undefined;\n  if (foldable) {\n    last.text = mergeComposerDraft({ current: last.text, write });\n    last.focus = last.focus || write.focus;\n  } else {\n    store.pending.push(write);\n  }\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'debug',\n    data: { phase: 'deferred', send: write.send, focus: write.focus, queued: store.pending.length },\n  });\n}\n\nfunction dropWrite({ write, reason }: { write: ComposerWrite; reason: string }): void {\n  const error = new AthenaSdkError({\n    code: 'composer_write_dropped',\n    message: `A composer ${write.send ? 'send' : 'draft'} queued before the chat was ready was dropped: ${reason}.`,\n    hint: 'Make the write again from the chat that is active now.',\n    context: { threadId: write.threadId, send: write.send },\n  });\n  athenaDiagnostics.emit('composer.handoff', {\n    level: 'warn',\n    error,\n    data: { phase: 'dropped', send: write.send, reason, threadId: write.threadId },\n  });\n  write.reject?.(error);\n}\n\n/**\n * Deliver the pending writes, in order, into a now-ready composer. A write\n * made for another thread is dropped (rejected), never applied here.\n */\nexport function drainComposerHandoff({\n  store,\n  target,\n  threadId,\n}: {\n  store: ComposerHandoffStore;\n  target: ComposerTarget;\n  /** The statewire thread of the mount that is draining. */\n  threadId: string | null;\n}): void {\n  const writes = store.pending;\n  if (writes.length === 0) return;\n  store.pending = [];\n  for (const write of writes) {\n    if (write.threadId !== null && threadId !== null && write.threadId !== threadId) {\n      dropWrite({ write, reason: `it was made for thread ${write.threadId}, thread ${threadId} is active` });\n      continue;\n    }\n    const outcome = applyComposerWrite({ target, store, write });\n    write.resolve?.(outcome);\n  }\n}\n\n/** Drop every pending write (identity changed, provider unmounted). */\nexport function clearComposerHandoff({\n  store,\n  reason,\n}: {\n  store: ComposerHandoffStore;\n  reason: string;\n}): void {\n  // Another identity, or no provider: the attachments given back belong to drafts that are gone.\n  store.restoredAttachments?.clear();\n  const writes = store.pending;\n  if (writes.length === 0) return;\n  store.pending = [];\n  for (const write of writes) dropWrite({ write, reason });\n}\n"],"names":[],"mappings":"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"}

package/dist/composer/useAttachFiles.cjs

@@ -4,6 +4,8 @@ const react = require("react");
 const athenaDiagnostics = require("../diagnostics/athena-diagnostics.cjs");
 const AttachmentContext = require("./AttachmentContext.cjs");
 const useFileUpload = require("./useFileUpload.cjs");
+const useDeepAgentChatOutbox = require("../agent-runtime/src/use-deep-agent-chat-outbox.cjs");
+const OFFLINE_FILE_ATTACH_MESSAGE = "Files can't be attached while Athena can't be reached. Messages you send now go out when it's back — attach the file then.";
 const ATTACH_FAILURE_MESSAGE = {
   paperclip: "Failed to attach the selected files",
   drop: "Failed to attach the dropped files",
@@ -11,10 +13,20 @@ const ATTACH_FAILURE_MESSAGE = {
 };
 function useAttachFiles() {
   const { upload, isUploading, error, clearError } = useFileUpload.useFileUpload();
-  const { addAttachments, setIsUploading } = AttachmentContext.useAttachments();
+  const { addAttachments, setIsUploading, setNotice } = AttachmentContext.useAttachments();
+  const outbox = useDeepAgentChatOutbox.useDeepAgentChatOutboxContext();
   const attachFiles = react.useCallback(
     async (files, source) => {
       if (files.length === 0) return [];
+      if (outbox && !outbox.reachability.get()) {
+        setNotice(OFFLINE_FILE_ATTACH_MESSAGE);
+        athenaDiagnostics.athenaDiagnostics.emit("composer.attachment.refused_offline", {
+          level: "info",
+          data: { source, count: files.length }
+        });
+        return [];
+      }
+      setNotice(null);
       setIsUploading(true);
       try {
         const assets = await upload([...files]);
@@ -32,9 +44,10 @@ function useAttachFiles() {
         setIsUploading(false);
       }
     },
-    [addAttachments, setIsUploading, upload]
+    [addAttachments, outbox, setIsUploading, setNotice, upload]
   );
   return { attachFiles, isUploading, error, clearError };
 }
+exports.OFFLINE_FILE_ATTACH_MESSAGE = OFFLINE_FILE_ATTACH_MESSAGE;
 exports.useAttachFiles = useAttachFiles;
 //# sourceMappingURL=useAttachFiles.cjs.map

package/dist/composer/useAttachFiles.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useAttachFiles.cjs","sources":["../../src/composer/useAttachFiles.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport { useAttachments } from './AttachmentContext';\nimport { useFileUpload, type UploadedAsset } from './useFileUpload';\n\n/** Which intake the files came through — carried on the diagnostics event. */\nexport type AttachFilesSource = 'paperclip' | 'drop' | 'paste';\n\nconst ATTACH_FAILURE_MESSAGE: Record<AttachFilesSource, string> = {\n  paperclip: 'Failed to attach the selected files',\n  drop: 'Failed to attach the dropped files',\n  paste: 'Failed to attach the pasted images',\n};\n\nexport interface UseAttachFilesReturn {\n  /**\n   * Upload files as Athena assets and add them to the attachment pills.\n   * Resolves to the assets attached; a failed upload resolves to `[]` after\n   * recording `composer.attachment.error` on the diagnostics bus (and in\n   * `error`).\n   */\n  attachFiles: (files: readonly File[], source: AttachFilesSource) => Promise<UploadedAsset[]>;\n  /** This intake's own upload in flight. */\n  isUploading: boolean;\n  /** Last failure of this intake, for its own affordance. */\n  error: string | null;\n  clearError: () => void;\n}\n\n/**\n * The one intake path for the attachment pills: the paperclip, the drop zone\n * and the composer's paste all upload through here, so a failure reaches the\n * diagnostics bus the same way and the shared `isUploading` flag — which\n * parks every submit path — is set for exactly the upload's duration.\n */\nexport function useAttachFiles(): UseAttachFilesReturn {\n  const { upload, isUploading, error, clearError } = useFileUpload();\n  const { addAttachments, setIsUploading } = useAttachments();\n\n  const attachFiles = useCallback(\n    async (files: readonly File[], source: AttachFilesSource): Promise<UploadedAsset[]> => {\n      if (files.length === 0) return [];\n      setIsUploading(true);\n      try {\n        const assets = await upload([...files]);\n        if (assets.length > 0) addAttachments(assets);\n        return assets;\n      } catch (error) {\n        athenaDiagnostics.error(\n          'composer.attachment.error',\n          error,\n          { code: 'attachment_failed', message: ATTACH_FAILURE_MESSAGE[source] },\n          { source, count: files.length },\n        );\n        return [];\n      } finally {\n        setIsUploading(false);\n      }\n    },\n    [addAttachments, setIsUploading, upload],\n  );\n\n  return { attachFiles, isUploading, error, clearError };\n}\n"],"names":["useFileUpload","useAttachments","useCallback","error","athenaDiagnostics"],"mappings":";;;;;;AAQA,MAAM,yBAA4D;AAAA,EAChE,WAAW;AAAA,EACX,MAAM;AAAA,EACN,OAAO;AACT;AAuBO,SAAS,iBAAuC;AACrD,QAAM,EAAE,QAAQ,aAAa,OAAO,WAAA,IAAeA,cAAAA,cAAA;AACnD,QAAM,EAAE,gBAAgB,eAAA,IAAmBC,iCAAA;AAE3C,QAAM,cAAcC,MAAAA;AAAAA,IAClB,OAAO,OAAwB,WAAwD;AACrF,UAAI,MAAM,WAAW,EAAG,QAAO,CAAA;AAC/B,qBAAe,IAAI;AACnB,UAAI;AACF,cAAM,SAAS,MAAM,OAAO,CAAC,GAAG,KAAK,CAAC;AACtC,YAAI,OAAO,SAAS,EAAG,gBAAe,MAAM;AAC5C,eAAO;AAAA,MACT,SAASC,QAAO;AACdC,0BAAAA,kBAAkB;AAAA,UAChB;AAAA,UACAD;AAAAA,UACA,EAAE,MAAM,qBAAqB,SAAS,uBAAuB,MAAM,EAAA;AAAA,UACnE,EAAE,QAAQ,OAAO,MAAM,OAAA;AAAA,QAAO;AAEhC,eAAO,CAAA;AAAA,MACT,UAAA;AACE,uBAAe,KAAK;AAAA,MACtB;AAAA,IACF;AAAA,IACA,CAAC,gBAAgB,gBAAgB,MAAM;AAAA,EAAA;AAGzC,SAAO,EAAE,aAAa,aAAa,OAAO,WAAA;AAC5C;;"}
+{"version":3,"file":"useAttachFiles.cjs","sources":["../../src/composer/useAttachFiles.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { useDeepAgentChatOutboxContext } from '@athenaintel/agent-runtime';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport { useAttachments } from './AttachmentContext';\nimport { useFileUpload, type UploadedAsset } from './useFileUpload';\n\n/**\n * What the composer says when a file is picked, pasted or dropped while Athena can't be reached\n * (the same words as Olympus's): the upload cannot happen, and a message sent now waits in the chat\n * outbox with only the files that were already uploaded.\n */\nexport const OFFLINE_FILE_ATTACH_MESSAGE =\n  \"Files can't be attached while Athena can't be reached. Messages you send now go out when it's back — attach the file then.\";\n\n/** Which intake the files came through — carried on the diagnostics event. */\nexport type AttachFilesSource = 'paperclip' | 'drop' | 'paste';\n\nconst ATTACH_FAILURE_MESSAGE: Record<AttachFilesSource, string> = {\n  paperclip: 'Failed to attach the selected files',\n  drop: 'Failed to attach the dropped files',\n  paste: 'Failed to attach the pasted images',\n};\n\nexport interface UseAttachFilesReturn {\n  /**\n   * Upload files as Athena assets and add them to the attachment pills.\n   * Resolves to the assets attached; a failed upload resolves to `[]` after\n   * recording `composer.attachment.error` on the diagnostics bus (and in\n   * `error`).\n   */\n  attachFiles: (files: readonly File[], source: AttachFilesSource) => Promise<UploadedAsset[]>;\n  /** This intake's own upload in flight. */\n  isUploading: boolean;\n  /** Last failure of this intake, for its own affordance. */\n  error: string | null;\n  clearError: () => void;\n}\n\n/**\n * The one intake path for the attachment pills: the paperclip, the drop zone\n * and the composer's paste all upload through here, so a failure reaches the\n * diagnostics bus the same way and the shared `isUploading` flag — which\n * parks every submit path — is set for exactly the upload's duration.\n *\n * While the chat's outbox (a host's `chatOutbox`) says Athena can't be\n * reached, a file is not attached: its upload could only fail, and a message\n * that waits to be sent carries only files already uploaded. The composer\n * says so (`notice`, {@link OFFLINE_FILE_ATTACH_MESSAGE}).\n */\nexport function useAttachFiles(): UseAttachFilesReturn {\n  const { upload, isUploading, error, clearError } = useFileUpload();\n  const { addAttachments, setIsUploading, setNotice } = useAttachments();\n  const outbox = useDeepAgentChatOutboxContext();\n\n  const attachFiles = useCallback(\n    async (files: readonly File[], source: AttachFilesSource): Promise<UploadedAsset[]> => {\n      if (files.length === 0) return [];\n      if (outbox && !outbox.reachability.get()) {\n        setNotice(OFFLINE_FILE_ATTACH_MESSAGE);\n        athenaDiagnostics.emit('composer.attachment.refused_offline', {\n          level: 'info',\n          data: { source, count: files.length },\n        });\n        return [];\n      }\n      setNotice(null);\n      setIsUploading(true);\n      try {\n        const assets = await upload([...files]);\n        if (assets.length > 0) addAttachments(assets);\n        return assets;\n      } catch (error) {\n        athenaDiagnostics.error(\n          'composer.attachment.error',\n          error,\n          { code: 'attachment_failed', message: ATTACH_FAILURE_MESSAGE[source] },\n          { source, count: files.length },\n        );\n        return [];\n      } finally {\n        setIsUploading(false);\n      }\n    },\n    [addAttachments, outbox, setIsUploading, setNotice, upload],\n  );\n\n  return { attachFiles, isUploading, error, clearError };\n}\n"],"names":["useFileUpload","useAttachments","useDeepAgentChatOutboxContext","useCallback","athenaDiagnostics","error"],"mappings":";;;;;;;AAWO,MAAM,8BACX;AAKF,MAAM,yBAA4D;AAAA,EAChE,WAAW;AAAA,EACX,MAAM;AAAA,EACN,OAAO;AACT;AA4BO,SAAS,iBAAuC;AACrD,QAAM,EAAE,QAAQ,aAAa,OAAO,WAAA,IAAeA,cAAAA,cAAA;AACnD,QAAM,EAAE,gBAAgB,gBAAgB,UAAA,IAAcC,kBAAAA,eAAA;AACtD,QAAM,SAASC,uBAAAA,8BAAA;AAEf,QAAM,cAAcC,MAAAA;AAAAA,IAClB,OAAO,OAAwB,WAAwD;AACrF,UAAI,MAAM,WAAW,EAAG,QAAO,CAAA;AAC/B,UAAI,UAAU,CAAC,OAAO,aAAa,OAAO;AACxC,kBAAU,2BAA2B;AACrCC,0BAAAA,kBAAkB,KAAK,uCAAuC;AAAA,UAC5D,OAAO;AAAA,UACP,MAAM,EAAE,QAAQ,OAAO,MAAM,OAAA;AAAA,QAAO,CACrC;AACD,eAAO,CAAA;AAAA,MACT;AACA,gBAAU,IAAI;AACd,qBAAe,IAAI;AACnB,UAAI;AACF,cAAM,SAAS,MAAM,OAAO,CAAC,GAAG,KAAK,CAAC;AACtC,YAAI,OAAO,SAAS,EAAG,gBAAe,MAAM;AAC5C,eAAO;AAAA,MACT,SAASC,QAAO;AACdD,0BAAAA,kBAAkB;AAAA,UAChB;AAAA,UACAC;AAAAA,UACA,EAAE,MAAM,qBAAqB,SAAS,uBAAuB,MAAM,EAAA;AAAA,UACnE,EAAE,QAAQ,OAAO,MAAM,OAAA;AAAA,QAAO;AAEhC,eAAO,CAAA;AAAA,MACT,UAAA;AACE,uBAAe,KAAK;AAAA,MACtB;AAAA,IACF;AAAA,IACA,CAAC,gBAAgB,QAAQ,gBAAgB,WAAW,MAAM;AAAA,EAAA;AAG5D,SAAO,EAAE,aAAa,aAAa,OAAO,WAAA;AAC5C;;;"}

package/dist/composer/useAttachFiles.d.ts

@@ -1,4 +1,10 @@
 import { type UploadedAsset } from './useFileUpload';
+/**
+ * What the composer says when a file is picked, pasted or dropped while Athena can't be reached
+ * (the same words as Olympus's): the upload cannot happen, and a message sent now waits in the chat
+ * outbox with only the files that were already uploaded.
+ */
+export declare const OFFLINE_FILE_ATTACH_MESSAGE = "Files can't be attached while Athena can't be reached. Messages you send now go out when it's back \u2014 attach the file then.";
 /** Which intake the files came through — carried on the diagnostics event. */
 export type AttachFilesSource = 'paperclip' | 'drop' | 'paste';
 export interface UseAttachFilesReturn {
@@ -20,5 +26,10 @@ export interface UseAttachFilesReturn {
  * and the composer's paste all upload through here, so a failure reaches the
  * diagnostics bus the same way and the shared `isUploading` flag — which
  * parks every submit path — is set for exactly the upload's duration.
+ *
+ * While the chat's outbox (a host's `chatOutbox`) says Athena can't be
+ * reached, a file is not attached: its upload could only fail, and a message
+ * that waits to be sent carries only files already uploaded. The composer
+ * says so (`notice`, {@link OFFLINE_FILE_ATTACH_MESSAGE}).
  */
 export declare function useAttachFiles(): UseAttachFilesReturn;

package/dist/composer/useAttachFiles.js

@@ -2,6 +2,8 @@ import { useCallback } from "react";
 import { athenaDiagnostics } from "../diagnostics/athena-diagnostics.js";
 import { useAttachments } from "./AttachmentContext.js";
 import { useFileUpload } from "./useFileUpload.js";
+import { useDeepAgentChatOutboxContext } from "../agent-runtime/src/use-deep-agent-chat-outbox.js";
+const OFFLINE_FILE_ATTACH_MESSAGE = "Files can't be attached while Athena can't be reached. Messages you send now go out when it's back — attach the file then.";
 const ATTACH_FAILURE_MESSAGE = {
   paperclip: "Failed to attach the selected files",
   drop: "Failed to attach the dropped files",
@@ -9,10 +11,20 @@ const ATTACH_FAILURE_MESSAGE = {
 };
 function useAttachFiles() {
   const { upload, isUploading, error, clearError } = useFileUpload();
-  const { addAttachments, setIsUploading } = useAttachments();
+  const { addAttachments, setIsUploading, setNotice } = useAttachments();
+  const outbox = useDeepAgentChatOutboxContext();
   const attachFiles = useCallback(
     async (files, source) => {
       if (files.length === 0) return [];
+      if (outbox && !outbox.reachability.get()) {
+        setNotice(OFFLINE_FILE_ATTACH_MESSAGE);
+        athenaDiagnostics.emit("composer.attachment.refused_offline", {
+          level: "info",
+          data: { source, count: files.length }
+        });
+        return [];
+      }
+      setNotice(null);
       setIsUploading(true);
       try {
         const assets = await upload([...files]);
@@ -30,11 +42,12 @@ function useAttachFiles() {
         setIsUploading(false);
       }
     },
-    [addAttachments, setIsUploading, upload]
+    [addAttachments, outbox, setIsUploading, setNotice, upload]
   );
   return { attachFiles, isUploading, error, clearError };
 }
 export {
+  OFFLINE_FILE_ATTACH_MESSAGE,
   useAttachFiles
 };
 //# sourceMappingURL=useAttachFiles.js.map

package/dist/composer/useAttachFiles.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAttachFiles.js","sources":["../../src/composer/useAttachFiles.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport { useAttachments } from './AttachmentContext';\nimport { useFileUpload, type UploadedAsset } from './useFileUpload';\n\n/** Which intake the files came through — carried on the diagnostics event. */\nexport type AttachFilesSource = 'paperclip' | 'drop' | 'paste';\n\nconst ATTACH_FAILURE_MESSAGE: Record<AttachFilesSource, string> = {\n  paperclip: 'Failed to attach the selected files',\n  drop: 'Failed to attach the dropped files',\n  paste: 'Failed to attach the pasted images',\n};\n\nexport interface UseAttachFilesReturn {\n  /**\n   * Upload files as Athena assets and add them to the attachment pills.\n   * Resolves to the assets attached; a failed upload resolves to `[]` after\n   * recording `composer.attachment.error` on the diagnostics bus (and in\n   * `error`).\n   */\n  attachFiles: (files: readonly File[], source: AttachFilesSource) => Promise<UploadedAsset[]>;\n  /** This intake's own upload in flight. */\n  isUploading: boolean;\n  /** Last failure of this intake, for its own affordance. */\n  error: string | null;\n  clearError: () => void;\n}\n\n/**\n * The one intake path for the attachment pills: the paperclip, the drop zone\n * and the composer's paste all upload through here, so a failure reaches the\n * diagnostics bus the same way and the shared `isUploading` flag — which\n * parks every submit path — is set for exactly the upload's duration.\n */\nexport function useAttachFiles(): UseAttachFilesReturn {\n  const { upload, isUploading, error, clearError } = useFileUpload();\n  const { addAttachments, setIsUploading } = useAttachments();\n\n  const attachFiles = useCallback(\n    async (files: readonly File[], source: AttachFilesSource): Promise<UploadedAsset[]> => {\n      if (files.length === 0) return [];\n      setIsUploading(true);\n      try {\n        const assets = await upload([...files]);\n        if (assets.length > 0) addAttachments(assets);\n        return assets;\n      } catch (error) {\n        athenaDiagnostics.error(\n          'composer.attachment.error',\n          error,\n          { code: 'attachment_failed', message: ATTACH_FAILURE_MESSAGE[source] },\n          { source, count: files.length },\n        );\n        return [];\n      } finally {\n        setIsUploading(false);\n      }\n    },\n    [addAttachments, setIsUploading, upload],\n  );\n\n  return { attachFiles, isUploading, error, clearError };\n}\n"],"names":["error"],"mappings":";;;;AAQA,MAAM,yBAA4D;AAAA,EAChE,WAAW;AAAA,EACX,MAAM;AAAA,EACN,OAAO;AACT;AAuBO,SAAS,iBAAuC;AACrD,QAAM,EAAE,QAAQ,aAAa,OAAO,WAAA,IAAe,cAAA;AACnD,QAAM,EAAE,gBAAgB,eAAA,IAAmB,eAAA;AAE3C,QAAM,cAAc;AAAA,IAClB,OAAO,OAAwB,WAAwD;AACrF,UAAI,MAAM,WAAW,EAAG,QAAO,CAAA;AAC/B,qBAAe,IAAI;AACnB,UAAI;AACF,cAAM,SAAS,MAAM,OAAO,CAAC,GAAG,KAAK,CAAC;AACtC,YAAI,OAAO,SAAS,EAAG,gBAAe,MAAM;AAC5C,eAAO;AAAA,MACT,SAASA,QAAO;AACd,0BAAkB;AAAA,UAChB;AAAA,UACAA;AAAAA,UACA,EAAE,MAAM,qBAAqB,SAAS,uBAAuB,MAAM,EAAA;AAAA,UACnE,EAAE,QAAQ,OAAO,MAAM,OAAA;AAAA,QAAO;AAEhC,eAAO,CAAA;AAAA,MACT,UAAA;AACE,uBAAe,KAAK;AAAA,MACtB;AAAA,IACF;AAAA,IACA,CAAC,gBAAgB,gBAAgB,MAAM;AAAA,EAAA;AAGzC,SAAO,EAAE,aAAa,aAAa,OAAO,WAAA;AAC5C;"}
+{"version":3,"file":"useAttachFiles.js","sources":["../../src/composer/useAttachFiles.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { useDeepAgentChatOutboxContext } from '@athenaintel/agent-runtime';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport { useAttachments } from './AttachmentContext';\nimport { useFileUpload, type UploadedAsset } from './useFileUpload';\n\n/**\n * What the composer says when a file is picked, pasted or dropped while Athena can't be reached\n * (the same words as Olympus's): the upload cannot happen, and a message sent now waits in the chat\n * outbox with only the files that were already uploaded.\n */\nexport const OFFLINE_FILE_ATTACH_MESSAGE =\n  \"Files can't be attached while Athena can't be reached. Messages you send now go out when it's back — attach the file then.\";\n\n/** Which intake the files came through — carried on the diagnostics event. */\nexport type AttachFilesSource = 'paperclip' | 'drop' | 'paste';\n\nconst ATTACH_FAILURE_MESSAGE: Record<AttachFilesSource, string> = {\n  paperclip: 'Failed to attach the selected files',\n  drop: 'Failed to attach the dropped files',\n  paste: 'Failed to attach the pasted images',\n};\n\nexport interface UseAttachFilesReturn {\n  /**\n   * Upload files as Athena assets and add them to the attachment pills.\n   * Resolves to the assets attached; a failed upload resolves to `[]` after\n   * recording `composer.attachment.error` on the diagnostics bus (and in\n   * `error`).\n   */\n  attachFiles: (files: readonly File[], source: AttachFilesSource) => Promise<UploadedAsset[]>;\n  /** This intake's own upload in flight. */\n  isUploading: boolean;\n  /** Last failure of this intake, for its own affordance. */\n  error: string | null;\n  clearError: () => void;\n}\n\n/**\n * The one intake path for the attachment pills: the paperclip, the drop zone\n * and the composer's paste all upload through here, so a failure reaches the\n * diagnostics bus the same way and the shared `isUploading` flag — which\n * parks every submit path — is set for exactly the upload's duration.\n *\n * While the chat's outbox (a host's `chatOutbox`) says Athena can't be\n * reached, a file is not attached: its upload could only fail, and a message\n * that waits to be sent carries only files already uploaded. The composer\n * says so (`notice`, {@link OFFLINE_FILE_ATTACH_MESSAGE}).\n */\nexport function useAttachFiles(): UseAttachFilesReturn {\n  const { upload, isUploading, error, clearError } = useFileUpload();\n  const { addAttachments, setIsUploading, setNotice } = useAttachments();\n  const outbox = useDeepAgentChatOutboxContext();\n\n  const attachFiles = useCallback(\n    async (files: readonly File[], source: AttachFilesSource): Promise<UploadedAsset[]> => {\n      if (files.length === 0) return [];\n      if (outbox && !outbox.reachability.get()) {\n        setNotice(OFFLINE_FILE_ATTACH_MESSAGE);\n        athenaDiagnostics.emit('composer.attachment.refused_offline', {\n          level: 'info',\n          data: { source, count: files.length },\n        });\n        return [];\n      }\n      setNotice(null);\n      setIsUploading(true);\n      try {\n        const assets = await upload([...files]);\n        if (assets.length > 0) addAttachments(assets);\n        return assets;\n      } catch (error) {\n        athenaDiagnostics.error(\n          'composer.attachment.error',\n          error,\n          { code: 'attachment_failed', message: ATTACH_FAILURE_MESSAGE[source] },\n          { source, count: files.length },\n        );\n        return [];\n      } finally {\n        setIsUploading(false);\n      }\n    },\n    [addAttachments, outbox, setIsUploading, setNotice, upload],\n  );\n\n  return { attachFiles, isUploading, error, clearError };\n}\n"],"names":["error"],"mappings":";;;;;AAWO,MAAM,8BACX;AAKF,MAAM,yBAA4D;AAAA,EAChE,WAAW;AAAA,EACX,MAAM;AAAA,EACN,OAAO;AACT;AA4BO,SAAS,iBAAuC;AACrD,QAAM,EAAE,QAAQ,aAAa,OAAO,WAAA,IAAe,cAAA;AACnD,QAAM,EAAE,gBAAgB,gBAAgB,UAAA,IAAc,eAAA;AACtD,QAAM,SAAS,8BAAA;AAEf,QAAM,cAAc;AAAA,IAClB,OAAO,OAAwB,WAAwD;AACrF,UAAI,MAAM,WAAW,EAAG,QAAO,CAAA;AAC/B,UAAI,UAAU,CAAC,OAAO,aAAa,OAAO;AACxC,kBAAU,2BAA2B;AACrC,0BAAkB,KAAK,uCAAuC;AAAA,UAC5D,OAAO;AAAA,UACP,MAAM,EAAE,QAAQ,OAAO,MAAM,OAAA;AAAA,QAAO,CACrC;AACD,eAAO,CAAA;AAAA,MACT;AACA,gBAAU,IAAI;AACd,qBAAe,IAAI;AACnB,UAAI;AACF,cAAM,SAAS,MAAM,OAAO,CAAC,GAAG,KAAK,CAAC;AACtC,YAAI,OAAO,SAAS,EAAG,gBAAe,MAAM;AAC5C,eAAO;AAAA,MACT,SAASA,QAAO;AACd,0BAAkB;AAAA,UAChB;AAAA,UACAA;AAAAA,UACA,EAAE,MAAM,qBAAqB,SAAS,uBAAuB,MAAM,EAAA;AAAA,UACnE,EAAE,QAAQ,OAAO,MAAM,OAAA;AAAA,QAAO;AAEhC,eAAO,CAAA;AAAA,MACT,UAAA;AACE,uBAAe,KAAK;AAAA,MACtB;AAAA,IACF;AAAA,IACA,CAAC,gBAAgB,QAAQ,gBAAgB,WAAW,MAAM;AAAA,EAAA;AAG5D,SAAO,EAAE,aAAa,aAAa,OAAO,WAAA;AAC5C;"}