@alpaca-editor/core 1.0.4049 → 1.0.4053

package/dist/editor/ai/AiTerminal.js

@@ -4,27 +4,13 @@ import { useEffect, useRef, useState } from "react";
 import { TerminalService } from "primereact/terminalservice";
 import { Terminal } from "../Terminal";
 import { useEditContext } from "../client/editContext";
-import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger, } from "../../components/ui/dropdown-menu";
-import { ChevronDown } from "lucide-react";
+import { Dropdown } from "primereact/dropdown";
 import { WizardIcon } from "../ui/Icons";
 import { AiResponseMessage } from "./AiResponseMessage";
-import { loadAiProfiles } from "../services/aiService";
-import { startAgent, connectToAgentStream, cancelAgent, checkAgentState, convertAgentMessagesToTerminalFormat, AgentStreamMessageType, } from "../services/agentService";
+import { loadAiProfiles, executePrompt, } from "../services/aiService";
 import { SimpleIconButton } from "../ui/SimpleIconButton";
-import { Settings, Square } from "lucide-react";
-import { AgentCostDisplay } from "./AgentCostDisplay";
-import { Tooltip, TooltipContent, TooltipTrigger, } from "../../components/ui/tooltip";
-import { Popover, PopoverContent, PopoverTrigger, } from "../../components/ui/popover";
-// Helper function to format message content
-function formatMessageContent(content) {
-    return (content
-        ?.trim()
-        ?.replaceAll("\n", "<br>")
-        ?.replace(/\*\*(.*?)\*\*/g, "<b>$1</b>") // Bold markdown
-        ?.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" class="text-blue-500" rel="noopener noreferrer">$1</a>') || "" // Links
-    );
-}
-export function AiTerminal({ closeButton, createAiContext, defaultProfile, options, onAgentNameUpdate, }) {
+import { Settings } from "lucide-react";
+export function AiTerminal({ closeButton, createAiContext, defaultProfile, options, }) {
     const editContext = useEditContext();
     const [showPredefined, setShowPredefined] = useState(false);
     if (!editContext)
@@ -36,25 +22,12 @@ export function AiTerminal({ closeButton, createAiContext, defaultProfile, optio
     const [profiles, setProfiles] = useState([]);
     const [activeProfile, setActiveProfile] = useState();
     const [initialPromptExecuted, setInitialPromptExecuted] = useState(false);
-    const [agentId, setAgentId] = useState(() => options?.agentId || crypto.randomUUID());
+    const [agentId] = useState(() => crypto.randomUUID());
     const selection = editContext.selection;
     const terminalRef = useRef(null);
     const [responseMessages, setResponseMessages] = useState(options?.initialMessages || []);
     const [showSettings, setShowSettings] = useState(false);
     const settingsRef = useRef(null);
-    const [isRunning, setIsRunning] = useState(false);
-    const abortControllerRef = useRef(null);
-    const [terminalError, setTerminalError] = useState(null);
-    // Debug function - expose globally for testing
-    useEffect(() => {
-        window.testAiTerminalError = (errorMsg = "Test error message") => {
-            console.log("Manually triggering error:", errorMsg);
-            setTerminalError(errorMsg);
-        };
-        return () => {
-            delete window.testAiTerminalError;
-        };
-    }, []);
     useEffect(() => {
         if (options?.initialPrompt && !initialPromptExecuted && model) {
             // Set the initial prompt text into the terminal's state.
@@ -78,293 +51,6 @@ export function AiTerminal({ closeButton, createAiContext, defaultProfile, optio
         }
         fetchProfiles();
     }, [editContext?.currentItemDescriptor]);
-    // Agent reconnection logic
-    useEffect(() => {
-        async function checkAndReconnectAgent() {
-            if (!editContext || !editContext.sessionId || !agentId) {
-                return;
-            }
-            const context = createAiContext({ editContext });
-            try {
-                const agentState = await checkAgentState(agentId, context);
-                if (agentState.exists && agentState.agent) {
-                    const agent = agentState.agent;
-                    // Convert and set persisted messages if not already set via options
-                    if (agent.messages &&
-                        (!options?.initialMessages || options.initialMessages.length === 0)) {
-                        const terminalMessages = convertAgentMessagesToTerminalFormat(agent.messages);
-                        setMessages(terminalMessages);
-                        setResponseMessages(terminalMessages);
-                    }
-                    else {
-                    }
-                    // Set cost information if available
-                    if (agent.totalCost !== undefined) {
-                        setResponse((prev) => ({
-                            ...prev,
-                            totalCost: agent.totalCost,
-                            totalInputTokenCost: agent.totalInputTokenCost,
-                            totalOutputTokenCost: agent.totalOutputTokenCost,
-                            totalCachedTokenCost: agent.totalCachedInputTokenCost,
-                            totalInputTokens: agent.totalInputTokens,
-                            totalOutputTokens: agent.totalOutputTokens,
-                            totalCachedTokens: agent.totalCachedInputTokens,
-                        }));
-                    }
-                    // If agent is still running, reconnect to the stream
-                    if (agentState.isRunning) {
-                        setIsRunning(true);
-                        await reconnectToRunningAgent(agentId, context);
-                    }
-                    else {
-                    }
-                }
-                else {
-                }
-            }
-            catch (error) {
-                setTerminalError(`Reconnection failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
-        // Only try to reconnect if we have an agentId and edit context
-        if (agentId && editContext && editContext.sessionId) {
-            checkAndReconnectAgent();
-        }
-        else {
-        }
-    }, [agentId, editContext?.sessionId]); // Run when agentId or session becomes available
-    // Function to reconnect to a running agent stream
-    async function reconnectToRunningAgent(agentId, context) {
-        try {
-            const abortController = new AbortController();
-            abortControllerRef.current = abortController;
-            setIsRunning(true);
-            let accumulatedResponse = {
-                messages: [...messages],
-                editOperations: [],
-                numInputTokens: 0,
-                numOutputTokens: 0,
-                numCachedTokens: 0,
-                state: "running",
-            };
-            let completionProcessed = false;
-            await connectToAgentStream(agentId, context, (streamMessage) => {
-                if (!streamMessage || !streamMessage.type) {
-                    return;
-                }
-                // Reuse stream message handling, but pipe updates into Terminal via TerminalService
-                try {
-                    const terminalCallback = (text, finished) => {
-                        TerminalService.emit("response", { text, finished });
-                    };
-                    const result = handleStreamMessage(streamMessage, accumulatedResponse, completionProcessed, context, terminalCallback);
-                    if (result) {
-                        accumulatedResponse = result.accumulatedResponse;
-                        completionProcessed = result.completionProcessed;
-                    }
-                }
-                catch (error) { }
-            }, abortController.signal);
-            setIsRunning(false);
-        }
-        catch (error) {
-            setIsRunning(false);
-            // Check if it's an abort error (user cancelled)
-            const isAbortError = error instanceof Error &&
-                (error.name === "AbortError" ||
-                    error.message.toLowerCase().includes("abort"));
-            if (!isAbortError) {
-                const errorMessage = `Failed to reconnect to agent: ${error instanceof Error ? error.message : "Unknown error"}`;
-                setTerminalError(errorMessage);
-            }
-            else {
-            }
-        }
-    }
-    // Extract stream message handling logic into a separate function for reuse
-    function handleStreamMessage(streamMessage, accumulatedResponse, completionProcessed, context, terminalCallback) {
-        // Safety check for valid stream message
-        if (!streamMessage || !streamMessage.type) {
-            console.error("Invalid stream message received:", streamMessage);
-            return;
-        }
-        console.log("Processing stream message:", streamMessage.type, streamMessage);
-        // Handle different message types (this logic was already in the component)
-        switch (streamMessage.type) {
-            case AgentStreamMessageType.StatusUpdate:
-                break;
-            case AgentStreamMessageType.ContentChunk:
-                if (streamMessage.data && typeof streamMessage.data === "object") {
-                    if (streamMessage.data.isIncremental &&
-                        streamMessage.data.deltaContent) {
-                        // Handle incremental content updates
-                        const updatedMessages = [...(accumulatedResponse.messages || [])];
-                        let lastAssistantMessage = null;
-                        let lastAssistantIndex = -1;
-                        // Find the last assistant message
-                        for (let i = updatedMessages.length - 1; i >= 0; i--) {
-                            if (updatedMessages[i].role === "assistant") {
-                                lastAssistantMessage = updatedMessages[i];
-                                lastAssistantIndex = i;
-                                break;
-                            }
-                        }
-                        // If no assistant message exists, or the last one has tool calls, create a new one
-                        if (!lastAssistantMessage ||
-                            (lastAssistantMessage.tool_calls &&
-                                lastAssistantMessage.tool_calls.length > 0)) {
-                            lastAssistantMessage = {
-                                id: crypto.randomUUID(),
-                                role: "assistant",
-                                name: "assistant",
-                                content: "",
-                                tool_calls: [],
-                            };
-                            updatedMessages.push(lastAssistantMessage);
-                            lastAssistantIndex = updatedMessages.length - 1;
-                        }
-                        // Append the delta content to build up the full message
-                        const currentContent = lastAssistantMessage.content || "";
-                        const newContent = currentContent + streamMessage.data.deltaContent;
-                        // Update the message with accumulated content
-                        updatedMessages[lastAssistantIndex] = {
-                            ...lastAssistantMessage,
-                            content: newContent,
-                        };
-                        // Update accumulated response with incremental content
-                        const newAccumulated = {
-                            ...accumulatedResponse,
-                            ...streamMessage.data,
-                            messages: updatedMessages,
-                            editOperations: streamMessage.data.editOperations ||
-                                accumulatedResponse.editOperations,
-                        };
-                        accumulatedResponse = newAccumulated;
-                    }
-                    else {
-                        // Non-incremental update - use as provided
-                        const newAccumulated = {
-                            ...accumulatedResponse,
-                            ...streamMessage.data,
-                            editOperations: streamMessage.data.editOperations ||
-                                accumulatedResponse.editOperations,
-                        };
-                        accumulatedResponse = newAccumulated;
-                    }
-                    // Always trigger UI update for content chunks
-                    handleResponse(accumulatedResponse, terminalCallback, false);
-                }
-                return { accumulatedResponse, completionProcessed };
-            case AgentStreamMessageType.ToolCall:
-                if (streamMessage.data && typeof streamMessage.data === "object") {
-                    // Find or create the assistant message that contains this tool call
-                    const updatedMessages = [...(accumulatedResponse.messages || [])];
-                    let lastAssistantMessage = null;
-                    let lastAssistantIndex = -1;
-                    for (let i = updatedMessages.length - 1; i >= 0; i--) {
-                        if (updatedMessages[i].role === "assistant") {
-                            lastAssistantMessage = updatedMessages[i];
-                            lastAssistantIndex = i;
-                            break;
-                        }
-                    }
-                    // If no assistant message exists, create one
-                    if (!lastAssistantMessage) {
-                        lastAssistantMessage = {
-                            id: crypto.randomUUID(),
-                            role: "assistant",
-                            name: "assistant",
-                            content: "",
-                            tool_calls: [],
-                        };
-                        updatedMessages.push(lastAssistantMessage);
-                        lastAssistantIndex = updatedMessages.length - 1;
-                    }
-                    const toolCall = {
-                        id: streamMessage.data.id,
-                        displayName: streamMessage.data.displayName,
-                        function: {
-                            name: streamMessage.data.function?.name || streamMessage.data.name,
-                            arguments: streamMessage.data.function?.arguments ||
-                                streamMessage.data.arguments,
-                        },
-                    };
-                    const existingToolCalls = lastAssistantMessage.tool_calls || [];
-                    const existingIndex = existingToolCalls.findIndex((tc) => tc.id === toolCall.id);
-                    let updatedToolCalls;
-                    if (existingIndex >= 0) {
-                        updatedToolCalls = [...existingToolCalls];
-                        updatedToolCalls[existingIndex] = toolCall;
-                    }
-                    else {
-                        updatedToolCalls = [...existingToolCalls, toolCall];
-                    }
-                    updatedMessages[lastAssistantIndex] = {
-                        ...lastAssistantMessage,
-                        tool_calls: updatedToolCalls,
-                    };
-                    const newAccumulated = {
-                        ...accumulatedResponse,
-                        messages: updatedMessages,
-                    };
-                    accumulatedResponse = newAccumulated;
-                    handleResponse(accumulatedResponse, terminalCallback, false);
-                }
-                return { accumulatedResponse, completionProcessed };
-            case AgentStreamMessageType.ToolResult:
-                if (streamMessage.data && typeof streamMessage.data === "object") {
-                    const updatedMessages = [...(accumulatedResponse.messages || [])];
-                    // Find the assistant message with the matching tool call ID
-                    for (let i = updatedMessages.length - 1; i >= 0; i--) {
-                        if (updatedMessages[i].role === "assistant" &&
-                            updatedMessages[i].tool_calls) {
-                            const toolCalls = updatedMessages[i].tool_calls || [];
-                            const toolCallIndex = toolCalls.findIndex((tc) => tc.id === streamMessage.data.toolCallId);
-                            if (toolCallIndex >= 0) {
-                                const updatedToolCalls = [...toolCalls];
-                                updatedToolCalls[toolCallIndex] = {
-                                    ...updatedToolCalls[toolCallIndex],
-                                    function: {
-                                        ...updatedToolCalls[toolCallIndex].function,
-                                        result: streamMessage.data.result,
-                                        error: streamMessage.data.error,
-                                    },
-                                };
-                                updatedMessages[i] = {
-                                    ...updatedMessages[i],
-                                    tool_calls: updatedToolCalls,
-                                };
-                                break;
-                            }
-                        }
-                    }
-                    const newAccumulated = {
-                        ...accumulatedResponse,
-                        messages: updatedMessages,
-                    };
-                    accumulatedResponse = newAccumulated;
-                    handleResponse(accumulatedResponse, terminalCallback, false);
-                }
-                return { accumulatedResponse, completionProcessed };
-            case AgentStreamMessageType.Completed:
-                if (!completionProcessed) {
-                    completionProcessed = true;
-                    console.log("Agent execution completed");
-                    setIsRunning(false);
-                    if (streamMessage.data) {
-                        handleResponse(streamMessage.data, terminalCallback, true);
-                    }
-                }
-                return { accumulatedResponse, completionProcessed };
-            case AgentStreamMessageType.Error:
-                console.error("Agent execution error:", streamMessage);
-                setIsRunning(false);
-                setTerminalError(streamMessage.error || "Agent execution failed");
-                return { accumulatedResponse, completionProcessed };
-            default:
-                console.warn("Unknown stream message type:", streamMessage.type);
-        }
-    }
     useEffect(() => {
         if (activeProfile?.defaultModelId)
             setModel(activeProfile.defaultModelId);
@@ -380,7 +66,10 @@ export function AiTerminal({ closeButton, createAiContext, defaultProfile, optio
             console.log("AiTerminal: Loading initial messages", options.initialMessages);
             // Format the initial messages for display
             const formattedMessages = options.initialMessages.map((message) => {
-                const formattedContent = formatMessageContent(message.content || "");
+                const formattedContent = message.content
+                    ?.trim()
+                    ?.replaceAll("\n", "<br>")
+                    ?.replace(/\*\*(.*?)\*\*/g, "<b>$1</b>") || "";
                 return {
                     ...message,
                     content: message.content || "",
@@ -388,6 +77,7 @@ export function AiTerminal({ closeButton, createAiContext, defaultProfile, optio
                     tool_calls: message.tool_calls || [],
                 };
             });
+            console.log("AiTerminal: Formatted messages", formattedMessages);
             // Update the internal message states
             setMessages(formattedMessages);
             setResponseMessages(formattedMessages);
@@ -395,101 +85,57 @@ export function AiTerminal({ closeButton, createAiContext, defaultProfile, optio
             const initialResponse = {
                 messages: formattedMessages,
                 editOperations: [],
-                numInputTokens: options?.totalInputTokens || 0,
-                numOutputTokens: options?.totalOutputTokens || 0,
-                numCachedTokens: options?.totalCachedTokens || 0,
+                numInputTokens: 0,
+                numOutputTokens: 0,
+                numCachedTokens: 0,
                 state: "loaded",
-                // Include cost information from loaded agent session
-                totalCost: options?.totalCost,
-                totalInputTokenCost: options?.totalInputTokenCost,
-                totalOutputTokenCost: options?.totalOutputTokenCost,
-                totalCachedTokenCost: options?.totalCachedTokenCost,
-                totalInputTokens: options?.totalInputTokens,
-                totalOutputTokens: options?.totalOutputTokens,
-                totalCachedTokens: options?.totalCachedTokens,
             };
+            console.log("AiTerminal: Setting response", initialResponse);
             setResponse(initialResponse);
             // Create individual Terminal messages for each conversation message
             const terminalMessages = [];
-            // Group messages by conversation turns (user + assistant pairs)
-            let i = 0;
-            while (i < formattedMessages.length) {
-                const message = formattedMessages[i];
-                if (!message) {
-                    i++;
-                    continue;
-                }
+            formattedMessages.forEach((message) => {
                 if (message.role === "user") {
                     // User messages appear as commands
                     terminalMessages.push({
                         type: "command",
                         text: message.content,
                     });
-                    i++;
-                    // Look for following assistant messages to group together
-                    const assistantMessages = [];
-                    while (i < formattedMessages.length) {
-                        const assistantMessage = formattedMessages[i];
-                        if (assistantMessage && assistantMessage.role === "assistant") {
-                            assistantMessages.push(assistantMessage);
-                            i++;
-                        }
-                        else {
-                            break;
-                        }
-                    }
-                    // If we have assistant messages, render them with AiResponseMessage
-                    if (assistantMessages.length > 0) {
-                        terminalMessages.push({
-                            type: "response",
-                            text: (_jsx(AiResponseMessage, { messages: assistantMessages, editOperations: [], finished: true })),
-                        });
-                    }
                 }
                 else if (message.role === "assistant") {
-                    // Handle standalone assistant messages
+                    // Assistant messages appear as responses
                     terminalMessages.push({
                         type: "response",
-                        text: (_jsx(AiResponseMessage, { messages: [message], editOperations: [], finished: true })),
+                        text: (_jsx("div", { dangerouslySetInnerHTML: {
+                                __html: message.formattedContent || message.content || "",
+                            } })),
                     });
-                    i++;
                 }
-                else {
-                    // Skip other message types (like tool messages)
-                    i++;
+                // Add tool calls if present
+                if (message.tool_calls && message.tool_calls.length > 0) {
+                    message.tool_calls.forEach((toolCall) => {
+                        terminalMessages.push({
+                            type: "response",
+                            text: (_jsxs("div", { className: "text-gray-1 text-xs", children: ["\uD83D\uDD27 ", toolCall.displayName] })),
+                        });
+                    });
                 }
-            }
+            });
             setInitialTerminalMessages(terminalMessages);
         }
     }, [options?.initialMessages]);
     // Handle click outside for settings popover
     useEffect(() => {
         function handleClickOutside(event) {
-            const target = event.target;
-            // Check if the click is inside the settings popover
-            if (settingsRef.current && settingsRef.current.contains(target)) {
-                return;
-            }
-            // Check if the click is inside any dropdown menu content
-            // Radix UI dropdown menus can have various selectors
-            const isInDropdown = target.closest([
-                "[data-radix-popper-content-wrapper]",
-                '[data-slot="dropdown-menu-content"]',
-                "[data-radix-dropdown-menu-content]",
-                '[role="menu"]',
-                ".dropdown-menu", // fallback for any custom dropdown classes
-            ].join(", "));
-            if (isInDropdown) {
-                return;
+            if (settingsRef.current &&
+                !settingsRef.current.contains(event.target)) {
+                setShowSettings(false);
             }
-            // If we get here, it's a click outside both the settings and any dropdown
-            setShowSettings(false);
         }
         if (showSettings) {
-            // Use mousedown instead of click for better timing
-            document.addEventListener("mousedown", handleClickOutside);
+            document.addEventListener("click", handleClickOutside);
             return () => {
-                document.removeEventListener("mousedown", handleClickOutside);
+                document.removeEventListener("click", handleClickOutside);
             };
         }
     }, [showSettings]);
@@ -498,7 +144,10 @@ export function AiTerminal({ closeButton, createAiContext, defaultProfile, optio
         // Replace the conversation history with the authoritative response from AI
         if (updatedMessages && Array.isArray(updatedMessages)) {
             const formattedMessages = updatedMessages.map((message) => {
-                const formattedContent = formatMessageContent(message.content || "");
+                const formattedContent = message.content
+                    ?.trim()
+                    ?.replaceAll("\n", "<br>")
+                    ?.replace(/\*\*(.*?)\*\*/g, "<b>$1</b>") || "";
                 return {
                     ...message,
                     content: message.content || "",
@@ -509,11 +158,11 @@ export function AiTerminal({ closeButton, createAiContext, defaultProfile, optio
             // Update the messages state with the complete conversation from AI
             setMessages([...formattedMessages]);
             setResponseMessages([...formattedMessages]);
-            terminalCallback(_jsx(AiResponseMessage, { messages: formattedMessages, editOperations: response.editOperations, finished: isFinished, error: response.error }), isFinished);
+            terminalCallback(_jsx(AiResponseMessage, { messages: formattedMessages, editOperations: response.editOperations, finished: isFinished }), isFinished);
         }
         else {
             // Fallback: if no messages in response, keep current state
-            terminalCallback(_jsx(AiResponseMessage, { messages: messagesRef.current, editOperations: response.editOperations, finished: isFinished, error: response.error }), isFinished);
+            terminalCallback(_jsx(AiResponseMessage, { messages: messagesRef.current, editOperations: response.editOperations, finished: isFinished }), isFinished);
         }
     }
     async function commandHandler(text, callback) {
@@ -524,11 +173,13 @@ export function AiTerminal({ closeButton, createAiContext, defaultProfile, optio
             name: "user",
             tool_calls: [], // Add empty toolCalls array
         };
-        const context = createAiContext({ editContext });
+        const context = createAiContext({ editContext: editContext });
+        let lastOpIndex = 0;
         const selectedText = editContext?.selectedRange?.text || null;
         if (!activeProfile || !model)
             return;
-        // Only send the new user message - message history will be loaded from database
+        // Build complete message history for API call
+        const conversationHistory = [...messagesRef.current, userMessage];
         const messages = [
             ...(options?.hiddenSystemPrompt
                 ? [
@@ -541,408 +192,35 @@ export function AiTerminal({ closeButton, createAiContext, defaultProfile, optio
                     },
                 ]
                 : []),
-            userMessage, // Send only the new user message
+            ...conversationHistory,
         ];
-        // Update local state to include the new user message for UI display
-        setMessages((prevMessages) => [...prevMessages, userMessage]);
-        setResponseMessages((prevMessages) => [...prevMessages, userMessage]);
-        try {
-            // Step 1: Start the agent execution
-            const startRequest = {
-                agentId,
-                messages,
-                sessionId: editContext.sessionId,
-                profileId: activeProfile.id,
-                model,
-                itemid: context.promptData.itemid,
-                language: context.promptData.language,
-                version: context.promptData.version,
-                selection,
-                selectedText: selectedText || undefined,
-                allowedFunctions: context.promptData.allowedFunctions,
-                addContextContent: context.promptData.addContextContent,
-                addAllContent: context.promptData.addAllContent,
-                addSelectedComponents: true,
-                profile: activeProfile.name,
-            };
-            const startResponse = await startAgent(startRequest, context);
-            // Step 2: Connect to the agent stream for real-time updates
-            const abortController = new AbortController();
-            abortControllerRef.current = abortController;
-            setIsRunning(true);
-            let accumulatedResponse = {
-                messages: [...messages],
-                editOperations: [],
-                numInputTokens: 0,
-                numOutputTokens: 0,
-                numCachedTokens: 0,
-                state: "running",
-            };
-            let completionProcessed = false;
-            try {
-                console.log("Connecting to agent stream");
-                await connectToAgentStream(agentId, context, (streamMessage) => {
-                    // console.log(
-                    //   "Stream message:",
-                    //   streamMessage,
-                    //   new Date().toISOString(),
-                    // );
-                    // Safety check for valid stream message
-                    if (!streamMessage || !streamMessage.type) {
-                        console.error("Invalid stream message received:", streamMessage);
-                        return;
-                    }
-                    console.log("Processing stream message:", streamMessage.type, streamMessage);
-                    // Message types are now normalized in agentService.ts
-                    switch (streamMessage.type) {
-                        case AgentStreamMessageType.StatusUpdate:
-                            //console.log("Status update:", streamMessage.data);
-                            break;
-                        case AgentStreamMessageType.ContentChunk:
-                            if (streamMessage.data &&
-                                typeof streamMessage.data === "object") {
-                                // Handle incremental content updates
-                                if (streamMessage.data.isIncremental &&
-                                    streamMessage.data.deltaContent) {
-                                    // Find the last assistant message to append delta content to
-                                    const updatedMessages = [
-                                        ...(accumulatedResponse.messages || []),
-                                    ];
-                                    let lastAssistantMessage = null;
-                                    let lastAssistantIndex = -1;
-                                    // Find the last assistant message
-                                    for (let i = updatedMessages.length - 1; i >= 0; i--) {
-                                        if (updatedMessages[i].role === "assistant") {
-                                            lastAssistantMessage = updatedMessages[i];
-                                            lastAssistantIndex = i;
-                                            break;
-                                        }
-                                    }
-                                    // If no assistant message exists, or the last one has tool calls, create a new one
-                                    if (!lastAssistantMessage ||
-                                        (lastAssistantMessage.tool_calls &&
-                                            lastAssistantMessage.tool_calls.length > 0)) {
-                                        lastAssistantMessage = {
-                                            id: crypto.randomUUID(),
-                                            role: "assistant",
-                                            name: "assistant",
-                                            content: "",
-                                            tool_calls: [],
-                                        };
-                                        updatedMessages.push(lastAssistantMessage);
-                                        lastAssistantIndex = updatedMessages.length - 1;
-                                    }
-                                    // Append the delta content to build up the full message
-                                    const currentContent = lastAssistantMessage.content || "";
-                                    const newContent = currentContent + streamMessage.data.deltaContent;
-                                    // Update the message with accumulated content
-                                    updatedMessages[lastAssistantIndex] = {
-                                        ...lastAssistantMessage,
-                                        content: newContent,
-                                    };
-                                    // Update accumulated response with incremental content
-                                    accumulatedResponse = {
-                                        ...accumulatedResponse,
-                                        ...streamMessage.data,
-                                        messages: updatedMessages,
-                                        editOperations: streamMessage.data.editOperations ||
-                                            accumulatedResponse.editOperations,
-                                    };
-                                }
-                                else {
-                                    // Non-incremental update - use as provided
-                                    accumulatedResponse = {
-                                        ...accumulatedResponse,
-                                        ...streamMessage.data,
-                                        editOperations: streamMessage.data.editOperations ||
-                                            accumulatedResponse.editOperations,
-                                    };
-                                }
-                                // Always trigger UI update for content chunks
-                                handleResponse(accumulatedResponse, callback, false);
-                            }
-                            break;
-                        case AgentStreamMessageType.ToolCall:
-                            //  console.log("Tool call received:", streamMessage.data);
-                            if (streamMessage.data &&
-                                typeof streamMessage.data === "object") {
-                                // Find or create the assistant message that contains this tool call
-                                const updatedMessages = [
-                                    ...(accumulatedResponse.messages || []),
-                                ];
-                                let lastAssistantMessage = null;
-                                let lastAssistantIndex = -1;
-                                // Find the last assistant message
-                                for (let i = updatedMessages.length - 1; i >= 0; i--) {
-                                    if (updatedMessages[i].role === "assistant") {
-                                        lastAssistantMessage = updatedMessages[i];
-                                        lastAssistantIndex = i;
-                                        break;
-                                    }
-                                }
-                                // If no assistant message exists, create one
-                                if (!lastAssistantMessage) {
-                                    lastAssistantMessage = {
-                                        id: crypto.randomUUID(),
-                                        role: "assistant",
-                                        name: "assistant",
-                                        content: "",
-                                        tool_calls: [],
-                                    };
-                                    updatedMessages.push(lastAssistantMessage);
-                                    lastAssistantIndex = updatedMessages.length - 1;
-                                }
-                                // Add or update the tool call
-                                const toolCall = {
-                                    id: streamMessage.data.id,
-                                    displayName: streamMessage.data.displayName,
-                                    function: {
-                                        name: streamMessage.data.function?.name ||
-                                            streamMessage.data.name,
-                                        arguments: streamMessage.data.function?.arguments ||
-                                            streamMessage.data.arguments,
-                                    },
-                                };
-                                // Update or add the tool call to the assistant message
-                                const existingToolCalls = lastAssistantMessage.tool_calls || [];
-                                const existingIndex = existingToolCalls.findIndex((tc) => tc.id === toolCall.id);
-                                let updatedToolCalls;
-                                if (existingIndex >= 0) {
-                                    // Update existing tool call
-                                    updatedToolCalls = [...existingToolCalls];
-                                    updatedToolCalls[existingIndex] = toolCall;
-                                }
-                                else {
-                                    // Add new tool call
-                                    updatedToolCalls = [...existingToolCalls, toolCall];
-                                }
-                                // Update the assistant message with the tool call
-                                updatedMessages[lastAssistantIndex] = {
-                                    ...lastAssistantMessage,
-                                    tool_calls: updatedToolCalls,
-                                };
-                                // Update accumulated response
-                                accumulatedResponse = {
-                                    ...accumulatedResponse,
-                                    messages: updatedMessages,
-                                };
-                                // Trigger UI update to show the tool call
-                                handleResponse(accumulatedResponse, callback, false);
-                            }
-                            break;
-                        case AgentStreamMessageType.ToolResult:
-                            console.log("Tool result received:", streamMessage.data);
-                            if (streamMessage.data &&
-                                typeof streamMessage.data === "object") {
-                                // Find the assistant message and tool call to update with the result
-                                const updatedMessages = [
-                                    ...(accumulatedResponse.messages || []),
-                                ];
-                                let messageUpdated = false;
-                                // Find the assistant message with the matching tool call ID
-                                for (let i = updatedMessages.length - 1; i >= 0; i--) {
-                                    if (updatedMessages[i].role === "assistant" &&
-                                        updatedMessages[i].tool_calls) {
-                                        const toolCalls = updatedMessages[i].tool_calls || [];
-                                        const toolCallIndex = toolCalls.findIndex((tc) => tc.id === streamMessage.data.toolCallId);
-                                        if (toolCallIndex >= 0) {
-                                            // Update the tool call with the result or error
-                                            const updatedToolCalls = [...toolCalls];
-                                            updatedToolCalls[toolCallIndex] = {
-                                                ...updatedToolCalls[toolCallIndex],
-                                                function: {
-                                                    ...updatedToolCalls[toolCallIndex].function,
-                                                    result: streamMessage.data.result,
-                                                    error: streamMessage.data.error,
-                                                },
-                                            };
-                                            // Update the message
-                                            updatedMessages[i] = {
-                                                ...updatedMessages[i],
-                                                tool_calls: updatedToolCalls,
-                                            };
-                                            messageUpdated = true;
-                                            break;
-                                        }
-                                    }
-                                }
-                                // Update accumulated response
-                                accumulatedResponse = {
-                                    ...accumulatedResponse,
-                                    messages: updatedMessages,
-                                };
-                                // Trigger UI update to show the tool result
-                                handleResponse(accumulatedResponse, callback, false);
-                            }
-                            break;
-                        case AgentStreamMessageType.Completed:
-                            if (streamMessage.data &&
-                                typeof streamMessage.data === "object") {
-                                // Final completion data
-                                const finalResponse = {
-                                    messages: accumulatedResponse.messages ||
-                                        streamMessage.data.messages,
-                                    editOperations: streamMessage.data.editOperations ||
-                                        accumulatedResponse.editOperations,
-                                    numInputTokens: streamMessage.data.tokenUsage?.inputTokens ||
-                                        accumulatedResponse.numInputTokens,
-                                    numOutputTokens: streamMessage.data.tokenUsage?.outputTokens ||
-                                        accumulatedResponse.numOutputTokens,
-                                    numCachedTokens: streamMessage.data.tokenUsage?.cachedTokens ||
-                                        accumulatedResponse.numCachedTokens,
-                                    state: "completed",
-                                    agentName: streamMessage.data.agentName,
-                                    error: streamMessage.data.error || accumulatedResponse.error,
-                                    // Add cost fields from backend (try both tokenUsage object and direct properties)
-                                    totalCost: streamMessage.data.totalCost ||
-                                        streamMessage.data.tokenUsage?.totalCost,
-                                    totalInputTokenCost: streamMessage.data.totalInputTokenCost ||
-                                        streamMessage.data.tokenUsage?.inputTokenCost,
-                                    totalOutputTokenCost: streamMessage.data.totalOutputTokenCost ||
-                                        streamMessage.data.tokenUsage?.outputTokenCost,
-                                    totalCachedTokenCost: streamMessage.data.totalCachedTokenCost ||
-                                        streamMessage.data.tokenUsage?.cachedTokenCost,
-                                    totalInputTokens: streamMessage.data.totalInputTokens ||
-                                        streamMessage.data.tokenUsage?.inputTokens,
-                                    totalOutputTokens: streamMessage.data.totalOutputTokens ||
-                                        streamMessage.data.tokenUsage?.outputTokens,
-                                    totalCachedTokens: streamMessage.data.totalCachedTokens ||
-                                        streamMessage.data.tokenUsage?.cachedTokens,
-                                };
-                                completionProcessed = true;
-                                setResponse(finalResponse);
-                                // On completion, just update the internal state and call the final callback
-                                // Don't call handleResponse again as it would duplicate the message
-                                // The Terminal component will clear the streaming response and add it to the message history
-                                const formattedMessages = (finalResponse.messages || []).map((message) => {
-                                    const formattedContent = formatMessageContent(message.content || "");
-                                    return {
-                                        ...message,
-                                        content: message.content || "",
-                                        formattedContent: formattedContent,
-                                        tool_calls: message.tool_calls || [],
-                                    };
-                                });
-                                // Update internal state without triggering a new render via handleResponse
-                                setMessages([...formattedMessages]);
-                                setResponseMessages([...formattedMessages]);
-                                // Only call the terminal callback to mark completion (this will add to history)
-                                callback(_jsx(AiResponseMessage, { messages: formattedMessages, editOperations: finalResponse.editOperations, finished: true, error: finalResponse.error }), true);
-                                // Handle agent name update
-                                if (finalResponse.agentName && onAgentNameUpdate) {
-                                    onAgentNameUpdate(finalResponse.agentName);
-                                }
-                                if (context.callback)
-                                    context.callback(finalResponse);
-                                //editContext?.requestRefresh("immediate");
-                            }
-                            break;
-                        case AgentStreamMessageType.Error:
-                            const errorMessage = streamMessage.error || "Unknown agent error";
-                            console.error("Agent execution error:", errorMessage);
-                            console.log("Displaying error in terminal:", errorMessage);
-                            setTerminalError(errorMessage);
-                            const errorResponse = {
-                                ...accumulatedResponse,
-                                state: "error",
-                                error: errorMessage,
-                            };
-                            setResponse(errorResponse);
-                            // Display the error in the terminal
-                            console.log("Calling handleResponse with error");
-                            handleResponse(errorResponse, callback, true);
-                            // Also try using TerminalService directly as fallback
-                            console.log("Also trying TerminalService.emit");
-                            TerminalService.emit("response", {
-                                text: (_jsx(AiResponseMessage, { messages: [], editOperations: [], finished: true, error: errorMessage })),
-                                type: "response",
-                            });
-                            console.log("Error callback completed");
-                            setIsRunning(false);
-                            abortControllerRef.current = null;
-                            return; // Exit the stream processing
-                        default:
-                            console.log("Unhandled stream message type:", streamMessage.type);
-                            break;
-                    }
-                }, abortController.signal);
-                // If we reach here, the stream ended without a Completed message
-                if (!completionProcessed) {
-                    //    console.log("Stream ended without Completed message, cleaning up");
-                    const finalResponse = {
-                        ...accumulatedResponse,
-                        state: "completed",
-                    };
-                    setResponse(finalResponse);
-                    handleResponse(finalResponse, callback, true);
-                }
-                setIsRunning(false);
-                abortControllerRef.current = null;
-            }
-            catch (streamError) {
-                console.error("Stream connection error:", streamError);
-                const isAbort = streamError?.name === "AbortError" ||
-                    streamError?.message?.toLowerCase?.().includes("abort");
-                if (isAbort) {
-                    const cancelledResponse = {
-                        ...accumulatedResponse,
-                        state: "cancelled",
-                    };
-                    setResponse(cancelledResponse);
-                    handleResponse(cancelledResponse, callback, true);
-                }
-                else {
-                    const errorMessage = streamError instanceof Error
-                        ? streamError.message
-                        : "Unknown stream error";
-                    const errorResponse = {
-                        ...accumulatedResponse,
-                        state: "error",
-                        error: errorMessage,
-                    };
-                    setResponse(errorResponse);
-                    // Display the error in the terminal
-                    callback(_jsx(AiResponseMessage, { messages: accumulatedResponse.messages || [], editOperations: accumulatedResponse.editOperations || [], finished: true, error: errorMessage }), true);
-                }
-                setIsRunning(false);
-                abortControllerRef.current = null;
-            }
-        }
-        catch (error) {
-            console.error("Error starting agent:", error);
-            const errorMessage = error instanceof Error ? error.message : "Unknown error";
-            // Display error in the terminal
-            const errorResponse = {
-                messages: [...messages],
-                editOperations: [],
-                numInputTokens: 0,
-                numOutputTokens: 0,
-                numCachedTokens: 0,
-                state: "error",
-                error: errorMessage,
-            };
-            setResponse(errorResponse);
-            // Show the error in the terminal
-            callback(_jsx(AiResponseMessage, { messages: [], editOperations: [], finished: true, error: errorMessage }), true);
-            setIsRunning(false);
-            abortControllerRef.current = null;
-        }
+        const response = await executePrompt(messages, context, {
+            profileId: activeProfile.id,
+            selection,
+            selectedText,
+            model,
+            sessionId: editContext.sessionId,
+            agentId,
+            addSelectedComponents: true,
+        }, undefined, (response) => {
+            setResponse(response);
+            handleResponse(response, callback, false);
+        });
+        if (response) {
+            handleResponse(response, callback, true);
+            if (context.callback)
+                context.callback(response);
+            editContext?.requestRefresh("immediate");
+        }
+        // if (response?.responseText)
+        //   newMessages.push({
+        //     content: response.responseText,
+        //     role: "assistant",
+        //     name: "assistant",
+        //   });
+        setResponse(response ? response : undefined);
+        // setMessages(newMessages);
     }
-    // Stop button handler to cancel running agent and abort stream
-    const handleStop = async () => {
-        try {
-            if (!isRunning)
-                return;
-            const context = createAiContext({ editContext });
-            await cancelAgent(agentId, context);
-        }
-        catch (e) {
-            // Ignore cancel errors; still abort client-side stream
-        }
-        finally {
-            abortControllerRef.current?.abort();
-        }
-    };
     useEffect(() => {
         TerminalService.on("command", commandHandler);
         return () => {
@@ -954,39 +232,18 @@ export function AiTerminal({ closeButton, createAiContext, defaultProfile, optio
                             setResponseMessages([]);
                             setResponse(undefined);
                             setInitialTerminalMessages(undefined);
-                            setTerminalError(null); // Clear any terminal errors
-                            // Generate a new agentId when clearing the terminal to start fresh
-                            setAgentId(crypto.randomUUID());
-                        }, initialMessages: initialTerminalMessages, infobar: _jsx(AgentCostDisplay, { response: response
-                                ? {
-                                    numInputTokens: response.numInputTokens,
-                                    numOutputTokens: response.numOutputTokens,
-                                    numCachedTokens: response.numCachedTokens,
-                                    totalCost: response.totalCost,
-                                    inputCost: response.totalInputTokenCost,
-                                    outputCost: response.totalOutputTokenCost,
-                                    cachedCost: response.totalCachedTokenCost,
-                                }
-                                : null, totalTokens: response
-                                ? {
-                                    input: response.totalInputTokens || response.numInputTokens,
-                                    output: response.totalOutputTokens ||
-                                        response.numOutputTokens,
-                                    cached: response.totalCachedTokens ||
-                                        response.numCachedTokens,
-                                    totalCost: response.totalCost || 0,
-                                    inputCost: response.totalInputTokenCost || 0,
-                                    outputCost: response.totalOutputTokenCost || 0,
-                                    cachedCost: response.totalCachedTokenCost || 0,
-                                }
-                                : undefined }), prompt: prompt, setPrompt: setPrompt, submitOverride: isRunning ? (_jsx(SimpleIconButton, { icon: _jsx(Square, { size: 16, strokeWidth: 1 }), label: "Stop", onClick: handleStop, disabled: !isRunning })) : undefined, statusbar: _jsxs("div", { className: "flex flex-1 items-center justify-between gap-1", children: [_jsxs(Popover, { open: showPredefined, onOpenChange: setShowPredefined, children: [_jsxs(Tooltip, { delayDuration: 500, children: [_jsx(TooltipTrigger, { asChild: true, children: _jsx(PopoverTrigger, { asChild: true, children: _jsx("a", { className: "ml-1 flex cursor-pointer items-center gap-1 text-xs", children: _jsx(WizardIcon, { className: "text-theme-secondary h-5 w-5" }) }) }) }), _jsx(TooltipContent, { children: "Predefined prompts" })] }), _jsx(PopoverContent, { className: "w-96 p-2", align: "start", side: "top", children: activeProfile?.prompts?.length ? (_jsx("div", { className: "flex max-h-64 flex-col gap-1 overflow-y-auto", children: activeProfile.prompts.map((p, index) => (_jsx("div", { className: "mb-1 cursor-pointer rounded-lg border border-gray-200 p-1.5 text-xs text-gray-700 hover:bg-gray-50", onClick: () => {
-                                                        setPrompt(p.prompt);
-                                                        setShowPredefined(false);
-                                                    }, children: p.title }, index))) })) : (_jsx("div", { className: "text-xs text-gray-500", children: "No predefined prompts available" })) })] }), editContext.selection?.length > 0 && (_jsxs("div", { className: "mr-2 flex items-center text-xs text-red-400", children: [editContext.selection.length, " items selected", _jsx(SimpleIconButton, { icon: "pi pi-times", label: "Clear selection", onClick: () => {
+                        }, initialMessages: initialTerminalMessages, infobar: response?.numInputTokens && response?.numInputTokens > 0 ? (_jsxs("div", { className: "text-right text-gray-400", style: { fontSize: "10px" }, children: ["Tokens in: ", response?.numInputTokens?.toLocaleString(), " out:", " ", response?.numOutputTokens?.toLocaleString(), " ", response?.numCachedTokens
+                                    ? `cached: ${response?.numCachedTokens?.toLocaleString()} `
+                                    : "", response?.state] })) : null, prompt: prompt, setPrompt: setPrompt, statusbar: _jsxs("div", { className: "flex flex-1 items-center justify-between gap-1", children: [_jsxs("a", { className: "ml-1 flex cursor-pointer items-center gap-1 text-xs", onClick: () => {
+                                        setShowPredefined(!showPredefined);
+                                    }, children: [_jsx(WizardIcon, { className: "h-5 w-5" }), "Predefined prompts"] }), editContext.selection?.length > 0 && (_jsxs("div", { className: "mr-2 flex items-center text-xs text-red-400", children: [editContext.selection.length, " items selected", _jsx(SimpleIconButton, { icon: "pi pi-times", label: "Clear selection", onClick: () => {
                                                 editContext.select([]);
-                                            } })] }))] }), toolbar: _jsxs("div", { className: "flex items-stretch gap-1", children: [_jsxs("div", { className: "relative", ref: settingsRef, children: [_jsx(SimpleIconButton, { icon: _jsx(Settings, { size: 16, strokeWidth: 1 }), label: "Settings", onClick: () => setShowSettings(!showSettings) }), showSettings && (_jsxs("div", { className: "absolute top-8 right-0 z-50 flex flex-col gap-2 rounded-lg border border-gray-200 bg-white p-3 shadow-lg", children: [_jsxs("div", { className: "flex flex-col gap-1", children: [_jsx("label", { className: "text-xs font-medium text-gray-700", children: "Profile" }), _jsxs(DropdownMenu, { children: [_jsxs(DropdownMenuTrigger, { className: "flex w-full items-center justify-between rounded-md border border-gray-300 bg-white px-3 py-2 text-xs hover:bg-gray-50 focus:border-blue-500 focus:ring-2 focus:ring-blue-500 focus:outline-none", children: [_jsx("span", { children: activeProfile?.name || "Select profile" }), _jsx(ChevronDown, { size: 16, strokeWidth: 1 })] }), _jsx(DropdownMenuContent, { className: "min-w-[200px]", children: profiles.map((profile) => (_jsx(DropdownMenuItem, { onClick: () => setActiveProfile(profile), className: "cursor-pointer", children: profile.name }, profile.id))) })] })] }), activeProfile && (_jsxs("div", { className: "flex flex-col gap-1", children: [_jsx("label", { className: "text-xs font-medium text-gray-700", children: "Model" }), _jsxs(DropdownMenu, { children: [_jsxs(DropdownMenuTrigger, { className: "flex w-full items-center justify-between rounded-md border border-gray-300 bg-white px-3 py-2 text-xs hover:bg-gray-50 focus:border-blue-500 focus:ring-2 focus:ring-blue-500 focus:outline-none", children: [_jsx("span", { children: activeProfile.models.find((m) => m.id === model)
-                                                                                ?.name || "Select model" }), _jsx(ChevronDown, { size: 16, strokeWidth: 1 })] }), _jsx(DropdownMenuContent, { className: "min-w-[200px]", children: activeProfile.models.map((modelOption) => (_jsx(DropdownMenuItem, { onClick: () => setModel(modelOption.id), className: "cursor-pointer", children: modelOption.name }, modelOption.id))) })] })] }))] }))] }), closeButton] }), commandHandler: (v, callback) => {
+                                            } })] })), showPredefined && (_jsx("div", { className: "absolute right-0 bottom-8 left-0 flex flex-col gap-1 overflow-y-auto bg-white p-3 pb-1 text-sm", children: activeProfile &&
+                                        activeProfile.prompts.map((p, index) => (_jsx("div", { className: "mb-1 cursor-pointer rounded-lg border border-gray-200 p-1.5 text-xs text-gray-700", onClick: () => {
+                                                setPrompt(p.prompt);
+                                                setShowPredefined(false);
+                                            }, children: p.title }, index))) }))] }), toolbar: _jsxs("div", { className: "flex items-stretch gap-1", children: [_jsxs("div", { className: "relative", ref: settingsRef, children: [_jsx(SimpleIconButton, { icon: _jsx(Settings, { size: 16, strokeWidth: 1 }), label: "Settings", onClick: () => setShowSettings(!showSettings) }), showSettings && (_jsxs("div", { className: "absolute top-8 right-0 z-50 flex flex-col gap-2 rounded-lg border border-gray-200 bg-white p-3 shadow-lg", children: [_jsxs("div", { className: "flex flex-col gap-1", children: [_jsx("label", { className: "text-xs font-medium text-gray-700", children: "Profile" }), _jsx(Dropdown, { className: "text-sm", value: activeProfile, onChange: (e) => setActiveProfile(e.value), optionLabel: "name", options: profiles })] }), activeProfile && (_jsxs("div", { className: "flex flex-col gap-1", children: [_jsx("label", { className: "text-xs font-medium text-gray-700", children: "Model" }), _jsx(Dropdown, { className: "text-sm", value: model, onChange: (e) => setModel(e.value), options: activeProfile.models })] }))] }))] }), closeButton] }), commandHandler: (v, callback) => {
                             commandHandler(v, callback);
-                        } }) }), terminalError && (_jsx("div", { className: "bg-opacity-95 absolute inset-0 z-10 flex items-center justify-center bg-white", children: _jsx("div", { className: "mx-4 max-w-md rounded-lg border-l-4 border-red-500 bg-red-50 p-4 shadow-md", children: _jsxs("div", { className: "flex items-start", children: [_jsx("div", { className: "flex-shrink-0", children: _jsx("div", { className: "h-5 w-5 text-red-400", children: "\u26A0\uFE0F" }) }), _jsxs("div", { className: "ml-3 flex-1", children: [_jsx("h3", { className: "text-sm font-medium text-red-800", children: "Agent Error" }), _jsx("p", { className: "mt-1 text-sm text-red-700", children: terminalError }), _jsx("div", { className: "mt-3", children: _jsx("button", { onClick: () => setTerminalError(null), className: "rounded bg-red-100 px-3 py-1 text-xs font-medium text-red-800 hover:bg-red-200", children: "Dismiss" }) })] })] }) }) })), activeProfile?.errorMessage && (_jsx("div", { className: "absolute inset-0 grid items-center justify-center p-2 text-sm text-red-500", children: activeProfile?.errorMessage })), !model && (_jsx("div", { className: "absolute inset-0 grid items-center justify-center text-sm text-gray-400", children: !activeProfile ? "No profile selected" : "No model selected" }))] }) }));
+                        } }) }), activeProfile?.errorMessage && (_jsx("div", { className: "absolute inset-0 grid items-center justify-center p-2 text-sm text-red-500", children: activeProfile?.errorMessage })), !model && (_jsx("div", { className: "absolute inset-0 grid items-center justify-center text-sm text-gray-400", children: !activeProfile ? "No profile selected" : "No model selected" }))] }) }));
 }
 //# sourceMappingURL=AiTerminal.js.map