@dexto/tui 1.6.2

package/dist/components/overlays/ContextStatsOverlay.js

@@ -0,0 +1,334 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useEffect, forwardRef, useImperativeHandle } from "react";
+import { Box, Text } from "ink";
+const BREAKDOWN_ITEMS = [
+  "systemPrompt",
+  "tools",
+  "messages",
+  "freeSpace",
+  "autoCompactBuffer"
+];
+const ITEM_COLORS = {
+  systemPrompt: "cyan",
+  tools: "yellow",
+  messages: "blue",
+  freeSpace: "gray",
+  autoCompactBuffer: "magenta"
+};
+function formatTokens(tokens) {
+  if (tokens >= 1e3) {
+    return `${(tokens / 1e3).toFixed(1)}k`;
+  }
+  return tokens.toLocaleString();
+}
+function createStackedBar(breakdown, maxContextTokens, thresholdPercent, totalWidth = 40) {
+  const segments = [];
+  const autoCompactBuffer = thresholdPercent > 0 && thresholdPercent < 1 ? Math.floor(maxContextTokens * (1 - thresholdPercent) / thresholdPercent) : 0;
+  const totalTokenSpace = maxContextTokens + autoCompactBuffer;
+  const usedTokens = breakdown.systemPrompt + breakdown.tools.total + breakdown.messages;
+  const freeTokens = Math.max(0, maxContextTokens - usedTokens);
+  const getWidth = (tokens) => {
+    if (tokens <= 0) return 0;
+    const proportional = Math.round(tokens / totalTokenSpace * totalWidth);
+    return Math.max(1, proportional);
+  };
+  const sysWidth = getWidth(breakdown.systemPrompt);
+  const toolsWidth = getWidth(breakdown.tools.total);
+  const msgsWidth = getWidth(breakdown.messages);
+  const freeWidth = getWidth(freeTokens);
+  const reservedWidth = getWidth(autoCompactBuffer);
+  const totalUsed = sysWidth + toolsWidth + msgsWidth + freeWidth + reservedWidth;
+  const adjustment = totalUsed - totalWidth;
+  const adjustedFreeWidth = Math.max(0, freeWidth - adjustment);
+  if (sysWidth > 0) {
+    segments.push({
+      char: "\u2588",
+      color: ITEM_COLORS.systemPrompt,
+      width: sysWidth,
+      item: "systemPrompt"
+    });
+  }
+  if (toolsWidth > 0) {
+    segments.push({ char: "\u2588", color: ITEM_COLORS.tools, width: toolsWidth, item: "tools" });
+  }
+  if (msgsWidth > 0) {
+    segments.push({
+      char: "\u2588",
+      color: ITEM_COLORS.messages,
+      width: msgsWidth,
+      item: "messages"
+    });
+  }
+  if (adjustedFreeWidth > 0) {
+    segments.push({ char: "\u2591", color: "gray", width: adjustedFreeWidth, item: "freeSpace" });
+  }
+  if (reservedWidth > 0) {
+    segments.push({
+      char: "\u2592",
+      color: ITEM_COLORS.autoCompactBuffer,
+      width: reservedWidth,
+      item: "autoCompactBuffer"
+    });
+  }
+  return segments;
+}
+const ContextStatsOverlay = forwardRef(
+  function ContextStatsOverlay2({ isVisible, onClose, agent, sessionId }, ref) {
+    const [stats, setStats] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [expandedSections, setExpandedSections] = useState(/* @__PURE__ */ new Set());
+    useEffect(() => {
+      if (!isVisible) {
+        setStats(null);
+        setError(null);
+        setSelectedIndex(0);
+        setExpandedSections(/* @__PURE__ */ new Set());
+        return;
+      }
+      let cancelled = false;
+      setIsLoading(true);
+      const fetchStats = async () => {
+        try {
+          const contextStats = await agent.getContextStats(sessionId);
+          if (!cancelled) {
+            setStats(contextStats);
+            setIsLoading(false);
+          }
+        } catch (err) {
+          if (!cancelled) {
+            setError(err instanceof Error ? err.message : String(err));
+            setIsLoading(false);
+          }
+        }
+      };
+      fetchStats();
+      return () => {
+        cancelled = true;
+      };
+    }, [isVisible, agent, sessionId]);
+    useImperativeHandle(
+      ref,
+      () => ({
+        handleInput: (_input, key) => {
+          if (!isVisible) return false;
+          if (key.escape || _input === "q") {
+            onClose();
+            return true;
+          }
+          if (key.upArrow) {
+            setSelectedIndex((prev) => Math.max(0, prev - 1));
+            return true;
+          }
+          if (key.downArrow) {
+            setSelectedIndex((prev) => Math.min(BREAKDOWN_ITEMS.length - 1, prev + 1));
+            return true;
+          }
+          if (key.return) {
+            const item = BREAKDOWN_ITEMS[selectedIndex];
+            if (item === "tools") {
+              setExpandedSections((prev) => {
+                const next = new Set(prev);
+                if (next.has(item)) {
+                  next.delete(item);
+                } else {
+                  next.add(item);
+                }
+                return next;
+              });
+              return true;
+            }
+          }
+          return false;
+        }
+      }),
+      [isVisible, onClose, selectedIndex]
+    );
+    if (!isVisible) return null;
+    if (isLoading) {
+      return /* @__PURE__ */ jsxs(
+        Box,
+        {
+          flexDirection: "column",
+          borderStyle: "round",
+          borderColor: "cyan",
+          paddingX: 2,
+          paddingY: 1,
+          children: [
+            /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u{1F4CA} Context Usage" }),
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: "Loading..." })
+          ]
+        }
+      );
+    }
+    if (error) {
+      return /* @__PURE__ */ jsxs(
+        Box,
+        {
+          flexDirection: "column",
+          borderStyle: "round",
+          borderColor: "red",
+          paddingX: 2,
+          paddingY: 1,
+          children: [
+            /* @__PURE__ */ jsx(Text, { color: "red", bold: true, children: "Error" }),
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: error }),
+            /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "Press Esc to close" }) })
+          ]
+        }
+      );
+    }
+    if (!stats) return null;
+    const autoCompactBuffer = stats.thresholdPercent > 0 && stats.thresholdPercent < 1 ? Math.floor(
+      stats.maxContextTokens * (1 - stats.thresholdPercent) / stats.thresholdPercent
+    ) : 0;
+    const totalTokenSpace = stats.maxContextTokens + autoCompactBuffer;
+    const pct = (tokens) => {
+      const percent = totalTokenSpace > 0 ? (tokens / totalTokenSpace * 100).toFixed(1) : "0.0";
+      return `${percent}%`;
+    };
+    const usedTokens = stats.estimatedTokens + autoCompactBuffer;
+    const tokenDisplay = `~${formatTokens(usedTokens)}`;
+    const isToolsExpanded = expandedSections.has("tools");
+    const barSegments = createStackedBar(
+      stats.breakdown,
+      stats.maxContextTokens,
+      stats.thresholdPercent
+    );
+    const renderRow = (index, item, label, tokens, isLast, expandable) => {
+      const isSelected = selectedIndex === index;
+      const prefix = isLast ? "\u2514\u2500" : "\u251C\u2500";
+      const expandIcon = expandable ? isToolsExpanded ? "\u25BC" : "\u25B6" : " ";
+      const itemColor = ITEM_COLORS[item];
+      const indicator = item === "freeSpace" ? "\u2591" : item === "autoCompactBuffer" ? "\u2592" : "\u2588";
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { color: isSelected ? "white" : "gray", children: [
+          prefix,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx(Text, { color: itemColor, bold: isSelected, children: indicator }),
+        /* @__PURE__ */ jsxs(Text, { color: isSelected ? "white" : "gray", bold: isSelected, children: [
+          " ",
+          expandIcon,
+          " ",
+          label,
+          ": ",
+          formatTokens(tokens),
+          " (",
+          pct(tokens),
+          ")"
+        ] }),
+        isSelected && expandable && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+          " ",
+          "(Enter to ",
+          isToolsExpanded ? "collapse" : "expand",
+          ")"
+        ] })
+      ] }, item);
+    };
+    const freeTokens = Math.max(0, stats.maxContextTokens - stats.estimatedTokens);
+    const bufferPercent = Math.round((1 - stats.thresholdPercent) * 100);
+    return /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "cyan",
+        paddingX: 2,
+        paddingY: 1,
+        children: [
+          /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+            /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u{1F4CA} Context Usage" }),
+            /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+              " - ",
+              stats.modelDisplayName
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx(Box, { children: barSegments.map((segment, idx) => {
+            const isHighlighted = BREAKDOWN_ITEMS[selectedIndex] === segment.item;
+            return /* @__PURE__ */ jsx(Text, { color: "white", children: isHighlighted ? "\u25BC".repeat(segment.width) : " ".repeat(segment.width) }, idx);
+          }) }),
+          /* @__PURE__ */ jsx(Box, { children: barSegments.map((segment, idx) => /* @__PURE__ */ jsx(Text, { color: segment.color, children: segment.char.repeat(segment.width) }, idx)) }),
+          /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+            /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+              tokenDisplay,
+              " / ",
+              formatTokens(totalTokenSpace),
+              " tokens"
+            ] }),
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: " \u2022 " }),
+            /* @__PURE__ */ jsxs(
+              Text,
+              {
+                color: stats.usagePercent > 80 ? "red" : stats.usagePercent > 60 ? "yellow" : "green",
+                children: [
+                  stats.usagePercent,
+                  "% used"
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx(Text, { color: "white", children: "Breakdown:" }),
+            renderRow(
+              0,
+              "systemPrompt",
+              "System prompt",
+              stats.breakdown.systemPrompt,
+              false
+            ),
+            renderRow(
+              1,
+              "tools",
+              `Tools (${stats.breakdown.tools.perTool.length})`,
+              stats.breakdown.tools.total,
+              false,
+              true
+            ),
+            isToolsExpanded && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginLeft: 4, children: stats.breakdown.tools.perTool.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "No tools registered" }) : [...stats.breakdown.tools.perTool].sort((a, b) => b.tokens - a.tokens).map((tool, idx, arr) => /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+              idx === arr.length - 1 ? "\u2514\u2500" : "\u251C\u2500",
+              " ",
+              /* @__PURE__ */ jsx(Text, { color: "yellow", dimColor: true, children: tool.name }),
+              ": ",
+              formatTokens(tool.tokens),
+              " (",
+              pct(tool.tokens),
+              ")"
+            ] }, tool.name)) }),
+            renderRow(2, "messages", "Messages", stats.breakdown.messages, false),
+            renderRow(3, "freeSpace", "Free space", freeTokens, false),
+            renderRow(
+              4,
+              "autoCompactBuffer",
+              bufferPercent > 0 ? `Auto compact buffer (${bufferPercent}%)` : "Auto compact buffer",
+              autoCompactBuffer,
+              true
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+              "Messages: ",
+              stats.filteredMessageCount,
+              " visible (",
+              stats.messageCount,
+              " total)"
+            ] }),
+            stats.prunedToolCount > 0 && /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+              "\u{1F5D1}\uFE0F ",
+              stats.prunedToolCount,
+              " tool output(s) pruned"
+            ] }),
+            stats.hasSummary && /* @__PURE__ */ jsx(Text, { color: "blue", children: "\u{1F4E6} Context has been compacted (summary present)" }),
+            stats.usagePercent > 100 && /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u{1F4A1} Use /compact to manually compact, or send a message to trigger auto-compaction" })
+          ] }),
+          /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "\u2191\u2193: navigate | Enter: expand/collapse | Esc: close" }) })
+        ]
+      }
+    );
+  }
+);
+var ContextStatsOverlay_default = ContextStatsOverlay;
+export {
+  ContextStatsOverlay_default as default
+};

package/dist/components/overlays/CustomModelWizard.cjs

@@ -0,0 +1,362 @@
+"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 CustomModelWizard_exports = {};
+__export(CustomModelWizard_exports, {
+  default: () => CustomModelWizard_default
+});
+module.exports = __toCommonJS(CustomModelWizard_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_ink = require("ink");
+var import_agent_management = require("@dexto/agent-management");
+var import_core = require("@dexto/core");
+var import_provider_config = require("./custom-model-wizard/provider-config.js");
+var import_shared = require("./custom-model-wizard/shared/index.js");
+var import_LocalModelWizard = __toESM(require("./custom-model-wizard/LocalModelWizard.js"), 1);
+const CustomModelWizard = (0, import_react.forwardRef)(
+  function CustomModelWizard2({ isVisible, onComplete, onClose, initialModel }, ref) {
+    const [selectedProvider, setSelectedProvider] = (0, import_react.useState)(null);
+    const [providerIndex, setProviderIndex] = (0, import_react.useState)(0);
+    const [currentStep, setCurrentStep] = (0, import_react.useState)(0);
+    const [values, setValues] = (0, import_react.useState)({});
+    const [currentInput, setCurrentInput] = (0, import_react.useState)("");
+    const [error, setError] = (0, import_react.useState)(null);
+    const [isSaving, setIsSaving] = (0, import_react.useState)(false);
+    const [isValidating, setIsValidating] = (0, import_react.useState)(false);
+    const [originalName, setOriginalName] = (0, import_react.useState)(null);
+    const isEditing = initialModel !== null && initialModel !== void 0;
+    const localModelWizardRef = (0, import_react.useRef)(null);
+    const providerConfig = selectedProvider ? (0, import_provider_config.getProviderConfig)(selectedProvider) : null;
+    const allWizardSteps = providerConfig?.steps ?? [];
+    const getVisibleSteps = (0, import_react.useCallback)(
+      (currentValues) => {
+        return allWizardSteps.filter(
+          (step) => !step.condition || step.condition(currentValues)
+        );
+      },
+      [allWizardSteps]
+    );
+    const visibleSteps = getVisibleSteps(values);
+    const currentStepConfig = visibleSteps[currentStep];
+    (0, import_react.useEffect)(() => {
+      if (isVisible) {
+        if (initialModel) {
+          const provider = initialModel.provider ?? "openai-compatible";
+          const providers = (0, import_provider_config.getAvailableProviders)();
+          setSelectedProvider(provider);
+          setOriginalName(initialModel.name);
+          setValues({
+            name: initialModel.name,
+            baseURL: initialModel.baseURL ?? "",
+            displayName: initialModel.displayName ?? "",
+            maxInputTokens: initialModel.maxInputTokens?.toString() ?? "",
+            reasoningPreset: initialModel.reasoning?.variant ?? "",
+            apiKey: initialModel.apiKey ?? "",
+            filePath: initialModel.filePath ?? ""
+          });
+          setCurrentStep(0);
+          setCurrentInput(initialModel.name);
+          const idx = providers.indexOf(provider);
+          setProviderIndex(idx >= 0 ? idx : 0);
+        } else {
+          setSelectedProvider(null);
+          setOriginalName(null);
+          setProviderIndex(0);
+          setCurrentStep(0);
+          setValues({});
+          setCurrentInput("");
+        }
+        setError(null);
+        setIsSaving(false);
+        setIsValidating(false);
+      }
+    }, [isVisible, initialModel]);
+    const handleProviderSelect = (0, import_react.useCallback)(() => {
+      const provider = (0, import_provider_config.getProviderByMenuIndex)(providerIndex);
+      if (provider) {
+        setSelectedProvider(provider);
+        setCurrentStep(0);
+        setCurrentInput("");
+        setError(null);
+      }
+    }, [providerIndex]);
+    const handleNext = (0, import_react.useCallback)(async () => {
+      if (!currentStepConfig || !selectedProvider || isSaving || isValidating) return;
+      const value = currentInput.trim();
+      if (currentStepConfig.validate) {
+        const validationError = currentStepConfig.validate(value);
+        if (validationError) {
+          setError(validationError);
+          return;
+        }
+      } else if (currentStepConfig.required && !value) {
+        setError(`${currentStepConfig.label} is required`);
+        return;
+      }
+      const asyncError = await (async () => {
+        setIsValidating(true);
+        setError(null);
+        try {
+          return await (0, import_provider_config.runAsyncValidation)(
+            selectedProvider,
+            currentStepConfig.field,
+            value
+          );
+        } finally {
+          setIsValidating(false);
+        }
+      })();
+      if (asyncError) {
+        setError(asyncError);
+        return;
+      }
+      const newValues = { ...values, [currentStepConfig.field]: value };
+      setValues(newValues);
+      setError(null);
+      setCurrentInput("");
+      const updatedVisibleSteps = getVisibleSteps(newValues);
+      if (currentStep >= updatedVisibleSteps.length - 1) {
+        await saveModel(newValues);
+      } else {
+        const nextStep = currentStep + 1;
+        setCurrentStep(nextStep);
+        const nextStepConfig = updatedVisibleSteps[nextStep];
+        const nextValue = nextStepConfig ? newValues[nextStepConfig.field] : void 0;
+        setCurrentInput(nextValue ?? "");
+      }
+    }, [
+      currentInput,
+      currentStep,
+      currentStepConfig,
+      getVisibleSteps,
+      isSaving,
+      isValidating,
+      selectedProvider,
+      values
+    ]);
+    const saveModel = (0, import_react.useCallback)(
+      async (finalValues) => {
+        if (!selectedProvider || !providerConfig) return;
+        const model = providerConfig.buildModel(finalValues, selectedProvider);
+        const userEnteredKey = finalValues.apiKey?.trim();
+        const providerKeyStatus = (0, import_agent_management.getProviderKeyStatus)(selectedProvider);
+        const existingProviderKey = (0, import_agent_management.resolveApiKeyForProvider)(
+          selectedProvider
+        );
+        const keyStorage = (0, import_agent_management.determineApiKeyStorage)(
+          selectedProvider,
+          userEnteredKey,
+          providerKeyStatus.hasApiKey,
+          existingProviderKey
+        );
+        if (keyStorage.saveToProviderEnvVar && userEnteredKey) {
+          try {
+            await (0, import_agent_management.saveProviderApiKey)(
+              selectedProvider,
+              userEnteredKey,
+              process.cwd()
+            );
+          } catch (err) {
+            import_core.logger.warn(
+              `Failed to save provider API key: ${err instanceof Error ? err.message : "Unknown error"}`
+            );
+            keyStorage.saveAsPerModel = true;
+          }
+        }
+        if (keyStorage.saveAsPerModel && userEnteredKey) {
+          model.apiKey = userEnteredKey;
+        }
+        setIsSaving(true);
+        try {
+          if (originalName && originalName !== model.name) {
+            try {
+              await (0, import_agent_management.deleteCustomModel)(originalName);
+            } catch (err) {
+              import_core.logger.warn(
+                `Failed to delete old model "${originalName}" during rename: ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          }
+          await (0, import_agent_management.saveCustomModel)(model);
+          onComplete(model);
+        } catch (err) {
+          import_core.logger.error(
+            `Failed to save custom model: ${err instanceof Error ? err.message : "Unknown error"}`
+          );
+          setError(
+            `Failed to save: ${err instanceof Error ? err.message : "Unknown error"}`
+          );
+          setIsSaving(false);
+        }
+      },
+      [selectedProvider, providerConfig, originalName, onComplete]
+    );
+    const handleBack = (0, import_react.useCallback)(() => {
+      if (currentStep > 0) {
+        setCurrentStep(currentStep - 1);
+        const prevStep = visibleSteps[currentStep - 1];
+        if (prevStep) {
+          setCurrentInput(values[prevStep.field] || "");
+        }
+        setError(null);
+      } else if (selectedProvider) {
+        setSelectedProvider(null);
+        setError(null);
+      } else {
+        onClose();
+      }
+    }, [currentStep, onClose, selectedProvider, values, visibleSteps]);
+    (0, import_react.useImperativeHandle)(
+      ref,
+      () => ({
+        handleInput: (input, key) => {
+          if (!isVisible || isSaving || isValidating) return false;
+          if (selectedProvider === "local" && localModelWizardRef.current) {
+            return localModelWizardRef.current.handleInput(input, key);
+          }
+          if (key.escape) {
+            handleBack();
+            return true;
+          }
+          if (!selectedProvider) {
+            const providers = (0, import_provider_config.getAvailableProviders)();
+            if (key.upArrow) {
+              setProviderIndex(
+                (prev) => prev > 0 ? prev - 1 : providers.length - 1
+              );
+              return true;
+            }
+            if (key.downArrow) {
+              setProviderIndex(
+                (prev) => prev < providers.length - 1 ? prev + 1 : 0
+              );
+              return true;
+            }
+            if (key.return) {
+              handleProviderSelect();
+              return true;
+            }
+            return true;
+          }
+          if (key.return) {
+            void handleNext();
+            return true;
+          }
+          if (key.backspace || key.delete) {
+            setCurrentInput((prev) => prev.slice(0, -1));
+            setError(null);
+            return true;
+          }
+          if (input && !key.ctrl && !key.meta) {
+            setCurrentInput((prev) => prev + input);
+            setError(null);
+            return true;
+          }
+          return false;
+        }
+      }),
+      [
+        isVisible,
+        isSaving,
+        isValidating,
+        handleBack,
+        handleNext,
+        handleProviderSelect,
+        selectedProvider
+      ]
+    );
+    if (!isVisible) return null;
+    if (!selectedProvider) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_shared.ProviderSelector, { selectedIndex: providerIndex, isEditing });
+    }
+    if (selectedProvider === "local") {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_LocalModelWizard.default,
+        {
+          ref: localModelWizardRef,
+          isVisible,
+          onComplete,
+          onClose: () => {
+            setSelectedProvider(null);
+          }
+        }
+      );
+    }
+    if (!currentStepConfig || !providerConfig) return null;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+      import_ink.Box,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "green",
+        paddingX: 1,
+        marginTop: 1,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Box, { marginBottom: 1, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Text, { bold: true, color: "green", children: isEditing ? "Edit Custom Model" : "Add Custom Model" }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { color: "gray", children: [
+              " ",
+              "(",
+              providerConfig.displayName,
+              ") Step ",
+              currentStep + 1,
+              "/",
+              visibleSteps.length
+            ] })
+          ] }),
+          providerConfig.setupInfo && currentStep === 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_shared.SetupInfoBanner,
+            {
+              title: providerConfig.setupInfo.title,
+              description: providerConfig.setupInfo.description,
+              docsUrl: providerConfig.setupInfo.docsUrl
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_shared.WizardStepInput,
+            {
+              step: currentStepConfig,
+              currentInput,
+              error,
+              isValidating,
+              isSaving,
+              additionalContent: currentStepConfig.field === "apiKey" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_shared.ApiKeyStep, { provider: selectedProvider }) : void 0
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { color: "gray", children: [
+            "Enter to continue \u2022 Esc to",
+            " ",
+            currentStep > 0 ? "go back" : "back to provider"
+          ] }) })
+        ]
+      }
+    );
+  }
+);
+var CustomModelWizard_default = CustomModelWizard;