@designcrowd/library.brand-page 5.17.28 → 5.18.0

package/lib/src/brand-page-maker/composables/ai-chat/useAiChat.js

@@ -1,368 +0,0 @@
-import { ref, computed, watch, nextTick, } from 'vue';
-import { getInstance as getAiAssistantClient, AI_ASSISTANT_AGENT_TYPES, buildWebsiteTextElementMessage, } from '../../../clients/ai-assistant-client';
-import { getCurrentLocale } from '../../../composables/useTranslate';
-import { storeToRefs } from 'pinia';
-import { useSnapshotStore, useAiThreadStore } from '../../stores';
-import { useBrandPageMakerStore } from '../../stores';
-import { useUiPageSettingsStore } from '../../../shared/page-settings/store';
-import { useAiMetadataBuilder } from '../ai-chat/useAiMetadataBuilder';
-import { Logger } from '../../../metadata-builder/logger';
-const MAX_TOOL_CALL_ITERATIONS = 5;
-const TEXT_DISPLAY_LIMIT = 150;
-const truncateText = (text) => {
-    if (text.length <= TEXT_DISPLAY_LIMIT)
-        return text;
-    return text.substring(0, TEXT_DISPLAY_LIMIT).trimEnd() + '...';
-};
-export const createWelcomeMessage = (currentValue) => ({
-    id: `welcome-${Date.now()}`,
-    type: 'text',
-    role: 'agent',
-    text: currentValue
-        ? `What changes would you like to make to the text?<br><br><strong>Current Text:</strong> "${truncateText(currentValue)}"`
-        : 'What would you like to generate?',
-    timestamp: new Date(),
-});
-export function useAiChat(options) {
-    const aiThreadStore = useAiThreadStore();
-    const snapshotStore = useSnapshotStore();
-    const brandPageMakerStore = useBrandPageMakerStore();
-    const pageSettingsStore = useUiPageSettingsStore();
-    const aiLogger = new Logger(!brandPageMakerStore.isProduction);
-    const aiMetadataBuilder = useAiMetadataBuilder(aiLogger);
-    const hasStoredMessages = aiThreadStore.messages.length > 0;
-    if (!hasStoredMessages) {
-        aiThreadStore.addThreadItem(createWelcomeMessage(options?.currentValue || ''));
-    }
-    const { messages: threadItems } = storeToRefs(aiThreadStore);
-    const isProcessing = ref(false);
-    watch(isProcessing, (newValue) => {
-        aiThreadStore.isProcessing = newValue;
-    });
-    const currentTypingMessageId = ref(null);
-    const isStopped = ref(false);
-    const generatedText = ref(null);
-    const generatedStyle = ref(null);
-    const pendingToolCalls = ref([]);
-    // Sequential queue so the AI thread always sees message → toolCall → message → toolCall.
-    // Operations that were flagged as stopped are skipped when they reach the front of the queue.
-    let operationQueue = Promise.resolve();
-    const enqueueOperationAsync = (fn) => {
-        operationQueue = operationQueue.then(fn, fn);
-        return operationQueue;
-    };
-    const buildMessage = (userPrompt) => {
-        return buildWebsiteTextElementMessage({
-            pageId: pageSettingsStore.currentPage?.id || '',
-            contentType: options.contentType,
-            fieldName: options.fieldName,
-            contentId: options.fieldId,
-            businessName: brandPageMakerStore.businessName || undefined,
-            industry: brandPageMakerStore.industry || undefined,
-            locale: getCurrentLocale(),
-            maxChars: options.maxChars,
-            userPrompt,
-            metadata: {
-                text: options.currentValue || '',
-                style: options.textStyle,
-            },
-        });
-    };
-    const applyToolCallsAsync = async (response) => {
-        let aiMessage = response.message || '';
-        const modelToUpdate = brandPageMakerStore.brandPageData;
-        const updateResult = await aiMetadataBuilder.applyAiToolCallsAsync(modelToUpdate, response.toolCalls || [], {
-            maxCharacters: options.maxChars,
-        });
-        const toolResults = updateResult.results.map((x) => {
-            return {
-                toolId: x.toolId,
-                success: x.errors && x.errors.length > 0 ? x.errors.join(',') : 'success',
-            };
-        });
-        updateResult.parsedToolCalls.forEach((toolCall) => {
-            const message = toolCall.arguments.message;
-            if (message) {
-                aiMessage = aiMessage ? `${aiMessage} ${message}` : message;
-            }
-        });
-        await brandPageMakerStore.initialiseStoresByBrandPageModelAsync(updateResult.model);
-        // Allow Vue to process reactive updates
-        await nextTick();
-        // Re-capture snapshot so subsequent messages reflect the updated page
-        await snapshotStore.refreshSnapshotAsync();
-        return {
-            shouldContinue: toolResults.length > 0 && aiThreadStore.runId !== null,
-            toolResults,
-            aiMessage,
-        };
-    };
-    const submitToolResults = async (toolResults) => {
-        if (!aiThreadStore.threadId || !aiThreadStore.runId || !toolResults.length)
-            return null;
-        const client = getAiAssistantClient();
-        const { response } = await client.submitWebsiteToolCallOutputAsync(aiThreadStore.threadId, {
-            runId: aiThreadStore.runId,
-            toolCalls: toolResults,
-            agentType: AI_ASSISTANT_AGENT_TYPES.WEBSITE_TEXT_ELEMENT,
-            websiteSnapshot: snapshotStore.snapshotBase64 || undefined,
-        });
-        return response;
-    };
-    /**
-     * Submit cancellation results for any pending tool calls so the AI run
-     * does not remain stuck in a "requires_action" state.
-     */
-    const submitCancelledToolCallsAsync = async () => {
-        const toolCalls = pendingToolCalls.value;
-        if (toolCalls.length === 0 ||
-            !aiThreadStore.threadId ||
-            !aiThreadStore.runId) {
-            return;
-        }
-        const cancelledResults = toolCalls.map((tc) => ({
-            toolId: tc.toolId,
-            success: 'success', // Mark as success to prevent retries, even though the tool call was not completed
-        }));
-        pendingToolCalls.value = [];
-        try {
-            const client = getAiAssistantClient();
-            await client.submitWebsiteToolCallOutputAsync(aiThreadStore.threadId, {
-                runId: aiThreadStore.runId,
-                toolCalls: cancelledResults,
-                agentType: AI_ASSISTANT_AGENT_TYPES.WEBSITE_TEXT_ELEMENT,
-            });
-        }
-        catch {
-            // Best-effort cancellation – silently ignore submission failures
-        }
-    };
-    const callApiAsync = async (userPrompt) => {
-        generatedText.value = null;
-        generatedStyle.value = null;
-        const client = getAiAssistantClient();
-        let aiAssistantResponse = {};
-        if (!aiThreadStore.threadId) {
-            const { response } = await client.createWebsiteThreadAndSendMessageAsync({
-                message: buildMessage(userPrompt || ''),
-                websiteSnapshot: snapshotStore.snapshotBase64 || undefined,
-                agentType: AI_ASSISTANT_AGENT_TYPES.WEBSITE_TEXT_ELEMENT,
-            });
-            aiAssistantResponse = response;
-            aiThreadStore.threadId = response.threadId;
-            aiThreadStore.runId = response.runId || null;
-        }
-        else {
-            const { response } = await client.sendWebsiteMessageAsync(aiThreadStore.threadId, {
-                message: buildMessage(userPrompt),
-                websiteSnapshot: snapshotStore.snapshotBase64 || undefined,
-                agentType: AI_ASSISTANT_AGENT_TYPES.WEBSITE_TEXT_ELEMENT,
-            });
-            aiAssistantResponse = response;
-        }
-        aiLogger.log('callApiAsync response', {
-            aiAssistantResponse,
-        });
-        if (aiAssistantResponse.toolCalls &&
-            aiAssistantResponse.toolCalls.length > 0) {
-            pendingToolCalls.value = aiAssistantResponse.toolCalls;
-        }
-        if (isStopped.value) {
-            await submitCancelledToolCallsAsync();
-            return { text: null };
-        }
-        const handledResponse = await handleAiResponseAsync(aiAssistantResponse);
-        return {
-            text: handledResponse.aiMessage ||
-                'I was unable to generate text. Please try again.',
-            langChainUrl: aiAssistantResponse.langChainUrl,
-        };
-    };
-    const handleToolResponseAsync = async (response) => {
-        let { shouldContinue, toolResults, aiMessage } = await applyToolCallsAsync(response);
-        let iterations = 0;
-        while (shouldContinue && iterations < MAX_TOOL_CALL_ITERATIONS) {
-            if (isStopped.value) {
-                await submitCancelledToolCallsAsync();
-                return { aiMessage: '' };
-            }
-            const nextResponse = await submitToolResults(toolResults);
-            pendingToolCalls.value = []; // Cleared after successful submission
-            aiLogger.log('handleToolResponseAsync submitToolResults', {
-                toolResults,
-                nextResponse,
-            });
-            if (!nextResponse)
-                break;
-            // Track new pending tool calls from the follow-up response
-            if (nextResponse.toolCalls && nextResponse.toolCalls.length > 0) {
-                pendingToolCalls.value = nextResponse.toolCalls;
-            }
-            if (isStopped.value) {
-                await submitCancelledToolCallsAsync();
-                return { aiMessage: '' };
-            }
-            const retryResult = await applyToolCallsAsync(nextResponse);
-            shouldContinue = retryResult.shouldContinue;
-            toolResults = retryResult.toolResults;
-            aiMessage = retryResult.aiMessage || aiMessage;
-            iterations += 1;
-        }
-        pendingToolCalls.value = [];
-        return {
-            aiMessage,
-        };
-    };
-    const handleAiResponseAsync = async (response) => {
-        let aiMessageResult = response.message || '';
-        if (response.toolCalls && response.toolCalls.length > 0) {
-            const toolResult = await handleToolResponseAsync(response);
-            aiMessageResult = toolResult.aiMessage || aiMessageResult;
-            aiLogger.log('handleAiResponseAsync toolResult', {
-                toolResult,
-            });
-        }
-        return {
-            aiMessage: aiMessageResult,
-        };
-    };
-    const sendMessageAsync = async (messageOptions) => {
-        const { text, images } = messageOptions;
-        if (!text?.trim() && (!images || images.length === 0))
-            return;
-        await enqueueOperationAsync(async () => {
-            isStopped.value = false;
-            isProcessing.value = true;
-            const userMessage = images
-                ? {
-                    id: Date.now().toString(),
-                    type: 'image',
-                    role: 'user',
-                    images,
-                    text,
-                    timestamp: new Date(),
-                }
-                : {
-                    id: Date.now().toString(),
-                    type: 'text',
-                    role: 'user',
-                    text: text || '',
-                    timestamp: new Date(),
-                };
-            aiThreadStore.addThreadItem(userMessage);
-            const agentMessageId = (Date.now() + 1).toString();
-            currentTypingMessageId.value = agentMessageId;
-            const agentMessage = {
-                id: agentMessageId,
-                type: 'text',
-                role: 'agent',
-                text: '',
-                isTyping: true,
-                timestamp: new Date(),
-            };
-            aiThreadStore.addThreadItem(agentMessage);
-            try {
-                aiLogger.startGroup();
-                aiLogger.log('sendMessageAsync', {
-                    messageOptions,
-                });
-                const apiResult = await callApiAsync(text || '');
-                if (isStopped.value)
-                    return;
-                const messageIndex = threadItems.value.findIndex((msg) => msg.id === agentMessageId);
-                if (messageIndex !== -1) {
-                    if (apiResult.text) {
-                        threadItems.value[messageIndex].text = apiResult.text;
-                        threadItems.value[messageIndex].isTyping = false;
-                        threadItems.value[messageIndex].langChainUrl =
-                            apiResult.langChainUrl;
-                        if (generatedText.value && options.onTextUpdate) {
-                            options.onTextUpdate(generatedText.value);
-                        }
-                        if (generatedStyle.value && options.onStyleUpdate) {
-                            options.onStyleUpdate(generatedStyle.value);
-                        }
-                    }
-                    else {
-                        threadItems.value[messageIndex].text =
-                            'Failed to generate text. Please try again.';
-                        threadItems.value[messageIndex].isTyping = false;
-                        threadItems.value[messageIndex].isError = true;
-                    }
-                }
-            }
-            catch (error) {
-                if (isStopped.value)
-                    return;
-                const messageIndex = threadItems.value.findIndex((msg) => msg.id === agentMessageId);
-                if (messageIndex !== -1) {
-                    threadItems.value[messageIndex].text =
-                        error?.response?.data?.error ||
-                            'An error occurred. Please try again.';
-                    threadItems.value[messageIndex].isTyping = false;
-                    threadItems.value[messageIndex].isError = true;
-                }
-            }
-            finally {
-                currentTypingMessageId.value = null;
-                isProcessing.value = false;
-            }
-        });
-    };
-    const deleteMessage = (messageId) => {
-        const index = threadItems.value.findIndex((msg) => msg.id === messageId);
-        if (index !== -1) {
-            threadItems.value.splice(index, 1);
-        }
-    };
-    /**
-     * Stop generation, remove the typing message, and submit cancellation
-     * for any pending tool calls so the AI run does not throw errors.
-     */
-    const stopGenerationAsync = async () => {
-        // Set the flag immediately so any in-flight operation can check it
-        isStopped.value = true;
-        if (currentTypingMessageId.value) {
-            deleteMessage(currentTypingMessageId.value);
-            currentTypingMessageId.value = null;
-        }
-        isProcessing.value = false;
-        // Enqueue cancellation — runs once the in-flight operation bails out via isStopped checks
-        await enqueueOperationAsync(async () => {
-            await submitCancelledToolCallsAsync();
-        });
-    };
-    // Register stopGenerationAsync in the store so parent components
-    // (e.g. BrandPageMaker overlay) can call it without needing a $ref to AiTextEdit
-    aiThreadStore.stopGeneration = stopGenerationAsync;
-    const formattedMessages = computed(() => {
-        const initialMessageCount = hasStoredMessages
-            ? aiThreadStore.messages.length
-            : 1;
-        return threadItems.value.map((msg, index) => ({
-            type: msg.type,
-            props: {
-                ...(msg.type === 'text' && { text: msg.text }),
-                ...(msg.type === 'image' && { images: msg.images, text: msg.text }),
-                isUser: msg.role === 'user',
-                isAi: msg.role === 'agent',
-                showIcon: msg.role === 'agent',
-                isTyping: msg.isTyping,
-                isResponse: index >= 1,
-                disableAnimation: index < initialMessageCount,
-                langChainUrl: msg.langChainUrl,
-            },
-        }));
-    });
-    return {
-        threadItems,
-        isProcessing,
-        currentTypingMessageId,
-        generatedText,
-        generatedStyle,
-        sendMessageAsync,
-        deleteMessage,
-        stopGenerationAsync,
-        formattedMessages,
-    };
-}

package/lib/src/brand-page-maker/composables/ai-chat/useAiTextEditPrompts.d.ts

@@ -1,18 +0,0 @@
-import { type ComputedRef, type Ref } from 'vue';
-import type { AiTextEditContext } from '../../../shared/side-bar/store';
-interface UseAiTextEditPromptsOptions {
-    aiContext: ComputedRef<AiTextEditContext | undefined>;
-    ctaLocation: ComputedRef<string>;
-    isProcessing: Ref<boolean>;
-    promptText: Ref<string>;
-}
-export declare function useAiTextEditPrompts(options: UseAiTextEditPromptsOptions): {
-    suggestedPrompts: ComputedRef<{
-        id: string;
-        label: any;
-        disabled: boolean;
-        handler: () => void;
-    }[]>;
-    formattedLocation: ComputedRef<any>;
-};
-export {};

package/lib/src/brand-page-maker/composables/ai-chat/useAiTextEditPrompts.js

@@ -1,144 +0,0 @@
-import { computed } from 'vue';
-import { useBrandPageMakerStore } from '../../stores';
-import { EVENTS, GENERATE_AI_SUGGESTED_PROMPT, useEventTracker, } from '../../composables/useEventTracker';
-import { generateAiModalTr, contentSettingsTr, } from '../../../composables/useTranslate';
-import { getPlainTextFromRTE } from '../../utils/rich-text-editor.util';
-import { useUiContentSettingsStore } from '../../../shared/content-settings/store';
-export function useAiTextEditPrompts(options) {
-    const brandPageMakerStore = useBrandPageMakerStore();
-    const contentSettingsStore = useUiContentSettingsStore();
-    const eventTracker = useEventTracker();
-    // Get the actual field value from the content store
-    const currentFieldValue = computed(() => {
-        if (!options.aiContext.value)
-            return '';
-        const content = contentSettingsStore.getContent(options.aiContext.value.fieldId);
-        if (!content)
-            return options.aiContext.value.fieldValue || '';
-        const fieldName = options.aiContext.value.fieldName;
-        // Parse the field path (e.g., "textItems.2.text" or "items.0.testimonial")
-        const parts = fieldName.split('.');
-        let value = content;
-        for (const part of parts) {
-            if (value === undefined || value === null)
-                break;
-            value = value[part];
-        }
-        return typeof value === 'string'
-            ? value
-            : options.aiContext.value.fieldValue || '';
-    });
-    // Business context
-    const businessName = computed(() => brandPageMakerStore.businessName || '');
-    const industry = computed(() => brandPageMakerStore.industry || '');
-    // Formatted location for display
-    const formattedLocation = computed(() => {
-        if (!options.ctaLocation.value)
-            return '';
-        const parts = options.ctaLocation.value.split('_');
-        if (parts[0] === 'testimonial' || parts[0] === 'text') {
-            return contentSettingsTr(`${parts[0]}DisplayName`);
-        }
-        // Use translations for both content type and field name
-        const contentTypeCamelCase = parts[0]
-            .split('-')
-            .map((word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1))
-            .join('');
-        const fieldNameKey = parts.slice(1).join('_');
-        const contentType = contentSettingsTr(`${contentTypeCamelCase}SectionDisplayName`);
-        const fieldName = contentSettingsTr(`${fieldNameKey}Title`);
-        return `${contentType} ${fieldName}`;
-    });
-    // Helper function to build prompt key based on available context
-    const buildPromptKey = (baseKey) => {
-        if (businessName.value && industry.value)
-            return baseKey;
-        if (industry.value)
-            return `${baseKey}WithIndustry`;
-        if (businessName.value)
-            return `${baseKey}WithBusinessName`;
-        return `${baseKey}Simple`;
-    };
-    // Helper function to get prompt params
-    const getPromptParams = (includeFieldName = false) => {
-        const params = {};
-        if (includeFieldName) {
-            params.fieldName = formattedLocation.value;
-        }
-        if (businessName.value) {
-            params.businessName = businessName.value;
-        }
-        if (industry.value) {
-            params.industry = industry.value;
-        }
-        return params;
-    };
-    // Prompt handlers
-    const onGenerateTextClick = () => {
-        const promptKey = buildPromptKey('generateTextPrompt');
-        const prompt = generateAiModalTr(promptKey, getPromptParams(true));
-        options.promptText.value = prompt;
-        eventTracker.sendWebsiteEvent({
-            eventName: EVENTS.WEBSITE_MAKER_AI_CLICK_SUGGESTED_PROMPT,
-            eventProps: {
-                cta_location: options.ctaLocation.value,
-                prompt: GENERATE_AI_SUGGESTED_PROMPT.GENERATE_TEXT,
-            },
-        });
-    };
-    const onImproveTextClick = () => {
-        const promptKey = buildPromptKey('improveTextPrompt');
-        const prompt = generateAiModalTr(promptKey, getPromptParams(false));
-        options.promptText.value = prompt;
-        eventTracker.sendWebsiteEvent({
-            eventName: EVENTS.WEBSITE_MAKER_AI_CLICK_SUGGESTED_PROMPT,
-            eventProps: {
-                cta_location: options.ctaLocation.value,
-                prompt: GENERATE_AI_SUGGESTED_PROMPT.IMPROVE_TEXT,
-            },
-        });
-    };
-    const onSpellCheckClick = () => {
-        const prompt = generateAiModalTr('spellCheckPrompt');
-        options.promptText.value = prompt;
-        eventTracker.sendWebsiteEvent({
-            eventName: EVENTS.WEBSITE_MAKER_AI_CLICK_SUGGESTED_PROMPT,
-            eventProps: {
-                cta_location: options.ctaLocation.value,
-                prompt: GENERATE_AI_SUGGESTED_PROMPT.SPELL_CHECK,
-            },
-        });
-    };
-    // Computed suggested prompts with handlers and disabled states
-    const suggestedPrompts = computed(() => {
-        // Get plain text from the current field value (strips HTML tags)
-        const plainText = getPlainTextFromRTE(currentFieldValue.value || '');
-        const hasText = plainText.trim().length > 0;
-        return [
-            {
-                id: 'generate-text',
-                label: generateAiModalTr('generateText', {
-                    location: formattedLocation.value,
-                }),
-                disabled: options.isProcessing.value,
-                handler: onGenerateTextClick,
-            },
-            {
-                id: 'improve-text',
-                label: generateAiModalTr('improveText'),
-                disabled: !hasText || options.isProcessing.value,
-                handler: onImproveTextClick,
-            },
-            {
-                id: 'spell-check',
-                label: generateAiModalTr('spellCheck'),
-                disabled: !hasText || options.isProcessing.value,
-                handler: onSpellCheckClick,
-            },
-        ];
-    });
-    return {
-        suggestedPrompts,
-        formattedLocation,
-    };
-}

package/lib/src/brand-page-maker/stores/ai-thread/ai-thread-store.d.ts

@@ -1,155 +0,0 @@
-import type { ThreadMessage } from '../../composables/ai-chat/useAiChat';
-export declare const useAiThreadStore: import("pinia").StoreDefinition<"aiThread", Pick<{
-    threadId: import("vue").Ref<string | null, string | null>;
-    runId: import("vue").Ref<string | null, string | null>;
-    messages: import("vue").Ref<({
-        type: "text";
-        text: string;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    } | {
-        type: "image";
-        images: {
-            url: string;
-            alt?: string | undefined;
-        }[];
-        text?: string | undefined;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    })[], ThreadMessage[] | ({
-        type: "text";
-        text: string;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    } | {
-        type: "image";
-        images: {
-            url: string;
-            alt?: string | undefined;
-        }[];
-        text?: string | undefined;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    })[]>;
-    isProcessing: import("vue").Ref<boolean, boolean>;
-    stopGeneration: import("vue").Ref<(() => void) | null, (() => void) | null>;
-    addThreadItem: (item: ThreadMessage) => void;
-}, "threadId" | "runId" | "messages" | "isProcessing" | "stopGeneration">, Pick<{
-    threadId: import("vue").Ref<string | null, string | null>;
-    runId: import("vue").Ref<string | null, string | null>;
-    messages: import("vue").Ref<({
-        type: "text";
-        text: string;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    } | {
-        type: "image";
-        images: {
-            url: string;
-            alt?: string | undefined;
-        }[];
-        text?: string | undefined;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    })[], ThreadMessage[] | ({
-        type: "text";
-        text: string;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    } | {
-        type: "image";
-        images: {
-            url: string;
-            alt?: string | undefined;
-        }[];
-        text?: string | undefined;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    })[]>;
-    isProcessing: import("vue").Ref<boolean, boolean>;
-    stopGeneration: import("vue").Ref<(() => void) | null, (() => void) | null>;
-    addThreadItem: (item: ThreadMessage) => void;
-}, never>, Pick<{
-    threadId: import("vue").Ref<string | null, string | null>;
-    runId: import("vue").Ref<string | null, string | null>;
-    messages: import("vue").Ref<({
-        type: "text";
-        text: string;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    } | {
-        type: "image";
-        images: {
-            url: string;
-            alt?: string | undefined;
-        }[];
-        text?: string | undefined;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    })[], ThreadMessage[] | ({
-        type: "text";
-        text: string;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    } | {
-        type: "image";
-        images: {
-            url: string;
-            alt?: string | undefined;
-        }[];
-        text?: string | undefined;
-        id: string;
-        role: "user" | "agent";
-        isTyping?: boolean | undefined;
-        isError?: boolean | undefined;
-        timestamp: Date;
-        langChainUrl?: string | undefined;
-    })[]>;
-    isProcessing: import("vue").Ref<boolean, boolean>;
-    stopGeneration: import("vue").Ref<(() => void) | null, (() => void) | null>;
-    addThreadItem: (item: ThreadMessage) => void;
-}, "addThreadItem">>;