@aws-amplify/ui-react-ai 1.3.0 → 1.4.1

package/dist/index.js

@@ -102,14 +102,63 @@ function convertBufferToBase64(buffer, format) {
     const base64string = arrayBufferToBase64(buffer);
     return `data:image/${format};base64,${base64string}`;
 }
-function getImageTypeFromMimeType(mimeType) {
-    return mimeType.split('/')[1];
+// This function will return the file extension or mime type
+function getAttachmentFormat(file) {
+    const fileNameParts = file.name.split('.');
+    // try to get format from extension first
+    // this is because some document mime file types are very complex
+    // and don't easily map to what Bedrock needs like "doc" or "docx"
+    if (fileNameParts.length > 1) {
+        return fileNameParts[fileNameParts.length - 1];
+    }
+    // return mime type if no extension exists
+    return file.type.split('/')[1];
+}
+// This will take a File and return a string to be used as the document name
+// in Bedrock. Bedrock has specific requirements around a valid name:
+// https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html
+function getValidDocumentName(file) {
+    const fileNameParts = file.name.split('.');
+    const baseFileName = fileNameParts.length > 1 ? fileNameParts.slice(0, -1).join('') : file.name;
+    // This is a regex to target special characters that are not allowed in file names
+    const specialCharactersRegex = /[!@#$%^&*()+\-=[\]{};':"\\|,.<>/?]/g;
+    return baseFileName.replace(specialCharactersRegex, '').replace(/\s+/g, '_');
+}
+// Using Sets instead of Arrays for faster and easier lookups
+const documentFileTypes = new Set([
+    'docx',
+    'csv',
+    'html',
+    'txt',
+    'pdf',
+    'md',
+    'doc',
+    'xlsx',
+    'xls',
+]);
+const imageFileTypes = new Set(['png', 'jpeg', 'gif', 'webp']);
+const validFileTypes = new Set([
+    ...documentFileTypes,
+    ...imageFileTypes,
+]);
+function isDocumentFormat(format) {
+    return documentFileTypes.has(format);
+}
+function isImageFormat(format) {
+    return imageFileTypes.has(format);
 }
 async function attachmentsValidator({ files, maxAttachments, maxAttachmentSize, }) {
     const acceptedFiles = [];
     const rejectedFiles = [];
-    let hasMaxSizeError = false;
+    let hasMaxAttachmentSizeError = false;
+    let hasUnsupportedFileError = false;
     for (const file of files) {
+        const format = getAttachmentFormat(file);
+        if (!validFileTypes.has(format)) {
+            rejectedFiles.push(file);
+            hasUnsupportedFileError = true;
+            continue;
+        }
         const arrayBuffer = await file.arrayBuffer();
         const base64 = arrayBufferToBase64(arrayBuffer);
         if (base64.length < maxAttachmentSize) {
@@ -117,22 +166,24 @@ async function attachmentsValidator({ files, maxAttachments, maxAttachmentSize,
         }
         else {
             rejectedFiles.push(file);
-            hasMaxSizeError = true;
+            hasMaxAttachmentSizeError = true;
         }
     }
     if (acceptedFiles.length > maxAttachments) {
         return {
             acceptedFiles: acceptedFiles.slice(0, maxAttachments),
             rejectedFiles: [...acceptedFiles.slice(maxAttachments), ...rejectedFiles],
+            hasMaxAttachmentSizeError,
+            hasUnsupportedFileError,
             hasMaxAttachmentsError: true,
-            hasMaxAttachmentSizeError: hasMaxSizeError,
         };
     }
     return {
         acceptedFiles,
         rejectedFiles,
+        hasMaxAttachmentSizeError,
+        hasUnsupportedFileError,
         hasMaxAttachmentsError: false,
-        hasMaxAttachmentSizeError: hasMaxSizeError,
     };
 }
 
@@ -144,6 +195,9 @@ const defaultAIConversationDisplayTextEn = {
     getAttachmentSizeErrorText(sizeText) {
         return `File size must be below ${sizeText}.`;
     },
+    getAttachmentFormatErrorText(formats) {
+        return `Files must be one of the supported types: ${formats.join(', ')}.`;
+    },
 };
 
 const { ConversationDisplayTextContext, ConversationDisplayTextProvider, useConversationDisplayText, } = uiReactCore.createContextUtilities({
@@ -288,15 +342,15 @@ const ListItemElement = elements.defineBaseElementWithRef({
     type: 'li',
     displayName: 'ListItem',
 });
-const HeadingElement = elements.defineBaseElementWithRef({
+elements.defineBaseElementWithRef({
     type: 'h2',
     displayName: 'Title',
 });
-const ImageElement = elements.defineBaseElementWithRef({
+elements.defineBaseElementWithRef({
     type: 'img',
     displayName: 'Image',
 });
-const InputElement = elements.defineBaseElementWithRef({
+elements.defineBaseElementWithRef({
     type: 'input',
     displayName: 'Input',
 });
@@ -315,10 +369,7 @@ const TextAreaElement = elements.defineBaseElementWithRef({
 });
 const AIConversationElements = {
     Button: ButtonElement,
-    Heading: HeadingElement,
     Icon: IconElement,
-    Input: InputElement,
-    Image: ImageElement,
     Label: LabelElement$1,
     ListItem: ListItemElement,
     Span: SpanElement,
@@ -605,6 +656,8 @@ const TextInput = React__namespace["default"].forwardRef(function TextInput(prop
 const InputContainer = elements.withBaseElementProps(View$2, {
     className: `${FIELD_BLOCK}__input-container`,
 });
+const isConversationInputWithText = (input) => !!input?.text;
+const isConversationInputWithFiles = (input) => !!input?.files?.length;
 const FormControl = () => {
     const { input, setInput, error, setError } = React__namespace["default"].useContext(ConversationInputContext);
     const handleSendMessage = React__namespace["default"].useContext(SendMessageContext);
@@ -616,25 +669,46 @@ const FormControl = () => {
     const ref = React__namespace["default"].useRef(null);
     const controls = React__namespace["default"].useContext(ControlsContext);
     const [composing, setComposing] = React__namespace["default"].useState(false);
+    const [isSubmitting, setIsSubmitting] = React__namespace["default"].useState(false);
+    const isInputText = isConversationInputWithText(input);
+    // an empty array will resolve false when evaluating the length
+    const isInputFiles = isConversationInputWithFiles(input);
     const submitMessage = async () => {
-        ref.current?.reset();
+        const hasInput = isInputFiles || isInputText;
+        // Prevent double submission and empty submission
+        if (isSubmitting || !hasInput) {
+            return;
+        }
+        setIsSubmitting(true);
         const submittedContent = [];
-        if (input?.text) {
+        if (isInputText) {
             const textContent = {
                 text: input.text,
             };
             submittedContent.push(textContent);
         }
-        if (input?.files) {
+        if (isInputFiles) {
             for (const file of input.files) {
                 const buffer = await file.arrayBuffer();
-                const fileContent = {
-                    image: {
-                        format: getImageTypeFromMimeType(file.type),
-                        source: { bytes: new Uint8Array(buffer) },
-                    },
-                };
-                submittedContent.push(fileContent);
+                const format = getAttachmentFormat(file);
+                const source = { bytes: new Uint8Array(buffer) };
+                if (isDocumentFormat(format)) {
+                    submittedContent.push({
+                        document: {
+                            name: getValidDocumentName(file),
+                            format,
+                            source,
+                        },
+                    });
+                }
+                else if (isImageFormat(format)) {
+                    submittedContent.push({
+                        image: {
+                            format,
+                            source,
+                        },
+                    });
+                }
             }
         }
         if (handleSendMessage) {
@@ -644,6 +718,12 @@ const FormControl = () => {
                 toolConfiguration: convertResponseComponentsToToolConfiguration(responseComponents),
             });
         }
+        // Clear the attachment errors when submitting
+        // because the errors are not actually preventing the submission
+        // but rather notifying the user that certain files were not attached and why they weren't
+        setError?.(undefined);
+        setIsSubmitting(false);
+        ref.current?.reset();
         if (setInput)
             setInput({ text: '', files: [] });
     };
@@ -655,24 +735,26 @@ const FormControl = () => {
         const { key, shiftKey } = event;
         if (key === 'Enter' && !shiftKey && !composing) {
             event.preventDefault();
-            const hasInput = !!input?.text || (input?.files?.length && input?.files?.length > 0);
-            if (hasInput) {
-                submitMessage();
-            }
+            submitMessage();
         }
     };
     const onValidate = React__namespace["default"].useCallback(async (files) => {
         const previousFiles = input?.files ?? [];
-        const { acceptedFiles, hasMaxAttachmentsError, hasMaxAttachmentSizeError, } = await attachmentsValidator({
+        const { acceptedFiles, hasMaxAttachmentsError, hasMaxAttachmentSizeError, hasUnsupportedFileError, } = await attachmentsValidator({
             files: [...files, ...previousFiles],
             maxAttachments,
             maxAttachmentSize,
         });
-        if (hasMaxAttachmentsError || hasMaxAttachmentSizeError) {
+        if (hasMaxAttachmentsError ||
+            hasMaxAttachmentSizeError ||
+            hasUnsupportedFileError) {
             const errors = [];
             if (hasMaxAttachmentsError) {
                 errors.push(displayText.getMaxAttachmentErrorText(maxAttachments));
             }
+            if (hasUnsupportedFileError) {
+                errors.push(displayText.getAttachmentFormatErrorText([...validFileTypes]));
+            }
             if (hasMaxAttachmentSizeError) {
                 errors.push(displayText.getAttachmentSizeErrorText(
                 // base64 size is about 137% that of the file size
@@ -690,7 +772,7 @@ const FormControl = () => {
         }));
     }, [setInput, input, displayText, maxAttachmentSize, maxAttachments, setError]);
     if (controls?.Form) {
-        return (React__namespace["default"].createElement(controls.Form, { handleSubmit: handleSubmit, input: input, setInput: setInput, onValidate: onValidate, allowAttachments: allowAttachments, isLoading: isLoading, error: error, setError: setError }));
+        return (React__namespace["default"].createElement(controls.Form, { handleSubmit: handleSubmit, input: input, setInput: setInput, onValidate: onValidate, allowAttachments: allowAttachments, isLoading: isLoading ?? isSubmitting, error: error, setError: setError }));
     }
     return (React__namespace["default"].createElement("form", { className: `${FIELD_BLOCK}__form`, onSubmit: handleSubmit, method: "post", ref: ref },
         allowAttachments ? React__namespace["default"].createElement(AttachFileControl, null) : null,
@@ -741,6 +823,17 @@ const ToolContent = ({ toolUse, }) => {
         }
     }
 };
+const DocumentContent = ({ format, name, source, }) => {
+    const icons = internal.useIcons('aiConversation');
+    const fileIcon = icons?.document ?? React__namespace["default"].createElement(internal.IconDocument, null);
+    return (React__namespace["default"].createElement(View$1, { className: ui.ComponentClassName.AIConversationAttachment },
+        fileIcon,
+        React__namespace["default"].createElement(View$1, { className: ui.ComponentClassName.AIConversationAttachmentName },
+            name,
+            ".",
+            format),
+        React__namespace["default"].createElement(View$1, { className: ui.ComponentClassName.AIConversationAttachmentSize }, ui.humanFileSize(source.bytes.length, true))));
+};
 const MessageControl = ({ message }) => {
     const messageRenderer = React__namespace["default"].useContext(MessageRendererContext);
     return (React__namespace["default"].createElement(React__namespace["default"].Fragment, null, message.content.map((content, index) => {
@@ -750,6 +843,9 @@ const MessageControl = ({ message }) => {
         else if (content.image) {
             return messageRenderer?.image ? (React__namespace["default"].createElement(React__namespace["default"].Fragment, { key: index }, messageRenderer?.image({ image: content.image }))) : (React__namespace["default"].createElement(MediaContent, { "data-testid": 'image-content', key: index, alt: "", src: convertBufferToBase64(content.image?.source.bytes, content.image?.format) }));
         }
+        else if (content.document) {
+            return React__namespace["default"].createElement(DocumentContent, { key: index, ...content.document });
+        }
         else if (content.toolUse) {
             return React__namespace["default"].createElement(ToolContent, { toolUse: content.toolUse, key: index });
         }
@@ -988,6 +1084,7 @@ const MessageList = ({ messages, }) => {
     const isLoading = React__namespace.useContext(LoadingContext);
     const messagesWithRenderableContent = messages?.filter((message) => message.content.some((content) => content.image ??
         content.text ??
+        content.document ??
         content.toolUse?.name.startsWith(RESPONSE_COMPONENT_PREFIX))) ?? [];
     return (React__namespace.createElement(uiReact.View, { className: ui.ComponentClassName.AIConversationMessageList },
         isLoading ? (React__namespace.createElement(React__namespace.Fragment, null,
@@ -999,8 +1096,11 @@ const MessageList = ({ messages, }) => {
 const Attachment = ({ file, handleRemove, }) => {
     const icons = internal.useIcons('aiConversation');
     const removeIcon = icons?.remove ?? React__namespace.createElement(internal.IconClose, null);
+    const fileIcon = icons?.document ?? React__namespace.createElement(internal.IconDocument, null);
+    const format = getAttachmentFormat(file);
+    const isDocument = documentFileTypes.has(format);
     return (React__namespace.createElement(uiReact.View, { className: ui.ComponentClassName.AIConversationAttachment },
-        React__namespace.createElement(uiReact.Image, { className: ui.ComponentClassName.AIConversationAttachmentImage, src: URL.createObjectURL(file), alt: file.name }),
+        isDocument ? (fileIcon) : (React__namespace.createElement(uiReact.Image, { className: ui.ComponentClassName.AIConversationAttachmentImage, src: URL.createObjectURL(file), alt: file.name })),
         React__namespace.createElement(uiReact.Text, { as: "span", className: ui.ComponentClassName.AIConversationAttachmentName }, file.name),
         React__namespace.createElement(uiReact.Text, { as: "span", className: ui.ComponentClassName.AIConversationAttachmentSize }, ui.humanFileSize(file.size, true)),
         React__namespace.createElement(uiReact.Button, { size: "small", variation: "link", colorTheme: "error", className: ui.ComponentClassName.AIConversationAttachmentRemove, onClick: handleRemove }, removeIcon)));
@@ -1041,8 +1141,9 @@ const Form = ({ setInput, input, handleSubmit, allowAttachments, onValidate, isL
     const sendIcon = icons?.send ?? React__namespace.createElement(internal.IconSend, null);
     const attachIcon = icons?.attach ?? React__namespace.createElement(internal.IconAttach, null);
     const hiddenInput = React__namespace.useRef(null);
+    // Bedrock does not accept message that are empty or are only whitespace
+    const isInputEmpty = !input?.text?.length || !!input.text.match(/^\s+$/);
     const [composing, setComposing] = React__namespace.useState(false);
-    const isInputEmpty = !input?.text?.length && !input?.files?.length;
     return (React__namespace.createElement(FormWrapper, { onValidate: onValidate, allowAttachments: allowAttachments },
         React__namespace.createElement(uiReact.View, { as: "form", className: ui.ComponentClassName.AIConversationForm, onSubmit: handleSubmit },
             allowAttachments ? (React__namespace.createElement(uiReact.Button, { className: ui.ComponentClassName.AIConversationFormAttach, onClick: () => {
@@ -1058,7 +1159,7 @@ const Form = ({ setInput, input, handleSubmit, allowAttachments, onValidate, isL
                                 return;
                             }
                             onValidate(Array.from(e.target.files));
-                        }, multiple: true, accept: ".jpeg,.png,.webp,.gif", "data-testid": "hidden-file-input" })))) : null,
+                        }, multiple: true, accept: [...validFileTypes].map((type) => `.${type}`).join(','), "data-testid": "hidden-file-input" })))) : null,
             React__namespace.createElement(uiReact.TextAreaField, { className: ui.ComponentClassName.AIConversationFormField, label: "input", labelHidden: true, autoResize: true, flex: "1", rows: 1, value: input?.text ?? '', testId: "text-input", onCompositionStart: () => setComposing(true), onCompositionEnd: () => setComposing(false), onKeyDown: (e) => {
                     // Submit on enter key if shift is not pressed also
                     const shouldSubmit = !e.shiftKey && e.key === 'Enter' && !composing;
@@ -1072,10 +1173,7 @@ const Form = ({ setInput, input, handleSubmit, allowAttachments, onValidate, isL
                         text: e.target.value,
                     }));
                 } }),
-            React__namespace.createElement(uiReact.Button, { type: "submit", variation: "primary", className: ui.ComponentClassName.AIConversationFormSend, 
-                // we intentionally || in the case where isLoading is false we should use the value of isInputEmpty
-                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-                isDisabled: isLoading || isInputEmpty },
+            React__namespace.createElement(uiReact.Button, { type: "submit", variation: "primary", className: ui.ComponentClassName.AIConversationFormSend, isDisabled: isLoading ?? isInputEmpty },
                 React__namespace.createElement("span", null, sendIcon))),
         error ? (React__namespace.createElement(uiReact.Message, { className: ui.ComponentClassName.AIConversationFormError, variation: "plain", colorTheme: "warning" }, error)) : null,
         React__namespace.createElement(Attachments, { setInput: setInput, files: input?.files })));
@@ -1092,7 +1190,7 @@ const PromptList = ({ setInput, suggestedPrompts = [], }) => {
     })));
 };
 
-const VERSION = '1.3.0';
+const VERSION = '1.4.1';
 
 function AIConversationBase({ avatars, controls, ...rest }) {
     uiReactCore.useSetUserAgent({
@@ -1153,26 +1251,19 @@ const ERROR_STATE = { hasError: true, isLoading: false };
 
 function createUseAIGeneration(client) {
     const useAIGeneration = (routeName) => {
-        const [dataState, setDataState] = React__namespace.useState(() => ({
-            ...INITIAL_STATE,
-            data: undefined,
-        }));
+        const [clientState, setClientState] = React__namespace.useState(() => ({ ...INITIAL_STATE, data: undefined }));
         const handleGeneration = React__namespace.useCallback(async (input) => {
-            setDataState(({ data }) => ({ ...LOADING_STATE, data }));
+            setClientState(({ data }) => ({ ...LOADING_STATE, data }));
             const result = await client.generations[routeName](input);
             const { data, errors } = result;
             if (errors) {
-                setDataState({
-                    ...ERROR_STATE,
-                    data,
-                    messages: errors,
-                });
+                setClientState({ ...ERROR_STATE, data, messages: errors });
             }
             else {
-                setDataState({ ...INITIAL_STATE, data });
+                setClientState({ ...INITIAL_STATE, data });
             }
         }, [routeName]);
-        return [dataState, handleGeneration];
+        return [clientState, handleGeneration];
     };
     return useAIGeneration;
 }
@@ -1239,11 +1330,11 @@ function createUseAIConversation(client) {
         // it will create a new conversation when it is executed
         // we don't want to create 2 conversations
         const initRef = React__namespace["default"].useRef('initial');
-        const [dataState, setDataState] = React__namespace["default"].useState(() => ({
+        const [clientState, setClientState] = React__namespace["default"].useState(() => ({
             ...INITIAL_STATE,
             data: { messages: [], conversation: undefined },
         }));
-        const { conversation } = dataState.data;
+        const { conversation } = clientState.data;
         const { id, onInitialize, onMessage } = input;
         React__namespace["default"].useEffect(() => {
             async function initialize() {
@@ -1255,7 +1346,7 @@ function createUseAIConversation(client) {
                 // Only show component loading state if we are
                 // actually loading messages
                 if (id) {
-                    setDataState({
+                    setClientState({
                         ...LOADING_STATE,
                         data: { messages: [], conversation: undefined },
                     });
@@ -1264,7 +1355,7 @@ function createUseAIConversation(client) {
                     ? await clientRoute.get({ id })
                     : await clientRoute.create();
                 if (errors ?? !conversation) {
-                    setDataState({
+                    setClientState({
                         ...ERROR_STATE,
                         data: { messages: [] },
                         messages: errors,
@@ -1275,13 +1366,13 @@ function createUseAIConversation(client) {
                         const { data: messages } = await exhaustivelyListMessages({
                             conversation,
                         });
-                        setDataState({
+                        setClientState({
                             ...INITIAL_STATE,
                             data: { messages, conversation },
                         });
                     }
                     else {
-                        setDataState({
+                        setClientState({
                             ...INITIAL_STATE,
                             data: { conversation, messages: [] },
                         });
@@ -1294,16 +1385,17 @@ function createUseAIConversation(client) {
             // between the gen2 schema definition and
             // whats in amplify_outputs
             if (!clientRoute) {
-                setDataState({
+                const error = {
+                    message: 'Conversation route does not exist',
+                    errorInfo: null,
+                    errorType: '',
+                };
+                setClientState({
                     ...ERROR_STATE,
                     data: { messages: [] },
-                    messages: [
-                        {
-                            message: 'Conversation route does not exist',
-                            errorInfo: null,
-                            errorType: '',
-                        },
-                    ],
+                    // TODO in MV bump: remove `messages`
+                    messages: [error],
+                    errors: [error],
                 });
                 return;
             }
@@ -1312,12 +1404,12 @@ function createUseAIConversation(client) {
                 contentBlocksRef.current = undefined;
                 if (hasStarted(initRef.current))
                     return;
-                setDataState({
+                setClientState({
                     ...INITIAL_STATE,
                     data: { messages: [], conversation: undefined },
                 });
             };
-        }, [clientRoute, id, setDataState]);
+        }, [clientRoute, id, setClientState]);
         // Run a separate effect that is triggered by the conversation state
         // so that we know we have a conversation object to set up the subscription
         // and also unsubscribe on cleanup
@@ -1345,7 +1437,7 @@ function createUseAIConversation(client) {
                     // stop reason will signify end of conversation turn
                     if (stopReason) {
                         // remove loading state from streamed message
-                        setDataState((prev) => {
+                        setClientState((prev) => {
                             return {
                                 ...prev,
                                 data: {
@@ -1392,7 +1484,7 @@ function createUseAIConversation(client) {
                             ];
                         }
                     }
-                    setDataState((prev) => {
+                    setClientState((prev) => {
                         const message = {
                             id,
                             conversationId,
@@ -1413,11 +1505,13 @@ function createUseAIConversation(client) {
                     });
                 },
                 error: (error) => {
-                    setDataState((prev) => {
+                    setClientState((prev) => {
                         return {
                             ...prev,
                             ...ERROR_STATE,
+                            // TODO in MV bump: remove `messages`
                             messages: error.errors,
+                            errors: error.errors,
                         };
                     });
                 },
@@ -1429,11 +1523,11 @@ function createUseAIConversation(client) {
                 contentBlocksRef.current = undefined;
                 subscription.unsubscribe();
             };
-        }, [conversation, onInitialize, onMessage, setDataState]);
+        }, [conversation, onInitialize, onMessage, setClientState]);
         const handleSendMessage = React__namespace["default"].useCallback((input) => {
             const { content } = input;
             if (conversation) {
-                setDataState((prevState) => ({
+                setClientState((prevState) => ({
                     ...prevState,
                     data: {
                         ...prevState.data,
@@ -1461,20 +1555,21 @@ function createUseAIConversation(client) {
                 conversation.sendMessage(input);
             }
             else {
-                setDataState((prev) => ({
+                const error = {
+                    message: 'No conversation found',
+                    errorInfo: null,
+                    errorType: '',
+                };
+                setClientState((prev) => ({
                     ...prev,
                     ...ERROR_STATE,
-                    messages: [
-                        {
-                            message: 'No conversation found',
-                            errorInfo: null,
-                            errorType: '',
-                        },
-                    ],
+                    // TODO in MV bump: remove `messages`
+                    messages: [error],
+                    errors: [error],
                 }));
             }
         }, [conversation]);
-        return [dataState, handleSendMessage];
+        return [clientState, handleSendMessage];
     };
     return useAIConversation;
 }

package/dist/types/components/AIConversation/displayText.d.ts

@@ -3,6 +3,7 @@ export type ConversationDisplayText = {
     getMessageTimestampText?: (date: Date) => string;
     getMaxAttachmentErrorText?: (count: number) => string;
     getAttachmentSizeErrorText?: (sizeText: string) => string;
+    getAttachmentFormatErrorText?: (formats: string[]) => string;
 };
 export declare const defaultAIConversationDisplayTextEn: Required<AIConversationDisplayText>;
 export type AIConversationDisplayText = DisplayTextTemplate<ConversationDisplayText>;

package/dist/types/components/AIConversation/utils.d.ts

@@ -1,7 +1,13 @@
-import { ImageContentBlock } from '../../types';
+import { ImageContentBlock, DocumentContentBlock } from '../../types';
 export declare function formatDate(date: Date): string;
 export declare function convertBufferToBase64(buffer: ArrayBuffer, format: ImageContentBlock['format']): string;
-export declare function getImageTypeFromMimeType(mimeType: string): 'png' | 'jpeg' | 'gif' | 'webp';
+export declare function getAttachmentFormat(file: File): string;
+export declare function getValidDocumentName(file: File): string;
+export declare const documentFileTypes: Set<string>;
+export declare const imageFileTypes: Set<string>;
+export declare const validFileTypes: Set<string>;
+export declare function isDocumentFormat(format: string): format is DocumentContentBlock['format'];
+export declare function isImageFormat(format: string): format is ImageContentBlock['format'];
 export declare function attachmentsValidator({ files, maxAttachments, maxAttachmentSize, }: {
     files: File[];
     maxAttachments: number;
@@ -11,4 +17,5 @@ export declare function attachmentsValidator({ files, maxAttachments, maxAttachm
     rejectedFiles: File[];
     hasMaxAttachmentSizeError: boolean;
     hasMaxAttachmentsError: boolean;
+    hasUnsupportedFileError: boolean;
 }>;

package/dist/types/components/AIConversation/views/Controls/MessagesControl.d.ts

@@ -3,6 +3,7 @@ import { AIConversationElements } from '../../context/elements';
 import { ActionsBarControl } from './ActionsBarControl';
 import { AvatarControl } from './AvatarControl';
 import { ConversationMessage } from '../../../../types';
+export declare const DocumentContent: ({ format, name, source, }: NonNullable<ConversationMessage['content'][number]['document']>) => React.JSX.Element;
 export declare const MessageControl: MessageControl;
 interface MessageControl {
     (props: {

package/dist/types/hooks/shared.d.ts

@@ -1,12 +1,22 @@
-import { DataState } from '@aws-amplify/ui-react-core';
 import { GraphQLFormattedError } from '../types';
-export type DataClientState<T> = Omit<DataState<T>, 'message'> & {
+export interface AiClientState<T> {
+    data: T;
+    hasError: boolean;
+    isLoading: boolean;
+    /**
+     * @deprecated will be removed in a future major version. Superseded by `errors`
+     * @description errors returned from the websocket connection
+     */
     messages?: GraphQLFormattedError[];
-};
-export type DataClientResponse<T> = {
+    /**
+     * @description errors returned from the websocket connection
+     */
+    errors?: GraphQLFormattedError[];
+}
+export interface AiClientResponse<T> {
     data: T | null;
     errors?: GraphQLFormattedError[];
-};
+}
 export declare const INITIAL_STATE: {
     hasError: boolean;
     isLoading: boolean;

package/dist/types/hooks/useAIConversation.d.ts

@@ -1,5 +1,5 @@
 import { Conversation, ConversationMessage, ConversationRoute, SendMessage } from '../types';
-import { DataClientState } from './shared';
+import { AiClientState } from './shared';
 interface UseAIConversationInput {
     id?: string;
     onMessage?: (message: ConversationMessage) => void;
@@ -9,6 +9,6 @@ interface AIConversationState {
     messages: ConversationMessage[];
     conversation?: Conversation;
 }
-export type UseAIConversationHook<T extends string> = (routeName: T, input?: UseAIConversationInput) => [DataClientState<AIConversationState>, SendMessage];
+export type UseAIConversationHook<T extends string> = (routeName: T, input?: UseAIConversationInput) => [AiClientState<AIConversationState>, SendMessage];
 export declare function createUseAIConversation<T extends Record<'conversations', Record<string, ConversationRoute>>>(client: T): UseAIConversationHook<Extract<keyof T['conversations'], string>>;
 export {};

package/dist/types/hooks/useAIGeneration.d.ts

@@ -1,16 +1,16 @@
-import { V6Client } from '@aws-amplify/api-graphql';
+import type { ClientExtensions } from '@aws-amplify/data-schema/runtime';
 import { getSchema } from '../types';
-import { DataClientState } from './shared';
+import { AiClientState } from './shared';
 export interface UseAIGenerationHookWrapper<Key extends keyof AIGenerationClient<Schema>['generations'], Schema extends Record<any, any>> {
     useAIGeneration: <U extends Key>(routeName: U) => [
-        Awaited<DataClientState<Schema[U]['returnType']>>,
+        Awaited<AiClientState<Schema[U]['returnType']>>,
         (input: Schema[U]['args']) => void
     ];
 }
 export type UseAIGenerationHook<Key extends keyof AIGenerationClient<Schema>['generations'], Schema extends Record<any, any>> = (routeName: Key) => [
-    Awaited<DataClientState<Schema[Key]['returnType']>>,
+    Awaited<AiClientState<Schema[Key]['returnType']>>,
     (input: Schema[Key]['args']) => void
 ];
-type AIGenerationClient<T extends Record<any, any>> = Pick<V6Client<T>, 'generations'>;
+type AIGenerationClient<T extends Record<any, any>> = Pick<ClientExtensions<T>, 'generations'>;
 export declare function createUseAIGeneration<Client extends Record<'generations' | 'conversations', Record<string, any>>, Schema extends getSchema<Client>>(client: Client): UseAIGenerationHook<keyof Client['generations'], Client>;
 export {};