@assistant-ui/react 0.10.49 → 0.11.0

package/dist/context/react/legacy/AttachmentContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttachmentContext.d.ts","sourceRoot":"","sources":["../../../../src/context/react/legacy/AttachmentContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAInE,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE;IAC7C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,iBAAiB,CAAC;AACtB,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE;IAC7C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,iBAAiB,GAAG,IAAI,CAAC;AAc7B,wBAAgB,kCAAkC,CAAC,OAAO,CAAC,EAAE;IAC3D,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;AACzC,wBAAgB,kCAAkC,CAAC,OAAO,CAAC,EAAE;IAC3D,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC;AAahD,wBAAgB,gCAAgC,CAAC,OAAO,CAAC,EAAE;IACzD,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,iBAAiB,CAAC,eAAe,CAAC,CAAC;AACvC,wBAAgB,gCAAgC,CAAC,OAAO,CAAC,EAAE;IACzD,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,iBAAiB,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;AAc9C,wBAAgB,2BAA2B,CAAC,OAAO,CAAC,EAAE;IACpD,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;AACjC,wBAAgB,2BAA2B,CAAC,OAAO,CAAC,EAAE;IACpD,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,iBAAiB,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;AAaxC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkD,CAAC;AAE7E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEvC,CAAC;AACF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAErC,CAAC;AACF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEhC,CAAC"}

package/dist/context/react/{AttachmentContext.js → legacy/AttachmentContext.js}

@@ -1,20 +1,15 @@
 "use client";
 
-// src/context/react/AttachmentContext.ts
-import { createContext } from "react";
-import { createContextHook } from "./utils/createContextHook.js";
-import { createStateHookForRuntime } from "./utils/createStateHookForRuntime.js";
-var AttachmentContext = createContext(
-  null
-);
-var useAttachmentContext = createContextHook(
-  AttachmentContext,
-  "a ComposerPrimitive.Attachments or MessagePrimitive.Attachments component"
-);
+// src/context/react/legacy/AttachmentContext.ts
+import { createStateHookForRuntime } from "../utils/createStateHookForRuntime.js";
+import { useAssistantApi } from "../index.js";
 function useAttachmentRuntime(options) {
-  const attachmentRuntime = useAttachmentContext(options);
-  if (!attachmentRuntime) return null;
-  return attachmentRuntime.useAttachmentRuntime();
+  const api = useAssistantApi();
+  const runtime = api.attachment.source ? api.attachment().__internal_getRuntime() : null;
+  if (!runtime && !options?.optional) {
+    throw new Error("AttachmentRuntime is not available");
+  }
+  return runtime;
 }
 function useThreadComposerAttachmentRuntime(options) {
   const attachmentRuntime = useAttachmentRuntime(options);
@@ -54,7 +49,6 @@ var useMessageAttachment = createStateHookForRuntime(
   useMessageAttachmentRuntime
 );
 export {
-  AttachmentContext,
   useAttachment,
   useAttachmentRuntime,
   useEditComposerAttachment,

package/dist/context/react/legacy/AttachmentContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/context/react/legacy/AttachmentContext.ts"],"sourcesContent":["\"use client\";\n\nimport { AttachmentRuntime } from \"../../../api/AttachmentRuntime\";\nimport { createStateHookForRuntime } from \"../utils/createStateHookForRuntime\";\nimport { useAssistantApi } from \"..\";\n\nexport function useAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime;\nexport function useAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime | null;\nexport function useAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime | null {\n  const api = useAssistantApi();\n  const runtime = api.attachment.source\n    ? api.attachment().__internal_getRuntime()\n    : null;\n  if (!runtime && !options?.optional) {\n    throw new Error(\"AttachmentRuntime is not available\");\n  }\n  return runtime;\n}\n\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"thread-composer\">;\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"thread-composer\"> | null;\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"thread-composer\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"thread-composer\")\n    throw new Error(\n      \"This component must be used within a thread's ComposerPrimitive.Attachments component.\",\n    );\n  return attachmentRuntime as AttachmentRuntime<\"thread-composer\">;\n}\n\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"edit-composer\">;\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"edit-composer\"> | null;\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"edit-composer\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"edit-composer\")\n    throw new Error(\n      \"This component must be used within a message's ComposerPrimitive.Attachments component.\",\n    );\n\n  return attachmentRuntime as AttachmentRuntime<\"edit-composer\">;\n}\n\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"message\">;\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"message\"> | null;\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"message\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"message\")\n    throw new Error(\n      \"This component must be used within a MessagePrimitive.Attachments component.\",\n    );\n  return attachmentRuntime as AttachmentRuntime<\"message\">;\n}\n\nexport const useAttachment = createStateHookForRuntime(useAttachmentRuntime);\n\nexport const useThreadComposerAttachment = createStateHookForRuntime(\n  useThreadComposerAttachmentRuntime,\n);\nexport const useEditComposerAttachment = createStateHookForRuntime(\n  useEditComposerAttachmentRuntime,\n);\nexport const useMessageAttachment = createStateHookForRuntime(\n  useMessageAttachmentRuntime,\n);\n"],"mappings":";;;AAGA,SAAS,iCAAiC;AAC1C,SAAS,uBAAuB;AAQzB,SAAS,qBAAqB,SAER;AAC3B,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU,IAAI,WAAW,SAC3B,IAAI,WAAW,EAAE,sBAAsB,IACvC;AACJ,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AACA,SAAO;AACT;AAQO,SAAS,mCAAmC,SAEH;AAC9C,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,SAAO;AACT;AAQO,SAAS,iCAAiC,SAEH;AAC5C,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAEF,SAAO;AACT;AAQO,SAAS,4BAA4B,SAEJ;AACtC,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,SAAO;AACT;AAEO,IAAM,gBAAgB,0BAA0B,oBAAoB;AAEpE,IAAM,8BAA8B;AAAA,EACzC;AACF;AACO,IAAM,4BAA4B;AAAA,EACvC;AACF;AACO,IAAM,uBAAuB;AAAA,EAClC;AACF;","names":[]}

package/dist/context/react/{ComposerContext.d.ts → legacy/ComposerContext.d.ts}

@@ -1,4 +1,4 @@
-import { ComposerRuntime } from "../../api/ComposerRuntime";
+import { ComposerRuntime } from "../../../api/ComposerRuntime";
 /**
  * Hook to access the ComposerRuntime from the current context.
  *
@@ -70,30 +70,30 @@ export declare function useComposerRuntime(options?: {
  * ```
  */
 export declare const useComposer: {
-    (): import("../..").ComposerState;
-    <TSelected>(selector: (state: import("../..").ComposerState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../..").ComposerState) => TSelected) | undefined): import("../..").ComposerState | TSelected;
+    (): import("../../..").ComposerState;
+    <TSelected>(selector: (state: import("../../..").ComposerState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../../..").ComposerState) => TSelected) | undefined): import("../../..").ComposerState | TSelected;
     (options: {
         optional?: false | undefined;
-    }): import("../..").ComposerState;
+    }): import("../../..").ComposerState;
     (options: {
         optional?: boolean | undefined;
-    }): import("../..").ComposerState | null;
+    }): import("../../..").ComposerState | null;
     <TSelected>(options: {
         optional?: false | undefined;
-        selector: (state: import("../..").ComposerState) => TSelected;
+        selector: (state: import("../../..").ComposerState) => TSelected;
     }): TSelected;
     <TSelected>(options: {
         optional?: false | undefined;
-        selector: ((state: import("../..").ComposerState) => TSelected) | undefined;
-    }): import("../..").ComposerState | TSelected;
+        selector: ((state: import("../../..").ComposerState) => TSelected) | undefined;
+    }): import("../../..").ComposerState | TSelected;
     <TSelected>(options: {
         optional?: boolean | undefined;
-        selector: (state: import("../..").ComposerState) => TSelected;
+        selector: (state: import("../../..").ComposerState) => TSelected;
     }): TSelected | null;
     <TSelected>(options: {
         optional?: boolean | undefined;
-        selector: ((state: import("../..").ComposerState) => TSelected) | undefined;
-    }): import("../..").ComposerState | TSelected | null;
+        selector: ((state: import("../../..").ComposerState) => TSelected) | undefined;
+    }): import("../../..").ComposerState | TSelected | null;
 };
 //# sourceMappingURL=ComposerContext.d.ts.map

package/dist/context/react/legacy/ComposerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposerContext.d.ts","sourceRoot":"","sources":["../../../../src/context/react/legacy/ComposerContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAG/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE;IAC3C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,eAAe,CAAC;AACpB,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE;IAC3C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,eAAe,GAAG,IAAI,CAAC;AAc3B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAC"}

package/dist/context/react/legacy/ComposerContext.js

@@ -0,0 +1,19 @@
+"use client";
+
+// src/context/react/legacy/ComposerContext.ts
+import { useAssistantApi } from "../index.js";
+import { createStateHookForRuntime } from "../utils/createStateHookForRuntime.js";
+function useComposerRuntime(options) {
+  const api = useAssistantApi();
+  const runtime = api.composer.source ? api.composer().__internal_getRuntime() : null;
+  if (!runtime && !options?.optional) {
+    throw new Error("ComposerRuntime is not available");
+  }
+  return runtime;
+}
+var useComposer = createStateHookForRuntime(useComposerRuntime);
+export {
+  useComposer,
+  useComposerRuntime
+};
+//# sourceMappingURL=ComposerContext.js.map

package/dist/context/react/legacy/ComposerContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/context/react/legacy/ComposerContext.ts"],"sourcesContent":["\"use client\";\n\nimport { useAssistantApi } from \"..\";\nimport { ComposerRuntime } from \"../../../api/ComposerRuntime\";\nimport { createStateHookForRuntime } from \"../utils/createStateHookForRuntime\";\n\n/**\n * Hook to access the ComposerRuntime from the current context.\n *\n * The ComposerRuntime provides access to composer state and actions for message\n * composition, including text input, attachments, and sending functionality.\n * This hook automatically resolves to either the message's edit composer or\n * the thread's main composer depending on the context.\n *\n * @param options Configuration options\n * @param options.optional Whether the hook should return null if no context is found\n * @returns The ComposerRuntime instance, or null if optional is true and no context exists\n *\n * @example\n * ```tsx\n * function ComposerActions() {\n *   const runtime = useComposerRuntime();\n *\n *   const handleSend = () => {\n *     if (runtime.getState().canSend) {\n *       runtime.send();\n *     }\n *   };\n *\n *   const handleCancel = () => {\n *     if (runtime.getState().canCancel) {\n *       runtime.cancel();\n *     }\n *   };\n *\n *   return (\n *     <div>\n *       <button onClick={handleSend}>Send</button>\n *       <button onClick={handleCancel}>Cancel</button>\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useComposerRuntime(options?: {\n  optional?: false | undefined;\n}): ComposerRuntime;\nexport function useComposerRuntime(options?: {\n  optional?: boolean | undefined;\n}): ComposerRuntime | null;\nexport function useComposerRuntime(options?: {\n  optional?: boolean | undefined;\n}): ComposerRuntime | null {\n  const api = useAssistantApi();\n  const runtime = api.composer.source\n    ? api.composer().__internal_getRuntime()\n    : null;\n  if (!runtime && !options?.optional) {\n    throw new Error(\"ComposerRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * Hook to access the current composer state.\n *\n * This hook provides reactive access to the composer's state, including text content,\n * attachments, editing status, and send/cancel capabilities.\n *\n * @param selector Optional selector function to pick specific state properties\n * @returns The selected composer state or the entire composer state if no selector provided\n *\n * @example\n * ```tsx\n * function ComposerStatus() {\n *   const text = useComposer((state) => state.text);\n *   const canSend = useComposer((state) => state.canSend);\n *   const attachmentCount = useComposer((state) => state.attachments.length);\n *\n *   return (\n *     <div>\n *       Text: {text.length} chars,\n *       Attachments: {attachmentCount},\n *       Can send: {canSend}\n *     </div>\n *   );\n * }\n * ```\n */\nexport const useComposer = createStateHookForRuntime(useComposerRuntime);\n"],"mappings":";;;AAEA,SAAS,uBAAuB;AAEhC,SAAS,iCAAiC;AA8CnC,SAAS,mBAAmB,SAER;AACzB,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU,IAAI,SAAS,SACzB,IAAI,SAAS,EAAE,sBAAsB,IACrC;AACJ,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,kCAAkC;AAAA,EACpD;AACA,SAAO;AACT;AA4BO,IAAM,cAAc,0BAA0B,kBAAkB;","names":[]}

package/dist/context/react/{MessageContext.d.ts → legacy/MessageContext.d.ts}

@@ -1,12 +1,4 @@
-import { ReadonlyStore } from "../ReadonlyStore";
-import { MessageUtilsState } from "../stores/MessageUtils";
-import { UseBoundStore } from "zustand";
-import { MessageRuntime } from "../../api/MessageRuntime";
-export type MessageContextValue = {
-    useMessageRuntime: UseBoundStore<ReadonlyStore<MessageRuntime>>;
-    useMessageUtils: UseBoundStore<ReadonlyStore<MessageUtilsState>>;
-};
-export declare const MessageContext: import("react").Context<MessageContextValue | null>;
+import { MessageRuntime } from "../../../api/MessageRuntime";
 /**
  * Hook to access the MessageRuntime from the current context.
  *
@@ -70,73 +62,57 @@ export declare function useMessageRuntime(options?: {
  * ```
  */
 export declare const useMessage: {
-    (): import("../..").MessageState;
-    <TSelected>(selector: (state: import("../..").MessageState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../..").MessageState) => TSelected) | undefined): import("../..").MessageState | TSelected;
+    (): import("../../..").MessageState;
+    <TSelected>(selector: (state: import("../../..").MessageState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../../..").MessageState) => TSelected) | undefined): import("../../..").MessageState | TSelected;
     (options: {
         optional?: false | undefined;
-    }): import("../..").MessageState;
+    }): import("../../..").MessageState;
     (options: {
         optional?: boolean | undefined;
-    }): import("../..").MessageState | null;
+    }): import("../../..").MessageState | null;
     <TSelected>(options: {
         optional?: false | undefined;
-        selector: (state: import("../..").MessageState) => TSelected;
+        selector: (state: import("../../..").MessageState) => TSelected;
     }): TSelected;
     <TSelected>(options: {
         optional?: false | undefined;
-        selector: ((state: import("../..").MessageState) => TSelected) | undefined;
-    }): import("../..").MessageState | TSelected;
+        selector: ((state: import("../../..").MessageState) => TSelected) | undefined;
+    }): import("../../..").MessageState | TSelected;
     <TSelected>(options: {
         optional?: boolean | undefined;
-        selector: (state: import("../..").MessageState) => TSelected;
+        selector: (state: import("../../..").MessageState) => TSelected;
     }): TSelected | null;
     <TSelected>(options: {
         optional?: boolean | undefined;
-        selector: ((state: import("../..").MessageState) => TSelected) | undefined;
-    }): import("../..").MessageState | TSelected | null;
+        selector: ((state: import("../../..").MessageState) => TSelected) | undefined;
+    }): import("../../..").MessageState | TSelected | null;
 };
 export declare const useEditComposer: {
-    (): import("../..").EditComposerState;
-    <TSelected>(selector: (state: import("../..").EditComposerState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../..").EditComposerState) => TSelected) | undefined): import("../..").EditComposerState | TSelected;
+    (): import("../../..").EditComposerState;
+    <TSelected>(selector: (state: import("../../..").EditComposerState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../../..").EditComposerState) => TSelected) | undefined): import("../../..").EditComposerState | TSelected;
     (options: {
         optional?: false | undefined;
-    }): import("../..").EditComposerState;
+    }): import("../../..").EditComposerState;
     (options: {
         optional?: boolean | undefined;
-    }): import("../..").EditComposerState | null;
+    }): import("../../..").EditComposerState | null;
     <TSelected>(options: {
         optional?: false | undefined;
-        selector: (state: import("../..").EditComposerState) => TSelected;
+        selector: (state: import("../../..").EditComposerState) => TSelected;
     }): TSelected;
     <TSelected>(options: {
         optional?: false | undefined;
-        selector: ((state: import("../..").EditComposerState) => TSelected) | undefined;
-    }): import("../..").EditComposerState | TSelected;
+        selector: ((state: import("../../..").EditComposerState) => TSelected) | undefined;
+    }): import("../../..").EditComposerState | TSelected;
     <TSelected>(options: {
         optional?: boolean | undefined;
-        selector: (state: import("../..").EditComposerState) => TSelected;
+        selector: (state: import("../../..").EditComposerState) => TSelected;
     }): TSelected | null;
     <TSelected>(options: {
         optional?: boolean | undefined;
-        selector: ((state: import("../..").EditComposerState) => TSelected) | undefined;
-    }): import("../..").EditComposerState | TSelected | null;
-};
-export declare const useMessageUtils: {
-    (): MessageUtilsState;
-    <TSelected>(selector: (state: MessageUtilsState) => TSelected): TSelected;
-    (options: {
-        optional: true;
-    }): MessageUtilsState | null;
-    <TSelected>(options: {
-        optional: true;
-        selector?: (state: MessageUtilsState) => TSelected;
-    }): TSelected | null;
-}, useMessageUtilsStore: {
-    (): ReadonlyStore<MessageUtilsState>;
-    (options: {
-        optional: true;
-    }): ReadonlyStore<MessageUtilsState> | null;
+        selector: ((state: import("../../..").EditComposerState) => TSelected) | undefined;
+    }): import("../../..").EditComposerState | TSelected | null;
 };
 //# sourceMappingURL=MessageContext.d.ts.map

package/dist/context/react/legacy/MessageContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageContext.d.ts","sourceRoot":"","sources":["../../../../src/context/react/legacy/MessageContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAK7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAC1C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,cAAc,CAAC;AACnB,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAC1C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,cAAc,GAAG,IAAI,CAAC;AAc1B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+C,CAAC;AAKvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CAE3B,CAAC"}

package/dist/context/react/legacy/MessageContext.js

@@ -0,0 +1,24 @@
+"use client";
+
+// src/context/react/legacy/MessageContext.ts
+import { useAssistantApi } from "../index.js";
+import { createStateHookForRuntime } from "../utils/createStateHookForRuntime.js";
+function useMessageRuntime(options) {
+  const api = useAssistantApi();
+  const runtime = api.message.source ? api.message().__internal_getRuntime() : null;
+  if (!runtime && !options?.optional) {
+    throw new Error("MessageRuntime is not available");
+  }
+  return runtime;
+}
+var useMessage = createStateHookForRuntime(useMessageRuntime);
+var useEditComposerRuntime = (opt) => useMessageRuntime(opt)?.composer ?? null;
+var useEditComposer = createStateHookForRuntime(
+  useEditComposerRuntime
+);
+export {
+  useEditComposer,
+  useMessage,
+  useMessageRuntime
+};
+//# sourceMappingURL=MessageContext.js.map

package/dist/context/react/legacy/MessageContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/context/react/legacy/MessageContext.ts"],"sourcesContent":["\"use client\";\n\nimport { MessageRuntime } from \"../../../api/MessageRuntime\";\nimport { useAssistantApi } from \"..\";\nimport { createStateHookForRuntime } from \"../utils/createStateHookForRuntime\";\nimport { EditComposerRuntime } from \"../../../api\";\n\n/**\n * Hook to access the MessageRuntime from the current context.\n *\n * The MessageRuntime provides access to message-level state and actions,\n * including message content, status, editing capabilities, and branching.\n *\n * @param options Configuration options\n * @param options.optional Whether the hook should return null if no context is found\n * @returns The MessageRuntime instance, or null if optional is true and no context exists\n *\n * @example\n * ```tsx\n * function MessageActions() {\n *   const runtime = useMessageRuntime();\n *\n *   const handleReload = () => {\n *     runtime.reload();\n *   };\n *\n *   const handleEdit = () => {\n *     runtime.startEdit();\n *   };\n *\n *   return (\n *     <div>\n *       <button onClick={handleReload}>Reload</button>\n *       <button onClick={handleEdit}>Edit</button>\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useMessageRuntime(options?: {\n  optional?: false | undefined;\n}): MessageRuntime;\nexport function useMessageRuntime(options?: {\n  optional?: boolean | undefined;\n}): MessageRuntime | null;\nexport function useMessageRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const api = useAssistantApi();\n  const runtime = api.message.source\n    ? api.message().__internal_getRuntime()\n    : null;\n  if (!runtime && !options?.optional) {\n    throw new Error(\"MessageRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * Hook to access the current message state.\n *\n * This hook provides reactive access to the message's state, including content,\n * role, status, and other message-level properties.\n *\n * @param selector Optional selector function to pick specific state properties\n * @returns The selected message state or the entire message state if no selector provided\n *\n * @example\n * ```tsx\n * function MessageContent() {\n *   const role = useMessage((state) => state.role);\n *   const content = useMessage((state) => state.content);\n *   const isLoading = useMessage((state) => state.status.type === \"running\");\n *\n *   return (\n *     <div className={`message-${role}`}>\n *       {isLoading ? \"Loading...\" : content.map(part => part.text).join(\"\")}\n *     </div>\n *   );\n * }\n * ```\n */\nexport const useMessage = createStateHookForRuntime(useMessageRuntime);\n\nconst useEditComposerRuntime = (opt: {\n  optional: boolean | undefined;\n}): EditComposerRuntime | null => useMessageRuntime(opt)?.composer ?? null;\nexport const useEditComposer = createStateHookForRuntime(\n  useEditComposerRuntime,\n);\n"],"mappings":";;;AAGA,SAAS,uBAAuB;AAChC,SAAS,iCAAiC;AAyCnC,SAAS,kBAAkB,SAE/B;AACD,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU,IAAI,QAAQ,SACxB,IAAI,QAAQ,EAAE,sBAAsB,IACpC;AACJ,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AACA,SAAO;AACT;AA0BO,IAAM,aAAa,0BAA0B,iBAAiB;AAErE,IAAM,yBAAyB,CAAC,QAEE,kBAAkB,GAAG,GAAG,YAAY;AAC/D,IAAM,kBAAkB;AAAA,EAC7B;AACF;","names":[]}

package/dist/context/react/legacy/MessagePartContext.d.ts

@@ -0,0 +1,35 @@
+import { MessagePartRuntime } from "../../../api/MessagePartRuntime";
+export declare function useMessagePartRuntime(options?: {
+    optional?: false | undefined;
+}): MessagePartRuntime;
+export declare function useMessagePartRuntime(options?: {
+    optional?: boolean | undefined;
+}): MessagePartRuntime | null;
+export declare const useMessagePart: {
+    (): import("../../..").MessagePartState;
+    <TSelected>(selector: (state: import("../../..").MessagePartState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../../..").MessagePartState) => TSelected) | undefined): import("../../..").MessagePartState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../../..").MessagePartState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../../..").MessagePartState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../../..").MessagePartState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../../..").MessagePartState) => TSelected) | undefined;
+    }): import("../../..").MessagePartState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../../..").MessagePartState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../../..").MessagePartState) => TSelected) | undefined;
+    }): import("../../..").MessagePartState | TSelected | null;
+};
+//# sourceMappingURL=MessagePartContext.d.ts.map

package/dist/context/react/legacy/MessagePartContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagePartContext.d.ts","sourceRoot":"","sources":["../../../../src/context/react/legacy/MessagePartContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAIrE,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,kBAAkB,CAAC;AACvB,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,kBAAkB,GAAG,IAAI,CAAC;AAY9B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmD,CAAC"}

package/dist/context/react/legacy/MessagePartContext.js

@@ -0,0 +1,19 @@
+"use client";
+
+// src/context/react/legacy/MessagePartContext.ts
+import { createStateHookForRuntime } from "../utils/createStateHookForRuntime.js";
+import { useAssistantApi } from "../index.js";
+function useMessagePartRuntime(options) {
+  const api = useAssistantApi();
+  const runtime = api.part.source ? api.part().__internal_getRuntime() : null;
+  if (!runtime && !options?.optional) {
+    throw new Error("MessagePartRuntime is not available");
+  }
+  return runtime;
+}
+var useMessagePart = createStateHookForRuntime(useMessagePartRuntime);
+export {
+  useMessagePart,
+  useMessagePartRuntime
+};
+//# sourceMappingURL=MessagePartContext.js.map

package/dist/context/react/legacy/MessagePartContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/context/react/legacy/MessagePartContext.ts"],"sourcesContent":["\"use client\";\n\nimport { MessagePartRuntime } from \"../../../api/MessagePartRuntime\";\nimport { createStateHookForRuntime } from \"../utils/createStateHookForRuntime\";\nimport { useAssistantApi } from \"..\";\n\nexport function useMessagePartRuntime(options?: {\n  optional?: false | undefined;\n}): MessagePartRuntime;\nexport function useMessagePartRuntime(options?: {\n  optional?: boolean | undefined;\n}): MessagePartRuntime | null;\nexport function useMessagePartRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const api = useAssistantApi();\n  const runtime = api.part.source ? api.part().__internal_getRuntime() : null;\n  if (!runtime && !options?.optional) {\n    throw new Error(\"MessagePartRuntime is not available\");\n  }\n  return runtime;\n}\n\nexport const useMessagePart = createStateHookForRuntime(useMessagePartRuntime);\n"],"mappings":";;;AAGA,SAAS,iCAAiC;AAC1C,SAAS,uBAAuB;AAQzB,SAAS,sBAAsB,SAEnC;AACD,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU,IAAI,KAAK,SAAS,IAAI,KAAK,EAAE,sBAAsB,IAAI;AACvE,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,qCAAqC;AAAA,EACvD;AACA,SAAO;AACT;AAEO,IAAM,iBAAiB,0BAA0B,qBAAqB;","names":[]}

package/dist/context/react/{ThreadContext.d.ts → legacy/ThreadContext.d.ts}

@@ -1,11 +1,5 @@
-import { ReadonlyStore } from "../ReadonlyStore";
-import { UseBoundStore } from "zustand";
-import { ThreadRuntime } from "../../api/ThreadRuntime";
-import { ModelContext } from "../../model-context";
-export type ThreadContextValue = {
-    useThreadRuntime: UseBoundStore<ReadonlyStore<ThreadRuntime>>;
-};
-export declare const ThreadContext: import("react").Context<ThreadContextValue | null>;
+import { ThreadRuntime } from "../../../api/ThreadRuntime";
+import { ModelContext } from "../../../model-context";
 /**
  * Hook to access the ThreadRuntime from the current context.
  *
@@ -55,58 +49,58 @@ export declare function useThreadRuntime(options?: {
  * ```
  */
 export declare const useThread: {
-    (): import("../..").ThreadState;
-    <TSelected>(selector: (state: import("../..").ThreadState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../..").ThreadState) => TSelected) | undefined): import("../..").ThreadState | TSelected;
+    (): import("../../..").ThreadState;
+    <TSelected>(selector: (state: import("../../..").ThreadState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../../..").ThreadState) => TSelected) | undefined): import("../../..").ThreadState | TSelected;
     (options: {
         optional?: false | undefined;
-    }): import("../..").ThreadState;
+    }): import("../../..").ThreadState;
     (options: {
         optional?: boolean | undefined;
-    }): import("../..").ThreadState | null;
+    }): import("../../..").ThreadState | null;
     <TSelected>(options: {
         optional?: false | undefined;
-        selector: (state: import("../..").ThreadState) => TSelected;
+        selector: (state: import("../../..").ThreadState) => TSelected;
     }): TSelected;
     <TSelected>(options: {
         optional?: false | undefined;
-        selector: ((state: import("../..").ThreadState) => TSelected) | undefined;
-    }): import("../..").ThreadState | TSelected;
+        selector: ((state: import("../../..").ThreadState) => TSelected) | undefined;
+    }): import("../../..").ThreadState | TSelected;
     <TSelected>(options: {
         optional?: boolean | undefined;
-        selector: (state: import("../..").ThreadState) => TSelected;
+        selector: (state: import("../../..").ThreadState) => TSelected;
     }): TSelected | null;
     <TSelected>(options: {
         optional?: boolean | undefined;
-        selector: ((state: import("../..").ThreadState) => TSelected) | undefined;
-    }): import("../..").ThreadState | TSelected | null;
+        selector: ((state: import("../../..").ThreadState) => TSelected) | undefined;
+    }): import("../../..").ThreadState | TSelected | null;
 };
 export declare const useThreadComposer: {
-    (): import("../..").ThreadComposerState;
-    <TSelected>(selector: (state: import("../..").ThreadComposerState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../..").ThreadComposerState) => TSelected) | undefined): import("../..").ThreadComposerState | TSelected;
+    (): import("../../..").ThreadComposerState;
+    <TSelected>(selector: (state: import("../../..").ThreadComposerState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../../..").ThreadComposerState) => TSelected) | undefined): import("../../..").ThreadComposerState | TSelected;
     (options: {
         optional?: false | undefined;
-    }): import("../..").ThreadComposerState;
+    }): import("../../..").ThreadComposerState;
     (options: {
         optional?: boolean | undefined;
-    }): import("../..").ThreadComposerState | null;
+    }): import("../../..").ThreadComposerState | null;
     <TSelected>(options: {
         optional?: false | undefined;
-        selector: (state: import("../..").ThreadComposerState) => TSelected;
+        selector: (state: import("../../..").ThreadComposerState) => TSelected;
     }): TSelected;
     <TSelected>(options: {
         optional?: false | undefined;
-        selector: ((state: import("../..").ThreadComposerState) => TSelected) | undefined;
-    }): import("../..").ThreadComposerState | TSelected;
+        selector: ((state: import("../../..").ThreadComposerState) => TSelected) | undefined;
+    }): import("../../..").ThreadComposerState | TSelected;
     <TSelected>(options: {
         optional?: boolean | undefined;
-        selector: (state: import("../..").ThreadComposerState) => TSelected;
+        selector: (state: import("../../..").ThreadComposerState) => TSelected;
     }): TSelected | null;
     <TSelected>(options: {
         optional?: boolean | undefined;
-        selector: ((state: import("../..").ThreadComposerState) => TSelected) | undefined;
-    }): import("../..").ThreadComposerState | TSelected | null;
+        selector: ((state: import("../../..").ThreadComposerState) => TSelected) | undefined;
+    }): import("../../..").ThreadComposerState | TSelected | null;
 };
 export declare function useThreadModelContext(options?: {
     optional?: false | undefined;

package/dist/context/react/legacy/ThreadContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadContext.d.ts","sourceRoot":"","sources":["../../../../src/context/react/legacy/ThreadContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAKtD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE;IACzC,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,aAAa,CAAC;AAClB,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE;IACzC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,aAAa,GAAG,IAAI,CAAC;AAYzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8C,CAAC;AAKrE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,YAAY,CAAC;AACjB,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,YAAY,GAAG,IAAI,CAAC"}

package/dist/context/react/legacy/ThreadContext.js

@@ -0,0 +1,33 @@
+"use client";
+
+// src/context/react/legacy/ThreadContext.ts
+import { useState } from "react";
+import { createStateHookForRuntime } from "../utils/createStateHookForRuntime.js";
+import { useAssistantApi, useAssistantEvent } from "../index.js";
+function useThreadRuntime(options) {
+  const api = useAssistantApi();
+  const runtime = api.thread.source ? api.thread().__internal_getRuntime() : null;
+  if (!runtime && !options?.optional) {
+    throw new Error("ThreadRuntime is not available");
+  }
+  return runtime;
+}
+var useThread = createStateHookForRuntime(useThreadRuntime);
+var useThreadComposerRuntime = (opt) => useThreadRuntime(opt)?.composer ?? null;
+var useThreadComposer = createStateHookForRuntime(
+  useThreadComposerRuntime
+);
+function useThreadModelContext(options) {
+  const [, rerender] = useState({});
+  const runtime = useThreadRuntime(options);
+  useAssistantEvent("thread.model-context-update", () => rerender({}));
+  if (!runtime) return null;
+  return runtime?.getModelContext();
+}
+export {
+  useThread,
+  useThreadComposer,
+  useThreadModelContext,
+  useThreadRuntime
+};
+//# sourceMappingURL=ThreadContext.js.map

package/dist/context/react/legacy/ThreadContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/context/react/legacy/ThreadContext.ts"],"sourcesContent":["\"use client\";\n\nimport { useState } from \"react\";\nimport { ThreadRuntime } from \"../../../api/ThreadRuntime\";\nimport { ModelContext } from \"../../../model-context\";\nimport { createStateHookForRuntime } from \"../utils/createStateHookForRuntime\";\nimport { ThreadComposerRuntime } from \"../../../api\";\nimport { useAssistantApi, useAssistantEvent } from \"..\";\n\n/**\n * Hook to access the ThreadRuntime from the current context.\n *\n * The ThreadRuntime provides access to thread-level state and actions,\n * including message management, thread state, and composer functionality.\n *\n * @param options Configuration options\n * @param options.optional Whether the hook should return null if no context is found\n * @returns The ThreadRuntime instance, or null if optional is true and no context exists\n *\n * @example\n * ```tsx\n * function MyComponent() {\n *   const runtime = useThreadRuntime();\n *\n *   const handleSendMessage = (text: string) => {\n *     runtime.append({ role: \"user\", content: [{ type: \"text\", text }] });\n *   };\n *\n *   return <button onClick={() => handleSendMessage(\"Hello!\")}>Send</button>;\n * }\n * ```\n */\nexport function useThreadRuntime(options?: {\n  optional?: false | undefined;\n}): ThreadRuntime;\nexport function useThreadRuntime(options?: {\n  optional?: boolean | undefined;\n}): ThreadRuntime | null;\nexport function useThreadRuntime(options?: { optional?: boolean | undefined }) {\n  const api = useAssistantApi();\n  const runtime = api.thread.source\n    ? api.thread().__internal_getRuntime()\n    : null;\n  if (!runtime && !options?.optional) {\n    throw new Error(\"ThreadRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * Hook to access the current thread state.\n *\n * This hook provides reactive access to the thread's state, including messages,\n * running status, capabilities, and other thread-level properties.\n *\n * @param selector Optional selector function to pick specific state properties\n * @returns The selected thread state or the entire thread state if no selector provided\n *\n * @example\n * ```tsx\n * function ThreadStatus() {\n *   const isRunning = useThread((state) => state.isRunning);\n *   const messageCount = useThread((state) => state.messages.length);\n *\n *   return <div>Running: {isRunning}, Messages: {messageCount}</div>;\n * }\n * ```\n */\nexport const useThread = createStateHookForRuntime(useThreadRuntime);\n\nconst useThreadComposerRuntime = (opt: {\n  optional: boolean | undefined;\n}): ThreadComposerRuntime | null => useThreadRuntime(opt)?.composer ?? null;\nexport const useThreadComposer = createStateHookForRuntime(\n  useThreadComposerRuntime,\n);\n\nexport function useThreadModelContext(options?: {\n  optional?: false | undefined;\n}): ModelContext;\nexport function useThreadModelContext(options?: {\n  optional?: boolean | undefined;\n}): ModelContext | null;\nexport function useThreadModelContext(options?: {\n  optional?: boolean | undefined;\n}): ModelContext | null {\n  const [, rerender] = useState({});\n\n  const runtime = useThreadRuntime(options);\n  useAssistantEvent(\"thread.model-context-update\", () => rerender({}));\n\n  if (!runtime) return null;\n  return runtime?.getModelContext();\n}\n"],"mappings":";;;AAEA,SAAS,gBAAgB;AAGzB,SAAS,iCAAiC;AAE1C,SAAS,iBAAiB,yBAAyB;AA+B5C,SAAS,iBAAiB,SAA8C;AAC7E,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU,IAAI,OAAO,SACvB,IAAI,OAAO,EAAE,sBAAsB,IACnC;AACJ,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,gCAAgC;AAAA,EAClD;AACA,SAAO;AACT;AAqBO,IAAM,YAAY,0BAA0B,gBAAgB;AAEnE,IAAM,2BAA2B,CAAC,QAEE,iBAAiB,GAAG,GAAG,YAAY;AAChE,IAAM,oBAAoB;AAAA,EAC/B;AACF;AAQO,SAAS,sBAAsB,SAEd;AACtB,QAAM,CAAC,EAAE,QAAQ,IAAI,SAAS,CAAC,CAAC;AAEhC,QAAM,UAAU,iBAAiB,OAAO;AACxC,oBAAkB,+BAA+B,MAAM,SAAS,CAAC,CAAC,CAAC;AAEnE,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,SAAS,gBAAgB;AAClC;","names":[]}

package/dist/context/react/legacy/ThreadListItemContext.d.ts

@@ -0,0 +1,35 @@
+import { ThreadListItemRuntime } from "../../../api/ThreadListItemRuntime";
+export declare function useThreadListItemRuntime(options?: {
+    optional?: false | undefined;
+}): ThreadListItemRuntime;
+export declare function useThreadListItemRuntime(options?: {
+    optional?: boolean | undefined;
+}): ThreadListItemRuntime | null;
+export declare const useThreadListItem: {
+    (): import("../../..").ThreadListItemState;
+    <TSelected>(selector: (state: import("../../..").ThreadListItemState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../../..").ThreadListItemState) => TSelected) | undefined): import("../../..").ThreadListItemState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../../..").ThreadListItemState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../../..").ThreadListItemState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../../..").ThreadListItemState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../../..").ThreadListItemState) => TSelected) | undefined;
+    }): import("../../..").ThreadListItemState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../../..").ThreadListItemState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../../..").ThreadListItemState) => TSelected) | undefined;
+    }): import("../../..").ThreadListItemState | TSelected | null;
+};
+//# sourceMappingURL=ThreadListItemContext.d.ts.map

package/dist/context/react/legacy/ThreadListItemContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadListItemContext.d.ts","sourceRoot":"","sources":["../../../../src/context/react/legacy/ThreadListItemContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAI3E,wBAAgB,wBAAwB,CAAC,OAAO,CAAC,EAAE;IACjD,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,qBAAqB,CAAC;AAC1B,wBAAgB,wBAAwB,CAAC,OAAO,CAAC,EAAE;IACjD,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,qBAAqB,GAAG,IAAI,CAAC;AAcjC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC"}

package/dist/context/react/legacy/ThreadListItemContext.js

@@ -0,0 +1,21 @@
+"use client";
+
+// src/context/react/legacy/ThreadListItemContext.ts
+import { createStateHookForRuntime } from "../utils/createStateHookForRuntime.js";
+import { useAssistantApi } from "../index.js";
+function useThreadListItemRuntime(options) {
+  const api = useAssistantApi();
+  const runtime = api.threadListItem.source ? api.threadListItem().__internal_getRuntime() : null;
+  if (!runtime && !options?.optional) {
+    throw new Error("ThreadListItemRuntime is not available");
+  }
+  return runtime;
+}
+var useThreadListItem = createStateHookForRuntime(
+  useThreadListItemRuntime
+);
+export {
+  useThreadListItem,
+  useThreadListItemRuntime
+};
+//# sourceMappingURL=ThreadListItemContext.js.map

package/dist/context/react/legacy/ThreadListItemContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/context/react/legacy/ThreadListItemContext.ts"],"sourcesContent":["\"use client\";\n\nimport { ThreadListItemRuntime } from \"../../../api/ThreadListItemRuntime\";\nimport { createStateHookForRuntime } from \"../utils/createStateHookForRuntime\";\nimport { useAssistantApi } from \"..\";\n\nexport function useThreadListItemRuntime(options?: {\n  optional?: false | undefined;\n}): ThreadListItemRuntime;\nexport function useThreadListItemRuntime(options?: {\n  optional?: boolean | undefined;\n}): ThreadListItemRuntime | null;\nexport function useThreadListItemRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const api = useAssistantApi();\n  const runtime = api.threadListItem.source\n    ? api.threadListItem().__internal_getRuntime()\n    : null;\n  if (!runtime && !options?.optional) {\n    throw new Error(\"ThreadListItemRuntime is not available\");\n  }\n  return runtime;\n}\n\nexport const useThreadListItem = createStateHookForRuntime(\n  useThreadListItemRuntime,\n);\n"],"mappings":";;;AAGA,SAAS,iCAAiC;AAC1C,SAAS,uBAAuB;AAQzB,SAAS,yBAAyB,SAEtC;AACD,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU,IAAI,eAAe,SAC/B,IAAI,eAAe,EAAE,sBAAsB,IAC3C;AACJ,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,wCAAwC;AAAA,EAC1D;AACA,SAAO;AACT;AAEO,IAAM,oBAAoB;AAAA,EAC/B;AACF;","names":[]}

package/dist/context/stores/index.d.ts

@@ -1,4 +1,2 @@
-export type { AssistantToolUIsState } from "./AssistantToolUIs";
-export type { MessageUtilsState } from "./MessageUtils";
 export type { ThreadViewportState } from "./ThreadViewport";
 //# sourceMappingURL=index.d.ts.map

package/dist/context/stores/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/context/stores/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/context/stores/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/hooks/useAssistantEvent.d.ts

@@ -0,0 +1,3 @@
+import { AssistantEventSelector, AssistantEvents } from "../types/EventTypes";
+export declare const useAssistantEvent: <TEvent extends keyof AssistantEvents>(selector: AssistantEventSelector<TEvent>, callback: (e: AssistantEvents[TEvent]) => void) => void;
+//# sourceMappingURL=useAssistantEvent.d.ts.map

package/dist/hooks/useAssistantEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssistantEvent.d.ts","sourceRoot":"","sources":["../../src/hooks/useAssistantEvent.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,sBAAsB,EACtB,eAAe,EAEhB,MAAM,qBAAqB,CAAC;AAE7B,eAAO,MAAM,iBAAiB,GAAI,MAAM,SAAS,MAAM,eAAe,EACpE,UAAU,sBAAsB,CAAC,MAAM,CAAC,EACxC,UAAU,CAAC,CAAC,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK,IAAI,SAa/C,CAAC"}

package/dist/hooks/useAssistantEvent.js

@@ -0,0 +1,22 @@
+// src/hooks/useAssistantEvent.ts
+import { useEffect, useRef } from "react";
+import { useAssistantApi } from "../context/react/AssistantApiContext.js";
+import {
+  normalizeEventSelector
+} from "../types/EventTypes.js";
+var useAssistantEvent = (selector, callback) => {
+  const api = useAssistantApi();
+  const callbackRef = useRef(callback);
+  useEffect(() => {
+    callbackRef.current = callback;
+  });
+  const { scope, event } = normalizeEventSelector(selector);
+  useEffect(
+    () => api.on({ scope, event }, (e) => callbackRef.current(e)),
+    [api, scope, event]
+  );
+};
+export {
+  useAssistantEvent
+};
+//# sourceMappingURL=useAssistantEvent.js.map