ikoncomponents 1.6.4 → 1.6.5

package/dist/vendor/assistant-ui-react/src/legacy-runtime/hooks/ThreadContext.js

@@ -0,0 +1,54 @@
+"use client";
+import { useState } from "react";
+import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
+import { useAui, useAuiEvent, useAuiState } from "@assistant-ui/store";
+export function useThreadRuntime(options) {
+    const aui = useAui();
+    const runtime = useAuiState(() => { var _a, _b, _c; return aui.thread.source ? ((_c = (_b = (_a = aui.thread()).__internal_getRuntime) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : null) : null; });
+    if (!runtime && !(options === null || options === void 0 ? void 0 : options.optional)) {
+        throw new Error("ThreadRuntime is not available");
+    }
+    return runtime;
+}
+/**
+ * @deprecated Use `useAuiState(({ thread }) => thread)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ *
+ * Hook to access the current thread state.
+ *
+ * This hook provides reactive access to the thread's state, including messages,
+ * running status, capabilities, and other thread-level properties.
+ *
+ * @param selector Optional selector function to pick specific state properties
+ * @returns The selected thread state or the entire thread state if no selector provided
+ *
+ * @example
+ * ```tsx
+ * // Before:
+ * function ThreadStatus() {
+ *   const isRunning = useThread((state) => state.isRunning);
+ *   const messageCount = useThread((state) => state.messages.length);
+ *   return <div>Running: {isRunning}, Messages: {messageCount}</div>;
+ * }
+ *
+ * // After:
+ * function ThreadStatus() {
+ *   const isRunning = useAuiState(({ thread }) => thread.isRunning);
+ *   const messageCount = useAuiState(({ thread }) => thread.messages.length);
+ *   return <div>Running: {isRunning}, Messages: {messageCount}</div>;
+ * }
+ * ```
+ */
+export const useThread = createStateHookForRuntime(useThreadRuntime);
+const useThreadComposerRuntime = (opt) => { var _a, _b; return (_b = (_a = useThreadRuntime(opt)) === null || _a === void 0 ? void 0 : _a.composer) !== null && _b !== void 0 ? _b : null; };
+/**
+ * @deprecated Use `useAuiState(({ thread }) => thread.composer)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ */
+export const useThreadComposer = createStateHookForRuntime(useThreadComposerRuntime);
+export function useThreadModelContext(options) {
+    const [, rerender] = useState({});
+    const runtime = useThreadRuntime(options);
+    useAuiEvent("thread.modelContextUpdate", () => rerender({}));
+    if (!runtime)
+        return null;
+    return runtime === null || runtime === void 0 ? void 0 : runtime.getModelContext();
+}

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

@@ -0,0 +1,40 @@
+import { ThreadListItemRuntime } from "../runtime/ThreadListItemRuntime";
+/**
+ * @deprecated Use `useAui()` with `aui.threadListItem()` instead. See migration guide: https://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 `useAuiState(({ threadListItem }) => threadListItem)` instead. See migration guide: https://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;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/hooks/ThreadListItemContext.js

@@ -0,0 +1,20 @@
+"use client";
+import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
+import { useAui, useAuiState } from "@assistant-ui/store";
+export function useThreadListItemRuntime(options) {
+    const aui = useAui();
+    const runtime = useAuiState(() => {
+        var _a, _b, _c;
+        return aui.threadListItem.source
+            ? ((_c = (_b = (_a = aui.threadListItem()).__internal_getRuntime) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : null)
+            : null;
+    });
+    if (!runtime && !(options === null || options === void 0 ? void 0 : options.optional)) {
+        throw new Error("ThreadListItemRuntime is not available");
+    }
+    return runtime;
+}
+/**
+ * @deprecated Use `useAuiState(({ threadListItem }) => threadListItem)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ */
+export const useThreadListItem = createStateHookForRuntime(useThreadListItemRuntime);

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

@@ -0,0 +1,63 @@
+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;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/AssistantRuntime.js

@@ -0,0 +1,42 @@
+import { ThreadListRuntimeImpl } from "./ThreadListRuntime";
+import { ExportedMessageRepository } from "../runtime-cores";
+export class AssistantRuntimeImpl {
+    get threadList() {
+        return this.threads;
+    }
+    constructor(_core) {
+        this._core = _core;
+        this.threads = new ThreadListRuntimeImpl(_core.threads);
+        this._thread = this.threads.main;
+        this.__internal_bindMethods();
+    }
+    __internal_bindMethods() {
+        this.switchToNewThread = this.switchToNewThread.bind(this);
+        this.switchToThread = this.switchToThread.bind(this);
+        this.registerModelContextProvider =
+            this.registerModelContextProvider.bind(this);
+        this.registerModelConfigProvider =
+            this.registerModelConfigProvider.bind(this);
+        this.reset = this.reset.bind(this);
+    }
+    get thread() {
+        return this._thread;
+    }
+    switchToNewThread() {
+        return this._core.threads.switchToNewThread();
+    }
+    switchToThread(threadId) {
+        return this._core.threads.switchToThread(threadId);
+    }
+    registerModelContextProvider(provider) {
+        return this._core.registerModelContextProvider(provider);
+    }
+    registerModelConfigProvider(provider) {
+        return this.registerModelContextProvider(provider);
+    }
+    reset({ initialMessages, } = {}) {
+        return this._core.threads
+            .getMainThreadRuntimeCore()
+            .import(ExportedMessageRepository.fromArray(initialMessages !== null && initialMessages !== void 0 ? initialMessages : []));
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/AttachmentRuntime.d.ts

@@ -0,0 +1,62 @@
+import { SubscribableWithState } from "./subscribable/Subscribable";
+import type { ComposerRuntimeCoreBinding } from "./RuntimeBindings";
+import { Attachment, CompleteAttachment, PendingAttachment, Unsubscribe } from "../../types";
+import { AttachmentRuntimePath } from "./RuntimePathTypes";
+type MessageAttachmentState = CompleteAttachment & {
+    readonly source: "message";
+};
+type ThreadComposerAttachmentState = PendingAttachment & {
+    readonly source: "thread-composer";
+};
+type EditComposerAttachmentState = Attachment & {
+    readonly source: "edit-composer";
+};
+export type AttachmentState = ThreadComposerAttachmentState | EditComposerAttachmentState | MessageAttachmentState;
+type AttachmentSnapshotBinding<Source extends AttachmentRuntimeSource> = SubscribableWithState<AttachmentState & {
+    source: Source;
+}, AttachmentRuntimePath & {
+    attachmentSource: Source;
+}>;
+type AttachmentRuntimeSource = AttachmentState["source"];
+export type AttachmentRuntime<TSource extends AttachmentRuntimeSource = AttachmentRuntimeSource> = {
+    readonly path: AttachmentRuntimePath & {
+        attachmentSource: TSource;
+    };
+    readonly source: TSource;
+    getState(): AttachmentState & {
+        source: TSource;
+    };
+    remove(): Promise<void>;
+    subscribe(callback: () => void): Unsubscribe;
+};
+export declare abstract class AttachmentRuntimeImpl<Source extends AttachmentRuntimeSource = AttachmentRuntimeSource> implements AttachmentRuntime {
+    private _core;
+    get path(): AttachmentRuntimePath & {
+        attachmentSource: Source;
+    };
+    abstract get source(): Source;
+    constructor(_core: AttachmentSnapshotBinding<Source>);
+    protected __internal_bindMethods(): void;
+    getState(): AttachmentState & {
+        source: Source;
+    };
+    abstract remove(): Promise<void>;
+    subscribe(callback: () => void): Unsubscribe;
+}
+declare abstract class ComposerAttachmentRuntime<Source extends "thread-composer" | "edit-composer"> extends AttachmentRuntimeImpl<Source> {
+    private _composerApi;
+    constructor(core: AttachmentSnapshotBinding<Source>, _composerApi: ComposerRuntimeCoreBinding);
+    remove(): Promise<void>;
+}
+export declare class ThreadComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"thread-composer"> {
+    get source(): "thread-composer";
+}
+export declare class EditComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"edit-composer"> {
+    get source(): "edit-composer";
+}
+export declare class MessageAttachmentRuntimeImpl extends AttachmentRuntimeImpl<"message"> {
+    get source(): "message";
+    constructor(core: AttachmentSnapshotBinding<"message">);
+    remove(): never;
+}
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/AttachmentRuntime.js

@@ -0,0 +1,53 @@
+export class AttachmentRuntimeImpl {
+    get path() {
+        return this._core.path;
+    }
+    constructor(_core) {
+        this._core = _core;
+        this.__internal_bindMethods();
+    }
+    __internal_bindMethods() {
+        this.getState = this.getState.bind(this);
+        this.remove = this.remove.bind(this);
+        this.subscribe = this.subscribe.bind(this);
+    }
+    getState() {
+        return this._core.getState();
+    }
+    subscribe(callback) {
+        return this._core.subscribe(callback);
+    }
+}
+class ComposerAttachmentRuntime extends AttachmentRuntimeImpl {
+    constructor(core, _composerApi) {
+        super(core);
+        this._composerApi = _composerApi;
+    }
+    remove() {
+        const core = this._composerApi.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        return core.removeAttachment(this.getState().id);
+    }
+}
+export class ThreadComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime {
+    get source() {
+        return "thread-composer";
+    }
+}
+export class EditComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime {
+    get source() {
+        return "edit-composer";
+    }
+}
+export class MessageAttachmentRuntimeImpl extends AttachmentRuntimeImpl {
+    get source() {
+        return "message";
+    }
+    constructor(core) {
+        super(core);
+    }
+    remove() {
+        throw new Error("Message attachments cannot be removed");
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/ComposerRuntime.d.ts

@@ -0,0 +1,171 @@
+import type { Attachment, PendingAttachment } from "../../types/AttachmentTypes";
+import type { ComposerRuntimeEventType, DictationState } from "../runtime-cores/core/ComposerRuntimeCore";
+import type { Unsubscribe } from "../../types";
+import type { MessageRole, RunConfig } from "../../types/AssistantTypes";
+import type { ThreadComposerRuntimeCoreBinding, EditComposerRuntimeCoreBinding, ComposerRuntimeCoreBinding } from "./RuntimeBindings";
+import type { ComposerRuntimePath } from "./RuntimePathTypes";
+import { type AttachmentRuntime, EditComposerAttachmentRuntimeImpl, ThreadComposerAttachmentRuntimeImpl } from "./AttachmentRuntime";
+export type { ThreadComposerRuntimeCoreBinding, EditComposerRuntimeCoreBinding, ComposerRuntimeCoreBinding, };
+type BaseComposerState = {
+    readonly canCancel: boolean;
+    readonly isEditing: boolean;
+    readonly isEmpty: boolean;
+    readonly text: string;
+    readonly role: MessageRole;
+    readonly attachments: readonly Attachment[];
+    readonly runConfig: RunConfig;
+    readonly attachmentAccept: string;
+    /**
+     * The current state of dictation.
+     * Undefined when dictation is not active.
+     */
+    readonly dictation: DictationState | undefined;
+};
+export type ThreadComposerState = BaseComposerState & {
+    readonly type: "thread";
+    readonly attachments: readonly PendingAttachment[];
+};
+export type EditComposerState = BaseComposerState & {
+    readonly type: "edit";
+};
+export type ComposerState = ThreadComposerState | EditComposerState;
+export type ComposerRuntime = {
+    readonly path: ComposerRuntimePath;
+    readonly type: "edit" | "thread";
+    /**
+     * Get the current state of the composer. Includes any data that has been added to the composer.
+     */
+    getState(): ComposerState;
+    /**
+     * Given a standard js File object, add it to the composer. A composer can have multiple attachments.
+     * @param file The file to add to the composer.
+     */
+    addAttachment(file: File): Promise<void>;
+    /**
+     * Set the text of the composer.
+     * @param text The text to set in the composer.
+     */
+    setText(text: string): void;
+    /**
+     * Set the role of the composer. For instance, if you'd like a specific message to have the 'assistant' role, you can do so here.
+     * @param role The role to set in the composer.
+     */
+    setRole(role: MessageRole): void;
+    /**
+     * Set the run config of the composer. This is used to send custom configuration data to the model.
+     * Within your backend, you can access this data using the `runConfig` object.
+     * Example:
+     * ```ts
+     * composerRuntime.setRunConfig({
+     *   custom: { customField: "customValue" }
+     * });
+     * ```
+     * @param runConfig The run config to set in the composer.
+     */
+    setRunConfig(runConfig: RunConfig): void;
+    /**
+     * Reset the composer. This will clear the entire state of the composer, including all text and attachments.
+     */
+    reset(): Promise<void>;
+    /**
+     * Clear all attachments from the composer.
+     */
+    clearAttachments(): Promise<void>;
+    /**
+     * Send a message. This will send whatever text or attachments are in the composer.
+     */
+    send(): void;
+    /**
+     * Cancel the current run. In edit mode, this will exit edit mode.
+     */
+    cancel(): void;
+    /**
+     * Listens for changes to the composer state.
+     * @param callback The callback to call when the composer state changes.
+     */
+    subscribe(callback: () => void): Unsubscribe;
+    /**
+     * Get an attachment by index.
+     * @param idx The index of the attachment to get.
+     */
+    getAttachmentByIndex(idx: number): AttachmentRuntime;
+    /**
+     * Start dictation to convert voice to text input.
+     * Requires a DictationAdapter to be configured.
+     */
+    startDictation(): void;
+    /**
+     * Stop the current dictation session.
+     */
+    stopDictation(): void;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    unstable_on(event: ComposerRuntimeEventType, callback: () => void): Unsubscribe;
+};
+export declare abstract class ComposerRuntimeImpl implements ComposerRuntime {
+    protected _core: ComposerRuntimeCoreBinding;
+    get path(): ComposerRuntimePath;
+    abstract get type(): "edit" | "thread";
+    constructor(_core: ComposerRuntimeCoreBinding);
+    protected __internal_bindMethods(): void;
+    abstract getState(): ComposerState;
+    setText(text: string): void;
+    setRunConfig(runConfig: RunConfig): void;
+    addAttachment(file: File): Promise<void>;
+    reset(): Promise<void>;
+    clearAttachments(): Promise<void>;
+    send(): void;
+    cancel(): void;
+    setRole(role: MessageRole): void;
+    startDictation(): void;
+    stopDictation(): void;
+    subscribe(callback: () => void): Unsubscribe;
+    private _eventSubscriptionSubjects;
+    unstable_on(event: ComposerRuntimeEventType, callback: () => void): Unsubscribe;
+    abstract getAttachmentByIndex(idx: number): AttachmentRuntime;
+}
+export type ThreadComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
+    readonly path: ComposerRuntimePath & {
+        composerSource: "thread";
+    };
+    readonly type: "thread";
+    getState(): ThreadComposerState;
+    getAttachmentByIndex(idx: number): AttachmentRuntime & {
+        source: "thread-composer";
+    };
+};
+export declare class ThreadComposerRuntimeImpl extends ComposerRuntimeImpl implements ThreadComposerRuntime {
+    get path(): ComposerRuntimePath & {
+        composerSource: "thread";
+    };
+    get type(): "thread";
+    private _getState;
+    constructor(core: ThreadComposerRuntimeCoreBinding);
+    getState(): ThreadComposerState;
+    getAttachmentByIndex(idx: number): ThreadComposerAttachmentRuntimeImpl;
+}
+export type EditComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
+    readonly path: ComposerRuntimePath & {
+        composerSource: "edit";
+    };
+    readonly type: "edit";
+    getState(): EditComposerState;
+    beginEdit(): void;
+    getAttachmentByIndex(idx: number): AttachmentRuntime & {
+        source: "edit-composer";
+    };
+};
+export declare class EditComposerRuntimeImpl extends ComposerRuntimeImpl implements EditComposerRuntime {
+    private _beginEdit;
+    get path(): ComposerRuntimePath & {
+        composerSource: "edit";
+    };
+    get type(): "edit";
+    private _getState;
+    constructor(core: EditComposerRuntimeCoreBinding, _beginEdit: () => void);
+    __internal_bindMethods(): void;
+    getState(): EditComposerState;
+    beginEdit(): void;
+    getAttachmentByIndex(idx: number): EditComposerAttachmentRuntimeImpl;
+}