fix: limit auto-retry to 3 attempts and enforce quota checks

- Add MAX_AUTO_RETRY_COUNT (3) to prevent infinite retry loops - Check token and TPM limits before each auto-retry - Reset retry counter on user-initiated messages - Show toast notification when limits are reached Fixes issue where models returning invalid tool inputs caused 45+ API requests due to sendAutomaticallyWhen having no retry limit or quota check.
2026-01-03 06:42:27 +08:00 · 2025-12-11 17:50:50 +09:00
11 changed files with 342 additions and 1125 deletions
--- a/app/api/chat/route.ts
+++ b/app/api/chat/route.ts
@@ -18,7 +18,7 @@ import {
 } from "@/lib/langfuse"
 import { getSystemPrompt } from "@/lib/system-prompts"

-export const maxDuration = 120
+export const maxDuration = 300

 // File upload limits (must match client-side)
 const MAX_FILE_SIZE = 2 * 1024 * 1024 // 2MB
@@ -95,6 +95,35 @@ function replaceHistoricalToolInputs(messages: any[]): any[] {
    })
 }

+// Helper function to fix tool call inputs for Bedrock API
+// Bedrock requires toolUse.input to be a JSON object, not a string
+function fixToolCallInputs(messages: any[]): any[] {
+    return messages.map((msg) => {
+        if (msg.role !== "assistant" || !Array.isArray(msg.content)) {
+            return msg
+        }
+        const fixedContent = msg.content.map((part: any) => {
+            if (part.type === "tool-call") {
+                if (typeof part.input === "string") {
+                    try {
+                        const parsed = JSON.parse(part.input)
+                        return { ...part, input: parsed }
+                    } catch {
+                        // If parsing fails, wrap the string in an object
+                        return { ...part, input: { rawInput: part.input } }
+                    }
+                }
+                // Input is already an object, but verify it's not null/undefined
+                if (part.input === null || part.input === undefined) {
+                    return { ...part, input: {} }
+                }
+            }
+            return part
+        })
+        return { ...msg, content: fixedContent }
+    })
+}
+
 // Helper function to create cached stream response
 function createCachedStreamResponse(xml: string): Response {
    const toolCallId = `cached-${Date.now()}`
@@ -157,9 +186,9 @@ async function handleChatRequest(req: Request): Promise<Response> {
            : undefined

    // Extract user input text for Langfuse trace
-    const lastMessage = messages[messages.length - 1]
+    const currentMessage = messages[messages.length - 1]
    const userInputText =
-        lastMessage?.parts?.find((p: any) => p.type === "text")?.text || ""
+        currentMessage?.parts?.find((p: any) => p.type === "text")?.text || ""

    // Update Langfuse trace with input, session, and user
    setTraceInput({
@@ -213,6 +242,12 @@ async function handleChatRequest(req: Request): Promise<Response> {
    // Get the appropriate system prompt based on model (extended for Opus/Haiku 4.5)
    const systemMessage = getSystemPrompt(modelId)

+    const lastMessage = messages[messages.length - 1]
+
+    // Extract text from the last message parts
+    const lastMessageText =
+        lastMessage.parts?.find((part: any) => part.type === "text")?.text || ""
+
    // Extract file parts (images) from the last message
    const fileParts =
        lastMessage.parts?.filter((part: any) => part.type === "file") || []
@@ -220,19 +255,22 @@ async function handleChatRequest(req: Request): Promise<Response> {
    // User input only - XML is now in a separate cached system message
    const formattedUserInput = `User input:
 """md
-${userInputText}
+${lastMessageText}
 """`

    // Convert UIMessages to ModelMessages and add system message
    const modelMessages = convertToModelMessages(messages)

+    // Fix tool call inputs for Bedrock API (requires JSON objects, not strings)
+    const fixedMessages = fixToolCallInputs(modelMessages)
+
    // Replace historical tool call XML with placeholders to reduce tokens
    // Disabled by default - some models (e.g. minimax) copy placeholders instead of generating XML
    const enableHistoryReplace =
        process.env.ENABLE_HISTORY_XML_REPLACE === "true"
    const placeholderMessages = enableHistoryReplace
-        ? replaceHistoricalToolInputs(modelMessages)
-        : modelMessages
+        ? replaceHistoricalToolInputs(fixedMessages)
+        : fixedMessages

    // Filter out messages with empty content arrays (Bedrock API rejects these)
    // This is a safety measure - ideally convertToModelMessages should handle all cases
@@ -316,9 +354,6 @@ ${userInputText}

    const result = streamText({
        model,
-        ...(process.env.MAX_OUTPUT_TOKENS && {
-            maxOutputTokens: parseInt(process.env.MAX_OUTPUT_TOKENS, 10),
-        }),
        stopWhen: stepCountIs(5),
        messages: allMessages,
        ...(providerOptions && { providerOptions }), // This now includes all reasoning configs
@@ -330,6 +365,32 @@ ${userInputText}
                userId,
            }),
        }),
+        // Repair malformed tool calls (model sometimes generates invalid JSON with unescaped quotes)
+        experimental_repairToolCall: async ({ toolCall }) => {
+            // The toolCall.input contains the raw JSON string that failed to parse
+            const rawJson =
+                typeof toolCall.input === "string" ? toolCall.input : null
+
+            if (rawJson) {
+                try {
+                    // Fix unescaped quotes: x="520" should be x=\"520\"
+                    const fixed = rawJson.replace(
+                        /([a-zA-Z])="(\d+)"/g,
+                        '$1=\\"$2\\"',
+                    )
+                    const parsed = JSON.parse(fixed)
+                    return {
+                        type: "tool-call" as const,
+                        toolCallId: toolCall.toolCallId,
+                        toolName: toolCall.toolName,
+                        input: JSON.stringify(parsed),
+                    }
+                } catch {
+                    // Repair failed, return null
+                }
+            }
+            return null
+        },
        onFinish: ({ text, usage }) => {
            // Pass usage to Langfuse (Bedrock streaming doesn't auto-report tokens to telemetry)
            setTraceOutput(text, {
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -1,4 +1,5 @@
 import { GoogleAnalytics } from "@next/third-parties/google"
+import { Analytics } from "@vercel/analytics/react"
 import type { Metadata, Viewport } from "next"
 import { JetBrains_Mono, Plus_Jakarta_Sans } from "next/font/google"
 import { DiagramProvider } from "@/contexts/diagram-context"
@@ -116,6 +117,7 @@ export default function RootLayout({
                className={`${plusJakarta.variable} ${jetbrainsMono.variable} antialiased`}
            >
                <DiagramProvider>{children}</DiagramProvider>
+                <Analytics />
            </body>
            {process.env.NEXT_PUBLIC_GA_ID && (
                <GoogleAnalytics gaId={process.env.NEXT_PUBLIC_GA_ID} />
--- a/components/chat-message-display.tsx
+++ b/components/chat-message-display.tsx
@@ -19,17 +19,19 @@ import {
    X,
 } from "lucide-react"
 import Image from "next/image"
-import type { MutableRefObject } from "react"
 import { useCallback, useEffect, useRef, useState } from "react"
 import ReactMarkdown from "react-markdown"
-import { toast } from "sonner"
 import {
    Reasoning,
    ReasoningContent,
    ReasoningTrigger,
 } from "@/components/ai-elements/reasoning"
 import { ScrollArea } from "@/components/ui/scroll-area"
-import { convertToLegalXml, replaceNodes, validateAndFixXml } from "@/lib/utils"
+import {
+    convertToLegalXml,
+    replaceNodes,
+    validateMxCellStructure,
+} from "@/lib/utils"
 import ExamplePanel from "./chat-example-panel"
 import { CodeBlock } from "./code-block"

@@ -167,7 +169,6 @@ interface ChatMessageDisplayProps {
    messages: UIMessage[]
    setInput: (input: string) => void
    setFiles: (files: File[]) => void
-    processedToolCallsRef: MutableRefObject<Set<string>>
    sessionId?: string
    onRegenerate?: (messageIndex: number) => void
    onEditMessage?: (messageIndex: number, newText: string) => void
@@ -178,7 +179,6 @@ export function ChatMessageDisplay({
    messages,
    setInput,
    setFiles,
-    processedToolCallsRef,
    sessionId,
    onRegenerate,
    onEditMessage,
@@ -187,7 +187,7 @@ export function ChatMessageDisplay({
    const { chartXML, loadDiagram: onDisplayChart } = useDiagram()
    const messagesEndRef = useRef<HTMLDivElement>(null)
    const previousXML = useRef<string>("")
-    const processedToolCalls = processedToolCallsRef
+    const processedToolCalls = useRef<Set<string>>(new Set())
    const [expandedTools, setExpandedTools] = useState<Record<string, boolean>>(
        {},
    )
@@ -213,32 +213,9 @@ export function ChatMessageDisplay({
            setCopiedMessageId(messageId)
            setTimeout(() => setCopiedMessageId(null), 2000)
        } catch (err) {
-            // Fallback for non-secure contexts (HTTP) or permission denied
-            const textarea = document.createElement("textarea")
-            textarea.value = text
-            textarea.style.position = "fixed"
-            textarea.style.left = "-9999px"
-            textarea.style.opacity = "0"
-            document.body.appendChild(textarea)
-
-            try {
-                textarea.select()
-                const success = document.execCommand("copy")
-                if (!success) {
-                    throw new Error("Copy command failed")
-                }
-                setCopiedMessageId(messageId)
-                setTimeout(() => setCopiedMessageId(null), 2000)
-            } catch (fallbackErr) {
-                console.error("Failed to copy message:", fallbackErr)
-                toast.error(
-                    "Failed to copy message. Please copy manually or check clipboard permissions.",
-                )
-                setCopyFailedMessageId(messageId)
-                setTimeout(() => setCopyFailedMessageId(null), 2000)
-            } finally {
-                document.body.removeChild(textarea)
-            }
+            console.error("Failed to copy message:", err)
+            setCopyFailedMessageId(messageId)
+            setTimeout(() => setCopyFailedMessageId(null), 2000)
        }
    }

@@ -266,85 +243,32 @@ export function ChatMessageDisplay({
                }),
            })
        } catch (error) {
-            console.error("Failed to log feedback:", error)
-            toast.error("Failed to record your feedback. Please try again.")
-            // Revert optimistic UI update
-            setFeedback((prev) => {
-                const next = { ...prev }
-                delete next[messageId]
-                return next
-            })
+            console.warn("Failed to log feedback:", error)
        }
    }

    const handleDisplayChart = useCallback(
-        (xml: string, showToast = false) => {
+        (xml: string) => {
            const currentXml = xml || ""
            const convertedXml = convertToLegalXml(currentXml)
            if (convertedXml !== previousXML.current) {
-                // Parse and validate XML BEFORE calling replaceNodes
-                const parser = new DOMParser()
-                const testDoc = parser.parseFromString(convertedXml, "text/xml")
-                const parseError = testDoc.querySelector("parsererror")
+                // If chartXML is empty, create a default mxfile structure to use with replaceNodes
+                // This ensures the XML is properly wrapped in mxfile/diagram/mxGraphModel format
+                const baseXML =
+                    chartXML ||
+                    `<mxfile><diagram name="Page-1" id="page-1"><mxGraphModel><root><mxCell id="0"/><mxCell id="1" parent="0"/></root></mxGraphModel></diagram></mxfile>`
+                const replacedXML = replaceNodes(baseXML, convertedXml)

-                if (parseError) {
-                    console.error(
-                        "[ChatMessageDisplay] Malformed XML detected - skipping update",
+                const validationError = validateMxCellStructure(replacedXML)
+                if (!validationError) {
+                    previousXML.current = convertedXml
+                    // Skip validation in loadDiagram since we already validated above
+                    onDisplayChart(replacedXML, true)
+                } else {
+                    console.log(
+                        "[ChatMessageDisplay] XML validation failed:",
+                        validationError,
                    )
-                    // Only show toast if this is the final XML (not during streaming)
-                    if (showToast) {
-                        toast.error(
-                            "AI generated invalid diagram XML. Please try regenerating.",
-                        )
-                    }
-                    return // Skip this update
-                }
-
-                try {
-                    // If chartXML is empty, create a default mxfile structure to use with replaceNodes
-                    // This ensures the XML is properly wrapped in mxfile/diagram/mxGraphModel format
-                    const baseXML =
-                        chartXML ||
-                        `<mxfile><diagram name="Page-1" id="page-1"><mxGraphModel><root><mxCell id="0"/><mxCell id="1" parent="0"/></root></mxGraphModel></diagram></mxfile>`
-                    const replacedXML = replaceNodes(baseXML, convertedXml)
-
-                    // Validate and auto-fix the XML
-                    const validation = validateAndFixXml(replacedXML)
-                    if (validation.valid) {
-                        previousXML.current = convertedXml
-                        // Use fixed XML if available, otherwise use original
-                        const xmlToLoad = validation.fixed || replacedXML
-                        if (validation.fixes.length > 0) {
-                            console.log(
-                                "[ChatMessageDisplay] Auto-fixed XML issues:",
-                                validation.fixes,
-                            )
-                        }
-                        // Skip validation in loadDiagram since we already validated above
-                        onDisplayChart(xmlToLoad, true)
-                    } else {
-                        console.error(
-                            "[ChatMessageDisplay] XML validation failed:",
-                            validation.error,
-                        )
-                        // Only show toast if this is the final XML (not during streaming)
-                        if (showToast) {
-                            toast.error(
-                                "Diagram validation failed. Please try regenerating.",
-                            )
-                        }
-                    }
-                } catch (error) {
-                    console.error(
-                        "[ChatMessageDisplay] Error processing XML:",
-                        error,
-                    )
-                    // Only show toast if this is the final XML (not during streaming)
-                    if (showToast) {
-                        toast.error(
-                            "Failed to process diagram. Please try regenerating.",
-                        )
-                    }
                }
            }
        },
@@ -387,14 +311,12 @@ export function ChatMessageDisplay({
                                state === "input-streaming" ||
                                state === "input-available"
                            ) {
-                                // During streaming, don't show toast (XML may be incomplete)
-                                handleDisplayChart(xml, false)
+                                handleDisplayChart(xml)
                            } else if (
                                state === "output-available" &&
                                !processedToolCalls.current.has(toolCallId)
                            ) {
-                                // Show toast only if final XML is malformed
-                                handleDisplayChart(xml, true)
+                                handleDisplayChart(xml)
                                processedToolCalls.current.add(toolCallId)
                            }
                        }
--- a/components/chat-panel.tsx
+++ b/components/chat-panel.tsx
@@ -4,7 +4,6 @@ import { useChat } from "@ai-sdk/react"
 import { DefaultChatTransport } from "ai"
 import {
    AlertTriangle,
-    MessageSquarePlus,
    PanelRightClose,
    PanelRightOpen,
    Settings,
@@ -18,7 +17,6 @@ import { FaGithub } from "react-icons/fa"
 import { Toaster, toast } from "sonner"
 import { ButtonWithTooltip } from "@/components/button-with-tooltip"
 import { ChatInput } from "@/components/chat-input"
-import { ResetWarningModal } from "@/components/reset-warning-modal"
 import { SettingsDialog } from "@/components/settings-dialog"
 import { useDiagram } from "@/contexts/diagram-context"
 import { getAIConfig } from "@/lib/ai-config"
@@ -63,7 +61,7 @@ interface ChatPanelProps {
 // Constants for tool states
 const TOOL_ERROR_STATE = "output-error" as const
 const DEBUG = process.env.NODE_ENV === "development"
-const MAX_AUTO_RETRY_COUNT = 1
+const MAX_AUTO_RETRY_COUNT = 3

 /**
 * Check if auto-resubmit should happen based on tool errors.
@@ -143,7 +141,6 @@ export default function ChatPanel({
    const [dailyRequestLimit, setDailyRequestLimit] = useState(0)
    const [dailyTokenLimit, setDailyTokenLimit] = useState(0)
    const [tpmLimit, setTpmLimit] = useState(0)
-    const [showNewChatDialog, setShowNewChatDialog] = useState(false)

    // Check config on mount
    useEffect(() => {
@@ -192,9 +189,6 @@ export default function ChatPanel({
    // Ref to track consecutive auto-retry count (reset on user action)
    const autoRetryCountRef = useRef(0)

-    // Persist processed tool call IDs so collapsing the chat doesn't replay old tool outputs
-    const processedToolCallsRef = useRef<Set<string>>(new Set())
-
    const {
        messages,
        sendMessage,
@@ -728,32 +722,6 @@ Please retry with an adjusted search pattern or use display_diagram if retries a
        }
    }

-    const handleNewChat = useCallback(() => {
-        setMessages([])
-        clearDiagram()
-        handleFileChange([]) // Use handleFileChange to also clear pdfData
-        const newSessionId = `session-${Date.now()}-${Math.random()
-            .toString(36)
-            .slice(2, 9)}`
-        setSessionId(newSessionId)
-        xmlSnapshotsRef.current.clear()
-        // Clear localStorage with error handling
-        try {
-            localStorage.removeItem(STORAGE_MESSAGES_KEY)
-            localStorage.removeItem(STORAGE_XML_SNAPSHOTS_KEY)
-            localStorage.removeItem(STORAGE_DIAGRAM_XML_KEY)
-            localStorage.setItem(STORAGE_SESSION_ID_KEY, newSessionId)
-            toast.success("Started a fresh chat")
-        } catch (error) {
-            console.error("Failed to clear localStorage:", error)
-            toast.warning(
-                "Chat cleared but browser storage could not be updated",
-            )
-        }
-
-        setShowNewChatDialog(false)
-    }, [clearDiagram, handleFileChange, setMessages, setSessionId])
-
    const handleInputChange = (
        e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,
    ) => {
@@ -830,14 +798,12 @@ Please retry with an adjusted search pattern or use display_diagram if retries a
                    "x-access-code": config.accessCode,
                    ...(config.aiProvider && {
                        "x-ai-provider": config.aiProvider,
-                        ...(config.aiBaseUrl && {
-                            "x-ai-base-url": config.aiBaseUrl,
-                        }),
-                        ...(config.aiApiKey && {
-                            "x-ai-api-key": config.aiApiKey,
-                        }),
-                        ...(config.aiModel && { "x-ai-model": config.aiModel }),
                    }),
+                    ...(config.aiBaseUrl && {
+                        "x-ai-base-url": config.aiBaseUrl,
+                    }),
+                    ...(config.aiApiKey && { "x-ai-api-key": config.aiApiKey }),
+                    ...(config.aiModel && { "x-ai-model": config.aiModel }),
                },
            },
        )
@@ -1023,7 +989,6 @@ Please retry with an adjusted search pattern or use display_diagram if retries a
                    style: {
                        maxWidth: "480px",
                    },
-                    duration: 2000,
                }}
            />
            {/* Header */}
@@ -1074,18 +1039,6 @@ Please retry with an adjusted search pattern or use display_diagram if retries a
                        )}
                    </div>
                    <div className="flex items-center gap-1">
-                        <ButtonWithTooltip
-                            tooltipContent="Start fresh chat"
-                            variant="ghost"
-                            size="icon"
-                            onClick={() => setShowNewChatDialog(true)}
-                            className="hover:bg-accent"
-                        >
-                            <MessageSquarePlus
-                                className={`${isMobile ? "h-4 w-4" : "h-5 w-5"} text-muted-foreground`}
-                            />
-                        </ButtonWithTooltip>
-                        <div className="w-px h-5 bg-border mx-1" />
                        <a
                            href="https://github.com/DayuanJiang/next-ai-draw-io"
                            target="_blank"
@@ -1128,7 +1081,6 @@ Please retry with an adjusted search pattern or use display_diagram if retries a
                    messages={messages}
                    setInput={setInput}
                    setFiles={handleFileChange}
-                    processedToolCallsRef={processedToolCallsRef}
                    sessionId={sessionId}
                    onRegenerate={handleRegenerate}
                    status={status}
@@ -1145,7 +1097,23 @@ Please retry with an adjusted search pattern or use display_diagram if retries a
                    status={status}
                    onSubmit={onFormSubmit}
                    onChange={handleInputChange}
-                    onClearChat={handleNewChat}
+                    onClearChat={() => {
+                        setMessages([])
+                        clearDiagram()
+                        const newSessionId = `session-${Date.now()}-${Math.random()
+                            .toString(36)
+                            .slice(2, 9)}`
+                        setSessionId(newSessionId)
+                        xmlSnapshotsRef.current.clear()
+                        // Clear localStorage
+                        localStorage.removeItem(STORAGE_MESSAGES_KEY)
+                        localStorage.removeItem(STORAGE_XML_SNAPSHOTS_KEY)
+                        localStorage.removeItem(STORAGE_DIAGRAM_XML_KEY)
+                        localStorage.setItem(
+                            STORAGE_SESSION_ID_KEY,
+                            newSessionId,
+                        )
+                    }}
                    files={files}
                    onFileChange={handleFileChange}
                    pdfData={pdfData}
@@ -1165,12 +1133,6 @@ Please retry with an adjusted search pattern or use display_diagram if retries a
                darkMode={darkMode}
                onToggleDarkMode={onToggleDarkMode}
            />
-
-            <ResetWarningModal
-                open={showNewChatDialog}
-                onOpenChange={setShowNewChatDialog}
-                onClear={handleNewChat}
-            />
        </div>
    )
 }
--- a/contexts/diagram-context.tsx
+++ b/contexts/diagram-context.tsx
@@ -5,7 +5,7 @@ import { createContext, useContext, useRef, useState } from "react"
 import type { DrawIoEmbedRef } from "react-drawio"
 import { STORAGE_DIAGRAM_XML_KEY } from "@/components/chat-panel"
 import type { ExportFormat } from "@/components/save-dialog"
-import { extractDiagramXML, validateAndFixXml } from "../lib/utils"
+import { extractDiagramXML, validateMxCellStructure } from "../lib/utils"

 interface DiagramContextType {
    chartXML: string
@@ -86,34 +86,21 @@ export function DiagramProvider({ children }: { children: React.ReactNode }) {
        chart: string,
        skipValidation?: boolean,
    ): string | null => {
-        let xmlToLoad = chart
-
        // Validate XML structure before loading (unless skipped for internal use)
        if (!skipValidation) {
-            const validation = validateAndFixXml(chart)
-            if (!validation.valid) {
-                console.warn(
-                    "[loadDiagram] Validation error:",
-                    validation.error,
-                )
-                return validation.error
-            }
-            // Use fixed XML if auto-fix was applied
-            if (validation.fixed) {
-                console.log(
-                    "[loadDiagram] Auto-fixed XML issues:",
-                    validation.fixes,
-                )
-                xmlToLoad = validation.fixed
+            const validationError = validateMxCellStructure(chart)
+            if (validationError) {
+                console.warn("[loadDiagram] Validation error:", validationError)
+                return validationError
            }
        }

        // Keep chartXML in sync even when diagrams are injected (e.g., display_diagram tool)
-        setChartXML(xmlToLoad)
+        setChartXML(chart)

        if (drawioRef.current) {
            drawioRef.current.load({
-                xml: xmlToLoad,
+                xml: chart,
            })
        }

--- a/docs/ai-providers.md
+++ b/docs/ai-providers.md
@@ -80,23 +80,13 @@ SILICONFLOW_BASE_URL=https://api.siliconflow.com/v1  # or https://api.siliconflo

 ```bash
 AZURE_API_KEY=your_api_key
-AZURE_RESOURCE_NAME=your-resource-name  # Required: your Azure resource name
 AI_MODEL=your-deployment-name
 ```

-Or use a custom endpoint instead of resource name:
+Optional custom endpoint:

 ```bash
-AZURE_API_KEY=your_api_key
-AZURE_BASE_URL=https://your-resource.openai.azure.com  # Alternative to AZURE_RESOURCE_NAME
-AI_MODEL=your-deployment-name
-```
-
-Optional reasoning configuration:
-
-```bash
-AZURE_REASONING_EFFORT=low      # Optional: low, medium, high
-AZURE_REASONING_SUMMARY=detailed  # Optional: none, brief, detailed
+AZURE_BASE_URL=https://your-resource.openai.azure.com
 ```

 ### AWS Bedrock
--- a/lib/ai-providers.ts
+++ b/lib/ai-providers.ts
@@ -371,16 +371,7 @@ function detectProvider(): ProviderName | null {
            continue
        }
        if (process.env[envVar]) {
-            // Azure requires additional config (baseURL or resourceName)
-            if (provider === "azure") {
-                const hasBaseUrl = !!process.env.AZURE_BASE_URL
-                const hasResourceName = !!process.env.AZURE_RESOURCE_NAME
-                if (hasBaseUrl || hasResourceName) {
-                    configuredProviders.push(provider as ProviderName)
-                }
-            } else {
-                configuredProviders.push(provider as ProviderName)
-            }
+            configuredProviders.push(provider as ProviderName)
        }
    }

@@ -402,18 +393,6 @@ function validateProviderCredentials(provider: ProviderName): void {
                `Please set it in your .env.local file.`,
        )
    }
-
-    // Azure requires either AZURE_BASE_URL or AZURE_RESOURCE_NAME in addition to API key
-    if (provider === "azure") {
-        const hasBaseUrl = !!process.env.AZURE_BASE_URL
-        const hasResourceName = !!process.env.AZURE_RESOURCE_NAME
-        if (!hasBaseUrl && !hasResourceName) {
-            throw new Error(
-                `Azure requires either AZURE_BASE_URL or AZURE_RESOURCE_NAME to be set. ` +
-                    `Please set one in your .env.local file.`,
-            )
-        }
-    }
 }

 /**
--- a/lib/utils.ts
+++ b/lib/utils.ts
@@ -6,95 +6,6 @@ export function cn(...inputs: ClassValue[]) {
    return twMerge(clsx(inputs))
 }

-// ============================================================================
-// XML Validation/Fix Constants
-// ============================================================================
-
-/** Maximum XML size to process (1MB) - larger XMLs may cause performance issues */
-const MAX_XML_SIZE = 1_000_000
-
-/** Maximum iterations for aggressive cell dropping to prevent infinite loops */
-const MAX_DROP_ITERATIONS = 10
-
-/** Structural attributes that should not be duplicated in draw.io */
-const STRUCTURAL_ATTRS = [
-    "edge",
-    "parent",
-    "source",
-    "target",
-    "vertex",
-    "connectable",
-]
-
-/** Valid XML entity names */
-const VALID_ENTITIES = new Set(["lt", "gt", "amp", "quot", "apos"])
-
-// ============================================================================
-// XML Parsing Helpers
-// ============================================================================
-
-interface ParsedTag {
-    tag: string
-    tagName: string
-    isClosing: boolean
-    isSelfClosing: boolean
-    startIndex: number
-    endIndex: number
-}
-
-/**
- * Parse XML tags while properly handling quoted strings
- * This is a shared utility used by both validation and fixing logic
- */
-function parseXmlTags(xml: string): ParsedTag[] {
-    const tags: ParsedTag[] = []
-    let i = 0
-
-    while (i < xml.length) {
-        const tagStart = xml.indexOf("<", i)
-        if (tagStart === -1) break
-
-        // Find matching > by tracking quotes
-        let tagEnd = tagStart + 1
-        let inQuote = false
-        let quoteChar = ""
-
-        while (tagEnd < xml.length) {
-            const c = xml[tagEnd]
-            if (inQuote) {
-                if (c === quoteChar) inQuote = false
-            } else {
-                if (c === '"' || c === "'") {
-                    inQuote = true
-                    quoteChar = c
-                } else if (c === ">") {
-                    break
-                }
-            }
-            tagEnd++
-        }
-
-        if (tagEnd >= xml.length) break
-
-        const tag = xml.substring(tagStart, tagEnd + 1)
-        i = tagEnd + 1
-
-        const tagMatch = /^<(\/?)([a-zA-Z][a-zA-Z0-9:_-]*)/.exec(tag)
-        if (!tagMatch) continue
-
-        tags.push({
-            tag,
-            tagName: tagMatch[2],
-            isClosing: tagMatch[1] === "/",
-            isSelfClosing: tag.endsWith("/>"),
-            startIndex: tagStart,
-            endIndex: tagEnd,
-        })
-    }
-
-    return tags
-}
-
 /**
 * Format XML string with proper indentation and line breaks
 * @param xml - The XML string to format
@@ -622,733 +533,143 @@ export function replaceXMLParts(
    return result
 }

-// ============================================================================
-// Validation Helper Functions
-// ============================================================================
-
-/** Check for duplicate structural attributes in a tag */
-function checkDuplicateAttributes(xml: string): string | null {
-    const structuralSet = new Set(STRUCTURAL_ATTRS)
-    const tagPattern = /<[^>]+>/g
-    let tagMatch
-    while ((tagMatch = tagPattern.exec(xml)) !== null) {
-        const tag = tagMatch[0]
-        const attrPattern = /\s([a-zA-Z_:][a-zA-Z0-9_:.-]*)\s*=/g
-        const attributes = new Map<string, number>()
-        let attrMatch
-        while ((attrMatch = attrPattern.exec(tag)) !== null) {
-            const attrName = attrMatch[1]
-            attributes.set(attrName, (attributes.get(attrName) || 0) + 1)
-        }
-        const duplicates = Array.from(attributes.entries())
-            .filter(([name, count]) => count > 1 && structuralSet.has(name))
-            .map(([name]) => name)
-        if (duplicates.length > 0) {
-            return `Invalid XML: Duplicate structural attribute(s): ${duplicates.join(", ")}. Remove duplicate attributes.`
-        }
-    }
-    return null
-}
-
-/** Check for duplicate IDs in XML */
-function checkDuplicateIds(xml: string): string | null {
-    const idPattern = /\bid\s*=\s*["']([^"']+)["']/gi
-    const ids = new Map<string, number>()
-    let idMatch
-    while ((idMatch = idPattern.exec(xml)) !== null) {
-        const id = idMatch[1]
-        ids.set(id, (ids.get(id) || 0) + 1)
-    }
-    const duplicateIds = Array.from(ids.entries())
-        .filter(([, count]) => count > 1)
-        .map(([id, count]) => `'${id}' (${count}x)`)
-    if (duplicateIds.length > 0) {
-        return `Invalid XML: Found duplicate ID(s): ${duplicateIds.slice(0, 3).join(", ")}. All id attributes must be unique.`
-    }
-    return null
-}
-
-/** Check for tag mismatches using parsed tags */
-function checkTagMismatches(xml: string): string | null {
-    const xmlWithoutComments = xml.replace(/<!--[\s\S]*?-->/g, "")
-    const tags = parseXmlTags(xmlWithoutComments)
-    const tagStack: string[] = []
-
-    for (const { tagName, isClosing, isSelfClosing } of tags) {
-        if (isClosing) {
-            if (tagStack.length === 0) {
-                return `Invalid XML: Closing tag </${tagName}> without matching opening tag`
-            }
-            const expected = tagStack.pop()
-            if (expected?.toLowerCase() !== tagName.toLowerCase()) {
-                return `Invalid XML: Expected closing tag </${expected}> but found </${tagName}>`
-            }
-        } else if (!isSelfClosing) {
-            tagStack.push(tagName)
-        }
-    }
-    if (tagStack.length > 0) {
-        return `Invalid XML: Document has ${tagStack.length} unclosed tag(s): ${tagStack.join(", ")}`
-    }
-    return null
-}
-
-/** Check for invalid character references */
-function checkCharacterReferences(xml: string): string | null {
-    const charRefPattern = /&#x?[^;]+;?/g
-    let charMatch
-    while ((charMatch = charRefPattern.exec(xml)) !== null) {
-        const ref = charMatch[0]
-        if (ref.startsWith("&#x")) {
-            if (!ref.endsWith(";")) {
-                return `Invalid XML: Missing semicolon after hex reference: ${ref}`
-            }
-            const hexDigits = ref.substring(3, ref.length - 1)
-            if (hexDigits.length === 0 || !/^[0-9a-fA-F]+$/.test(hexDigits)) {
-                return `Invalid XML: Invalid hex character reference: ${ref}`
-            }
-        } else if (ref.startsWith("&#")) {
-            if (!ref.endsWith(";")) {
-                return `Invalid XML: Missing semicolon after decimal reference: ${ref}`
-            }
-            const decDigits = ref.substring(2, ref.length - 1)
-            if (decDigits.length === 0 || !/^[0-9]+$/.test(decDigits)) {
-                return `Invalid XML: Invalid decimal character reference: ${ref}`
-            }
-        }
-    }
-    return null
-}
-
-/** Check for invalid entity references */
-function checkEntityReferences(xml: string): string | null {
-    const xmlWithoutComments = xml.replace(/<!--[\s\S]*?-->/g, "")
-    const bareAmpPattern = /&(?!(?:lt|gt|amp|quot|apos|#))/g
-    if (bareAmpPattern.test(xmlWithoutComments)) {
-        return "Invalid XML: Found unescaped & character(s). Replace & with &amp;"
-    }
-    const invalidEntityPattern = /&([a-zA-Z][a-zA-Z0-9]*);/g
-    let entityMatch
-    while (
-        (entityMatch = invalidEntityPattern.exec(xmlWithoutComments)) !== null
-    ) {
-        if (!VALID_ENTITIES.has(entityMatch[1])) {
-            return `Invalid XML: Invalid entity reference: &${entityMatch[1]}; - use only valid XML entities (lt, gt, amp, quot, apos)`
-        }
-    }
-    return null
-}
-
-/** Check for nested mxCell tags using regex */
-function checkNestedMxCells(xml: string): string | null {
-    const cellTagPattern = /<\/?mxCell[^>]*>/g
-    const cellStack: number[] = []
-    let cellMatch
-    while ((cellMatch = cellTagPattern.exec(xml)) !== null) {
-        const tag = cellMatch[0]
-        if (tag.startsWith("</mxCell>")) {
-            if (cellStack.length > 0) cellStack.pop()
-        } else if (!tag.endsWith("/>")) {
-            const isLabelOrGeometry =
-                /\sas\s*=\s*["'](valueLabel|geometry)["']/.test(tag)
-            if (!isLabelOrGeometry) {
-                cellStack.push(cellMatch.index)
-                if (cellStack.length > 1) {
-                    return "Invalid XML: Found nested mxCell tags. Cells should be siblings, not nested inside other mxCell elements."
-                }
-            }
-        }
-    }
-    return null
-}
-
 /**
 * Validates draw.io XML structure for common issues
- * Uses DOM parsing + additional regex checks for high accuracy
 * @param xml - The XML string to validate
 * @returns null if valid, error message string if invalid
 */
 export function validateMxCellStructure(xml: string): string | null {
-    // Size check for performance
-    if (xml.length > MAX_XML_SIZE) {
-        console.warn(
-            `[validateMxCellStructure] XML size (${xml.length}) exceeds ${MAX_XML_SIZE} bytes, may cause performance issues`,
-        )
+    const parser = new DOMParser()
+    const doc = parser.parseFromString(xml, "text/xml")
+
+    // Check for XML parsing errors (includes unescaped special characters)
+    const parseError = doc.querySelector("parsererror")
+    if (parseError) {
+        return `Invalid XML: The XML contains syntax errors (likely unescaped special characters like <, >, & in attribute values). Please escape special characters: use &lt; for <, &gt; for >, &amp; for &, &quot; for ". Regenerate the diagram with properly escaped values.`
    }

-    // 0. First use DOM parser to catch syntax errors (most accurate)
-    try {
-        const parser = new DOMParser()
-        const doc = parser.parseFromString(xml, "text/xml")
-        const parseError = doc.querySelector("parsererror")
-        if (parseError) {
-            return `Invalid XML: The XML contains syntax errors (likely unescaped special characters like <, >, & in attribute values). Please escape special characters: use &lt; for <, &gt; for >, &amp; for &, &quot; for ". Regenerate the diagram with properly escaped values.`
-        }
+    // Get all mxCell elements once for all validations
+    const allCells = doc.querySelectorAll("mxCell")

-        // DOM-based checks for nested mxCell
-        const allCells = doc.querySelectorAll("mxCell")
-        for (const cell of allCells) {
-            if (cell.parentElement?.tagName === "mxCell") {
-                const id = cell.getAttribute("id") || "unknown"
-                return `Invalid XML: Found nested mxCell (id="${id}"). Cells should be siblings, not nested inside other mxCell elements.`
+    // Single pass: collect IDs, check for duplicates, nesting, orphans, and invalid parents
+    const cellIds = new Set<string>()
+    const duplicateIds: string[] = []
+    const nestedCells: string[] = []
+    const orphanCells: string[] = []
+    const invalidParents: { id: string; parent: string }[] = []
+    const edgesToValidate: {
+        id: string
+        source: string | null
+        target: string | null
+    }[] = []
+
+    allCells.forEach((cell) => {
+        const id = cell.getAttribute("id")
+        const parent = cell.getAttribute("parent")
+        const isEdge = cell.getAttribute("edge") === "1"
+
+        // Check for duplicate IDs
+        if (id) {
+            if (cellIds.has(id)) {
+                duplicateIds.push(id)
+            } else {
+                cellIds.add(id)
            }
        }
-    } catch (error) {
-        // Log unexpected DOMParser errors before falling back to regex checks
-        console.warn(
-            "[validateMxCellStructure] DOMParser threw unexpected error, falling back to regex validation:",
-            error,
-        )
-    }

-    // 1. Check for CDATA wrapper (invalid at document root)
-    if (/^\s*<!\[CDATA\[/.test(xml)) {
-        return "Invalid XML: XML is wrapped in CDATA section - remove <![CDATA[ from start and ]]> from end"
-    }
-
-    // 2. Check for duplicate structural attributes
-    const dupAttrError = checkDuplicateAttributes(xml)
-    if (dupAttrError) return dupAttrError
-
-    // 3. Check for unescaped < in attribute values
-    const attrValuePattern = /=\s*"([^"]*)"/g
-    let attrValMatch
-    while ((attrValMatch = attrValuePattern.exec(xml)) !== null) {
-        const value = attrValMatch[1]
-        if (/</.test(value) && !/&lt;/.test(value)) {
-            return "Invalid XML: Unescaped < character in attribute values. Replace < with &lt;"
+        // Check for nested mxCell (parent element is also mxCell)
+        if (cell.parentElement?.tagName === "mxCell") {
+            nestedCells.push(id || "unknown")
        }
-    }

-    // 4. Check for duplicate IDs
-    const dupIdError = checkDuplicateIds(xml)
-    if (dupIdError) return dupIdError
-
-    // 5. Check for tag mismatches
-    const tagMismatchError = checkTagMismatches(xml)
-    if (tagMismatchError) return tagMismatchError
-
-    // 6. Check invalid character references
-    const charRefError = checkCharacterReferences(xml)
-    if (charRefError) return charRefError
-
-    // 7. Check for invalid comment syntax (-- inside comments)
-    const commentPattern = /<!--([\s\S]*?)-->/g
-    let commentMatch
-    while ((commentMatch = commentPattern.exec(xml)) !== null) {
-        if (/--/.test(commentMatch[1])) {
-            return "Invalid XML: Comment contains -- (double hyphen) which is not allowed"
+        // Check parent attribute (skip root cell id="0")
+        if (id !== "0") {
+            if (!parent) {
+                if (id) orphanCells.push(id)
+            } else {
+                // Store for later validation (after all IDs collected)
+                invalidParents.push({ id: id || "unknown", parent })
+            }
        }
+
+        // Collect edges for connection validation
+        if (isEdge) {
+            edgesToValidate.push({
+                id: id || "unknown",
+                source: cell.getAttribute("source"),
+                target: cell.getAttribute("target"),
+            })
+        }
+    })
+
+    // Return errors in priority order
+    if (nestedCells.length > 0) {
+        return `Invalid XML: Found nested mxCell elements (IDs: ${nestedCells.slice(0, 3).join(", ")}). All mxCell elements must be direct children of <root>, never nested inside other mxCell elements. Please regenerate the diagram with correct structure.`
    }

-    // 8. Check for unescaped entity references and invalid entity names
-    const entityError = checkEntityReferences(xml)
-    if (entityError) return entityError
-
-    // 9. Check for empty id attributes on mxCell
-    if (/<mxCell[^>]*\sid\s*=\s*["']\s*["'][^>]*>/g.test(xml)) {
-        return "Invalid XML: Found mxCell element(s) with empty id attribute"
+    if (duplicateIds.length > 0) {
+        return `Invalid XML: Found duplicate cell IDs (${duplicateIds.slice(0, 3).join(", ")}). Each mxCell must have a unique ID. Please regenerate the diagram with unique IDs for all elements.`
    }

-    // 10. Check for nested mxCell tags
-    const nestedCellError = checkNestedMxCells(xml)
-    if (nestedCellError) return nestedCellError
+    if (orphanCells.length > 0) {
+        return `Invalid XML: Found cells without parent attribute (IDs: ${orphanCells.slice(0, 3).join(", ")}). All mxCell elements (except id="0") must have a parent attribute. Please regenerate the diagram with proper parent references.`
+    }
+
+    // Validate parent references (now that all IDs are collected)
+    const badParents = invalidParents.filter((p) => !cellIds.has(p.parent))
+    if (badParents.length > 0) {
+        const details = badParents
+            .slice(0, 3)
+            .map((p) => `${p.id} (parent: ${p.parent})`)
+            .join(", ")
+        return `Invalid XML: Found cells with invalid parent references (${details}). Parent IDs must reference existing cells. Please regenerate the diagram with valid parent references.`
+    }
+
+    // Validate edge connections
+    const invalidConnections: string[] = []
+    edgesToValidate.forEach((edge) => {
+        if (edge.source && !cellIds.has(edge.source)) {
+            invalidConnections.push(`${edge.id} (source: ${edge.source})`)
+        }
+        if (edge.target && !cellIds.has(edge.target)) {
+            invalidConnections.push(`${edge.id} (target: ${edge.target})`)
+        }
+    })
+
+    if (invalidConnections.length > 0) {
+        return `Invalid XML: Found edges with invalid source/target references (${invalidConnections.slice(0, 3).join(", ")}). Edge source and target must reference existing cell IDs. Please regenerate the diagram with valid edge connections.`
+    }
+
+    // Check for orphaned mxPoint elements (not inside <Array as="points"> and without 'as' attribute)
+    // These cause "Could not add object mxPoint" errors in draw.io
+    const allMxPoints = doc.querySelectorAll("mxPoint")
+    const orphanedMxPoints: string[] = []
+    allMxPoints.forEach((point) => {
+        const hasAsAttr = point.hasAttribute("as")
+        const parentIsArray =
+            point.parentElement?.tagName === "Array" &&
+            point.parentElement?.getAttribute("as") === "points"
+
+        if (!hasAsAttr && !parentIsArray) {
+            // Find the parent mxCell to report which edge has the problem
+            let parent = point.parentElement
+            while (parent && parent.tagName !== "mxCell") {
+                parent = parent.parentElement
+            }
+            const cellId = parent?.getAttribute("id") || "unknown"
+            if (!orphanedMxPoints.includes(cellId)) {
+                orphanedMxPoints.push(cellId)
+            }
+        }
+    })
+
+    if (orphanedMxPoints.length > 0) {
+        return `Invalid XML: Found orphaned mxPoint elements in cells (${orphanedMxPoints.slice(0, 3).join(", ")}). mxPoint elements must either have an 'as' attribute (e.g., as="sourcePoint") or be inside <Array as="points">. For edge waypoints, use: <Array as="points"><mxPoint x="..." y="..."/></Array>. Please fix the mxPoint structure.`
+    }

    return null
 }

-/**
- * Attempts to auto-fix common XML issues in draw.io diagrams
- * @param xml - The XML string to fix
- * @returns Object with fixed XML and list of fixes applied
- */
-export function autoFixXml(xml: string): { fixed: string; fixes: string[] } {
-    let fixed = xml
-    const fixes: string[] = []
-
-    // 0. Fix JSON-escaped XML (common when XML is stored in JSON without unescaping)
-    // Only apply when we see JSON-escaped attribute patterns like =\"value\"
-    // Don't apply to legitimate \n in value attributes (draw.io uses these for line breaks)
-    if (/=\\"/.test(fixed)) {
-        // Replace literal \" with actual quotes
-        fixed = fixed.replace(/\\"/g, '"')
-        // Replace literal \n with actual newlines (only after confirming JSON-escaped)
-        fixed = fixed.replace(/\\n/g, "\n")
-        fixes.push("Fixed JSON-escaped XML")
-    }
-
-    // 1. Remove CDATA wrapper (MUST be before text-before-root check)
-    if (/^\s*<!\[CDATA\[/.test(fixed)) {
-        fixed = fixed.replace(/^\s*<!\[CDATA\[/, "").replace(/\]\]>\s*$/, "")
-        fixes.push("Removed CDATA wrapper")
-    }
-
-    // 2. Remove text before XML declaration or root element (only if it's garbage text, not valid XML)
-    const xmlStart = fixed.search(/<(\?xml|mxGraphModel|mxfile)/i)
-    if (xmlStart > 0 && !/^<[a-zA-Z]/.test(fixed.trim())) {
-        fixed = fixed.substring(xmlStart)
-        fixes.push("Removed text before XML root")
-    }
-
-    // 2. Fix duplicate attributes (keep first occurrence, remove duplicates)
-    let dupAttrFixed = false
-    fixed = fixed.replace(/<[^>]+>/g, (tag) => {
-        let newTag = tag
-
-        for (const attr of STRUCTURAL_ATTRS) {
-            // Find all occurrences of this attribute
-            const attrRegex = new RegExp(
-                `\\s${attr}\\s*=\\s*["'][^"']*["']`,
-                "gi",
-            )
-            const matches = tag.match(attrRegex)
-
-            if (matches && matches.length > 1) {
-                // Keep first, remove others
-                let firstKept = false
-                newTag = newTag.replace(attrRegex, (m) => {
-                    if (!firstKept) {
-                        firstKept = true
-                        return m
-                    }
-                    dupAttrFixed = true
-                    return ""
-                })
-            }
-        }
-        return newTag
-    })
-    if (dupAttrFixed) {
-        fixes.push("Removed duplicate structural attributes")
-    }
-
-    // 3. Fix unescaped & characters (but not valid entities)
-    // Match & not followed by valid entity pattern
-    const ampersandPattern =
-        /&(?!(?:lt|gt|amp|quot|apos|#[0-9]+|#x[0-9a-fA-F]+);)/g
-    if (ampersandPattern.test(fixed)) {
-        fixed = fixed.replace(
-            /&(?!(?:lt|gt|amp|quot|apos|#[0-9]+|#x[0-9a-fA-F]+);)/g,
-            "&amp;",
-        )
-        fixes.push("Escaped unescaped & characters")
-    }
-
-    // 3. Fix invalid entity names like &ampquot; -> &quot;
-    // Common mistake: double-escaping
-    const invalidEntities = [
-        { pattern: /&ampquot;/g, replacement: "&quot;", name: "&ampquot;" },
-        { pattern: /&amplt;/g, replacement: "&lt;", name: "&amplt;" },
-        { pattern: /&ampgt;/g, replacement: "&gt;", name: "&ampgt;" },
-        { pattern: /&ampapos;/g, replacement: "&apos;", name: "&ampapos;" },
-        { pattern: /&ampamp;/g, replacement: "&amp;", name: "&ampamp;" },
-    ]
-    for (const { pattern, replacement, name } of invalidEntities) {
-        if (pattern.test(fixed)) {
-            fixed = fixed.replace(pattern, replacement)
-            fixes.push(`Fixed double-escaped entity ${name}`)
-        }
-    }
-
-    // 3b. Fix malformed attribute values where &quot; is used as delimiter instead of actual quotes
-    // Pattern: attr=&quot;value&quot; should become attr="value" (the &quot; was meant to be the quote delimiter)
-    // This commonly happens with dashPattern=&quot;1 1;&quot;
-    const malformedQuotePattern = /(\s[a-zA-Z][a-zA-Z0-9_:-]*)=&quot;/
-    if (malformedQuotePattern.test(fixed)) {
-        // Replace =&quot; with =" and trailing &quot; before next attribute or tag end with "
-        fixed = fixed.replace(
-            /(\s[a-zA-Z][a-zA-Z0-9_:-]*)=&quot;([^&]*?)&quot;/g,
-            '$1="$2"',
-        )
-        fixes.push(
-            'Fixed malformed attribute quotes (=&quot;...&quot; to ="...")',
-        )
-    }
-
-    // 3c. Fix malformed closing tags like </tag/> -> </tag>
-    const malformedClosingTag = /<\/([a-zA-Z][a-zA-Z0-9]*)\s*\/>/g
-    if (malformedClosingTag.test(fixed)) {
-        fixed = fixed.replace(/<\/([a-zA-Z][a-zA-Z0-9]*)\s*\/>/g, "</$1>")
-        fixes.push("Fixed malformed closing tags (</tag/> to </tag>)")
-    }
-
-    // 3d. Fix missing space between attributes like vertex="1"parent="1"
-    const missingSpacePattern = /("[^"]*")([a-zA-Z][a-zA-Z0-9_:-]*=)/g
-    if (missingSpacePattern.test(fixed)) {
-        fixed = fixed.replace(/("[^"]*")([a-zA-Z][a-zA-Z0-9_:-]*=)/g, "$1 $2")
-        fixes.push("Added missing space between attributes")
-    }
-
-    // 3e. Fix unescaped quotes in style color values like fillColor="#fff2e6"
-    // The " after Color= prematurely ends the style attribute. Remove it.
-    // Pattern: ;fillColor="#fff → ;fillColor=#fff (remove first ", keep second as style closer)
-    const quotedColorPattern = /;([a-zA-Z]*[Cc]olor)="#/
-    if (quotedColorPattern.test(fixed)) {
-        fixed = fixed.replace(/;([a-zA-Z]*[Cc]olor)="#/g, ";$1=#")
-        fixes.push("Removed quotes around color values in style")
-    }
-
-    // 4. Fix unescaped < in attribute values
-    // This is tricky - we need to find < inside quoted attribute values
-    const attrPattern = /(=\s*")([^"]*?)(<)([^"]*?)(")/g
-    let attrMatch
-    let hasUnescapedLt = false
-    while ((attrMatch = attrPattern.exec(fixed)) !== null) {
-        if (!attrMatch[3].startsWith("&lt;")) {
-            hasUnescapedLt = true
-            break
-        }
-    }
-    if (hasUnescapedLt) {
-        // Replace < with &lt; inside attribute values
-        fixed = fixed.replace(/=\s*"([^"]*)"/g, (_match, value) => {
-            const escaped = value.replace(/</g, "&lt;")
-            return `="${escaped}"`
-        })
-        fixes.push("Escaped < characters in attribute values")
-    }
-
-    // 5. Fix invalid character references (remove malformed ones)
-    // Pattern: &#x followed by non-hex chars before ;
-    const invalidHexRefs: string[] = []
-    fixed = fixed.replace(/&#x([^;]*);/g, (match, hex) => {
-        if (/^[0-9a-fA-F]+$/.test(hex) && hex.length > 0) {
-            return match // Valid hex ref, keep it
-        }
-        invalidHexRefs.push(match)
-        return "" // Remove invalid ref
-    })
-    if (invalidHexRefs.length > 0) {
-        fixes.push(
-            `Removed ${invalidHexRefs.length} invalid hex character reference(s)`,
-        )
-    }
-
-    // 6. Fix invalid decimal character references
-    const invalidDecRefs: string[] = []
-    fixed = fixed.replace(/&#([^x][^;]*);/g, (match, dec) => {
-        if (/^[0-9]+$/.test(dec) && dec.length > 0) {
-            return match // Valid decimal ref, keep it
-        }
-        invalidDecRefs.push(match)
-        return "" // Remove invalid ref
-    })
-    if (invalidDecRefs.length > 0) {
-        fixes.push(
-            `Removed ${invalidDecRefs.length} invalid decimal character reference(s)`,
-        )
-    }
-
-    // 7. Fix invalid comment syntax (replace -- with - repeatedly until none left)
-    fixed = fixed.replace(/<!--([\s\S]*?)-->/g, (match, content) => {
-        if (/--/.test(content)) {
-            // Keep replacing until no double hyphens remain
-            let fixedContent = content
-            while (/--/.test(fixedContent)) {
-                fixedContent = fixedContent.replace(/--/g, "-")
-            }
-            fixes.push("Fixed invalid comment syntax (removed double hyphens)")
-            return `<!--${fixedContent}-->`
-        }
-        return match
-    })
-
-    // 8. Fix <Cell> tags that should be <mxCell> (common LLM mistake)
-    // This handles both opening and closing tags
-    const hasCellTags = /<\/?Cell[\s>]/i.test(fixed)
-    if (hasCellTags) {
-        fixed = fixed.replace(/<Cell(\s)/gi, "<mxCell$1")
-        fixed = fixed.replace(/<Cell>/gi, "<mxCell>")
-        fixed = fixed.replace(/<\/Cell>/gi, "</mxCell>")
-        fixes.push("Fixed <Cell> tags to <mxCell>")
-    }
-
-    // 9. Fix common closing tag typos
-    const tagTypos = [
-        { wrong: /<\/mxElement>/gi, right: "</mxCell>", name: "</mxElement>" },
-        { wrong: /<\/mxcell>/g, right: "</mxCell>", name: "</mxcell>" }, // case sensitivity
-        {
-            wrong: /<\/mxgeometry>/g,
-            right: "</mxGeometry>",
-            name: "</mxgeometry>",
-        },
-        { wrong: /<\/mxpoint>/g, right: "</mxPoint>", name: "</mxpoint>" },
-        {
-            wrong: /<\/mxgraphmodel>/gi,
-            right: "</mxGraphModel>",
-            name: "</mxgraphmodel>",
-        },
-    ]
-    for (const { wrong, right, name } of tagTypos) {
-        if (wrong.test(fixed)) {
-            fixed = fixed.replace(wrong, right)
-            fixes.push(`Fixed typo ${name} to ${right}`)
-        }
-    }
-
-    // 10. Fix unclosed tags by appending missing closing tags
-    // Use parseXmlTags helper to track open tags
-    const tagStack: string[] = []
-    const parsedTags = parseXmlTags(fixed)
-
-    for (const { tagName, isClosing, isSelfClosing } of parsedTags) {
-        if (isClosing) {
-            // Find matching opening tag (may not be the last one if there's mismatch)
-            const lastIdx = tagStack.lastIndexOf(tagName)
-            if (lastIdx !== -1) {
-                tagStack.splice(lastIdx, 1)
-            }
-        } else if (!isSelfClosing) {
-            tagStack.push(tagName)
-        }
-    }
-
-    // If there are unclosed tags, append closing tags in reverse order
-    // But first verify with simple count that they're actually unclosed
-    if (tagStack.length > 0) {
-        const tagsToClose: string[] = []
-        for (const tagName of tagStack.reverse()) {
-            // Simple count check: only close if opens > closes
-            const openCount = (
-                fixed.match(new RegExp(`<${tagName}[\\s>]`, "gi")) || []
-            ).length
-            const closeCount = (
-                fixed.match(new RegExp(`</${tagName}>`, "gi")) || []
-            ).length
-            if (openCount > closeCount) {
-                tagsToClose.push(tagName)
-            }
-        }
-        if (tagsToClose.length > 0) {
-            const closingTags = tagsToClose.map((t) => `</${t}>`).join("\n")
-            fixed = fixed.trimEnd() + "\n" + closingTags
-            fixes.push(
-                `Closed ${tagsToClose.length} unclosed tag(s): ${tagsToClose.join(", ")}`,
-            )
-        }
-    }
-
-    // 11. Fix nested mxCell by flattening
-    // Pattern A: <mxCell id="X">...<mxCell id="X">...</mxCell></mxCell> (duplicate ID)
-    // Pattern B: <mxCell id="X">...<mxCell id="Y">...</mxCell></mxCell> (different ID - true nesting)
-    const lines = fixed.split("\n")
-    let newLines: string[] = []
-    let nestedFixed = 0
-    let extraClosingToRemove = 0
-
-    // First pass: fix duplicate ID nesting (same as before)
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i]
-        const nextLine = lines[i + 1]
-
-        // Check if current line and next line are both mxCell opening tags with same ID
-        if (
-            nextLine &&
-            /<mxCell\s/.test(line) &&
-            /<mxCell\s/.test(nextLine) &&
-            !line.includes("/>") &&
-            !nextLine.includes("/>")
-        ) {
-            const id1 = line.match(/\bid\s*=\s*["']([^"']+)["']/)?.[1]
-            const id2 = nextLine.match(/\bid\s*=\s*["']([^"']+)["']/)?.[1]
-
-            if (id1 && id1 === id2) {
-                nestedFixed++
-                extraClosingToRemove++ // Need to remove one </mxCell> later
-                continue // Skip this duplicate opening line
-            }
-        }
-
-        // Remove extra </mxCell> if we have pending removals
-        if (extraClosingToRemove > 0 && /^\s*<\/mxCell>\s*$/.test(line)) {
-            extraClosingToRemove--
-            continue // Skip this closing tag
-        }
-
-        newLines.push(line)
-    }
-
-    if (nestedFixed > 0) {
-        fixed = newLines.join("\n")
-        fixes.push(`Flattened ${nestedFixed} duplicate-ID nested mxCell(s)`)
-    }
-
-    // Second pass: fix true nesting (different IDs)
-    // Insert </mxCell> before nested child to close parent
-    const lines2 = fixed.split("\n")
-    newLines = []
-    let trueNestedFixed = 0
-    let cellDepth = 0
-    let pendingCloseRemoval = 0
-
-    for (let i = 0; i < lines2.length; i++) {
-        const line = lines2[i]
-        const trimmed = line.trim()
-
-        // Track mxCell depth
-        const isOpenCell = /<mxCell\s/.test(trimmed) && !trimmed.endsWith("/>")
-        const isCloseCell = trimmed === "</mxCell>"
-
-        if (isOpenCell) {
-            if (cellDepth > 0) {
-                // Found nested cell - insert closing tag for parent before this line
-                const indent = line.match(/^(\s*)/)?.[1] || ""
-                newLines.push(indent + "</mxCell>")
-                trueNestedFixed++
-                pendingCloseRemoval++ // Need to remove one </mxCell> later
-            }
-            cellDepth = 1 // Reset to 1 since we just opened a new cell
-            newLines.push(line)
-        } else if (isCloseCell) {
-            if (pendingCloseRemoval > 0) {
-                pendingCloseRemoval--
-                // Skip this extra closing tag
-            } else {
-                cellDepth = Math.max(0, cellDepth - 1)
-                newLines.push(line)
-            }
-        } else {
-            newLines.push(line)
-        }
-    }
-
-    if (trueNestedFixed > 0) {
-        fixed = newLines.join("\n")
-        fixes.push(`Fixed ${trueNestedFixed} true nested mxCell(s)`)
-    }
-
-    // 12. Fix duplicate IDs by appending suffix
-    const seenIds = new Map<string, number>()
-    const duplicateIds: string[] = []
-
-    // First pass: find duplicates
-    const idPattern = /\bid\s*=\s*["']([^"']+)["']/gi
-    let idMatch
-    while ((idMatch = idPattern.exec(fixed)) !== null) {
-        const id = idMatch[1]
-        seenIds.set(id, (seenIds.get(id) || 0) + 1)
-    }
-
-    // Find which IDs are duplicated
-    for (const [id, count] of seenIds) {
-        if (count > 1) duplicateIds.push(id)
-    }
-
-    // Second pass: rename duplicates (keep first occurrence, rename others)
-    if (duplicateIds.length > 0) {
-        const idCounters = new Map<string, number>()
-        fixed = fixed.replace(/\bid\s*=\s*["']([^"']+)["']/gi, (match, id) => {
-            if (!duplicateIds.includes(id)) return match
-
-            const count = idCounters.get(id) || 0
-            idCounters.set(id, count + 1)
-
-            if (count === 0) return match // Keep first occurrence
-
-            // Rename subsequent occurrences
-            const newId = `${id}_dup${count}`
-            return match.replace(id, newId)
-        })
-        fixes.push(`Renamed ${duplicateIds.length} duplicate ID(s)`)
-    }
-
-    // 9. Fix empty id attributes by generating unique IDs
-    let emptyIdCount = 0
-    fixed = fixed.replace(
-        /<mxCell([^>]*)\sid\s*=\s*["']\s*["']([^>]*)>/g,
-        (_match, before, after) => {
-            emptyIdCount++
-            const newId = `cell_${Date.now()}_${emptyIdCount}`
-            return `<mxCell${before} id="${newId}"${after}>`
-        },
-    )
-    if (emptyIdCount > 0) {
-        fixes.push(`Generated ${emptyIdCount} missing ID(s)`)
-    }
-
-    // 13. Aggressive: drop broken mxCell elements that can't be fixed
-    // Only do this if DOM parser still finds errors after all other fixes
-    if (typeof DOMParser !== "undefined") {
-        let droppedCells = 0
-        let maxIterations = MAX_DROP_ITERATIONS
-        while (maxIterations-- > 0) {
-            const parser = new DOMParser()
-            const doc = parser.parseFromString(fixed, "text/xml")
-            const parseError = doc.querySelector("parsererror")
-            if (!parseError) break // Valid now!
-
-            const errText = parseError.textContent || ""
-            const match = errText.match(/(\d+):\d+:/)
-            if (!match) break
-
-            const errLine = parseInt(match[1], 10) - 1
-            const lines = fixed.split("\n")
-
-            // Find the mxCell containing this error line
-            let cellStart = errLine
-            let cellEnd = errLine
-
-            // Go back to find <mxCell
-            while (cellStart > 0 && !lines[cellStart].includes("<mxCell")) {
-                cellStart--
-            }
-
-            // Go forward to find </mxCell> or />
-            while (cellEnd < lines.length - 1) {
-                if (
-                    lines[cellEnd].includes("</mxCell>") ||
-                    lines[cellEnd].trim().endsWith("/>")
-                ) {
-                    break
-                }
-                cellEnd++
-            }
-
-            // Remove these lines
-            lines.splice(cellStart, cellEnd - cellStart + 1)
-            fixed = lines.join("\n")
-            droppedCells++
-        }
-        if (droppedCells > 0) {
-            fixes.push(`Dropped ${droppedCells} unfixable mxCell element(s)`)
-        }
-    }
-
-    return { fixed, fixes }
-}
-
-/**
- * Validates XML and attempts to fix if invalid
- * @param xml - The XML string to validate and potentially fix
- * @returns Object with validation result, fixed XML if applicable, and fixes applied
- */
-export function validateAndFixXml(xml: string): {
-    valid: boolean
-    error: string | null
-    fixed: string | null
-    fixes: string[]
-} {
-    // First validation attempt
-    let error = validateMxCellStructure(xml)
-
-    if (!error) {
-        return { valid: true, error: null, fixed: null, fixes: [] }
-    }
-
-    // Try to fix
-    const { fixed, fixes } = autoFixXml(xml)
-
-    // Validate the fixed version
-    error = validateMxCellStructure(fixed)
-
-    if (!error) {
-        return { valid: true, error: null, fixed, fixes }
-    }
-
-    // Still invalid after fixes
-    return { valid: false, error, fixed: null, fixes }
-}
-
 export function extractDiagramXML(xml_svg_string: string): string {
    try {
        // 1. Parse the SVG string (using built-in DOMParser in a browser-like environment)
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,15 +1,15 @@
 {
    "name": "next-ai-draw-io",
-    "version": "0.4.0",
+    "version": "0.3.0",
    "lockfileVersion": 3,
    "requires": true,
    "packages": {
        "": {
            "name": "next-ai-draw-io",
-            "version": "0.4.0",
+            "version": "0.3.0",
            "license": "Apache-2.0",
            "dependencies": {
-                "@ai-sdk/amazon-bedrock": "^3.0.70",
+                "@ai-sdk/amazon-bedrock": "^3.0.62",
                "@ai-sdk/anthropic": "^2.0.44",
                "@ai-sdk/azure": "^2.0.69",
                "@ai-sdk/deepseek": "^1.0.30",
@@ -33,6 +33,7 @@
                "@radix-ui/react-switch": "^1.2.6",
                "@radix-ui/react-tooltip": "^1.1.8",
                "@radix-ui/react-use-controllable-state": "^1.2.2",
+                "@vercel/analytics": "^1.5.0",
                "@xmldom/xmldom": "^0.9.8",
                "ai": "^5.0.89",
                "base-64": "^1.0.0",
@@ -77,14 +78,14 @@
            }
        },
        "node_modules/@ai-sdk/amazon-bedrock": {
-            "version": "3.0.70",
-            "resolved": "https://registry.npmjs.org/@ai-sdk/amazon-bedrock/-/amazon-bedrock-3.0.70.tgz",
-            "integrity": "sha512-4NIBlwuS/iLKq2ynOqqyJ9imk/oyHuOzhBx88Bfm5I0ihQPKJ0dMMD1IKKuyDZvLRYKmlOEpa//P+/ZBp10drw==",
+            "version": "3.0.62",
+            "resolved": "https://registry.npmjs.org/@ai-sdk/amazon-bedrock/-/amazon-bedrock-3.0.62.tgz",
+            "integrity": "sha512-vVtndaj5zfHmgw8NSqN4baFDbFDTBZP6qufhKfqSNLtygEm8+8PL9XQX9urgzSzU3zp+zi3AmNNemvKLkkqblg==",
            "license": "Apache-2.0",
            "dependencies": {
-                "@ai-sdk/anthropic": "2.0.56",
+                "@ai-sdk/anthropic": "2.0.50",
                "@ai-sdk/provider": "2.0.0",
-                "@ai-sdk/provider-utils": "3.0.19",
+                "@ai-sdk/provider-utils": "3.0.18",
                "@smithy/eventstream-codec": "^4.0.1",
                "@smithy/util-utf8": "^4.0.0",
                "aws4fetch": "^1.0.20"
@@ -96,48 +97,14 @@
                "zod": "^3.25.76 || ^4.1.8"
            }
        },
-        "node_modules/@ai-sdk/amazon-bedrock/node_modules/@ai-sdk/provider-utils": {
-            "version": "3.0.19",
-            "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-3.0.19.tgz",
-            "integrity": "sha512-W41Wc9/jbUVXVwCN/7bWa4IKe8MtxO3EyA0Hfhx6grnmiYlCvpI8neSYWFE0zScXJkgA/YK3BRybzgyiXuu6JA==",
-            "license": "Apache-2.0",
-            "dependencies": {
-                "@ai-sdk/provider": "2.0.0",
-                "@standard-schema/spec": "^1.0.0",
-                "eventsource-parser": "^3.0.6"
-            },
-            "engines": {
-                "node": ">=18"
-            },
-            "peerDependencies": {
-                "zod": "^3.25.76 || ^4.1.8"
-            }
-        },
        "node_modules/@ai-sdk/anthropic": {
-            "version": "2.0.56",
-            "resolved": "https://registry.npmjs.org/@ai-sdk/anthropic/-/anthropic-2.0.56.tgz",
-            "integrity": "sha512-XHJKu0Yvfu9SPzRfsAFESa+9T7f2YJY6TxykKMfRsAwpeWAiX/Gbx5J5uM15AzYC3Rw8tVP3oH+j7jEivENirQ==",
+            "version": "2.0.50",
+            "resolved": "https://registry.npmjs.org/@ai-sdk/anthropic/-/anthropic-2.0.50.tgz",
+            "integrity": "sha512-21PaHfoLmouOXXNINTsZJsMw+wE5oLR2He/1kq/sKokTVKyq7ObGT1LDk6ahwxaz/GoaNaGankMh+EgVcdv2Cw==",
            "license": "Apache-2.0",
            "dependencies": {
                "@ai-sdk/provider": "2.0.0",
-                "@ai-sdk/provider-utils": "3.0.19"
-            },
-            "engines": {
-                "node": ">=18"
-            },
-            "peerDependencies": {
-                "zod": "^3.25.76 || ^4.1.8"
-            }
-        },
-        "node_modules/@ai-sdk/anthropic/node_modules/@ai-sdk/provider-utils": {
-            "version": "3.0.19",
-            "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-3.0.19.tgz",
-            "integrity": "sha512-W41Wc9/jbUVXVwCN/7bWa4IKe8MtxO3EyA0Hfhx6grnmiYlCvpI8neSYWFE0zScXJkgA/YK3BRybzgyiXuu6JA==",
-            "license": "Apache-2.0",
-            "dependencies": {
-                "@ai-sdk/provider": "2.0.0",
-                "@standard-schema/spec": "^1.0.0",
-                "eventsource-parser": "^3.0.6"
+                "@ai-sdk/provider-utils": "3.0.18"
            },
            "engines": {
                "node": ">=18"
@@ -2522,9 +2489,9 @@
            }
        },
        "node_modules/@next/env": {
-            "version": "16.0.10",
-            "resolved": "https://registry.npmjs.org/@next/env/-/env-16.0.10.tgz",
-            "integrity": "sha512-8tuaQkyDVgeONQ1MeT9Mkk8pQmZapMKFh5B+OrFUlG3rVmYTXcXlBetBgTurKXGaIZvkoqRT9JL5K3phXcgang==",
+            "version": "16.0.7",
+            "resolved": "https://registry.npmjs.org/@next/env/-/env-16.0.7.tgz",
+            "integrity": "sha512-gpaNgUh5nftFKRkRQGnVi5dpcYSKGcZZkQffZ172OrG/XkrnS7UBTQ648YY+8ME92cC4IojpI2LqTC8sTDhAaw==",
            "license": "MIT"
        },
        "node_modules/@next/eslint-plugin-next": {
@@ -2538,9 +2505,9 @@
            }
        },
        "node_modules/@next/swc-darwin-arm64": {
-            "version": "16.0.10",
-            "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-16.0.10.tgz",
-            "integrity": "sha512-4XgdKtdVsaflErz+B5XeG0T5PeXKDdruDf3CRpnhN+8UebNa5N2H58+3GDgpn/9GBurrQ1uWW768FfscwYkJRg==",
+            "version": "16.0.7",
+            "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-16.0.7.tgz",
+            "integrity": "sha512-LlDtCYOEj/rfSnEn/Idi+j1QKHxY9BJFmxx7108A6D8K0SB+bNgfYQATPk/4LqOl4C0Wo3LACg2ie6s7xqMpJg==",
            "cpu": [
                "arm64"
            ],
@@ -2554,9 +2521,9 @@
            }
        },
        "node_modules/@next/swc-darwin-x64": {
-            "version": "16.0.10",
-            "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.0.10.tgz",
-            "integrity": "sha512-spbEObMvRKkQ3CkYVOME+ocPDFo5UqHb8EMTS78/0mQ+O1nqE8toHJVioZo4TvebATxgA8XMTHHrScPrn68OGw==",
+            "version": "16.0.7",
+            "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.0.7.tgz",
+            "integrity": "sha512-rtZ7BhnVvO1ICf3QzfW9H3aPz7GhBrnSIMZyr4Qy6boXF0b5E3QLs+cvJmg3PsTCG2M1PBoC+DANUi4wCOKXpA==",
            "cpu": [
                "x64"
            ],
@@ -2570,9 +2537,9 @@
            }
        },
        "node_modules/@next/swc-linux-arm64-gnu": {
-            "version": "16.0.10",
-            "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-16.0.10.tgz",
-            "integrity": "sha512-uQtWE3X0iGB8apTIskOMi2w/MKONrPOUCi5yLO+v3O8Mb5c7K4Q5KD1jvTpTF5gJKa3VH/ijKjKUq9O9UhwOYw==",
+            "version": "16.0.7",
+            "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-16.0.7.tgz",
+            "integrity": "sha512-mloD5WcPIeIeeZqAIP5c2kdaTa6StwP4/2EGy1mUw8HiexSHGK/jcM7lFuS3u3i2zn+xH9+wXJs6njO7VrAqww==",
            "cpu": [
                "arm64"
            ],
@@ -2586,9 +2553,9 @@
            }
        },
        "node_modules/@next/swc-linux-arm64-musl": {
-            "version": "16.0.10",
-            "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-16.0.10.tgz",
-            "integrity": "sha512-llA+hiDTrYvyWI21Z0L1GiXwjQaanPVQQwru5peOgtooeJ8qx3tlqRV2P7uH2pKQaUfHxI/WVarvI5oYgGxaTw==",
+            "version": "16.0.7",
+            "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-16.0.7.tgz",
+            "integrity": "sha512-+ksWNrZrthisXuo9gd1XnjHRowCbMtl/YgMpbRvFeDEqEBd523YHPWpBuDjomod88U8Xliw5DHhekBC3EOOd9g==",
            "cpu": [
                "arm64"
            ],
@@ -2602,9 +2569,9 @@
            }
        },
        "node_modules/@next/swc-linux-x64-gnu": {
-            "version": "16.0.10",
-            "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-16.0.10.tgz",
-            "integrity": "sha512-AK2q5H0+a9nsXbeZ3FZdMtbtu9jxW4R/NgzZ6+lrTm3d6Zb7jYrWcgjcpM1k8uuqlSy4xIyPR2YiuUr+wXsavA==",
+            "version": "16.0.7",
+            "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-16.0.7.tgz",
+            "integrity": "sha512-4WtJU5cRDxpEE44Ana2Xro1284hnyVpBb62lIpU5k85D8xXxatT+rXxBgPkc7C1XwkZMWpK5rXLXTh9PFipWsA==",
            "cpu": [
                "x64"
            ],
@@ -2618,9 +2585,9 @@
            }
        },
        "node_modules/@next/swc-linux-x64-musl": {
-            "version": "16.0.10",
-            "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-16.0.10.tgz",
-            "integrity": "sha512-1TDG9PDKivNw5550S111gsO4RGennLVl9cipPhtkXIFVwo31YZ73nEbLjNC8qG3SgTz/QZyYyaFYMeY4BKZR/g==",
+            "version": "16.0.7",
+            "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-16.0.7.tgz",
+            "integrity": "sha512-HYlhqIP6kBPXalW2dbMTSuB4+8fe+j9juyxwfMwCe9kQPPeiyFn7NMjNfoFOfJ2eXkeQsoUGXg+O2SE3m4Qg2w==",
            "cpu": [
                "x64"
            ],
@@ -2634,9 +2601,9 @@
            }
        },
        "node_modules/@next/swc-win32-arm64-msvc": {
-            "version": "16.0.10",
-            "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-16.0.10.tgz",
-            "integrity": "sha512-aEZIS4Hh32xdJQbHz121pyuVZniSNoqDVx1yIr2hy+ZwJGipeqnMZBJHyMxv2tiuAXGx6/xpTcQJ6btIiBjgmg==",
+            "version": "16.0.7",
+            "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-16.0.7.tgz",
+            "integrity": "sha512-EviG+43iOoBRZg9deGauXExjRphhuYmIOJ12b9sAPy0eQ6iwcPxfED2asb/s2/yiLYOdm37kPaiZu8uXSYPs0Q==",
            "cpu": [
                "arm64"
            ],
@@ -2650,9 +2617,9 @@
            }
        },
        "node_modules/@next/swc-win32-x64-msvc": {
-            "version": "16.0.10",
-            "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-16.0.10.tgz",
-            "integrity": "sha512-E+njfCoFLb01RAFEnGZn6ERoOqhK1Gl3Lfz1Kjnj0Ulfu7oJbuMyvBKNj/bw8XZnenHDASlygTjZICQW+rYW1Q==",
+            "version": "16.0.7",
+            "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-16.0.7.tgz",
+            "integrity": "sha512-gniPjy55zp5Eg0896qSrf3yB1dw4F/3s8VK1ephdsZZ129j2n6e1WqCbE2YgcKhW9hPB9TVZENugquWJD5x0ug==",
            "cpu": [
                "x64"
            ],
@@ -6061,6 +6028,44 @@
                "win32"
            ]
        },
+        "node_modules/@vercel/analytics": {
+            "version": "1.5.0",
+            "resolved": "https://registry.npmjs.org/@vercel/analytics/-/analytics-1.5.0.tgz",
+            "integrity": "sha512-MYsBzfPki4gthY5HnYN7jgInhAZ7Ac1cYDoRWFomwGHWEX7odTEzbtg9kf/QSo7XEsEAqlQugA6gJ2WS2DEa3g==",
+            "license": "MPL-2.0",
+            "peerDependencies": {
+                "@remix-run/react": "^2",
+                "@sveltejs/kit": "^1 || ^2",
+                "next": ">= 13",
+                "react": "^18 || ^19 || ^19.0.0-rc",
+                "svelte": ">= 4",
+                "vue": "^3",
+                "vue-router": "^4"
+            },
+            "peerDependenciesMeta": {
+                "@remix-run/react": {
+                    "optional": true
+                },
+                "@sveltejs/kit": {
+                    "optional": true
+                },
+                "next": {
+                    "optional": true
+                },
+                "react": {
+                    "optional": true
+                },
+                "svelte": {
+                    "optional": true
+                },
+                "vue": {
+                    "optional": true
+                },
+                "vue-router": {
+                    "optional": true
+                }
+            }
+        },
        "node_modules/@vercel/oidc": {
            "version": "3.0.5",
            "resolved": "https://registry.npmjs.org/@vercel/oidc/-/oidc-3.0.5.tgz",
@@ -8012,15 +8017,14 @@
            }
        },
        "node_modules/form-data": {
-            "version": "4.0.5",
-            "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
-            "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+            "version": "4.0.2",
+            "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.2.tgz",
+            "integrity": "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==",
            "license": "MIT",
            "dependencies": {
                "asynckit": "^0.4.0",
                "combined-stream": "^1.0.8",
                "es-set-tostringtag": "^2.1.0",
-                "hasown": "^2.0.2",
                "mime-types": "^2.1.12"
            },
            "engines": {
@@ -10672,12 +10676,12 @@
            "license": "MIT"
        },
        "node_modules/next": {
-            "version": "16.0.10",
-            "resolved": "https://registry.npmjs.org/next/-/next-16.0.10.tgz",
-            "integrity": "sha512-RtWh5PUgI+vxlV3HdR+IfWA1UUHu0+Ram/JBO4vWB54cVPentCD0e+lxyAYEsDTqGGMg7qpjhKh6dc6aW7W/sA==",
+            "version": "16.0.7",
+            "resolved": "https://registry.npmjs.org/next/-/next-16.0.7.tgz",
+            "integrity": "sha512-3mBRJyPxT4LOxAJI6IsXeFtKfiJUbjCLgvXO02fV8Wy/lIhPvP94Fe7dGhUgHXcQy4sSuYwQNcOLhIfOm0rL0A==",
            "license": "MIT",
            "dependencies": {
-                "@next/env": "16.0.10",
+                "@next/env": "16.0.7",
                "@swc/helpers": "0.5.15",
                "caniuse-lite": "^1.0.30001579",
                "postcss": "8.4.31",
@@ -10690,14 +10694,14 @@
                "node": ">=20.9.0"
            },
            "optionalDependencies": {
-                "@next/swc-darwin-arm64": "16.0.10",
-                "@next/swc-darwin-x64": "16.0.10",
-                "@next/swc-linux-arm64-gnu": "16.0.10",
-                "@next/swc-linux-arm64-musl": "16.0.10",
-                "@next/swc-linux-x64-gnu": "16.0.10",
-                "@next/swc-linux-x64-musl": "16.0.10",
-                "@next/swc-win32-arm64-msvc": "16.0.10",
-                "@next/swc-win32-x64-msvc": "16.0.10",
+                "@next/swc-darwin-arm64": "16.0.7",
+                "@next/swc-darwin-x64": "16.0.7",
+                "@next/swc-linux-arm64-gnu": "16.0.7",
+                "@next/swc-linux-arm64-musl": "16.0.7",
+                "@next/swc-linux-x64-gnu": "16.0.7",
+                "@next/swc-linux-x64-musl": "16.0.7",
+                "@next/swc-win32-arm64-msvc": "16.0.7",
+                "@next/swc-win32-x64-msvc": "16.0.7",
                "sharp": "^0.34.4"
            },
            "peerDependencies": {
--- a/package.json
+++ b/package.json
@@ -13,7 +13,7 @@
        "prepare": "husky"
    },
    "dependencies": {
-        "@ai-sdk/amazon-bedrock": "^3.0.70",
+        "@ai-sdk/amazon-bedrock": "^3.0.62",
        "@ai-sdk/anthropic": "^2.0.44",
        "@ai-sdk/azure": "^2.0.69",
        "@ai-sdk/deepseek": "^1.0.30",
@@ -37,6 +37,7 @@
        "@radix-ui/react-switch": "^1.2.6",
        "@radix-ui/react-tooltip": "^1.1.8",
        "@radix-ui/react-use-controllable-state": "^1.2.2",
+        "@vercel/analytics": "^1.5.0",
        "@xmldom/xmldom": "^0.9.8",
        "ai": "^5.0.89",
        "base-64": "^1.0.0",
--- a/vercel.json
+++ b/vercel.json
@@ -1,12 +0,0 @@
-{
-    "functions": {
-        "app/api/chat/route.ts": {
-            "memory": 512,
-            "maxDuration": 120
-        },
-        "app/api/**/route.ts": {
-            "memory": 256,
-            "maxDuration": 10
-        }
-    }
-}