ikoncomponents 1.6.4 → 1.6.5

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

@@ -0,0 +1,222 @@
+import { LazyMemoizeSubject } from "./subscribable/LazyMemoizeSubject";
+import { EditComposerAttachmentRuntimeImpl, ThreadComposerAttachmentRuntimeImpl, } from "./AttachmentRuntime";
+import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject";
+import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE";
+import { EventSubscriptionSubject } from "./subscribable/EventSubscriptionSubject";
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_OBJECT = Object.freeze({});
+const getThreadComposerState = (runtime) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    return Object.freeze({
+        type: "thread",
+        isEditing: (_a = runtime === null || runtime === void 0 ? void 0 : runtime.isEditing) !== null && _a !== void 0 ? _a : false,
+        canCancel: (_b = runtime === null || runtime === void 0 ? void 0 : runtime.canCancel) !== null && _b !== void 0 ? _b : false,
+        isEmpty: (_c = runtime === null || runtime === void 0 ? void 0 : runtime.isEmpty) !== null && _c !== void 0 ? _c : true,
+        attachments: (_d = runtime === null || runtime === void 0 ? void 0 : runtime.attachments) !== null && _d !== void 0 ? _d : EMPTY_ARRAY,
+        text: (_e = runtime === null || runtime === void 0 ? void 0 : runtime.text) !== null && _e !== void 0 ? _e : "",
+        role: (_f = runtime === null || runtime === void 0 ? void 0 : runtime.role) !== null && _f !== void 0 ? _f : "user",
+        runConfig: (_g = runtime === null || runtime === void 0 ? void 0 : runtime.runConfig) !== null && _g !== void 0 ? _g : EMPTY_OBJECT,
+        attachmentAccept: (_h = runtime === null || runtime === void 0 ? void 0 : runtime.attachmentAccept) !== null && _h !== void 0 ? _h : "",
+        dictation: runtime === null || runtime === void 0 ? void 0 : runtime.dictation,
+        value: (_j = runtime === null || runtime === void 0 ? void 0 : runtime.text) !== null && _j !== void 0 ? _j : "",
+    });
+};
+const getEditComposerState = (runtime) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    return Object.freeze({
+        type: "edit",
+        isEditing: (_a = runtime === null || runtime === void 0 ? void 0 : runtime.isEditing) !== null && _a !== void 0 ? _a : false,
+        canCancel: (_b = runtime === null || runtime === void 0 ? void 0 : runtime.canCancel) !== null && _b !== void 0 ? _b : false,
+        isEmpty: (_c = runtime === null || runtime === void 0 ? void 0 : runtime.isEmpty) !== null && _c !== void 0 ? _c : true,
+        text: (_d = runtime === null || runtime === void 0 ? void 0 : runtime.text) !== null && _d !== void 0 ? _d : "",
+        role: (_e = runtime === null || runtime === void 0 ? void 0 : runtime.role) !== null && _e !== void 0 ? _e : "user",
+        attachments: (_f = runtime === null || runtime === void 0 ? void 0 : runtime.attachments) !== null && _f !== void 0 ? _f : EMPTY_ARRAY,
+        runConfig: (_g = runtime === null || runtime === void 0 ? void 0 : runtime.runConfig) !== null && _g !== void 0 ? _g : EMPTY_OBJECT,
+        attachmentAccept: (_h = runtime === null || runtime === void 0 ? void 0 : runtime.attachmentAccept) !== null && _h !== void 0 ? _h : "",
+        dictation: runtime === null || runtime === void 0 ? void 0 : runtime.dictation,
+        value: (_j = runtime === null || runtime === void 0 ? void 0 : runtime.text) !== null && _j !== void 0 ? _j : "",
+    });
+};
+export class ComposerRuntimeImpl {
+    get path() {
+        return this._core.path;
+    }
+    constructor(_core) {
+        this._core = _core;
+        this._eventSubscriptionSubjects = new Map();
+    }
+    __internal_bindMethods() {
+        this.setText = this.setText.bind(this);
+        this.setRunConfig = this.setRunConfig.bind(this);
+        this.getState = this.getState.bind(this);
+        this.subscribe = this.subscribe.bind(this);
+        this.addAttachment = this.addAttachment.bind(this);
+        this.reset = this.reset.bind(this);
+        this.clearAttachments = this.clearAttachments.bind(this);
+        this.send = this.send.bind(this);
+        this.cancel = this.cancel.bind(this);
+        this.setRole = this.setRole.bind(this);
+        this.getAttachmentByIndex = this.getAttachmentByIndex.bind(this);
+        this.startDictation = this.startDictation.bind(this);
+        this.stopDictation = this.stopDictation.bind(this);
+        this.unstable_on = this.unstable_on.bind(this);
+    }
+    setText(text) {
+        const core = this._core.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        core.setText(text);
+    }
+    setRunConfig(runConfig) {
+        const core = this._core.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        core.setRunConfig(runConfig);
+    }
+    addAttachment(file) {
+        const core = this._core.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        return core.addAttachment(file);
+    }
+    reset() {
+        const core = this._core.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        return core.reset();
+    }
+    clearAttachments() {
+        const core = this._core.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        return core.clearAttachments();
+    }
+    send() {
+        const core = this._core.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        core.send();
+    }
+    cancel() {
+        const core = this._core.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        core.cancel();
+    }
+    setRole(role) {
+        const core = this._core.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        core.setRole(role);
+    }
+    startDictation() {
+        const core = this._core.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        core.startDictation();
+    }
+    stopDictation() {
+        const core = this._core.getState();
+        if (!core)
+            throw new Error("Composer is not available");
+        core.stopDictation();
+    }
+    subscribe(callback) {
+        return this._core.subscribe(callback);
+    }
+    unstable_on(event, callback) {
+        let subject = this._eventSubscriptionSubjects.get(event);
+        if (!subject) {
+            subject = new EventSubscriptionSubject({
+                event: event,
+                binding: this._core,
+            });
+            this._eventSubscriptionSubjects.set(event, subject);
+        }
+        return subject.subscribe(callback);
+    }
+}
+export class ThreadComposerRuntimeImpl extends ComposerRuntimeImpl {
+    get path() {
+        return this._core.path;
+    }
+    get type() {
+        return "thread";
+    }
+    constructor(core) {
+        const stateBinding = new LazyMemoizeSubject({
+            path: core.path,
+            getState: () => getThreadComposerState(core.getState()),
+            subscribe: (callback) => core.subscribe(callback),
+        });
+        super({
+            path: core.path,
+            getState: () => core.getState(),
+            subscribe: (callback) => stateBinding.subscribe(callback),
+        });
+        this._getState = stateBinding.getState.bind(stateBinding);
+        this.__internal_bindMethods();
+    }
+    getState() {
+        return this._getState();
+    }
+    getAttachmentByIndex(idx) {
+        return new ThreadComposerAttachmentRuntimeImpl(new ShallowMemoizeSubject({
+            path: Object.assign(Object.assign({}, this.path), { attachmentSource: "thread-composer", attachmentSelector: { type: "index", index: idx }, ref: `${this.path.ref}.attachments[${idx}]` }),
+            getState: () => {
+                const attachments = this.getState().attachments;
+                const attachment = attachments[idx];
+                if (!attachment)
+                    return SKIP_UPDATE;
+                return Object.assign(Object.assign({}, attachment), { source: "thread-composer" });
+            },
+            subscribe: (callback) => this._core.subscribe(callback),
+        }), this._core);
+    }
+}
+export class EditComposerRuntimeImpl extends ComposerRuntimeImpl {
+    get path() {
+        return this._core.path;
+    }
+    get type() {
+        return "edit";
+    }
+    constructor(core, _beginEdit) {
+        const stateBinding = new LazyMemoizeSubject({
+            path: core.path,
+            getState: () => getEditComposerState(core.getState()),
+            subscribe: (callback) => core.subscribe(callback),
+        });
+        super({
+            path: core.path,
+            getState: () => core.getState(),
+            subscribe: (callback) => stateBinding.subscribe(callback),
+        });
+        this._beginEdit = _beginEdit;
+        this._getState = stateBinding.getState.bind(stateBinding);
+        this.__internal_bindMethods();
+    }
+    __internal_bindMethods() {
+        super.__internal_bindMethods();
+        this.beginEdit = this.beginEdit.bind(this);
+    }
+    getState() {
+        return this._getState();
+    }
+    beginEdit() {
+        this._beginEdit();
+    }
+    getAttachmentByIndex(idx) {
+        return new EditComposerAttachmentRuntimeImpl(new ShallowMemoizeSubject({
+            path: Object.assign(Object.assign({}, this.path), { attachmentSource: "edit-composer", attachmentSelector: { type: "index", index: idx }, ref: `${this.path.ref}.attachments[${idx}]` }),
+            getState: () => {
+                const attachments = this.getState().attachments;
+                const attachment = attachments[idx];
+                if (!attachment)
+                    return SKIP_UPDATE;
+                return Object.assign(Object.assign({}, attachment), { source: "edit-composer" });
+            },
+            subscribe: (callback) => this._core.subscribe(callback),
+        }), this._core);
+    }
+}

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

@@ -0,0 +1,39 @@
+import { ThreadAssistantMessagePart, ThreadUserMessagePart, MessagePartStatus, ToolCallMessagePartStatus } from "../../types/AssistantTypes";
+import { ThreadRuntimeCoreBinding } from "./ThreadRuntime";
+import type { MessageStateBinding } from "./RuntimeBindings";
+import { SubscribableWithState } from "./subscribable/Subscribable";
+import { Unsubscribe } from "../../types";
+import { MessagePartRuntimePath } from "./RuntimePathTypes";
+import { ToolResponse } from "assistant-stream";
+export type MessagePartState = (ThreadUserMessagePart | ThreadAssistantMessagePart) & {
+    readonly status: MessagePartStatus | ToolCallMessagePartStatus;
+};
+type MessagePartSnapshotBinding = SubscribableWithState<MessagePartState, MessagePartRuntimePath>;
+export type MessagePartRuntime = {
+    /**
+     * Add tool result to a tool call message part that has no tool result yet.
+     * This is useful when you are collecting a tool result via user input ("human tool calls").
+     */
+    addToolResult(result: any | ToolResponse<any>): void;
+    /**
+     * Resume a tool call that is waiting for human input with a payload.
+     * This is useful when a tool has requested human input and is waiting for a response.
+     */
+    resumeToolCall(payload: unknown): void;
+    readonly path: MessagePartRuntimePath;
+    getState(): MessagePartState;
+    subscribe(callback: () => void): Unsubscribe;
+};
+export declare class MessagePartRuntimeImpl implements MessagePartRuntime {
+    private contentBinding;
+    private messageApi?;
+    private threadApi?;
+    get path(): MessagePartRuntimePath;
+    constructor(contentBinding: MessagePartSnapshotBinding, messageApi?: MessageStateBinding | undefined, threadApi?: ThreadRuntimeCoreBinding | undefined);
+    protected __internal_bindMethods(): void;
+    getState(): MessagePartState;
+    addToolResult(result: any | ToolResponse<any>): void;
+    resumeToolCall(payload: unknown): void;
+    subscribe(callback: () => void): Unsubscribe;
+}
+export {};

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

@@ -0,0 +1,63 @@
+import { ToolResponse } from "assistant-stream";
+export class MessagePartRuntimeImpl {
+    get path() {
+        return this.contentBinding.path;
+    }
+    constructor(contentBinding, messageApi, threadApi) {
+        this.contentBinding = contentBinding;
+        this.messageApi = messageApi;
+        this.threadApi = threadApi;
+        this.__internal_bindMethods();
+    }
+    __internal_bindMethods() {
+        this.addToolResult = this.addToolResult.bind(this);
+        this.resumeToolCall = this.resumeToolCall.bind(this);
+        this.getState = this.getState.bind(this);
+        this.subscribe = this.subscribe.bind(this);
+    }
+    getState() {
+        return this.contentBinding.getState();
+    }
+    addToolResult(result) {
+        const state = this.contentBinding.getState();
+        if (!state)
+            throw new Error("Message part is not available");
+        if (state.type !== "tool-call")
+            throw new Error("Tried to add tool result to non-tool message part");
+        if (!this.messageApi)
+            throw new Error("Message API is not available. This is likely a bug in assistant-ui.");
+        if (!this.threadApi)
+            throw new Error("Thread API is not available");
+        const message = this.messageApi.getState();
+        if (!message)
+            throw new Error("Message is not available");
+        const toolName = state.toolName;
+        const toolCallId = state.toolCallId;
+        const response = ToolResponse.toResponse(result);
+        this.threadApi.getState().addToolResult({
+            messageId: message.id,
+            toolName,
+            toolCallId,
+            result: response.result,
+            artifact: response.artifact,
+            isError: response.isError,
+        });
+    }
+    resumeToolCall(payload) {
+        const state = this.contentBinding.getState();
+        if (!state)
+            throw new Error("Message part is not available");
+        if (state.type !== "tool-call")
+            throw new Error("Tried to resume tool call on non-tool message part");
+        if (!this.threadApi)
+            throw new Error("Thread API is not available");
+        const toolCallId = state.toolCallId;
+        this.threadApi.getState().resumeToolCall({
+            toolCallId,
+            payload,
+        });
+    }
+    subscribe(callback) {
+        return this.contentBinding.subscribe(callback);
+    }
+}

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

@@ -0,0 +1,91 @@
+import { SpeechState, SubmittedFeedback } from "../runtime-cores/core/ThreadRuntimeCore";
+import { ThreadMessage, ThreadAssistantMessagePart, ThreadUserMessagePart, Unsubscribe } from "../../types";
+import { RunConfig, ToolCallMessagePartStatus } from "../../types/AssistantTypes";
+import { AttachmentRuntime, MessageAttachmentRuntimeImpl } from "./AttachmentRuntime";
+import { EditComposerRuntime, EditComposerRuntimeImpl } from "./ComposerRuntime";
+import { MessagePartRuntime, MessagePartRuntimeImpl } from "./MessagePartRuntime";
+import { MessageRuntimePath } from "./RuntimePathTypes";
+import { ThreadRuntimeCoreBinding } from "./ThreadRuntime";
+import type { MessageStateBinding } from "./RuntimeBindings";
+export declare const toMessagePartStatus: (message: ThreadMessage, partIndex: number, part: ThreadUserMessagePart | ThreadAssistantMessagePart) => ToolCallMessagePartStatus;
+export type MessageState = ThreadMessage & {
+    readonly parentId: string | null;
+    /** The position of this message in the thread (0 for first message) */
+    readonly index: number;
+    readonly isLast: boolean;
+    readonly branchNumber: number;
+    readonly branchCount: number;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    readonly speech: SpeechState | undefined;
+    /**
+     * @deprecated Use `message.metadata.submittedFeedback` instead. This will be removed in 0.12.0.
+     */
+    readonly submittedFeedback: SubmittedFeedback | undefined;
+};
+export type { MessageStateBinding } from "./RuntimeBindings";
+type ReloadConfig = {
+    runConfig?: RunConfig;
+};
+export type MessageRuntime = {
+    readonly path: MessageRuntimePath;
+    readonly composer: EditComposerRuntime;
+    getState(): MessageState;
+    reload(config?: ReloadConfig): void;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    speak(): void;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    stopSpeaking(): void;
+    submitFeedback({ type }: {
+        type: "positive" | "negative";
+    }): void;
+    switchToBranch({ position, branchId, }: {
+        position?: "previous" | "next" | undefined;
+        branchId?: string | undefined;
+    }): void;
+    unstable_getCopyText(): string;
+    subscribe(callback: () => void): Unsubscribe;
+    getMessagePartByIndex(idx: number): MessagePartRuntime;
+    getMessagePartByToolCallId(toolCallId: string): MessagePartRuntime;
+    getAttachmentByIndex(idx: number): AttachmentRuntime & {
+        source: "message";
+    };
+};
+export declare class MessageRuntimeImpl implements MessageRuntime {
+    private _core;
+    private _threadBinding;
+    get path(): MessageRuntimePath;
+    constructor(_core: MessageStateBinding, _threadBinding: ThreadRuntimeCoreBinding);
+    protected __internal_bindMethods(): void;
+    readonly composer: EditComposerRuntimeImpl;
+    private _getEditComposerRuntimeCore;
+    getState(): ThreadMessage & {
+        readonly parentId: string | null;
+        readonly index: number;
+        readonly isLast: boolean;
+        readonly branchNumber: number;
+        readonly branchCount: number;
+        readonly speech: SpeechState | undefined;
+        readonly submittedFeedback: SubmittedFeedback | undefined;
+    };
+    reload(reloadConfig?: ReloadConfig): void;
+    speak(): void;
+    stopSpeaking(): void;
+    submitFeedback({ type }: {
+        type: "positive" | "negative";
+    }): void;
+    switchToBranch({ position, branchId, }: {
+        position?: "previous" | "next" | undefined;
+        branchId?: string | undefined;
+    }): void;
+    unstable_getCopyText(): string;
+    subscribe(callback: () => void): Unsubscribe;
+    getMessagePartByIndex(idx: number): MessagePartRuntimeImpl;
+    getMessagePartByToolCallId(toolCallId: string): MessagePartRuntimeImpl;
+    getAttachmentByIndex(idx: number): MessageAttachmentRuntimeImpl;
+}

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

@@ -0,0 +1,174 @@
+import { symbolInnerMessage } from "../runtime-cores/external-store/getExternalStoreMessage";
+import { getThreadMessageText } from "../../utils/getThreadMessageText";
+import { MessageAttachmentRuntimeImpl, } from "./AttachmentRuntime";
+import { EditComposerRuntimeImpl, } from "./ComposerRuntime";
+import { MessagePartRuntimeImpl, } from "./MessagePartRuntime";
+import { NestedSubscriptionSubject } from "./subscribable/NestedSubscriptionSubject";
+import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE";
+import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject";
+const COMPLETE_STATUS = Object.freeze({
+    type: "complete",
+});
+export const toMessagePartStatus = (message, partIndex, part) => {
+    if (message.role !== "assistant")
+        return COMPLETE_STATUS;
+    if (part.type === "tool-call") {
+        if (!part.result) {
+            return message.status;
+        }
+        else {
+            return COMPLETE_STATUS;
+        }
+    }
+    const isLastPart = partIndex === Math.max(0, message.content.length - 1);
+    if (message.status.type === "requires-action")
+        return COMPLETE_STATUS;
+    return isLastPart ? message.status : COMPLETE_STATUS;
+};
+const getMessagePartState = (message, partIndex) => {
+    const part = message.content[partIndex];
+    if (!part) {
+        return SKIP_UPDATE;
+    }
+    // if the message part is the same, don't update
+    const status = toMessagePartStatus(message, partIndex, part);
+    return Object.freeze(Object.assign(Object.assign(Object.assign({}, part), { [symbolInnerMessage]: part[symbolInnerMessage] }), { status }));
+};
+export class MessageRuntimeImpl {
+    get path() {
+        return this._core.path;
+    }
+    constructor(_core, _threadBinding) {
+        this._core = _core;
+        this._threadBinding = _threadBinding;
+        this._getEditComposerRuntimeCore = () => {
+            return this._threadBinding
+                .getState()
+                .getEditComposer(this._core.getState().id);
+        };
+        this.composer = new EditComposerRuntimeImpl(new NestedSubscriptionSubject({
+            path: Object.assign(Object.assign({}, this.path), { ref: `${this.path.ref}${this.path.ref}.composer`, composerSource: "edit" }),
+            getState: this._getEditComposerRuntimeCore,
+            subscribe: (callback) => this._threadBinding.subscribe(callback),
+        }), () => this._threadBinding.getState().beginEdit(this._core.getState().id));
+        this.__internal_bindMethods();
+    }
+    __internal_bindMethods() {
+        this.reload = this.reload.bind(this);
+        this.getState = this.getState.bind(this);
+        this.subscribe = this.subscribe.bind(this);
+        this.getMessagePartByIndex = this.getMessagePartByIndex.bind(this);
+        this.getMessagePartByToolCallId =
+            this.getMessagePartByToolCallId.bind(this);
+        this.getAttachmentByIndex = this.getAttachmentByIndex.bind(this);
+        this.unstable_getCopyText = this.unstable_getCopyText.bind(this);
+        this.speak = this.speak.bind(this);
+        this.stopSpeaking = this.stopSpeaking.bind(this);
+        this.submitFeedback = this.submitFeedback.bind(this);
+        this.switchToBranch = this.switchToBranch.bind(this);
+    }
+    getState() {
+        return this._core.getState();
+    }
+    reload(reloadConfig = {}) {
+        const editComposerRuntimeCore = this._getEditComposerRuntimeCore();
+        const composerRuntimeCore = editComposerRuntimeCore !== null && editComposerRuntimeCore !== void 0 ? editComposerRuntimeCore : this._threadBinding.getState().composer;
+        const composer = editComposerRuntimeCore !== null && editComposerRuntimeCore !== void 0 ? editComposerRuntimeCore : composerRuntimeCore;
+        const { runConfig = composer.runConfig } = reloadConfig;
+        const state = this._core.getState();
+        if (state.role !== "assistant")
+            throw new Error("Can only reload assistant messages");
+        this._threadBinding.getState().startRun({
+            parentId: state.parentId,
+            sourceId: state.id,
+            runConfig,
+        });
+    }
+    speak() {
+        const state = this._core.getState();
+        return this._threadBinding.getState().speak(state.id);
+    }
+    stopSpeaking() {
+        var _a;
+        const state = this._core.getState();
+        const thread = this._threadBinding.getState();
+        if (((_a = thread.speech) === null || _a === void 0 ? void 0 : _a.messageId) === state.id) {
+            this._threadBinding.getState().stopSpeaking();
+        }
+        else {
+            throw new Error("Message is not being spoken");
+        }
+    }
+    submitFeedback({ type }) {
+        const state = this._core.getState();
+        this._threadBinding.getState().submitFeedback({
+            messageId: state.id,
+            type,
+        });
+    }
+    switchToBranch({ position, branchId, }) {
+        const state = this._core.getState();
+        if (branchId && position) {
+            throw new Error("May not specify both branchId and position");
+        }
+        else if (!branchId && !position) {
+            throw new Error("Must specify either branchId or position");
+        }
+        const thread = this._threadBinding.getState();
+        const branches = thread.getBranches(state.id);
+        let targetBranch = branchId;
+        if (position === "previous") {
+            targetBranch = branches[state.branchNumber - 2];
+        }
+        else if (position === "next") {
+            targetBranch = branches[state.branchNumber];
+        }
+        if (!targetBranch)
+            throw new Error("Branch not found");
+        this._threadBinding.getState().switchToBranch(targetBranch);
+    }
+    unstable_getCopyText() {
+        return getThreadMessageText(this.getState());
+    }
+    subscribe(callback) {
+        return this._core.subscribe(callback);
+    }
+    getMessagePartByIndex(idx) {
+        if (idx < 0)
+            throw new Error("Message part index must be >= 0");
+        return new MessagePartRuntimeImpl(new ShallowMemoizeSubject({
+            path: Object.assign(Object.assign({}, this.path), { ref: `${this.path.ref}${this.path.ref}.content[${idx}]`, messagePartSelector: { type: "index", index: idx } }),
+            getState: () => {
+                return getMessagePartState(this.getState(), idx);
+            },
+            subscribe: (callback) => this._core.subscribe(callback),
+        }), this._core, this._threadBinding);
+    }
+    getMessagePartByToolCallId(toolCallId) {
+        return new MessagePartRuntimeImpl(new ShallowMemoizeSubject({
+            path: Object.assign(Object.assign({}, this.path), { ref: this.path.ref +
+                    `${this.path.ref}.content[toolCallId=${JSON.stringify(toolCallId)}]`, messagePartSelector: { type: "toolCallId", toolCallId } }),
+            getState: () => {
+                const state = this._core.getState();
+                const idx = state.content.findIndex((part) => part.type === "tool-call" && part.toolCallId === toolCallId);
+                if (idx === -1)
+                    return SKIP_UPDATE;
+                return getMessagePartState(state, idx);
+            },
+            subscribe: (callback) => this._core.subscribe(callback),
+        }), this._core, this._threadBinding);
+    }
+    getAttachmentByIndex(idx) {
+        return new MessageAttachmentRuntimeImpl(new ShallowMemoizeSubject({
+            path: Object.assign(Object.assign({}, this.path), { ref: `${this.path.ref}${this.path.ref}.attachments[${idx}]`, attachmentSource: "message", attachmentSelector: { type: "index", index: idx } }),
+            getState: () => {
+                const attachments = this.getState().attachments;
+                const attachment = attachments === null || attachments === void 0 ? void 0 : attachments[idx];
+                if (!attachment)
+                    return SKIP_UPDATE;
+                return Object.assign(Object.assign({}, attachment), { source: "message" });
+            },
+            subscribe: (callback) => this._core.subscribe(callback),
+        }));
+    }
+}

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

@@ -0,0 +1,36 @@
+import type { ComposerRuntimeCore, ThreadComposerRuntimeCore } from "../runtime-cores/core/ComposerRuntimeCore";
+import type { ThreadRuntimeCore } from "../runtime-cores/core/ThreadRuntimeCore";
+import type { ThreadListRuntimeCore } from "../runtime-cores/core/ThreadListRuntimeCore";
+import type { SubscribableWithState } from "./subscribable/Subscribable";
+import type { ThreadMessage } from "../../types";
+import type { SpeechState, SubmittedFeedback } from "../runtime-cores/core/ThreadRuntimeCore";
+import type { ComposerRuntimePath, ThreadRuntimePath, ThreadListItemRuntimePath, MessageRuntimePath } from "./RuntimePathTypes";
+export type ComposerRuntimeCoreBinding = SubscribableWithState<ComposerRuntimeCore | undefined, ComposerRuntimePath>;
+export type ThreadComposerRuntimeCoreBinding = SubscribableWithState<ThreadComposerRuntimeCore | undefined, ComposerRuntimePath & {
+    composerSource: "thread";
+}>;
+export type EditComposerRuntimeCoreBinding = SubscribableWithState<ComposerRuntimeCore | undefined, ComposerRuntimePath & {
+    composerSource: "edit";
+}>;
+export type ThreadRuntimeCoreBinding = SubscribableWithState<ThreadRuntimeCore, ThreadRuntimePath>;
+export type ThreadListRuntimeCoreBinding = SubscribableWithState<ThreadListRuntimeCore, ThreadListItemRuntimePath>;
+export type MessageStateBinding = SubscribableWithState<ThreadMessage & {
+    readonly parentId: string | null;
+    /** The position of this message in the thread (0 for first message) */
+    readonly index: number;
+    readonly isLast: boolean;
+    readonly branchNumber: number;
+    readonly branchCount: number;
+    readonly speech: SpeechState | undefined;
+    /** @deprecated Use `message.metadata.submittedFeedback` instead. This will be removed in 0.12.0. */
+    readonly submittedFeedback: SubmittedFeedback | undefined;
+}, MessageRuntimePath>;
+export type ThreadListItemStatus = "archived" | "regular" | "new" | "deleted";
+export type ThreadListItemState = {
+    readonly isMain: boolean;
+    readonly id: string;
+    readonly remoteId: string | undefined;
+    readonly externalId: string | undefined;
+    readonly status: ThreadListItemStatus;
+    readonly title?: string | undefined;
+};

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

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