ikoncomponents 1.6.4 → 1.6.5

package/dist/vendor/assistant-ui-react/src/context/react/utils/createStateHookForRuntime.d.ts

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

package/dist/vendor/assistant-ui-react/src/context/react/utils/createStateHookForRuntime.js

@@ -0,0 +1,20 @@
+import { useRuntimeStateInternal, } from "./useRuntimeState";
+export function createStateHookForRuntime(useRuntime) {
+    function useStoreHook(param) {
+        let optional = false;
+        let selector;
+        if (typeof param === "function") {
+            selector = param;
+        }
+        else if (param) {
+            optional = !!param.optional;
+            selector = param.selector;
+        }
+        const store = useRuntime({ optional });
+        if (!store)
+            return null;
+        // it is ok to call useRuntimeStateInternal conditionally because it will never become null if its available
+        return useRuntimeStateInternal(store, selector);
+    }
+    return useStoreHook;
+}

package/dist/vendor/assistant-ui-react/src/context/react/utils/ensureBinding.d.ts

@@ -0,0 +1 @@
+export declare const ensureBinding: (r: unknown) => void;

package/dist/vendor/assistant-ui-react/src/context/react/utils/ensureBinding.js

@@ -0,0 +1,31 @@
+const debugVerifyPrototype = (runtime, prototype) => {
+    const unboundMethods = Object.getOwnPropertyNames(prototype).filter((methodStr) => {
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, methodStr);
+        const isMethod = descriptor && typeof descriptor.value === "function";
+        if (!isMethod)
+            return false;
+        const methodName = methodStr;
+        return (isMethod &&
+            !methodName.startsWith("_") &&
+            methodName !== "constructor" &&
+            prototype[methodName] === runtime[methodName]);
+    });
+    if (unboundMethods.length > 0) {
+        throw new Error(`The following methods are not bound: ${JSON.stringify(unboundMethods)}`);
+    }
+    const prototypePrototype = Object.getPrototypeOf(prototype);
+    if (prototypePrototype && prototypePrototype !== Object.prototype) {
+        debugVerifyPrototype(runtime, prototypePrototype);
+    }
+};
+export const ensureBinding = (r) => {
+    var _a;
+    const runtime = r;
+    if (runtime.__isBound)
+        return;
+    (_a = runtime.__internal_bindMethods) === null || _a === void 0 ? void 0 : _a.call(runtime);
+    runtime.__isBound = true;
+    if (process.env["NODE_ENV"] !== "production") {
+        debugVerifyPrototype(runtime, Object.getPrototypeOf(runtime));
+    }
+};

package/dist/vendor/assistant-ui-react/src/context/react/utils/useRuntimeState.d.ts

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

package/dist/vendor/assistant-ui-react/src/context/react/utils/useRuntimeState.js

@@ -0,0 +1,15 @@
+import { useDebugValue, useSyncExternalStore } from "react";
+import { ensureBinding } from "./ensureBinding";
+export function useRuntimeStateInternal(runtime, selector = identity) {
+    // TODO move to useRuntimeState
+    ensureBinding(runtime);
+    const slice = useSyncExternalStore(runtime.subscribe, () => selector(runtime.getState()), () => selector(runtime.getState()));
+    useDebugValue(slice);
+    return slice;
+}
+const identity = (arg) => arg;
+export function useRuntimeState(runtime, selector) {
+    // ensure that the runtime is bound
+    // ensureBinding(runtime);
+    return useRuntimeStateInternal(runtime, selector);
+}

package/dist/vendor/assistant-ui-react/src/context/stores/ThreadViewport.d.ts

@@ -0,0 +1,37 @@
+import type { Unsubscribe } from "../../types/Unsubscribe";
+export type SizeHandle = {
+    /** Update the height */
+    setHeight: (height: number) => void;
+    /** Unregister this handle */
+    unregister: Unsubscribe;
+};
+export type ThreadViewportState = {
+    readonly isAtBottom: boolean;
+    readonly scrollToBottom: (config?: {
+        behavior?: ScrollBehavior | undefined;
+    }) => void;
+    readonly onScrollToBottom: (callback: ({ behavior }: {
+        behavior: ScrollBehavior;
+    }) => void) => Unsubscribe;
+    /** Controls scroll anchoring: "top" anchors user messages at top, "bottom" is classic behavior */
+    readonly turnAnchor: "top" | "bottom";
+    /** Raw height values from registered elements */
+    readonly height: {
+        /** Total viewport height */
+        readonly viewport: number;
+        /** Total content inset height (footer, anchor message, etc.) */
+        readonly inset: number;
+        /** Height of the anchor user message (full height) */
+        readonly userMessage: number;
+    };
+    /** Register a viewport and get a handle to update its height */
+    readonly registerViewport: () => SizeHandle;
+    /** Register a content inset (footer, anchor message, etc.) and get a handle to update its height */
+    readonly registerContentInset: () => SizeHandle;
+    /** Register the anchor user message height */
+    readonly registerUserMessageHeight: () => SizeHandle;
+};
+export type ThreadViewportStoreOptions = {
+    turnAnchor?: "top" | "bottom" | undefined;
+};
+export declare const makeThreadViewportStore: (options?: ThreadViewportStoreOptions) => import("zustand").UseBoundStore<import("zustand").StoreApi<ThreadViewportState>>;

package/dist/vendor/assistant-ui-react/src/context/stores/ThreadViewport.js

@@ -0,0 +1,75 @@
+"use client";
+import { create } from "zustand";
+const createSizeRegistry = (onChange) => {
+    const entries = new Map();
+    const recalculate = () => {
+        let total = 0;
+        for (const height of entries.values()) {
+            total += height;
+        }
+        onChange(total);
+    };
+    return {
+        register: () => {
+            const id = Symbol();
+            entries.set(id, 0);
+            return {
+                setHeight: (height) => {
+                    if (entries.get(id) !== height) {
+                        entries.set(id, height);
+                        recalculate();
+                    }
+                },
+                unregister: () => {
+                    entries.delete(id);
+                    recalculate();
+                },
+            };
+        },
+    };
+};
+export const makeThreadViewportStore = (options = {}) => {
+    const scrollToBottomListeners = new Set();
+    const viewportRegistry = createSizeRegistry((total) => {
+        store.setState({
+            height: Object.assign(Object.assign({}, store.getState().height), { viewport: total }),
+        });
+    });
+    const insetRegistry = createSizeRegistry((total) => {
+        store.setState({
+            height: Object.assign(Object.assign({}, store.getState().height), { inset: total }),
+        });
+    });
+    const userMessageRegistry = createSizeRegistry((total) => {
+        store.setState({
+            height: Object.assign(Object.assign({}, store.getState().height), { userMessage: total }),
+        });
+    });
+    const store = create(() => {
+        var _a;
+        return ({
+            isAtBottom: true,
+            scrollToBottom: ({ behavior = "auto" } = {}) => {
+                for (const listener of scrollToBottomListeners) {
+                    listener({ behavior });
+                }
+            },
+            onScrollToBottom: (callback) => {
+                scrollToBottomListeners.add(callback);
+                return () => {
+                    scrollToBottomListeners.delete(callback);
+                };
+            },
+            turnAnchor: (_a = options.turnAnchor) !== null && _a !== void 0 ? _a : "bottom",
+            height: {
+                viewport: 0,
+                inset: 0,
+                userMessage: 0,
+            },
+            registerViewport: viewportRegistry.register,
+            registerContentInset: insetRegistry.register,
+            registerUserMessageHeight: userMessageRegistry.register,
+        });
+    });
+    return store;
+};

package/dist/vendor/assistant-ui-react/src/context/stores/index.d.ts

@@ -0,0 +1 @@
+export type { ThreadViewportState } from "./ThreadViewport";

package/dist/vendor/assistant-ui-react/src/context/stores/index.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/devtools/DevToolsHooks.d.ts

@@ -0,0 +1,33 @@
+import { AssistantClient } from "@assistant-ui/store";
+import { Unsubscribe } from "../types";
+export interface EventLog {
+    time: Date;
+    event: string;
+    data: unknown;
+}
+interface DevToolsApiEntry {
+    api: Partial<AssistantClient>;
+    logs: EventLog[];
+}
+interface DevToolsHook {
+    apis: Map<number, DevToolsApiEntry>;
+    nextId: number;
+    listeners: Set<(apiId: number) => void>;
+}
+declare global {
+    interface Window {
+        __ASSISTANT_UI_DEVTOOLS_HOOK__?: DevToolsHook;
+    }
+}
+export declare class DevToolsHooks {
+    static subscribe(listener: () => void): Unsubscribe;
+    static clearEventLogs(apiId: number): void;
+    static getApis(): Map<number, DevToolsApiEntry>;
+    private static notifyListeners;
+}
+export declare class DevToolsProviderApi {
+    private static readonly MAX_EVENT_LOGS_PER_API;
+    static register(aui: Partial<AssistantClient>): Unsubscribe;
+    private static notifyListeners;
+}
+export {};

package/dist/vendor/assistant-ui-react/src/devtools/DevToolsHooks.js

@@ -0,0 +1,98 @@
+let cachedHook;
+const getHook = () => {
+    if (cachedHook) {
+        return cachedHook;
+    }
+    const createHook = () => ({
+        apis: new Map(),
+        nextId: 0,
+        listeners: new Set(),
+    });
+    if (typeof window === "undefined") {
+        cachedHook = createHook();
+        return cachedHook;
+    }
+    const existingHook = window.__ASSISTANT_UI_DEVTOOLS_HOOK__;
+    if (existingHook) {
+        cachedHook = existingHook;
+        return existingHook;
+    }
+    const newHook = createHook();
+    window.__ASSISTANT_UI_DEVTOOLS_HOOK__ = newHook;
+    cachedHook = newHook;
+    return newHook;
+};
+export class DevToolsHooks {
+    static subscribe(listener) {
+        const hook = getHook();
+        hook.listeners.add(listener);
+        return () => {
+            hook.listeners.delete(listener);
+        };
+    }
+    static clearEventLogs(apiId) {
+        const hook = getHook();
+        const entry = hook.apis.get(apiId);
+        if (!entry)
+            return;
+        entry.logs = [];
+        DevToolsHooks.notifyListeners(apiId);
+    }
+    static getApis() {
+        return getHook().apis;
+    }
+    static notifyListeners(apiId) {
+        const hook = getHook();
+        hook.listeners.forEach((listener) => listener(apiId));
+    }
+}
+export class DevToolsProviderApi {
+    static register(aui) {
+        var _a, _b;
+        const hook = getHook();
+        for (const entry of hook.apis.values()) {
+            if (entry.api === aui) {
+                return () => { };
+            }
+        }
+        const apiId = hook.nextId++;
+        const entry = {
+            api: aui,
+            logs: [],
+        };
+        const eventUnsubscribe = (_a = aui.on) === null || _a === void 0 ? void 0 : _a.call(aui, "*", (e) => {
+            const entry = hook.apis.get(apiId);
+            if (!entry)
+                return;
+            entry.logs.push({
+                time: new Date(),
+                event: e.event,
+                data: e.payload,
+            });
+            if (entry.logs.length > DevToolsProviderApi.MAX_EVENT_LOGS_PER_API) {
+                entry.logs = entry.logs.slice(-DevToolsProviderApi.MAX_EVENT_LOGS_PER_API);
+            }
+            DevToolsProviderApi.notifyListeners(apiId);
+        });
+        const stateUnsubscribe = (_b = aui.subscribe) === null || _b === void 0 ? void 0 : _b.call(aui, () => {
+            DevToolsProviderApi.notifyListeners(apiId);
+        });
+        hook.apis.set(apiId, entry);
+        DevToolsProviderApi.notifyListeners(apiId);
+        return () => {
+            const hook = getHook();
+            const entry = hook.apis.get(apiId);
+            if (!entry)
+                return;
+            eventUnsubscribe === null || eventUnsubscribe === void 0 ? void 0 : eventUnsubscribe();
+            stateUnsubscribe === null || stateUnsubscribe === void 0 ? void 0 : stateUnsubscribe();
+            hook.apis.delete(apiId);
+            DevToolsProviderApi.notifyListeners(apiId);
+        };
+    }
+    static notifyListeners(apiId) {
+        const hook = getHook();
+        hook.listeners.forEach((listener) => listener(apiId));
+    }
+}
+DevToolsProviderApi.MAX_EVENT_LOGS_PER_API = 200;

package/dist/vendor/assistant-ui-react/src/devtools/index.d.ts

@@ -0,0 +1 @@
+export { DevToolsHooks, DevToolsProviderApi } from "./DevToolsHooks";

package/dist/vendor/assistant-ui-react/src/devtools/index.js

@@ -0,0 +1 @@
+export { DevToolsHooks, DevToolsProviderApi } from "./DevToolsHooks";

package/dist/vendor/assistant-ui-react/src/index.d.ts

@@ -0,0 +1,30 @@
+import "./types/store-augmentation";
+export { useAui, AuiProvider, useAuiState, useAuiEvent, AuiIf, type AssistantClient, type AssistantState, type AssistantEventScope, type AssistantEventSelector, type AssistantEventName, type AssistantEventPayload, type AssistantEventCallback, } from "@assistant-ui/store";
+export * from "./legacy-runtime/runtime";
+export * from "./legacy-runtime/cloud";
+export * from "./legacy-runtime/runtime-cores";
+export * from "./context";
+export * from "./model-context";
+export * from "./primitives";
+export * from "./types";
+export * from "./devtools";
+export * from "./client";
+export * as INTERNAL from "./internal";
+export type { ToolExecutionStatus } from "./internal";
+export type { Assistant } from "./augmentations";
+/**
+ * @deprecated Use `useAui` instead. This alias will be removed in v0.13.
+ */
+export { useAui as useAssistantApi } from "@assistant-ui/store";
+/**
+ * @deprecated Use `useAuiState` instead. This alias will be removed in v0.13.
+ */
+export { useAuiState as useAssistantState } from "@assistant-ui/store";
+/**
+ * @deprecated Use `useAuiEvent` instead. This alias will be removed in v0.13.
+ */
+export { useAuiEvent as useAssistantEvent } from "@assistant-ui/store";
+/**
+ * @deprecated Use `AuiIf` instead. This alias will be removed in v0.13.
+ */
+export { AuiIf as AssistantIf } from "@assistant-ui/store";

package/dist/vendor/assistant-ui-react/src/index.js

@@ -0,0 +1,32 @@
+import "./types/store-augmentation";
+// Re-export from @assistant-ui/store
+export { useAui, AuiProvider, useAuiState, useAuiEvent, AuiIf, } from "@assistant-ui/store";
+export * from "./legacy-runtime/runtime";
+export * from "./legacy-runtime/cloud";
+export * from "./legacy-runtime/runtime-cores";
+export * from "./context";
+export * from "./model-context";
+export * from "./primitives";
+export * from "./types";
+export * from "./devtools";
+export * from "./client";
+export * as INTERNAL from "./internal";
+// ============================================================================
+// Backwards compatibility - deprecated exports
+// ============================================================================
+/**
+ * @deprecated Use `useAui` instead. This alias will be removed in v0.13.
+ */
+export { useAui as useAssistantApi } from "@assistant-ui/store";
+/**
+ * @deprecated Use `useAuiState` instead. This alias will be removed in v0.13.
+ */
+export { useAuiState as useAssistantState } from "@assistant-ui/store";
+/**
+ * @deprecated Use `useAuiEvent` instead. This alias will be removed in v0.13.
+ */
+export { useAuiEvent as useAssistantEvent } from "@assistant-ui/store";
+/**
+ * @deprecated Use `AuiIf` instead. This alias will be removed in v0.13.
+ */
+export { AuiIf as AssistantIf } from "@assistant-ui/store";

package/dist/vendor/assistant-ui-react/src/internal.d.ts

@@ -0,0 +1,14 @@
+export type { ThreadRuntimeCore } from "./legacy-runtime/runtime-cores/core/ThreadRuntimeCore";
+export type { ThreadListRuntimeCore } from "./legacy-runtime/runtime-cores/core/ThreadListRuntimeCore";
+export { DefaultThreadComposerRuntimeCore } from "./legacy-runtime/runtime-cores/composer/DefaultThreadComposerRuntimeCore";
+export { CompositeContextProvider } from "./utils/CompositeContextProvider";
+export { MessageRepository } from "./legacy-runtime/runtime-cores/utils/MessageRepository";
+export { BaseAssistantRuntimeCore } from "./legacy-runtime/runtime-cores/core/BaseAssistantRuntimeCore";
+export { generateId } from "./utils/idUtils";
+export { AssistantRuntimeImpl } from "./legacy-runtime/runtime/AssistantRuntime";
+export { ThreadRuntimeImpl, type ThreadRuntimeCoreBinding, type ThreadListItemRuntimeBinding, } from "./legacy-runtime/runtime/ThreadRuntime";
+export { fromThreadMessageLike } from "./legacy-runtime/runtime-cores/external-store/ThreadMessageLike";
+export { getAutoStatus } from "./legacy-runtime/runtime-cores/external-store/auto-status";
+export { splitLocalRuntimeOptions } from "./legacy-runtime/runtime-cores/local/LocalRuntimeOptions";
+export { useToolInvocations, type ToolExecutionStatus, } from "./legacy-runtime/runtime-cores/assistant-transport/useToolInvocations";
+export * from "./utils/smooth";

package/dist/vendor/assistant-ui-react/src/internal.js

@@ -0,0 +1,12 @@
+export { DefaultThreadComposerRuntimeCore } from "./legacy-runtime/runtime-cores/composer/DefaultThreadComposerRuntimeCore";
+export { CompositeContextProvider } from "./utils/CompositeContextProvider";
+export { MessageRepository } from "./legacy-runtime/runtime-cores/utils/MessageRepository";
+export { BaseAssistantRuntimeCore } from "./legacy-runtime/runtime-cores/core/BaseAssistantRuntimeCore";
+export { generateId } from "./utils/idUtils";
+export { AssistantRuntimeImpl } from "./legacy-runtime/runtime/AssistantRuntime";
+export { ThreadRuntimeImpl, } from "./legacy-runtime/runtime/ThreadRuntime";
+export { fromThreadMessageLike } from "./legacy-runtime/runtime-cores/external-store/ThreadMessageLike";
+export { getAutoStatus } from "./legacy-runtime/runtime-cores/external-store/auto-status";
+export { splitLocalRuntimeOptions } from "./legacy-runtime/runtime-cores/local/LocalRuntimeOptions";
+export { useToolInvocations, } from "./legacy-runtime/runtime-cores/assistant-transport/useToolInvocations";
+export * from "./utils/smooth";

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

@@ -0,0 +1,17 @@
+import { FC, PropsWithChildren } from "react";
+import { AssistantClient } from "@assistant-ui/store";
+import { AssistantRuntime } from "./runtime/AssistantRuntime";
+export declare namespace AssistantRuntimeProvider {
+    type Props = PropsWithChildren<{
+        /**
+         * The runtime to provide to the rest of your app.
+         */
+        runtime: AssistantRuntime;
+        /**
+         * The aui instance to extend. If not provided, a new aui instance will be created.
+         */
+        aui?: AssistantClient;
+    }>;
+}
+export declare const AssistantRuntimeProviderImpl: FC<AssistantRuntimeProvider.Props>;
+export declare const AssistantRuntimeProvider: import("react").NamedExoticComponent<AssistantRuntimeProvider.Props>;

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

@@ -0,0 +1,23 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo, useEffect } from "react";
+import { useAui, AuiProvider } from "@assistant-ui/store";
+import { RuntimeAdapter } from "./RuntimeAdapter";
+import { ThreadPrimitiveViewportProvider } from "../context/providers/ThreadViewportProvider";
+import { DevToolsProviderApi } from "../devtools";
+const getRenderComponent = (runtime) => {
+    var _a;
+    return (_a = runtime._core) === null || _a === void 0 ? void 0 : _a.RenderComponent;
+};
+export const AssistantRuntimeProviderImpl = ({ children, aui: parent = null, runtime }) => {
+    const aui = useAui({ threads: RuntimeAdapter(runtime) }, { parent: parent });
+    useEffect(() => {
+        if (typeof process === "undefined" ||
+            process.env["NODE_ENV"] === "production")
+            return;
+        return DevToolsProviderApi.register(aui);
+    }, [aui]);
+    const RenderComponent = getRenderComponent(runtime);
+    return (_jsxs(AuiProvider, { value: aui, children: [RenderComponent && _jsx(RenderComponent, {}), _jsx(ThreadPrimitiveViewportProvider, { children: children })] }));
+};
+export const AssistantRuntimeProvider = memo(AssistantRuntimeProviderImpl);

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

@@ -0,0 +1 @@
+export declare const RuntimeAdapter: any;

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

@@ -0,0 +1,35 @@
+import { resource, tapEffect, tapInlineResource } from "@assistant-ui/tap";
+import { ThreadListClient } from "./client/ThreadListRuntimeClient";
+import { tapAssistantClientRef, Derived, attachDefaultPeers, } from "@assistant-ui/store";
+import { ModelContext } from "../client/ModelContextClient";
+import { Tools, Suggestions } from "../model-context";
+export const RuntimeAdapter = resource((runtime) => {
+    const clientRef = tapAssistantClientRef();
+    tapEffect(() => {
+        return runtime.registerModelContextProvider(clientRef.current.modelContext());
+    }, [runtime, clientRef]);
+    return tapInlineResource(ThreadListClient({
+        runtime: runtime.threads,
+        __internal_assistantRuntime: runtime,
+    }));
+});
+attachDefaultPeers(RuntimeAdapter, {
+    modelContext: ModelContext(),
+    tools: Tools({}),
+    suggestions: Suggestions(),
+    threadListItem: Derived({
+        source: "threads",
+        query: { type: "main" },
+        get: (aui) => aui.threads().item("main"),
+    }),
+    thread: Derived({
+        source: "threads",
+        query: { type: "main" },
+        get: (aui) => aui.threads().thread("main"),
+    }),
+    composer: Derived({
+        source: "thread",
+        query: {},
+        get: (aui) => aui.threads().thread("main").composer,
+    }),
+});

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

@@ -0,0 +1 @@
+export declare const AttachmentRuntimeClient: any;

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

@@ -0,0 +1,13 @@
+import { resource } from "@assistant-ui/tap";
+import { tapSubscribable } from "../util-hooks/tapSubscribable";
+export const AttachmentRuntimeClient = resource(({ runtime }) => {
+    const state = tapSubscribable(runtime);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            remove: runtime.remove,
+            __internal_getRuntime: () => runtime,
+        },
+    };
+});

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

@@ -0,0 +1 @@
+export declare const ComposerClient: any;

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

@@ -0,0 +1,81 @@
+import { resource, tapMemo, tapEffect, tapInlineResource, withKey, } from "@assistant-ui/tap";
+import { tapAssistantEmit, tapClientLookup, } from "@assistant-ui/store";
+import { AttachmentRuntimeClient } from "./AttachmentRuntimeClient";
+import { tapSubscribable } from "../util-hooks/tapSubscribable";
+const ComposerAttachmentClientByIndex = resource(({ runtime, index }) => {
+    const attachmentRuntime = tapMemo(() => runtime.getAttachmentByIndex(index), [runtime, index]);
+    return tapInlineResource(AttachmentRuntimeClient({
+        runtime: attachmentRuntime,
+    }));
+});
+export const ComposerClient = resource(({ threadIdRef, messageIdRef, runtime, }) => {
+    var _a;
+    const runtimeState = tapSubscribable(runtime);
+    const emit = tapAssistantEmit();
+    // Bind composer events to event manager
+    tapEffect(() => {
+        const unsubscribers = [];
+        // Subscribe to composer events
+        const composerEvents = [
+            "send",
+            "attachmentAdd",
+        ];
+        for (const event of composerEvents) {
+            const unsubscribe = runtime.unstable_on(event, () => {
+                emit(`composer.${event}`, Object.assign({ threadId: threadIdRef.current }, (messageIdRef && { messageId: messageIdRef.current })));
+            });
+            unsubscribers.push(unsubscribe);
+        }
+        return () => {
+            for (const unsub of unsubscribers)
+                unsub();
+        };
+    }, [runtime, emit, threadIdRef, messageIdRef]);
+    const attachments = tapClientLookup(() => runtimeState.attachments.map((attachment, idx) => withKey(attachment.id, ComposerAttachmentClientByIndex({
+        runtime,
+        index: idx,
+    }))), [runtimeState.attachments, runtime]);
+    const state = tapMemo(() => {
+        var _a;
+        return {
+            text: runtimeState.text,
+            role: runtimeState.role,
+            attachments: attachments.state,
+            runConfig: runtimeState.runConfig,
+            isEditing: runtimeState.isEditing,
+            canCancel: runtimeState.canCancel,
+            attachmentAccept: runtimeState.attachmentAccept,
+            isEmpty: runtimeState.isEmpty,
+            type: (_a = runtimeState.type) !== null && _a !== void 0 ? _a : "thread",
+            dictation: runtimeState.dictation,
+        };
+    }, [runtimeState, attachments.state]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            setText: runtime.setText,
+            setRole: runtime.setRole,
+            setRunConfig: runtime.setRunConfig,
+            addAttachment: runtime.addAttachment,
+            reset: runtime.reset,
+            clearAttachments: runtime.clearAttachments,
+            send: runtime.send,
+            cancel: runtime.cancel,
+            beginEdit: (_a = runtime.beginEdit) !== null && _a !== void 0 ? _a : (() => {
+                throw new Error("beginEdit is not supported in this runtime");
+            }),
+            startDictation: runtime.startDictation,
+            stopDictation: runtime.stopDictation,
+            attachment: (selector) => {
+                if ("id" in selector) {
+                    return attachments.get({ key: selector.id });
+                }
+                else {
+                    return attachments.get(selector);
+                }
+            },
+            __internal_getRuntime: () => runtime,
+        },
+    };
+});

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

@@ -0,0 +1 @@
+export declare const MessagePartClient: any;