@assistant-ui/react 0.15.26 → 0.15.27

package/dist/primitives/composer/ComposerAttachmentDropzone.js.map

@@ -1 +1 @@
-{"version":3,"file":"ComposerAttachmentDropzone.js","names":["forwardRef","useCallback","useEffect","useState","ReactElement","isValidElement","composeEventHandlers","Slot","React","useAui","renderSlot","ComposerPrimitiveAttachmentDropzone","Element","HTMLDivElement","Props","HTMLAttributes","asChild","render","disabled","children","rest","ref","isDragging","setIsDragging","aui","handleDragEnterCapture","e","DragEvent","dataTransfer","types","includes","preventDefault","thread","getState","capabilities","attachments","dropEffect","handleDragOverCapture","handleDragLeaveCapture","next","relatedTarget","Node","currentTarget","contains","handleDrop","files","Array","from","length","Promise","all","map","file","composer","addAttachment","mergedProps","onDragEnterCapture","onDragOverCapture","onDragLeaveCapture","onDropCapture","Comp","Root","displayName"],"sources":["../../../src/primitives/composer/ComposerAttachmentDropzone.tsx"],"sourcesContent":["\"use client\";\n\nimport {\n  forwardRef,\n  useCallback,\n  useEffect,\n  useState,\n  type ReactElement,\n  isValidElement,\n} from \"react\";\n\nimport { composeEventHandlers } from \"radix-ui/internal\";\nimport { Slot } from \"radix-ui\";\nimport type React from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport { renderSlot } from \"../../utils/Primitive\";\n\nexport namespace ComposerPrimitiveAttachmentDropzone {\n  export type Element = HTMLDivElement;\n  export type Props = React.HTMLAttributes<HTMLDivElement> & {\n    asChild?: boolean | undefined;\n    render?: ReactElement | undefined;\n    disabled?: boolean | undefined;\n  };\n}\n\nexport const ComposerPrimitiveAttachmentDropzone = forwardRef<\n  HTMLDivElement,\n  ComposerPrimitiveAttachmentDropzone.Props\n>(({ disabled, asChild = false, render, children, ...rest }, ref) => {\n  const [isDragging, setIsDragging] = useState(false);\n  const aui = useAui();\n\n  useEffect(() => {\n    if (!disabled) return;\n    // Disabled handlers cannot clear the latch, so reset it when the enabled period ends.\n    // eslint-disable-next-line react-hooks/set-state-in-effect\n    setIsDragging(false);\n  }, [disabled]);\n\n  // An unprevented file drop navigates the tab to the file, so file drags are\n  // claimed via preventDefault even when the runtime does not support attachments.\n  const handleDragEnterCapture = useCallback(\n    (e: React.DragEvent) => {\n      if (!e.dataTransfer.types.includes(\"Files\")) return;\n      e.preventDefault();\n      if (disabled || !aui.thread.getState().capabilities.attachments) {\n        e.dataTransfer.dropEffect = \"none\";\n        return;\n      }\n      setIsDragging(true);\n    },\n    [disabled, aui],\n  );\n\n  const handleDragOverCapture = useCallback(\n    (e: React.DragEvent) => {\n      if (!e.dataTransfer.types.includes(\"Files\")) return;\n      e.preventDefault();\n      if (disabled || !aui.thread.getState().capabilities.attachments) {\n        e.dataTransfer.dropEffect = \"none\";\n        return;\n      }\n      if (!isDragging) setIsDragging(true);\n    },\n    [disabled, isDragging, aui],\n  );\n\n  const handleDragLeaveCapture = useCallback(\n    (e: React.DragEvent) => {\n      if (disabled) return;\n      e.preventDefault();\n      const next = e.relatedTarget as Node | null;\n      if (next && e.currentTarget.contains(next)) {\n        return;\n      }\n      setIsDragging(false);\n    },\n    [disabled],\n  );\n\n  const handleDrop = useCallback(\n    async (e: React.DragEvent) => {\n      setIsDragging(false);\n      if (!e.dataTransfer.types.includes(\"Files\")) return;\n      e.preventDefault();\n      if (disabled) return;\n      const files = Array.from(e.dataTransfer.files);\n      if (!aui.thread.getState().capabilities.attachments || files.length === 0)\n        return;\n      await Promise.all(\n        files.map(async (file) => {\n          try {\n            await aui.composer.addAttachment(file);\n          } catch {\n            // The composer runtime emits composer.attachmentAddError before rejecting;\n            // the readonly and empty-thread stubs only throw.\n          }\n        }),\n      );\n    },\n    [disabled, aui],\n  );\n\n  const mergedProps = {\n    ...(isDragging && !disabled ? { \"data-dragging\": \"true\" } : null),\n    ...rest,\n    onDragEnterCapture: composeEventHandlers(\n      rest.onDragEnterCapture,\n      handleDragEnterCapture,\n    ),\n    onDragOverCapture: composeEventHandlers(\n      rest.onDragOverCapture,\n      handleDragOverCapture,\n    ),\n    onDragLeaveCapture: composeEventHandlers(\n      rest.onDragLeaveCapture,\n      handleDragLeaveCapture,\n    ),\n    onDropCapture: composeEventHandlers(rest.onDropCapture, handleDrop),\n    ref,\n  };\n\n  if (render && isValidElement(render)) {\n    return renderSlot(render, children, mergedProps);\n  }\n\n  const Comp = asChild ? Slot.Root : \"div\";\n  return <Comp {...mergedProps}>{children}</Comp>;\n});\n\nComposerPrimitiveAttachmentDropzone.displayName =\n  \"ComposerPrimitive.AttachmentDropzone\";\n"],"mappings":";;;;;;;;AA0BA,MAAaW,sCAAsCX,YAGhD,EAAEkB,UAAUF,UAAU,OAAOC,QAAQE,UAAU,GAAGC,QAAQC,QAAQ;CACnE,MAAM,CAACC,YAAYC,iBAAiBpB,SAAS,KAAK;CAClD,MAAMqB,MAAMf,OAAO;CAEnBP,gBAAgB;EACd,IAAI,CAACgB,UAAU;EAGfK,cAAc,KAAK;CACrB,GAAG,CAACL,QAAQ,CAAC;CAIb,MAAMO,yBAAyBxB,aAC5ByB,MAAuB;EACtB,IAAI,CAACA,EAAEE,aAAaC,MAAMC,SAAS,OAAO,GAAG;EAC7CJ,EAAEK,eAAe;EACjB,IAAIb,YAAY,CAACM,IAAIQ,OAAOC,SAAS,CAAC,CAACC,aAAaC,aAAa;GAC/DT,EAAEE,aAAaQ,aAAa;GAC5B;EACF;EACAb,cAAc,IAAI;CACpB,GACA,CAACL,UAAUM,GAAG,CAChB;CAEA,MAAMa,wBAAwBpC,aAC3ByB,QAAuB;EACtB,IAAI,CAACA,IAAEE,aAAaC,MAAMC,SAAS,OAAO,GAAG;EAC7CJ,IAAEK,eAAe;EACjB,IAAIb,YAAY,CAACM,IAAIQ,OAAOC,SAAS,CAAC,CAACC,aAAaC,aAAa;GAC/DT,IAAEE,aAAaQ,aAAa;GAC5B;EACF;EACA,IAAI,CAACd,YAAYC,cAAc,IAAI;CACrC,GACA;EAACL;EAAUI;EAAYE;CAAG,CAC5B;CAEA,MAAMc,yBAAyBrC,aAC5ByB,QAAuB;EACtB,IAAIR,UAAU;EACdQ,IAAEK,eAAe;EACjB,MAAMQ,OAAOb,IAAEc;EACf,IAAID,QAAQb,IAAEgB,cAAcC,SAASJ,IAAI,GACvC;EAEFhB,cAAc,KAAK;CACrB,GACA,CAACL,QAAQ,CACX;CAEA,MAAM0B,aAAa3C,YACjB,OAAOyB,QAAuB;EAC5BH,cAAc,KAAK;EACnB,IAAI,CAACG,IAAEE,aAAaC,MAAMC,SAAS,OAAO,GAAG;EAC7CJ,IAAEK,eAAe;EACjB,IAAIb,UAAU;EACd,MAAM2B,QAAQC,MAAMC,KAAKrB,IAAEE,aAAaiB,KAAK;EAC7C,IAAI,CAACrB,IAAIQ,OAAOC,SAAS,CAAC,CAACC,aAAaC,eAAeU,MAAMG,WAAW,GACtE;EACF,MAAMC,QAAQC,IACZL,MAAMM,IAAI,OAAOC,SAAS;GACxB,IAAI;IACF,MAAM5B,IAAI6B,SAASC,cAAcF,IAAI;GACvC,QAAQ,CAEN;EAEJ,CAAC,CACH;CACF,GACA,CAAClC,UAAUM,GAAG,CAChB;CAEA,MAAM+B,cAAc;EAClB,GAAIjC,cAAc,CAACJ,WAAW,EAAE,iBAAiB,OAAO,IAAI;EAC5D,GAAGE;EACHoC,oBAAoBlD,qBAClBc,KAAKoC,oBACL/B,sBACF;EACAgC,mBAAmBnD,qBACjBc,KAAKqC,mBACLpB,qBACF;EACAqB,oBAAoBpD,qBAClBc,KAAKsC,oBACLpB,sBACF;EACAqB,eAAerD,qBAAqBc,KAAKuC,eAAef,UAAU;EAClEvB;CACF;CAEA,IAAIJ,UAAUZ,eAAeY,MAAM,GACjC,OAAOP,WAAWO,QAAQE,UAAUoC,WAAW;CAGjD,MAAMK,OAAO5C,UAAUT,KAAKsD,OAAO;CACnC,OAAO,oBAAC,MAAD;EAAM,GAAIN;EAAcpC;CAAe,CAAA;AAChD,CAAC;AAEDR,oCAAoCmD,cAClC"}
+{"version":3,"file":"ComposerAttachmentDropzone.js","names":["forwardRef","useCallback","useEffect","useState","ReactElement","isValidElement","composeEventHandlers","Slot","React","useAui","useAuiState","renderSlot","ComposerPrimitiveAttachmentDropzone","Element","HTMLDivElement","Props","HTMLAttributes","asChild","render","disabled","children","rest","ref","isDragging","setIsDragging","aui","disabledByThread","s","thread","isDisabled","handleDragEnterCapture","e","DragEvent","dataTransfer","types","includes","preventDefault","getState","capabilities","attachments","dropEffect","handleDragOverCapture","handleDragLeaveCapture","next","relatedTarget","Node","currentTarget","contains","handleDrop","files","Array","from","length","Promise","all","map","file","composer","addAttachment","mergedProps","onDragEnterCapture","onDragOverCapture","onDragLeaveCapture","onDropCapture","Comp","Root","displayName"],"sources":["../../../src/primitives/composer/ComposerAttachmentDropzone.tsx"],"sourcesContent":["\"use client\";\n\nimport {\n  forwardRef,\n  useCallback,\n  useEffect,\n  useState,\n  type ReactElement,\n  isValidElement,\n} from \"react\";\n\nimport { composeEventHandlers } from \"radix-ui/internal\";\nimport { Slot } from \"radix-ui\";\nimport type React from \"react\";\nimport { useAui, useAuiState } from \"@assistant-ui/store\";\nimport { renderSlot } from \"../../utils/Primitive\";\n\nexport namespace ComposerPrimitiveAttachmentDropzone {\n  export type Element = HTMLDivElement;\n  export type Props = React.HTMLAttributes<HTMLDivElement> & {\n    asChild?: boolean | undefined;\n    render?: ReactElement | undefined;\n    disabled?: boolean | undefined;\n  };\n}\n\nexport const ComposerPrimitiveAttachmentDropzone = forwardRef<\n  HTMLDivElement,\n  ComposerPrimitiveAttachmentDropzone.Props\n>(({ disabled, asChild = false, render, children, ...rest }, ref) => {\n  const [isDragging, setIsDragging] = useState(false);\n  const aui = useAui();\n  const disabledByThread = useAuiState((s) => s.thread.isDisabled);\n  const isDisabled = disabled || disabledByThread;\n\n  useEffect(() => {\n    if (!isDisabled) return;\n    // Disabled handlers cannot clear the latch, so reset it when the enabled period ends.\n    // eslint-disable-next-line react-hooks/set-state-in-effect\n    setIsDragging(false);\n  }, [isDisabled]);\n\n  // An unprevented file drop navigates the tab to the file, so file drags are\n  // claimed via preventDefault even when the runtime does not support attachments.\n  const handleDragEnterCapture = useCallback(\n    (e: React.DragEvent) => {\n      if (!e.dataTransfer.types.includes(\"Files\")) return;\n      e.preventDefault();\n      if (isDisabled || !aui.thread.getState().capabilities.attachments) {\n        e.dataTransfer.dropEffect = \"none\";\n        return;\n      }\n      setIsDragging(true);\n    },\n    [isDisabled, aui],\n  );\n\n  const handleDragOverCapture = useCallback(\n    (e: React.DragEvent) => {\n      if (!e.dataTransfer.types.includes(\"Files\")) return;\n      e.preventDefault();\n      if (isDisabled || !aui.thread.getState().capabilities.attachments) {\n        e.dataTransfer.dropEffect = \"none\";\n        return;\n      }\n      if (!isDragging) setIsDragging(true);\n    },\n    [isDisabled, isDragging, aui],\n  );\n\n  const handleDragLeaveCapture = useCallback(\n    (e: React.DragEvent) => {\n      if (isDisabled) return;\n      e.preventDefault();\n      const next = e.relatedTarget as Node | null;\n      if (next && e.currentTarget.contains(next)) {\n        return;\n      }\n      setIsDragging(false);\n    },\n    [isDisabled],\n  );\n\n  const handleDrop = useCallback(\n    async (e: React.DragEvent) => {\n      setIsDragging(false);\n      if (!e.dataTransfer.types.includes(\"Files\")) return;\n      e.preventDefault();\n      if (isDisabled) return;\n      const files = Array.from(e.dataTransfer.files);\n      if (!aui.thread.getState().capabilities.attachments || files.length === 0)\n        return;\n      await Promise.all(\n        files.map(async (file) => {\n          try {\n            await aui.composer.addAttachment(file);\n          } catch {\n            // The composer runtime emits composer.attachmentAddError before rejecting;\n            // the readonly and empty-thread stubs only throw.\n          }\n        }),\n      );\n    },\n    [isDisabled, aui],\n  );\n\n  const mergedProps = {\n    ...(isDragging && !isDisabled ? { \"data-dragging\": \"true\" } : null),\n    ...rest,\n    onDragEnterCapture: composeEventHandlers(\n      rest.onDragEnterCapture,\n      handleDragEnterCapture,\n    ),\n    onDragOverCapture: composeEventHandlers(\n      rest.onDragOverCapture,\n      handleDragOverCapture,\n    ),\n    onDragLeaveCapture: composeEventHandlers(\n      rest.onDragLeaveCapture,\n      handleDragLeaveCapture,\n    ),\n    onDropCapture: composeEventHandlers(rest.onDropCapture, handleDrop),\n    ref,\n  };\n\n  if (render && isValidElement(render)) {\n    return renderSlot(render, children, mergedProps);\n  }\n\n  const Comp = asChild ? Slot.Root : \"div\";\n  return <Comp {...mergedProps}>{children}</Comp>;\n});\n\nComposerPrimitiveAttachmentDropzone.displayName =\n  \"ComposerPrimitive.AttachmentDropzone\";\n"],"mappings":";;;;;;;;AA0BA,MAAaY,sCAAsCZ,YAGhD,EAAEmB,UAAUF,UAAU,OAAOC,QAAQE,UAAU,GAAGC,QAAQC,QAAQ;CACnE,MAAM,CAACC,YAAYC,iBAAiBrB,SAAS,KAAK;CAClD,MAAMsB,MAAMhB,OAAO;CACnB,MAAMiB,mBAAmBhB,aAAaiB,MAAMA,EAAEC,OAAOC,UAAU;CAC/D,MAAMA,aAAaV,YAAYO;CAE/BxB,gBAAgB;EACd,IAAI,CAAC2B,YAAY;EAGjBL,cAAc,KAAK;CACrB,GAAG,CAACK,UAAU,CAAC;CAIf,MAAMC,yBAAyB7B,aAC5B8B,MAAuB;EACtB,IAAI,CAACA,EAAEE,aAAaC,MAAMC,SAAS,OAAO,GAAG;EAC7CJ,EAAEK,eAAe;EACjB,IAAIP,cAAc,CAACJ,IAAIG,OAAOS,SAAS,CAAC,CAACC,aAAaC,aAAa;GACjER,EAAEE,aAAaO,aAAa;GAC5B;EACF;EACAhB,cAAc,IAAI;CACpB,GACA,CAACK,YAAYJ,GAAG,CAClB;CAEA,MAAMgB,wBAAwBxC,aAC3B8B,QAAuB;EACtB,IAAI,CAACA,IAAEE,aAAaC,MAAMC,SAAS,OAAO,GAAG;EAC7CJ,IAAEK,eAAe;EACjB,IAAIP,cAAc,CAACJ,IAAIG,OAAOS,SAAS,CAAC,CAACC,aAAaC,aAAa;GACjER,IAAEE,aAAaO,aAAa;GAC5B;EACF;EACA,IAAI,CAACjB,YAAYC,cAAc,IAAI;CACrC,GACA;EAACK;EAAYN;EAAYE;CAAG,CAC9B;CAEA,MAAMiB,yBAAyBzC,aAC5B8B,QAAuB;EACtB,IAAIF,YAAY;EAChBE,IAAEK,eAAe;EACjB,MAAMO,OAAOZ,IAAEa;EACf,IAAID,QAAQZ,IAAEe,cAAcC,SAASJ,IAAI,GACvC;EAEFnB,cAAc,KAAK;CACrB,GACA,CAACK,UAAU,CACb;CAEA,MAAMmB,aAAa/C,YACjB,OAAO8B,QAAuB;EAC5BP,cAAc,KAAK;EACnB,IAAI,CAACO,IAAEE,aAAaC,MAAMC,SAAS,OAAO,GAAG;EAC7CJ,IAAEK,eAAe;EACjB,IAAIP,YAAY;EAChB,MAAMoB,QAAQC,MAAMC,KAAKpB,IAAEE,aAAagB,KAAK;EAC7C,IAAI,CAACxB,IAAIG,OAAOS,SAAS,CAAC,CAACC,aAAaC,eAAeU,MAAMG,WAAW,GACtE;EACF,MAAMC,QAAQC,IACZL,MAAMM,IAAI,OAAOC,SAAS;GACxB,IAAI;IACF,MAAM/B,IAAIgC,SAASC,cAAcF,IAAI;GACvC,QAAQ,CAEN;EAEJ,CAAC,CACH;CACF,GACA,CAAC3B,YAAYJ,GAAG,CAClB;CAEA,MAAMkC,cAAc;EAClB,GAAIpC,cAAc,CAACM,aAAa,EAAE,iBAAiB,OAAO,IAAI;EAC9D,GAAGR;EACHuC,oBAAoBtD,qBAClBe,KAAKuC,oBACL9B,sBACF;EACA+B,mBAAmBvD,qBACjBe,KAAKwC,mBACLpB,qBACF;EACAqB,oBAAoBxD,qBAClBe,KAAKyC,oBACLpB,sBACF;EACAqB,eAAezD,qBAAqBe,KAAK0C,eAAef,UAAU;EAClE1B;CACF;CAEA,IAAIJ,UAAUb,eAAea,MAAM,GACjC,OAAOP,WAAWO,QAAQE,UAAUuC,WAAW;CAGjD,MAAMK,OAAO/C,UAAUV,KAAK0D,OAAO;CACnC,OAAO,oBAAC,MAAD;EAAM,GAAIN;EAAcvC;CAAe,CAAA;AAChD,CAAC;AAEDR,oCAAoCsD,cAClC"}

package/dist/unstable/useComposerInput.d.ts

@@ -54,6 +54,8 @@ export type Unstable_ComposerInput = {
  *   disabled={isDisabled}
  *   onChange={(e) => setText(e.target.value)}
  *   onKeyDown={(e) => {
+ *     if (e.nativeEvent.isComposing || e.keyCode === 229) return;
+ *
  *     if (e.key === "Enter" && !e.shiftKey && canSend) {
  *       e.preventDefault();
  *       send();

package/dist/unstable/useComposerInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useComposerInput.d.ts","sourceRoot":"","sources":["../../src/unstable/useComposerInput.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EACL,KAAK,uBAAuB,EAI7B,wDAAqD;AAEtD,+GAA+G;AAC/G,MAAM,MAAM,gCAAgC,GAAG;IAC7C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,CAAC;AAEF,+GAA+G;AAC/G,MAAM,MAAM,sBAAsB,GAAG;IACnC,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;;OAGG;IACH,IAAI,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC1C;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,CAAC,EAAE,gCAAgC,GACzC,sBAAsB,CA0BxB;AAED,+GAA+G;AAC/G,MAAM,MAAM,gCAAgC,GAAG,uBAAuB,CAAC;AAEvE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mCAAmC,IAAI,gCAAgC,CAEtF"}
+{"version":3,"file":"useComposerInput.d.ts","sourceRoot":"","sources":["../../src/unstable/useComposerInput.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EACL,KAAK,uBAAuB,EAI7B,wDAAqD;AAEtD,+GAA+G;AAC/G,MAAM,MAAM,gCAAgC,GAAG;IAC7C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,CAAC;AAEF,+GAA+G;AAC/G,MAAM,MAAM,sBAAsB,GAAG;IACnC,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;;OAGG;IACH,IAAI,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC1C;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,CAAC,EAAE,gCAAgC,GACzC,sBAAsB,CA0BxB;AAED,+GAA+G;AAC/G,MAAM,MAAM,gCAAgC,GAAG,uBAAuB,CAAC;AAEvE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mCAAmC,IAAI,gCAAgC,CAEtF"}

package/dist/unstable/useComposerInput.js

@@ -23,6 +23,8 @@ import { flushTapSync } from "@assistant-ui/tap";
 *   disabled={isDisabled}
 *   onChange={(e) => setText(e.target.value)}
 *   onKeyDown={(e) => {
+*     if (e.nativeEvent.isComposing || e.keyCode === 229) return;
+*
 *     if (e.key === "Enter" && !e.shiftKey && canSend) {
 *       e.preventDefault();
 *       send();

package/dist/unstable/useComposerInput.js.map

@@ -1 +1 @@
-{"version":3,"file":"useComposerInput.js","names":["useCallback","useAui","flushTapSync","useComposerSend","ComposerSendOptions","TriggerPopoverAriaProps","useComposerInputDisabled","useComposerInputValue","useTriggerPopoverAriaProps","Unstable_UseComposerInputOptions","disabled","Unstable_ComposerInput","value","setText","text","send","options","isDisabled","canSend","unstable_useComposerInput","aui","composer","getState","isEditing","rawSend","sendDisabled","sendOptions","Unstable_TriggerPopoverAriaProps","unstable_useTriggerPopoverAriaProps"],"sources":["../../src/unstable/useComposerInput.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport { flushTapSync } from \"@assistant-ui/tap\";\nimport { useComposerSend } from \"@assistant-ui/core/react\";\nimport type { ComposerSendOptions } from \"@assistant-ui/core/store\";\nimport {\n  type TriggerPopoverAriaProps,\n  useComposerInputDisabled,\n  useComposerInputValue,\n  useTriggerPopoverAriaProps,\n} from \"../primitives/composer/useComposerInputState\";\n\n/** @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_UseComposerInputOptions = {\n  /**\n   * Disables the input in addition to the composer's own disabled sources\n   * (thread disabled, active dictation). When disabled, `isDisabled` is `true`\n   * and `canSend` is `false`.\n   */\n  disabled?: boolean | undefined;\n};\n\n/** @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_ComposerInput = {\n  /** Current composer text, or `\"\"` when the composer is not editing. */\n  value: string;\n  /**\n   * Writes `text` into the composer, mirroring `ComposerPrimitive.Input`:\n   * a no-op unless the composer is editing; the controlled value stays in\n   * sync within the same tick.\n   */\n  setText(text: string): void;\n  /**\n   * Sends the current message when `canSend` is `true`; otherwise a no-op.\n   * Accepts the same options as the composer send action.\n   */\n  send(options?: ComposerSendOptions): void;\n  /**\n   * Whether the input is disabled, combining the `disabled` option with the\n   * composer's own disabled sources (thread disabled, active dictation).\n   */\n  isDisabled: boolean;\n  /**\n   * Whether a send is currently available. Matches `ComposerPrimitive.Send`\n   * gating (non-empty editing composer, not running without queue support) and\n   * is additionally `false` while `isDisabled`.\n   */\n  canSend: boolean;\n};\n\n/**\n * Headless bridge to the composer's text value and send action, for building a\n * custom composer input without `ComposerPrimitive.Input`. It is a thin bridge,\n * not a second input: it does not own keyboard behavior, autosize, IME or\n * contentEditable sync, paste/drop attachments, focus management, or rich-text\n * state. Spread `unstable_useTriggerPopoverAriaProps()` onto your element for\n * trigger-popover combobox semantics.\n *\n * @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release.\n *\n * @example\n * ```tsx\n * const { value, setText, send, isDisabled, canSend } = unstable_useComposerInput();\n * <textarea\n *   value={value}\n *   disabled={isDisabled}\n *   onChange={(e) => setText(e.target.value)}\n *   onKeyDown={(e) => {\n *     if (e.key === \"Enter\" && !e.shiftKey && canSend) {\n *       e.preventDefault();\n *       send();\n *     }\n *   }}\n * />\n * ```\n */\nexport function unstable_useComposerInput(\n  options?: Unstable_UseComposerInputOptions,\n): Unstable_ComposerInput {\n  const aui = useAui();\n  const value = useComposerInputValue();\n  const isDisabled = useComposerInputDisabled(options?.disabled);\n\n  const setText = useCallback(\n    (text: string) => {\n      if (!aui.composer.getState().isEditing) return;\n      flushTapSync(() => {\n        aui.composer.setText(text);\n      });\n    },\n    [aui],\n  );\n\n  const { send: rawSend, disabled: sendDisabled } = useComposerSend();\n  const canSend = !sendDisabled && !isDisabled;\n  const send = useCallback(\n    (sendOptions?: ComposerSendOptions) => {\n      if (!canSend) return;\n      rawSend(sendOptions);\n    },\n    [canSend, rawSend],\n  );\n\n  return { value, setText, send, isDisabled, canSend };\n}\n\n/** @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_TriggerPopoverAriaProps = TriggerPopoverAriaProps;\n\n/**\n * ARIA combobox attributes for the focused element (typically the composer\n * input) describing the open trigger popover, per the WAI-ARIA editable\n * combobox pattern. Returns an empty object outside a `TriggerPopoverRoot` or\n * when no popover is open. Spread these last so they take precedence over any\n * matching ARIA props you set yourself, mirroring `ComposerPrimitive.Input`.\n *\n * @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release.\n *\n * @example\n * ```tsx\n * const aria = unstable_useTriggerPopoverAriaProps();\n * <textarea {...aria} />\n * ```\n */\nexport function unstable_useTriggerPopoverAriaProps(): Unstable_TriggerPopoverAriaProps {\n  return useTriggerPopoverAriaProps();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8EA,SAAgBmB,0BACdH,SACwB;CACxB,MAAMI,MAAMnB,OAAO;CACnB,MAAMW,QAAQL,sBAAsB;CACpC,MAAMU,aAAaX,yBAAyBU,SAASN,QAAQ;CAE7D,MAAMG,UAAUb,aACbc,SAAiB;EAChB,IAAI,CAACM,IAAIC,SAASC,SAAS,CAAC,CAACC,WAAW;EACxCrB,mBAAmB;GACjBkB,IAAIC,SAASR,QAAQC,IAAI;EAC3B,CAAC;CACH,GACA,CAACM,GAAG,CACN;CAEA,MAAM,EAAEL,MAAMS,SAASd,UAAUe,iBAAiBtB,gBAAgB;CAClE,MAAMe,UAAU,CAACO,gBAAgB,CAACR;CASlC,OAAO;EAAEL;EAAOC;EAASE,MARZf,aACV0B,gBAAsC;GACrC,IAAI,CAACR,SAAS;GACdM,QAAQE,WAAW;EACrB,GACA,CAACR,SAASM,OAAO,CAGMT;EAAME;EAAYC;CAAQ;AACrD;;;;;;;;;;;;;;;;AAoBA,SAAgBU,sCAAwE;CACtF,OAAOpB,2BAA2B;AACpC"}
+{"version":3,"file":"useComposerInput.js","names":["useCallback","useAui","flushTapSync","useComposerSend","ComposerSendOptions","TriggerPopoverAriaProps","useComposerInputDisabled","useComposerInputValue","useTriggerPopoverAriaProps","Unstable_UseComposerInputOptions","disabled","Unstable_ComposerInput","value","setText","text","send","options","isDisabled","canSend","unstable_useComposerInput","aui","composer","getState","isEditing","rawSend","sendDisabled","sendOptions","Unstable_TriggerPopoverAriaProps","unstable_useTriggerPopoverAriaProps"],"sources":["../../src/unstable/useComposerInput.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport { flushTapSync } from \"@assistant-ui/tap\";\nimport { useComposerSend } from \"@assistant-ui/core/react\";\nimport type { ComposerSendOptions } from \"@assistant-ui/core/store\";\nimport {\n  type TriggerPopoverAriaProps,\n  useComposerInputDisabled,\n  useComposerInputValue,\n  useTriggerPopoverAriaProps,\n} from \"../primitives/composer/useComposerInputState\";\n\n/** @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_UseComposerInputOptions = {\n  /**\n   * Disables the input in addition to the composer's own disabled sources\n   * (thread disabled, active dictation). When disabled, `isDisabled` is `true`\n   * and `canSend` is `false`.\n   */\n  disabled?: boolean | undefined;\n};\n\n/** @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_ComposerInput = {\n  /** Current composer text, or `\"\"` when the composer is not editing. */\n  value: string;\n  /**\n   * Writes `text` into the composer, mirroring `ComposerPrimitive.Input`:\n   * a no-op unless the composer is editing; the controlled value stays in\n   * sync within the same tick.\n   */\n  setText(text: string): void;\n  /**\n   * Sends the current message when `canSend` is `true`; otherwise a no-op.\n   * Accepts the same options as the composer send action.\n   */\n  send(options?: ComposerSendOptions): void;\n  /**\n   * Whether the input is disabled, combining the `disabled` option with the\n   * composer's own disabled sources (thread disabled, active dictation).\n   */\n  isDisabled: boolean;\n  /**\n   * Whether a send is currently available. Matches `ComposerPrimitive.Send`\n   * gating (non-empty editing composer, not running without queue support) and\n   * is additionally `false` while `isDisabled`.\n   */\n  canSend: boolean;\n};\n\n/**\n * Headless bridge to the composer's text value and send action, for building a\n * custom composer input without `ComposerPrimitive.Input`. It is a thin bridge,\n * not a second input: it does not own keyboard behavior, autosize, IME or\n * contentEditable sync, paste/drop attachments, focus management, or rich-text\n * state. Spread `unstable_useTriggerPopoverAriaProps()` onto your element for\n * trigger-popover combobox semantics.\n *\n * @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release.\n *\n * @example\n * ```tsx\n * const { value, setText, send, isDisabled, canSend } = unstable_useComposerInput();\n * <textarea\n *   value={value}\n *   disabled={isDisabled}\n *   onChange={(e) => setText(e.target.value)}\n *   onKeyDown={(e) => {\n *     if (e.nativeEvent.isComposing || e.keyCode === 229) return;\n *\n *     if (e.key === \"Enter\" && !e.shiftKey && canSend) {\n *       e.preventDefault();\n *       send();\n *     }\n *   }}\n * />\n * ```\n */\nexport function unstable_useComposerInput(\n  options?: Unstable_UseComposerInputOptions,\n): Unstable_ComposerInput {\n  const aui = useAui();\n  const value = useComposerInputValue();\n  const isDisabled = useComposerInputDisabled(options?.disabled);\n\n  const setText = useCallback(\n    (text: string) => {\n      if (!aui.composer.getState().isEditing) return;\n      flushTapSync(() => {\n        aui.composer.setText(text);\n      });\n    },\n    [aui],\n  );\n\n  const { send: rawSend, disabled: sendDisabled } = useComposerSend();\n  const canSend = !sendDisabled && !isDisabled;\n  const send = useCallback(\n    (sendOptions?: ComposerSendOptions) => {\n      if (!canSend) return;\n      rawSend(sendOptions);\n    },\n    [canSend, rawSend],\n  );\n\n  return { value, setText, send, isDisabled, canSend };\n}\n\n/** @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_TriggerPopoverAriaProps = TriggerPopoverAriaProps;\n\n/**\n * ARIA combobox attributes for the focused element (typically the composer\n * input) describing the open trigger popover, per the WAI-ARIA editable\n * combobox pattern. Returns an empty object outside a `TriggerPopoverRoot` or\n * when no popover is open. Spread these last so they take precedence over any\n * matching ARIA props you set yourself, mirroring `ComposerPrimitive.Input`.\n *\n * @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release.\n *\n * @example\n * ```tsx\n * const aria = unstable_useTriggerPopoverAriaProps();\n * <textarea {...aria} />\n * ```\n */\nexport function unstable_useTriggerPopoverAriaProps(): Unstable_TriggerPopoverAriaProps {\n  return useTriggerPopoverAriaProps();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,SAAgBmB,0BACdH,SACwB;CACxB,MAAMI,MAAMnB,OAAO;CACnB,MAAMW,QAAQL,sBAAsB;CACpC,MAAMU,aAAaX,yBAAyBU,SAASN,QAAQ;CAE7D,MAAMG,UAAUb,aACbc,SAAiB;EAChB,IAAI,CAACM,IAAIC,SAASC,SAAS,CAAC,CAACC,WAAW;EACxCrB,mBAAmB;GACjBkB,IAAIC,SAASR,QAAQC,IAAI;EAC3B,CAAC;CACH,GACA,CAACM,GAAG,CACN;CAEA,MAAM,EAAEL,MAAMS,SAASd,UAAUe,iBAAiBtB,gBAAgB;CAClE,MAAMe,UAAU,CAACO,gBAAgB,CAACR;CASlC,OAAO;EAAEL;EAAOC;EAASE,MARZf,aACV0B,gBAAsC;GACrC,IAAI,CAACR,SAAS;GACdM,QAAQE,WAAW;EACrB,GACA,CAACR,SAASM,OAAO,CAGMT;EAAME;EAAYC;CAAQ;AACrD;;;;;;;;;;;;;;;;AAoBA,SAAgBU,sCAAwE;CACtF,OAAOpB,2BAA2B;AACpC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react",
-  "version": "0.15.26",
+  "version": "0.15.27",
   "description": "Open-source TypeScript/React library for building production-grade AI chat experiences",
   "keywords": [
     "ai",
@@ -55,10 +55,10 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "^0.3.25",
-    "@assistant-ui/store": "^0.3.18",
+    "@assistant-ui/core": "^0.3.26",
+    "@assistant-ui/store": "^0.3.19",
     "@assistant-ui/tap": "^0.9.22",
-    "assistant-cloud": "^0.2.6",
+    "assistant-cloud": "^0.2.7",
     "assistant-stream": "^0.3.49",
     "radix-ui": "^1.7.0",
     "react-textarea-autosize": "^8.5.9",

package/src/index.ts

@@ -586,6 +586,7 @@ export type {
   McpAppsHost,
   McpAppsRemoteHostOptions,
   McpAppToolCallParams,
+  McpAppInitializeParams,
   McpAppBridgeHandlers,
   ToolCallMessagePartMcpMetadata,
 } from "./mcp-apps";

package/src/mcp-apps/McpAppRenderer.test.tsx

@@ -11,6 +11,7 @@ import type {
   McpAppBridgeHandlers,
   McpAppFrameProps,
   McpAppHostContext,
+  McpAppInitializeParams,
   McpAppsHost,
   McpAppsRemoteHostOptions,
 } from "./types";
@@ -229,8 +230,12 @@ describe("McpAppRenderer", () => {
     await waitFor(() => expect(framePropsCalls().length).toBeGreaterThan(0));
     const handlers = framePropsCalls().at(-1)?.handlers;
     expect(handlers?.requestDisplayMode).toBeDefined();
-    handlers?.onInitialized?.();
+    const params: McpAppInitializeParams = {
+      appCapabilities: { availableDisplayModes: ["inline", "fullscreen"] },
+    };
+    handlers?.onInitialized?.(params);
     expect(onInitialized).toHaveBeenCalledOnce();
+    expect(onInitialized).toHaveBeenCalledWith(params);
   });
 
   it("leaves mounted parts alone when renderer options are unchanged", async () => {
@@ -759,7 +764,7 @@ describe("McpAppRenderer", () => {
     await handlers.updateModelContext?.({ text: "context" });
     await handlers.openLink?.({ url: "https://example.com" });
     await handlers.sendMessage?.({ text: "hello" });
-    handlers.onInitialized?.();
+    handlers.onInitialized?.({});
     await handlers.callTool?.({ name: "search" });
     await handlers.readResource?.({ uri: "ui://resource" });
     await handlers.listResources?.();

package/src/mcp-apps/app-frame.test.tsx

@@ -8,7 +8,11 @@ import type {
 } from "../sandbox-host/SandboxHost";
 import type { CreateMcpAppBridgeOptions, McpAppBridge } from "./bridge";
 import type * as BridgeModule from "./bridge";
-import { MCP_APP_MIME_TYPE, type McpAppHostContext } from "./types";
+import {
+  MCP_APP_MIME_TYPE,
+  type McpAppHostContext,
+  type McpAppInitializeParams,
+} from "./types";
 
 const { sandboxHostMock, createMcpAppBridgeMock } = vi.hoisted(() => ({
   sandboxHostMock: vi.fn(),
@@ -272,6 +276,60 @@ describe("McpAppFrame", () => {
     }
   });
 
+  it("forwards initialization metadata to the live handler", () => {
+    let createBridge: SandboxHostProps["createBridge"] | null = null;
+    sandboxHostMock.mockImplementation((props: SandboxHostProps) => {
+      createBridge ??= props.createBridge;
+      return null;
+    });
+    const bridge: McpAppBridge = {
+      onMessage: vi.fn(),
+      dispose: vi.fn(),
+      notifyToolInput: vi.fn(),
+      notifyToolResult: vi.fn(),
+      notifyHostContextChanged: vi.fn(),
+    };
+    createMcpAppBridgeMock.mockReturnValue(bridge);
+    const onInitialized = vi.fn();
+    const view = (handler: typeof onInitialized) => (
+      <McpAppFrame
+        app={{ resourceUri: "ui://example/widget" }}
+        resource={{
+          uri: "ui://example/widget",
+          mimeType: MCP_APP_MIME_TYPE,
+          html: "",
+        }}
+        handlers={{ onInitialized: handler }}
+      />
+    );
+    const rendered = render(view(onInitialized));
+
+    const sandboxBridge = createBridge!(
+      {
+        iframe: document.createElement("iframe"),
+        origin: "https://widget.example",
+        sendMessage: vi.fn(),
+      },
+      { setHeight: vi.fn() },
+    );
+    const options = createMcpAppBridgeMock.mock
+      .calls[0]![0] as CreateMcpAppBridgeOptions;
+    const replacementOnInitialized = vi.fn();
+    const params: McpAppInitializeParams = {
+      protocolVersion: "2026-01-26",
+      appInfo: { name: "example-app", version: "1.2.3" },
+      appCapabilities: { availableDisplayModes: ["inline", "pip"] },
+    };
+
+    rendered.rerender(view(replacementOnInitialized));
+    options.handlers?.onInitialized?.(params);
+
+    expect(onInitialized).not.toHaveBeenCalled();
+    expect(replacementOnInitialized).toHaveBeenCalledOnce();
+    expect(replacementOnInitialized).toHaveBeenCalledWith(params);
+    sandboxBridge.dispose();
+  });
+
   it("disposes the underlying bridge with the sandbox bridge", () => {
     let createBridge: SandboxHostProps["createBridge"] | null = null;
     sandboxHostMock.mockImplementation((props: SandboxHostProps) => {
@@ -350,7 +408,7 @@ describe("McpAppFrame", () => {
     );
     const options = createMcpAppBridgeMock.mock
       .calls[0]![0] as CreateMcpAppBridgeOptions;
-    options.handlers?.onInitialized?.();
+    options.handlers?.onInitialized?.({});
 
     rendered.rerender(
       view({ displayMode: "inline", availableDisplayModes: ["inline", "pip"] }),
@@ -429,7 +487,7 @@ describe("McpAppFrame", () => {
 
     const options = createMcpAppBridgeMock.mock
       .calls[0]![0] as CreateMcpAppBridgeOptions;
-    options.handlers?.onInitialized?.();
+    options.handlers?.onInitialized?.({});
 
     expect(bridge.notifyHostContextChanged).not.toHaveBeenCalled();
 
@@ -474,7 +532,7 @@ describe("McpAppFrame", () => {
     );
     const options = createMcpAppBridgeMock.mock
       .calls[0]![0] as CreateMcpAppBridgeOptions;
-    options.handlers?.onInitialized?.();
+    options.handlers?.onInitialized?.({});
 
     rendered.rerender(view());
     expect(bridge.notifyHostContextChanged).not.toHaveBeenCalled();
@@ -519,7 +577,7 @@ describe("McpAppFrame", () => {
     );
     const options = createMcpAppBridgeMock.mock
       .calls[0]![0] as CreateMcpAppBridgeOptions;
-    options.handlers?.onInitialized?.();
+    options.handlers?.onInitialized?.({});
 
     rendered.rerender(view(new Date(2)));
     expect(bridge.notifyHostContextChanged).toHaveBeenCalledTimes(1);
@@ -565,7 +623,7 @@ describe("McpAppFrame", () => {
     );
     const options = createMcpAppBridgeMock.mock
       .calls[0]![0] as CreateMcpAppBridgeOptions;
-    options.handlers?.onInitialized?.();
+    options.handlers?.onInitialized?.({});
 
     rendered.rerender(view({}));
     expect(bridge.notifyHostContextChanged).not.toHaveBeenCalled();

package/src/mcp-apps/app-frame.tsx

@@ -143,9 +143,9 @@ function buildLiveHandlers(
     lifecycle.onSizeChange(p);
     live()?.onSizeChange?.(p);
   };
-  out.onInitialized = () => {
+  out.onInitialized = (params) => {
     lifecycle.onInitialized();
-    live()?.onInitialized?.();
+    live()?.onInitialized?.(params);
   };
   out.onRequestTeardown = (p) => live()?.onRequestTeardown?.(p);
   out.onLog = (p) => live()?.onLog?.(p);

package/src/mcp-apps/bridge.test.ts

@@ -197,6 +197,160 @@ describe("createMcpAppBridge", () => {
     bridge.dispose();
   });
 
+  it("passes view initialization metadata to onInitialized", () => {
+    const { frame } = makeFrame();
+    const onInitialized = vi.fn();
+    const bridge = createMcpAppBridge({ frame, handlers: { onInitialized } });
+    const params = {
+      protocolVersion: "2026-01-26",
+      appInfo: { name: "example-app", version: "1.2.3" },
+      appCapabilities: {
+        availableDisplayModes: ["inline", "fullscreen"],
+        tools: { listChanged: true },
+      },
+    };
+
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "ui/initialize",
+      params,
+    });
+    expect(onInitialized).not.toHaveBeenCalled();
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+    });
+
+    expect(onInitialized).toHaveBeenCalledOnce();
+    expect(onInitialized).toHaveBeenCalledWith(params);
+    bridge.dispose();
+  });
+
+  it("omits malformed initialization fields and keeps the protocol fallback", async () => {
+    const { frame, captured } = makeFrame();
+    const onInitialized = vi.fn();
+    const bridge = createMcpAppBridge({ frame, handlers: { onInitialized } });
+
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "ui/initialize",
+      params: {
+        protocolVersion: 1,
+        appInfo: { name: "malformed" },
+        appCapabilities: { availableDisplayModes: "fullscreen" },
+      },
+    });
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+    });
+    await flush();
+
+    expect(onInitialized).toHaveBeenCalledOnce();
+    expect(onInitialized).toHaveBeenCalledWith({
+      appCapabilities: {},
+    });
+    expect((captured[0] as McpAppJsonRpcResponse).result).toMatchObject({
+      protocolVersion: MCP_APP_PROTOCOL_VERSION,
+    });
+    bridge.dispose();
+  });
+
+  it("keeps only the display modes the host recognizes", () => {
+    const { frame } = makeFrame();
+    const onInitialized = vi.fn();
+    const bridge = createMcpAppBridge({ frame, handlers: { onInitialized } });
+
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "ui/initialize",
+      params: {
+        appCapabilities: { availableDisplayModes: ["inline", "sidebar"] },
+      },
+    });
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+    });
+
+    expect(onInitialized).toHaveBeenCalledWith({
+      appCapabilities: { availableDisplayModes: ["inline"] },
+    });
+    bridge.dispose();
+  });
+
+  it("reads a sparse display mode list without walking its length", () => {
+    const { frame } = makeFrame();
+    const onInitialized = vi.fn();
+    const bridge = createMcpAppBridge({ frame, handlers: { onInitialized } });
+    const availableDisplayModes = ["inline"];
+    availableDisplayModes.length = 2 ** 32 - 1;
+
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "ui/initialize",
+      params: { appCapabilities: { availableDisplayModes } },
+    });
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+    });
+
+    expect(onInitialized).toHaveBeenCalledWith({
+      appCapabilities: { availableDisplayModes: ["inline"] },
+    });
+    bridge.dispose();
+  });
+
+  it("initializes when the display mode list carries its own methods", async () => {
+    const { frame, captured } = makeFrame();
+    const onInitialized = vi.fn();
+    const bridge = createMcpAppBridge({ frame, handlers: { onInitialized } });
+
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "ui/initialize",
+      params: {
+        appCapabilities: {
+          availableDisplayModes: Object.assign(["inline", "pip"], {
+            filter: 0,
+            constructor: 0,
+          }),
+        },
+      },
+    });
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+    });
+    await flush();
+
+    expect((captured[0] as McpAppJsonRpcResponse).error).toBeUndefined();
+    expect(onInitialized).toHaveBeenCalledWith({
+      appCapabilities: { availableDisplayModes: ["inline", "pip"] },
+    });
+    bridge.dispose();
+  });
+
+  it("calls onInitialized with empty params when ui/initialize never arrived", () => {
+    const { frame } = makeFrame();
+    const onInitialized = vi.fn();
+    const bridge = createMcpAppBridge({ frame, handlers: { onInitialized } });
+
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+    });
+
+    expect(onInitialized).toHaveBeenCalledWith({});
+    bridge.dispose();
+  });
+
   it("routes tools/call to handler", async () => {
     const { frame, captured } = makeFrame();
     const callTool = vi.fn().mockResolvedValue({ ok: true });

package/src/mcp-apps/bridge.ts

@@ -6,6 +6,7 @@ import {
   type McpAppDisplayMode,
   type McpAppHostContext,
   type McpAppHostInfo,
+  type McpAppInitializeParams,
   type McpAppJsonRpcMessage,
   type McpAppJsonRpcNotification,
   type McpAppJsonRpcRequest,
@@ -19,6 +20,50 @@ const VALID_DISPLAY_MODES = [
   "pip",
 ] as const satisfies readonly McpAppDisplayMode[];
 
+function isMcpAppDisplayMode(value: unknown): value is McpAppDisplayMode {
+  return VALID_DISPLAY_MODES.some((mode) => mode === value);
+}
+
+function isAppInfo(
+  value: unknown,
+): value is NonNullable<McpAppInitializeParams["appInfo"]> {
+  return (
+    isRecord(value) &&
+    typeof value.name === "string" &&
+    typeof value.version === "string"
+  );
+}
+
+function getAppCapabilities(
+  value: unknown,
+): McpAppInitializeParams["appCapabilities"] {
+  if (!isRecord(value)) return undefined;
+  const { availableDisplayModes, ...rest } = value;
+  return {
+    ...rest,
+    // Object.values reads only the entries present, so a sparse list claiming a huge length stays cheap, and the list's own methods are never called.
+    ...(Array.isArray(availableDisplayModes)
+      ? {
+          availableDisplayModes: Object.values(availableDisplayModes).filter(
+            isMcpAppDisplayMode,
+          ),
+        }
+      : {}),
+  };
+}
+
+function getInitializeParams(params: unknown): McpAppInitializeParams {
+  if (!isRecord(params)) return {};
+  const appCapabilities = getAppCapabilities(params.appCapabilities);
+  return {
+    ...(isAppInfo(params.appInfo) ? { appInfo: params.appInfo } : {}),
+    ...(appCapabilities ? { appCapabilities } : {}),
+    ...(typeof params.protocolVersion === "string"
+      ? { protocolVersion: params.protocolVersion }
+      : {}),
+  };
+}
+
 export type McpAppBridgeFrame = SandboxHostFrame;
 
 export type CreateMcpAppBridgeOptions = {
@@ -91,6 +136,7 @@ export function createMcpAppBridge(
     hostContext = {},
   } = opts;
   let disposed = false;
+  let initializeParams: McpAppInitializeParams = {};
 
   const post = (msg: McpAppJsonRpcMessage) => {
     if (disposed) return;
@@ -142,10 +188,9 @@ export function createMcpAppBridge(
 
       switch (normalizeMethod(req.method)) {
         case "ui/initialize": {
+          initializeParams = getInitializeParams(params);
           const requestedProtocolVersion =
-            isRecord(params) && typeof params.protocolVersion === "string"
-              ? params.protocolVersion
-              : MCP_APP_PROTOCOL_VERSION;
+            initializeParams.protocolVersion ?? MCP_APP_PROTOCOL_VERSION;
           respond(req.id, {
             result: {
               protocolVersion: requestedProtocolVersion,
@@ -360,10 +405,7 @@ export function createMcpAppBridge(
             return;
           }
           const modeParams = (params ?? {}) as { mode?: unknown };
-          if (
-            typeof modeParams.mode !== "string" ||
-            !VALID_DISPLAY_MODES.includes(modeParams.mode as McpAppDisplayMode)
-          ) {
+          if (!isMcpAppDisplayMode(modeParams.mode)) {
             errorResponse(
               req.id,
               JSONRPC_ERROR.invalidParams,
@@ -373,7 +415,7 @@ export function createMcpAppBridge(
           }
           respond(req.id, {
             result: await handlers.requestDisplayMode({
-              mode: modeParams.mode as McpAppDisplayMode,
+              mode: modeParams.mode,
             }),
           });
           return;
@@ -398,7 +440,7 @@ export function createMcpAppBridge(
     try {
       switch (normalizeMethod(note.method)) {
         case "notifications/initialized": {
-          handlers.onInitialized?.();
+          handlers.onInitialized?.(initializeParams);
           return;
         }
         case "notifications/size_changed": {

package/src/mcp-apps/index.ts

@@ -17,6 +17,7 @@ export type {
   McpAppsHost,
   McpAppsRemoteHostOptions,
   McpAppToolCallParams,
+  McpAppInitializeParams,
   McpAppBridgeHandlers,
   ToolCallMessagePartMcpMetadata,
 } from "./types";

package/src/mcp-apps/types.ts

@@ -87,6 +87,20 @@ export type McpAppToolCallParams = {
   arguments?: Record<string, unknown>;
 };
 
+/**
+ * The params of the app's `ui/initialize` request, as `onInitialized`
+ * receives them. A field that fails validation is omitted, and
+ * `availableDisplayModes` keeps only the modes the bridge recognizes.
+ */
+export type McpAppInitializeParams = {
+  appInfo?: { name: string; version: string; [k: string]: unknown };
+  appCapabilities?: {
+    availableDisplayModes?: McpAppDisplayMode[];
+    [k: string]: unknown;
+  };
+  protocolVersion?: string;
+};
+
 export type McpAppBridgeHandlers = {
   allowedTools?: readonly string[];
   callTool?: (params: McpAppToolCallParams) => Promise<unknown> | unknown;
@@ -99,7 +113,7 @@ export type McpAppBridgeHandlers = {
     mode: McpAppDisplayMode;
   }) => Promise<{ mode: McpAppDisplayMode }> | { mode: McpAppDisplayMode };
   onSizeChange?: (params: { width?: number; height?: number }) => void;
-  onInitialized?: () => void;
+  onInitialized?: (params: McpAppInitializeParams) => void;
   onRequestTeardown?: (params: unknown) => void;
   onLog?: (params: unknown) => void;
   onError?: (error: Error) => void;

package/src/primitives/composer/ComposerAttachmentDropzone.test.tsx

@@ -6,9 +6,10 @@ import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { ComposerPrimitiveAttachmentDropzone } from "./ComposerAttachmentDropzone";
 
-const { addAttachment, threadCapabilities } = vi.hoisted(() => ({
+const { addAttachment, threadCapabilities, threadState } = vi.hoisted(() => ({
   addAttachment: vi.fn<(file: File) => Promise<void>>(),
   threadCapabilities: { attachments: true },
+  threadState: { isDisabled: false },
 }));
 
 (globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
@@ -25,6 +26,9 @@ vi.mock("@assistant-ui/store", async (importOriginal) => {
         getState: () => ({ capabilities: threadCapabilities }),
       },
     }),
+    useAuiState: (
+      selector: (state: { thread: typeof threadState }) => unknown,
+    ) => selector({ thread: threadState }),
   };
 });
 
@@ -53,6 +57,7 @@ describe("ComposerPrimitiveAttachmentDropzone", () => {
   beforeEach(async () => {
     addAttachment.mockReset();
     threadCapabilities.attachments = true;
+    threadState.isDisabled = false;
     container = document.createElement("div");
     document.body.appendChild(container);
     root = createRoot(container);
@@ -250,6 +255,32 @@ describe("ComposerPrimitiveAttachmentDropzone", () => {
     expect(dropzone.hasAttribute("data-dragging")).toBe(false);
   });
 
+  it("blocks file drops when the thread is disabled", async () => {
+    threadState.isDisabled = true;
+    await act(async () => {
+      root.render(
+        <ComposerPrimitiveAttachmentDropzone data-testid="dropzone">
+          <div>dropzone</div>
+        </ComposerPrimitiveAttachmentDropzone>,
+      );
+    });
+    const dropzone = container.querySelector("[data-testid='dropzone']")!;
+    const over = createDragEvent("dragover", ["Files"]);
+    const drop = createDropEvent([
+      new File(["file"], "photo.png", { type: "image/png" }),
+    ]);
+
+    await act(async () => {
+      dropzone.dispatchEvent(over);
+      dropzone.dispatchEvent(drop);
+    });
+
+    expect(over.defaultPrevented).toBe(true);
+    expect(drop.defaultPrevented).toBe(true);
+    expect(addAttachment).not.toHaveBeenCalled();
+    expect(dropzone.hasAttribute("data-dragging")).toBe(false);
+  });
+
   it("ignores non-file drags", async () => {
     const dropzone = container.querySelector("[data-testid='dropzone']");
     expect(dropzone).not.toBeNull();