ikoncomponents 1.6.3 → 1.6.5

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

@@ -0,0 +1,218 @@
+import { MessageRuntimeImpl, } from "./MessageRuntime";
+import { NestedSubscriptionSubject } from "./subscribable/NestedSubscriptionSubject";
+import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject";
+import { ThreadComposerRuntimeImpl, } from "./ComposerRuntime";
+import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE";
+import { EventSubscriptionSubject } from "./subscribable/EventSubscriptionSubject";
+import { symbolInnerMessage } from "../runtime-cores/external-store/getExternalStoreMessage";
+const toResumeRunConfig = (message) => {
+    var _a, _b, _c;
+    return Object.assign({ parentId: (_a = message.parentId) !== null && _a !== void 0 ? _a : null, sourceId: (_b = message.sourceId) !== null && _b !== void 0 ? _b : null, runConfig: (_c = message.runConfig) !== null && _c !== void 0 ? _c : {} }, (message.stream ? { stream: message.stream } : {}));
+};
+const toStartRunConfig = (message) => {
+    var _a, _b, _c;
+    return {
+        parentId: (_a = message.parentId) !== null && _a !== void 0 ? _a : null,
+        sourceId: (_b = message.sourceId) !== null && _b !== void 0 ? _b : null,
+        runConfig: (_c = message.runConfig) !== null && _c !== void 0 ? _c : {},
+    };
+};
+const toAppendMessage = (messages, message) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    if (typeof message === "string") {
+        return {
+            createdAt: new Date(),
+            parentId: (_b = (_a = messages.at(-1)) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null,
+            sourceId: null,
+            runConfig: {},
+            role: "user",
+            content: [{ type: "text", text: message }],
+            attachments: [],
+            metadata: { custom: {} },
+        };
+    }
+    return {
+        createdAt: (_c = message.createdAt) !== null && _c !== void 0 ? _c : new Date(),
+        parentId: (_f = (_d = message.parentId) !== null && _d !== void 0 ? _d : (_e = messages.at(-1)) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : null,
+        sourceId: (_g = message.sourceId) !== null && _g !== void 0 ? _g : null,
+        role: (_h = message.role) !== null && _h !== void 0 ? _h : "user",
+        content: message.content,
+        attachments: (_j = message.attachments) !== null && _j !== void 0 ? _j : [],
+        metadata: (_k = message.metadata) !== null && _k !== void 0 ? _k : { custom: {} },
+        runConfig: (_l = message.runConfig) !== null && _l !== void 0 ? _l : {},
+        startRun: message.startRun,
+    };
+};
+export const getThreadState = (runtime, threadListItemState) => {
+    const lastMessage = runtime.messages.at(-1);
+    return Object.freeze({
+        threadId: threadListItemState.id,
+        metadata: threadListItemState,
+        capabilities: runtime.capabilities,
+        isDisabled: runtime.isDisabled,
+        isLoading: runtime.isLoading,
+        isRunning: (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) !== "assistant"
+            ? false
+            : lastMessage.status.type === "running",
+        messages: runtime.messages,
+        state: runtime.state,
+        suggestions: runtime.suggestions,
+        extras: runtime.extras,
+        speech: runtime.speech,
+    });
+};
+export class ThreadRuntimeImpl {
+    get path() {
+        return this._threadBinding.path;
+    }
+    get __internal_threadBinding() {
+        return this._threadBinding;
+    }
+    constructor(threadBinding, threadListItemBinding) {
+        this._eventSubscriptionSubjects = new Map();
+        const stateBinding = new ShallowMemoizeSubject({
+            path: threadBinding.path,
+            getState: () => getThreadState(threadBinding.getState(), threadListItemBinding.getState()),
+            subscribe: (callback) => {
+                const sub1 = threadBinding.subscribe(callback);
+                const sub2 = threadListItemBinding.subscribe(callback);
+                return () => {
+                    sub1();
+                    sub2();
+                };
+            },
+        });
+        this._threadBinding = {
+            path: threadBinding.path,
+            getState: () => threadBinding.getState(),
+            getStateState: () => stateBinding.getState(),
+            outerSubscribe: (callback) => threadBinding.outerSubscribe(callback),
+            subscribe: (callback) => threadBinding.subscribe(callback),
+        };
+        this.composer = new ThreadComposerRuntimeImpl(new NestedSubscriptionSubject({
+            path: Object.assign(Object.assign({}, this.path), { ref: `${this.path.ref}${this.path.ref}.composer`, composerSource: "thread" }),
+            getState: () => this._threadBinding.getState().composer,
+            subscribe: (callback) => this._threadBinding.subscribe(callback),
+        }));
+        this.__internal_bindMethods();
+    }
+    __internal_bindMethods() {
+        this.append = this.append.bind(this);
+        this.unstable_resumeRun = this.unstable_resumeRun.bind(this);
+        this.unstable_loadExternalState =
+            this.unstable_loadExternalState.bind(this);
+        this.importExternalState = this.importExternalState.bind(this);
+        this.exportExternalState = this.exportExternalState.bind(this);
+        this.startRun = this.startRun.bind(this);
+        this.cancelRun = this.cancelRun.bind(this);
+        this.stopSpeaking = this.stopSpeaking.bind(this);
+        this.export = this.export.bind(this);
+        this.import = this.import.bind(this);
+        this.reset = this.reset.bind(this);
+        this.getMessageByIndex = this.getMessageByIndex.bind(this);
+        this.getMessageById = this.getMessageById.bind(this);
+        this.subscribe = this.subscribe.bind(this);
+        this.unstable_on = this.unstable_on.bind(this);
+        this.getModelContext = this.getModelContext.bind(this);
+        this.getModelConfig = this.getModelConfig.bind(this);
+        this.getState = this.getState.bind(this);
+    }
+    getState() {
+        return this._threadBinding.getStateState();
+    }
+    append(message) {
+        this._threadBinding
+            .getState()
+            .append(toAppendMessage(this._threadBinding.getState().messages, message));
+    }
+    subscribe(callback) {
+        return this._threadBinding.subscribe(callback);
+    }
+    getModelContext() {
+        return this._threadBinding.getState().getModelContext();
+    }
+    getModelConfig() {
+        return this.getModelContext();
+    }
+    startRun(configOrParentId) {
+        const config = configOrParentId === null || typeof configOrParentId === "string"
+            ? { parentId: configOrParentId }
+            : configOrParentId;
+        return this._threadBinding.getState().startRun(toStartRunConfig(config));
+    }
+    unstable_resumeRun(config) {
+        return this._threadBinding.getState().resumeRun(toResumeRunConfig(config));
+    }
+    exportExternalState() {
+        return this._threadBinding.getState().exportExternalState();
+    }
+    importExternalState(state) {
+        this._threadBinding.getState().importExternalState(state);
+    }
+    unstable_loadExternalState(state) {
+        this._threadBinding.getState().unstable_loadExternalState(state);
+    }
+    cancelRun() {
+        this._threadBinding.getState().cancelRun();
+    }
+    stopSpeaking() {
+        return this._threadBinding.getState().stopSpeaking();
+    }
+    export() {
+        return this._threadBinding.getState().export();
+    }
+    import(data) {
+        this._threadBinding.getState().import(data);
+    }
+    reset(initialMessages) {
+        this._threadBinding.getState().reset(initialMessages);
+    }
+    getMessageByIndex(idx) {
+        if (idx < 0)
+            throw new Error("Message index must be >= 0");
+        return this._getMessageRuntime(Object.assign(Object.assign({}, this.path), { ref: `${this.path.ref}${this.path.ref}.messages[${idx}]`, messageSelector: { type: "index", index: idx } }), () => {
+            var _a, _b;
+            const messages = this._threadBinding.getState().messages;
+            const message = messages[idx];
+            if (!message)
+                return undefined;
+            return {
+                message,
+                parentId: (_b = (_a = messages[idx - 1]) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null,
+                index: idx,
+            };
+        });
+    }
+    getMessageById(messageId) {
+        return this._getMessageRuntime(Object.assign(Object.assign({}, this.path), { ref: this.path.ref +
+                `${this.path.ref}.messages[messageId=${JSON.stringify(messageId)}]`, messageSelector: { type: "messageId", messageId: messageId } }), () => this._threadBinding.getState().getMessageById(messageId));
+    }
+    _getMessageRuntime(path, callback) {
+        return new MessageRuntimeImpl(new ShallowMemoizeSubject({
+            path,
+            getState: () => {
+                var _a, _b;
+                const { message, parentId, index } = (_a = callback()) !== null && _a !== void 0 ? _a : {};
+                const { messages, speech: speechState } = this._threadBinding.getState();
+                if (!message || parentId === undefined || index === undefined)
+                    return SKIP_UPDATE;
+                const thread = this._threadBinding.getState();
+                const branches = thread.getBranches(message.id);
+                const submittedFeedback = message.metadata.submittedFeedback;
+                return Object.assign(Object.assign(Object.assign({}, message), { [symbolInnerMessage]: message[symbolInnerMessage] }), { index, isLast: ((_b = messages.at(-1)) === null || _b === void 0 ? void 0 : _b.id) === message.id, parentId, branchNumber: branches.indexOf(message.id) + 1, branchCount: branches.length, speech: (speechState === null || speechState === void 0 ? void 0 : speechState.messageId) === message.id ? speechState : undefined, submittedFeedback });
+            },
+            subscribe: (callback) => this._threadBinding.subscribe(callback),
+        }), this._threadBinding);
+    }
+    unstable_on(event, callback) {
+        let subject = this._eventSubscriptionSubjects.get(event);
+        if (!subject) {
+            subject = new EventSubscriptionSubject({
+                event: event,
+                binding: this._threadBinding,
+            });
+            this._eventSubscriptionSubjects.set(event, subject);
+        }
+        return subject.subscribe(callback);
+    }
+}

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

@@ -0,0 +1,8 @@
+export type { AssistantRuntime } from "./AssistantRuntime";
+export type { ThreadRuntime, ThreadState, CreateAppendMessage, CreateStartRunConfig, } from "./ThreadRuntime";
+export type { MessageRuntime, MessageState } from "./MessageRuntime";
+export type { MessagePartRuntime, MessagePartState, } from "./MessagePartRuntime";
+export type { ComposerRuntime, ThreadComposerRuntime, EditComposerRuntime, EditComposerState, ThreadComposerState, ComposerState, } from "./ComposerRuntime";
+export type { AttachmentRuntime, AttachmentState } from "./AttachmentRuntime";
+export type { ThreadListRuntime, ThreadListState } from "./ThreadListRuntime";
+export type { ThreadListItemRuntime, ThreadListItemState, } from "./ThreadListItemRuntime";

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

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

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

@@ -0,0 +1,10 @@
+import { Unsubscribe } from "../../../types/Unsubscribe";
+export declare abstract class BaseSubject {
+    private _subscriptions;
+    private _connection;
+    protected get isConnected(): boolean;
+    protected abstract _connect(): Unsubscribe;
+    protected notifySubscribers(): void;
+    private _updateConnection;
+    subscribe(callback: () => void): () => void;
+}

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

@@ -0,0 +1,32 @@
+export class BaseSubject {
+    constructor() {
+        this._subscriptions = new Set();
+    }
+    get isConnected() {
+        return !!this._connection;
+    }
+    notifySubscribers() {
+        for (const callback of this._subscriptions)
+            callback();
+    }
+    _updateConnection() {
+        var _a;
+        if (this._subscriptions.size > 0) {
+            if (this._connection)
+                return;
+            this._connection = this._connect();
+        }
+        else {
+            (_a = this._connection) === null || _a === void 0 ? void 0 : _a.call(this);
+            this._connection = undefined;
+        }
+    }
+    subscribe(callback) {
+        this._subscriptions.add(callback);
+        this._updateConnection();
+        return () => {
+            this._subscriptions.delete(callback);
+            this._updateConnection();
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Unsubscribe } from "../../../types";
+import { BaseSubject } from "./BaseSubject";
+import { EventSubscribable } from "./Subscribable";
+export declare class EventSubscriptionSubject<TEvent extends string> extends BaseSubject {
+    private config;
+    constructor(config: EventSubscribable<TEvent>);
+    getState(): {
+        unstable_on: (event: TEvent, callback: () => void) => Unsubscribe;
+    } | undefined;
+    outerSubscribe(callback: () => void): Unsubscribe;
+    protected _connect(): Unsubscribe;
+}

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

@@ -0,0 +1,35 @@
+import { BaseSubject } from "./BaseSubject";
+export class EventSubscriptionSubject extends BaseSubject {
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    getState() {
+        return this.config.binding.getState();
+    }
+    outerSubscribe(callback) {
+        return this.config.binding.subscribe(callback);
+    }
+    _connect() {
+        const callback = () => {
+            this.notifySubscribers();
+        };
+        let lastState = this.config.binding.getState();
+        let innerUnsubscribe = lastState === null || lastState === void 0 ? void 0 : lastState.unstable_on(this.config.event, callback);
+        const onRuntimeUpdate = () => {
+            var _a;
+            const newState = this.config.binding.getState();
+            if (newState === lastState)
+                return;
+            lastState = newState;
+            innerUnsubscribe === null || innerUnsubscribe === void 0 ? void 0 : innerUnsubscribe();
+            innerUnsubscribe = (_a = this.config.binding
+                .getState()) === null || _a === void 0 ? void 0 : _a.unstable_on(this.config.event, callback);
+        };
+        const outerUnsubscribe = this.outerSubscribe(onRuntimeUpdate);
+        return () => {
+            outerUnsubscribe === null || outerUnsubscribe === void 0 ? void 0 : outerUnsubscribe();
+            innerUnsubscribe === null || innerUnsubscribe === void 0 ? void 0 : innerUnsubscribe();
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+import { BaseSubject } from "./BaseSubject";
+import { SKIP_UPDATE } from "./SKIP_UPDATE";
+import { SubscribableWithState } from "./Subscribable";
+export declare class LazyMemoizeSubject<TState extends object, TPath> extends BaseSubject implements SubscribableWithState<TState, TPath> {
+    private binding;
+    get path(): TPath;
+    constructor(binding: SubscribableWithState<TState | SKIP_UPDATE, TPath>);
+    private _previousStateDirty;
+    private _previousState;
+    getState: () => TState;
+    protected _connect(): import("../../..").Unsubscribe;
+}

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

@@ -0,0 +1,31 @@
+import { BaseSubject } from "./BaseSubject";
+import { SKIP_UPDATE } from "./SKIP_UPDATE";
+export class LazyMemoizeSubject extends BaseSubject {
+    get path() {
+        return this.binding.path;
+    }
+    constructor(binding) {
+        super();
+        this.binding = binding;
+        this._previousStateDirty = true;
+        this.getState = () => {
+            if (!this.isConnected || this._previousStateDirty) {
+                const newState = this.binding.getState();
+                if (newState !== SKIP_UPDATE) {
+                    this._previousState = newState;
+                }
+                this._previousStateDirty = false;
+            }
+            if (this._previousState === undefined)
+                throw new Error("Entry not available in the store");
+            return this._previousState;
+        };
+    }
+    _connect() {
+        const callback = () => {
+            this._previousStateDirty = true;
+            this.notifySubscribers();
+        };
+        return this.binding.subscribe(callback);
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Unsubscribe } from "../../../types";
+import { BaseSubject } from "./BaseSubject";
+import { NestedSubscribable, Subscribable, SubscribableWithState } from "./Subscribable";
+export declare class NestedSubscriptionSubject<TState extends Subscribable | undefined, TPath> extends BaseSubject implements SubscribableWithState<TState, TPath>, NestedSubscribable<TState, TPath> {
+    private binding;
+    get path(): TPath;
+    constructor(binding: NestedSubscribable<TState, TPath>);
+    getState(): TState;
+    outerSubscribe(callback: () => void): Unsubscribe;
+    protected _connect(): Unsubscribe;
+}

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

@@ -0,0 +1,38 @@
+import { BaseSubject } from "./BaseSubject";
+export class NestedSubscriptionSubject extends BaseSubject {
+    get path() {
+        return this.binding.path;
+    }
+    constructor(binding) {
+        super();
+        this.binding = binding;
+    }
+    getState() {
+        return this.binding.getState();
+    }
+    outerSubscribe(callback) {
+        return this.binding.subscribe(callback);
+    }
+    _connect() {
+        const callback = () => {
+            this.notifySubscribers();
+        };
+        let lastState = this.binding.getState();
+        let innerUnsubscribe = lastState === null || lastState === void 0 ? void 0 : lastState.subscribe(callback);
+        const onRuntimeUpdate = () => {
+            var _a;
+            const newState = this.binding.getState();
+            if (newState === lastState)
+                return;
+            lastState = newState;
+            innerUnsubscribe === null || innerUnsubscribe === void 0 ? void 0 : innerUnsubscribe();
+            innerUnsubscribe = (_a = this.binding.getState()) === null || _a === void 0 ? void 0 : _a.subscribe(callback);
+            callback();
+        };
+        const outerUnsubscribe = this.outerSubscribe(onRuntimeUpdate);
+        return () => {
+            outerUnsubscribe === null || outerUnsubscribe === void 0 ? void 0 : outerUnsubscribe();
+            innerUnsubscribe === null || innerUnsubscribe === void 0 ? void 0 : innerUnsubscribe();
+        };
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare const SKIP_UPDATE: unique symbol;
+export type SKIP_UPDATE = typeof SKIP_UPDATE;

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

@@ -0,0 +1 @@
+export const SKIP_UPDATE = Symbol("skip-update");

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

@@ -0,0 +1,12 @@
+import { BaseSubject } from "./BaseSubject";
+import { SubscribableWithState } from "./Subscribable";
+import { SKIP_UPDATE } from "./SKIP_UPDATE";
+export declare class ShallowMemoizeSubject<TState extends object, TPath> extends BaseSubject implements SubscribableWithState<TState, TPath> {
+    private binding;
+    get path(): TPath;
+    constructor(binding: SubscribableWithState<TState | SKIP_UPDATE, TPath>);
+    private _previousState;
+    getState: () => TState;
+    private _syncState;
+    protected _connect(): import("../../..").Unsubscribe;
+}

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

@@ -0,0 +1,38 @@
+import { shallowEqual } from "./shallowEqual";
+import { BaseSubject } from "./BaseSubject";
+import { SKIP_UPDATE } from "./SKIP_UPDATE";
+export class ShallowMemoizeSubject extends BaseSubject {
+    get path() {
+        return this.binding.path;
+    }
+    constructor(binding) {
+        super();
+        this.binding = binding;
+        this.getState = () => {
+            if (!this.isConnected)
+                this._syncState();
+            return this._previousState;
+        };
+        const state = binding.getState();
+        if (state === SKIP_UPDATE)
+            throw new Error("Entry not available in the store");
+        this._previousState = state;
+    }
+    _syncState() {
+        const state = this.binding.getState();
+        if (state === SKIP_UPDATE)
+            return false;
+        if (shallowEqual(state, this._previousState))
+            return false;
+        this._previousState = state;
+        return true;
+    }
+    _connect() {
+        const callback = () => {
+            if (this._syncState()) {
+                this.notifySubscribers();
+            }
+        };
+        return this.binding.subscribe(callback);
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Unsubscribe } from "../../../types";
+export type Subscribable = {
+    subscribe: (callback: () => void) => Unsubscribe;
+};
+export type SubscribableWithState<TState, TPath> = Subscribable & {
+    path: TPath;
+    getState: () => TState;
+};
+export type NestedSubscribable<TState extends Subscribable | undefined, TPath> = SubscribableWithState<TState, TPath>;
+export type EventSubscribable<TEvent extends string> = {
+    event: TEvent;
+    binding: SubscribableWithState<{
+        unstable_on: (event: TEvent, callback: () => void) => Unsubscribe;
+    } | undefined, unknown>;
+};

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

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

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

@@ -0,0 +1 @@
+export declare function shallowEqual<T extends object>(objA: T | undefined, objB: T | undefined): boolean;

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

@@ -0,0 +1,15 @@
+export function shallowEqual(objA, objB) {
+    if (objA === undefined && objB === undefined)
+        return true;
+    if (objA === undefined)
+        return false;
+    if (objB === undefined)
+        return false;
+    for (const key of Object.keys(objA)) {
+        const valueA = objA[key];
+        const valueB = objB[key];
+        if (!Object.is(valueA, valueB))
+            return false;
+    }
+    return true;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/RuntimeAdapterProvider.d.ts

@@ -0,0 +1,17 @@
+import { FC, ReactNode } from "react";
+import { ThreadHistoryAdapter } from "./thread-history/ThreadHistoryAdapter";
+import { AttachmentAdapter } from "./attachment/AttachmentAdapter";
+import { ModelContextProvider } from "../../../model-context";
+export type RuntimeAdapters = {
+    modelContext?: ModelContextProvider;
+    history?: ThreadHistoryAdapter;
+    attachments?: AttachmentAdapter;
+};
+export declare namespace RuntimeAdapterProvider {
+    type Props = {
+        adapters: RuntimeAdapters;
+        children: ReactNode;
+    };
+}
+export declare const RuntimeAdapterProvider: FC<RuntimeAdapterProvider.Props>;
+export declare const useRuntimeAdapters: () => RuntimeAdapters | null;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/RuntimeAdapterProvider.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const RuntimeAdaptersContext = createContext(null);
+export const RuntimeAdapterProvider = ({ adapters, children, }) => {
+    const context = useContext(RuntimeAdaptersContext);
+    return (_jsx(RuntimeAdaptersContext.Provider, { value: Object.assign(Object.assign({}, context), adapters), children: children }));
+};
+export const useRuntimeAdapters = () => {
+    const adapters = useContext(RuntimeAdaptersContext);
+    return adapters;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/AttachmentAdapter.d.ts

@@ -0,0 +1,63 @@
+import { Attachment, PendingAttachment, CompleteAttachment } from "../../../../types/AttachmentTypes";
+/**
+ * Interface for handling file attachments in the assistant runtime.
+ *
+ * AttachmentAdapter provides methods for managing file attachments throughout
+ * their lifecycle: adding, processing, removing, and sending attachments with messages.
+ *
+ * @example
+ * ```tsx
+ * const imageAdapter: AttachmentAdapter = {
+ *   accept: "image/*",
+ *
+ *   async add({ file }) {
+ *     return {
+ *       id: generateId(),
+ *       type: "image",
+ *       name: file.name,
+ *       file,
+ *       status: { type: "uploading" }
+ *     };
+ *   },
+ *
+ *   async remove(attachment) {
+ *     // Clean up resources
+ *   },
+ *
+ *   async send(attachment) {
+ *     const url = await uploadFile(attachment.file);
+ *     return { ...attachment, url, status: { type: "complete" } };
+ *   }
+ * };
+ * ```
+ */
+export type AttachmentAdapter = {
+    /**
+     * MIME type pattern for accepted file types (e.g., "image/*", "text/plain").
+     */
+    accept: string;
+    /**
+     * Processes a file when it's added as an attachment.
+     *
+     * @param state - Object containing the file to process
+     * @param state.file - The File object to be attached
+     * @returns Promise or AsyncGenerator yielding PendingAttachment states
+     */
+    add(state: {
+        file: File;
+    }): Promise<PendingAttachment> | AsyncGenerator<PendingAttachment, void>;
+    /**
+     * Removes an attachment and cleans up associated resources.
+     *
+     * @param attachment - The attachment to remove
+     * @returns Promise that resolves when removal is complete
+     */
+    remove(attachment: Attachment): Promise<void>;
+    /**
+     * Finalizes an attachment for sending with a message.
+     *
+     * @param attachment - The pending attachment to finalize
+     * @returns Promise resolving to the complete attachment
+     */
+    send(attachment: PendingAttachment): Promise<CompleteAttachment>;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/AttachmentAdapter.js

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

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/adapters/attachment/CloudFileAttachmentAdapter.d.ts

@@ -0,0 +1,14 @@
+import type { AssistantCloud } from "assistant-cloud";
+import { Attachment, PendingAttachment, CompleteAttachment } from "../../../../types/AttachmentTypes";
+import { AttachmentAdapter } from "./AttachmentAdapter";
+export declare class CloudFileAttachmentAdapter implements AttachmentAdapter {
+    private cloud;
+    accept: string;
+    constructor(cloud: AssistantCloud);
+    private uploadedUrls;
+    add({ file, }: {
+        file: File;
+    }): AsyncGenerator<PendingAttachment, void>;
+    remove(attachment: Attachment): Promise<void>;
+    send(attachment: PendingAttachment): Promise<CompleteAttachment>;
+}