@assistant-ui/react-ag-ui 0.0.6 → 0.0.7

package/dist/react/src/legacy-runtime/hooks/AttachmentContext.d.ts.map

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

package/dist/react/src/legacy-runtime/hooks/ComposerContext.d.ts

@@ -1,138 +0,0 @@
-import { ComposerRuntime } from "../runtime/ComposerRuntime";
-/**
- * @deprecated Use `useAssistantApi()` with `api.composer()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
- *
- * Hook to access the ComposerRuntime from the current context.
- *
- * The ComposerRuntime provides access to composer state and actions for message
- * composition, including text input, attachments, and sending functionality.
- * This hook automatically resolves to either the message's edit composer or
- * the thread's main composer depending on the context.
- *
- * @param options Configuration options
- * @param options.optional Whether the hook should return null if no context is found
- * @returns The ComposerRuntime instance, or null if optional is true and no context exists
- *
- * @example
- * ```tsx
- * // Before:
- * function ComposerActions() {
- *   const runtime = useComposerRuntime();
- *   const handleSend = () => {
- *     if (runtime.getState().canSend) {
- *       runtime.send();
- *     }
- *   };
- *   const handleCancel = () => {
- *     if (runtime.getState().canCancel) {
- *       runtime.cancel();
- *     }
- *   };
- *   return (
- *     <div>
- *       <button onClick={handleSend}>Send</button>
- *       <button onClick={handleCancel}>Cancel</button>
- *     </div>
- *   );
- * }
- *
- * // After:
- * function ComposerActions() {
- *   const api = useAssistantApi();
- *   const canSend = useAssistantState(({ composer }) => composer.canSend);
- *   const canCancel = useAssistantState(({ composer }) => composer.canCancel);
- *   const handleSend = () => {
- *     if (canSend) {
- *       api.composer().send();
- *     }
- *   };
- *   const handleCancel = () => {
- *     if (canCancel) {
- *       api.composer().cancel();
- *     }
- *   };
- *   return (
- *     <div>
- *       <button onClick={handleSend}>Send</button>
- *       <button onClick={handleCancel}>Cancel</button>
- *     </div>
- *   );
- * }
- * ```
- */
-export declare function useComposerRuntime(options?: {
-    optional?: false | undefined;
-}): ComposerRuntime;
-export declare function useComposerRuntime(options?: {
-    optional?: boolean | undefined;
-}): ComposerRuntime | null;
-/**
- * @deprecated Use `useAssistantState(({ composer }) => composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
- *
- * Hook to access the current composer state.
- *
- * This hook provides reactive access to the composer's state, including text content,
- * attachments, editing status, and send/cancel capabilities.
- *
- * @param selector Optional selector function to pick specific state properties
- * @returns The selected composer state or the entire composer state if no selector provided
- *
- * @example
- * ```tsx
- * // Before:
- * function ComposerStatus() {
- *   const text = useComposer((state) => state.text);
- *   const canSend = useComposer((state) => state.canSend);
- *   const attachmentCount = useComposer((state) => state.attachments.length);
- *   return (
- *     <div>
- *       Text: {text.length} chars,
- *       Attachments: {attachmentCount},
- *       Can send: {canSend}
- *     </div>
- *   );
- * }
- *
- * // After:
- * function ComposerStatus() {
- *   const text = useAssistantState(({ composer }) => composer.text);
- *   const canSend = useAssistantState(({ composer }) => composer.canSend);
- *   const attachmentCount = useAssistantState(({ composer }) => composer.attachments.length);
- *   return (
- *     <div>
- *       Text: {text.length} chars,
- *       Attachments: {attachmentCount},
- *       Can send: {canSend}
- *     </div>
- *   );
- * }
- * ```
- */
-export declare const useComposer: {
-    (): import("../runtime").ComposerState;
-    <TSelected>(selector: (state: import("../runtime").ComposerState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../runtime").ComposerState) => TSelected) | undefined): import("../runtime").ComposerState | TSelected;
-    (options: {
-        optional?: false | undefined;
-    }): import("../runtime").ComposerState;
-    (options: {
-        optional?: boolean | undefined;
-    }): import("../runtime").ComposerState | null;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: (state: import("../runtime").ComposerState) => TSelected;
-    }): TSelected;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: ((state: import("../runtime").ComposerState) => TSelected) | undefined;
-    }): import("../runtime").ComposerState | TSelected;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: (state: import("../runtime").ComposerState) => TSelected;
-    }): TSelected | null;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: ((state: import("../runtime").ComposerState) => TSelected) | undefined;
-    }): import("../runtime").ComposerState | TSelected | null;
-};
-//# sourceMappingURL=ComposerContext.d.ts.map

package/dist/react/src/legacy-runtime/hooks/ComposerContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ComposerContext.d.ts","sourceRoot":"","sources":["../../../../../../react/src/legacy-runtime/hooks/ComposerContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;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;AAgB3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAC"}

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

@@ -1,152 +0,0 @@
-import { MessageRuntime } from "../runtime/MessageRuntime";
-/**
- * @deprecated Use `useAssistantApi()` with `api.message()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
- *
- * Hook to access the MessageRuntime from the current context.
- *
- * The MessageRuntime provides access to message-level state and actions,
- * including message content, status, editing capabilities, and branching.
- *
- * @param options Configuration options
- * @param options.optional Whether the hook should return null if no context is found
- * @returns The MessageRuntime instance, or null if optional is true and no context exists
- *
- * @example
- * ```tsx
- * // Before:
- * function MessageActions() {
- *   const runtime = useMessageRuntime();
- *   const handleReload = () => {
- *     runtime.reload();
- *   };
- *   const handleEdit = () => {
- *     runtime.startEdit();
- *   };
- *   return (
- *     <div>
- *       <button onClick={handleReload}>Reload</button>
- *       <button onClick={handleEdit}>Edit</button>
- *     </div>
- *   );
- * }
- *
- * // After:
- * function MessageActions() {
- *   const api = useAssistantApi();
- *   const handleReload = () => {
- *     api.message().reload();
- *   };
- *   const handleEdit = () => {
- *     api.message().startEdit();
- *   };
- *   return (
- *     <div>
- *       <button onClick={handleReload}>Reload</button>
- *       <button onClick={handleEdit}>Edit</button>
- *     </div>
- *   );
- * }
- * ```
- */
-export declare function useMessageRuntime(options?: {
-    optional?: false | undefined;
-}): MessageRuntime;
-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
- *
- * 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 declare const useMessage: {
-    (): import("../runtime").MessageState;
-    <TSelected>(selector: (state: import("../runtime").MessageState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../runtime").MessageState) => TSelected) | undefined): import("../runtime").MessageState | TSelected;
-    (options: {
-        optional?: false | undefined;
-    }): import("../runtime").MessageState;
-    (options: {
-        optional?: boolean | undefined;
-    }): import("../runtime").MessageState | null;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: (state: import("../runtime").MessageState) => TSelected;
-    }): TSelected;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: ((state: import("../runtime").MessageState) => TSelected) | undefined;
-    }): import("../runtime").MessageState | TSelected;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: (state: import("../runtime").MessageState) => TSelected;
-    }): TSelected | null;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: ((state: import("../runtime").MessageState) => TSelected) | undefined;
-    }): import("../runtime").MessageState | TSelected | null;
-};
-/**
- * @deprecated Use `useAssistantState(({ message }) => message.composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
- */
-export declare const useEditComposer: {
-    (): import("../runtime").EditComposerState;
-    <TSelected>(selector: (state: import("../runtime").EditComposerState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../runtime").EditComposerState) => TSelected) | undefined): import("../runtime").EditComposerState | TSelected;
-    (options: {
-        optional?: false | undefined;
-    }): import("../runtime").EditComposerState;
-    (options: {
-        optional?: boolean | undefined;
-    }): import("../runtime").EditComposerState | null;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: (state: import("../runtime").EditComposerState) => TSelected;
-    }): TSelected;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: ((state: import("../runtime").EditComposerState) => TSelected) | undefined;
-    }): import("../runtime").EditComposerState | TSelected;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: (state: import("../runtime").EditComposerState) => TSelected;
-    }): TSelected | null;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: ((state: import("../runtime").EditComposerState) => TSelected) | undefined;
-    }): import("../runtime").EditComposerState | TSelected | null;
-};
-//# sourceMappingURL=MessageContext.d.ts.map

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

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

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

@@ -1,41 +0,0 @@
-import { MessagePartRuntime } from "../runtime/MessagePartRuntime";
-/**
- * @deprecated Use `useAssistantApi()` with `api.part()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
- */
-export declare function useMessagePartRuntime(options?: {
-    optional?: false | undefined;
-}): MessagePartRuntime;
-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
- */
-export declare const useMessagePart: {
-    (): import("../runtime").MessagePartState;
-    <TSelected>(selector: (state: import("../runtime").MessagePartState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../runtime").MessagePartState) => TSelected) | undefined): import("../runtime").MessagePartState | TSelected;
-    (options: {
-        optional?: false | undefined;
-    }): import("../runtime").MessagePartState;
-    (options: {
-        optional?: boolean | undefined;
-    }): import("../runtime").MessagePartState | null;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: (state: import("../runtime").MessagePartState) => TSelected;
-    }): TSelected;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: ((state: import("../runtime").MessagePartState) => TSelected) | undefined;
-    }): import("../runtime").MessagePartState | TSelected;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: (state: import("../runtime").MessagePartState) => TSelected;
-    }): TSelected | null;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: ((state: import("../runtime").MessagePartState) => TSelected) | undefined;
-    }): import("../runtime").MessagePartState | TSelected | null;
-};
-//# sourceMappingURL=MessagePartContext.d.ts.map

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

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

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

@@ -1,136 +0,0 @@
-import { ThreadRuntime } from "../runtime/ThreadRuntime";
-import { ModelContext } from "../../model-context";
-/**
- * @deprecated Use `useAssistantApi()` with `api.thread()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
- *
- * Hook to access the ThreadRuntime from the current context.
- *
- * The ThreadRuntime provides access to thread-level state and actions,
- * including message management, thread state, and composer functionality.
- *
- * @param options Configuration options
- * @param options.optional Whether the hook should return null if no context is found
- * @returns The ThreadRuntime instance, or null if optional is true and no context exists
- *
- * @example
- * ```tsx
- * // Before:
- * function MyComponent() {
- *   const runtime = useThreadRuntime();
- *   const handleSendMessage = (text: string) => {
- *     runtime.append({ role: "user", content: [{ type: "text", text }] });
- *   };
- *   return <button onClick={() => handleSendMessage("Hello!")}>Send</button>;
- * }
- *
- * // After:
- * function MyComponent() {
- *   const api = useAssistantApi();
- *   const handleSendMessage = (text: string) => {
- *     api.thread().append({ role: "user", content: [{ type: "text", text }] });
- *   };
- *   return <button onClick={() => handleSendMessage("Hello!")}>Send</button>;
- * }
- * ```
- */
-export declare function useThreadRuntime(options?: {
-    optional?: false | undefined;
-}): ThreadRuntime;
-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
- *
- * 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 declare const useThread: {
-    (): import("../runtime").ThreadState;
-    <TSelected>(selector: (state: import("../runtime").ThreadState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../runtime").ThreadState) => TSelected) | undefined): import("../runtime").ThreadState | TSelected;
-    (options: {
-        optional?: false | undefined;
-    }): import("../runtime").ThreadState;
-    (options: {
-        optional?: boolean | undefined;
-    }): import("../runtime").ThreadState | null;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: (state: import("../runtime").ThreadState) => TSelected;
-    }): TSelected;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: ((state: import("../runtime").ThreadState) => TSelected) | undefined;
-    }): import("../runtime").ThreadState | TSelected;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: (state: import("../runtime").ThreadState) => TSelected;
-    }): TSelected | null;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: ((state: import("../runtime").ThreadState) => TSelected) | undefined;
-    }): import("../runtime").ThreadState | TSelected | null;
-};
-/**
- * @deprecated Use `useAssistantState(({ thread }) => thread.composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
- */
-export declare const useThreadComposer: {
-    (): import("../runtime").ThreadComposerState;
-    <TSelected>(selector: (state: import("../runtime").ThreadComposerState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../runtime").ThreadComposerState) => TSelected) | undefined): import("../runtime").ThreadComposerState | TSelected;
-    (options: {
-        optional?: false | undefined;
-    }): import("../runtime").ThreadComposerState;
-    (options: {
-        optional?: boolean | undefined;
-    }): import("../runtime").ThreadComposerState | null;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: (state: import("../runtime").ThreadComposerState) => TSelected;
-    }): TSelected;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: ((state: import("../runtime").ThreadComposerState) => TSelected) | undefined;
-    }): import("../runtime").ThreadComposerState | TSelected;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: (state: import("../runtime").ThreadComposerState) => TSelected;
-    }): TSelected | null;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: ((state: import("../runtime").ThreadComposerState) => TSelected) | undefined;
-    }): import("../runtime").ThreadComposerState | TSelected | null;
-};
-/**
- * @deprecated Use `useAssistantState(({ thread }) => thread.modelContext)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
- */
-export declare function useThreadModelContext(options?: {
-    optional?: false | undefined;
-}): ModelContext;
-export declare function useThreadModelContext(options?: {
-    optional?: boolean | undefined;
-}): ModelContext | null;
-//# sourceMappingURL=ThreadContext.d.ts.map

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

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

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

@@ -1,41 +0,0 @@
-import { ThreadListItemRuntime } from "../runtime/ThreadListItemRuntime";
-/**
- * @deprecated Use `useAssistantApi()` with `api.threadListItem()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
- */
-export declare function useThreadListItemRuntime(options?: {
-    optional?: false | undefined;
-}): ThreadListItemRuntime;
-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
- */
-export declare const useThreadListItem: {
-    (): import("../runtime").ThreadListItemState;
-    <TSelected>(selector: (state: import("../runtime").ThreadListItemState) => TSelected): TSelected;
-    <TSelected>(selector: ((state: import("../runtime").ThreadListItemState) => TSelected) | undefined): import("../runtime").ThreadListItemState | TSelected;
-    (options: {
-        optional?: false | undefined;
-    }): import("../runtime").ThreadListItemState;
-    (options: {
-        optional?: boolean | undefined;
-    }): import("../runtime").ThreadListItemState | null;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: (state: import("../runtime").ThreadListItemState) => TSelected;
-    }): TSelected;
-    <TSelected>(options: {
-        optional?: false | undefined;
-        selector: ((state: import("../runtime").ThreadListItemState) => TSelected) | undefined;
-    }): import("../runtime").ThreadListItemState | TSelected;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: (state: import("../runtime").ThreadListItemState) => TSelected;
-    }): TSelected | null;
-    <TSelected>(options: {
-        optional?: boolean | undefined;
-        selector: ((state: import("../runtime").ThreadListItemState) => TSelected) | undefined;
-    }): import("../runtime").ThreadListItemState | TSelected | null;
-};
-//# sourceMappingURL=ThreadListItemContext.d.ts.map

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

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

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

@@ -1,64 +0,0 @@
-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";
-export type AssistantRuntime = {
-    /**
-     * The threads in this assistant.
-     */
-    readonly threads: ThreadListRuntime;
-    /**
-     * The currently selected main thread. Equivalent to `threads.main`.
-     */
-    readonly thread: ThreadRuntime;
-    /**
-     * @deprecated This field was renamed to `threads`.
-     */
-    readonly threadList: ThreadListRuntime;
-    /**
-     * Switch to a new thread.
-     *
-     * @deprecated This method was moved to `threads.switchToNewThread`.
-     */
-    switchToNewThread(): void;
-    /**
-     * Switch to a thread.
-     *
-     * @param threadId The thread ID to switch to.
-     * @deprecated This method was moved to `threads.switchToThread`.
-     */
-    switchToThread(threadId: string): void;
-    /**
-     * Register a model context provider. Model context providers are configuration such as system message, temperature, etc. that are set in the frontend.
-     *
-     * @param provider The model context provider to register.
-     */
-    registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
-    /**
-     * @deprecated This method was renamed to `registerModelContextProvider`.
-     */
-    registerModelConfigProvider(provider: ModelContextProvider): Unsubscribe;
-    /**
-     * @deprecated Use `runtime.thread.reset(initialMessages)`.
-     */
-    reset: unknown;
-};
-export declare class AssistantRuntimeImpl implements AssistantRuntime {
-    private readonly _core;
-    readonly threads: ThreadListRuntimeImpl;
-    get threadList(): ThreadListRuntimeImpl;
-    readonly _thread: ThreadRuntime;
-    constructor(_core: AssistantRuntimeCore);
-    protected __internal_bindMethods(): void;
-    get thread(): ThreadRuntime;
-    switchToNewThread(): Promise<void>;
-    switchToThread(threadId: string): Promise<void>;
-    registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
-    registerModelConfigProvider(provider: ModelContextProvider): Unsubscribe;
-    reset({ initialMessages, }?: {
-        initialMessages?: ThreadMessageLike[];
-    }): void;
-}
-//# sourceMappingURL=AssistantRuntime.d.ts.map

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

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