dexto 1.6.1 → 1.6.2

package/dist/cli/ink-cli/containers/InputContainer.js

@@ -1,643 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * InputContainer Component
- * Smart container for input area - handles submission and state
- *
- * Buffer is passed as prop from parent (useCLIState).
- * No more ref chain - buffer can be accessed directly.
- */
-import { useCallback, useRef, useEffect, useImperativeHandle, forwardRef } from 'react';
-import { InputArea } from '../components/input/InputArea.js';
-import { processStream } from '../services/index.js';
-import { useSoundService } from '../contexts/index.js';
-import { createUserMessage } from '../utils/messageFormatting.js';
-import { generateMessageId } from '../utils/idGenerator.js';
-import { capture } from '../../../analytics/index.js';
-import { getOverlayPresentation } from '../utils/overlayPresentation.js';
-/**
- * Smart container for input area
- * Manages submission, history, and overlay triggers
- */
-export const InputContainer = forwardRef(function InputContainer({ buffer, input, ui, session, initialPrompt, approval, queuedMessages, setInput, setUi, setSession, setMessages, setPendingMessages, setDequeuedBuffer, setQueuedMessages, setApproval, setApprovalQueue, setTodos, agent, inputService, configFilePath, onKeyboardScroll, useStreaming = true, }, ref) {
-    // Track pending session creation to prevent race conditions
-    const sessionCreationPromiseRef = useRef(null);
-    const didAutoSubmitInitialPromptRef = useRef(false);
-    // Sound notification service from context
-    const soundService = useSoundService();
-    // Ref to track autoApproveEdits so processStream can read latest value mid-stream
-    const autoApproveEditsRef = useRef(ui.autoApproveEdits);
-    useEffect(() => {
-        autoApproveEditsRef.current = ui.autoApproveEdits;
-    }, [ui.autoApproveEdits]);
-    // Clear the session creation ref when session is cleared
-    useEffect(() => {
-        if (session.id === null) {
-            sessionCreationPromiseRef.current = null;
-        }
-    }, [session.id]);
-    // Extract text content from ContentPart[]
-    const extractTextFromContent = useCallback((content) => {
-        return content
-            .filter((part) => part.type === 'text')
-            .map((part) => part.text)
-            .join('\n');
-    }, []);
-    // Handle history navigation - set text directly on buffer
-    // Up arrow first edits queued messages (removes from queue), then navigates history
-    const handleHistoryNavigate = useCallback((direction) => {
-        const { history, historyIndex, draftBeforeHistory } = input;
-        if (direction === 'up') {
-            // First check if there are queued messages to edit
-            if (queuedMessages.length > 0 && session.id) {
-                // Get the last queued message
-                const lastQueued = queuedMessages[queuedMessages.length - 1];
-                if (lastQueued) {
-                    // Extract text content and put it in the input
-                    const text = extractTextFromContent(lastQueued.content);
-                    buffer.setText(text);
-                    setInput((prev) => ({ ...prev, value: text }));
-                    // Remove from queue (this will trigger the event and update queuedMessages state)
-                    agent.removeQueuedMessage(session.id, lastQueued.id).catch(() => {
-                        // Silently ignore errors - queue might have been cleared
-                    });
-                    return;
-                }
-            }
-            // Don't navigate history when processing (only queue editing is allowed)
-            if (ui.isProcessing)
-                return;
-            // No queued messages, navigate history
-            if (history.length === 0)
-                return;
-            let newIndex = historyIndex;
-            if (newIndex < 0) {
-                // First time pressing up - save current input as draft
-                const currentText = buffer.text;
-                setInput((prev) => ({
-                    ...prev,
-                    draftBeforeHistory: currentText,
-                    historyIndex: history.length - 1,
-                    value: history[history.length - 1] || '',
-                }));
-                buffer.setText(history[history.length - 1] || '');
-                return;
-            }
-            else if (newIndex > 0) {
-                newIndex = newIndex - 1;
-            }
-            else {
-                return; // Already at oldest
-            }
-            const historyItem = history[newIndex] || '';
-            buffer.setText(historyItem);
-            setInput((prev) => ({ ...prev, value: historyItem, historyIndex: newIndex }));
-        }
-        else {
-            // Down - navigate history (queued messages don't affect down navigation)
-            // Don't navigate history when processing
-            if (ui.isProcessing)
-                return;
-            if (historyIndex < 0)
-                return; // Not navigating history
-            if (historyIndex < history.length - 1) {
-                const newIndex = historyIndex + 1;
-                const historyItem = history[newIndex] || '';
-                buffer.setText(historyItem);
-                setInput((prev) => ({
-                    ...prev,
-                    value: historyItem,
-                    historyIndex: newIndex,
-                }));
-            }
-            else {
-                // At newest history item, restore draft
-                buffer.setText(draftBeforeHistory);
-                setInput((prev) => ({
-                    ...prev,
-                    value: draftBeforeHistory,
-                    historyIndex: -1,
-                    draftBeforeHistory: '',
-                }));
-            }
-        }
-    }, [
-        buffer,
-        input,
-        setInput,
-        queuedMessages,
-        session.id,
-        agent,
-        extractTextFromContent,
-        ui.isProcessing,
-    ]);
-    // Handle overlay triggers
-    // Allow triggers while processing (for queuing), but not during approval
-    // IMPORTANT: Use functional updates to check prev.activeOverlay, not the closure value.
-    // This avoids race conditions when open/close happen in quick succession (React batching).
-    const handleTriggerOverlay = useCallback((trigger) => {
-        if (approval)
-            return;
-        if (trigger === 'close') {
-            // Use functional update to check the ACTUAL current state, not stale closure
-            setUi((prev) => {
-                if (prev.activeOverlay === 'slash-autocomplete' ||
-                    prev.activeOverlay === 'resource-autocomplete') {
-                    return {
-                        ...prev,
-                        activeOverlay: 'none',
-                        mcpWizardServerType: null,
-                    };
-                }
-                return prev;
-            });
-        }
-        else if (trigger === 'slash-autocomplete') {
-            setUi((prev) => ({ ...prev, activeOverlay: 'slash-autocomplete' }));
-        }
-        else if (trigger === 'resource-autocomplete') {
-            setUi((prev) => ({ ...prev, activeOverlay: 'resource-autocomplete' }));
-        }
-    }, [setUi, approval]);
-    // Handle image paste from clipboard
-    const handleImagePaste = useCallback((image) => {
-        // Track image attachment analytics (only if session exists)
-        if (session.id) {
-            capture('dexto_image_attached', {
-                source: 'cli',
-                sessionId: session.id,
-                imageType: image.mimeType,
-                imageSizeBytes: Math.floor(image.data.length * 0.75), // Approx base64 decode
-            });
-        }
-        setInput((prev) => ({
-            ...prev,
-            images: [...prev.images, image],
-        }));
-    }, [setInput, session.id]);
-    // Handle image removal (when placeholder is deleted from text)
-    const handleImageRemove = useCallback((imageId) => {
-        setInput((prev) => ({
-            ...prev,
-            images: prev.images.filter((img) => img.id !== imageId),
-        }));
-    }, [setInput]);
-    // Handle new paste block creation (when large text is pasted)
-    const handlePasteBlock = useCallback((block) => {
-        setInput((prev) => ({
-            ...prev,
-            pastedBlocks: [...prev.pastedBlocks, block],
-            pasteCounter: Math.max(prev.pasteCounter, block.number),
-        }));
-    }, [setInput]);
-    // Handle paste block update (e.g., toggle collapse)
-    const handlePasteBlockUpdate = useCallback((blockId, updates) => {
-        setInput((prev) => ({
-            ...prev,
-            pastedBlocks: prev.pastedBlocks.map((block) => block.id === blockId ? { ...block, ...updates } : block),
-        }));
-    }, [setInput]);
-    // Handle paste block removal (when placeholder is deleted from text)
-    const handlePasteBlockRemove = useCallback((blockId) => {
-        setInput((prev) => ({
-            ...prev,
-            pastedBlocks: prev.pastedBlocks.filter((block) => block.id !== blockId),
-        }));
-    }, [setInput]);
-    // Expand all collapsed paste blocks in a text string
-    const expandPasteBlocks = useCallback((text, blocks) => {
-        let result = text;
-        // Sort blocks by placeholder position descending to avoid offset issues
-        const sortedBlocks = [...blocks].sort((a, b) => {
-            const posA = result.indexOf(a.placeholder);
-            const posB = result.indexOf(b.placeholder);
-            return posB - posA;
-        });
-        for (const block of sortedBlocks) {
-            if (block.isCollapsed) {
-                // Replace placeholder with full text
-                result = result.replace(block.placeholder, block.fullText);
-            }
-        }
-        return result;
-    }, []);
-    // Handle submission
-    // bypassOverlayCheck: skip the overlay check when called programmatically (e.g., from OverlayContainer)
-    const handleSubmit = useCallback(async (value, bypassOverlayCheck = false) => {
-        // Expand all collapsed paste blocks before processing
-        const expandedValue = expandPasteBlocks(value, input.pastedBlocks);
-        const trimmed = expandedValue.trim();
-        if (!trimmed)
-            return;
-        // Auto-queue when agent is processing
-        if (ui.isProcessing && session.id) {
-            // Build content parts for queueing
-            const content = [{ type: 'text', text: trimmed }];
-            // Add images if any
-            for (const img of input.images) {
-                content.push({
-                    type: 'image',
-                    image: img.data,
-                    mimeType: img.mimeType,
-                });
-            }
-            try {
-                await agent.queueMessage(session.id, { content });
-                // Queued messages are displayed via QueuedMessagesDisplay component
-                // (state updated by message:queued event handler in useAgentEvents)
-                // Clear input, update history, and clear images
-                buffer.setText('');
-                setInput((prev) => {
-                    const newHistory = prev.history.length > 0 &&
-                        prev.history[prev.history.length - 1] === trimmed
-                        ? prev.history
-                        : [...prev.history, trimmed].slice(-100);
-                    return {
-                        ...prev,
-                        value: '',
-                        history: newHistory,
-                        historyIndex: -1,
-                        draftBeforeHistory: '',
-                        images: [],
-                        pastedBlocks: [],
-                    };
-                });
-            }
-            catch (error) {
-                setMessages((prev) => [
-                    ...prev,
-                    {
-                        id: generateMessageId('error'),
-                        role: 'system',
-                        content: `Failed to queue message: ${error instanceof Error ? error.message : String(error)}`,
-                        timestamp: new Date(),
-                    },
-                ]);
-            }
-            return;
-        }
-        // Prevent double submission when autocomplete/selector is active
-        // Skip this check when called programmatically (e.g., from OverlayContainer prompt selection)
-        if (!bypassOverlayCheck &&
-            ui.activeOverlay !== 'none' &&
-            ui.activeOverlay !== 'approval') {
-            return;
-        }
-        // Capture images before clearing - we need them for the API call
-        const pendingImages = [...input.images];
-        // Create user message and add it to messages
-        const userMessage = createUserMessage(trimmed);
-        setMessages((prev) => [...prev, userMessage]);
-        // Clear input directly on buffer and update history
-        buffer.setText('');
-        setInput((prev) => {
-            const newHistory = prev.history.length > 0 && prev.history[prev.history.length - 1] === trimmed
-                ? prev.history
-                : [...prev.history, trimmed].slice(-100);
-            return {
-                value: '',
-                history: newHistory,
-                historyIndex: -1,
-                draftBeforeHistory: '',
-                images: [], // Clear images on submit
-                pastedBlocks: [], // Clear paste blocks on submit
-                pasteCounter: prev.pasteCounter, // Keep counter for next session
-            };
-        });
-        // Start processing
-        setUi((prev) => ({
-            ...prev,
-            isProcessing: true,
-            isCancelling: false,
-            activeOverlay: 'none',
-            commandOutput: null,
-            exitWarningShown: false,
-            exitWarningTimestamp: null,
-        }));
-        // Parse and handle command or prompt
-        const parsed = inputService.parseInput(trimmed);
-        // Check if this command should show an interactive overlay
-        if (parsed.type === 'command' && parsed.command) {
-            const { getCommandOverlay } = await import('../utils/commandOverlays.js');
-            const overlay = getCommandOverlay(parsed.command, parsed.args || []);
-            if (overlay) {
-                setUi((prev) => ({
-                    ...prev,
-                    isProcessing: false,
-                    activeOverlay: overlay,
-                }));
-                return;
-            }
-        }
-        if (parsed.type === 'command' && parsed.command) {
-            const { CommandService } = await import('../services/CommandService.js');
-            const commandService = new CommandService();
-            try {
-                const result = await commandService.executeCommand(parsed.command, parsed.args || [], agent, session.id || undefined, configFilePath);
-                if (result.type === 'output' && result.output) {
-                    const output = result.output;
-                    setUi((prev) => ({
-                        ...prev,
-                        activeOverlay: 'command-output',
-                        commandOutput: {
-                            title: `/${parsed.command}`,
-                            content: output,
-                        },
-                    }));
-                }
-                if (result.type === 'styled' && result.styled) {
-                    const { fallbackText } = result.styled;
-                    setUi((prev) => ({
-                        ...prev,
-                        activeOverlay: 'command-output',
-                        commandOutput: {
-                            title: `/${parsed.command}`,
-                            content: fallbackText,
-                        },
-                    }));
-                }
-                // Handle sendMessage - send through normal streaming flow
-                if (result.type === 'sendMessage' && result.messageToSend) {
-                    let currentSessionId = session.id;
-                    if (!currentSessionId) {
-                        if (sessionCreationPromiseRef.current) {
-                            try {
-                                const existingSession = await sessionCreationPromiseRef.current;
-                                currentSessionId = existingSession.id;
-                            }
-                            catch {
-                                sessionCreationPromiseRef.current = null;
-                            }
-                        }
-                        if (!currentSessionId) {
-                            const sessionPromise = agent.createSession();
-                            sessionCreationPromiseRef.current = sessionPromise;
-                            const newSession = await sessionPromise;
-                            currentSessionId = newSession.id;
-                            setSession((prev) => ({
-                                ...prev,
-                                id: currentSessionId,
-                                hasActiveSession: true,
-                            }));
-                        }
-                    }
-                    if (!currentSessionId) {
-                        throw new Error('Failed to create or retrieve session');
-                    }
-                    // Send through normal streaming flow (matches WebUI pattern)
-                    const iterator = await agent.stream(result.messageToSend, currentSessionId);
-                    await processStream(iterator, {
-                        setMessages,
-                        setPendingMessages,
-                        setDequeuedBuffer,
-                        setUi,
-                        setSession,
-                        setQueuedMessages,
-                        setApproval,
-                        setApprovalQueue,
-                    }, {
-                        useStreaming,
-                        autoApproveEditsRef,
-                        eventBus: agent,
-                        setTodos,
-                        ...(soundService && { soundService }),
-                    });
-                    return; // processStream handles UI state
-                }
-                setUi((prev) => ({
-                    ...prev,
-                    isProcessing: false,
-                    isCancelling: false,
-                    isThinking: false,
-                }));
-            }
-            catch (error) {
-                setMessages((prev) => [
-                    ...prev,
-                    {
-                        id: generateMessageId('error'),
-                        role: 'system',
-                        content: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                        timestamp: new Date(),
-                    },
-                ]);
-                setUi((prev) => ({
-                    ...prev,
-                    isProcessing: false,
-                    isCancelling: false,
-                    isThinking: false,
-                }));
-            }
-        }
-        else {
-            try {
-                let currentSessionId = session.id;
-                if (!currentSessionId) {
-                    if (sessionCreationPromiseRef.current) {
-                        try {
-                            const existingSession = await sessionCreationPromiseRef.current;
-                            currentSessionId = existingSession.id;
-                        }
-                        catch {
-                            sessionCreationPromiseRef.current = null;
-                        }
-                    }
-                    if (!currentSessionId) {
-                        const sessionPromise = agent.createSession();
-                        sessionCreationPromiseRef.current = sessionPromise;
-                        const newSession = await sessionPromise;
-                        currentSessionId = newSession.id;
-                        setSession((prev) => ({
-                            ...prev,
-                            id: currentSessionId,
-                            hasActiveSession: true,
-                        }));
-                    }
-                }
-                if (!currentSessionId) {
-                    throw new Error('Failed to create or retrieve session');
-                }
-                const metadata = await agent.getSessionMetadata(currentSessionId);
-                const isFirstMessage = !metadata || metadata.messageCount <= 0;
-                // Build content with images if any
-                let content;
-                // Plan mode injection: prepend plan skill content on first message
-                // The <plan-mode> tags are filtered out by the message renderer so users
-                // don't see the instructions, but the LLM receives them.
-                //
-                // TODO: Consider dropping <plan-mode> content after plan is approved/disabled.
-                // Edge case: user may still need access to plan tools after approval for
-                // progress tracking (checking off tasks). Current approach keeps it simple
-                // by letting the content remain in context - it's not re-injected, just
-                // stays from the first message.
-                let messageText = trimmed;
-                if (ui.planModeActive && !ui.planModeInitialized) {
-                    try {
-                        const planSkill = await agent.resolvePrompt('config:dexto-plan-mode', {});
-                        if (planSkill.text) {
-                            messageText = `<plan-mode>\n${planSkill.text}\n</plan-mode>\n\n${trimmed}`;
-                            // Mark plan mode as initialized after injection
-                            setUi((prev) => ({ ...prev, planModeInitialized: true }));
-                        }
-                    }
-                    catch {
-                        // Plan skill not found - continue without injection
-                        // This can happen if the agent config/image doesn't include `config:dexto-plan-mode`.
-                    }
-                }
-                if (pendingImages.length > 0) {
-                    // Build multimodal content parts
-                    const parts = [];
-                    // Add text part first (with potential plan-mode injection)
-                    parts.push({ type: 'text', text: messageText });
-                    // Add image parts
-                    for (const img of pendingImages) {
-                        parts.push({
-                            type: 'image',
-                            image: img.data,
-                            mimeType: img.mimeType,
-                        });
-                    }
-                    content = parts;
-                }
-                else {
-                    content = messageText;
-                }
-                // Get current LLM config for analytics
-                const llmConfig = agent.getCurrentLLMConfig();
-                // Track message sent analytics
-                capture('dexto_message_sent', {
-                    source: 'cli',
-                    sessionId: currentSessionId,
-                    provider: llmConfig.provider,
-                    model: llmConfig.model,
-                    hasImage: pendingImages.length > 0,
-                    hasFile: false,
-                    messageLength: trimmed.length,
-                });
-                // Use streaming API and process events directly
-                const iterator = await agent.stream(content, currentSessionId);
-                await processStream(iterator, {
-                    setMessages,
-                    setPendingMessages,
-                    setDequeuedBuffer,
-                    setUi,
-                    setSession,
-                    setQueuedMessages,
-                    setApproval,
-                    setApprovalQueue,
-                }, {
-                    useStreaming,
-                    autoApproveEditsRef,
-                    eventBus: agent,
-                    setTodos,
-                    ...(soundService && { soundService }),
-                });
-                if (isFirstMessage) {
-                    agent.generateSessionTitle(currentSessionId).catch(() => {
-                        // Title generation is non-critical - silently ignore failures
-                    });
-                }
-            }
-            catch (error) {
-                setMessages((prev) => [
-                    ...prev,
-                    {
-                        id: generateMessageId('error'),
-                        role: 'system',
-                        content: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                        timestamp: new Date(),
-                    },
-                ]);
-                setUi((prev) => ({
-                    ...prev,
-                    isProcessing: false,
-                    isCancelling: false,
-                    isThinking: false,
-                }));
-            }
-        }
-    }, [
-        buffer,
-        input.images,
-        input.pastedBlocks,
-        expandPasteBlocks,
-        setInput,
-        setUi,
-        setMessages,
-        setPendingMessages,
-        setDequeuedBuffer,
-        setQueuedMessages,
-        setSession,
-        agent,
-        inputService,
-        ui.isProcessing,
-        ui.activeOverlay,
-        ui.planModeActive,
-        ui.planModeInitialized,
-        session.id,
-        useStreaming,
-        soundService,
-    ]);
-    useEffect(() => {
-        if (!initialPrompt || didAutoSubmitInitialPromptRef.current) {
-            return;
-        }
-        didAutoSubmitInitialPromptRef.current = true;
-        handleSubmit(initialPrompt, true).catch((error) => {
-            agent.logger.error('InputContainer initial prompt submission failed', {
-                error,
-                initialPrompt,
-            });
-            setMessages((prev) => [
-                ...prev,
-                {
-                    id: generateMessageId('error'),
-                    role: 'system',
-                    content: `Failed to submit initial prompt: ${error instanceof Error ? error.message : String(error)}`,
-                    timestamp: new Date(),
-                },
-            ]);
-        });
-    }, [agent.logger, handleSubmit, initialPrompt, setMessages]);
-    // Determine if input should be active (not blocked by approval/overlay/history search)
-    // Input stays active for filter-type overlays (so user can keep typing to filter)
-    // Disable for approval prompts, overlays with their own text input, and history search mode
-    const overlaysWithOwnInput = [
-        'mcp-custom-wizard',
-        'custom-model-wizard',
-        'api-key-input',
-        'search',
-        'tool-browser',
-        'prompt-add-wizard',
-        'model-selector',
-        'export-wizard',
-        'marketplace-add',
-    ];
-    const hasOverlayWithOwnInput = overlaysWithOwnInput.includes(ui.activeOverlay);
-    const isHistorySearchActive = ui.historySearch.isActive;
-    const isInputActive = !approval && !hasOverlayWithOwnInput && !isHistorySearchActive;
-    const isInputDisabled = !!approval || hasOverlayWithOwnInput || isHistorySearchActive;
-    // Allow submit when:
-    // - no overlay active
-    // - approval active
-    // Note: slash-autocomplete handles its own Enter key (either executes command or submits raw text)
-    const shouldHandleSubmit = ui.activeOverlay === 'none' || ui.activeOverlay === 'approval';
-    // Allow history navigation when not blocked by approval/overlay
-    // Allow during processing so users can browse previous prompts while agent runs
-    const canNavigateHistory = !approval && ui.activeOverlay === 'none';
-    // Hide the input area when a focused overlay/approval is active.
-    // This matches "full-screen overlay" UX (Claude-style) and prevents extra UI chrome/flicker.
-    const shouldHideInputArea = getOverlayPresentation(ui.activeOverlay, approval) === 'focus';
-    const placeholder = approval
-        ? 'Approval required above...'
-        : 'Type your message or /help for commands';
-    // Expose submit method for external use (e.g., from OverlayContainer)
-    // Pass bypassOverlayCheck=true since programmatic calls should skip the overlay check
-    useImperativeHandle(ref, () => ({
-        submit: (text) => handleSubmit(text, true),
-    }));
-    if (shouldHideInputArea) {
-        return null;
-    }
-    return (_jsx(InputArea, { buffer: buffer, onSubmit: shouldHandleSubmit ? handleSubmit : () => { }, isDisabled: isInputDisabled, isActive: isInputActive, placeholder: placeholder, onHistoryNavigate: canNavigateHistory ? handleHistoryNavigate : undefined, onTriggerOverlay: handleTriggerOverlay, onKeyboardScroll: onKeyboardScroll, imageCount: input.images.length, onImagePaste: handleImagePaste, images: input.images, onImageRemove: handleImageRemove, pastedBlocks: input.pastedBlocks, onPasteBlock: handlePasteBlock, onPasteBlockUpdate: handlePasteBlockUpdate, onPasteBlockRemove: handlePasteBlockRemove, highlightQuery: ui.historySearch.isActive ? ui.historySearch.query : undefined }));
-});

package/dist/cli/ink-cli/containers/OverlayContainer.d.ts

@@ -1,42 +0,0 @@
-/**
- * OverlayContainer Component
- * Smart container for managing all overlays (selectors, autocomplete, approval)
- */
-import React from 'react';
-import type { DextoAgent } from '@dexto/core';
-import type { TextBuffer } from '../components/shared/text-buffer.js';
-import type { Key } from '../hooks/useInputOrchestrator.js';
-import type { Message, UIState, InputState, SessionState } from '../state/types.js';
-import { type ApprovalRequest } from '../components/ApprovalPrompt.js';
-import { InputService } from '../services/InputService.js';
-export interface OverlayContainerHandle {
-    handleInput: (input: string, key: Key) => boolean;
-}
-interface OverlayContainerProps {
-    ui: UIState;
-    input: InputState;
-    session: SessionState;
-    approval: ApprovalRequest | null;
-    setInput: React.Dispatch<React.SetStateAction<InputState>>;
-    setUi: React.Dispatch<React.SetStateAction<UIState>>;
-    setSession: React.Dispatch<React.SetStateAction<SessionState>>;
-    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
-    setApproval: React.Dispatch<React.SetStateAction<ApprovalRequest | null>>;
-    setApprovalQueue: React.Dispatch<React.SetStateAction<ApprovalRequest[]>>;
-    agent: DextoAgent;
-    inputService: InputService;
-    buffer: TextBuffer;
-    /** Source agent config file path (if available) */
-    configFilePath: string | null;
-    /** Callback to refresh static content (clear terminal and force re-render) */
-    refreshStatic?: () => void;
-    /** Callback to submit a prompt command through the normal streaming flow */
-    onSubmitPromptCommand?: (commandText: string) => Promise<void>;
-}
-/**
- * Smart container for managing overlays
- * Handles all modal interactions (selectors, autocomplete, approval)
- */
-export declare const OverlayContainer: React.ForwardRefExoticComponent<OverlayContainerProps & React.RefAttributes<OverlayContainerHandle>>;
-export {};
-//# sourceMappingURL=OverlayContainer.d.ts.map