ikoncomponents 1.6.4 → 1.6.5

package/dist/vendor/assistant-ui-react/src/model-context/registry/ModelContextRegistry.d.ts

@@ -0,0 +1,18 @@
+import { ModelContext, ModelContextProvider } from "../ModelContextTypes";
+import { Unsubscribe } from "../../types/Unsubscribe";
+import { ModelContextRegistryToolHandle, ModelContextRegistryInstructionHandle, ModelContextRegistryProviderHandle } from "./ModelContextRegistryHandles";
+import type { AssistantToolProps } from "../useAssistantTool";
+import type { AssistantInstructionsConfig } from "../useAssistantInstructions";
+export declare class ModelContextRegistry implements ModelContextProvider {
+    private _tools;
+    private _instructions;
+    private _providers;
+    private _subscribers;
+    private _providerUnsubscribes;
+    getModelContext(): ModelContext;
+    subscribe(callback: () => void): Unsubscribe;
+    private notifySubscribers;
+    addTool<TArgs extends Record<string, unknown>, TResult>(tool: AssistantToolProps<TArgs, TResult>): ModelContextRegistryToolHandle<TArgs, TResult>;
+    addInstruction(config: string | AssistantInstructionsConfig): ModelContextRegistryInstructionHandle;
+    addProvider(provider: ModelContextProvider): ModelContextRegistryProviderHandle;
+}

package/dist/vendor/assistant-ui-react/src/model-context/registry/ModelContextRegistry.js

@@ -0,0 +1,127 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { mergeModelContexts, } from "../ModelContextTypes";
+export class ModelContextRegistry {
+    constructor() {
+        this._tools = new Map();
+        this._instructions = new Map();
+        this._providers = new Map();
+        this._subscribers = new Set();
+        this._providerUnsubscribes = new Map();
+    }
+    getModelContext() {
+        // Merge instructions
+        const instructions = Array.from(this._instructions.values()).filter(Boolean);
+        const system = instructions.length > 0 ? instructions.join("\n\n") : undefined;
+        // Collect tools
+        const tools = {};
+        for (const toolProps of this._tools.values()) {
+            const { toolName, render } = toolProps, tool = __rest(toolProps, ["toolName", "render"]);
+            tools[toolName] = tool;
+        }
+        // Merge provider contexts
+        const providerContexts = mergeModelContexts(new Set(this._providers.values()));
+        // Combine everything
+        const context = {
+            system,
+            tools: Object.keys(tools).length > 0 ? tools : undefined,
+        };
+        // Merge with provider contexts
+        if (providerContexts.system) {
+            context.system = context.system
+                ? `${context.system}\n\n${providerContexts.system}`
+                : providerContexts.system;
+        }
+        if (providerContexts.tools) {
+            context.tools = Object.assign(Object.assign({}, (context.tools || {})), providerContexts.tools);
+        }
+        if (providerContexts.callSettings) {
+            context.callSettings = providerContexts.callSettings;
+        }
+        if (providerContexts.config) {
+            context.config = providerContexts.config;
+        }
+        return context;
+    }
+    subscribe(callback) {
+        this._subscribers.add(callback);
+        return () => this._subscribers.delete(callback);
+    }
+    notifySubscribers() {
+        for (const callback of this._subscribers) {
+            callback();
+        }
+    }
+    addTool(tool) {
+        const id = Symbol();
+        this._tools.set(id, tool);
+        this.notifySubscribers();
+        return {
+            update: (newTool) => {
+                if (this._tools.has(id)) {
+                    this._tools.set(id, newTool);
+                    this.notifySubscribers();
+                }
+            },
+            remove: () => {
+                this._tools.delete(id);
+                this.notifySubscribers();
+            },
+        };
+    }
+    addInstruction(config) {
+        const id = Symbol();
+        const instruction = typeof config === "string" ? config : config.instruction;
+        const disabled = typeof config === "object" ? config.disabled : false;
+        if (!disabled) {
+            this._instructions.set(id, instruction);
+            this.notifySubscribers();
+        }
+        return {
+            update: (newConfig) => {
+                const newInstruction = typeof newConfig === "string" ? newConfig : newConfig.instruction;
+                const newDisabled = typeof newConfig === "object" ? newConfig.disabled : false;
+                if (newDisabled) {
+                    this._instructions.delete(id);
+                }
+                else {
+                    this._instructions.set(id, newInstruction);
+                }
+                this.notifySubscribers();
+            },
+            remove: () => {
+                this._instructions.delete(id);
+                this.notifySubscribers();
+            },
+        };
+    }
+    addProvider(provider) {
+        var _a;
+        const id = Symbol();
+        this._providers.set(id, provider);
+        // Subscribe to provider changes
+        const unsubscribe = (_a = provider.subscribe) === null || _a === void 0 ? void 0 : _a.call(provider, () => {
+            this.notifySubscribers();
+        });
+        this._providerUnsubscribes.set(id, unsubscribe);
+        this.notifySubscribers();
+        return {
+            remove: () => {
+                this._providers.delete(id);
+                const unsubscribe = this._providerUnsubscribes.get(id);
+                unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+                this._providerUnsubscribes.delete(id);
+                this.notifySubscribers();
+            },
+        };
+    }
+}

package/dist/vendor/assistant-ui-react/src/model-context/registry/ModelContextRegistryHandles.d.ts

@@ -0,0 +1,13 @@
+import type { AssistantToolProps } from "../useAssistantTool";
+import type { AssistantInstructionsConfig } from "../useAssistantInstructions";
+export interface ModelContextRegistryToolHandle<TArgs extends Record<string, unknown> = any, TResult = any> {
+    update(tool: AssistantToolProps<TArgs, TResult>): void;
+    remove(): void;
+}
+export interface ModelContextRegistryInstructionHandle {
+    update(config: string | AssistantInstructionsConfig): void;
+    remove(): void;
+}
+export interface ModelContextRegistryProviderHandle {
+    remove(): void;
+}

package/dist/vendor/assistant-ui-react/src/model-context/registry/ModelContextRegistryHandles.js

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

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

@@ -0,0 +1,2 @@
+export * from "./ModelContextRegistry";
+export * from "./ModelContextRegistryHandles";

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

@@ -0,0 +1,2 @@
+export * from "./ModelContextRegistry";
+export * from "./ModelContextRegistryHandles";

package/dist/vendor/assistant-ui-react/src/model-context/tool.d.ts

@@ -0,0 +1,2 @@
+import { Tool } from "assistant-stream";
+export declare function tool<TArgs extends Record<string, unknown>, TResult = any>(tool: Tool<TArgs, TResult>): Tool<TArgs, TResult>;

package/dist/vendor/assistant-ui-react/src/model-context/tool.js

@@ -0,0 +1,4 @@
+// TODO re-add the inferrence of the parameters
+export function tool(tool) {
+    return tool;
+}

package/dist/vendor/assistant-ui-react/src/model-context/toolbox.d.ts

@@ -0,0 +1,9 @@
+import type { Tool } from "assistant-stream";
+import type { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
+export type ToolDefinition<TArgs extends Record<string, unknown>, TResult> = Tool<TArgs, TResult> & {
+    render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;
+};
+export type Toolkit = Record<string, ToolDefinition<any, any>>;
+export type ToolsConfig = {
+    toolkit: Toolkit;
+};

package/dist/vendor/assistant-ui-react/src/model-context/toolbox.js

@@ -0,0 +1,2 @@
+"use client";
+export {};

package/dist/vendor/assistant-ui-react/src/model-context/useAssistantInstructions.d.ts

@@ -0,0 +1,5 @@
+export type AssistantInstructionsConfig = {
+    disabled?: boolean | undefined;
+    instruction: string;
+};
+export declare const useAssistantInstructions: (config: string | AssistantInstructionsConfig) => void;

package/dist/vendor/assistant-ui-react/src/model-context/useAssistantInstructions.js

@@ -0,0 +1,22 @@
+"use client";
+import { useEffect } from "react";
+import { useAui } from "@assistant-ui/store";
+const getInstructions = (instruction) => {
+    if (typeof instruction === "string")
+        return { instruction };
+    return instruction;
+};
+export const useAssistantInstructions = (config) => {
+    const { instruction, disabled = false } = getInstructions(config);
+    const aui = useAui();
+    useEffect(() => {
+        if (disabled)
+            return;
+        const config = {
+            system: instruction,
+        };
+        return aui.modelContext().register({
+            getModelContext: () => config,
+        });
+    }, [aui, instruction, disabled]);
+};

package/dist/vendor/assistant-ui-react/src/model-context/useAssistantTool.d.ts

@@ -0,0 +1,7 @@
+import type { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
+import type { Tool } from "assistant-stream";
+export type AssistantToolProps<TArgs extends Record<string, unknown>, TResult> = Tool<TArgs, TResult> & {
+    toolName: string;
+    render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;
+};
+export declare const useAssistantTool: <TArgs extends Record<string, unknown>, TResult>(tool: AssistantToolProps<TArgs, TResult>) => void;

package/dist/vendor/assistant-ui-react/src/model-context/useAssistantTool.js

@@ -0,0 +1,33 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { useEffect } from "react";
+import { useAui } from "@assistant-ui/store";
+export const useAssistantTool = (tool) => {
+    const aui = useAui();
+    useEffect(() => {
+        if (!tool.render)
+            return undefined;
+        return aui.tools().setToolUI(tool.toolName, tool.render);
+    }, [aui, tool.toolName, tool.render]);
+    useEffect(() => {
+        const { toolName, render } = tool, rest = __rest(tool, ["toolName", "render"]);
+        const context = {
+            tools: {
+                [toolName]: rest,
+            },
+        };
+        return aui.modelContext().register({
+            getModelContext: () => context,
+        });
+    }, [aui, tool]);
+};

package/dist/vendor/assistant-ui-react/src/model-context/useAssistantToolUI.d.ts

@@ -0,0 +1,6 @@
+import type { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
+export type AssistantToolUIProps<TArgs, TResult> = {
+    toolName: string;
+    render: ToolCallMessagePartComponent<TArgs, TResult>;
+};
+export declare const useAssistantToolUI: (tool: AssistantToolUIProps<any, any> | null) => void;

package/dist/vendor/assistant-ui-react/src/model-context/useAssistantToolUI.js

@@ -0,0 +1,11 @@
+"use client";
+import { useEffect } from "react";
+import { useAui } from "@assistant-ui/store";
+export const useAssistantToolUI = (tool) => {
+    const aui = useAui();
+    useEffect(() => {
+        if (!(tool === null || tool === void 0 ? void 0 : tool.toolName) || !(tool === null || tool === void 0 ? void 0 : tool.render))
+            return undefined;
+        return aui.tools().setToolUI(tool.toolName, tool.render);
+    }, [aui, tool === null || tool === void 0 ? void 0 : tool.toolName, tool === null || tool === void 0 ? void 0 : tool.render]);
+};

package/dist/vendor/assistant-ui-react/src/model-context/useInlineRender.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { ToolCallMessagePartProps } from "../types";
+export declare const useInlineRender: <TArgs, TResult>(toolUI: FC<ToolCallMessagePartProps<TArgs, TResult>>) => FC<ToolCallMessagePartProps<TArgs, TResult>>;

package/dist/vendor/assistant-ui-react/src/model-context/useInlineRender.js

@@ -0,0 +1,15 @@
+"use client";
+import { useCallback, useEffect, useState } from "react";
+import { create } from "zustand";
+export const useInlineRender = (toolUI) => {
+    const [useToolUIStore] = useState(() => create(() => ({
+        toolUI,
+    })));
+    useEffect(() => {
+        useToolUIStore.setState({ toolUI });
+    }, [toolUI, useToolUIStore]);
+    return useCallback(function ToolUI(args) {
+        const store = useToolUIStore();
+        return store.toolUI(args);
+    }, [useToolUIStore]);
+};

package/dist/vendor/assistant-ui-react/src/primitives/actionBar/ActionBarCopy.d.ts

@@ -0,0 +1,56 @@
+import { ActionButtonProps } from "../../utils/createActionButton";
+/**
+ * Hook that provides copy functionality for action bar buttons.
+ *
+ * This hook returns a callback function that copies message content to the clipboard,
+ * or null if copying is not available. It handles both regular message content and
+ * composer text when in editing mode.
+ *
+ * @param options Configuration options
+ * @param options.copiedDuration Duration in milliseconds to show the copied state
+ * @returns A copy callback function, or null if copying is disabled
+ *
+ * @example
+ * ```tsx
+ * function CustomCopyButton() {
+ *   const copy = useActionBarPrimitiveCopy({ copiedDuration: 2000 });
+ *
+ *   return (
+ *     <button onClick={copy} disabled={!copy}>
+ *       {copy ? "Copy" : "Cannot Copy"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare const useActionBarPrimitiveCopy: ({ copiedDuration, }?: {
+    copiedDuration?: number | undefined;
+}) => (() => void) | null;
+export declare namespace ActionBarPrimitiveCopy {
+    type Element = HTMLButtonElement;
+    /**
+     * Props for the ActionBarPrimitive.Copy component.
+     * Inherits all button element props and action button functionality.
+     */
+    type Props = ActionButtonProps<typeof useActionBarPrimitiveCopy>;
+}
+/**
+ * A button component that copies message content to the clipboard.
+ *
+ * This component automatically handles copying message text to the clipboard
+ * and provides visual feedback through the data-copied attribute. It's disabled
+ * when there's no copyable content available.
+ *
+ * @example
+ * ```tsx
+ * <ActionBarPrimitive.Copy copiedDuration={2000}>
+ *   Copy Message
+ * </ActionBarPrimitive.Copy>
+ * ```
+ */
+export declare const ActionBarPrimitiveCopy: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    copiedDuration?: number | undefined;
+} & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/vendor/assistant-ui-react/src/primitives/actionBar/ActionBarCopy.js

@@ -0,0 +1,87 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { composeEventHandlers } from "@radix-ui/primitive";
+import { Primitive } from "@radix-ui/react-primitive";
+import { useCallback } from "react";
+import { useAuiState, useAui } from "@assistant-ui/store";
+/**
+ * Hook that provides copy functionality for action bar buttons.
+ *
+ * This hook returns a callback function that copies message content to the clipboard,
+ * or null if copying is not available. It handles both regular message content and
+ * composer text when in editing mode.
+ *
+ * @param options Configuration options
+ * @param options.copiedDuration Duration in milliseconds to show the copied state
+ * @returns A copy callback function, or null if copying is disabled
+ *
+ * @example
+ * ```tsx
+ * function CustomCopyButton() {
+ *   const copy = useActionBarPrimitiveCopy({ copiedDuration: 2000 });
+ *
+ *   return (
+ *     <button onClick={copy} disabled={!copy}>
+ *       {copy ? "Copy" : "Cannot Copy"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+const useActionBarPrimitiveCopy = ({ copiedDuration = 3000, } = {}) => {
+    const aui = useAui();
+    const hasCopyableContent = useAuiState(({ message }) => {
+        var _a;
+        return ((message.role !== "assistant" || ((_a = message.status) === null || _a === void 0 ? void 0 : _a.type) !== "running") &&
+            message.parts.some((c) => c.type === "text" && c.text.length > 0));
+    });
+    const isEditing = useAuiState(({ composer }) => composer.isEditing);
+    const composerValue = useAuiState(({ composer }) => composer.text);
+    const callback = useCallback(() => {
+        const valueToCopy = isEditing ? composerValue : aui.message().getCopyText();
+        if (!valueToCopy)
+            return;
+        navigator.clipboard.writeText(valueToCopy).then(() => {
+            aui.message().setIsCopied(true);
+            setTimeout(() => aui.message().setIsCopied(false), copiedDuration);
+        });
+    }, [aui, isEditing, composerValue, copiedDuration]);
+    if (!hasCopyableContent)
+        return null;
+    return callback;
+};
+/**
+ * A button component that copies message content to the clipboard.
+ *
+ * This component automatically handles copying message text to the clipboard
+ * and provides visual feedback through the data-copied attribute. It's disabled
+ * when there's no copyable content available.
+ *
+ * @example
+ * ```tsx
+ * <ActionBarPrimitive.Copy copiedDuration={2000}>
+ *   Copy Message
+ * </ActionBarPrimitive.Copy>
+ * ```
+ */
+export const ActionBarPrimitiveCopy = forwardRef((_a, forwardedRef) => {
+    var { copiedDuration, onClick, disabled } = _a, props = __rest(_a, ["copiedDuration", "onClick", "disabled"]);
+    const isCopied = useAuiState(({ message }) => message.isCopied);
+    const callback = useActionBarPrimitiveCopy({ copiedDuration });
+    return (_jsx(Primitive.button, Object.assign({ type: "button" }, (isCopied ? { "data-copied": "true" } : {}), props, { ref: forwardedRef, disabled: disabled || !callback, onClick: composeEventHandlers(onClick, () => {
+            callback === null || callback === void 0 ? void 0 : callback();
+        }) })));
+});
+ActionBarPrimitiveCopy.displayName = "ActionBarPrimitive.Copy";

package/dist/vendor/assistant-ui-react/src/primitives/actionBar/ActionBarEdit.d.ts

@@ -0,0 +1,48 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+/**
+ * Hook that provides edit functionality for action bar buttons.
+ *
+ * This hook returns a callback function that starts editing the current message,
+ * or null if editing is not available (e.g., already in editing mode).
+ *
+ * @returns An edit callback function, or null if editing is disabled
+ *
+ * @example
+ * ```tsx
+ * function CustomEditButton() {
+ *   const edit = useActionBarEdit();
+ *
+ *   return (
+ *     <button onClick={edit} disabled={!edit}>
+ *       {edit ? "Edit Message" : "Cannot Edit"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare const useActionBarEdit: () => (() => void) | null;
+export declare namespace ActionBarPrimitiveEdit {
+    type Element = ActionButtonElement;
+    /**
+     * Props for the ActionBarPrimitive.Edit component.
+     * Inherits all button element props and action button functionality.
+     */
+    type Props = ActionButtonProps<typeof useActionBarEdit>;
+}
+/**
+ * A button component that starts editing the current message.
+ *
+ * This component automatically handles starting the edit mode for the current message
+ * and is disabled when editing is not available (e.g., already in editing mode).
+ *
+ * @example
+ * ```tsx
+ * <ActionBarPrimitive.Edit>
+ *   Edit Message
+ * </ActionBarPrimitive.Edit>
+ * ```
+ */
+export declare const ActionBarPrimitiveEdit: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/vendor/assistant-ui-react/src/primitives/actionBar/ActionBarEdit.js

@@ -0,0 +1,49 @@
+"use client";
+import { createActionButton, } from "../../utils/createActionButton";
+import { useCallback } from "react";
+import { useAuiState, useAui } from "@assistant-ui/store";
+/**
+ * Hook that provides edit functionality for action bar buttons.
+ *
+ * This hook returns a callback function that starts editing the current message,
+ * or null if editing is not available (e.g., already in editing mode).
+ *
+ * @returns An edit callback function, or null if editing is disabled
+ *
+ * @example
+ * ```tsx
+ * function CustomEditButton() {
+ *   const edit = useActionBarEdit();
+ *
+ *   return (
+ *     <button onClick={edit} disabled={!edit}>
+ *       {edit ? "Edit Message" : "Cannot Edit"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+const useActionBarEdit = () => {
+    const aui = useAui();
+    const disabled = useAuiState(({ composer }) => composer.isEditing);
+    const callback = useCallback(() => {
+        aui.composer().beginEdit();
+    }, [aui]);
+    if (disabled)
+        return null;
+    return callback;
+};
+/**
+ * A button component that starts editing the current message.
+ *
+ * This component automatically handles starting the edit mode for the current message
+ * and is disabled when editing is not available (e.g., already in editing mode).
+ *
+ * @example
+ * ```tsx
+ * <ActionBarPrimitive.Edit>
+ *   Edit Message
+ * </ActionBarPrimitive.Edit>
+ * ```
+ */
+export const ActionBarPrimitiveEdit = createActionButton("ActionBarPrimitive.Edit", useActionBarEdit);

package/dist/vendor/assistant-ui-react/src/primitives/actionBar/ActionBarExportMarkdown.d.ts

@@ -0,0 +1,16 @@
+import { ActionButtonProps } from "../../utils/createActionButton";
+declare const useActionBarExportMarkdown: ({ filename, onExport, }?: {
+    filename?: string | undefined;
+    onExport?: ((content: string) => void | Promise<void>) | undefined;
+}) => (() => Promise<void>) | null;
+export declare namespace ActionBarPrimitiveExportMarkdown {
+    type Element = HTMLButtonElement;
+    type Props = ActionButtonProps<typeof useActionBarExportMarkdown>;
+}
+export declare const ActionBarPrimitiveExportMarkdown: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    filename?: string | undefined;
+    onExport?: ((content: string) => void | Promise<void>) | undefined;
+} & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/vendor/assistant-ui-react/src/primitives/actionBar/ActionBarExportMarkdown.js

@@ -0,0 +1,53 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useCallback } from "react";
+import { composeEventHandlers } from "@radix-ui/primitive";
+import { Primitive } from "@radix-ui/react-primitive";
+import { useAuiState, useAui } from "@assistant-ui/store";
+const useActionBarExportMarkdown = ({ filename, onExport, } = {}) => {
+    const aui = useAui();
+    const hasExportableContent = useAuiState(({ message }) => {
+        var _a;
+        return ((message.role !== "assistant" || ((_a = message.status) === null || _a === void 0 ? void 0 : _a.type) !== "running") &&
+            message.parts.some((c) => c.type === "text" && c.text.length > 0));
+    });
+    const callback = useCallback(async () => {
+        const content = aui.message().getCopyText();
+        if (!content)
+            return;
+        if (onExport) {
+            await onExport(content);
+            return;
+        }
+        const blob = new Blob([content], { type: "text/markdown" });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = filename !== null && filename !== void 0 ? filename : `message-${Date.now()}.md`;
+        a.click();
+        URL.revokeObjectURL(url);
+    }, [aui, filename, onExport]);
+    if (!hasExportableContent)
+        return null;
+    return callback;
+};
+export const ActionBarPrimitiveExportMarkdown = forwardRef((_a, forwardedRef) => {
+    var { filename, onExport, onClick, disabled } = _a, props = __rest(_a, ["filename", "onExport", "onClick", "disabled"]);
+    const callback = useActionBarExportMarkdown({ filename, onExport });
+    return (_jsx(Primitive.button, Object.assign({ type: "button" }, props, { ref: forwardedRef, disabled: disabled || !callback, onClick: composeEventHandlers(onClick, () => {
+            callback === null || callback === void 0 ? void 0 : callback();
+        }) })));
+});
+ActionBarPrimitiveExportMarkdown.displayName =
+    "ActionBarPrimitive.ExportMarkdown";

package/dist/vendor/assistant-ui-react/src/primitives/actionBar/ActionBarFeedbackNegative.d.ts

@@ -0,0 +1,10 @@
+import { ActionButtonProps } from "../../utils/createActionButton";
+declare const useActionBarFeedbackNegative: () => () => void;
+export declare namespace ActionBarPrimitiveFeedbackNegative {
+    type Element = HTMLButtonElement;
+    type Props = ActionButtonProps<typeof useActionBarFeedbackNegative>;
+}
+export declare const ActionBarPrimitiveFeedbackNegative: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export {};