mastra 0.1.57-alpha.90 → 0.1.57-unstable.100

package/dist/shared/components/dynamic-form/schema.d.ts

@@ -0,0 +1,70 @@
+import * as React from 'react';
+import { Control } from 'react-hook-form';
+import { z, ZodSchema } from 'zod';
+type ActionVariables = Record<string, any>;
+export declare enum FormConfigType {
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    DATE = "DATE",
+    ENUM = "ENUM",
+    ARRAY = "ARRAY",
+    BOOLEAN = "BOOLEAN",
+    RECORD = "RECORD",
+    OBJECT = "OBJECT",
+    UNION = "UNION",
+    CREATABLE = "CREATABLE",
+    SELECT = "SELECT",
+    MULTI_SELECT = "MULTI_SELECT"
+}
+type FormConfig = {
+    type: FormConfigType;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    isOptional?: boolean;
+    hasEffects?: boolean;
+    innerSchema?: ZodSchema;
+};
+export declare function getFormConfigTypesFromSchemaDef({ schema, isOptional, }: {
+    schema: ZodSchema<any>;
+    isOptional?: boolean;
+}): FormConfig;
+export type FieldProps = {
+    name: string;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    control: Control<any>;
+    innerSchema?: ZodSchema;
+    variables?: Record<string, ActionVariables | undefined>;
+    isNullable?: boolean;
+    handleFieldChange: ({ key, value, variables, }: {
+        key: keyof z.infer<any>;
+        value: any;
+        variables?: ActionVariables;
+    }) => void;
+};
+export declare function schemaToFormFieldRenderer<T extends ZodSchema>({ schema, errors, renderFieldMap, schemaField, renderLabel, control, variables, onFieldChange, schemaOptions, values, isOptional, isNullable, }: {
+    schema: ZodSchema<any>;
+    errors: any;
+    renderFieldMap?: Record<FormConfigType, (props: FieldProps) => React.ReactNode>;
+    schemaField: string;
+    control: any;
+    onFieldChange: (props: {
+        key: keyof z.infer<T>;
+        value: any;
+        variables?: ActionVariables;
+    }) => void;
+    variables?: Record<string, ActionVariables | undefined>;
+    schemaOptions?: Record<string, any>;
+    renderLabel?: ({ isOptional, schemaField }: {
+        isOptional: boolean;
+        schemaField: string;
+    }) => React.ReactNode;
+    values: Record<keyof z.infer<T>, unknown>;
+    isOptional?: boolean;
+    isNullable?: boolean;
+}): any;
+export {};

package/dist/shared/components/dynamic-form/schema.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { z, ZodArray, ZodBoolean, ZodDate, ZodEnum, ZodLiteral, ZodNumber } from 'zod';
+import { flattenObject, getPath } from '../../lib/object';
+import { toTitleCase } from '../../lib/string';
+import { Label } from '../ui/label';
+import { Text } from '../ui/text';
+export var FormConfigType;
+(function (FormConfigType) {
+    FormConfigType["STRING"] = "STRING";
+    FormConfigType["NUMBER"] = "NUMBER";
+    FormConfigType["DATE"] = "DATE";
+    FormConfigType["ENUM"] = "ENUM";
+    FormConfigType["ARRAY"] = "ARRAY";
+    FormConfigType["BOOLEAN"] = "BOOLEAN";
+    FormConfigType["RECORD"] = "RECORD";
+    FormConfigType["OBJECT"] = "OBJECT";
+    FormConfigType["UNION"] = "UNION";
+    FormConfigType["CREATABLE"] = "CREATABLE";
+    FormConfigType["SELECT"] = "SELECT";
+    FormConfigType["MULTI_SELECT"] = "MULTI_SELECT";
+})(FormConfigType || (FormConfigType = {}));
+export function getFormConfigTypesFromSchemaDef({ schema, isOptional = false, }) {
+    if (schema instanceof z.ZodObject) {
+        return { type: FormConfigType.OBJECT, isOptional };
+    }
+    if (schema instanceof z.ZodString) {
+        // if it's a datetime -- accounts for date weirdness during zod schema serialization to JSON
+        if (schema instanceof z.ZodString && schema._def.checks.some((check) => check.kind === 'datetime')) {
+            return { type: FormConfigType.DATE, isOptional };
+        }
+        return { type: FormConfigType.STRING, isOptional };
+    }
+    else if (schema instanceof ZodNumber) {
+        return { type: FormConfigType.NUMBER, isOptional };
+    }
+    else if (schema instanceof ZodBoolean) {
+        return { type: FormConfigType.BOOLEAN, isOptional };
+    }
+    else if (schema instanceof ZodDate) {
+        return { type: FormConfigType.DATE, isOptional };
+    }
+    else if (schema instanceof ZodLiteral) {
+        return {
+            type: FormConfigType.ENUM,
+            isOptional,
+            options: [{ label: schema.value, value: schema.value }],
+        };
+    }
+    else if (schema instanceof ZodEnum) {
+        return {
+            type: FormConfigType.ENUM,
+            isOptional,
+            options: schema.options.map((v) => ({ label: v, value: v })),
+        };
+    }
+    else if (schema instanceof ZodArray) {
+        return {
+            type: FormConfigType.ARRAY,
+            isOptional,
+            options: schema.element instanceof ZodEnum ? schema.element.options.map((v) => ({ label: v, value: v })) : [],
+        };
+    }
+    else if (schema instanceof z.ZodOptional || schema instanceof z.ZodDefault) {
+        return getFormConfigTypesFromSchemaDef({ schema: schema._def.innerType, isOptional: true });
+    }
+    else if (schema instanceof z.ZodEffects) {
+        return getFormConfigTypesFromSchemaDef({ schema: schema._def.schema, isOptional });
+    }
+    else if (schema instanceof z.ZodRecord) {
+        return {
+            type: FormConfigType.RECORD,
+            isOptional,
+            innerSchema: schema._def.valueType,
+        };
+    }
+    else {
+        return { type: FormConfigType.STRING, isOptional }; // Handle other types as needed
+    }
+}
+export function schemaToFormFieldRenderer({ schema, errors, renderFieldMap, schemaField, renderLabel, control, variables, onFieldChange, schemaOptions, values, isOptional = false, isNullable = false, }) {
+    const fieldConfig = getFormConfigTypesFromSchemaDef({ schema, isOptional });
+    const parentFieldValue = schemaOptions?.parentField ? getPath(values, schemaOptions?.parentField) : '';
+    if (schemaOptions?.parentField && !parentFieldValue) {
+        return null;
+    }
+    if (!renderFieldMap)
+        return;
+    const flattenedErrors = flattenObject(errors, ['message', 'type']);
+    const fieldOptions = schemaOptions?.parentField
+        ? schemaOptions?.options?.[parentFieldValue]
+        : schemaOptions?.options || fieldConfig.options;
+    return (_jsxs("div", { className: "flex flex-col gap-1 mt-3", children: [renderLabel ? (renderLabel({ isOptional: Boolean(fieldConfig.isOptional), schemaField })) : (_jsxs(Label, { className: "flex gap-0.5 capitalize", htmlFor: schemaField, "aria-required": !fieldConfig.isOptional, children: [!fieldConfig?.isOptional && _jsx("span", { className: "text-red-500", children: "*" }), _jsx(Text, { variant: "secondary", className: "text-mastra-el-3", size: "xs", children: toTitleCase(schemaField.split('.').pop() || '') })] })), renderFieldMap[fieldConfig.type]({
+                name: schemaField,
+                options: fieldOptions,
+                control,
+                variables,
+                innerSchema: fieldConfig.innerSchema,
+                handleFieldChange: onFieldChange,
+                isNullable,
+            }), flattenedErrors?.[schemaField] ? (_jsx(Text, { size: "xs", className: "text-red-500", children: flattenedErrors[schemaField]?.message })) : null] }, schemaField));
+}

package/dist/shared/components/dynamic-form/utils.d.ts

@@ -0,0 +1,11 @@
+import { FieldErrors } from 'react-hook-form';
+import { z } from 'zod';
+export declare const transformToNestObject: (error: z.ZodError) => FieldErrors;
+/**
+ * Resolve serialized zod output - This function takes the string output ot the `jsonSchemaToZod` function
+ * and instantiates the zod object correctly.
+ *
+ * @param obj - serialized zod object
+ * @returns resolved zod object
+ */
+export declare function resolveSerializedZodOutput(obj: any): any;

package/dist/shared/components/dynamic-form/utils.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const transformToNestObject = (error) => {
+    const fieldErrors = {};
+    error.errors.forEach(err => {
+        if (err.path.length > 0) {
+            const path = err.path.join('.');
+            fieldErrors[path] = {
+                type: 'validation',
+                message: err.message,
+            };
+        }
+    });
+    return fieldErrors;
+};
+/**
+ * Resolve serialized zod output - This function takes the string output ot the `jsonSchemaToZod` function
+ * and instantiates the zod object correctly.
+ *
+ * @param obj - serialized zod object
+ * @returns resolved zod object
+ */
+export function resolveSerializedZodOutput(obj) {
+    return Function('z', `"use strict";return (${obj});`)(z);
+}

package/dist/shared/components/layout.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const Layout: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/components/layout.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Sidebar } from './ui/sidebar';
+import { Toaster } from './ui/sonner';
+import { ThemeProvider } from './ui/theme-provider';
+export const Layout = ({ children }) => {
+    return (_jsxs(ThemeProvider, { defaultTheme: "dark", attribute: "class", children: [_jsx(Toaster, { position: "bottom-right" }), _jsxs("main", { className: "bg-mastra-bg-1 grid h-full w-full grid-cols-[15rem_minmax(0,_1fr)] overflow-clip", children: [_jsx("div", { className: "z-20 h-full", children: _jsx("div", { className: "h-full", children: _jsx(Sidebar, {}) }) }), _jsx("div", { className: "bg-mastra-bg-2 grid h-[calc(100vh-1rem)] relative border-mastra-border-1 rounded-xs border-thin m-2 overflow-hidden border-solid", children: children })] })] }));
+};

package/dist/shared/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const badgeVariants: (props?: {
+    variant?: "default" | "destructive" | "outline" | "secondary";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/shared/components/ui/badge.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cva } from 'class-variance-authority';
+import { cn } from '../../lib/utils';
+const badgeVariants = cva('inline-flex items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2', {
+    variants: {
+        variant: {
+            default: 'border-transparent bg-primary text-primary-foreground shadow hover:bg-primary/80',
+            secondary: 'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80',
+            destructive: 'border-transparent bg-destructive text-destructive-foreground shadow hover:bg-destructive/80',
+            outline: 'text-foreground',
+        },
+    },
+    defaultVariants: {
+        variant: 'default',
+    },
+});
+function Badge({ className, variant, ...props }) {
+    return _jsx("div", { className: cn(badgeVariants({ variant }), className), ...props });
+}
+export { Badge, badgeVariants };

package/dist/shared/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonVariants: (props?: {
+    variant?: "link" | "default" | "primary" | "destructive" | "outline" | "secondary" | "ghost";
+    size?: "default" | "sm" | "lg" | "icon";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/dist/shared/components/ui/button.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Slot } from '@radix-ui/react-slot';
+import { cva } from 'class-variance-authority';
+import * as React from 'react';
+import { cn } from '../../lib/utils';
+const buttonVariants = cva('inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0', {
+    variants: {
+        variant: {
+            default: 'bg-mastra-bg-7 border-[0.5px] border-mastra-border-4 text-white hover:bg-mastra-bg-7/70',
+            primary: 'border-[0.5px] border-mastra-border-1 bg-mastra-bg-4 hover:bg-mastra-bg-2/80 text-kp-el-6',
+            destructive: 'bg-destructive text-destructive-foreground shadow-sm hover:bg-destructive/90',
+            outline: 'border border-input bg-transparent shadow-sm hover:bg-accent hover:text-accent-foreground',
+            secondary: 'bg-secondary text-secondary-foreground shadow-sm hover:bg-secondary/80',
+            ghost: 'hover:bg-accent hover:text-accent-foreground',
+            link: 'text-primary underline-offset-4 hover:underline',
+        },
+        size: {
+            default: 'h-9 px-4 py-2',
+            sm: 'h-8 rounded-md px-3 text-xs',
+            lg: 'h-10 rounded-md px-8',
+            icon: 'h-9 w-9',
+        },
+    },
+    defaultVariants: {
+        variant: 'default',
+        size: 'default',
+    },
+});
+const Button = React.forwardRef(({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : 'button';
+    return _jsx(Comp, { className: cn(buttonVariants({ variant, size, className })), ref: ref, ...props });
+});
+Button.displayName = 'Button';
+export { Button, buttonVariants };

package/dist/shared/components/ui/calendar.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { DayPicker } from 'react-day-picker';
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };

package/dist/shared/components/ui/calendar.js

@@ -0,0 +1,41 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CalendarIcon } from 'lucide-react';
+import { DayPicker } from 'react-day-picker';
+import { cn } from '../../lib/utils';
+import { buttonVariants } from './button';
+function Calendar({ className, classNames, showOutsideDays = true, ...props }) {
+    return (_jsx(DayPicker, { showOutsideDays: showOutsideDays, className: cn('p-3', className), classNames: {
+            months: 'flex flex-col space-y-4 sm:space-y-0',
+            month: 'space-y-4',
+            month_caption: 'flex justify-center pt-1 relative items-center',
+            caption_label: 'text-sm text-text font-medium',
+            nav: 'space-x-1 flex items-center',
+            button_previous: cn(buttonVariants({ variant: 'outline' }), 'h-7 w-7 bg-transparent p-0 opacity-50 hover:opacity-100', 'absolute left-1 top-[12px] z-10'),
+            button_next: cn(buttonVariants({ variant: 'outline' }), 'h-7 w-7 bg-transparent p-0 opacity-50 hover:opacity-100', 'absolute right-1 top-[12px] z-10'),
+            month_grid: 'w-full border-collapse space-y-1',
+            weekdays: 'flex',
+            weekday: 'text-muted-foreground rounded-md w-8 font-normal text-[0.8rem]',
+            week: 'flex w-full mt-2',
+            day: cn(buttonVariants({ variant: 'ghost' }), 'relative p-0 text-center text-sm focus-within:relative focus-within:z-20 [&:has([aria-selected])]:bg-accent [&:has([aria-selected].day-outside)]:bg-accent/50 [&:has([aria-selected].day-range-end)]:rounded-r-md', props.mode === 'range'
+                ? '[&:has(>.day-range-end)]:rounded-r-md [&:has(>.day-range-start)]:rounded-l-md first:[&:has([aria-selected])]:rounded-l-md last:[&:has([aria-selected])]:rounded-r-md'
+                : '[&:has([aria-selected])]:rounded-md', 'h-8 w-8 p-0 hover:bg-lightGray-7/50 font-normal aria-selected:opacity-100'),
+            range_start: 'day-range-start',
+            range_end: 'day-range-end',
+            selected: '!bg-primary !text-primary-foreground hover:bg-primary hover:text-primary-foreground focus:bg-primary focus:text-primary-foreground',
+            today: 'bg-lightGray-7/50 text-accent-foreground',
+            outside: 'day-outside text-muted-foreground opacity-50  aria-selected:bg-accent/50 aria-selected:text-muted-foreground aria-selected:opacity-30',
+            disabled: 'text-muted-foreground opacity-50',
+            range_middle: 'aria-selected:bg-accent aria-selected:text-accent-foreground',
+            hidden: 'invisible',
+            ...classNames,
+        }, components: {
+            Chevron: ({ orientation }) => (_jsx(CalendarIcon, { className: cn('h-4 w-4', {
+                    'rotate-180': orientation === 'up',
+                    'rotate-90': orientation === 'left',
+                    '-rotate-90': orientation === 'right',
+                }) })),
+        }, ...props }));
+}
+Calendar.displayName = 'Calendar';
+export { Calendar };

package/dist/shared/components/ui/chat-message.d.ts

@@ -0,0 +1,29 @@
+import { type VariantProps } from 'class-variance-authority';
+import React from 'react';
+declare const chatBubbleVariants: (props?: {
+    isUser?: boolean;
+    isError?: boolean;
+    animation?: "none" | "scale" | "slide" | "fade";
+} & import("class-variance-authority/types").ClassProp) => string;
+type Animation = VariantProps<typeof chatBubbleVariants>['animation'];
+interface Attachment {
+    name?: string;
+    contentType?: string;
+    url: string;
+}
+export interface Message {
+    id?: string;
+    role?: 'user' | 'assistant';
+    content: any;
+    isError?: boolean;
+    createdAt?: Date;
+}
+export interface ChatMessageProps extends Message {
+    showTimeStamp?: boolean;
+    animation?: Animation;
+    actions?: React.ReactNode;
+    className?: string;
+    experimental_attachments?: Attachment[];
+}
+export declare const ChatMessage: React.FC<ChatMessageProps>;
+export {};

package/dist/shared/components/ui/chat-message.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cva } from 'class-variance-authority';
+import { useMemo } from 'react';
+import { FilePreview } from '../../components/ui/file-preview';
+import { MarkdownRenderer } from '../../components/ui/markdown-renderer';
+import { cn } from '../../lib/utils';
+const chatBubbleVariants = cva('group/message relative break-words rounded-lg p-3 text-sm sm:max-w-[70%]', {
+    variants: {
+        isUser: {
+            true: 'bg-primary text-primary-foreground',
+            false: 'bg-muted text-foreground',
+        },
+        isError: {
+            true: 'bg-red-100 dark:bg-red-900/20',
+            false: '',
+        },
+        animation: {
+            none: '',
+            slide: 'duration-300 animate-in fade-in-0',
+            scale: 'duration-300 animate-in fade-in-0 zoom-in-75',
+            fade: 'duration-500 animate-in fade-in-0',
+        },
+    },
+    compoundVariants: [
+        {
+            isUser: true,
+            animation: 'slide',
+            class: 'slide-in-from-right',
+        },
+        {
+            isUser: false,
+            animation: 'slide',
+            class: 'slide-in-from-left',
+        },
+        {
+            isUser: true,
+            animation: 'scale',
+            class: 'origin-bottom-right',
+        },
+        {
+            isUser: false,
+            animation: 'scale',
+            class: 'origin-bottom-left',
+        },
+    ],
+});
+export const ChatMessage = ({ role, content, createdAt, showTimeStamp = false, animation = 'scale', actions, className, experimental_attachments, isError = false, }) => {
+    const isUser = role === 'user';
+    const files = useMemo(() => {
+        return experimental_attachments?.map(attachment => {
+            const dataArray = dataUrlToUint8Array(attachment.url);
+            const file = new File([dataArray], attachment.name ?? 'Unknown');
+            return file;
+        });
+    }, [experimental_attachments]);
+    const formattedTime = createdAt?.toLocaleTimeString('en-US', {
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+    return (_jsxs("div", { className: cn('flex flex-col', isUser ? 'items-end' : 'items-start'), children: [files ? (_jsx("div", { className: "mb-1 flex gap-2 flex-wrap", children: files.map((file, index) => {
+                    return _jsx(FilePreview, { file: file }, index);
+                }) })) : null, _jsxs("div", { className: cn(chatBubbleVariants({ isUser, isError, animation }), className), children: [_jsx("div", { children: _jsx(MarkdownRenderer, { children: content }) }), role === 'assistant' && actions ? (_jsx("div", { className: "absolute -bottom-4 right-2 flex space-x-1 rounded-lg border bg-background p-1 opacity-0 transition-opacity group-hover/message:opacity-100 text-foreground", children: actions })) : null] }), showTimeStamp && createdAt ? (_jsx("time", { dateTime: createdAt.toISOString(), className: cn('mt-1 block px-1 text-xs opacity-50', animation !== 'none' && 'duration-500 animate-in fade-in-0'), children: formattedTime })) : null] }));
+};
+function dataUrlToUint8Array(data) {
+    const base64 = data.split(',')[1];
+    const buf = Buffer.from(base64 ?? '', 'base64');
+    return new Uint8Array(buf);
+}

package/dist/shared/components/ui/chat.d.ts

@@ -0,0 +1,51 @@
+import { type ReactElement } from 'react';
+import { type Message } from '../../components/ui/chat-message';
+interface ChatPropsBase {
+    handleSubmit: (event?: {
+        preventDefault?: () => void;
+    }, options?: {
+        experimental_attachments?: FileList;
+    }) => void;
+    messages: Array<Message>;
+    input: string;
+    className?: string;
+    handleInputChange: React.ChangeEventHandler<HTMLTextAreaElement>;
+    isGenerating: boolean;
+    stop?: () => void;
+    onRateResponse?: (messageId: string, rating: 'thumbs-up' | 'thumbs-down') => void;
+}
+interface ChatPropsWithoutSuggestions extends ChatPropsBase {
+    append?: never;
+    suggestions?: never;
+}
+interface ChatPropsWithSuggestions extends ChatPropsBase {
+    append: (message: {
+        role: 'user';
+        content: string;
+    }) => void;
+    suggestions: string[];
+}
+type ChatProps = ChatPropsWithoutSuggestions | ChatPropsWithSuggestions;
+export declare function Chat({ messages, handleSubmit, input, handleInputChange, stop, isGenerating, append, suggestions, className, onRateResponse, }: ChatProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Chat {
+    var displayName: string;
+}
+export declare function ChatMessages({ messages, children, }: React.PropsWithChildren<{
+    messages: Message[];
+}>): import("react/jsx-runtime").JSX.Element;
+export declare const ChatContainer: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;
+interface ChatFormProps {
+    className?: string;
+    isPending: boolean;
+    handleSubmit: (event?: {
+        preventDefault?: () => void;
+    }, options?: {
+        experimental_attachments?: FileList;
+    }) => void;
+    children: (props: {
+        files: File[] | null;
+        setFiles: React.Dispatch<React.SetStateAction<File[] | null>>;
+    }) => ReactElement;
+}
+export declare const ChatForm: import("react").ForwardRefExoticComponent<ChatFormProps & import("react").RefAttributes<HTMLFormElement>>;
+export {};

package/dist/shared/components/ui/chat.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ArrowDown, ThumbsDown, ThumbsUp } from 'lucide-react';
+import { forwardRef, useCallback, useState } from 'react';
+import { Button } from '../../components/ui/button';
+import { CopyButton } from '../../components/ui/copy-button';
+import { MessageInput } from '../../components/ui/message-input';
+import { MessageList } from '../../components/ui/message-list';
+import { PromptSuggestions } from '../../components/ui/prompt-suggestions';
+import { useAutoScroll } from '../../hooks/use-auto-scroll';
+import { cn } from '../../lib/utils';
+export function Chat({ messages, handleSubmit, input, handleInputChange, stop, isGenerating, append, suggestions, className, onRateResponse, }) {
+    const lastMessage = messages.at(-1);
+    const isEmpty = messages.length === 0;
+    const isTyping = lastMessage?.role === 'user';
+    const messageOptions = useCallback((message) => ({
+        actions: onRateResponse ? (_jsxs(_Fragment, { children: [_jsx("div", { className: "border-r pr-1", children: _jsx(CopyButton, { content: message.content, copyMessage: "Copied response to clipboard!" }) }), _jsx(Button, { size: "icon", variant: "ghost", className: "h-6 w-6", onClick: () => onRateResponse(message.id, 'thumbs-up'), children: _jsx(ThumbsUp, { className: "h-4 w-4" }) }), _jsx(Button, { size: "icon", variant: "ghost", className: "h-6 w-6", onClick: () => onRateResponse(message.id, 'thumbs-down'), children: _jsx(ThumbsDown, { className: "h-4 w-4" }) })] })) : (_jsx(CopyButton, { content: message.content, copyMessage: "Copied response to clipboard!" })),
+    }), [onRateResponse]);
+    return (_jsxs(ChatContainer, { className: className, children: [isEmpty && append && suggestions ? (_jsx(PromptSuggestions, { label: "Try these prompts \u2728", append: append, suggestions: suggestions })) : null, messages.length > 0 ? (_jsx(ChatMessages, { messages: messages, children: _jsx(MessageList, { messages: messages, isTyping: isTyping, messageOptions: messageOptions }) })) : null, _jsx(ChatForm, { className: "mt-auto", isPending: isGenerating || isTyping, handleSubmit: handleSubmit, children: ({ files, setFiles }) => (_jsx(MessageInput, { value: input, onChange: handleInputChange, allowAttachments: true, files: files, setFiles: setFiles, stop: stop, isGenerating: isGenerating })) })] }));
+}
+Chat.displayName = 'Chat';
+export function ChatMessages({ messages, children, }) {
+    const { containerRef, scrollToBottom, handleScroll, shouldAutoScroll, handleTouchStart } = useAutoScroll([messages]);
+    return (_jsxs("div", { className: "grid overflow-y-auto pb-4 grid-cols-1", ref: containerRef, onScroll: handleScroll, onTouchStart: handleTouchStart, children: [_jsx("div", { className: "[grid-column:1/1] [grid-row:1/1] max-w-full", children: children }), _jsx("div", { className: "flex justify-end items-end [grid-column:1/1] [grid-row:1/1] flex-1", children: !shouldAutoScroll && (_jsx("div", { className: "sticky bottom-0 left-0 flex w-full justify-end", children: _jsx(Button, { onClick: scrollToBottom, className: "h-8 w-8 rounded-full ease-in-out animate-in fade-in-0 slide-in-from-bottom-1", size: "icon", variant: "ghost", children: _jsx(ArrowDown, { className: "h-4 w-4" }) }) })) })] }));
+}
+export const ChatContainer = forwardRef(({ className, ...props }, ref) => {
+    return _jsx("div", { ref: ref, className: cn('grid max-h-full w-full grid-rows-[1fr_auto]', className), ...props });
+});
+ChatContainer.displayName = 'ChatContainer';
+export const ChatForm = forwardRef(({ children, handleSubmit, isPending, className }, ref) => {
+    const [files, setFiles] = useState(null);
+    const onSubmit = (event) => {
+        if (isPending) {
+            event.preventDefault();
+            return;
+        }
+        if (!files) {
+            handleSubmit(event);
+            return;
+        }
+        const fileList = createFileList(files);
+        handleSubmit(event, { experimental_attachments: fileList });
+        setFiles(null);
+    };
+    return (_jsx("form", { ref: ref, onSubmit: onSubmit, className: className, children: children({ files, setFiles }) }));
+});
+ChatForm.displayName = 'ChatForm';
+function createFileList(files) {
+    const dataTransfer = new DataTransfer();
+    for (const file of Array.from(files)) {
+        dataTransfer.items.add(file);
+    }
+    return dataTransfer.files;
+}

package/dist/shared/components/ui/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as React from 'react';
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };

package/dist/shared/components/ui/checkbox.js

@@ -0,0 +1,8 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as React from 'react';
+import { cn } from '../../lib/utils';
+const Checkbox = React.forwardRef(({ className, ...props }, ref) => (_jsx(CheckboxPrimitive.Root, { ref: ref, className: cn('ring-offset-background peer h-4 w-4 shrink-0 rounded-sm border border-mastra-border-4', 'data-[state=checked]:text-white data-[state=checked]:bg-mastra-bg-7', 'focus-visible:ring-offset-2 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring', 'disabled:cursor-not-allowed disabled:opacity-50', className), ...props, children: _jsx(CheckboxPrimitive.Indicator, { className: cn('flex items-center justify-center text-current'), children: _jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "h-4 w-4", children: _jsx("polyline", { points: "20 6 9 17 4 12" }) }) }) })));
+Checkbox.displayName = CheckboxPrimitive.Root.displayName;
+export { Checkbox };

package/dist/shared/components/ui/code-block.d.ts

@@ -0,0 +1,6 @@
+declare function CodeBlockDemo({ code, language, filename, }: {
+    code?: string;
+    language: 'ts' | 'json';
+    filename?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export { CodeBlockDemo };

package/dist/shared/components/ui/code-block.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { themes } from 'prism-react-renderer';
+import { CodeBlock } from 'react-code-block';
+import { cn } from '../../lib/utils';
+function CodeBlockDemo({ code = '', language = 'ts', filename, }) {
+    return (_jsxs(CodeBlock, { code: code, language: language, theme: themes.oneDark, children: [filename ? (_jsx("div", { className: "absolute  rounded bg-mastra-bg-2 w-full text-sm text-mastra-el-6/50 px-6 pl-4 py-2", children: filename })) : null, _jsx(CodeBlock.Code, { className: cn('bg-transparent h-full p-6 rounded-xl', filename ? 'pt-10' : ''), children: _jsx("div", { className: "table-row", children: _jsxs("div", { className: "flex items-center", children: [_jsx(CodeBlock.LineNumber, { className: "table-cell pr-4 text-sm text-gray-500/50 text-right select-none" }), _jsx(CodeBlock.LineContent, { className: "flex", children: _jsx(CodeBlock.Token, { className: "mastra-token text-sm font-mono" }) })] }) }) })] }));
+}
+export { CodeBlockDemo };

package/dist/shared/components/ui/collapsible.d.ts

@@ -0,0 +1,5 @@
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+declare const Collapsible: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & import("react").RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/shared/components/ui/collapsible.js

@@ -0,0 +1,6 @@
+'use client';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+const Collapsible = CollapsiblePrimitive.Root;
+const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger;
+const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };