@assistant-ui/react 0.10.0 → 0.10.1

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

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

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

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

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

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

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

@@ -0,0 +1,41 @@
+import { ReadonlyStore } from "../ReadonlyStore";
+import { UseBoundStore } from "zustand";
+import { ContentPartRuntime } from "../../api/ContentPartRuntime";
+export type ContentPartContextValue = {
+    useContentPartRuntime: UseBoundStore<ReadonlyStore<ContentPartRuntime>>;
+};
+export declare const ContentPartContext: import("react").Context<ContentPartContextValue | null>;
+export declare function useContentPartRuntime(options?: {
+    optional?: false | undefined;
+}): ContentPartRuntime;
+export declare function useContentPartRuntime(options?: {
+    optional?: boolean | undefined;
+}): ContentPartRuntime | null;
+export declare const useContentPart: {
+    (): import("../..").ContentPartState;
+    <TSelected>(selector: (state: import("../..").ContentPartState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").ContentPartState) => TSelected) | undefined): import("../..").ContentPartState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").ContentPartState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").ContentPartState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").ContentPartState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").ContentPartState) => TSelected) | undefined;
+    }): import("../..").ContentPartState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").ContentPartState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").ContentPartState) => TSelected) | undefined;
+    }): import("../..").ContentPartState | TSelected | null;
+};
+//# sourceMappingURL=ContentPartContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContentPartContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/ContentPartContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGlE,MAAM,MAAM,uBAAuB,GAAG;IACpC,qBAAqB,EAAE,aAAa,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC;CACzE,CAAC;AAEF,eAAO,MAAM,kBAAkB,yDAE9B,CAAC;AAOF,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;AAS9B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmD,CAAC"}

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

@@ -0,0 +1,86 @@
+import { ReadonlyStore } from "../ReadonlyStore";
+import { MessageUtilsState } from "../stores/MessageUtils";
+import { UseBoundStore } from "zustand";
+import { MessageRuntime } from "../../api/MessageRuntime";
+export type MessageContextValue = {
+    useMessageRuntime: UseBoundStore<ReadonlyStore<MessageRuntime>>;
+    useMessageUtils: UseBoundStore<ReadonlyStore<MessageUtilsState>>;
+};
+export declare const MessageContext: import("react").Context<MessageContextValue | null>;
+export declare function useMessageRuntime(options?: {
+    optional?: false | undefined;
+}): MessageRuntime;
+export declare function useMessageRuntime(options?: {
+    optional?: boolean | undefined;
+}): MessageRuntime | null;
+export declare const useMessage: {
+    (): import("../..").MessageState;
+    <TSelected>(selector: (state: import("../..").MessageState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").MessageState) => TSelected) | undefined): import("../..").MessageState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").MessageState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").MessageState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").MessageState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").MessageState) => TSelected) | undefined;
+    }): import("../..").MessageState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").MessageState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").MessageState) => TSelected) | undefined;
+    }): import("../..").MessageState | TSelected | null;
+};
+export declare const useEditComposer: {
+    (): import("../..").EditComposerState;
+    <TSelected>(selector: (state: import("../..").EditComposerState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").EditComposerState) => TSelected) | undefined): import("../..").EditComposerState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").EditComposerState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").EditComposerState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").EditComposerState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").EditComposerState) => TSelected) | undefined;
+    }): import("../..").EditComposerState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").EditComposerState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").EditComposerState) => TSelected) | undefined;
+    }): import("../..").EditComposerState | TSelected | null;
+};
+export declare const useMessageUtils: {
+    (): MessageUtilsState;
+    <TSelected>(selector: (state: MessageUtilsState) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): MessageUtilsState | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: MessageUtilsState) => TSelected;
+    }): TSelected | null;
+}, useMessageUtilsStore: {
+    (): ReadonlyStore<MessageUtilsState>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<MessageUtilsState> | null;
+};
+//# sourceMappingURL=MessageContext.d.ts.map

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

@@ -0,0 +1 @@
+{"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,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,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+C,CAAC;AAKvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CAE3B,CAAC;AAEF,eAAO,MAAQ,eAAe;;;;;;;;;;GAAE,oBAAoB;;;;;CAGnD,CAAC"}

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

@@ -0,0 +1,75 @@
+import { ReadonlyStore } from "../ReadonlyStore";
+import { UseBoundStore } from "zustand";
+import { ThreadRuntime } from "../../api/ThreadRuntime";
+import { ModelContext } from "../../model-context";
+export type ThreadContextValue = {
+    useThreadRuntime: UseBoundStore<ReadonlyStore<ThreadRuntime>>;
+};
+export declare const ThreadContext: import("react").Context<ThreadContextValue | null>;
+export declare function useThreadRuntime(options?: {
+    optional?: false | undefined;
+}): ThreadRuntime;
+export declare function useThreadRuntime(options?: {
+    optional?: boolean | undefined;
+}): ThreadRuntime | null;
+export declare const useThread: {
+    (): import("../..").ThreadState;
+    <TSelected>(selector: (state: import("../..").ThreadState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").ThreadState) => TSelected) | undefined): import("../..").ThreadState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").ThreadState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").ThreadState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").ThreadState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").ThreadState) => TSelected) | undefined;
+    }): import("../..").ThreadState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").ThreadState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").ThreadState) => TSelected) | undefined;
+    }): import("../..").ThreadState | TSelected | null;
+};
+export declare const useThreadComposer: {
+    (): import("../..").ThreadComposerState;
+    <TSelected>(selector: (state: import("../..").ThreadComposerState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").ThreadComposerState) => TSelected) | undefined): import("../..").ThreadComposerState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").ThreadComposerState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").ThreadComposerState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").ThreadComposerState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").ThreadComposerState) => TSelected) | undefined;
+    }): import("../..").ThreadComposerState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").ThreadComposerState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").ThreadComposerState) => TSelected) | undefined;
+    }): import("../..").ThreadComposerState | TSelected | null;
+};
+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/context/react/ThreadContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/ThreadContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAInD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gBAAgB,EAAE,aAAa,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC;CAC/D,CAAC;AAEF,eAAO,MAAM,aAAa,oDAAiD,CAAC;AAO5E,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;AAOzB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8C,CAAC;AAKrE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,YAAY,CAAC;AACjB,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,YAAY,GAAG,IAAI,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadListItemContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/ThreadListItemContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAGxE,MAAM,MAAM,0BAA0B,GAAG;IACvC,wBAAwB,EAAE,aAAa,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC;CAC/E,CAAC;AAEF,eAAO,MAAM,qBAAqB,4DACsB,CAAC;AAOzD,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;AASjC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC"}

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

@@ -0,0 +1,24 @@
+import { ReadonlyStore } from "../ReadonlyStore";
+import { UseBoundStore } from "zustand";
+import { ThreadViewportState } from "../stores";
+export type ThreadViewportContextValue = {
+    useThreadViewport: UseBoundStore<ReadonlyStore<ThreadViewportState>>;
+};
+export declare const ThreadViewportContext: import("react").Context<ThreadViewportContextValue | null>;
+export declare const useThreadViewport: {
+    (): ThreadViewportState;
+    <TSelected>(selector: (state: ThreadViewportState) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): ThreadViewportState | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: ThreadViewportState) => TSelected;
+    }): TSelected | null;
+}, useThreadViewportStore: {
+    (): ReadonlyStore<ThreadViewportState>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<ThreadViewportState> | null;
+};
+//# sourceMappingURL=ThreadViewportContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadViewportContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/ThreadViewportContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEhD,MAAM,MAAM,0BAA0B,GAAG;IACvC,iBAAiB,EAAE,aAAa,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC,CAAC;CACtE,CAAC;AAEF,eAAO,MAAM,qBAAqB,4DACsB,CAAC;AAOzD,eAAO,MAAQ,iBAAiB;;;;;;;;;;GAAE,sBAAsB;;;;;CACe,CAAC"}

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

@@ -0,0 +1,14 @@
+export { useAssistantRuntime, useThreadList, useToolUIs, useToolUIsStore, } from "./AssistantContext";
+export { useThreadRuntime, useThread, useThreadComposer, useThreadModelContext, 
+/**
+ * @deprecated This method was renamed to `useThreadModelContext`.
+ */
+useThreadModelContext as useThreadModelConfig, } from "./ThreadContext";
+export { useThreadViewport, useThreadViewportStore, } from "./ThreadViewportContext";
+export { useThreadListItemRuntime, useThreadListItem, } from "./ThreadListItemContext";
+export { useMessageRuntime, useMessage, useEditComposer, useMessageUtils, useMessageUtilsStore, } from "./MessageContext";
+export { useContentPartRuntime, useContentPart } from "./ContentPartContext";
+export { useComposerRuntime, useComposer } from "./ComposerContext";
+export { useAttachment, useAttachmentRuntime, } from "./AttachmentContext";
+export { useRuntimeState } from "./utils/useRuntimeState";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/context/react/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,UAAU,EACV,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,gBAAgB,EAChB,SAAS,EACT,iBAAiB,EACjB,qBAAqB;AACrB;;GAEG;AACH,qBAAqB,IAAI,oBAAoB,GAC9C,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,wBAAwB,EACxB,iBAAiB,GAClB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,iBAAiB,EACjB,UAAU,EACV,eAAe,EACf,eAAe,EACf,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEpE,OAAO,EACL,aAAa,EACb,oBAAoB,GASrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/context/react/utils/createContextHook.d.ts

@@ -0,0 +1,11 @@
+import { Context } from "react";
+/**
+ * Creates a context hook with optional support.
+ * @param context - The React context to consume.
+ * @param providerName - The name of the provider for error messages.
+ * @returns A hook function that provides the context value.
+ */
+export declare function createContextHook<T>(context: Context<T | null>, providerName: string): (options?: {
+    optional?: boolean | undefined;
+}) => T | null;
+//# sourceMappingURL=createContextHook.d.ts.map

package/dist/context/react/utils/createContextHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createContextHook.d.ts","sourceRoot":"","sources":["../../../../src/context/react/utils/createContextHook.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,OAAO,EAAE,MAAM,OAAO,CAAC;AAE5C;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,OAAO,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,EAC1B,YAAY,EAAE,MAAM,cAEc;IAChC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,KAAG,CAAC,GAAG,IAAI,CASb"}

package/dist/context/react/utils/createContextStoreHook.d.ts

@@ -0,0 +1,26 @@
+import { ReadonlyStore } from "../../ReadonlyStore";
+/**
+ * Creates hooks for accessing a store within a context.
+ * @param contextHook - The hook to access the context.
+ * @param contextKey - The key of the store in the context.
+ * @returns An object containing the hooks: `use...` and `use...Store`.
+ */
+export declare function createContextStoreHook<T, K extends keyof T & string>(contextHook: (options?: {
+    optional?: boolean;
+}) => T | null, contextKey: K): { [P in K]: {
+    (): T[K] extends ReadonlyStore<infer S> ? S : never;
+    <TSelected>(selector: (state: T[K] extends ReadonlyStore<infer S> ? S : never) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): (T[K] extends ReadonlyStore<infer S> ? S : never) | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: T[K] extends ReadonlyStore<infer S> ? S : never) => TSelected;
+    }): TSelected | null;
+}; } & { [P in `${K}Store`]: {
+    (): ReadonlyStore<T[K] extends ReadonlyStore<infer S> ? S : never>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<T[K] extends ReadonlyStore<infer S> ? S : never> | null;
+}; };
+//# sourceMappingURL=createContextStoreHook.d.ts.map

package/dist/context/react/utils/createContextStoreHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createContextStoreHook.d.ts","sourceRoot":"","sources":["../../../../src/context/react/utils/createContextStoreHook.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAClE,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,KAAK,CAAC,GAAG,IAAI,EAC3D,UAAU,EAAE,CAAC,GAyDR,GACF,CAAC,IAAI,CAAC;yCAvD8C,CAAC;KAiBlC,SAAS,YACnB,CAAC,KAAK,mCAlBqC,CAAC,aAkB3B,KAAK,SAAS,GACxC,SAAS;cACmB;QAAE,QAAQ,EAAE,IAAI,CAAA;KAAE,GAAG,kCApBG,CAAC,iBAoBQ,IAAI;KAC9C,SAAS,WAAW;QACxC,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,CAAC,EAAE,CAAC,KAAK,mCAvBoC,CAAC,aAuB1B,KAAK,SAAS,CAAC;KAC5C,GAAG,SAAS,GAAG,IAAI;IAgCnB,GAAG,GACD,CAAC,IAAI,GAAG,CAAC,OAAO;QAtDW,aAAa,kCAHY,CAAC,cAGF;cAClB;QAClC,QAAQ,EAAE,IAAI,CAAC;KAChB,GAAG,aAAa,kCANsC,CAAC,cAM5B,GAAG,IAAI;IAoDlC,CACF"}

package/dist/context/react/utils/createStateHookForRuntime.d.ts

@@ -0,0 +1,31 @@
+import { SubscribableRuntime } from "./useRuntimeState";
+export declare function createStateHookForRuntime<TState>(useRuntime: (options: {
+    optional: boolean | undefined;
+}) => SubscribableRuntime<TState> | null): {
+    (): TState;
+    <TSelected>(selector: (state: TState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: TState) => TSelected) | undefined): TSelected | TState;
+    (options: {
+        optional?: false | undefined;
+    }): TState;
+    (options: {
+        optional?: boolean | undefined;
+    }): TState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: TState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: TState) => TSelected) | undefined;
+    }): TSelected | TState;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: TState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: TState) => TSelected) | undefined;
+    }): TSelected | TState | null;
+};
+//# sourceMappingURL=createStateHookForRuntime.d.ts.map

package/dist/context/react/utils/createStateHookForRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStateHookForRuntime.d.ts","sourceRoot":"","sources":["../../../../src/context/react/utils/createStateHookForRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EAEpB,MAAM,mBAAmB,CAAC;AAE3B,wBAAgB,yBAAyB,CAAC,MAAM,EAC9C,UAAU,EAAE,CAAC,OAAO,EAAE;IACpB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B,KAAK,mBAAmB,CAAC,MAAM,CAAC,GAAG,IAAI;QAGf,MAAM;KAGT,SAAS,YACnB,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,GACrC,SAAS;KAGU,SAAS,YACnB,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,CAAC,GAAG,SAAS,GACnD,SAAS,GAAG,MAAM;cAGU;QAAE,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAA;KAAE,GAAG,MAAM;cAGzC;QAC7B,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;KAChC,GAAG,MAAM,GAAG,IAAI;KAGK,SAAS,WAAW;QACxC,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;QAC7B,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,CAAC;KACxC,GAAG,SAAS;KAGS,SAAS,WAAW;QACxC,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;QAC7B,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,CAAC,GAAG,SAAS,CAAC;KACtD,GAAG,SAAS,GAAG,MAAM;KAGA,SAAS,WAAW;QACxC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;QAC/B,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,CAAC;KACxC,GAAG,SAAS,GAAG,IAAI;KAGE,SAAS,WAAW;QACxC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;QAC/B,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,CAAC,GAAG,SAAS,CAAC;KACtD,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI;EA6B9B"}

package/dist/context/react/utils/ensureBinding.d.ts

@@ -0,0 +1,2 @@
+export declare const ensureBinding: (r: unknown) => void;
+//# sourceMappingURL=ensureBinding.d.ts.map

package/dist/context/react/utils/ensureBinding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureBinding.d.ts","sourceRoot":"","sources":["../../../../src/context/react/utils/ensureBinding.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,aAAa,GAAI,GAAG,OAAO,SASvC,CAAC"}

package/dist/context/react/utils/useRuntimeState.d.ts

@@ -0,0 +1,10 @@
+import { Unsubscribe } from "../../../types";
+export type SubscribableRuntime<TState> = {
+    getState: () => TState;
+    subscribe: (callback: () => void) => Unsubscribe;
+};
+export declare function useRuntimeStateInternal<TState, TSelected>(runtime: SubscribableRuntime<TState>, selector?: ((state: TState) => TSelected | TState) | undefined): TSelected | TState;
+export declare function useRuntimeState<TState>(runtime: SubscribableRuntime<TState>): TState;
+export declare function useRuntimeState<TState, TSelected>(runtime: SubscribableRuntime<TState>, selector: (state: TState) => TSelected): TSelected;
+export declare function useRuntimeState<TState, TSelected>(runtime: SubscribableRuntime<TState>, selector: ((state: TState) => TSelected) | undefined): TSelected | TState;
+//# sourceMappingURL=useRuntimeState.d.ts.map

package/dist/context/react/utils/useRuntimeState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRuntimeState.d.ts","sourceRoot":"","sources":["../../../../src/context/react/utils/useRuntimeState.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG7C,MAAM,MAAM,mBAAmB,CAAC,MAAM,IAAI;IACxC,QAAQ,EAAE,MAAM,MAAM,CAAC;IACvB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,WAAW,CAAC;CAClD,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EACvD,OAAO,EAAE,mBAAmB,CAAC,MAAM,CAAC,EACpC,QAAQ,GAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,GAAG,MAAM,CAAC,GAAG,SAAoB,GACvE,SAAS,GAAG,MAAM,CAWpB;AAGD,wBAAgB,eAAe,CAAC,MAAM,EACpC,OAAO,EAAE,mBAAmB,CAAC,MAAM,CAAC,GACnC,MAAM,CAAC;AACV,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAC/C,OAAO,EAAE,mBAAmB,CAAC,MAAM,CAAC,EACpC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,GACrC,SAAS,CAAC;AACb,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAC/C,OAAO,EAAE,mBAAmB,CAAC,MAAM,CAAC,EACpC,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,SAAS,CAAC,GAAG,SAAS,GACnD,SAAS,GAAG,MAAM,CAAC"}

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

@@ -0,0 +1,14 @@
+import type { ToolCallContentPartComponent } from "../../types/ContentPartComponentTypes";
+import { Unsubscribe } from "../../types";
+export type AssistantToolUIsState = {
+    /**
+     * Get the tool UI configured for a given tool name.
+     */
+    getToolUI: (toolName: string) => ToolCallContentPartComponent | null;
+    /**
+     * Registers a tool UI for a given tool name. Returns an unsubscribe function to remove the tool UI.
+     */
+    setToolUI: (toolName: string, render: ToolCallContentPartComponent) => Unsubscribe;
+};
+export declare const makeAssistantToolUIsStore: () => import("zustand").UseBoundStore<import("zustand").StoreApi<AssistantToolUIsState>>;
+//# sourceMappingURL=AssistantToolUIs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AssistantToolUIs.d.ts","sourceRoot":"","sources":["../../../src/context/stores/AssistantToolUIs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AAC1F,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,MAAM,MAAM,qBAAqB,GAAG;IAClC;;OAEG;IACH,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,4BAA4B,GAAG,IAAI,CAAC;IAErE;;OAEG;IACH,SAAS,EAAE,CACT,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,4BAA4B,KACjC,WAAW,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,yBAAyB,0FA+BlC,CAAC"}

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

@@ -0,0 +1,8 @@
+export type MessageUtilsState = {
+    readonly isCopied: boolean;
+    readonly setIsCopied: (value: boolean) => void;
+    readonly isHovering: boolean;
+    readonly setIsHovering: (value: boolean) => void;
+};
+export declare const makeMessageUtilsStore: () => import("zustand").UseBoundStore<import("zustand").StoreApi<MessageUtilsState>>;
+//# sourceMappingURL=MessageUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MessageUtils.d.ts","sourceRoot":"","sources":["../../../src/context/stores/MessageUtils.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAE/C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAClD,CAAC;AAEF,eAAO,MAAM,qBAAqB,sFAY9B,CAAC"}

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

@@ -0,0 +1,8 @@
+import type { Unsubscribe } from "../../types/Unsubscribe";
+export type ThreadViewportState = {
+    readonly isAtBottom: boolean;
+    readonly scrollToBottom: () => void;
+    readonly onScrollToBottom: (callback: () => void) => Unsubscribe;
+};
+export declare const makeThreadViewportStore: () => import("zustand").UseBoundStore<import("zustand").StoreApi<ThreadViewportState>>;
+//# sourceMappingURL=ThreadViewport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadViewport.d.ts","sourceRoot":"","sources":["../../../src/context/stores/ThreadViewport.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,IAAI,CAAC;IACpC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,WAAW,CAAC;CAClE,CAAC;AAEF,eAAO,MAAM,uBAAuB,wFAiBnC,CAAC"}

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

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

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

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

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./api";
+export * from "./cloud";
+export * from "./context";
+export * from "./model-context";
+export * from "./primitives";
+export * from "./runtimes";
+export * from "./types";
+export * as INTERNAL from "./internal";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AAExB,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC"}

package/dist/internal.d.ts

@@ -0,0 +1,14 @@
+export type { ThreadRuntimeCore } from "./runtimes/core/ThreadRuntimeCore";
+export type { ThreadListRuntimeCore } from "./runtimes/core/ThreadListRuntimeCore";
+export { DefaultThreadComposerRuntimeCore } from "./runtimes/composer/DefaultThreadComposerRuntimeCore";
+export { CompositeContextProvider } from "./utils/CompositeContextProvider";
+export { MessageRepository } from "./runtimes/utils/MessageRepository";
+export { BaseAssistantRuntimeCore } from "./runtimes/core/BaseAssistantRuntimeCore";
+export { generateId } from "./utils/idUtils";
+export { AssistantRuntimeImpl } from "./api/AssistantRuntime";
+export { ThreadRuntimeImpl, type ThreadRuntimeCoreBinding, type ThreadListItemRuntimeBinding, } from "./api/ThreadRuntime";
+export { fromThreadMessageLike } from "./runtimes/external-store/ThreadMessageLike";
+export { getAutoStatus } from "./runtimes/external-store/auto-status";
+export { splitLocalRuntimeOptions } from "./runtimes/local/LocalRuntimeOptions";
+export * from "./utils/smooth";
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,YAAY,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,gCAAgC,EAAE,MAAM,sDAAsD,CAAC;AACxG,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AACpF,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EACL,iBAAiB,EACjB,KAAK,wBAAwB,EAC7B,KAAK,4BAA4B,GAClC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAEhF,cAAc,gBAAgB,CAAC"}

package/dist/model-context/ModelContextTypes.d.ts

@@ -0,0 +1,29 @@
+import { Unsubscribe } from "../types/Unsubscribe";
+import { Tool } from "assistant-stream";
+export type LanguageModelV1CallSettings = {
+    maxTokens?: number;
+    temperature?: number;
+    topP?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    seed?: number;
+    headers?: Record<string, string | undefined>;
+};
+export type LanguageModelConfig = {
+    apiKey?: string;
+    baseUrl?: string;
+    modelName?: string;
+};
+export type ModelContext = {
+    priority?: number | undefined;
+    system?: string | undefined;
+    tools?: Record<string, Tool<any, any>> | undefined;
+    callSettings?: LanguageModelV1CallSettings | undefined;
+    config?: LanguageModelConfig | undefined;
+};
+export type ModelContextProvider = {
+    getModelContext: () => ModelContext;
+    subscribe?: (callback: () => void) => Unsubscribe;
+};
+export declare const mergeModelContexts: (configSet: Set<ModelContextProvider>) => ModelContext;
+//# sourceMappingURL=ModelContextTypes.d.ts.map

package/dist/model-context/ModelContextTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelContextTypes.d.ts","sourceRoot":"","sources":["../../src/model-context/ModelContextTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,MAAM,MAAM,2BAA2B,GAAG;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC;IACnD,YAAY,CAAC,EAAE,2BAA2B,GAAG,SAAS,CAAC;IACvD,MAAM,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,eAAe,EAAE,MAAM,YAAY,CAAC;IACpC,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,WAAW,CAAC;CACnD,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,WAAW,GAAG,CAAC,oBAAoB,CAAC,KACnC,YAyCF,CAAC"}

package/dist/model-context/index.d.ts

@@ -0,0 +1,23 @@
+export { makeAssistantTool, type AssistantTool } from "./makeAssistantTool";
+export { type AssistantToolUI, makeAssistantToolUI, } from "./makeAssistantToolUI";
+export { useAssistantInstructions } from "./useAssistantInstructions";
+export { useAssistantTool, type AssistantToolProps } from "./useAssistantTool";
+export { useAssistantToolUI, type AssistantToolUIProps, } from "./useAssistantToolUI";
+export { useInlineRender } from "./useInlineRender";
+export type { 
+/**
+ * @deprecated This type was renamed to `ModelContext`.
+ */
+ModelContext as AssistantConfig, 
+/**
+ * @deprecated This type was renamed to `ModelContextProvider`.
+ */
+ModelContextProvider as AssistantConfigProvider, ModelContext, ModelContextProvider, } from "./ModelContextTypes";
+export type { Tool } from "assistant-stream";
+export { tool } from "./tool";
+/**
+ * @deprecated This function was renamed to `makeAssistantVisible`.
+ */
+export { makeAssistantVisible as makeAssistantReadable } from "./makeAssistantVisible";
+export { makeAssistantVisible } from "./makeAssistantVisible";
+//# sourceMappingURL=index.d.ts.map