wave-code 1.0.10 → 1.1.1

package/dist/contexts/useChat.js

@@ -1,993 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useCallback, useRef, useEffect, useState, useMemo, } from "react";
-import { useInput, useStdout } from "ink";
-import { useAppConfig } from "./useAppConfig.js";
-import { Agent, OPERATION_CANCELLED_BY_USER, extractLatestTotalTokens, } from "wave-agent-sdk";
-import { logger } from "../utils/logger.js";
-import { displayUsageSummary } from "../utils/usageSummary.js";
-import { expandLongTextPlaceholders } from "../managers/inputHandlers.js";
-const ChatContext = createContext(null);
-export const useChat = () => {
-    const context = useContext(ChatContext);
-    if (!context) {
-        throw new Error("useChat must be used within ChatProvider");
-    }
-    return context;
-};
-/**
- * Snapshot a SDK message for consumer state. The SDK mutates its internal
- * message blocks in-place BEFORE firing the delta callback (it writes the full
- * accumulated value to the shared block, then computes the chunk delta by
- * slicing the new value). A consumer that pushed the SDK message object by
- * live reference would read the already-updated block and append the delta
- * again — the first delta is double-counted ("LetLet me think..."), affecting
- * reasoning and text content alike. See docs/specs/core/stream-content-updates.md.
- * The clone must be at least one layer deep (message + blocks) so the in-place
- * block mutation never leaks into consumer state.
- */
-const snapshotMessage = (message) => ({
-    ...message,
-    blocks: message.blocks.map((block) => ({ ...block })),
-});
-/**
- * Window-concat throttle for pure-delta streaming updates: chunks arriving
- * within the cooldown window are merged so no delta is lost (a dropped delta
- * would permanently lose content, unlike the accumulated-payload throttle it
- * replaces). Leading edge fires immediately; the trailing edge carries only
- * chunks that arrived within the window. `end` flushes any pending deltas
- * first, then forwards the end signal right away.
- */
-function createStreamingWindowThrottle(fn, wait) {
-    let timer = null;
-    let pending = null;
-    const fire = (stage) => {
-        if (pending) {
-            fn({ ...pending, stage });
-            pending = null;
-        }
-    };
-    const throttled = (params) => {
-        if (params.stage === "end") {
-            // Flush any deltas still pending inside the cooldown window first
-            if (timer) {
-                clearTimeout(timer);
-                timer = null;
-            }
-            fire("streaming");
-            fn(params);
-            return;
-        }
-        if (pending) {
-            pending.chunk += params.chunk;
-        }
-        else {
-            pending = { messageId: params.messageId, chunk: params.chunk };
-        }
-        if (!timer) {
-            // Leading edge: fire the current delta immediately, then reset pending so
-            // the trailing edge only carries chunks arriving within this window
-            fire("streaming");
-            timer = setTimeout(() => {
-                timer = null;
-                fire("streaming");
-            }, wait);
-        }
-    };
-    throttled.cancel = () => {
-        if (timer) {
-            clearTimeout(timer);
-            timer = null;
-        }
-        pending = null;
-    };
-    throttled.flush = () => {
-        if (timer) {
-            clearTimeout(timer);
-            timer = null;
-        }
-        fire("streaming");
-    };
-    return throttled;
-}
-/**
- * Per-tool window-concat throttle for pure-delta tool parameter streaming:
- * `parametersChunk` deltas are accumulated independently per tool block id
- * within the cooldown window, so interleaved multi-tool streams lose no delta
- * (a plain throttle's single last-args slot would drop every earlier tool's
- * deltas, leaving the first tool without streaming parameters). `start` /
- * `running` apply immediately (one-shot snapshots); `end` flushes pending
- * streaming deltas first, then applies the authoritative parameters/result.
- */
-export function createToolStreamingThrottle(fn, wait) {
-    let timer = null;
-    let pending = null;
-    const fire = () => {
-        if (pending && pending.chunks.size > 0) {
-            const { messageId, chunks } = pending;
-            pending = null;
-            for (const [id, chunk] of chunks) {
-                fn({ messageId, id, parametersChunk: chunk, stage: "streaming" });
-            }
-        }
-    };
-    const throttled = (params) => {
-        if (params.stage === "end") {
-            // Flush any deltas still pending inside the cooldown window first
-            if (timer) {
-                clearTimeout(timer);
-                timer = null;
-            }
-            fire();
-            fn(params);
-            return;
-        }
-        if (params.stage === "streaming") {
-            if (!pending) {
-                pending = { messageId: params.messageId, chunks: new Map() };
-            }
-            const prev = pending.chunks.get(params.id) || "";
-            pending.chunks.set(params.id, prev + (params.parametersChunk || ""));
-            if (!timer) {
-                timer = setTimeout(() => {
-                    timer = null;
-                    fire();
-                }, wait);
-            }
-            return;
-        }
-        // start / running — one-shot snapshots applied immediately. Drop this
-        // tool's buffered streaming deltas first: start/running carry the
-        // authoritative parameters, and a pending timer would otherwise fire late
-        // with a stale `streaming` event, regressing this tool block's stage back
-        // to streaming (yellow dot -> gray) mid-execution. Other tools' in-flight
-        // chunks are kept so interleaved multi-tool streaming still accumulates.
-        if (pending) {
-            pending.chunks.delete(params.id);
-            if (pending.chunks.size === 0) {
-                pending = null;
-                if (timer) {
-                    clearTimeout(timer);
-                    timer = null;
-                }
-            }
-        }
-        fn(params);
-    };
-    throttled.cancel = () => {
-        if (timer) {
-            clearTimeout(timer);
-            timer = null;
-        }
-        pending = null;
-    };
-    throttled.flush = () => {
-        if (timer) {
-            clearTimeout(timer);
-            timer = null;
-        }
-        fire();
-    };
-    return throttled;
-}
-export const ChatProvider = ({ children, bypassPermissions, permissionMode: initialPermissionMode, pluginDirs, additionalDirectories, tools, allowedTools, disallowedTools, workdir, worktreeSession, originalCwd, version, model, mcpServers, }) => {
-    const { restoreSessionId, continueLastSession } = useAppConfig();
-    const { stdout } = useStdout();
-    // Message Display State
-    const [isExpanded, setIsExpanded] = useState(false);
-    const isExpandedRef = useRef(isExpanded);
-    const [isTaskListVisible, setIsTaskListVisible] = useState(true);
-    const [isBtwActive, setIsBtwActive] = useState(false);
-    const [messages, setMessages] = useState([]);
-    const [latestTotalTokens, setLatestTotalTokens] = useState(0);
-    const [maxInputTokens, setMaxInputTokens] = useState(200000);
-    // Throttled incremental streaming updaters — 500ms window-concat, the same
-    // interval as the pre-incremental throttledSetMessages. Chunks are pure
-    // deltas: within-window chunks are merged so none is dropped, and
-    // `stage === "end"` flushes pending deltas + applies the end signal
-    // immediately so completion results are never delayed.
-    const throttledContentUpdate = useMemo(() => createStreamingWindowThrottle((params) => {
-        const { messageId, chunk, stage } = params;
-        setMessages((prev) => prev.map((m) => {
-            if (m.id !== messageId)
-                return m;
-            const textBlockIndex = m.blocks.findIndex((b) => b.type === "text");
-            if (textBlockIndex === -1) {
-                return {
-                    ...m,
-                    blocks: [...m.blocks, { type: "text", content: chunk, stage }],
-                };
-            }
-            return {
-                ...m,
-                blocks: m.blocks.map((b, idx) => idx === textBlockIndex && b.type === "text"
-                    ? {
-                        ...b,
-                        content: (b.content || "") + chunk,
-                        stage,
-                    }
-                    : b),
-            };
-        }));
-    }, 500), []);
-    const throttledReasoningUpdate = useMemo(() => createStreamingWindowThrottle((params) => {
-        const { messageId, chunk, stage } = params;
-        setMessages((prev) => prev.map((m) => {
-            if (m.id !== messageId)
-                return m;
-            const reasoningBlockIndex = m.blocks.findIndex((b) => b.type === "reasoning");
-            if (reasoningBlockIndex === -1) {
-                return {
-                    ...m,
-                    blocks: [
-                        ...m.blocks,
-                        { type: "reasoning", content: chunk, stage },
-                    ],
-                };
-            }
-            return {
-                ...m,
-                blocks: m.blocks.map((b, idx) => idx === reasoningBlockIndex && b.type === "reasoning"
-                    ? {
-                        ...b,
-                        content: (b.content || "") + chunk,
-                        stage,
-                    }
-                    : b),
-            };
-        }));
-    }, 500), []);
-    const throttledToolBlockUpdate = useMemo(() => createToolStreamingThrottle((params) => {
-        const { messageId, id: toolBlockId, parametersChunk, ...updates } = params;
-        setMessages((prev) => prev.map((m) => {
-            if (m.id !== messageId)
-                return m;
-            const toolBlockIndex = m.blocks.findIndex((b) => b.type === "tool" && b.id === toolBlockId);
-            if (toolBlockIndex === -1) {
-                return {
-                    ...m,
-                    blocks: [
-                        ...m.blocks,
-                        {
-                            type: "tool",
-                            id: toolBlockId,
-                            name: updates.name || "",
-                            stage: updates.stage || "start",
-                            parameters: (updates.parameters || "") + (parametersChunk || ""),
-                            result: updates.result || "",
-                            ...updates,
-                        },
-                    ],
-                };
-            }
-            return {
-                ...m,
-                blocks: m.blocks.map((b, idx) => idx === toolBlockIndex && b.type === "tool"
-                    ? {
-                        ...b,
-                        ...updates,
-                        // Streaming carries only the delta; append it to the
-                        // accumulated parameters. start/running/end carry the
-                        // authoritative value and replace wholesale.
-                        parameters: parametersChunk
-                            ? (b.parameters || "") + parametersChunk
-                            : updates.parameters !== undefined
-                                ? updates.parameters
-                                : b.parameters,
-                    }
-                    : b),
-            };
-        }));
-    }, 500), []);
-    useEffect(() => {
-        isExpandedRef.current = isExpanded;
-        if (isExpanded) {
-            // Cancel pending throttled updates so the frozen expanded view isn't overwritten
-            throttledContentUpdate.cancel();
-            throttledReasoningUpdate.cancel();
-            throttledToolBlockUpdate.cancel();
-        }
-    }, [
-        isExpanded,
-        throttledContentUpdate,
-        throttledReasoningUpdate,
-        throttledToolBlockUpdate,
-    ]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [sessionId, setSessionId] = useState("");
-    const [isCommandRunning, setIsCommandRunning] = useState(false);
-    const [isCompacting, setIsCompacting] = useState(false);
-    const [currentModel, setCurrentModelState] = useState("");
-    const [configuredModels, setConfiguredModels] = useState([]);
-    const [queuedMessages, setQueuedMessages] = useState([]);
-    // MCP State
-    const [mcpServerStatuses, setMcpServerStatuses] = useState([]);
-    // Background tasks state
-    const [backgroundTasks, setBackgroundTasks] = useState([]);
-    // Workflow runs state
-    const [workflowRuns, setWorkflowRuns] = useState([]);
-    // Tasks state
-    const [tasks, setTasks] = useState([]);
-    // Command state
-    const [slashCommands, setSlashCommands] = useState([]);
-    // Agent definitions (for /agents overlay)
-    const [agentDefinitions, setAgentDefinitions] = useState([]);
-    // Permission state
-    const [permissionMode, setPermissionModeState] = useState(initialPermissionMode ||
-        (bypassPermissions ? "bypassPermissions" : "default"));
-    // Confirmation state with queue-based architecture
-    const [isConfirmationVisible, setIsConfirmationVisible] = useState(false);
-    const [confirmingTool, setConfirmingTool] = useState();
-    const [confirmationQueue, setConfirmationQueue] = useState([]);
-    const [currentConfirmation, setCurrentConfirmation] = useState(null);
-    // Remount state
-    const [remountKey, setRemountKey] = useState(0);
-    // Full terminal clear + remount so Ink's append-only <Static> re-renders.
-    // Used on structural actions (/clear, /compact, rewind, ctrl-o, forceStatic
-    // exit) where stale Static output must not linger on screen.
-    const forceRemount = useCallback(() => {
-        stdout?.write("\u001b[2J\u001b[3J\u001b[0;0H", () => {
-            setRemountKey((prev) => prev + 1);
-        });
-    }, [stdout]);
-    // Status metadata state
-    const [workingDirectory, setWorkingDirectory] = useState("");
-    const agentRef = useRef(null);
-    // Full-list refresh — one-shot pull from the agent, used only for structural
-    // changes (compact/clear/rewind/collapse/init). Streaming updates flow through
-    // the incremental callbacks in initializeAgent below.
-    const refreshMessages = useCallback(() => {
-        if (!isExpandedRef.current && agentRef.current) {
-            const msgs = agentRef.current.messages.map(snapshotMessage);
-            setMessages(msgs);
-            setLatestTotalTokens(extractLatestTotalTokens(msgs));
-        }
-    }, []);
-    // Permission confirmation methods with queue support
-    const showConfirmation = useCallback(async (toolName, toolInput, suggestedPrefix, hidePersistentOption, planContent, permissionMode, warning) => {
-        return new Promise((resolve, reject) => {
-            const queueItem = {
-                toolName,
-                toolInput,
-                suggestedPrefix,
-                hidePersistentOption,
-                planContent,
-                permissionMode,
-                warning,
-                resolver: resolve,
-                reject,
-            };
-            setConfirmationQueue((prev) => [...prev, queueItem]);
-            // processNextConfirmation will be called via useEffect
-        });
-    }, []);
-    // Initialize AI manager
-    const initializeAgent = useCallback(async (restoreSessionIdOverride) => {
-        const effectiveRestoreSessionId = restoreSessionIdOverride ?? restoreSessionId;
-        const callbacks = {
-            // ── Incremental message updates (no full-list pushes) ──────
-            onUserMessageAdded: () => {
-                if (isExpandedRef.current || !agentRef.current)
-                    return;
-                const msgs = agentRef.current.messages;
-                const last = msgs[msgs.length - 1];
-                if (!last || last.role !== "user")
-                    return;
-                setMessages((prev) => prev.some((m) => m.id === last.id)
-                    ? prev
-                    : [...prev, snapshotMessage(last)]);
-            },
-            onAssistantMessageAdded: (messageId) => {
-                if (isExpandedRef.current || !agentRef.current)
-                    return;
-                const msg = agentRef.current.messages.find((m) => m.id === messageId);
-                if (!msg)
-                    return;
-                setMessages((prev) => prev.some((m) => m.id === messageId)
-                    ? prev
-                    : [...prev, snapshotMessage(msg)]);
-            },
-            onAssistantContentUpdated: (params) => {
-                if (isExpandedRef.current)
-                    return;
-                throttledContentUpdate(params);
-            },
-            onAssistantReasoningUpdated: (params) => {
-                if (isExpandedRef.current)
-                    return;
-                throttledReasoningUpdate(params);
-            },
-            onToolBlockUpdated: (params) => {
-                if (isExpandedRef.current)
-                    return;
-                throttledToolBlockUpdate(params);
-                if (params.stage === "end")
-                    throttledToolBlockUpdate.flush();
-            },
-            onErrorBlockAdded: (error) => {
-                if (isExpandedRef.current)
-                    return;
-                setMessages((prev) => {
-                    // Append to the LAST message only if it is an assistant message
-                    // (the current turn's in-flight reply). If the last message is a
-                    // user message, the error belongs BELOW it — create a new
-                    // assistant message instead of polluting the stale assistant from
-                    // an earlier turn (which surfaced the error above the latest
-                    // user message and accumulated it there).
-                    const last = prev[prev.length - 1];
-                    if (last && last.role === "assistant") {
-                        return prev.map((m, idx) => idx === prev.length - 1
-                            ? {
-                                ...m,
-                                blocks: [...m.blocks, { type: "error", content: error }],
-                            }
-                            : m);
-                    }
-                    return [
-                        ...prev,
-                        {
-                            id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
-                            role: "assistant",
-                            timestamp: new Date().toISOString(),
-                            blocks: [{ type: "error", content: error }],
-                        },
-                    ];
-                });
-            },
-            onAddBangMessage: (command, messageId) => {
-                if (isExpandedRef.current)
-                    return;
-                setMessages((prev) => prev.some((m) => m.id === messageId)
-                    ? prev
-                    : [
-                        ...prev,
-                        {
-                            id: messageId,
-                            role: "user",
-                            timestamp: new Date().toISOString(),
-                            blocks: [
-                                {
-                                    type: "bang",
-                                    command,
-                                    output: "",
-                                    stage: "running",
-                                    exitCode: null,
-                                },
-                            ],
-                        },
-                    ]);
-            },
-            onUpdateBangMessage: (command, output, messageId) => {
-                if (isExpandedRef.current)
-                    return;
-                setMessages((prev) => prev.map((m) => m.id === messageId
-                    ? {
-                        ...m,
-                        blocks: m.blocks.map((b, idx) => idx === m.blocks.length - 1 && b.type === "bang"
-                            ? { ...b, command, output }
-                            : b),
-                    }
-                    : m));
-            },
-            onCompleteBangMessage: (command, exitCode, messageId, output) => {
-                if (isExpandedRef.current)
-                    return;
-                setMessages((prev) => prev.map((m) => m.id === messageId
-                    ? {
-                        ...m,
-                        blocks: m.blocks.map((b, idx) => idx === m.blocks.length - 1 && b.type === "bang"
-                            ? {
-                                ...b,
-                                command,
-                                exitCode,
-                                stage: "end",
-                                ...(output !== undefined ? { output } : {}),
-                            }
-                            : b),
-                    }
-                    : m));
-            },
-            onLatestTotalTokensChange: (tokens) => {
-                setLatestTotalTokens(tokens);
-            },
-            onMcpServersChange: (servers) => {
-                setMcpServerStatuses([...servers]);
-            },
-            onSessionIdChange: (sessionId) => {
-                setSessionId(sessionId);
-            },
-            onCompactionStateChange: (isCompactingState) => {
-                setIsCompacting(isCompactingState);
-            },
-            onBackgroundTasksChange: async (tasks) => {
-                setBackgroundTasks([...tasks]);
-                // Also refresh workflow runs since workflows are background tasks
-                const runs = await agentRef.current?.getWorkflowRuns();
-                if (runs)
-                    setWorkflowRuns([...runs]);
-            },
-            onTasksChange: (newTasks) => {
-                setTasks((prev) => {
-                    if (prev.length === newTasks.length &&
-                        prev.every((t, i) => t.id === newTasks[i].id && t.status === newTasks[i].status)) {
-                        return prev;
-                    }
-                    return [...newTasks];
-                });
-            },
-            onPermissionModeChange: (mode) => {
-                setPermissionModeState(mode);
-            },
-            onModelChange: (model) => {
-                setCurrentModelState(model);
-            },
-            onConfiguredModelsChange: (models) => {
-                setConfiguredModels(models);
-            },
-            onLoadingChange: (loading) => {
-                setIsLoading(loading);
-            },
-            onCommandRunningChange: (running) => {
-                setIsCommandRunning(running);
-            },
-            onQueuedMessagesChange: (messages) => {
-                setQueuedMessages([...messages]);
-            },
-        };
-        try {
-            // Create the permission callback inside the try block to access showConfirmation
-            const permissionCallback = async (context) => {
-                try {
-                    return await showConfirmation(context.toolName, context.toolInput, context.suggestedPrefix, context.hidePersistentOption, context.planContent, context.permissionMode, context.warning);
-                }
-                catch {
-                    // If confirmation was cancelled or failed, deny the operation
-                    return {
-                        behavior: "deny",
-                        message: OPERATION_CANCELLED_BY_USER,
-                    };
-                }
-            };
-            const agent = await Agent.create({
-                callbacks,
-                restoreSessionId: effectiveRestoreSessionId,
-                continueLastSession,
-                logger,
-                permissionMode: initialPermissionMode ||
-                    (bypassPermissions ? "bypassPermissions" : undefined),
-                canUseTool: permissionCallback,
-                stream: true,
-                plugins: pluginDirs?.map((path) => ({ type: "local", path })),
-                additionalDirectories,
-                tools,
-                allowedTools,
-                disallowedTools,
-                workdir,
-                worktreeName: worktreeSession?.name,
-                isNewWorktree: worktreeSession?.isNew,
-                model,
-                mcpServers,
-            });
-            agentRef.current = agent;
-            // Inject worktree session into this agent's own DI container so system
-            // prompts and permission checks reflect the CLI -w worktree. This state is
-            // per-session, not process-global (see docs/specs/multi-agent/worktree.md FR-042).
-            if (worktreeSession) {
-                const session = {
-                    originalCwd: originalCwd ?? worktreeSession.repoRoot,
-                    worktreePath: worktreeSession.path,
-                    worktreeBranch: worktreeSession.branch,
-                    worktreeName: worktreeSession.name,
-                    isNew: worktreeSession.isNew,
-                    repoRoot: worktreeSession.repoRoot,
-                };
-                agent.setWorktreeSession(session);
-            }
-            // Get initial state — snapshot the SDK messages (never hold live
-            // references; see snapshotMessage)
-            setSessionId(agent.sessionId);
-            setMessages(agent.messages.map(snapshotMessage));
-            setIsLoading(agent.isLoading);
-            setLatestTotalTokens(extractLatestTotalTokens(agent.messages));
-            setIsCommandRunning(agent.isCommandRunning);
-            setIsCompacting(agent.isCompacting);
-            setPermissionModeState(agent.getPermissionMode());
-            setWorkingDirectory(agent.workingDirectory);
-            setCurrentModelState(agent.getModelConfig().model || "");
-            setConfiguredModels(agent.getConfiguredModels());
-            setMaxInputTokens(agent.getMaxInputTokens());
-            // Get initial MCP servers state
-            const initialMcpServers = agent.getMcpServers?.() || [];
-            setMcpServerStatuses(initialMcpServers);
-            // Get initial commands
-            const agentSlashCommands = agent.getSlashCommands?.() || [];
-            setSlashCommands(agentSlashCommands);
-            // Get initial agent definitions
-            const initialAgentDefinitions = agent.getSubagentConfigurations?.() || [];
-            setAgentDefinitions(initialAgentDefinitions);
-        }
-        catch (error) {
-            console.error("Failed to initialize AI manager:", error);
-        }
-    }, [
-        restoreSessionId,
-        continueLastSession,
-        bypassPermissions,
-        showConfirmation,
-        pluginDirs,
-        additionalDirectories,
-        tools,
-        allowedTools,
-        disallowedTools,
-        workdir,
-        worktreeSession,
-        originalCwd,
-        model,
-        initialPermissionMode,
-        throttledContentUpdate,
-        throttledReasoningUpdate,
-        throttledToolBlockUpdate,
-        mcpServers,
-    ]);
-    // Recreate agent (e.g. after plugin install) — destroys current agent and reinitializes
-    const recreateAgent = useCallback(() => {
-        const currentSessionId = agentRef.current?.sessionId;
-        if (agentRef.current) {
-            try {
-                agentRef.current.destroy();
-            }
-            catch {
-                // Ignore destroy errors
-            }
-        }
-        agentRef.current = null;
-        setMessages([]);
-        setMcpServerStatuses([]);
-        setSlashCommands([]);
-        setAgentDefinitions([]);
-        setSessionId("");
-        setIsLoading(false);
-        setLatestTotalTokens(0);
-        setMaxInputTokens(200000);
-        setIsCommandRunning(false);
-        setIsCompacting(false);
-        if (currentSessionId) {
-            initializeAgent(currentSessionId);
-        }
-    }, [initializeAgent]);
-    // Run initial agent creation
-    useEffect(() => {
-        initializeAgent();
-    }, [initializeAgent]);
-    // Cleanup on unmount
-    useEffect(() => {
-        return () => {
-            throttledContentUpdate.cancel();
-            throttledReasoningUpdate.cancel();
-            throttledToolBlockUpdate.cancel();
-            if (agentRef.current) {
-                try {
-                    // Display usage summary before cleanup
-                    const usages = agentRef.current.usages;
-                    const sessionFilePath = agentRef.current.sessionFilePath;
-                    displayUsageSummary(usages, sessionFilePath);
-                }
-                catch {
-                    // Silently ignore usage summary errors during cleanup
-                }
-                agentRef.current.destroy();
-            }
-        };
-    }, [
-        throttledContentUpdate,
-        throttledReasoningUpdate,
-        throttledToolBlockUpdate,
-    ]);
-    // Trigger WorktreeRemove hook BEFORE agent destruction
-    const triggerWorktreeRemoveHook = useCallback(async (worktreePath) => {
-        await agentRef.current?.triggerWorktreeRemoveHook(worktreePath);
-    }, []);
-    // Send message function (including judgment logic)
-    const sendMessage = useCallback(async (content, images, longTextMap) => {
-        // Check if there's content to send (text content or image attachments)
-        const hasTextContent = content.trim();
-        const hasImageAttachments = images && images.length > 0;
-        if (!hasTextContent && !hasImageAttachments)
-            return;
-        try {
-            const expandedContent = longTextMap
-                ? expandLongTextPlaceholders(content, longTextMap)
-                : content;
-            // Handle bash mode - check if it's a bash command (starts with ! and only one line)
-            if (expandedContent.startsWith("!") &&
-                !expandedContent.includes("\n") &&
-                !hasImageAttachments) {
-                const command = expandedContent.substring(1).trim();
-                if (command) {
-                    await agentRef.current?.bang(command);
-                    return;
-                }
-            }
-            try {
-                await agentRef.current?.sendMessage(expandedContent, images);
-            }
-            catch (error) {
-                console.error("Failed to send message:", error);
-            }
-        }
-        catch (error) {
-            console.error("Failed to send message:", error);
-        }
-    }, []);
-    const askBtw = useCallback(async (question, abortSignal, onContent) => {
-        if (!agentRef.current) {
-            throw new Error("Agent not initialized");
-        }
-        return await agentRef.current.askBtw(question, abortSignal, onContent);
-    }, []);
-    const clearMessages = useCallback(async () => {
-        await agentRef.current?.clearMessages();
-        refreshMessages();
-        forceRemount();
-    }, [refreshMessages, forceRemount]);
-    const compact = useCallback(async (instructions) => {
-        await agentRef.current?.compact(instructions);
-        refreshMessages();
-        forceRemount();
-    }, [refreshMessages, forceRemount]);
-    // /add-dir: add a directory to the session Safe Zone (session-level, with
-    // optional --remember persistence). Bare command shows usage + current list.
-    const addDir = useCallback(async (args) => {
-        const agent = agentRef.current;
-        if (!agent)
-            return;
-        // Show the result as a UI-only assistant text message (same display path
-        // as error blocks; not persisted to session history).
-        const showResult = (content) => {
-            setMessages((prev) => [
-                ...prev,
-                {
-                    id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
-                    role: "assistant",
-                    timestamp: new Date().toISOString(),
-                    blocks: [{ type: "text", content, stage: "end" }],
-                },
-            ]);
-        };
-        const rawArgs = (args ?? "").trim();
-        if (!rawArgs) {
-            const dirs = agent.getAdditionalDirectories();
-            const list = dirs.length > 0
-                ? dirs.map((dir) => `  - ${dir}`).join("\n")
-                : "  (none)";
-            showResult(`Usage: /add-dir <path> [--remember]\n\nAdditional working directories:\n${list}`);
-            return;
-        }
-        const remember = rawArgs.includes("--remember");
-        const dir = rawArgs.replace("--remember", "").trim();
-        if (!dir) {
-            showResult("Usage: /add-dir <path> [--remember]");
-            return;
-        }
-        await agent.addAdditionalDirectory(dir, { remember });
-        showResult(`Added ${dir} to the session Safe Zone${remember ? " (remembered)" : ""}.`);
-    }, []);
-    // Unified interrupt method, interrupt both AI messages and command execution
-    const abortMessage = useCallback(() => {
-        agentRef.current?.abortMessage();
-    }, []);
-    const recallQueuedMessage = useCallback(() => {
-        return agentRef.current?.recallQueuedMessage() ?? null;
-    }, []);
-    const removeQueuedMessageById = useCallback((id) => {
-        return agentRef.current?.removeQueuedMessageById(id) ?? false;
-    }, []);
-    // Permission management methods
-    const setPermissionMode = useCallback((mode) => {
-        setPermissionModeState((prev) => {
-            if (prev === mode)
-                return prev;
-            if (agentRef.current && agentRef.current.getPermissionMode() !== mode) {
-                agentRef.current.setPermissionMode(mode);
-            }
-            return mode;
-        });
-    }, []);
-    // MCP management methods - delegate to Agent
-    const connectMcpServer = useCallback(async (serverName) => {
-        return (await agentRef.current?.connectMcpServer(serverName)) ?? false;
-    }, []);
-    const disconnectMcpServer = useCallback(async (serverName) => {
-        return (await agentRef.current?.disconnectMcpServer(serverName)) ?? false;
-    }, []);
-    // Background task management methods - delegate to Agent
-    const getBackgroundTaskOutput = useCallback((taskId) => {
-        if (!agentRef.current)
-            return null;
-        return agentRef.current.getBackgroundTaskOutput(taskId);
-    }, []);
-    const stopBackgroundTask = useCallback((taskId) => {
-        if (!agentRef.current)
-            return false;
-        return agentRef.current.stopBackgroundTask(taskId);
-    }, []);
-    const stopWorkflowRun = useCallback((runId) => {
-        agentRef.current?.stopWorkflowRun(runId);
-    }, []);
-    const hasSlashCommand = useCallback((commandId) => {
-        if (!agentRef.current)
-            return false;
-        return agentRef.current.hasSlashCommand(commandId);
-    }, []);
-    // Queue processing helper
-    const processNextConfirmation = useCallback(() => {
-        if (confirmationQueue.length > 0 && !isConfirmationVisible) {
-            const next = confirmationQueue[0];
-            setCurrentConfirmation(next);
-            setConfirmingTool({
-                name: next.toolName,
-                input: next.toolInput,
-                suggestedPrefix: next.suggestedPrefix,
-                hidePersistentOption: next.hidePersistentOption,
-                planContent: next.planContent,
-                permissionMode: next.permissionMode,
-                warning: next.warning,
-            });
-            setIsConfirmationVisible(true);
-            setConfirmationQueue((prev) => prev.slice(1));
-        }
-    }, [confirmationQueue, isConfirmationVisible]);
-    // Process queue when queue changes or confirmation is hidden
-    useEffect(() => {
-        processNextConfirmation();
-    }, [processNextConfirmation]);
-    const hideConfirmation = useCallback(() => {
-        setIsConfirmationVisible(false);
-        setConfirmingTool(undefined);
-        setCurrentConfirmation(null);
-    }, []);
-    const handleConfirmationDecision = useCallback((decision) => {
-        if (currentConfirmation) {
-            currentConfirmation.resolver(decision);
-        }
-        hideConfirmation();
-    }, [currentConfirmation, hideConfirmation]);
-    const handleConfirmationCancel = useCallback(() => {
-        if (currentConfirmation) {
-            currentConfirmation.reject();
-        }
-        agentRef.current?.abortMessage();
-        hideConfirmation();
-    }, [currentConfirmation, hideConfirmation]);
-    const backgroundCurrentTask = useCallback(() => {
-        agentRef.current?.backgroundCurrentTask();
-    }, []);
-    const handleRewindSelect = useCallback(async (index) => {
-        if (agentRef.current) {
-            try {
-                await agentRef.current.truncateHistory(index);
-                refreshMessages();
-                forceRemount();
-            }
-            catch (error) {
-                logger.error("Failed to rewind:", error);
-            }
-        }
-    }, [forceRemount, refreshMessages]);
-    const getFullMessageThread = useCallback(async () => {
-        if (agentRef.current) {
-            return await agentRef.current.getFullMessageThread();
-        }
-        return { messages: [], sessionIds: [] };
-    }, []);
-    const getGatewayConfig = useCallback(() => {
-        if (!agentRef.current) {
-            return { baseURL: "" };
-        }
-        return agentRef.current.getGatewayConfig();
-    }, []);
-    const getModelConfig = useCallback(() => {
-        if (!agentRef.current) {
-            return { model: "", fastModel: "" };
-        }
-        return agentRef.current.getModelConfig();
-    }, []);
-    const getConfiguredModels = useCallback(() => {
-        if (!agentRef.current) {
-            return [];
-        }
-        return agentRef.current.getConfiguredModels();
-    }, []);
-    const setModel = useCallback((model) => {
-        if (agentRef.current) {
-            agentRef.current.setModel(model);
-            setCurrentModelState(model);
-        }
-    }, []);
-    // Listen for Ctrl+O hotkey to toggle collapse/expand state and ESC to cancel confirmation
-    useInput((input, key) => {
-        if (key.ctrl && input === "o") {
-            // Use ref to get the current value to avoid stale closure
-            const nextExpanded = !isExpandedRef.current;
-            setIsExpanded(nextExpanded);
-            isExpandedRef.current = nextExpanded;
-            if (nextExpanded) {
-                // Transitioning to EXPANDED: Freeze the current view
-                // Incremental updates are skipped while expanded (isExpandedRef guard)
-            }
-            else {
-                // Transitioning to COLLAPSED: Restore from agent's actual state
-                refreshMessages();
-            }
-            // Force remount to ensure Static items re-render
-            forceRemount();
-        }
-        if (key.ctrl && input === "t") {
-            setIsTaskListVisible((prev) => !prev);
-        }
-        // Handle ESC key to cancel confirmation
-        if (key.escape && isConfirmationVisible) {
-            handleConfirmationCancel();
-        }
-    });
-    const contextValue = {
-        messages,
-        isLoading,
-        isCommandRunning,
-        isExpanded,
-        isTaskListVisible,
-        setIsTaskListVisible,
-        isBtwActive,
-        setIsBtwActive,
-        queuedMessages,
-        sessionId,
-        sendMessage,
-        askBtw,
-        clearMessages,
-        compact,
-        addDir,
-        abortMessage,
-        recallQueuedMessage,
-        removeQueuedMessageById,
-        latestTotalTokens,
-        maxInputTokens,
-        currentModel,
-        configuredModels,
-        getConfiguredModels,
-        setModel,
-        isCompacting,
-        mcpServers: mcpServerStatuses,
-        connectMcpServer,
-        disconnectMcpServer,
-        backgroundTasks,
-        workflowRuns,
-        stopWorkflowRun,
-        tasks,
-        getBackgroundTaskOutput,
-        stopBackgroundTask,
-        slashCommands,
-        hasSlashCommand,
-        agentDefinitions,
-        permissionMode,
-        setPermissionMode,
-        isConfirmationVisible,
-        hasPendingConfirmations: confirmationQueue.length > 0,
-        confirmingTool,
-        showConfirmation,
-        hideConfirmation,
-        handleConfirmationDecision,
-        handleConfirmationCancel,
-        backgroundCurrentTask,
-        remountKey,
-        forceRemount,
-        handleRewindSelect,
-        getFullMessageThread,
-        getGatewayConfig,
-        getModelConfig,
-        workingDirectory,
-        version,
-        workdir,
-        recreateAgent,
-        triggerWorktreeRemoveHook,
-    };
-    return (_jsx(ChatContext.Provider, { value: contextValue, children: children }));
-};