@assistant-ui/react 0.10.49 → 0.11.0

package/src/utils/tap-store/tap-store-api.ts

@@ -0,0 +1,75 @@
+import { tapEffect, tapMemo, tapRef } from "@assistant-ui/tap";
+
+export interface ActionsObject {
+  [key: string]: ((...args: any[]) => any) | ActionsObject;
+}
+
+export type StoreApi<TState, TActions> = TActions & {
+  getState(): TState;
+};
+
+class ReadonlyStoreApiHandler<TState, TActions>
+  implements ProxyHandler<StoreApi<TState, TActions>>
+{
+  constructor(
+    private readonly getState: () => TState,
+    private readonly getActions: () => TActions,
+  ) {}
+
+  get(_: unknown, prop: string | symbol) {
+    if (prop === "getState") return this.getState;
+    return this.getActions()[prop as keyof TActions];
+  }
+
+  ownKeys(): ArrayLike<string | symbol> {
+    return ["getState", ...Object.keys(this.getActions() as object)];
+  }
+
+  has(_: unknown, prop: string | symbol) {
+    if (prop === "getState") return true;
+    return prop in (this.getActions() as object);
+  }
+
+  getOwnPropertyDescriptor(_: unknown, prop: string | symbol) {
+    if (prop === "getState")
+      return {
+        enumerable: true,
+        configurable: false,
+        get: this.getState,
+      };
+
+    return Object.getOwnPropertyDescriptor(this.getActions(), prop);
+  }
+
+  set() {
+    return false;
+  }
+  defineProperty() {
+    return false;
+  }
+  deleteProperty() {
+    return false;
+  }
+}
+
+export const tapApi = <TState, TActions extends ActionsObject>(
+  state: TState,
+  actions: TActions,
+) => {
+  const ref = tapRef(() => ({ state, actions }));
+  tapEffect(() => {
+    ref.current = { state, actions };
+  });
+
+  return tapMemo(
+    () =>
+      new Proxy<StoreApi<TState, TActions>>(
+        {} as StoreApi<TState, TActions>,
+        new ReadonlyStoreApiHandler(
+          () => ref.current.state,
+          () => ref.current.actions,
+        ),
+      ),
+    [],
+  );
+};

package/src/utils/useToolArgsFieldStatus.tsx

@@ -1,18 +1,18 @@
 import { getPartialJsonObjectFieldState } from "assistant-stream/utils";
-import { useMessagePart } from "../context";
+import { useAssistantState } from "../context";
 
 const COMPLETE_STATUS = { type: "complete" };
 
 export const useToolArgsFieldStatus = (fieldPath: (string | number)[]) => {
-  return useMessagePart((t) => {
-    if (t.type !== "tool-call")
+  return useAssistantState(({ part }) => {
+    if (part.type !== "tool-call")
       throw new Error(
         "useToolArgsFieldStatus can only be used inside tool-call message parts",
       );
 
-    const state = getPartialJsonObjectFieldState(t.args, fieldPath);
-    if (state === "complete" || t.status.type === "requires-action")
+    const state = getPartialJsonObjectFieldState(part.args, fieldPath);
+    if (state === "complete" || part.status?.type === "requires-action")
       return COMPLETE_STATUS;
-    return t.status;
+    return part.status;
   });
 };

package/dist/context/providers/AttachmentRuntimeProvider.d.ts

@@ -1,9 +0,0 @@
-import { type FC, type PropsWithChildren } from "react";
-import { AttachmentRuntime } from "../../api/AttachmentRuntime";
-export declare namespace AttachmentRuntimeProvider {
-    type Props = PropsWithChildren<{
-        runtime: AttachmentRuntime;
-    }>;
-}
-export declare const AttachmentRuntimeProvider: FC<AttachmentRuntimeProvider.Props>;
-//# sourceMappingURL=AttachmentRuntimeProvider.d.ts.map

package/dist/context/providers/AttachmentRuntimeProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AttachmentRuntimeProvider.d.ts","sourceRoot":"","sources":["../../../src/context/providers/AttachmentRuntimeProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAuB,MAAM,OAAO,CAAC;AAI7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAGhE,yBAAiB,yBAAyB,CAAC;IACzC,KAAY,KAAK,GAAG,iBAAiB,CAAC;QACpC,OAAO,EAAE,iBAAiB,CAAC;KAC5B,CAAC,CAAC;CACJ;AAcD,eAAO,MAAM,yBAAyB,EAAE,EAAE,CAAC,yBAAyB,CAAC,KAAK,CAgBzE,CAAC"}

package/dist/context/providers/AttachmentRuntimeProvider.js

@@ -1,33 +0,0 @@
-"use client";
-
-// src/context/providers/AttachmentRuntimeProvider.tsx
-import { useEffect, useState } from "react";
-import { create } from "zustand";
-import { AttachmentContext } from "../react/AttachmentContext.js";
-import { writableStore } from "../ReadonlyStore.js";
-import { ensureBinding } from "../react/utils/ensureBinding.js";
-import { jsx } from "react/jsx-runtime";
-var useAttachmentRuntimeStore = (runtime) => {
-  const [store] = useState(() => create(() => runtime));
-  useEffect(() => {
-    ensureBinding(runtime);
-    writableStore(store).setState(runtime, true);
-  }, [runtime, store]);
-  return store;
-};
-var AttachmentRuntimeProvider = ({
-  runtime,
-  children
-}) => {
-  const useAttachmentRuntime = useAttachmentRuntimeStore(runtime);
-  const [context] = useState(() => {
-    return {
-      useAttachmentRuntime
-    };
-  });
-  return /* @__PURE__ */ jsx(AttachmentContext.Provider, { value: context, children });
-};
-export {
-  AttachmentRuntimeProvider
-};
-//# sourceMappingURL=AttachmentRuntimeProvider.js.map

package/dist/context/providers/AttachmentRuntimeProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/context/providers/AttachmentRuntimeProvider.tsx"],"sourcesContent":["\"use client\";\n\nimport { type FC, type PropsWithChildren, useEffect, useState } from \"react\";\nimport { create } from \"zustand\";\nimport { AttachmentContext } from \"../react/AttachmentContext\";\nimport { writableStore } from \"../ReadonlyStore\";\nimport { AttachmentRuntime } from \"../../api/AttachmentRuntime\";\nimport { ensureBinding } from \"../react/utils/ensureBinding\";\n\nexport namespace AttachmentRuntimeProvider {\n  export type Props = PropsWithChildren<{\n    runtime: AttachmentRuntime;\n  }>;\n}\n\nconst useAttachmentRuntimeStore = (runtime: AttachmentRuntime) => {\n  const [store] = useState(() => create(() => runtime));\n\n  useEffect(() => {\n    ensureBinding(runtime);\n\n    writableStore(store).setState(runtime, true);\n  }, [runtime, store]);\n\n  return store;\n};\n\nexport const AttachmentRuntimeProvider: FC<AttachmentRuntimeProvider.Props> = ({\n  runtime,\n  children,\n}) => {\n  const useAttachmentRuntime = useAttachmentRuntimeStore(runtime);\n  const [context] = useState(() => {\n    return {\n      useAttachmentRuntime,\n    };\n  });\n\n  return (\n    <AttachmentContext.Provider value={context}>\n      {children}\n    </AttachmentContext.Provider>\n  );\n};\n"],"mappings":";;;AAEA,SAA0C,WAAW,gBAAgB;AACrE,SAAS,cAAc;AACvB,SAAS,yBAAyB;AAClC,SAAS,qBAAqB;AAE9B,SAAS,qBAAqB;AAgC1B;AAxBJ,IAAM,4BAA4B,CAAC,YAA+B;AAChE,QAAM,CAAC,KAAK,IAAI,SAAS,MAAM,OAAO,MAAM,OAAO,CAAC;AAEpD,YAAU,MAAM;AACd,kBAAc,OAAO;AAErB,kBAAc,KAAK,EAAE,SAAS,SAAS,IAAI;AAAA,EAC7C,GAAG,CAAC,SAAS,KAAK,CAAC;AAEnB,SAAO;AACT;AAEO,IAAM,4BAAiE,CAAC;AAAA,EAC7E;AAAA,EACA;AACF,MAAM;AACJ,QAAM,uBAAuB,0BAA0B,OAAO;AAC9D,QAAM,CAAC,OAAO,IAAI,SAAS,MAAM;AAC/B,WAAO;AAAA,MACL;AAAA,IACF;AAAA,EACF,CAAC;AAED,SACE,oBAAC,kBAAkB,UAAlB,EAA2B,OAAO,SAChC,UACH;AAEJ;","names":[]}

package/dist/context/providers/MessagePartRuntimeProvider.d.ts

@@ -1,9 +0,0 @@
-import { type FC, type PropsWithChildren } from "react";
-import { MessagePartRuntime } from "../../api/MessagePartRuntime";
-export declare namespace MessagePartRuntimeProvider {
-    type Props = PropsWithChildren<{
-        runtime: MessagePartRuntime;
-    }>;
-}
-export declare const MessagePartRuntimeProvider: FC<MessagePartRuntimeProvider.Props>;
-//# sourceMappingURL=MessagePartRuntimeProvider.d.ts.map

package/dist/context/providers/MessagePartRuntimeProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MessagePartRuntimeProvider.d.ts","sourceRoot":"","sources":["../../../src/context/providers/MessagePartRuntimeProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAuB,MAAM,OAAO,CAAC;AAK7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGlE,yBAAiB,0BAA0B,CAAC;IAC1C,KAAY,KAAK,GAAG,iBAAiB,CAAC;QACpC,OAAO,EAAE,kBAAkB,CAAC;KAC7B,CAAC,CAAC;CACJ;AAcD,eAAO,MAAM,0BAA0B,EAAE,EAAE,CACzC,0BAA0B,CAAC,KAAK,CAYjC,CAAC"}

package/dist/context/providers/MessagePartRuntimeProvider.js

@@ -1,28 +0,0 @@
-"use client";
-
-// src/context/providers/MessagePartRuntimeProvider.tsx
-import { useEffect, useState } from "react";
-import { create } from "zustand";
-import { MessagePartContext } from "../react/MessagePartContext.js";
-import { writableStore } from "../ReadonlyStore.js";
-import { ensureBinding } from "../react/utils/ensureBinding.js";
-import { jsx } from "react/jsx-runtime";
-var useMessagePartRuntimeStore = (runtime) => {
-  const [store] = useState(() => create(() => runtime));
-  useEffect(() => {
-    ensureBinding(runtime);
-    writableStore(store).setState(runtime, true);
-  }, [runtime, store]);
-  return store;
-};
-var MessagePartRuntimeProvider = ({ runtime, children }) => {
-  const useMessagePartRuntime = useMessagePartRuntimeStore(runtime);
-  const [context] = useState(() => {
-    return { useMessagePartRuntime };
-  });
-  return /* @__PURE__ */ jsx(MessagePartContext.Provider, { value: context, children });
-};
-export {
-  MessagePartRuntimeProvider
-};
-//# sourceMappingURL=MessagePartRuntimeProvider.js.map

package/dist/context/providers/MessagePartRuntimeProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/context/providers/MessagePartRuntimeProvider.tsx"],"sourcesContent":["\"use client\";\n\nimport { type FC, type PropsWithChildren, useEffect, useState } from \"react\";\nimport { create } from \"zustand\";\nimport { MessagePartContext } from \"../react/MessagePartContext\";\nimport type { MessagePartContextValue } from \"../react/MessagePartContext\";\nimport { writableStore } from \"../ReadonlyStore\";\nimport { MessagePartRuntime } from \"../../api/MessagePartRuntime\";\nimport { ensureBinding } from \"../react/utils/ensureBinding\";\n\nexport namespace MessagePartRuntimeProvider {\n  export type Props = PropsWithChildren<{\n    runtime: MessagePartRuntime;\n  }>;\n}\n\nconst useMessagePartRuntimeStore = (runtime: MessagePartRuntime) => {\n  const [store] = useState(() => create(() => runtime));\n\n  useEffect(() => {\n    ensureBinding(runtime);\n\n    writableStore(store).setState(runtime, true);\n  }, [runtime, store]);\n\n  return store;\n};\n\nexport const MessagePartRuntimeProvider: FC<\n  MessagePartRuntimeProvider.Props\n> = ({ runtime, children }) => {\n  const useMessagePartRuntime = useMessagePartRuntimeStore(runtime);\n  const [context] = useState<MessagePartContextValue>(() => {\n    return { useMessagePartRuntime };\n  });\n\n  return (\n    <MessagePartContext.Provider value={context}>\n      {children}\n    </MessagePartContext.Provider>\n  );\n};\n"],"mappings":";;;AAEA,SAA0C,WAAW,gBAAgB;AACrE,SAAS,cAAc;AACvB,SAAS,0BAA0B;AAEnC,SAAS,qBAAqB;AAE9B,SAAS,qBAAqB;AA6B1B;AArBJ,IAAM,6BAA6B,CAAC,YAAgC;AAClE,QAAM,CAAC,KAAK,IAAI,SAAS,MAAM,OAAO,MAAM,OAAO,CAAC;AAEpD,YAAU,MAAM;AACd,kBAAc,OAAO;AAErB,kBAAc,KAAK,EAAE,SAAS,SAAS,IAAI;AAAA,EAC7C,GAAG,CAAC,SAAS,KAAK,CAAC;AAEnB,SAAO;AACT;AAEO,IAAM,6BAET,CAAC,EAAE,SAAS,SAAS,MAAM;AAC7B,QAAM,wBAAwB,2BAA2B,OAAO;AAChE,QAAM,CAAC,OAAO,IAAI,SAAkC,MAAM;AACxD,WAAO,EAAE,sBAAsB;AAAA,EACjC,CAAC;AAED,SACE,oBAAC,mBAAmB,UAAnB,EAA4B,OAAO,SACjC,UACH;AAEJ;","names":[]}

package/dist/context/providers/MessageRuntimeProvider.d.ts

@@ -1,9 +0,0 @@
-import { type FC, type PropsWithChildren } from "react";
-import { MessageRuntime } from "../../api/MessageRuntime";
-export declare namespace MessageRuntimeProvider {
-    type Props = PropsWithChildren<{
-        runtime: MessageRuntime;
-    }>;
-}
-export declare const MessageRuntimeProvider: FC<MessageRuntimeProvider.Props>;
-//# sourceMappingURL=MessageRuntimeProvider.d.ts.map

package/dist/context/providers/MessageRuntimeProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MessageRuntimeProvider.d.ts","sourceRoot":"","sources":["../../../src/context/providers/MessageRuntimeProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAuB,MAAM,OAAO,CAAC;AAM7E,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG1D,yBAAiB,sBAAsB,CAAC;IACtC,KAAY,KAAK,GAAG,iBAAiB,CAAC;QACpC,OAAO,EAAE,cAAc,CAAC;KACzB,CAAC,CAAC;CACJ;AAmBD,eAAO,MAAM,sBAAsB,EAAE,EAAE,CAAC,sBAAsB,CAAC,KAAK,CAenE,CAAC"}

package/dist/context/providers/MessageRuntimeProvider.js

@@ -1,37 +0,0 @@
-"use client";
-
-// src/context/providers/MessageRuntimeProvider.tsx
-import { useEffect, useState } from "react";
-import { create } from "zustand";
-import { MessageContext } from "../react/MessageContext.js";
-import { makeMessageUtilsStore } from "../stores/MessageUtils.js";
-import { writableStore } from "../ReadonlyStore.js";
-import { ensureBinding } from "../react/utils/ensureBinding.js";
-import { jsx } from "react/jsx-runtime";
-var useMessageRuntimeStore = (runtime) => {
-  const [store] = useState(() => create(() => runtime));
-  useEffect(() => {
-    ensureBinding(runtime);
-    writableStore(store).setState(runtime, true);
-  }, [runtime, store]);
-  return store;
-};
-var useMessageUtilsStore = () => {
-  const [store] = useState(() => makeMessageUtilsStore());
-  return store;
-};
-var MessageRuntimeProvider = ({
-  runtime,
-  children
-}) => {
-  const useMessageRuntime = useMessageRuntimeStore(runtime);
-  const useMessageUtils = useMessageUtilsStore();
-  const [context] = useState(() => {
-    return { useMessageRuntime, useMessageUtils };
-  });
-  return /* @__PURE__ */ jsx(MessageContext.Provider, { value: context, children });
-};
-export {
-  MessageRuntimeProvider
-};
-//# sourceMappingURL=MessageRuntimeProvider.js.map

package/dist/context/providers/MessageRuntimeProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/context/providers/MessageRuntimeProvider.tsx"],"sourcesContent":["\"use client\";\n\nimport { type FC, type PropsWithChildren, useEffect, useState } from \"react\";\nimport { create } from \"zustand\";\nimport { MessageContext } from \"../react/MessageContext\";\nimport type { MessageContextValue } from \"../react/MessageContext\";\nimport { makeMessageUtilsStore } from \"../stores/MessageUtils\";\nimport { writableStore } from \"../ReadonlyStore\";\nimport { MessageRuntime } from \"../../api/MessageRuntime\";\nimport { ensureBinding } from \"../react/utils/ensureBinding\";\n\nexport namespace MessageRuntimeProvider {\n  export type Props = PropsWithChildren<{\n    runtime: MessageRuntime;\n  }>;\n}\n\nconst useMessageRuntimeStore = (runtime: MessageRuntime) => {\n  const [store] = useState(() => create(() => runtime));\n\n  useEffect(() => {\n    ensureBinding(runtime);\n\n    writableStore(store).setState(runtime, true);\n  }, [runtime, store]);\n\n  return store;\n};\n\nconst useMessageUtilsStore = () => {\n  const [store] = useState(() => makeMessageUtilsStore());\n  return store;\n};\n\nexport const MessageRuntimeProvider: FC<MessageRuntimeProvider.Props> = ({\n  runtime,\n  children,\n}) => {\n  const useMessageRuntime = useMessageRuntimeStore(runtime);\n  const useMessageUtils = useMessageUtilsStore();\n  const [context] = useState<MessageContextValue>(() => {\n    return { useMessageRuntime, useMessageUtils };\n  });\n\n  return (\n    <MessageContext.Provider value={context}>\n      {children}\n    </MessageContext.Provider>\n  );\n};\n"],"mappings":";;;AAEA,SAA0C,WAAW,gBAAgB;AACrE,SAAS,cAAc;AACvB,SAAS,sBAAsB;AAE/B,SAAS,6BAA6B;AACtC,SAAS,qBAAqB;AAE9B,SAAS,qBAAqB;AAoC1B;AA5BJ,IAAM,yBAAyB,CAAC,YAA4B;AAC1D,QAAM,CAAC,KAAK,IAAI,SAAS,MAAM,OAAO,MAAM,OAAO,CAAC;AAEpD,YAAU,MAAM;AACd,kBAAc,OAAO;AAErB,kBAAc,KAAK,EAAE,SAAS,SAAS,IAAI;AAAA,EAC7C,GAAG,CAAC,SAAS,KAAK,CAAC;AAEnB,SAAO;AACT;AAEA,IAAM,uBAAuB,MAAM;AACjC,QAAM,CAAC,KAAK,IAAI,SAAS,MAAM,sBAAsB,CAAC;AACtD,SAAO;AACT;AAEO,IAAM,yBAA2D,CAAC;AAAA,EACvE;AAAA,EACA;AACF,MAAM;AACJ,QAAM,oBAAoB,uBAAuB,OAAO;AACxD,QAAM,kBAAkB,qBAAqB;AAC7C,QAAM,CAAC,OAAO,IAAI,SAA8B,MAAM;AACpD,WAAO,EAAE,mBAAmB,gBAAgB;AAAA,EAC9C,CAAC;AAED,SACE,oBAAC,eAAe,UAAf,EAAwB,OAAO,SAC7B,UACH;AAEJ;","names":[]}

package/dist/context/providers/ThreadListItemRuntimeProvider.d.ts

@@ -1,9 +0,0 @@
-import { type FC, type PropsWithChildren } from "react";
-import { ThreadListItemRuntime } from "../../api/ThreadListItemRuntime";
-export declare namespace ThreadListItemRuntimeProvider {
-    type Props = PropsWithChildren<{
-        runtime: ThreadListItemRuntime;
-    }>;
-}
-export declare const ThreadListItemRuntimeProvider: FC<ThreadListItemRuntimeProvider.Props>;
-//# sourceMappingURL=ThreadListItemRuntimeProvider.d.ts.map

package/dist/context/providers/ThreadListItemRuntimeProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ThreadListItemRuntimeProvider.d.ts","sourceRoot":"","sources":["../../../src/context/providers/ThreadListItemRuntimeProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAuB,MAAM,OAAO,CAAC;AAO7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAGxE,yBAAiB,6BAA6B,CAAC;IAC7C,KAAY,KAAK,GAAG,iBAAiB,CAAC;QACpC,OAAO,EAAE,qBAAqB,CAAC;KAChC,CAAC,CAAC;CACJ;AAaD,eAAO,MAAM,6BAA6B,EAAE,EAAE,CAC5C,6BAA6B,CAAC,KAAK,CAYpC,CAAC"}

package/dist/context/providers/ThreadListItemRuntimeProvider.js

@@ -1,30 +0,0 @@
-"use client";
-
-// src/context/providers/ThreadListItemRuntimeProvider.tsx
-import { useEffect, useState } from "react";
-import { create } from "zustand";
-import {
-  ThreadListItemContext
-} from "../react/ThreadListItemContext.js";
-import { writableStore } from "../ReadonlyStore.js";
-import { ensureBinding } from "../react/utils/ensureBinding.js";
-import { jsx } from "react/jsx-runtime";
-var useThreadListItemRuntimeStore = (runtime) => {
-  const [store] = useState(() => create(() => runtime));
-  useEffect(() => {
-    ensureBinding(runtime);
-    writableStore(store).setState(runtime, true);
-  }, [runtime, store]);
-  return store;
-};
-var ThreadListItemRuntimeProvider = ({ runtime, children }) => {
-  const useThreadListItemRuntime = useThreadListItemRuntimeStore(runtime);
-  const [context] = useState(() => {
-    return { useThreadListItemRuntime };
-  });
-  return /* @__PURE__ */ jsx(ThreadListItemContext.Provider, { value: context, children });
-};
-export {
-  ThreadListItemRuntimeProvider
-};
-//# sourceMappingURL=ThreadListItemRuntimeProvider.js.map

package/dist/context/providers/ThreadListItemRuntimeProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/context/providers/ThreadListItemRuntimeProvider.tsx"],"sourcesContent":["\"use client\";\n\nimport { type FC, type PropsWithChildren, useEffect, useState } from \"react\";\nimport { create } from \"zustand\";\nimport {\n  ThreadListItemContext,\n  type ThreadListItemContextValue,\n} from \"../react/ThreadListItemContext\";\nimport { writableStore } from \"../ReadonlyStore\";\nimport { ThreadListItemRuntime } from \"../../api/ThreadListItemRuntime\";\nimport { ensureBinding } from \"../react/utils/ensureBinding\";\n\nexport namespace ThreadListItemRuntimeProvider {\n  export type Props = PropsWithChildren<{\n    runtime: ThreadListItemRuntime;\n  }>;\n}\n\nconst useThreadListItemRuntimeStore = (runtime: ThreadListItemRuntime) => {\n  const [store] = useState(() => create(() => runtime));\n\n  useEffect(() => {\n    ensureBinding(runtime);\n    writableStore(store).setState(runtime, true);\n  }, [runtime, store]);\n\n  return store;\n};\n\nexport const ThreadListItemRuntimeProvider: FC<\n  ThreadListItemRuntimeProvider.Props\n> = ({ runtime, children }) => {\n  const useThreadListItemRuntime = useThreadListItemRuntimeStore(runtime);\n  const [context] = useState<ThreadListItemContextValue>(() => {\n    return { useThreadListItemRuntime };\n  });\n\n  return (\n    <ThreadListItemContext.Provider value={context}>\n      {children}\n    </ThreadListItemContext.Provider>\n  );\n};\n"],"mappings":";;;AAEA,SAA0C,WAAW,gBAAgB;AACrE,SAAS,cAAc;AACvB;AAAA,EACE;AAAA,OAEK;AACP,SAAS,qBAAqB;AAE9B,SAAS,qBAAqB;AA4B1B;AApBJ,IAAM,gCAAgC,CAAC,YAAmC;AACxE,QAAM,CAAC,KAAK,IAAI,SAAS,MAAM,OAAO,MAAM,OAAO,CAAC;AAEpD,YAAU,MAAM;AACd,kBAAc,OAAO;AACrB,kBAAc,KAAK,EAAE,SAAS,SAAS,IAAI;AAAA,EAC7C,GAAG,CAAC,SAAS,KAAK,CAAC;AAEnB,SAAO;AACT;AAEO,IAAM,gCAET,CAAC,EAAE,SAAS,SAAS,MAAM;AAC7B,QAAM,2BAA2B,8BAA8B,OAAO;AACtE,QAAM,CAAC,OAAO,IAAI,SAAqC,MAAM;AAC3D,WAAO,EAAE,yBAAyB;AAAA,EACpC,CAAC;AAED,SACE,oBAAC,sBAAsB,UAAtB,EAA+B,OAAO,SACpC,UACH;AAEJ;","names":[]}

package/dist/context/providers/ThreadRuntimeProvider.d.ts

@@ -1,10 +0,0 @@
-import type { FC, PropsWithChildren } from "react";
-import { ThreadRuntime } from "../../api/ThreadRuntime";
-import { ThreadListItemRuntime } from "../../api/ThreadListItemRuntime";
-type ThreadProviderProps = {
-    listItemRuntime: ThreadListItemRuntime;
-    runtime: ThreadRuntime;
-};
-export declare const ThreadRuntimeProvider: FC<PropsWithChildren<ThreadProviderProps>>;
-export {};
-//# sourceMappingURL=ThreadRuntimeProvider.d.ts.map

package/dist/context/providers/ThreadRuntimeProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ThreadRuntimeProvider.d.ts","sourceRoot":"","sources":["../../../src/context/providers/ThreadRuntimeProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAKnD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAKxE,KAAK,mBAAmB,GAAG;IACzB,eAAe,EAAE,qBAAqB,CAAC;IACvC,OAAO,EAAE,aAAa,CAAC;CACxB,CAAC;AAeF,eAAO,MAAM,qBAAqB,EAAE,EAAE,CACpC,iBAAiB,CAAC,mBAAmB,CAAC,CAmBvC,CAAC"}

package/dist/context/providers/ThreadRuntimeProvider.js

@@ -1,33 +0,0 @@
-"use client";
-
-// src/context/providers/ThreadRuntimeProvider.tsx
-import { useEffect, useState } from "react";
-import { ThreadContext } from "../react/ThreadContext.js";
-import { writableStore } from "../ReadonlyStore.js";
-import { create } from "zustand";
-import { ThreadListItemRuntimeProvider } from "./ThreadListItemRuntimeProvider.js";
-import { ensureBinding } from "../react/utils/ensureBinding.js";
-import { ThreadViewportProvider } from "./ThreadViewportProvider.js";
-import { jsx } from "react/jsx-runtime";
-var useThreadRuntimeStore = (runtime) => {
-  const [store] = useState(() => create(() => runtime));
-  useEffect(() => {
-    ensureBinding(runtime);
-    ensureBinding(runtime.composer);
-    writableStore(store).setState(runtime, true);
-  }, [runtime, store]);
-  return store;
-};
-var ThreadRuntimeProvider = ({ children, listItemRuntime: threadListItemRuntime, runtime }) => {
-  const useThreadRuntime = useThreadRuntimeStore(runtime);
-  const [context] = useState(() => {
-    return {
-      useThreadRuntime
-    };
-  });
-  return /* @__PURE__ */ jsx(ThreadListItemRuntimeProvider, { runtime: threadListItemRuntime, children: /* @__PURE__ */ jsx(ThreadContext.Provider, { value: context, children: /* @__PURE__ */ jsx(ThreadViewportProvider, { children }) }) });
-};
-export {
-  ThreadRuntimeProvider
-};
-//# sourceMappingURL=ThreadRuntimeProvider.js.map

package/dist/context/providers/ThreadRuntimeProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/context/providers/ThreadRuntimeProvider.tsx"],"sourcesContent":["\"use client\";\n\nimport type { FC, PropsWithChildren } from \"react\";\nimport { useEffect, useState } from \"react\";\nimport type { ThreadContextValue } from \"../react/ThreadContext\";\nimport { ThreadContext } from \"../react/ThreadContext\";\nimport { writableStore } from \"../ReadonlyStore\";\nimport { ThreadRuntime } from \"../../api/ThreadRuntime\";\nimport { create } from \"zustand\";\nimport { ThreadListItemRuntime } from \"../../api/ThreadListItemRuntime\";\nimport { ThreadListItemRuntimeProvider } from \"./ThreadListItemRuntimeProvider\";\nimport { ensureBinding } from \"../react/utils/ensureBinding\";\nimport { ThreadViewportProvider } from \"./ThreadViewportProvider\";\n\ntype ThreadProviderProps = {\n  listItemRuntime: ThreadListItemRuntime;\n  runtime: ThreadRuntime;\n};\n\nconst useThreadRuntimeStore = (runtime: ThreadRuntime) => {\n  const [store] = useState(() => create(() => runtime));\n\n  useEffect(() => {\n    ensureBinding(runtime);\n    ensureBinding(runtime.composer);\n\n    writableStore(store).setState(runtime, true);\n  }, [runtime, store]);\n\n  return store;\n};\n\nexport const ThreadRuntimeProvider: FC<\n  PropsWithChildren<ThreadProviderProps>\n> = ({ children, listItemRuntime: threadListItemRuntime, runtime }) => {\n  const useThreadRuntime = useThreadRuntimeStore(runtime);\n\n  const [context] = useState<ThreadContextValue>(() => {\n    return {\n      useThreadRuntime,\n    };\n  });\n\n  return (\n    <ThreadListItemRuntimeProvider runtime={threadListItemRuntime}>\n      <ThreadContext.Provider value={context}>\n        {/* TODO temporarily allow accessing viewport state from outside the viewport */}\n        {/* TODO figure out if this behavior should be deprecated, since it is quite hacky */}\n        <ThreadViewportProvider>{children}</ThreadViewportProvider>\n      </ThreadContext.Provider>\n    </ThreadListItemRuntimeProvider>\n  );\n};\n"],"mappings":";;;AAGA,SAAS,WAAW,gBAAgB;AAEpC,SAAS,qBAAqB;AAC9B,SAAS,qBAAqB;AAE9B,SAAS,cAAc;AAEvB,SAAS,qCAAqC;AAC9C,SAAS,qBAAqB;AAC9B,SAAS,8BAA8B;AAoC/B;AA7BR,IAAM,wBAAwB,CAAC,YAA2B;AACxD,QAAM,CAAC,KAAK,IAAI,SAAS,MAAM,OAAO,MAAM,OAAO,CAAC;AAEpD,YAAU,MAAM;AACd,kBAAc,OAAO;AACrB,kBAAc,QAAQ,QAAQ;AAE9B,kBAAc,KAAK,EAAE,SAAS,SAAS,IAAI;AAAA,EAC7C,GAAG,CAAC,SAAS,KAAK,CAAC;AAEnB,SAAO;AACT;AAEO,IAAM,wBAET,CAAC,EAAE,UAAU,iBAAiB,uBAAuB,QAAQ,MAAM;AACrE,QAAM,mBAAmB,sBAAsB,OAAO;AAEtD,QAAM,CAAC,OAAO,IAAI,SAA6B,MAAM;AACnD,WAAO;AAAA,MACL;AAAA,IACF;AAAA,EACF,CAAC;AAED,SACE,oBAAC,iCAA8B,SAAS,uBACtC,8BAAC,cAAc,UAAd,EAAuB,OAAO,SAG7B,8BAAC,0BAAwB,UAAS,GACpC,GACF;AAEJ;","names":[]}

package/dist/context/react/AssistantContext.d.ts

@@ -1,85 +0,0 @@
-import type { AssistantToolUIsState } from "../stores/AssistantToolUIs";
-import { ReadonlyStore } from "../ReadonlyStore";
-import { UseBoundStore } from "zustand";
-import { AssistantRuntime } from "../../api/AssistantRuntime";
-export type AssistantContextValue = {
-    useAssistantRuntime: UseBoundStore<ReadonlyStore<AssistantRuntime>>;
-    useToolUIs: UseBoundStore<ReadonlyStore<AssistantToolUIsState>>;
-};
-export declare const AssistantContext: import("react").Context<AssistantContextValue | null>;
-export declare const useAssistantContext: (options?: {
-    optional?: boolean | undefined;
-} | undefined) => AssistantContextValue | null;
-/**
- * Hook to access the AssistantRuntime from the current context.
- *
- * The AssistantRuntime provides access to the top-level assistant state and actions,
- * including thread management, tool registration, and configuration.
- *
- * @param options Configuration options
- * @param options.optional Whether the hook should return null if no context is found
- * @returns The AssistantRuntime instance, or null if optional is true and no context exists
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const runtime = useAssistantRuntime();
- *
- *   const handleNewThread = () => {
- *     runtime.switchToNewThread();
- *   };
- *
- *   return <button onClick={handleNewThread}>New Thread</button>;
- * }
- * ```
- */
-export declare function useAssistantRuntime(options?: {
-    optional?: false | undefined;
-}): AssistantRuntime;
-export declare function useAssistantRuntime(options?: {
-    optional?: boolean | undefined;
-}): AssistantRuntime | null;
-export declare const useToolUIs: {
-    (): AssistantToolUIsState;
-    <TSelected>(selector: (state: AssistantToolUIsState) => TSelected): TSelected;
-    (options: {
-        optional: true;
-    }): AssistantToolUIsState | null;
-    <TSelected>(options: {
-        optional: true;
-        selector?: (state: AssistantToolUIsState) => TSelected;
-    }): TSelected | null;
-}, useToolUIsStore: {
-    (): ReadonlyStore<AssistantToolUIsState>;
-    (options: {
-        optional: true;
-    }): ReadonlyStore<AssistantToolUIsState> | null;
-};
-export declare const useThreadList: {
-    (): import("../..").ThreadListState;
-    <TSelected>(selector: (state: import("../..").ThreadListState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../..").ThreadListState) => TSelected) | undefined): import("../..").ThreadListState | TSelected;
-    (options: {
-        optional?: false | undefined;
-    }): import("../..").ThreadListState;
-    (options: {
-        optional?: boolean | undefined;
-    }): import("../..").ThreadListState | null;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: (state: import("../..").ThreadListState) => TSelected;
-    }): TSelected;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: ((state: import("../..").ThreadListState) => TSelected) | undefined;
-    }): import("../..").ThreadListState | TSelected;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: (state: import("../..").ThreadListState) => TSelected;
-    }): TSelected | null;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: ((state: import("../..").ThreadListState) => TSelected) | undefined;
-    }): import("../..").ThreadListState | TSelected | null;
-};
-//# sourceMappingURL=AssistantContext.d.ts.map

package/dist/context/react/AssistantContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AssistantContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/AssistantContext.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAI9D,MAAM,MAAM,qBAAqB,GAAG;IAClC,mBAAmB,EAAE,aAAa,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC;IACpE,UAAU,EAAE,aAAa,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC;CACjE,CAAC;AAEF,eAAO,MAAM,gBAAgB,uDAE5B,CAAC;AAEF,eAAO,MAAM,mBAAmB;;8CAG/B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE;IAC5C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,gBAAgB,CAAC;AACrB,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE;IAC5C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,gBAAgB,GAAG,IAAI,CAAC;AAS5B,eAAO,MAAQ,UAAU;;;;;;;;;;GAAE,eAAe;;;;;CAGzC,CAAC;AAKF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkD,CAAC"}

package/dist/context/react/AssistantContext.js

@@ -1,34 +0,0 @@
-"use client";
-
-// src/context/react/AssistantContext.ts
-import { createContext } from "react";
-import { createContextHook } from "./utils/createContextHook.js";
-import { createContextStoreHook } from "./utils/createContextStoreHook.js";
-import { createStateHookForRuntime } from "./utils/createStateHookForRuntime.js";
-var AssistantContext = createContext(
-  null
-);
-var useAssistantContext = createContextHook(
-  AssistantContext,
-  "AssistantRuntimeProvider"
-);
-function useAssistantRuntime(options) {
-  const context = useAssistantContext(options);
-  if (!context) return null;
-  return context.useAssistantRuntime();
-}
-var { useToolUIs, useToolUIsStore } = createContextStoreHook(
-  useAssistantContext,
-  "useToolUIs"
-);
-var useThreadListRuntime = (opt) => useAssistantRuntime(opt)?.threads ?? null;
-var useThreadList = createStateHookForRuntime(useThreadListRuntime);
-export {
-  AssistantContext,
-  useAssistantContext,
-  useAssistantRuntime,
-  useThreadList,
-  useToolUIs,
-  useToolUIsStore
-};
-//# sourceMappingURL=AssistantContext.js.map

package/dist/context/react/AssistantContext.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/context/react/AssistantContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport type { AssistantToolUIsState } from \"../stores/AssistantToolUIs\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { createContextStoreHook } from \"./utils/createContextStoreHook\";\nimport { UseBoundStore } from \"zustand\";\nimport { AssistantRuntime } from \"../../api/AssistantRuntime\";\nimport { ThreadListRuntime } from \"../../api/ThreadListRuntime\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\n\nexport type AssistantContextValue = {\n  useAssistantRuntime: UseBoundStore<ReadonlyStore<AssistantRuntime>>;\n  useToolUIs: UseBoundStore<ReadonlyStore<AssistantToolUIsState>>;\n};\n\nexport const AssistantContext = createContext<AssistantContextValue | null>(\n  null,\n);\n\nexport const useAssistantContext = createContextHook(\n  AssistantContext,\n  \"AssistantRuntimeProvider\",\n);\n\n/**\n * Hook to access the AssistantRuntime from the current context.\n *\n * The AssistantRuntime provides access to the top-level assistant state and actions,\n * including thread management, tool registration, and configuration.\n *\n * @param options Configuration options\n * @param options.optional Whether the hook should return null if no context is found\n * @returns The AssistantRuntime instance, or null if optional is true and no context exists\n *\n * @example\n * ```tsx\n * function MyComponent() {\n *   const runtime = useAssistantRuntime();\n *\n *   const handleNewThread = () => {\n *     runtime.switchToNewThread();\n *   };\n *\n *   return <button onClick={handleNewThread}>New Thread</button>;\n * }\n * ```\n */\nexport function useAssistantRuntime(options?: {\n  optional?: false | undefined;\n}): AssistantRuntime;\nexport function useAssistantRuntime(options?: {\n  optional?: boolean | undefined;\n}): AssistantRuntime | null;\nexport function useAssistantRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const context = useAssistantContext(options);\n  if (!context) return null;\n  return context.useAssistantRuntime();\n}\n\nexport const { useToolUIs, useToolUIsStore } = createContextStoreHook(\n  useAssistantContext,\n  \"useToolUIs\",\n);\n\nconst useThreadListRuntime = (opt: {\n  optional: boolean | undefined;\n}): ThreadListRuntime | null => useAssistantRuntime(opt)?.threads ?? null;\nexport const useThreadList = createStateHookForRuntime(useThreadListRuntime);\n"],"mappings":";;;AAEA,SAAS,qBAAqB;AAG9B,SAAS,yBAAyB;AAClC,SAAS,8BAA8B;AAIvC,SAAS,iCAAiC;AAOnC,IAAM,mBAAmB;AAAA,EAC9B;AACF;AAEO,IAAM,sBAAsB;AAAA,EACjC;AAAA,EACA;AACF;AA+BO,SAAS,oBAAoB,SAEjC;AACD,QAAM,UAAU,oBAAoB,OAAO;AAC3C,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,oBAAoB;AACrC;AAEO,IAAM,EAAE,YAAY,gBAAgB,IAAI;AAAA,EAC7C;AAAA,EACA;AACF;AAEA,IAAM,uBAAuB,CAAC,QAEE,oBAAoB,GAAG,GAAG,WAAW;AAC9D,IAAM,gBAAgB,0BAA0B,oBAAoB;","names":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"AttachmentContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/AttachmentContext.ts"],"names":[],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/context/react/AttachmentContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { AttachmentRuntime } from \"../../api/AttachmentRuntime\";\nimport { UseBoundStore } from \"zustand\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\n\nexport type AttachmentContextValue = {\n  useAttachmentRuntime: UseBoundStore<ReadonlyStore<AttachmentRuntime>>;\n};\n\nexport const AttachmentContext = createContext<AttachmentContextValue | null>(\n  null,\n);\n\nconst useAttachmentContext = createContextHook(\n  AttachmentContext,\n  \"a ComposerPrimitive.Attachments or MessagePrimitive.Attachments component\",\n);\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 attachmentRuntime = useAttachmentContext(options);\n  if (!attachmentRuntime) return null;\n  return attachmentRuntime.useAttachmentRuntime();\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":";;;AAEA,SAAS,qBAAqB;AAI9B,SAAS,yBAAyB;AAClC,SAAS,iCAAiC;AAMnC,IAAM,oBAAoB;AAAA,EAC/B;AACF;AAEA,IAAM,uBAAuB;AAAA,EAC3B;AAAA,EACA;AACF;AAQO,SAAS,qBAAqB,SAER;AAC3B,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,SAAO,kBAAkB,qBAAqB;AAChD;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.map

@@ -1 +0,0 @@
-{"version":3,"file":"ComposerContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/ComposerContext.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;AAW3B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAC"}

package/dist/context/react/ComposerContext.js

@@ -1,17 +0,0 @@
-"use client";
-
-// src/context/react/ComposerContext.ts
-import { useMessageRuntime } from "./MessageContext.js";
-import { useThreadRuntime } from "./ThreadContext.js";
-import { createStateHookForRuntime } from "./utils/createStateHookForRuntime.js";
-function useComposerRuntime(options) {
-  const messageRuntime = useMessageRuntime({ optional: true });
-  const threadRuntime = useThreadRuntime(options);
-  return messageRuntime ? messageRuntime.composer : threadRuntime?.composer ?? null;
-}
-var useComposer = createStateHookForRuntime(useComposerRuntime);
-export {
-  useComposer,
-  useComposerRuntime
-};
-//# sourceMappingURL=ComposerContext.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/context/react/ComposerContext.ts"],"sourcesContent":["\"use client\";\n\nimport { useMessageRuntime } from \"./MessageContext\";\nimport { useThreadRuntime } from \"./ThreadContext\";\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 messageRuntime = useMessageRuntime({ optional: true });\n  const threadRuntime = useThreadRuntime(options);\n  return messageRuntime\n    ? messageRuntime.composer\n    : (threadRuntime?.composer ?? null);\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,yBAAyB;AAClC,SAAS,wBAAwB;AAEjC,SAAS,iCAAiC;AA8CnC,SAAS,mBAAmB,SAER;AACzB,QAAM,iBAAiB,kBAAkB,EAAE,UAAU,KAAK,CAAC;AAC3D,QAAM,gBAAgB,iBAAiB,OAAO;AAC9C,SAAO,iBACH,eAAe,WACd,eAAe,YAAY;AAClC;AA4BO,IAAM,cAAc,0BAA0B,kBAAkB;","names":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"MessageContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/MessageContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAG3D,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAI1D,MAAM,MAAM,mBAAmB,GAAG;IAChC,iBAAiB,EAAE,aAAa,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC;IAChE,eAAe,EAAE,aAAa,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC;CAClE,CAAC;AAEF,eAAO,MAAM,cAAc,qDAAkD,CAAC;AAO9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;AAS1B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+C,CAAC;AAKvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CAE3B,CAAC;AAEF,eAAO,MAAQ,eAAe;;;;;;;;;;GAAE,oBAAoB;;;;;CAGnD,CAAC"}

package/dist/context/react/MessageContext.js

@@ -1,35 +0,0 @@
-"use client";
-
-// src/context/react/MessageContext.ts
-import { createContext } from "react";
-import { createContextHook } from "./utils/createContextHook.js";
-import { createContextStoreHook } from "./utils/createContextStoreHook.js";
-import { createStateHookForRuntime } from "./utils/createStateHookForRuntime.js";
-var MessageContext = createContext(null);
-var useMessageContext = createContextHook(
-  MessageContext,
-  "a component passed to <ThreadPrimitive.Messages components={...} />"
-);
-function useMessageRuntime(options) {
-  const context = useMessageContext(options);
-  if (!context) return null;
-  return context.useMessageRuntime();
-}
-var useMessage = createStateHookForRuntime(useMessageRuntime);
-var useEditComposerRuntime = (opt) => useMessageRuntime(opt)?.composer ?? null;
-var useEditComposer = createStateHookForRuntime(
-  useEditComposerRuntime
-);
-var { useMessageUtils, useMessageUtilsStore } = createContextStoreHook(
-  useMessageContext,
-  "useMessageUtils"
-);
-export {
-  MessageContext,
-  useEditComposer,
-  useMessage,
-  useMessageRuntime,
-  useMessageUtils,
-  useMessageUtilsStore
-};
-//# sourceMappingURL=MessageContext.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/context/react/MessageContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { MessageUtilsState } from \"../stores/MessageUtils\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { createContextStoreHook } from \"./utils/createContextStoreHook\";\nimport { UseBoundStore } from \"zustand\";\nimport { MessageRuntime } from \"../../api/MessageRuntime\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\nimport { EditComposerRuntime } from \"../../api\";\n\nexport type MessageContextValue = {\n  useMessageRuntime: UseBoundStore<ReadonlyStore<MessageRuntime>>;\n  useMessageUtils: UseBoundStore<ReadonlyStore<MessageUtilsState>>;\n};\n\nexport const MessageContext = createContext<MessageContextValue | null>(null);\n\nconst useMessageContext = createContextHook(\n  MessageContext,\n  \"a component passed to <ThreadPrimitive.Messages components={...} />\",\n);\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 context = useMessageContext(options);\n  if (!context) return null;\n  return context.useMessageRuntime();\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\nexport const { useMessageUtils, useMessageUtilsStore } = createContextStoreHook(\n  useMessageContext,\n  \"useMessageUtils\",\n);\n"],"mappings":";;;AAEA,SAAS,qBAAqB;AAG9B,SAAS,yBAAyB;AAClC,SAAS,8BAA8B;AAGvC,SAAS,iCAAiC;AAQnC,IAAM,iBAAiB,cAA0C,IAAI;AAE5E,IAAM,oBAAoB;AAAA,EACxB;AAAA,EACA;AACF;AAwCO,SAAS,kBAAkB,SAE/B;AACD,QAAM,UAAU,kBAAkB,OAAO;AACzC,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,kBAAkB;AACnC;AA0BO,IAAM,aAAa,0BAA0B,iBAAiB;AAErE,IAAM,yBAAyB,CAAC,QAEE,kBAAkB,GAAG,GAAG,YAAY;AAC/D,IAAM,kBAAkB;AAAA,EAC7B;AACF;AAEO,IAAM,EAAE,iBAAiB,qBAAqB,IAAI;AAAA,EACvD;AAAA,EACA;AACF;","names":[]}