@assistant-ui/react 0.11.52 → 0.11.54

package/dist/legacy-runtime/hooks/ComposerContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/legacy-runtime/hooks/ComposerContext.ts"],"sourcesContent":["\"use client\";\n\nimport { useAssistantApi, useAssistantState } from \"../../context/react\";\nimport { ComposerRuntime } from \"../runtime/ComposerRuntime\";\nimport { createStateHookForRuntime } from \"../../context/react/utils/createStateHookForRuntime\";\n\n/**\n * @deprecated Use `useAssistantApi()` with `api.composer()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\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 * // Before:\n * function ComposerActions() {\n *   const runtime = useComposerRuntime();\n *   const handleSend = () => {\n *     if (runtime.getState().canSend) {\n *       runtime.send();\n *     }\n *   };\n *   const handleCancel = () => {\n *     if (runtime.getState().canCancel) {\n *       runtime.cancel();\n *     }\n *   };\n *   return (\n *     <div>\n *       <button onClick={handleSend}>Send</button>\n *       <button onClick={handleCancel}>Cancel</button>\n *     </div>\n *   );\n * }\n *\n * // After:\n * function ComposerActions() {\n *   const api = useAssistantApi();\n *   const canSend = useAssistantState(({ composer }) => composer.canSend);\n *   const canCancel = useAssistantState(({ composer }) => composer.canCancel);\n *   const handleSend = () => {\n *     if (canSend) {\n *       api.composer().send();\n *     }\n *   };\n *   const handleCancel = () => {\n *     if (canCancel) {\n *       api.composer().cancel();\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 = useAssistantState(() =>\n    api.composer.source\n      ? (api.composer().__internal_getRuntime?.() ?? null)\n      : null,\n  );\n  if (!runtime && !options?.optional) {\n    throw new Error(\"ComposerRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * @deprecated Use `useAssistantState(({ composer }) => composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\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 * // Before:\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 *   return (\n *     <div>\n *       Text: {text.length} chars,\n *       Attachments: {attachmentCount},\n *       Can send: {canSend}\n *     </div>\n *   );\n * }\n *\n * // After:\n * function ComposerStatus() {\n *   const text = useAssistantState(({ composer }) => composer.text);\n *   const canSend = useAssistantState(({ composer }) => composer.canSend);\n *   const attachmentCount = useAssistantState(({ composer }) => composer.attachments.length);\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,iBAAiB,yBAAyB;AAEnD,SAAS,iCAAiC;AAqEnC,SAAS,mBAAmB,SAER;AACzB,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU;AAAA,IAAkB,MAChC,IAAI,SAAS,SACR,IAAI,SAAS,EAAE,wBAAwB,KAAK,OAC7C;AAAA,EACN;AACA,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,kCAAkC;AAAA,EACpD;AACA,SAAO;AACT;AA4CO,IAAM,cAAc,0BAA0B,kBAAkB;","names":[]}
+{"version":3,"file":"ComposerContext.js","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/ComposerContext.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,qCAA4B;AAEzE,OAAO,EAAE,yBAAyB,EAAE,+DAA4D;AAqEhG,MAAM,UAAU,kBAAkB,CAAC,OAElC;IACC,MAAM,GAAG,GAAG,eAAe,EAAE,CAAC;IAC9B,MAAM,OAAO,GAAG,iBAAiB,CAAC,GAAG,EAAE,CACrC,GAAG,CAAC,QAAQ,CAAC,MAAM;QACjB,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,qBAAqB,EAAE,EAAE,IAAI,IAAI,CAAC;QACpD,CAAC,CAAC,IAAI,CACT,CAAC;IACF,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;IACtD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,yBAAyB,CAAC,kBAAkB,CAAC,CAAC"}

package/dist/legacy-runtime/hooks/MessageContext.d.ts

@@ -1,6 +1,6 @@
-import { MessageRuntime } from "../runtime/MessageRuntime";
+import { MessageRuntime } from "../runtime/MessageRuntime.js";
 /**
- * @deprecated Use `useAssistantApi()` with `api.message()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantApi()` with `api.message()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  *
  * Hook to access the MessageRuntime from the current context.
  *
@@ -55,7 +55,7 @@ export declare function useMessageRuntime(options?: {
     optional?: boolean | undefined;
 }): MessageRuntime | null;
 /**
- * @deprecated Use `useAssistantState(({ message }) => message)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantState(({ message }) => message)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  *
  * Hook to access the current message state.
  *
@@ -120,7 +120,7 @@ export declare const useMessage: {
     }): import("../runtime").MessageState | TSelected | null;
 };
 /**
- * @deprecated Use `useAssistantState(({ message }) => message.composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantState(({ message }) => message.composer)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export declare const useEditComposer: {
     (): import("../runtime").EditComposerState;

package/dist/legacy-runtime/hooks/MessageContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageContext.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/MessageContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAK3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;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;AAgB1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+C,CAAC;AAMvE;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CAE3B,CAAC"}
+{"version":3,"file":"MessageContext.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/MessageContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,qCAAkC;AAK3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;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;AAgB1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+C,CAAC;AAMvE;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CAE3B,CAAC"}

package/dist/legacy-runtime/hooks/MessageContext.js

@@ -1,26 +1,58 @@
 "use client";
-
-// src/legacy-runtime/hooks/MessageContext.ts
 import { useAssistantApi, useAssistantState } from "../../context/react/index.js";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime.js";
-function useMessageRuntime(options) {
-  const api = useAssistantApi();
-  const runtime = useAssistantState(
-    () => api.message.source ? api.message().__internal_getRuntime?.() ?? null : null
-  );
-  if (!runtime && !options?.optional) {
-    throw new Error("MessageRuntime is not available");
-  }
-  return runtime;
+export function useMessageRuntime(options) {
+    const api = useAssistantApi();
+    const runtime = useAssistantState(() => api.message.source
+        ? (api.message().__internal_getRuntime?.() ?? null)
+        : 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
-};
+/**
+ * @deprecated Use `useAssistantState(({ message }) => message)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ *
+ * Hook to access the current message state.
+ *
+ * This hook provides reactive access to the message's state, including content,
+ * role, status, and other message-level properties.
+ *
+ * @param selector Optional selector function to pick specific state properties
+ * @returns The selected message state or the entire message state if no selector provided
+ *
+ * @example
+ * ```tsx
+ * // Before:
+ * function MessageContent() {
+ *   const role = useMessage((state) => state.role);
+ *   const content = useMessage((state) => state.content);
+ *   const isLoading = useMessage((state) => state.status.type === "running");
+ *   return (
+ *     <div className={`message-${role}`}>
+ *       {isLoading ? "Loading..." : content.map(part => part.text).join("")}
+ *     </div>
+ *   );
+ * }
+ *
+ * // After:
+ * function MessageContent() {
+ *   const role = useAssistantState(({ message }) => message.role);
+ *   const content = useAssistantState(({ message }) => message.content);
+ *   const isLoading = useAssistantState(({ message }) => message.status.type === "running");
+ *   return (
+ *     <div className={`message-${role}`}>
+ *       {isLoading ? "Loading..." : content.map(part => part.text).join("")}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export const useMessage = createStateHookForRuntime(useMessageRuntime);
+const useEditComposerRuntime = (opt) => useMessageRuntime(opt)?.composer ?? null;
+/**
+ * @deprecated Use `useAssistantState(({ message }) => message.composer)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ */
+export const useEditComposer = createStateHookForRuntime(useEditComposerRuntime);
 //# sourceMappingURL=MessageContext.js.map

package/dist/legacy-runtime/hooks/MessageContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/legacy-runtime/hooks/MessageContext.ts"],"sourcesContent":["\"use client\";\n\nimport { MessageRuntime } from \"../runtime/MessageRuntime\";\nimport { useAssistantApi, useAssistantState } from \"../../context/react\";\nimport { createStateHookForRuntime } from \"../../context/react/utils/createStateHookForRuntime\";\nimport { EditComposerRuntime } from \"../runtime\";\n\n/**\n * @deprecated Use `useAssistantApi()` with `api.message()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\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 * // Before:\n * function MessageActions() {\n *   const runtime = useMessageRuntime();\n *   const handleReload = () => {\n *     runtime.reload();\n *   };\n *   const handleEdit = () => {\n *     runtime.startEdit();\n *   };\n *   return (\n *     <div>\n *       <button onClick={handleReload}>Reload</button>\n *       <button onClick={handleEdit}>Edit</button>\n *     </div>\n *   );\n * }\n *\n * // After:\n * function MessageActions() {\n *   const api = useAssistantApi();\n *   const handleReload = () => {\n *     api.message().reload();\n *   };\n *   const handleEdit = () => {\n *     api.message().startEdit();\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 = useAssistantState(() =>\n    api.message.source\n      ? (api.message().__internal_getRuntime?.() ?? null)\n      : null,\n  );\n  if (!runtime && !options?.optional) {\n    throw new Error(\"MessageRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * @deprecated Use `useAssistantState(({ message }) => message)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\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 * // Before:\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 *   return (\n *     <div className={`message-${role}`}>\n *       {isLoading ? \"Loading...\" : content.map(part => part.text).join(\"\")}\n *     </div>\n *   );\n * }\n *\n * // After:\n * function MessageContent() {\n *   const role = useAssistantState(({ message }) => message.role);\n *   const content = useAssistantState(({ message }) => message.content);\n *   const isLoading = useAssistantState(({ message }) => message.status.type === \"running\");\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;\n\n/**\n * @deprecated Use `useAssistantState(({ message }) => message.composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\n */\nexport const useEditComposer = createStateHookForRuntime(\n  useEditComposerRuntime,\n);\n"],"mappings":";;;AAGA,SAAS,iBAAiB,yBAAyB;AACnD,SAAS,iCAAiC;AA0DnC,SAAS,kBAAkB,SAE/B;AACD,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU;AAAA,IAAkB,MAChC,IAAI,QAAQ,SACP,IAAI,QAAQ,EAAE,wBAAwB,KAAK,OAC5C;AAAA,EACN;AACA,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AACA,SAAO;AACT;AAwCO,IAAM,aAAa,0BAA0B,iBAAiB;AAErE,IAAM,yBAAyB,CAAC,QAEE,kBAAkB,GAAG,GAAG,YAAY;AAK/D,IAAM,kBAAkB;AAAA,EAC7B;AACF;","names":[]}
+{"version":3,"file":"MessageContext.js","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/MessageContext.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAGb,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,qCAA4B;AACzE,OAAO,EAAE,yBAAyB,EAAE,+DAA4D;AA0DhG,MAAM,UAAU,iBAAiB,CAAC,OAEjC;IACC,MAAM,GAAG,GAAG,eAAe,EAAE,CAAC;IAC9B,MAAM,OAAO,GAAG,iBAAiB,CAAC,GAAG,EAAE,CACrC,GAAG,CAAC,OAAO,CAAC,MAAM;QAChB,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,qBAAqB,EAAE,EAAE,IAAI,IAAI,CAAC;QACnD,CAAC,CAAC,IAAI,CACT,CAAC;IACF,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,yBAAyB,CAAC,iBAAiB,CAAC,CAAC;AAEvE,MAAM,sBAAsB,GAAG,CAAC,GAE/B,EAA8B,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,EAAE,QAAQ,IAAI,IAAI,CAAC;AAE3E;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,yBAAyB,CACtD,sBAAsB,CACvB,CAAC"}

package/dist/legacy-runtime/hooks/MessagePartContext.d.ts

@@ -1,6 +1,6 @@
-import { MessagePartRuntime } from "../runtime/MessagePartRuntime";
+import { MessagePartRuntime } from "../runtime/MessagePartRuntime.js";
 /**
- * @deprecated Use `useAssistantApi()` with `api.part()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantApi()` with `api.part()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export declare function useMessagePartRuntime(options?: {
     optional?: false | undefined;
@@ -9,7 +9,7 @@ export declare function useMessagePartRuntime(options?: {
     optional?: boolean | undefined;
 }): MessagePartRuntime | null;
 /**
- * @deprecated Use `useAssistantState(({ part }) => part)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantState(({ part }) => part)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export declare const useMessagePart: {
     (): import("../runtime").MessagePartState;

package/dist/legacy-runtime/hooks/MessagePartContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessagePartContext.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/MessagePartContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAInE;;GAEG;AACH,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;AAc9B;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmD,CAAC"}
+{"version":3,"file":"MessagePartContext.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/MessagePartContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,yCAAsC;AAInE;;GAEG;AACH,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;AAc9B;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmD,CAAC"}

package/dist/legacy-runtime/hooks/MessagePartContext.js

@@ -1,21 +1,16 @@
 "use client";
-
-// src/legacy-runtime/hooks/MessagePartContext.ts
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime.js";
 import { useAssistantApi, useAssistantState } from "../../context/react/index.js";
-function useMessagePartRuntime(options) {
-  const api = useAssistantApi();
-  const runtime = useAssistantState(
-    () => api.part.source ? api.part().__internal_getRuntime?.() ?? null : null
-  );
-  if (!runtime && !options?.optional) {
-    throw new Error("MessagePartRuntime is not available");
-  }
-  return runtime;
+export function useMessagePartRuntime(options) {
+    const api = useAssistantApi();
+    const runtime = useAssistantState(() => api.part.source ? (api.part().__internal_getRuntime?.() ?? null) : null);
+    if (!runtime && !options?.optional) {
+        throw new Error("MessagePartRuntime is not available");
+    }
+    return runtime;
 }
-var useMessagePart = createStateHookForRuntime(useMessagePartRuntime);
-export {
-  useMessagePart,
-  useMessagePartRuntime
-};
+/**
+ * @deprecated Use `useAssistantState(({ part }) => part)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ */
+export const useMessagePart = createStateHookForRuntime(useMessagePartRuntime);
 //# sourceMappingURL=MessagePartContext.js.map

package/dist/legacy-runtime/hooks/MessagePartContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/legacy-runtime/hooks/MessagePartContext.ts"],"sourcesContent":["\"use client\";\n\nimport { MessagePartRuntime } from \"../runtime/MessagePartRuntime\";\nimport { createStateHookForRuntime } from \"../../context/react/utils/createStateHookForRuntime\";\nimport { useAssistantApi, useAssistantState } from \"../../context/react\";\n\n/**\n * @deprecated Use `useAssistantApi()` with `api.part()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\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 = useAssistantState(() =>\n    api.part.source ? (api.part().__internal_getRuntime?.() ?? null) : null,\n  );\n  if (!runtime && !options?.optional) {\n    throw new Error(\"MessagePartRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * @deprecated Use `useAssistantState(({ part }) => part)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\n */\nexport const useMessagePart = createStateHookForRuntime(useMessagePartRuntime);\n"],"mappings":";;;AAGA,SAAS,iCAAiC;AAC1C,SAAS,iBAAiB,yBAAyB;AAW5C,SAAS,sBAAsB,SAEnC;AACD,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU;AAAA,IAAkB,MAChC,IAAI,KAAK,SAAU,IAAI,KAAK,EAAE,wBAAwB,KAAK,OAAQ;AAAA,EACrE;AACA,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,qCAAqC;AAAA,EACvD;AACA,SAAO;AACT;AAKO,IAAM,iBAAiB,0BAA0B,qBAAqB;","names":[]}
+{"version":3,"file":"MessagePartContext.js","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/MessagePartContext.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAGb,OAAO,EAAE,yBAAyB,EAAE,+DAA4D;AAChG,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,qCAA4B;AAWzE,MAAM,UAAU,qBAAqB,CAAC,OAErC;IACC,MAAM,GAAG,GAAG,eAAe,EAAE,CAAC;IAC9B,MAAM,OAAO,GAAG,iBAAiB,CAAC,GAAG,EAAE,CACrC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,qBAAqB,EAAE,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CACxE,CAAC;IACF,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,yBAAyB,CAAC,qBAAqB,CAAC,CAAC"}

package/dist/legacy-runtime/hooks/ThreadContext.d.ts

@@ -1,7 +1,7 @@
-import { ThreadRuntime } from "../runtime/ThreadRuntime";
-import { ModelContext } from "../../model-context";
+import { ThreadRuntime } from "../runtime/ThreadRuntime.js";
+import { ModelContext } from "../../model-context/index.js";
 /**
- * @deprecated Use `useAssistantApi()` with `api.thread()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantApi()` with `api.thread()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  *
  * Hook to access the ThreadRuntime from the current context.
  *
@@ -40,7 +40,7 @@ export declare function useThreadRuntime(options?: {
     optional?: boolean | undefined;
 }): ThreadRuntime | null;
 /**
- * @deprecated Use `useAssistantState(({ thread }) => thread)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantState(({ thread }) => thread)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  *
  * Hook to access the current thread state.
  *
@@ -95,7 +95,7 @@ export declare const useThread: {
     }): import("../runtime").ThreadState | TSelected | null;
 };
 /**
- * @deprecated Use `useAssistantState(({ thread }) => thread.composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantState(({ thread }) => thread.composer)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export declare const useThreadComposer: {
     (): import("../runtime").ThreadComposerState;
@@ -125,7 +125,7 @@ export declare const useThreadComposer: {
     }): import("../runtime").ThreadComposerState | TSelected | null;
 };
 /**
- * @deprecated Use `useAssistantState(({ thread }) => thread.modelContext)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantState(({ thread }) => thread.modelContext)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export declare function useThreadModelContext(options?: {
     optional?: false | undefined;

package/dist/legacy-runtime/hooks/ThreadContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ThreadContext.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/ThreadContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AASnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8C,CAAC;AAMrE;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC;AAEF;;GAEG;AACH,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"}
+{"version":3,"file":"ThreadContext.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/ThreadContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,oCAAiC;AACzD,OAAO,EAAE,YAAY,EAAE,qCAA4B;AASnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8C,CAAC;AAMrE;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC;AAEF;;GAEG;AACH,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/legacy-runtime/hooks/ThreadContext.js

@@ -1,39 +1,55 @@
 "use client";
-
-// src/legacy-runtime/hooks/ThreadContext.ts
 import { useState } from "react";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime.js";
-import {
-  useAssistantApi,
-  useAssistantEvent,
-  useAssistantState
-} from "../../context/react/index.js";
-function useThreadRuntime(options) {
-  const api = useAssistantApi();
-  const runtime = useAssistantState(
-    () => api.thread.source ? api.thread().__internal_getRuntime?.() ?? null : null
-  );
-  if (!runtime && !options?.optional) {
-    throw new Error("ThreadRuntime is not available");
-  }
-  return runtime;
+import { useAssistantApi, useAssistantEvent, useAssistantState, } from "../../context/react/index.js";
+export function useThreadRuntime(options) {
+    const api = useAssistantApi();
+    const runtime = useAssistantState(() => api.thread.source ? (api.thread().__internal_getRuntime?.() ?? null) : 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();
+/**
+ * @deprecated Use `useAssistantState(({ thread }) => thread)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ *
+ * Hook to access the current thread state.
+ *
+ * This hook provides reactive access to the thread's state, including messages,
+ * running status, capabilities, and other thread-level properties.
+ *
+ * @param selector Optional selector function to pick specific state properties
+ * @returns The selected thread state or the entire thread state if no selector provided
+ *
+ * @example
+ * ```tsx
+ * // Before:
+ * function ThreadStatus() {
+ *   const isRunning = useThread((state) => state.isRunning);
+ *   const messageCount = useThread((state) => state.messages.length);
+ *   return <div>Running: {isRunning}, Messages: {messageCount}</div>;
+ * }
+ *
+ * // After:
+ * function ThreadStatus() {
+ *   const isRunning = useAssistantState(({ thread }) => thread.isRunning);
+ *   const messageCount = useAssistantState(({ thread }) => thread.messages.length);
+ *   return <div>Running: {isRunning}, Messages: {messageCount}</div>;
+ * }
+ * ```
+ */
+export const useThread = createStateHookForRuntime(useThreadRuntime);
+const useThreadComposerRuntime = (opt) => useThreadRuntime(opt)?.composer ?? null;
+/**
+ * @deprecated Use `useAssistantState(({ thread }) => thread.composer)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ */
+export const useThreadComposer = createStateHookForRuntime(useThreadComposerRuntime);
+export 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/legacy-runtime/hooks/ThreadContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/legacy-runtime/hooks/ThreadContext.ts"],"sourcesContent":["\"use client\";\n\nimport { useState } from \"react\";\nimport { ThreadRuntime } from \"../runtime/ThreadRuntime\";\nimport { ModelContext } from \"../../model-context\";\nimport { createStateHookForRuntime } from \"../../context/react/utils/createStateHookForRuntime\";\nimport { ThreadComposerRuntime } from \"../runtime\";\nimport {\n  useAssistantApi,\n  useAssistantEvent,\n  useAssistantState,\n} from \"../../context/react\";\n\n/**\n * @deprecated Use `useAssistantApi()` with `api.thread()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\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 * // Before:\n * function MyComponent() {\n *   const runtime = useThreadRuntime();\n *   const handleSendMessage = (text: string) => {\n *     runtime.append({ role: \"user\", content: [{ type: \"text\", text }] });\n *   };\n *   return <button onClick={() => handleSendMessage(\"Hello!\")}>Send</button>;\n * }\n *\n * // After:\n * function MyComponent() {\n *   const api = useAssistantApi();\n *   const handleSendMessage = (text: string) => {\n *     api.thread().append({ role: \"user\", content: [{ type: \"text\", text }] });\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 = useAssistantState(() =>\n    api.thread.source ? (api.thread().__internal_getRuntime?.() ?? null) : null,\n  );\n  if (!runtime && !options?.optional) {\n    throw new Error(\"ThreadRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * @deprecated Use `useAssistantState(({ thread }) => thread)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\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 * // Before:\n * function ThreadStatus() {\n *   const isRunning = useThread((state) => state.isRunning);\n *   const messageCount = useThread((state) => state.messages.length);\n *   return <div>Running: {isRunning}, Messages: {messageCount}</div>;\n * }\n *\n * // After:\n * function ThreadStatus() {\n *   const isRunning = useAssistantState(({ thread }) => thread.isRunning);\n *   const messageCount = useAssistantState(({ thread }) => thread.messages.length);\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;\n\n/**\n * @deprecated Use `useAssistantState(({ thread }) => thread.composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\n */\nexport const useThreadComposer = createStateHookForRuntime(\n  useThreadComposerRuntime,\n);\n\n/**\n * @deprecated Use `useAssistantState(({ thread }) => thread.modelContext)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\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;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAyCA,SAAS,iBAAiB,SAA8C;AAC7E,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU;AAAA,IAAkB,MAChC,IAAI,OAAO,SAAU,IAAI,OAAO,EAAE,wBAAwB,KAAK,OAAQ;AAAA,EACzE;AACA,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,gCAAgC;AAAA,EAClD;AACA,SAAO;AACT;AA8BO,IAAM,YAAY,0BAA0B,gBAAgB;AAEnE,IAAM,2BAA2B,CAAC,QAEE,iBAAiB,GAAG,GAAG,YAAY;AAKhE,IAAM,oBAAoB;AAAA,EAC/B;AACF;AAWO,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":[]}
+{"version":3,"file":"ThreadContext.js","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/ThreadContext.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAGjC,OAAO,EAAE,yBAAyB,EAAE,+DAA4D;AAEhG,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,iBAAiB,GAClB,qCAA4B;AAyC7B,MAAM,UAAU,gBAAgB,CAAC,OAA4C;IAC3E,MAAM,GAAG,GAAG,eAAe,EAAE,CAAC;IAC9B,MAAM,OAAO,GAAG,iBAAiB,CAAC,GAAG,EAAE,CACrC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,qBAAqB,EAAE,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAC5E,CAAC;IACF,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,yBAAyB,CAAC,gBAAgB,CAAC,CAAC;AAErE,MAAM,wBAAwB,GAAG,CAAC,GAEjC,EAAgC,EAAE,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,QAAQ,IAAI,IAAI,CAAC;AAE5E;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,yBAAyB,CACxD,wBAAwB,CACzB,CAAC;AAWF,MAAM,UAAU,qBAAqB,CAAC,OAErC;IACC,MAAM,CAAC,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC1C,iBAAiB,CAAC,6BAA6B,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;IAErE,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAC1B,OAAO,OAAO,EAAE,eAAe,EAAE,CAAC;AACpC,CAAC"}

package/dist/legacy-runtime/hooks/ThreadListItemContext.d.ts

@@ -1,6 +1,6 @@
-import { ThreadListItemRuntime } from "../runtime/ThreadListItemRuntime";
+import { ThreadListItemRuntime } from "../runtime/ThreadListItemRuntime.js";
 /**
- * @deprecated Use `useAssistantApi()` with `api.threadListItem()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantApi()` with `api.threadListItem()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export declare function useThreadListItemRuntime(options?: {
     optional?: false | undefined;
@@ -9,7 +9,7 @@ export declare function useThreadListItemRuntime(options?: {
     optional?: boolean | undefined;
 }): ThreadListItemRuntime | null;
 /**
- * @deprecated Use `useAssistantState(({ threadListItem }) => threadListItem)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAssistantState(({ threadListItem }) => threadListItem)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export declare const useThreadListItem: {
     (): import("../runtime").ThreadListItemState;

package/dist/legacy-runtime/hooks/ThreadListItemContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ThreadListItemContext.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/ThreadListItemContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAIzE;;GAEG;AACH,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;AAgBjC;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC"}
+{"version":3,"file":"ThreadListItemContext.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/ThreadListItemContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,4CAAyC;AAIzE;;GAEG;AACH,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;AAgBjC;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC"}

package/dist/legacy-runtime/hooks/ThreadListItemContext.js

@@ -1,23 +1,18 @@
 "use client";
-
-// src/legacy-runtime/hooks/ThreadListItemContext.ts
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime.js";
 import { useAssistantApi, useAssistantState } from "../../context/react/index.js";
-function useThreadListItemRuntime(options) {
-  const api = useAssistantApi();
-  const runtime = useAssistantState(
-    () => api.threadListItem.source ? api.threadListItem().__internal_getRuntime?.() ?? null : null
-  );
-  if (!runtime && !options?.optional) {
-    throw new Error("ThreadListItemRuntime is not available");
-  }
-  return runtime;
+export function useThreadListItemRuntime(options) {
+    const api = useAssistantApi();
+    const runtime = useAssistantState(() => api.threadListItem.source
+        ? (api.threadListItem().__internal_getRuntime?.() ?? null)
+        : null);
+    if (!runtime && !options?.optional) {
+        throw new Error("ThreadListItemRuntime is not available");
+    }
+    return runtime;
 }
-var useThreadListItem = createStateHookForRuntime(
-  useThreadListItemRuntime
-);
-export {
-  useThreadListItem,
-  useThreadListItemRuntime
-};
+/**
+ * @deprecated Use `useAssistantState(({ threadListItem }) => threadListItem)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ */
+export const useThreadListItem = createStateHookForRuntime(useThreadListItemRuntime);
 //# sourceMappingURL=ThreadListItemContext.js.map

package/dist/legacy-runtime/hooks/ThreadListItemContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/legacy-runtime/hooks/ThreadListItemContext.ts"],"sourcesContent":["\"use client\";\n\nimport { ThreadListItemRuntime } from \"../runtime/ThreadListItemRuntime\";\nimport { createStateHookForRuntime } from \"../../context/react/utils/createStateHookForRuntime\";\nimport { useAssistantApi, useAssistantState } from \"../../context/react\";\n\n/**\n * @deprecated Use `useAssistantApi()` with `api.threadListItem()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\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 = useAssistantState(() =>\n    api.threadListItem.source\n      ? (api.threadListItem().__internal_getRuntime?.() ?? null)\n      : null,\n  );\n  if (!runtime && !options?.optional) {\n    throw new Error(\"ThreadListItemRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * @deprecated Use `useAssistantState(({ threadListItem }) => threadListItem)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12\n */\nexport const useThreadListItem = createStateHookForRuntime(\n  useThreadListItemRuntime,\n);\n"],"mappings":";;;AAGA,SAAS,iCAAiC;AAC1C,SAAS,iBAAiB,yBAAyB;AAW5C,SAAS,yBAAyB,SAEtC;AACD,QAAM,MAAM,gBAAgB;AAC5B,QAAM,UAAU;AAAA,IAAkB,MAChC,IAAI,eAAe,SACd,IAAI,eAAe,EAAE,wBAAwB,KAAK,OACnD;AAAA,EACN;AACA,MAAI,CAAC,WAAW,CAAC,SAAS,UAAU;AAClC,UAAM,IAAI,MAAM,wCAAwC;AAAA,EAC1D;AACA,SAAO;AACT;AAKO,IAAM,oBAAoB;AAAA,EAC/B;AACF;","names":[]}
+{"version":3,"file":"ThreadListItemContext.js","sourceRoot":"","sources":["../../../src/legacy-runtime/hooks/ThreadListItemContext.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAGb,OAAO,EAAE,yBAAyB,EAAE,+DAA4D;AAChG,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,qCAA4B;AAWzE,MAAM,UAAU,wBAAwB,CAAC,OAExC;IACC,MAAM,GAAG,GAAG,eAAe,EAAE,CAAC;IAC9B,MAAM,OAAO,GAAG,iBAAiB,CAAC,GAAG,EAAE,CACrC,GAAG,CAAC,cAAc,CAAC,MAAM;QACvB,CAAC,CAAC,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,qBAAqB,EAAE,EAAE,IAAI,IAAI,CAAC;QAC1D,CAAC,CAAC,IAAI,CACT,CAAC;IACF,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,yBAAyB,CACxD,wBAAwB,CACzB,CAAC"}

package/dist/legacy-runtime/runtime/AssistantRuntime.d.ts

@@ -1,9 +1,9 @@
-import { AssistantRuntimeCore } from "../runtime-cores/core/AssistantRuntimeCore";
-import { ModelContextProvider } from "../../model-context/ModelContextTypes";
-import { ThreadRuntime } from "./ThreadRuntime";
-import { Unsubscribe } from "../../types";
-import { ThreadListRuntime, ThreadListRuntimeImpl } from "./ThreadListRuntime";
-import { ThreadMessageLike } from "../runtime-cores";
+import { AssistantRuntimeCore } from "../runtime-cores/core/AssistantRuntimeCore.js";
+import { ModelContextProvider } from "../../model-context/ModelContextTypes.js";
+import { ThreadRuntime } from "./ThreadRuntime.js";
+import { Unsubscribe } from "../../types/index.js";
+import { ThreadListRuntime, ThreadListRuntimeImpl } from "./ThreadListRuntime.js";
+import { ThreadMessageLike } from "../runtime-cores/index.js";
 export type AssistantRuntime = {
     /**
      * The threads in this assistant.

package/dist/legacy-runtime/runtime/AssistantRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantRuntime.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/runtime/AssistantRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EAA6B,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAEhF,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IAEpC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAE/B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;IAEvC;;;;OAIG;IACH,iBAAiB,IAAI,IAAI,CAAC;IAE1B;;;;;OAKG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvC;;;;OAIG;IACH,4BAA4B,CAAC,QAAQ,EAAE,oBAAoB,GAAG,WAAW,CAAC;IAE1E;;OAEG;IACH,2BAA2B,CAAC,QAAQ,EAAE,oBAAoB,GAAG,WAAW,CAAC;IAEzE;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,qBAAa,oBAAqB,YAAW,gBAAgB;IAQxC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAPzC,SAAgB,OAAO,wBAAC;IACxB,IAAW,UAAU,0BAEpB;IAED,SAAgB,OAAO,EAAE,aAAa,CAAC;gBAEH,KAAK,EAAE,oBAAoB;IAO/D,SAAS,CAAC,sBAAsB;IAUhC,IAAW,MAAM,kBAEhB;IAEM,iBAAiB;IAIjB,cAAc,CAAC,QAAQ,EAAE,MAAM;IAI/B,4BAA4B,CAAC,QAAQ,EAAE,oBAAoB;IAI3D,2BAA2B,CAAC,QAAQ,EAAE,oBAAoB;IAI1D,KAAK,CAAC,EACX,eAAe,GAChB,GAAE;QACD,eAAe,CAAC,EAAE,iBAAiB,EAAE,CAAC;KAClC;CAKP"}
+{"version":3,"file":"AssistantRuntime.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/runtime/AssistantRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,sDAAmD;AAClF,OAAO,EAAE,oBAAoB,EAAE,iDAA8C;AAC7E,OAAO,EAAE,aAAa,EAAE,2BAAwB;AAChD,OAAO,EAAE,WAAW,EAAE,6BAAoB;AAC1C,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,+BAA4B;AAC/E,OAAO,EAA6B,iBAAiB,EAAE,kCAAyB;AAEhF,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IAEpC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAE/B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;IAEvC;;;;OAIG;IACH,iBAAiB,IAAI,IAAI,CAAC;IAE1B;;;;;OAKG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvC;;;;OAIG;IACH,4BAA4B,CAAC,QAAQ,EAAE,oBAAoB,GAAG,WAAW,CAAC;IAE1E;;OAEG;IACH,2BAA2B,CAAC,QAAQ,EAAE,oBAAoB,GAAG,WAAW,CAAC;IAEzE;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,qBAAa,oBAAqB,YAAW,gBAAgB;IAQxC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAPzC,SAAgB,OAAO,wBAAC;IACxB,IAAW,UAAU,0BAEpB;IAED,SAAgB,OAAO,EAAE,aAAa,CAAC;gBAEH,KAAK,EAAE,oBAAoB;IAO/D,SAAS,CAAC,sBAAsB;IAUhC,IAAW,MAAM,kBAEhB;IAEM,iBAAiB;IAIjB,cAAc,CAAC,QAAQ,EAAE,MAAM;IAI/B,4BAA4B,CAAC,QAAQ,EAAE,oBAAoB;IAI3D,2BAA2B,CAAC,QAAQ,EAAE,oBAAoB;IAI1D,KAAK,CAAC,EACX,eAAe,GAChB,GAAE;QACD,eAAe,CAAC,EAAE,iBAAiB,EAAE,CAAC;KAClC;CAKP"}

package/dist/legacy-runtime/runtime/AssistantRuntime.js

@@ -1,47 +1,46 @@
-// src/legacy-runtime/runtime/AssistantRuntime.ts
 import { ThreadListRuntimeImpl } from "./ThreadListRuntime.js";
 import { ExportedMessageRepository } from "../runtime-cores/index.js";
-var AssistantRuntimeImpl = class {
-  constructor(_core) {
-    this._core = _core;
-    this.threads = new ThreadListRuntimeImpl(_core.threads);
-    this._thread = this.threads.main;
-    this.__internal_bindMethods();
-  }
-  threads;
-  get threadList() {
-    return this.threads;
-  }
-  _thread;
-  __internal_bindMethods() {
-    this.switchToNewThread = this.switchToNewThread.bind(this);
-    this.switchToThread = this.switchToThread.bind(this);
-    this.registerModelContextProvider = this.registerModelContextProvider.bind(this);
-    this.registerModelConfigProvider = this.registerModelConfigProvider.bind(this);
-    this.reset = this.reset.bind(this);
-  }
-  get thread() {
-    return this._thread;
-  }
-  switchToNewThread() {
-    return this._core.threads.switchToNewThread();
-  }
-  switchToThread(threadId) {
-    return this._core.threads.switchToThread(threadId);
-  }
-  registerModelContextProvider(provider) {
-    return this._core.registerModelContextProvider(provider);
-  }
-  registerModelConfigProvider(provider) {
-    return this.registerModelContextProvider(provider);
-  }
-  reset({
-    initialMessages
-  } = {}) {
-    return this._core.threads.getMainThreadRuntimeCore().import(ExportedMessageRepository.fromArray(initialMessages ?? []));
-  }
-};
-export {
-  AssistantRuntimeImpl
-};
+export class AssistantRuntimeImpl {
+    _core;
+    threads;
+    get threadList() {
+        return this.threads;
+    }
+    _thread;
+    constructor(_core) {
+        this._core = _core;
+        this.threads = new ThreadListRuntimeImpl(_core.threads);
+        this._thread = this.threads.main;
+        this.__internal_bindMethods();
+    }
+    __internal_bindMethods() {
+        this.switchToNewThread = this.switchToNewThread.bind(this);
+        this.switchToThread = this.switchToThread.bind(this);
+        this.registerModelContextProvider =
+            this.registerModelContextProvider.bind(this);
+        this.registerModelConfigProvider =
+            this.registerModelConfigProvider.bind(this);
+        this.reset = this.reset.bind(this);
+    }
+    get thread() {
+        return this._thread;
+    }
+    switchToNewThread() {
+        return this._core.threads.switchToNewThread();
+    }
+    switchToThread(threadId) {
+        return this._core.threads.switchToThread(threadId);
+    }
+    registerModelContextProvider(provider) {
+        return this._core.registerModelContextProvider(provider);
+    }
+    registerModelConfigProvider(provider) {
+        return this.registerModelContextProvider(provider);
+    }
+    reset({ initialMessages, } = {}) {
+        return this._core.threads
+            .getMainThreadRuntimeCore()
+            .import(ExportedMessageRepository.fromArray(initialMessages ?? []));
+    }
+}
 //# sourceMappingURL=AssistantRuntime.js.map

package/dist/legacy-runtime/runtime/AssistantRuntime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/legacy-runtime/runtime/AssistantRuntime.ts"],"sourcesContent":["import { AssistantRuntimeCore } from \"../runtime-cores/core/AssistantRuntimeCore\";\nimport { ModelContextProvider } from \"../../model-context/ModelContextTypes\";\nimport { ThreadRuntime } from \"./ThreadRuntime\";\nimport { Unsubscribe } from \"../../types\";\nimport { ThreadListRuntime, ThreadListRuntimeImpl } from \"./ThreadListRuntime\";\nimport { ExportedMessageRepository, ThreadMessageLike } from \"../runtime-cores\";\n\nexport type AssistantRuntime = {\n  /**\n   * The threads in this assistant.\n   */\n  readonly threads: ThreadListRuntime;\n\n  /**\n   * The currently selected main thread. Equivalent to `threads.main`.\n   */\n  readonly thread: ThreadRuntime;\n\n  /**\n   * @deprecated This field was renamed to `threads`.\n   */\n  readonly threadList: ThreadListRuntime;\n\n  /**\n   * Switch to a new thread.\n   *\n   * @deprecated This method was moved to `threads.switchToNewThread`.\n   */\n  switchToNewThread(): void;\n\n  /**\n   * Switch to a thread.\n   *\n   * @param threadId The thread ID to switch to.\n   * @deprecated This method was moved to `threads.switchToThread`.\n   */\n  switchToThread(threadId: string): void;\n\n  /**\n   * Register a model context provider. Model context providers are configuration such as system message, temperature, etc. that are set in the frontend.\n   *\n   * @param provider The model context provider to register.\n   */\n  registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;\n\n  /**\n   * @deprecated This method was renamed to `registerModelContextProvider`.\n   */\n  registerModelConfigProvider(provider: ModelContextProvider): Unsubscribe;\n\n  /**\n   * @deprecated Use `runtime.thread.reset(initialMessages)`.\n   */\n  reset: unknown; // make it a type error\n};\n\nexport class AssistantRuntimeImpl implements AssistantRuntime {\n  public readonly threads;\n  public get threadList() {\n    return this.threads;\n  }\n\n  public readonly _thread: ThreadRuntime;\n\n  public constructor(private readonly _core: AssistantRuntimeCore) {\n    this.threads = new ThreadListRuntimeImpl(_core.threads);\n    this._thread = this.threads.main;\n\n    this.__internal_bindMethods();\n  }\n\n  protected __internal_bindMethods() {\n    this.switchToNewThread = this.switchToNewThread.bind(this);\n    this.switchToThread = this.switchToThread.bind(this);\n    this.registerModelContextProvider =\n      this.registerModelContextProvider.bind(this);\n    this.registerModelConfigProvider =\n      this.registerModelConfigProvider.bind(this);\n    this.reset = this.reset.bind(this);\n  }\n\n  public get thread() {\n    return this._thread;\n  }\n\n  public switchToNewThread() {\n    return this._core.threads.switchToNewThread();\n  }\n\n  public switchToThread(threadId: string) {\n    return this._core.threads.switchToThread(threadId);\n  }\n\n  public registerModelContextProvider(provider: ModelContextProvider) {\n    return this._core.registerModelContextProvider(provider);\n  }\n\n  public registerModelConfigProvider(provider: ModelContextProvider) {\n    return this.registerModelContextProvider(provider);\n  }\n\n  public reset({\n    initialMessages,\n  }: {\n    initialMessages?: ThreadMessageLike[];\n  } = {}) {\n    return this._core.threads\n      .getMainThreadRuntimeCore()\n      .import(ExportedMessageRepository.fromArray(initialMessages ?? []));\n  }\n}\n"],"mappings":";AAIA,SAA4B,6BAA6B;AACzD,SAAS,iCAAoD;AAmDtD,IAAM,uBAAN,MAAuD;AAAA,EAQrD,YAA6B,OAA6B;AAA7B;AAClC,SAAK,UAAU,IAAI,sBAAsB,MAAM,OAAO;AACtD,SAAK,UAAU,KAAK,QAAQ;AAE5B,SAAK,uBAAuB;AAAA,EAC9B;AAAA,EAZgB;AAAA,EAChB,IAAW,aAAa;AACtB,WAAO,KAAK;AAAA,EACd;AAAA,EAEgB;AAAA,EASN,yBAAyB;AACjC,SAAK,oBAAoB,KAAK,kBAAkB,KAAK,IAAI;AACzD,SAAK,iBAAiB,KAAK,eAAe,KAAK,IAAI;AACnD,SAAK,+BACH,KAAK,6BAA6B,KAAK,IAAI;AAC7C,SAAK,8BACH,KAAK,4BAA4B,KAAK,IAAI;AAC5C,SAAK,QAAQ,KAAK,MAAM,KAAK,IAAI;AAAA,EACnC;AAAA,EAEA,IAAW,SAAS;AAClB,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,oBAAoB;AACzB,WAAO,KAAK,MAAM,QAAQ,kBAAkB;AAAA,EAC9C;AAAA,EAEO,eAAe,UAAkB;AACtC,WAAO,KAAK,MAAM,QAAQ,eAAe,QAAQ;AAAA,EACnD;AAAA,EAEO,6BAA6B,UAAgC;AAClE,WAAO,KAAK,MAAM,6BAA6B,QAAQ;AAAA,EACzD;AAAA,EAEO,4BAA4B,UAAgC;AACjE,WAAO,KAAK,6BAA6B,QAAQ;AAAA,EACnD;AAAA,EAEO,MAAM;AAAA,IACX;AAAA,EACF,IAEI,CAAC,GAAG;AACN,WAAO,KAAK,MAAM,QACf,yBAAyB,EACzB,OAAO,0BAA0B,UAAU,mBAAmB,CAAC,CAAC,CAAC;AAAA,EACtE;AACF;","names":[]}
+{"version":3,"file":"AssistantRuntime.js","sourceRoot":"","sources":["../../../src/legacy-runtime/runtime/AssistantRuntime.ts"],"names":[],"mappings":"AAIA,OAAO,EAAqB,qBAAqB,EAAE,+BAA4B;AAC/E,OAAO,EAAE,yBAAyB,EAAqB,kCAAyB;AAmDhF,MAAM,OAAO,oBAAoB;IAQK;IAPpB,OAAO,CAAC;IACxB,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAEe,OAAO,CAAgB;IAEvC,YAAoC,KAA2B;QAA3B,UAAK,GAAL,KAAK,CAAsB;QAC7D,IAAI,CAAC,OAAO,GAAG,IAAI,qBAAqB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACxD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;QAEjC,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAES,sBAAsB;QAC9B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3D,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrD,IAAI,CAAC,4BAA4B;YAC/B,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/C,IAAI,CAAC,2BAA2B;YAC9B,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAED,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAEM,iBAAiB;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAChD,CAAC;IAEM,cAAc,CAAC,QAAgB;QACpC,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IACrD,CAAC;IAEM,4BAA4B,CAAC,QAA8B;QAChE,OAAO,IAAI,CAAC,KAAK,CAAC,4BAA4B,CAAC,QAAQ,CAAC,CAAC;IAC3D,CAAC;IAEM,2BAA2B,CAAC,QAA8B;QAC/D,OAAO,IAAI,CAAC,4BAA4B,CAAC,QAAQ,CAAC,CAAC;IACrD,CAAC;IAEM,KAAK,CAAC,EACX,eAAe,MAGb,EAAE;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO;aACtB,wBAAwB,EAAE;aAC1B,MAAM,CAAC,yBAAyB,CAAC,SAAS,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,CAAC;IACxE,CAAC;CACF"}