@dexto/tui 1.6.2

package/dist/containers/OverlayContainer.cjs

@@ -0,0 +1,2372 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var OverlayContainer_exports = {};
+__export(OverlayContainer_exports, {
+  OverlayContainer: () => OverlayContainer
+});
+module.exports = __toCommonJS(OverlayContainer_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = __toESM(require("react"), 1);
+var import_ink = require("ink");
+var import_path = __toESM(require("path"), 1);
+var import_core = require("@dexto/core");
+var import_ApprovalPrompt = require("../components/ApprovalPrompt.js");
+var import_SlashCommandAutocomplete = require("../components/SlashCommandAutocomplete.js");
+var import_ResourceAutocomplete = __toESM(require("../components/ResourceAutocomplete.js"), 1);
+var import_ModelSelectorRefactored = __toESM(require("../components/overlays/ModelSelectorRefactored.js"), 1);
+var import_ReasoningOverlay = require("../components/overlays/ReasoningOverlay.js");
+var import_SessionSelectorRefactored = __toESM(require("../components/overlays/SessionSelectorRefactored.js"), 1);
+var import_LogLevelSelector = __toESM(require("../components/overlays/LogLevelSelector.js"), 1);
+var import_StreamSelector = __toESM(require("../components/overlays/StreamSelector.js"), 1);
+var import_SoundsSelector = __toESM(require("../components/overlays/SoundsSelector.js"), 1);
+var import_ToolBrowser = __toESM(require("../components/overlays/ToolBrowser.js"), 1);
+var import_CommandOutputOverlay = require("../components/overlays/CommandOutputOverlay.js");
+var import_McpServerList = __toESM(require("../components/overlays/McpServerList.js"), 1);
+var import_McpServerActions = __toESM(require("../components/overlays/McpServerActions.js"), 1);
+var import_McpAddChoice = __toESM(require("../components/overlays/McpAddChoice.js"), 1);
+var import_McpAddSelector = __toESM(require("../components/overlays/McpAddSelector.js"), 1);
+var import_SessionSubcommandSelector = __toESM(require("../components/overlays/SessionSubcommandSelector.js"), 1);
+var import_McpCustomTypeSelector = __toESM(require("../components/overlays/McpCustomTypeSelector.js"), 1);
+var import_McpCustomWizard = __toESM(require("../components/overlays/McpCustomWizard.js"), 1);
+var import_CustomModelWizard = __toESM(require("../components/overlays/CustomModelWizard.js"), 1);
+var import_agent_management = require("@dexto/agent-management");
+var import_ApiKeyInput = __toESM(require("../components/overlays/ApiKeyInput.js"), 1);
+var import_SearchOverlay = __toESM(require("../components/overlays/SearchOverlay.js"), 1);
+var import_PromptList = __toESM(require("../components/overlays/PromptList.js"), 1);
+var import_PromptAddChoice = __toESM(require("../components/overlays/PromptAddChoice.js"), 1);
+var import_PromptAddWizard = __toESM(require("../components/overlays/PromptAddWizard.js"), 1);
+var import_PromptDeleteSelector = __toESM(require("../components/overlays/PromptDeleteSelector.js"), 1);
+var import_SessionRenameOverlay = __toESM(require("../components/overlays/SessionRenameOverlay.js"), 1);
+var import_ContextStatsOverlay = __toESM(require("../components/overlays/ContextStatsOverlay.js"), 1);
+var import_ExportWizard = __toESM(require("../components/overlays/ExportWizard.js"), 1);
+var import_PluginManager = __toESM(require("../components/overlays/PluginManager.js"), 1);
+var import_PluginList = __toESM(require("../components/overlays/PluginList.js"), 1);
+var import_PluginActions = __toESM(require("../components/overlays/PluginActions.js"), 1);
+var import_MarketplaceBrowser = __toESM(require("../components/overlays/MarketplaceBrowser.js"), 1);
+var import_MarketplaceAddPrompt = __toESM(require("../components/overlays/MarketplaceAddPrompt.js"), 1);
+var import_LoginOverlay = __toESM(require("../components/overlays/LoginOverlay.js"), 1);
+var import_LogoutOverlay = __toESM(require("../components/overlays/LogoutOverlay.js"), 1);
+var import_core2 = require("@dexto/core");
+var import_messageFormatting = require("../utils/messageFormatting.js");
+var import_idGenerator = require("../utils/idGenerator.js");
+var import_host = require("../host/index.js");
+var import_FocusOverlayFrame = require("../components/shared/FocusOverlayFrame.js");
+var import_overlayPresentation = require("../utils/overlayPresentation.js");
+function isLLMProvider(value) {
+  if (typeof value !== "string") return false;
+  for (const provider of import_core2.LLM_PROVIDERS) {
+    if (provider === value) return true;
+  }
+  return false;
+}
+function getProviderFromIssueContext(context) {
+  if (typeof context !== "object" || context === null) return null;
+  const provider = Reflect.get(context, "provider");
+  return isLLMProvider(provider) ? provider : null;
+}
+function buildReasoningSwitchUpdate(provider, model, reasoningVariant) {
+  if (reasoningVariant === void 0) {
+    return {};
+  }
+  const defaultVariant = (0, import_core2.getReasoningProfile)(provider, model).defaultVariant;
+  if (defaultVariant !== void 0 && reasoningVariant === defaultVariant) {
+    return { reasoning: null };
+  }
+  return { reasoning: { variant: reasoningVariant } };
+}
+const OverlayContainer = (0, import_react.forwardRef)(
+  function OverlayContainer2({
+    ui,
+    input,
+    session,
+    approval,
+    setInput,
+    setUi,
+    setSession,
+    setMessages,
+    setApproval,
+    setApprovalQueue,
+    agent,
+    inputService,
+    buffer,
+    configFilePath,
+    refreshStatic,
+    onSubmitPromptCommand
+  }, ref) {
+    const approvalRef = (0, import_react.useRef)(null);
+    const slashAutocompleteRef = (0, import_react.useRef)(null);
+    const resourceAutocompleteRef = (0, import_react.useRef)(null);
+    const modelSelectorRef = (0, import_react.useRef)(null);
+    const reasoningOverlayRef = (0, import_react.useRef)(null);
+    const sessionSelectorRef = (0, import_react.useRef)(null);
+    const logLevelSelectorRef = (0, import_react.useRef)(null);
+    const streamSelectorRef = (0, import_react.useRef)(null);
+    const soundsSelectorRef = (0, import_react.useRef)(null);
+    const toolBrowserRef = (0, import_react.useRef)(null);
+    const commandOutputRef = (0, import_react.useRef)(null);
+    const mcpServerListRef = (0, import_react.useRef)(null);
+    const mcpServerActionsRef = (0, import_react.useRef)(null);
+    const mcpAddChoiceRef = (0, import_react.useRef)(null);
+    const mcpAddSelectorRef = (0, import_react.useRef)(null);
+    const mcpCustomTypeSelectorRef = (0, import_react.useRef)(null);
+    const mcpCustomWizardRef = (0, import_react.useRef)(null);
+    const customModelWizardRef = (0, import_react.useRef)(null);
+    const sessionSubcommandSelectorRef = (0, import_react.useRef)(null);
+    const apiKeyInputRef = (0, import_react.useRef)(null);
+    const loginOverlayRef = (0, import_react.useRef)(null);
+    const logoutOverlayRef = (0, import_react.useRef)(null);
+    const searchOverlayRef = (0, import_react.useRef)(null);
+    const promptListRef = (0, import_react.useRef)(null);
+    const promptAddChoiceRef = (0, import_react.useRef)(null);
+    const promptAddWizardRef = (0, import_react.useRef)(null);
+    const promptDeleteSelectorRef = (0, import_react.useRef)(null);
+    const sessionRenameRef = (0, import_react.useRef)(null);
+    const contextStatsRef = (0, import_react.useRef)(null);
+    const exportWizardRef = (0, import_react.useRef)(null);
+    const pluginManagerRef = (0, import_react.useRef)(null);
+    const pluginListRef = (0, import_react.useRef)(null);
+    const pluginActionsRef = (0, import_react.useRef)(null);
+    const marketplaceBrowserRef = (0, import_react.useRef)(null);
+    const [selectedPlugin, setSelectedPlugin] = (0, import_react.useState)(null);
+    const marketplaceAddPromptRef = (0, import_react.useRef)(null);
+    const getConfigFilePathOrWarn = (0, import_react.useCallback)(
+      (action) => {
+        if (configFilePath) {
+          return configFilePath;
+        }
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u26A0\uFE0F Cannot ${action}: this agent is not file-backed (no config path).`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+        return null;
+      },
+      [configFilePath, setMessages]
+    );
+    (0, import_react.useImperativeHandle)(
+      ref,
+      () => ({
+        handleInput: (inputStr, key) => {
+          if (approval && approvalRef.current) {
+            return approvalRef.current.handleInput(inputStr, key);
+          }
+          switch (ui.activeOverlay) {
+            case "slash-autocomplete":
+              return slashAutocompleteRef.current?.handleInput(inputStr, key) ?? false;
+            case "resource-autocomplete":
+              return resourceAutocompleteRef.current?.handleInput(inputStr, key) ?? false;
+            case "model-selector":
+              return modelSelectorRef.current?.handleInput(inputStr, key) ?? false;
+            case "reasoning":
+              return reasoningOverlayRef.current?.handleInput(inputStr, key) ?? false;
+            case "session-selector":
+              return sessionSelectorRef.current?.handleInput(inputStr, key) ?? false;
+            case "log-level-selector":
+              return logLevelSelectorRef.current?.handleInput(inputStr, key) ?? false;
+            case "stream-selector":
+              return streamSelectorRef.current?.handleInput(inputStr, key) ?? false;
+            case "sounds-selector":
+              return soundsSelectorRef.current?.handleInput(inputStr, key) ?? false;
+            case "tool-browser":
+              return toolBrowserRef.current?.handleInput(inputStr, key) ?? false;
+            case "command-output":
+              return commandOutputRef.current?.handleInput(inputStr, key) ?? false;
+            case "mcp-server-list":
+              return mcpServerListRef.current?.handleInput(inputStr, key) ?? false;
+            case "mcp-server-actions":
+              return mcpServerActionsRef.current?.handleInput(inputStr, key) ?? false;
+            case "mcp-add-choice":
+              return mcpAddChoiceRef.current?.handleInput(inputStr, key) ?? false;
+            case "mcp-add-selector":
+              return mcpAddSelectorRef.current?.handleInput(inputStr, key) ?? false;
+            case "mcp-custom-type-selector":
+              return mcpCustomTypeSelectorRef.current?.handleInput(inputStr, key) ?? false;
+            case "mcp-custom-wizard":
+              return mcpCustomWizardRef.current?.handleInput(inputStr, key) ?? false;
+            case "custom-model-wizard":
+              return customModelWizardRef.current?.handleInput(inputStr, key) ?? false;
+            case "session-subcommand-selector":
+              return sessionSubcommandSelectorRef.current?.handleInput(inputStr, key) ?? false;
+            case "api-key-input":
+              return apiKeyInputRef.current?.handleInput(inputStr, key) ?? false;
+            case "login":
+              return loginOverlayRef.current?.handleInput(inputStr, key) ?? false;
+            case "logout":
+              return logoutOverlayRef.current?.handleInput(inputStr, key) ?? false;
+            case "search":
+              return searchOverlayRef.current?.handleInput(inputStr, key) ?? false;
+            case "prompt-list":
+              return promptListRef.current?.handleInput(inputStr, key) ?? false;
+            case "prompt-add-choice":
+              return promptAddChoiceRef.current?.handleInput(inputStr, key) ?? false;
+            case "prompt-add-wizard":
+              return promptAddWizardRef.current?.handleInput(inputStr, key) ?? false;
+            case "prompt-delete-selector":
+              return promptDeleteSelectorRef.current?.handleInput(inputStr, key) ?? false;
+            case "session-rename":
+              return sessionRenameRef.current?.handleInput(inputStr, key) ?? false;
+            case "context-stats":
+              return contextStatsRef.current?.handleInput(inputStr, key) ?? false;
+            case "export-wizard":
+              return exportWizardRef.current?.handleInput(inputStr, key) ?? false;
+            case "plugin-manager":
+              return pluginManagerRef.current?.handleInput(inputStr, key) ?? false;
+            case "plugin-list":
+              return pluginListRef.current?.handleInput(inputStr, key) ?? false;
+            case "plugin-actions":
+              return pluginActionsRef.current?.handleInput(inputStr, key) ?? false;
+            case "marketplace-browser":
+              return marketplaceBrowserRef.current?.handleInput(inputStr, key) ?? false;
+            case "marketplace-add":
+              return marketplaceAddPromptRef.current?.handleInput(inputStr, key) ?? false;
+            default:
+              return false;
+          }
+        }
+      }),
+      [approval, ui.activeOverlay]
+    );
+    const completeApproval = (0, import_react.useCallback)(() => {
+      setApprovalQueue((queue) => {
+        if (queue.length > 0) {
+          const [next, ...rest] = queue;
+          setApproval(next);
+          setUi((prev) => ({ ...prev, activeOverlay: "approval" }));
+          return rest;
+        } else {
+          setApproval(null);
+          setUi((prev) => ({ ...prev, activeOverlay: "none" }));
+          return [];
+        }
+      });
+    }, [setApproval, setApprovalQueue, setUi]);
+    const handleApprove = (0, import_react.useCallback)(
+      (options) => {
+        if (!approval) return;
+        if (options.enableAcceptEditsMode) {
+          setUi((prev) => ({ ...prev, autoApproveEdits: true }));
+        }
+        const toolName = approval.metadata.toolName;
+        if (toolName === "plan_create" || toolName === "plan_review") {
+          setUi((prev) => ({
+            ...prev,
+            planModeActive: false,
+            planModeInitialized: false
+          }));
+        }
+        agent.emit("approval:response", {
+          approvalId: approval.approvalId,
+          status: import_core.ApprovalStatus.APPROVED,
+          sessionId: approval.sessionId,
+          data: {
+            rememberChoice: options.rememberChoice,
+            rememberPattern: options.rememberPattern,
+            formData: options.formData,
+            rememberDirectory: options.rememberDirectory
+          }
+        });
+        completeApproval();
+      },
+      [approval, agent, completeApproval, setUi]
+    );
+    const handleDeny = (0, import_react.useCallback)(
+      (feedback) => {
+        if (!approval) return;
+        const message = feedback ? `User requested changes: ${feedback}` : "User denied the tool execution";
+        agent.emit("approval:response", {
+          approvalId: approval.approvalId,
+          status: import_core.ApprovalStatus.DENIED,
+          sessionId: approval.sessionId,
+          reason: import_core.DenialReason.USER_DENIED,
+          message
+        });
+        completeApproval();
+      },
+      [approval, agent, completeApproval]
+    );
+    const handleCancelApproval = (0, import_react.useCallback)(() => {
+      if (!approval) return;
+      agent.emit("approval:response", {
+        approvalId: approval.approvalId,
+        status: import_core.ApprovalStatus.CANCELLED,
+        sessionId: approval.sessionId,
+        reason: import_core.DenialReason.USER_CANCELLED,
+        message: "User cancelled the approval request"
+      });
+      completeApproval();
+    }, [approval, agent, completeApproval]);
+    const isApiKeyMissingError = (error) => {
+      if (error instanceof import_core2.DextoValidationError) {
+        const apiKeyIssue = error.issues.find(
+          (issue) => issue.code === import_core2.LLMErrorCode.API_KEY_MISSING
+        );
+        if (apiKeyIssue && apiKeyIssue.context) {
+          return getProviderFromIssueContext(apiKeyIssue.context);
+        }
+      }
+      return null;
+    };
+    const handleModelSelect = (0, import_react.useCallback)(
+      async (provider, model, displayName, baseURL, reasoningVariant) => {
+        if (provider === "dexto-nova") {
+          try {
+            const canUse = await (0, import_host.canUseDextoProvider)();
+            if (!canUse) {
+              setMessages((prev) => [
+                ...prev,
+                {
+                  id: (0, import_idGenerator.generateMessageId)("system"),
+                  role: "system",
+                  content: "Cannot switch to Dexto Nova model - authentication required. Run /login to authenticate.",
+                  timestamp: /* @__PURE__ */ new Date()
+                }
+              ]);
+              return;
+            }
+          } catch (error) {
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("error"),
+                role: "system",
+                content: `Failed to verify Dexto Nova auth: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+            return;
+          }
+        }
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        try {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u{1F504} Switching to ${displayName || model} (${provider})...`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          await agent.switchLLM(
+            {
+              provider,
+              model,
+              baseURL,
+              ...buildReasoningSwitchUpdate(provider, model, reasoningVariant)
+            },
+            session.id || void 0
+          );
+          setSession((prev) => ({ ...prev, modelName: displayName || model }));
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Successfully switched to ${displayName || model} (${provider})`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        } catch (error) {
+          const missingProvider = isApiKeyMissingError(error);
+          if (missingProvider) {
+            setUi((prev) => ({
+              ...prev,
+              activeOverlay: "api-key-input",
+              pendingModelSwitch: {
+                provider: missingProvider,
+                model,
+                ...displayName && { displayName },
+                ...baseURL && { baseURL },
+                ...reasoningVariant !== void 0 && { reasoningVariant }
+              }
+            }));
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("system"),
+                role: "system",
+                content: `\u{1F511} API key required for ${provider}`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+            return;
+          }
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("error"),
+              role: "system",
+              content: `Failed to switch model: ${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        }
+      },
+      [setUi, setInput, setMessages, setSession, agent, session.id, buffer]
+    );
+    const handleSetDefaultModel = (0, import_react.useCallback)(
+      async (provider, model, displayName, baseURL, reasoningVariant) => {
+        try {
+          let providerEnvVar;
+          try {
+            const providerKeyStatus = await (0, import_agent_management.getProviderKeyStatus)(provider);
+            providerEnvVar = providerKeyStatus?.envVar;
+          } catch (error) {
+            agent.logger.debug(
+              `Failed to resolve provider API key env var: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+          let existing = null;
+          try {
+            existing = await (0, import_agent_management.loadGlobalPreferences)();
+          } catch {
+            existing = null;
+          }
+          const existingReasoning = existing?.llm.reasoning;
+          const defaultReasoningVariant = (0, import_core2.getReasoningProfile)(
+            provider,
+            model
+          ).defaultVariant;
+          const nextReasoning = reasoningVariant === void 0 ? existingReasoning : defaultReasoningVariant !== void 0 && reasoningVariant === defaultReasoningVariant ? void 0 : { variant: reasoningVariant };
+          const preferencesUpdate = {
+            provider,
+            model,
+            ...baseURL ? { baseURL } : {},
+            ...nextReasoning ? { reasoning: nextReasoning } : {}
+          };
+          const switchReasoningUpdate = buildReasoningSwitchUpdate(
+            provider,
+            model,
+            reasoningVariant
+          );
+          if (existing?.llm.provider === provider && existing?.llm.apiKey) {
+            preferencesUpdate.apiKey = existing.llm.apiKey;
+          } else if (providerEnvVar) {
+            preferencesUpdate.apiKey = "$" + providerEnvVar;
+          }
+          await (0, import_agent_management.updateGlobalPreferences)({
+            llm: preferencesUpdate
+          });
+          try {
+            await agent.switchLLM(
+              {
+                provider,
+                model,
+                ...baseURL ? { baseURL } : {},
+                ...switchReasoningUpdate
+              },
+              session.id || void 0
+            );
+            setSession((prev) => ({ ...prev, modelName: displayName || model }));
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("system"),
+                role: "system",
+                content: `\u2705 Default model set to ${displayName || model} (${provider})`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          } catch (error) {
+            const missingProvider = isApiKeyMissingError(error);
+            if (missingProvider) {
+              setUi((prev) => ({
+                ...prev,
+                activeOverlay: "api-key-input",
+                pendingModelSwitch: {
+                  provider: missingProvider,
+                  model,
+                  ...displayName && { displayName },
+                  ...baseURL && { baseURL },
+                  ...reasoningVariant !== void 0 && { reasoningVariant }
+                }
+              }));
+              setMessages((prev) => [
+                ...prev,
+                {
+                  id: (0, import_idGenerator.generateMessageId)("system"),
+                  role: "system",
+                  content: `\u{1F511} API key required for ${provider}`,
+                  timestamp: /* @__PURE__ */ new Date()
+                }
+              ]);
+              return;
+            }
+            throw error;
+          }
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("error"),
+              role: "system",
+              content: `Failed to set default model: ${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        }
+      },
+      [agent, setMessages, setSession, setUi, session.id]
+    );
+    const [editingModel, setEditingModel] = (0, import_react.useState)(null);
+    const handleAddCustomModel = (0, import_react.useCallback)(() => {
+      setEditingModel(null);
+      setUi((prev) => ({ ...prev, activeOverlay: "custom-model-wizard" }));
+    }, [setUi]);
+    const handleEditCustomModel = (0, import_react.useCallback)(
+      (model) => {
+        setEditingModel(model);
+        setUi((prev) => ({ ...prev, activeOverlay: "custom-model-wizard" }));
+      },
+      [setUi]
+    );
+    const handleCustomModelComplete = (0, import_react.useCallback)(
+      async (model) => {
+        const wasEditing = editingModel !== null;
+        setEditingModel(null);
+        setUi((prev) => ({ ...prev, activeOverlay: "none" }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        if (wasEditing) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Custom model "${model.displayName || model.name}" updated`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        } else {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Custom model "${model.displayName || model.name}" saved`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          await handleModelSelect(
+            model.provider,
+            model.name,
+            model.displayName,
+            model.baseURL
+          );
+        }
+      },
+      [setUi, setInput, setMessages, buffer, editingModel, handleModelSelect]
+    );
+    const handleApiKeySaved = (0, import_react.useCallback)(
+      async (meta) => {
+        const pending = ui.pendingModelSwitch;
+        if (!pending) {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "none",
+            pendingModelSwitch: null
+          }));
+          return;
+        }
+        setUi((prev) => ({
+          ...prev,
+          activeOverlay: "none",
+          pendingModelSwitch: null
+        }));
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u2705 API key saved for ${meta.provider}`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+        try {
+          const pendingDisplayName = pending.displayName || pending.model;
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u{1F504} Retrying switch to ${pendingDisplayName} (${pending.provider})...`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          await agent.switchLLM(
+            {
+              provider: pending.provider,
+              model: pending.model,
+              ...pending.baseURL && { baseURL: pending.baseURL },
+              ...buildReasoningSwitchUpdate(
+                pending.provider,
+                pending.model,
+                pending.reasoningVariant
+              )
+            },
+            session.id || void 0
+          );
+          setSession((prev) => ({ ...prev, modelName: pendingDisplayName }));
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Successfully switched to ${pendingDisplayName} (${pending.provider})`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("error"),
+              role: "system",
+              content: `Failed to switch model: ${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        }
+      },
+      [ui.pendingModelSwitch, setUi, setMessages, setSession, agent, session.id]
+    );
+    const handleApiKeyClose = (0, import_react.useCallback)(() => {
+      setUi((prev) => ({
+        ...prev,
+        activeOverlay: "none",
+        pendingModelSwitch: null
+      }));
+    }, [setUi]);
+    const handleSearchResultSelect = (0, import_react.useCallback)(
+      (result) => {
+        setUi((prev) => ({ ...prev, activeOverlay: "none" }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        const roleLabel = result.message.role === "user" ? "\u{1F464} User" : result.message.role === "assistant" ? "\u{1F916} Assistant" : `\u{1F4CB} ${result.message.role}`;
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u{1F50D} Search Result from session ${result.sessionId.slice(0, 8)}:
+
+${roleLabel}:
+${result.context}`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+      },
+      [setUi, setInput, setMessages, buffer]
+    );
+    const handleSessionSelect = (0, import_react.useCallback)(
+      async (newSessionId) => {
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        try {
+          if (newSessionId === session.id) {
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("system"),
+                role: "system",
+                content: `\u2139\uFE0F  Already using session ${newSessionId.slice(0, 8)}`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+            return;
+          }
+          (0, import_host.captureAnalytics)("dexto_session_switched", {
+            source: "cli",
+            fromSessionId: session.id || null,
+            toSessionId: newSessionId
+          });
+          setMessages([]);
+          setApproval(null);
+          setApprovalQueue([]);
+          const sessionData = await agent.getSession(newSessionId);
+          if (!sessionData) {
+            throw new Error(`Session ${newSessionId} not found`);
+          }
+          const newSessionConfig = agent.getCurrentLLMConfig(newSessionId);
+          const newSessionModelName = (0, import_core2.getModelDisplayName)(
+            newSessionConfig.model,
+            newSessionConfig.provider
+          );
+          setSession({
+            id: newSessionId,
+            hasActiveSession: true,
+            modelName: newSessionModelName
+          });
+          const history = await agent.getSessionHistory(newSessionId);
+          if (history && history.length > 0) {
+            const historyMessages = (0, import_messageFormatting.convertHistoryToUIMessages)(history, newSessionId);
+            setMessages(historyMessages);
+            const userInputHistory = history.filter(import_core.isUserMessage).map((msg) => {
+              if (typeof msg.content === "string") {
+                return msg.content;
+              }
+              if (Array.isArray(msg.content)) {
+                return msg.content.filter(
+                  (part) => typeof part === "object" && part.type === "text"
+                ).map((part) => part.text).join("\n");
+              }
+              return "";
+            }).filter((text) => text.trim().length > 0);
+            setInput((prev) => ({
+              ...prev,
+              history: userInputHistory,
+              historyIndex: -1
+            }));
+          }
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Switched to session ${newSessionId.slice(0, 8)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          refreshStatic?.();
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("error"),
+              role: "system",
+              content: `Failed to switch session: ${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        }
+      },
+      [
+        setUi,
+        setInput,
+        setMessages,
+        setApproval,
+        setApprovalQueue,
+        setSession,
+        agent,
+        session.id,
+        session.modelName,
+        buffer,
+        refreshStatic
+      ]
+    );
+    const handlePromptSelect = (0, import_react.useCallback)(
+      async (prompt) => {
+        const commandName = prompt.displayName || prompt.name;
+        const commandText = `/${commandName}`;
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        if (onSubmitPromptCommand) {
+          await onSubmitPromptCommand(commandText);
+          return;
+        }
+        const userMessage = (0, import_messageFormatting.createUserMessage)(commandText);
+        setMessages((prev) => [...prev, userMessage]);
+        setUi((prev) => ({ ...prev, isProcessing: true, isCancelling: false }));
+        const { CommandService } = await import("../services/CommandService.js");
+        const commandService = new CommandService();
+        try {
+          const result = await commandService.executeCommand(
+            commandName,
+            [],
+            agent,
+            session.id || void 0
+          );
+          if (result.type === "output" && result.output) {
+            const output = result.output;
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("command"),
+                role: "system",
+                content: output,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          }
+          if (result.type === "styled" && result.styled) {
+            const { fallbackText, styledType, styledData } = result.styled;
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("command"),
+                role: "system",
+                content: fallbackText,
+                timestamp: /* @__PURE__ */ new Date(),
+                styledType,
+                styledData
+              }
+            ]);
+          }
+          setUi((prev) => ({
+            ...prev,
+            isProcessing: false,
+            isCancelling: false,
+            isThinking: false
+          }));
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("error"),
+              role: "system",
+              content: `${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          setUi((prev) => ({
+            ...prev,
+            isProcessing: false,
+            isCancelling: false,
+            isThinking: false
+          }));
+        }
+      },
+      [setUi, setInput, setMessages, agent, session.id, buffer, onSubmitPromptCommand]
+    );
+    const handleSystemCommandSelect = (0, import_react.useCallback)(
+      async (command) => {
+        const { getCommandOverlay } = await import("../utils/commandOverlays.js");
+        const overlay = getCommandOverlay(command, []);
+        if (overlay) {
+          buffer.setText("");
+          setInput((prev) => ({ ...prev, historyIndex: -1 }));
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: overlay,
+            mcpWizardServerType: null
+          }));
+          return;
+        }
+        const commandText = `/${command}`;
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        const userMessage = (0, import_messageFormatting.createUserMessage)(commandText);
+        setMessages((prev) => [...prev, userMessage]);
+        setUi((prev) => ({ ...prev, isProcessing: true, isCancelling: false }));
+        const { CommandService } = await import("../services/CommandService.js");
+        const commandService = new CommandService();
+        try {
+          const result = await commandService.executeCommand(
+            command,
+            [],
+            agent,
+            session.id || void 0
+          );
+          if (result.type === "output" && result.output) {
+            const output = result.output;
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("command"),
+                role: "system",
+                content: output,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          }
+          if (result.type === "styled" && result.styled) {
+            const { fallbackText, styledType, styledData } = result.styled;
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("command"),
+                role: "system",
+                content: fallbackText,
+                timestamp: /* @__PURE__ */ new Date(),
+                styledType,
+                styledData
+              }
+            ]);
+          }
+          setUi((prev) => ({
+            ...prev,
+            isProcessing: false,
+            isCancelling: false,
+            isThinking: false
+          }));
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("error"),
+              role: "system",
+              content: `${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          setUi((prev) => ({
+            ...prev,
+            isProcessing: false,
+            isCancelling: false,
+            isThinking: false
+          }));
+        }
+      },
+      [setInput, setUi, setMessages, agent, session.id, buffer]
+    );
+    const handleLoadIntoInput = (0, import_react.useCallback)(
+      (text) => {
+        buffer.setText(text);
+        setInput((prev) => ({ ...prev, value: text }));
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+      },
+      [buffer, setInput, setUi]
+    );
+    const handleResourceSelect = (0, import_react.useCallback)(
+      (resource) => {
+        const atIndex = input.value.lastIndexOf("@");
+        if (atIndex >= 0) {
+          const before = input.value.slice(0, atIndex + 1);
+          const uriParts = resource.uri.split(/[\\/]/);
+          let reference = resource.name || uriParts[uriParts.length - 1] || resource.uri;
+          const rawUri = resource.uri.replace(/^(fs|file):\/\//, "");
+          if (import_path.default.isAbsolute(rawUri)) {
+            try {
+              const relativePath = import_path.default.relative(process.cwd(), rawUri);
+              reference = relativePath;
+            } catch {
+            }
+          }
+          const newValue = `${before}${reference} `;
+          buffer.setText(newValue);
+          setInput((prev) => ({ ...prev, value: newValue }));
+        }
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+      },
+      [input.value, buffer, setInput, setUi]
+    );
+    const handleClose = (0, import_react.useCallback)(() => {
+      setUi((prev) => ({
+        ...prev,
+        activeOverlay: "none",
+        mcpWizardServerType: null,
+        commandOutput: null
+      }));
+    }, [setUi]);
+    const handleLoginDone = (0, import_react.useCallback)(
+      (outcome) => {
+        handleClose();
+        if (outcome.outcome === "closed") {
+          return;
+        }
+        if (outcome.outcome === "cancelled") {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: "Login cancelled.",
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          return;
+        }
+        const userLabel = outcome.email ? ` as ${outcome.email}` : "";
+        const keyLine = outcome.hasDextoApiKey ? `\u{1F511} DEXTO_API_KEY ready${outcome.keyId ? ` (Key ID: ${outcome.keyId})` : ""}` : "\u26A0\uFE0F Failed to provision DEXTO_API_KEY (you can still use your own API keys)";
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u2705 Logged in${userLabel}
+${keyLine}`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+      },
+      [handleClose, setMessages]
+    );
+    const handleLogoutDone = (0, import_react.useCallback)(
+      (outcome) => {
+        handleClose();
+        if (outcome.outcome === "closed") {
+          return;
+        }
+        if (outcome.outcome === "cancelled") {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: "Logout cancelled.",
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          return;
+        }
+        const warning = outcome.wasUsingDextoCredits ? "\n\nNext steps:\n\u2022 Run `/login` to log back in\n\u2022 Or run `dexto setup` to configure a different provider" : "";
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u2705 Successfully logged out${warning}`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+      },
+      [handleClose, setMessages]
+    );
+    const handleLogLevelSelect = (0, import_react.useCallback)(
+      (level) => {
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        void agent.setLogLevel(
+          level,
+          session.id ? { sessionId: session.id } : void 0
+        );
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u{1F4CA} Log level set to: ${level}`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+      },
+      [setUi, setInput, setMessages, agent, buffer, getConfigFilePathOrWarn, session.id]
+    );
+    const handleStreamSelect = (0, import_react.useCallback)(
+      (enabled) => {
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: enabled ? "\u25B6\uFE0F Streaming enabled - responses will appear as they are generated" : "\u23F8\uFE0F Streaming disabled - responses will appear when complete",
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+      },
+      [setUi, setInput, setMessages, buffer]
+    );
+    const handleToggleShowReasoning = (0, import_react.useCallback)(() => {
+      setUi((prev) => ({ ...prev, showReasoning: !prev.showReasoning }));
+    }, [setUi]);
+    const handleReasoningNotify = (0, import_react.useCallback)(
+      (message) => {
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u{1F9E0} ${message}`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+      },
+      [setMessages]
+    );
+    const handleSetReasoningBudgetTokens = (0, import_react.useCallback)(
+      async (budgetTokens) => {
+        const sessionId = session.id || void 0;
+        const current = agent.getCurrentLLMConfig(sessionId);
+        const profile = (0, import_core2.getReasoningProfile)(current.provider, current.model);
+        const defaultVariant = profile.defaultVariant;
+        const variant = current.reasoning?.variant ?? defaultVariant ?? profile.supportedVariants[0];
+        if (variant === void 0) {
+          return;
+        }
+        const reasoningUpdate = budgetTokens === void 0 && defaultVariant !== void 0 && variant === defaultVariant ? { reasoning: null } : {
+          reasoning: {
+            variant,
+            ...typeof budgetTokens === "number" ? { budgetTokens } : {}
+          }
+        };
+        await agent.switchLLM(
+          {
+            provider: current.provider,
+            model: current.model,
+            ...reasoningUpdate
+          },
+          sessionId
+        );
+      },
+      [agent, session.id]
+    );
+    const handleMcpServerListAction = (0, import_react.useCallback)(
+      (action) => {
+        if (action.type === "select-server") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "mcp-server-actions",
+            selectedMcpServer: action.server
+          }));
+        } else if (action.type === "add-new") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "mcp-add-choice"
+          }));
+        }
+      },
+      [setUi]
+    );
+    const handleMcpServerAction = (0, import_react.useCallback)(
+      async (action) => {
+        const { server } = action;
+        if (action.type === "back") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "mcp-server-list",
+            selectedMcpServer: null
+          }));
+          return;
+        }
+        setUi((prev) => ({
+          ...prev,
+          activeOverlay: "none",
+          selectedMcpServer: null,
+          mcpWizardServerType: null,
+          isProcessing: true,
+          isCancelling: false
+        }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        if (action.type === "enable" || action.type === "disable") {
+          const newEnabled = action.type === "enable";
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `${newEnabled ? "\u25B6\uFE0F" : "\u23F8\uFE0F"} ${newEnabled ? "Enabling" : "Disabling"} ${server.name}...`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          try {
+            if (newEnabled) {
+              try {
+                await agent.enableMcpServer(server.name);
+              } catch (connectError) {
+                setMessages((prev) => [
+                  ...prev,
+                  {
+                    id: (0, import_idGenerator.generateMessageId)("system"),
+                    role: "system",
+                    content: `\u26A0\uFE0F Failed to enable server: ${connectError instanceof Error ? connectError.message : String(connectError)}`,
+                    timestamp: /* @__PURE__ */ new Date()
+                  }
+                ]);
+                setUi((prev) => ({
+                  ...prev,
+                  isProcessing: false,
+                  isCancelling: false,
+                  isThinking: false
+                }));
+                return;
+              }
+            } else {
+              await agent.disableMcpServer(server.name);
+            }
+            const { updateMcpServerField } = await import("@dexto/agent-management");
+            const agentPath = getConfigFilePathOrWarn("persist MCP server settings");
+            if (!agentPath) {
+              return;
+            }
+            await updateMcpServerField(agentPath, server.name, "enabled", newEnabled);
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("system"),
+                role: "system",
+                content: `\u2705 ${server.name} ${newEnabled ? "enabled" : "disabled"}`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          } catch (error) {
+            let errorMessage = error instanceof Error ? error.message : String(error);
+            if (error instanceof import_core2.DextoValidationError && error.issues.length > 0) {
+              const issueDetails = error.issues.map((i) => {
+                const path2 = i.path?.length ? `[${i.path.join(".")}] ` : "";
+                return `  - ${path2}${i.message}`;
+              }).join("\n");
+              errorMessage = `Validation failed:
+${issueDetails}`;
+            }
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("error"),
+                role: "system",
+                content: `Failed to ${action.type} server: ${errorMessage}`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          }
+        } else if (action.type === "authenticate") {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u{1F510} Authenticating ${server.name}...`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          try {
+            await agent.restartMcpServer(server.name);
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("system"),
+                role: "system",
+                content: `\u2705 Authenticated ${server.name}`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          } catch (error) {
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("error"),
+                role: "system",
+                content: `Failed to authenticate server: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          }
+        } else if (action.type === "delete") {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u{1F5D1}\uFE0F Deleting ${server.name}...`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          try {
+            const { removeMcpServerFromConfig } = await import("@dexto/agent-management");
+            const agentPath = getConfigFilePathOrWarn("persist MCP server deletion");
+            if (agentPath) {
+              await removeMcpServerFromConfig(agentPath, server.name);
+            }
+            try {
+              await agent.removeMcpServer(server.name);
+            } catch {
+            }
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("system"),
+                role: "system",
+                content: `\u2705 Deleted ${server.name}`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          } catch (error) {
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("error"),
+                role: "system",
+                content: `Failed to delete server: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          }
+        }
+        setUi((prev) => ({
+          ...prev,
+          isProcessing: false,
+          isCancelling: false,
+          isThinking: false
+        }));
+      },
+      [setUi, setInput, setMessages, agent, buffer]
+    );
+    const handleMcpAddChoice = (0, import_react.useCallback)(
+      (choice) => {
+        if (choice === "back") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "mcp-server-list"
+          }));
+        } else if (choice === "registry") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "mcp-add-selector"
+          }));
+        } else if (choice === "custom") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "mcp-custom-type-selector"
+          }));
+        }
+      },
+      [setUi]
+    );
+    const handleMcpAddSelect = (0, import_react.useCallback)(
+      async (result) => {
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        setUi((prev) => ({ ...prev, isProcessing: true, isCancelling: false }));
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u{1F50C} Connecting to ${result.entry.name}...`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+        try {
+          const mcpConfig = result.entry.config;
+          await agent.addMcpServer(result.entry.id, mcpConfig);
+          (0, import_host.captureAnalytics)("dexto_mcp_server_connected", {
+            source: "cli",
+            serverName: result.entry.name,
+            transportType: mcpConfig.type
+          });
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Connected to ${result.entry.name}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `Failed to connect: ${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        }
+        setUi((prev) => ({
+          ...prev,
+          isProcessing: false,
+          isCancelling: false,
+          isThinking: false
+        }));
+      },
+      [setUi, setInput, setMessages, agent, buffer]
+    );
+    const handleMcpCustomTypeSelect = (0, import_react.useCallback)(
+      (serverType) => {
+        setUi((prev) => ({
+          ...prev,
+          mcpWizardServerType: serverType,
+          activeOverlay: "mcp-custom-wizard"
+        }));
+      },
+      [setUi]
+    );
+    const handleMcpCustomWizardComplete = (0, import_react.useCallback)(
+      async (config) => {
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        setUi((prev) => ({ ...prev, isProcessing: true, isCancelling: false }));
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u{1F50C} Connecting to ${config.name}...`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+        try {
+          let serverConfig;
+          if (config.serverType === "stdio") {
+            serverConfig = {
+              type: "stdio",
+              command: config.command,
+              args: config.args || []
+            };
+          } else if (config.serverType === "http") {
+            serverConfig = {
+              type: "http",
+              url: config.url
+            };
+          } else {
+            serverConfig = {
+              type: "sse",
+              url: config.url
+            };
+          }
+          await agent.addMcpServer(config.name, serverConfig);
+          (0, import_host.captureAnalytics)("dexto_mcp_server_connected", {
+            source: "cli",
+            serverName: config.name,
+            transportType: serverConfig.type
+          });
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Connected to ${config.name}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `Failed to connect: ${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        }
+        setUi((prev) => ({
+          ...prev,
+          isProcessing: false,
+          isCancelling: false,
+          isThinking: false
+        }));
+      },
+      [setUi, setInput, setMessages, agent, buffer]
+    );
+    const handlePluginManagerAction = (0, import_react.useCallback)(
+      (action) => {
+        if (action === "list") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "plugin-list"
+          }));
+        } else if (action === "marketplace") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "marketplace-browser"
+          }));
+        }
+      },
+      [setUi]
+    );
+    const handlePluginSelect = (0, import_react.useCallback)(
+      (plugin) => {
+        setSelectedPlugin(plugin);
+        setUi((prev) => ({
+          ...prev,
+          activeOverlay: "plugin-actions"
+        }));
+      },
+      [setUi]
+    );
+    const handlePluginAction = (0, import_react.useCallback)(
+      async (action) => {
+        if (action.type === "back") {
+          setSelectedPlugin(null);
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "plugin-list"
+          }));
+          return;
+        }
+        if (action.type === "uninstall") {
+          setUi((prev) => ({ ...prev, activeOverlay: "none", isProcessing: true }));
+          try {
+            const { uninstallPlugin, reloadAgentConfigFromFile, enrichAgentConfig } = await import("@dexto/agent-management");
+            await uninstallPlugin(action.plugin.name);
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("system"),
+                role: "system",
+                content: `Plugin '${action.plugin.name}' has been uninstalled.`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+            try {
+              const agentPath = getConfigFilePathOrWarn(
+                "refresh prompts after plugin uninstall"
+              );
+              if (!agentPath) {
+                return;
+              }
+              const newConfig = await reloadAgentConfigFromFile(agentPath);
+              const enrichedConfig = enrichAgentConfig(newConfig, agentPath);
+              await agent.refreshPrompts(enrichedConfig.prompts);
+            } catch {
+            }
+          } catch (error) {
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("error"),
+                role: "system",
+                content: `Failed to uninstall plugin: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          }
+          setSelectedPlugin(null);
+          setUi((prev) => ({ ...prev, isProcessing: false }));
+        }
+      },
+      [setUi, setMessages, agent, getConfigFilePathOrWarn]
+    );
+    const handleMarketplaceBrowserAction = (0, import_react.useCallback)(
+      async (action) => {
+        if (action.type === "add-marketplace") {
+          setUi((prev) => ({ ...prev, activeOverlay: "marketplace-add" }));
+        } else if (action.type === "plugin-installed") {
+          setUi((prev) => ({ ...prev, activeOverlay: "none" }));
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Plugin '${action.pluginName}' installed from ${action.marketplace}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          try {
+            const { reloadAgentConfigFromFile, enrichAgentConfig } = await import("@dexto/agent-management");
+            const agentPath = getConfigFilePathOrWarn(
+              "refresh prompts after plugin install"
+            );
+            if (!agentPath) {
+              return;
+            }
+            const newConfig = await reloadAgentConfigFromFile(agentPath);
+            const enrichedConfig = enrichAgentConfig(newConfig, agentPath);
+            await agent.refreshPrompts(enrichedConfig.prompts);
+          } catch (error) {
+          }
+        }
+      },
+      [setUi, setMessages, agent, getConfigFilePathOrWarn]
+    );
+    const handleMarketplaceAddComplete = (0, import_react.useCallback)(
+      (name, pluginCount) => {
+        setUi((prev) => ({ ...prev, activeOverlay: "marketplace-browser" }));
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u2705 Marketplace '${name}' added (${pluginCount} plugins found)`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+      },
+      [setUi, setMessages]
+    );
+    const handleSessionSubcommandSelect = (0, import_react.useCallback)(
+      async (action) => {
+        if (action === "switch") {
+          setInput((prev) => ({ ...prev, value: "/session switch" }));
+          setUi((prev) => ({ ...prev, activeOverlay: "session-selector" }));
+          return;
+        }
+        setUi((prev) => ({ ...prev, activeOverlay: "none", mcpWizardServerType: null }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        setUi((prev) => ({ ...prev, isProcessing: true, isCancelling: false }));
+        try {
+          const { CommandService } = await import("../services/CommandService.js");
+          const commandService = new CommandService();
+          const result = await commandService.executeCommand(
+            "session",
+            [action],
+            agent,
+            session.id || void 0
+          );
+          if (result.type === "output" && result.output) {
+            const output = result.output;
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("command"),
+                role: "system",
+                content: output,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            ]);
+          }
+          if (result.type === "styled" && result.styled) {
+            const { fallbackText, styledType, styledData } = result.styled;
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: (0, import_idGenerator.generateMessageId)("command"),
+                role: "system",
+                content: fallbackText,
+                timestamp: /* @__PURE__ */ new Date(),
+                styledType,
+                styledData
+              }
+            ]);
+          }
+          setUi((prev) => ({
+            ...prev,
+            isProcessing: false,
+            isCancelling: false,
+            isThinking: false
+          }));
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("error"),
+              role: "system",
+              content: `${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          setUi((prev) => ({
+            ...prev,
+            isProcessing: false,
+            isCancelling: false,
+            isThinking: false
+          }));
+        }
+      },
+      [setInput, setUi, setMessages, agent, session.id, buffer]
+    );
+    const handlePromptListAction = (0, import_react.useCallback)(
+      async (action) => {
+        if (action.type === "add-prompt") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "prompt-add-choice"
+          }));
+        } else if (action.type === "delete-prompt") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "prompt-delete-selector"
+          }));
+        } else if (action.type === "select-prompt") {
+          const displayName = action.prompt.displayName || action.prompt.name;
+          const commandText = `/${displayName}`;
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "none",
+            promptAddWizard: null
+          }));
+          buffer.setText("");
+          setInput((prev) => ({ ...prev, historyIndex: -1 }));
+          if (onSubmitPromptCommand) {
+            await onSubmitPromptCommand(commandText);
+          }
+        }
+      },
+      [setUi, setInput, buffer, onSubmitPromptCommand]
+    );
+    const handlePromptLoadIntoInput = (0, import_react.useCallback)(
+      (text) => {
+        buffer.setText(text);
+        setInput((prev) => ({ ...prev, value: text }));
+        setUi((prev) => ({
+          ...prev,
+          activeOverlay: "none",
+          promptAddWizard: null
+        }));
+      },
+      [buffer, setInput, setUi]
+    );
+    const handlePromptAddChoice = (0, import_react.useCallback)(
+      (choice) => {
+        if (choice === "back") {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "prompt-list"
+          }));
+        } else {
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "prompt-add-wizard",
+            promptAddWizard: {
+              scope: choice,
+              step: "name",
+              name: "",
+              title: "",
+              description: "",
+              content: ""
+            }
+          }));
+        }
+      },
+      [setUi]
+    );
+    const handlePromptAddComplete = (0, import_react.useCallback)(
+      async (data) => {
+        const scope = ui.promptAddWizard?.scope || "agent";
+        setUi((prev) => ({
+          ...prev,
+          activeOverlay: "none",
+          promptAddWizard: null
+        }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u{1F4DD} Creating ${scope === "shared" ? "shared" : "agent"} prompt "${data.name}"...`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+        try {
+          const { mkdir, writeFile } = await import("fs/promises");
+          const { dirname, join } = await import("path");
+          const SAFE_NAME_PATTERN = /^[a-z0-9][a-z0-9-_]*$/i;
+          if (!SAFE_NAME_PATTERN.test(data.name)) {
+            throw new Error(
+              `Invalid prompt name "${data.name}". Names must start with a letter or number and contain only letters, numbers, hyphens, and underscores.`
+            );
+          }
+          const frontmatterLines = [
+            "---",
+            `id: ${data.name}`,
+            data.title ? `title: "${data.title}"` : null,
+            data.description ? `description: "${data.description}"` : null,
+            data.argumentHint ? `argument-hint: ${data.argumentHint}` : null,
+            "---"
+          ].filter(Boolean);
+          const fileContent = `${frontmatterLines.join("\n")}
+
+${data.content}
+`;
+          let filePath;
+          if (scope === "shared") {
+            const {
+              getExecutionContext,
+              findDextoSourceRoot,
+              findDextoProjectRoot,
+              getDextoGlobalPath
+            } = await import("@dexto/agent-management");
+            const context = getExecutionContext();
+            let commandsDir;
+            if (context === "dexto-source") {
+              const isDevMode = process.env.DEXTO_DEV_MODE === "true";
+              if (isDevMode) {
+                const sourceRoot = findDextoSourceRoot();
+                commandsDir = sourceRoot ? join(sourceRoot, "commands") : getDextoGlobalPath("commands");
+              } else {
+                commandsDir = getDextoGlobalPath("commands");
+              }
+            } else if (context === "dexto-project") {
+              const projectRoot = findDextoProjectRoot();
+              commandsDir = projectRoot ? join(projectRoot, "commands") : getDextoGlobalPath("commands");
+            } else {
+              commandsDir = getDextoGlobalPath("commands");
+            }
+            filePath = join(commandsDir, `${data.name}.md`);
+            await mkdir(commandsDir, { recursive: true });
+            await writeFile(filePath, fileContent, "utf-8");
+            const { reloadAgentConfigFromFile, enrichAgentConfig } = await import("@dexto/agent-management");
+            const agentPath = getConfigFilePathOrWarn(
+              "refresh prompts after creating shared prompt"
+            );
+            if (!agentPath) {
+              return;
+            }
+            const newConfig = await reloadAgentConfigFromFile(agentPath);
+            const enrichedConfig = enrichAgentConfig(newConfig, agentPath);
+            await agent.refreshPrompts(enrichedConfig.prompts);
+          } else {
+            const agentPath = getConfigFilePathOrWarn(
+              "create prompt in agent prompts directory"
+            );
+            if (!agentPath) {
+              return;
+            }
+            const agentDir = dirname(agentPath);
+            const promptsDir = join(agentDir, "prompts");
+            filePath = join(promptsDir, `${data.name}.md`);
+            await mkdir(promptsDir, { recursive: true });
+            await writeFile(filePath, fileContent, "utf-8");
+            const {
+              addPromptToAgentConfig,
+              reloadAgentConfigFromFile,
+              enrichAgentConfig
+            } = await import("@dexto/agent-management");
+            await addPromptToAgentConfig(agentPath, {
+              type: "file",
+              file: `\${{dexto.agent_dir}}/prompts/${data.name}.md`
+            });
+            const newConfig = await reloadAgentConfigFromFile(agentPath);
+            const enrichedConfig = enrichAgentConfig(newConfig, agentPath);
+            await agent.refreshPrompts(enrichedConfig.prompts);
+          }
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Created prompt "${data.name}"
+\u{1F4C4} File: ${filePath}
+
+Use /${data.name} to run it.`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("error"),
+              role: "system",
+              content: `Failed to create prompt: ${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        }
+      },
+      [
+        ui.promptAddWizard?.scope,
+        setUi,
+        setInput,
+        setMessages,
+        buffer,
+        agent,
+        getConfigFilePathOrWarn
+      ]
+    );
+    const handlePromptDelete = (0, import_react.useCallback)(
+      async (deletable) => {
+        const displayName = deletable.prompt.displayName || deletable.prompt.name;
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: (0, import_idGenerator.generateMessageId)("system"),
+            role: "system",
+            content: `\u{1F5D1}\uFE0F Deleting prompt "${displayName}"...`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+        try {
+          const { deletePromptByMetadata, reloadAgentConfigFromFile, enrichAgentConfig } = await import("@dexto/agent-management");
+          const agentPath = getConfigFilePathOrWarn("delete prompt");
+          if (!agentPath) {
+            return;
+          }
+          const promptMetadata = deletable.prompt.metadata;
+          const result = await deletePromptByMetadata(
+            agentPath,
+            {
+              name: deletable.prompt.name,
+              metadata: {
+                filePath: deletable.filePath,
+                originalId: promptMetadata?.originalId
+              }
+            },
+            { deleteFile: true }
+          );
+          if (!result.success) {
+            throw new Error(result.error || "Failed to delete prompt");
+          }
+          const newConfig = await reloadAgentConfigFromFile(agentPath);
+          const enrichedConfig = enrichAgentConfig(newConfig, agentPath);
+          await agent.refreshPrompts(enrichedConfig.prompts);
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Deleted prompt "${displayName}"`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "prompt-list"
+          }));
+          promptListRef.current?.refresh();
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("error"),
+              role: "system",
+              content: `Failed to delete prompt: ${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "prompt-list"
+          }));
+        }
+      },
+      [setUi, setMessages, agent, getConfigFilePathOrWarn]
+    );
+    const handlePromptAddWizardClose = (0, import_react.useCallback)(() => {
+      setUi((prev) => ({
+        ...prev,
+        activeOverlay: "prompt-add-choice",
+        promptAddWizard: null
+      }));
+    }, [setUi]);
+    const handlePromptDeleteClose = (0, import_react.useCallback)(() => {
+      setUi((prev) => ({
+        ...prev,
+        activeOverlay: "prompt-list"
+      }));
+      promptListRef.current?.refresh();
+    }, [setUi]);
+    const handlePromptAddChoiceClose = (0, import_react.useCallback)(() => {
+      setUi((prev) => ({
+        ...prev,
+        activeOverlay: "prompt-list"
+      }));
+    }, [setUi]);
+    const [currentSessionTitle, setCurrentSessionTitle] = (0, import_react.useState)(
+      void 0
+    );
+    import_react.default.useEffect(() => {
+      if (ui.activeOverlay === "session-rename" && session.id) {
+        void agent.getSessionTitle(session.id).then(setCurrentSessionTitle);
+      }
+    }, [ui.activeOverlay, session.id, agent]);
+    const handleSessionRename = (0, import_react.useCallback)(
+      async (newTitle) => {
+        if (!session.id) return;
+        setUi((prev) => ({ ...prev, activeOverlay: "none" }));
+        buffer.setText("");
+        setInput((prev) => ({ ...prev, historyIndex: -1 }));
+        try {
+          await agent.setSessionTitle(session.id, newTitle);
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("system"),
+              role: "system",
+              content: `\u2705 Session renamed to: ${newTitle}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        } catch (error) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: (0, import_idGenerator.generateMessageId)("error"),
+              role: "system",
+              content: `Failed to rename session: ${error instanceof Error ? error.message : String(error)}`,
+              timestamp: /* @__PURE__ */ new Date()
+            }
+          ]);
+        }
+      },
+      [session.id, setUi, setInput, setMessages, agent, buffer]
+    );
+    const handleSessionRenameClose = (0, import_react.useCallback)(() => {
+      setUi((prev) => ({ ...prev, activeOverlay: "none" }));
+    }, [setUi]);
+    const hideCliChrome = (0, import_overlayPresentation.shouldHideCliChrome)(ui.activeOverlay, approval);
+    const overlayContent = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+      approval && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_ApprovalPrompt.ApprovalPrompt,
+        {
+          ref: approvalRef,
+          approval,
+          onApprove: handleApprove,
+          onDeny: handleDeny,
+          onCancel: handleCancelApproval
+        }
+      ),
+      ui.activeOverlay === "slash-autocomplete" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_SlashCommandAutocomplete.SlashCommandAutocomplete,
+        {
+          ref: slashAutocompleteRef,
+          isVisible: true,
+          searchQuery: input.value,
+          onSelectPrompt: handlePromptSelect,
+          onSelectSystemCommand: handleSystemCommandSelect,
+          onLoadIntoInput: handleLoadIntoInput,
+          onSubmitRaw: onSubmitPromptCommand,
+          onClose: handleClose,
+          agent
+        }
+      ) }),
+      ui.activeOverlay === "resource-autocomplete" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_ResourceAutocomplete.default,
+        {
+          ref: resourceAutocompleteRef,
+          isVisible: true,
+          searchQuery: input.value,
+          onSelectResource: handleResourceSelect,
+          onLoadIntoInput: handleLoadIntoInput,
+          onClose: handleClose,
+          agent
+        }
+      ) }),
+      ui.activeOverlay === "model-selector" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_ModelSelectorRefactored.default,
+        {
+          ref: modelSelectorRef,
+          isVisible: true,
+          onSelectModel: handleModelSelect,
+          onSetDefaultModel: handleSetDefaultModel,
+          onClose: handleClose,
+          onAddCustomModel: handleAddCustomModel,
+          onEditCustomModel: handleEditCustomModel,
+          agent
+        }
+      ) }),
+      ui.activeOverlay === "reasoning" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_ReasoningOverlay.ReasoningOverlay,
+        {
+          ref: reasoningOverlayRef,
+          isVisible: true,
+          agent,
+          sessionId: session.id,
+          showReasoning: ui.showReasoning,
+          onToggleShowReasoning: handleToggleShowReasoning,
+          onSetBudgetTokens: handleSetReasoningBudgetTokens,
+          onNotify: handleReasoningNotify,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "session-selector" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_SessionSelectorRefactored.default,
+        {
+          ref: sessionSelectorRef,
+          isVisible: true,
+          onSelectSession: handleSessionSelect,
+          onClose: handleClose,
+          agent,
+          currentSessionId: session.id || void 0
+        }
+      ) }),
+      ui.activeOverlay === "log-level-selector" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_LogLevelSelector.default,
+        {
+          ref: logLevelSelectorRef,
+          isVisible: true,
+          onSelect: handleLogLevelSelect,
+          onClose: handleClose,
+          agent,
+          sessionId: session.id
+        }
+      ) }),
+      ui.activeOverlay === "stream-selector" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_StreamSelector.default,
+        {
+          ref: streamSelectorRef,
+          isVisible: true,
+          onSelect: handleStreamSelect,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "sounds-selector" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_SoundsSelector.default,
+        {
+          ref: soundsSelectorRef,
+          isVisible: true,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "tool-browser" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_ToolBrowser.default,
+        {
+          ref: toolBrowserRef,
+          isVisible: true,
+          onClose: handleClose,
+          agent,
+          sessionId: session.id
+        }
+      ) }),
+      ui.activeOverlay === "command-output" && ui.commandOutput && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_CommandOutputOverlay.CommandOutputOverlay,
+        {
+          ref: commandOutputRef,
+          isVisible: true,
+          title: ui.commandOutput.title,
+          content: ui.commandOutput.content,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "mcp-server-list" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_McpServerList.default,
+        {
+          ref: mcpServerListRef,
+          isVisible: true,
+          onAction: handleMcpServerListAction,
+          onClose: handleClose,
+          agent
+        }
+      ) }),
+      ui.activeOverlay === "mcp-server-actions" && ui.selectedMcpServer && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_McpServerActions.default,
+        {
+          ref: mcpServerActionsRef,
+          isVisible: true,
+          server: ui.selectedMcpServer,
+          onAction: handleMcpServerAction,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "mcp-add-choice" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_McpAddChoice.default,
+        {
+          ref: mcpAddChoiceRef,
+          isVisible: true,
+          onSelect: handleMcpAddChoice,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "mcp-add-selector" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_McpAddSelector.default,
+        {
+          ref: mcpAddSelectorRef,
+          isVisible: true,
+          onSelect: handleMcpAddSelect,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "mcp-custom-type-selector" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_McpCustomTypeSelector.default,
+        {
+          ref: mcpCustomTypeSelectorRef,
+          isVisible: true,
+          onSelect: handleMcpCustomTypeSelect,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "mcp-custom-wizard" && ui.mcpWizardServerType && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_McpCustomWizard.default,
+        {
+          ref: mcpCustomWizardRef,
+          isVisible: true,
+          serverType: ui.mcpWizardServerType,
+          onComplete: handleMcpCustomWizardComplete,
+          onClose: handleClose
+        }
+      ),
+      ui.activeOverlay === "custom-model-wizard" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_CustomModelWizard.default,
+        {
+          ref: customModelWizardRef,
+          isVisible: true,
+          onComplete: handleCustomModelComplete,
+          onClose: () => {
+            setEditingModel(null);
+            handleClose();
+          },
+          initialModel: editingModel
+        }
+      ),
+      ui.activeOverlay === "plugin-manager" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_PluginManager.default,
+        {
+          ref: pluginManagerRef,
+          isVisible: true,
+          onAction: handlePluginManagerAction,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "plugin-list" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_PluginList.default,
+        {
+          ref: pluginListRef,
+          isVisible: true,
+          onPluginSelect: handlePluginSelect,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "plugin-actions" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_PluginActions.default,
+        {
+          ref: pluginActionsRef,
+          isVisible: true,
+          plugin: selectedPlugin,
+          onAction: handlePluginAction,
+          onClose: () => {
+            setSelectedPlugin(null);
+            setUi((prev) => ({
+              ...prev,
+              activeOverlay: "plugin-list"
+            }));
+          }
+        }
+      ) }),
+      ui.activeOverlay === "marketplace-browser" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_MarketplaceBrowser.default,
+        {
+          ref: marketplaceBrowserRef,
+          isVisible: true,
+          onAction: handleMarketplaceBrowserAction,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "marketplace-add" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_MarketplaceAddPrompt.default,
+        {
+          ref: marketplaceAddPromptRef,
+          isVisible: true,
+          onComplete: handleMarketplaceAddComplete,
+          onClose: () => setUi((prev) => ({ ...prev, activeOverlay: "marketplace-browser" }))
+        }
+      ) }),
+      ui.activeOverlay === "session-subcommand-selector" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_SessionSubcommandSelector.default,
+        {
+          ref: sessionSubcommandSelectorRef,
+          isVisible: true,
+          onSelect: handleSessionSubcommandSelect,
+          onClose: handleClose
+        }
+      ) }),
+      ui.activeOverlay === "login" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_LoginOverlay.default,
+        {
+          ref: loginOverlayRef,
+          isVisible: true,
+          onDone: handleLoginDone
+        }
+      ) }),
+      ui.activeOverlay === "logout" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_LogoutOverlay.default,
+        {
+          ref: logoutOverlayRef,
+          isVisible: true,
+          onDone: handleLogoutDone
+        }
+      ) }),
+      ui.activeOverlay === "api-key-input" && ui.pendingModelSwitch && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_ApiKeyInput.default,
+        {
+          ref: apiKeyInputRef,
+          isVisible: true,
+          provider: ui.pendingModelSwitch.provider,
+          onSaved: handleApiKeySaved,
+          onClose: handleApiKeyClose
+        }
+      ),
+      ui.activeOverlay === "search" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_SearchOverlay.default,
+        {
+          ref: searchOverlayRef,
+          isVisible: true,
+          agent,
+          onClose: handleClose,
+          onSelectResult: handleSearchResultSelect
+        }
+      ),
+      ui.activeOverlay === "prompt-list" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_PromptList.default,
+        {
+          ref: promptListRef,
+          isVisible: true,
+          onAction: handlePromptListAction,
+          onLoadIntoInput: handlePromptLoadIntoInput,
+          onClose: handleClose,
+          agent
+        }
+      ) }),
+      ui.activeOverlay === "prompt-add-choice" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_PromptAddChoice.default,
+        {
+          ref: promptAddChoiceRef,
+          isVisible: true,
+          onSelect: handlePromptAddChoice,
+          onClose: handlePromptAddChoiceClose
+        }
+      ) }),
+      ui.activeOverlay === "prompt-add-wizard" && ui.promptAddWizard && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_PromptAddWizard.default,
+        {
+          ref: promptAddWizardRef,
+          isVisible: true,
+          scope: ui.promptAddWizard.scope,
+          onComplete: handlePromptAddComplete,
+          onClose: handlePromptAddWizardClose
+        }
+      ),
+      ui.activeOverlay === "prompt-delete-selector" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_PromptDeleteSelector.default,
+        {
+          ref: promptDeleteSelectorRef,
+          isVisible: true,
+          onDelete: handlePromptDelete,
+          onClose: handlePromptDeleteClose,
+          agent
+        }
+      ) }),
+      ui.activeOverlay === "session-rename" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_SessionRenameOverlay.default,
+        {
+          ref: sessionRenameRef,
+          isVisible: true,
+          currentTitle: currentSessionTitle,
+          onRename: handleSessionRename,
+          onClose: handleSessionRenameClose
+        }
+      ),
+      ui.activeOverlay === "context-stats" && session.id && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_ContextStatsOverlay.default,
+        {
+          ref: contextStatsRef,
+          isVisible: true,
+          onClose: handleClose,
+          agent,
+          sessionId: session.id ?? ""
+        }
+      ) }),
+      ui.activeOverlay === "export-wizard" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_ExportWizard.default,
+        {
+          ref: exportWizardRef,
+          isVisible: true,
+          agent,
+          sessionId: session.id,
+          onClose: handleClose
+        }
+      )
+    ] });
+    return hideCliChrome ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_FocusOverlayFrame.FocusOverlayFrame, { children: overlayContent }) : overlayContent;
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OverlayContainer
+});