@shareai-lab/kode 2.0.1 → 2.0.3

package/dist/chunks/chunk-7X3TW4JB.js

@@ -0,0 +1,4520 @@
+import {
+  Select
+} from "./chunk-3TNIOEBO.js";
+import {
+  PressEnterToContinue
+} from "./chunk-2QONJ5MG.js";
+import {
+  models_default
+} from "./chunk-2WEXPKHH.js";
+import {
+  fetchCustomModels,
+  providers
+} from "./chunk-IFCIADS3.js";
+import {
+  normalizeLineEndings,
+  shouldAggregatePasteChunk,
+  shouldTreatAsSpecialPaste
+} from "./chunk-7RRW4NTB.js";
+import {
+  getTheme
+} from "./chunk-T7RB5V5J.js";
+import {
+  wrapText
+} from "./chunk-GELCZWMB.js";
+import {
+  verifyApiKey
+} from "./chunk-BHDHXOXB.js";
+import {
+  getModelManager
+} from "./chunk-6ZWEOSEI.js";
+import {
+  debug
+} from "./chunk-YIO5EBMQ.js";
+import {
+  ASCII_LOGO,
+  PRODUCT_NAME
+} from "./chunk-3OEJVB5A.js";
+import {
+  DEFAULT_GLOBAL_CONFIG,
+  getGlobalConfig,
+  saveGlobalConfig,
+  setAllPointersToModel,
+  setModelPointer,
+  testGPT5Connection,
+  validateGPT5Config
+} from "./chunk-XR2W3MAM.js";
+import {
+  __export
+} from "./chunk-54KOYG5C.js";
+
+// apps/cli/src/ui/hooks/useExitOnCtrlCD.ts
+import { useInput } from "ink";
+
+// apps/cli/src/ui/hooks/useDoublePress.ts
+import { useRef } from "react";
+var DOUBLE_PRESS_TIMEOUT_MS = 2e3;
+function useDoublePress(setPending, onDoublePress, onFirstPress) {
+  const lastPressRef = useRef(0);
+  const timeoutRef = useRef(void 0);
+  return () => {
+    const now = Date.now();
+    const timeSinceLastPress = now - lastPressRef.current;
+    if (timeSinceLastPress <= DOUBLE_PRESS_TIMEOUT_MS && timeoutRef.current) {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+        timeoutRef.current = void 0;
+      }
+      onDoublePress();
+      setPending(false);
+    } else {
+      onFirstPress?.();
+      setPending(true);
+      timeoutRef.current = setTimeout(
+        () => setPending(false),
+        DOUBLE_PRESS_TIMEOUT_MS
+      );
+    }
+    lastPressRef.current = now;
+  };
+}
+
+// apps/cli/src/ui/hooks/useExitOnCtrlCD.ts
+import { useState } from "react";
+function useExitOnCtrlCD(onExit) {
+  const [exitState, setExitState] = useState({
+    pending: false,
+    keyName: null
+  });
+  const handleCtrlC = useDoublePress(
+    (pending) => setExitState({ pending, keyName: "Ctrl-C" }),
+    onExit
+  );
+  const handleCtrlD = useDoublePress(
+    (pending) => setExitState({ pending, keyName: "Ctrl-D" }),
+    onExit
+  );
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") handleCtrlC();
+    if (key.ctrl && input === "d") handleCtrlD();
+  });
+  return exitState;
+}
+
+// apps/cli/src/utils/terminal.ts
+function setTerminalTitle(title) {
+  if (process.platform === "win32") {
+    process.title = title ? `\u2733 ${title}` : title;
+  } else {
+    process.stdout.write(`\x1B]0;${title ? `\u2733 ${title}` : ""}\x07`);
+  }
+}
+function clearTerminal() {
+  return new Promise((resolve) => {
+    process.stdout.write("\x1B[2J\x1B[3J\x1B[H", () => {
+      resolve();
+    });
+  });
+}
+
+// apps/cli/src/ui/components/Onboarding.tsx
+import React20, { useState as useState4 } from "react";
+import { Box as Box17, Newline as Newline8, Text as Text18, useInput as useInput5 } from "ink";
+import { OrderedList } from "@inkjs/ui";
+
+// apps/cli/src/ui/components/Logo.tsx
+import { Box, Text } from "ink";
+import * as React from "react";
+var MIN_LOGO_WIDTH = 60;
+function Logo({
+  mcpClients,
+  updateBannerVersion,
+  terminalColumns
+}) {
+  const theme = getTheme();
+  const connected = mcpClients.filter((c) => c.type === "connected");
+  const failed = mcpClients.filter((c) => c.type !== "connected");
+  const separatorWidth = Math.min(terminalColumns || 80, 80) - 16;
+  const separator = "\u2500".repeat(Math.max(separatorWidth, 20));
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, updateBannerVersion && /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "Update ", updateBannerVersion, " available: npm i -g @shareai-lab/kode@latest")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: theme.kode }, ASCII_LOGO)), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "/init", "  ", "/help", "  ", /* @__PURE__ */ React.createElement(Text, { color: theme.bashBorder }, "!"), "shell", "  ", /* @__PURE__ */ React.createElement(Text, { color: theme.notingBorder }, "#"), "note", "  ", "@file", "  ", "opt+m", "  ", "opt+g")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", marginTop: 2 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "\u2500\u2500 MCP Servers ", separator), /* @__PURE__ */ React.createElement(Box, { marginTop: 1, paddingLeft: 3 }, mcpClients.length === 0 ? /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "No servers configured - run: kode mcp add ", "<name>") : /* @__PURE__ */ React.createElement(React.Fragment, null, connected.map((c) => /* @__PURE__ */ React.createElement(Text, { key: c.name }, /* @__PURE__ */ React.createElement(Text, { color: theme.success }, c.name), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "   "))), failed.map((c) => /* @__PURE__ */ React.createElement(Text, { key: c.name }, /* @__PURE__ */ React.createElement(Text, { color: theme.error }, c.name), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "   ")))))));
+}
+
+// apps/cli/src/ui/components/StructuredDiff.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import * as React2 from "react";
+import { useMemo } from "react";
+function StructuredDiff({
+  patch,
+  dim,
+  width,
+  overrideTheme
+}) {
+  const diff = useMemo(
+    () => formatDiff(patch.lines, patch.oldStart, width, dim, overrideTheme),
+    [patch.lines, patch.oldStart, width, dim, overrideTheme]
+  );
+  return diff.map((_, i) => /* @__PURE__ */ React2.createElement(Box2, { key: i }, _));
+}
+function formatDiff(lines, startingLineNumber, width, dim, overrideTheme) {
+  const theme = getTheme(overrideTheme);
+  const ls = numberDiffLines(
+    lines.map((code) => {
+      if (code.startsWith("+")) {
+        return {
+          code: " " + code.slice(1),
+          i: 0,
+          type: "add"
+        };
+      }
+      if (code.startsWith("-")) {
+        return {
+          code: " " + code.slice(1),
+          i: 0,
+          type: "remove"
+        };
+      }
+      return { code, i: 0, type: "nochange" };
+    }),
+    startingLineNumber
+  );
+  const maxLineNumber = Math.max(...ls.map(({ i }) => i));
+  const maxWidth = maxLineNumber.toString().length;
+  return ls.flatMap(({ type, code, i }) => {
+    const wrappedLines = wrapText(code, width - maxWidth);
+    return wrappedLines.map((line, lineIndex) => {
+      const key = `${type}-${i}-${lineIndex}`;
+      switch (type) {
+        case "add":
+          return /* @__PURE__ */ React2.createElement(React2.Fragment, { key }, /* @__PURE__ */ React2.createElement(Text2, null, /* @__PURE__ */ React2.createElement(
+            LineNumber,
+            {
+              i: lineIndex === 0 ? i : void 0,
+              width: maxWidth
+            }
+          ), /* @__PURE__ */ React2.createElement(
+            Text2,
+            {
+              color: overrideTheme ? theme.text : void 0,
+              backgroundColor: dim ? theme.diff.addedDimmed : theme.diff.added,
+              dimColor: dim
+            },
+            line
+          )));
+        case "remove":
+          return /* @__PURE__ */ React2.createElement(React2.Fragment, { key }, /* @__PURE__ */ React2.createElement(Text2, null, /* @__PURE__ */ React2.createElement(
+            LineNumber,
+            {
+              i: lineIndex === 0 ? i : void 0,
+              width: maxWidth
+            }
+          ), /* @__PURE__ */ React2.createElement(
+            Text2,
+            {
+              color: overrideTheme ? theme.text : void 0,
+              backgroundColor: dim ? theme.diff.removedDimmed : theme.diff.removed,
+              dimColor: dim
+            },
+            line
+          )));
+        case "nochange":
+          return /* @__PURE__ */ React2.createElement(React2.Fragment, { key }, /* @__PURE__ */ React2.createElement(Text2, null, /* @__PURE__ */ React2.createElement(
+            LineNumber,
+            {
+              i: lineIndex === 0 ? i : void 0,
+              width: maxWidth
+            }
+          ), /* @__PURE__ */ React2.createElement(
+            Text2,
+            {
+              color: overrideTheme ? theme.text : void 0,
+              dimColor: dim
+            },
+            line
+          )));
+      }
+    });
+  });
+}
+function LineNumber({
+  i,
+  width
+}) {
+  return /* @__PURE__ */ React2.createElement(Text2, { color: getTheme().secondaryText }, i !== void 0 ? i.toString().padStart(width) : " ".repeat(width), " ");
+}
+function numberDiffLines(diff, startLine) {
+  let i = startLine;
+  const result = [];
+  const queue = [...diff];
+  while (queue.length > 0) {
+    const { code, type } = queue.shift();
+    const line = {
+      code,
+      type,
+      i
+    };
+    switch (type) {
+      case "nochange":
+        i++;
+        result.push(line);
+        break;
+      case "add":
+        i++;
+        result.push(line);
+        break;
+      case "remove": {
+        result.push(line);
+        let numRemoved = 0;
+        while (queue[0]?.type === "remove") {
+          i++;
+          const { code: code2, type: type2 } = queue.shift();
+          const line2 = {
+            code: code2,
+            type: type2,
+            i
+          };
+          result.push(line2);
+          numRemoved++;
+        }
+        i -= numRemoved;
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+// apps/cli/src/ui/components/ModelSelector/ModelSelector.tsx
+import * as React19 from "react";
+
+// apps/cli/src/ui/components/ModelSelector/ModelSelectorView.tsx
+import * as React18 from "react";
+import { Box as Box16, Text as Text17 } from "ink";
+import figures from "figures";
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ApiKeyScreen.tsx
+import React5 from "react";
+import { Box as Box3, Newline, Text as Text4 } from "ink";
+
+// apps/cli/src/ui/components/TextInput.tsx
+import React4 from "react";
+import { Text as Text3, useInput as useInput2 } from "ink";
+import chalk from "chalk";
+
+// apps/cli/src/ui/hooks/useTextInput.ts
+import { useState as useState2 } from "react";
+
+// apps/cli/src/utils/Cursor/MeasuredText.ts
+import wrapAnsi from "wrap-ansi";
+var WrappedLine = class {
+  constructor(text, startOffset, isPrecededByNewline, endsWithNewline = false) {
+    this.text = text;
+    this.startOffset = startOffset;
+    this.isPrecededByNewline = isPrecededByNewline;
+    this.endsWithNewline = endsWithNewline;
+  }
+  equals(other) {
+    return this.text === other.text && this.startOffset === other.startOffset;
+  }
+  get length() {
+    return this.text.length + (this.endsWithNewline ? 1 : 0);
+  }
+};
+var MeasuredText = class {
+  constructor(text, columns) {
+    this.text = text;
+    this.columns = columns;
+    this.wrappedLines = this.measureWrappedText();
+  }
+  wrappedLines;
+  measureWrappedText() {
+    const wrappedText = wrapAnsi(this.text, this.columns, {
+      hard: true,
+      trim: false
+    });
+    const wrappedLines = [];
+    let searchOffset = 0;
+    let lastNewLinePos = -1;
+    const lines = wrappedText.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const text = lines[i];
+      const isPrecededByNewline = (startOffset) => i == 0 || startOffset > 0 && this.text[startOffset - 1] === "\n";
+      if (text.length === 0) {
+        lastNewLinePos = this.text.indexOf("\n", lastNewLinePos + 1);
+        if (lastNewLinePos !== -1) {
+          const startOffset = lastNewLinePos;
+          const endsWithNewline = true;
+          wrappedLines.push(
+            new WrappedLine(
+              text,
+              startOffset,
+              isPrecededByNewline(startOffset),
+              endsWithNewline
+            )
+          );
+        } else {
+          const startOffset = this.text.length;
+          wrappedLines.push(
+            new WrappedLine(
+              text,
+              startOffset,
+              isPrecededByNewline(startOffset),
+              false
+            )
+          );
+        }
+      } else {
+        const startOffset = this.text.indexOf(text, searchOffset);
+        if (startOffset === -1) {
+          debug.error("CURSOR_WRAP_MISMATCH", {
+            currentText: text,
+            originalText: this.text,
+            searchOffset,
+            wrappedText
+          });
+          throw new Error("Failed to find wrapped line in original text");
+        }
+        searchOffset = startOffset + text.length;
+        const potentialNewlinePos = startOffset + text.length;
+        const endsWithNewline = potentialNewlinePos < this.text.length && this.text[potentialNewlinePos] === "\n";
+        if (endsWithNewline) {
+          lastNewLinePos = potentialNewlinePos;
+        }
+        wrappedLines.push(
+          new WrappedLine(
+            text,
+            startOffset,
+            isPrecededByNewline(startOffset),
+            endsWithNewline
+          )
+        );
+      }
+    }
+    return wrappedLines;
+  }
+  getWrappedText() {
+    return this.wrappedLines.map(
+      (line) => line.isPrecededByNewline ? line.text : line.text.trimStart()
+    );
+  }
+  getLine(line) {
+    return this.wrappedLines[Math.max(0, Math.min(line, this.wrappedLines.length - 1))];
+  }
+  getOffsetFromPosition(position) {
+    const wrappedLine = this.getLine(position.line);
+    const startOffsetPlusColumn = wrappedLine.startOffset + position.column;
+    if (wrappedLine.text.length === 0 && wrappedLine.endsWithNewline) {
+      return wrappedLine.startOffset;
+    }
+    const lineEnd = wrappedLine.startOffset + wrappedLine.text.length;
+    const maxOffset = wrappedLine.endsWithNewline ? lineEnd + 1 : lineEnd;
+    return Math.min(startOffsetPlusColumn, maxOffset);
+  }
+  getLineLength(line) {
+    const currentLine = this.getLine(line);
+    const nextLine = this.getLine(line + 1);
+    if (nextLine.equals(currentLine)) {
+      return this.text.length - currentLine.startOffset;
+    }
+    return nextLine.startOffset - currentLine.startOffset - 1;
+  }
+  getPositionFromOffset(offset) {
+    const lines = this.wrappedLines;
+    for (let line2 = 0; line2 < lines.length; line2++) {
+      const currentLine = lines[line2];
+      const nextLine = lines[line2 + 1];
+      if (offset >= currentLine.startOffset && (!nextLine || offset < nextLine.startOffset)) {
+        const leadingWhitepace = currentLine.isPrecededByNewline ? 0 : currentLine.text.length - currentLine.text.trimStart().length;
+        const column = Math.max(
+          0,
+          Math.min(
+            offset - currentLine.startOffset - leadingWhitepace,
+            currentLine.text.length
+          )
+        );
+        return {
+          line: line2,
+          column
+        };
+      }
+    }
+    const line = lines.length - 1;
+    return {
+      line,
+      column: this.wrappedLines[line].text.length
+    };
+  }
+  get lineCount() {
+    return this.wrappedLines.length;
+  }
+  equals(other) {
+    return this.text === other.text && this.columns === other.columns;
+  }
+};
+
+// apps/cli/src/utils/Cursor.ts
+var Cursor = class _Cursor {
+  constructor(measuredText, offset = 0, selection = 0) {
+    this.measuredText = measuredText;
+    this.selection = selection;
+    this.offset = Math.max(0, Math.min(this.measuredText.text.length, offset));
+  }
+  offset;
+  static fromText(text, columns, offset = 0, selection = 0) {
+    return new _Cursor(new MeasuredText(text, columns - 1), offset, selection);
+  }
+  render(cursorChar, mask, invert) {
+    const { line, column } = this.getPosition();
+    return this.measuredText.getWrappedText().map((text, currentLine, allLines) => {
+      let displayText = text;
+      if (mask && currentLine === allLines.length - 1) {
+        const lastSixStart = Math.max(0, text.length - 6);
+        displayText = mask.repeat(lastSixStart) + text.slice(lastSixStart);
+      }
+      if (line != currentLine) return displayText.trimEnd();
+      return displayText.slice(0, column) + invert(displayText[column] || cursorChar) + displayText.trimEnd().slice(column + 1);
+    }).join("\n");
+  }
+  left() {
+    return new _Cursor(this.measuredText, this.offset - 1);
+  }
+  right() {
+    return new _Cursor(this.measuredText, this.offset + 1);
+  }
+  up() {
+    const { line, column } = this.getPosition();
+    if (line == 0) {
+      return new _Cursor(this.measuredText, 0, 0);
+    }
+    const newOffset = this.getOffset({ line: line - 1, column });
+    return new _Cursor(this.measuredText, newOffset, 0);
+  }
+  down() {
+    const { line, column } = this.getPosition();
+    if (line >= this.measuredText.lineCount - 1) {
+      return new _Cursor(this.measuredText, this.text.length, 0);
+    }
+    const newOffset = this.getOffset({ line: line + 1, column });
+    return new _Cursor(this.measuredText, newOffset, 0);
+  }
+  startOfLine() {
+    const { line } = this.getPosition();
+    return new _Cursor(
+      this.measuredText,
+      this.getOffset({
+        line,
+        column: 0
+      }),
+      0
+    );
+  }
+  endOfLine() {
+    const { line } = this.getPosition();
+    const column = this.measuredText.getLineLength(line);
+    const offset = this.getOffset({ line, column });
+    return new _Cursor(this.measuredText, offset, 0);
+  }
+  nextWord() {
+    let nextCursor = this;
+    while (nextCursor.isOverWordChar() && !nextCursor.isAtEnd()) {
+      nextCursor = nextCursor.right();
+    }
+    while (!nextCursor.isOverWordChar() && !nextCursor.isAtEnd()) {
+      nextCursor = nextCursor.right();
+    }
+    return nextCursor;
+  }
+  prevWord() {
+    let cursor = this;
+    if (!cursor.left().isOverWordChar()) {
+      cursor = cursor.left();
+    }
+    while (!cursor.isOverWordChar() && !cursor.isAtStart()) {
+      cursor = cursor.left();
+    }
+    if (cursor.isOverWordChar()) {
+      while (cursor.left().isOverWordChar() && !cursor.isAtStart()) {
+        cursor = cursor.left();
+      }
+    }
+    return cursor;
+  }
+  modifyText(end, insertString = "") {
+    const startOffset = this.offset;
+    const endOffset = end.offset;
+    const newText = this.text.slice(0, startOffset) + insertString + this.text.slice(endOffset);
+    return _Cursor.fromText(
+      newText,
+      this.columns,
+      startOffset + insertString.length
+    );
+  }
+  insert(insertString) {
+    const newCursor = this.modifyText(this, insertString);
+    return newCursor;
+  }
+  del() {
+    if (this.isAtEnd()) {
+      return this;
+    }
+    return this.modifyText(this.right());
+  }
+  backspace() {
+    if (this.isAtStart()) {
+      return this;
+    }
+    const currentOffset = this.offset;
+    const leftCursor = this.left();
+    const leftOffset = leftCursor.offset;
+    const newText = this.text.slice(0, leftOffset) + this.text.slice(currentOffset);
+    return _Cursor.fromText(newText, this.columns, leftOffset);
+  }
+  deleteToLineStart() {
+    return this.startOfLine().modifyText(this);
+  }
+  deleteToLineEnd() {
+    if (this.text[this.offset] === "\n") {
+      return this.modifyText(this.right());
+    }
+    return this.modifyText(this.endOfLine());
+  }
+  deleteWordBefore() {
+    if (this.isAtStart()) {
+      return this;
+    }
+    return this.prevWord().modifyText(this);
+  }
+  deleteWordAfter() {
+    if (this.isAtEnd()) {
+      return this;
+    }
+    return this.modifyText(this.nextWord());
+  }
+  isOverWordChar() {
+    const currentChar = this.text[this.offset] ?? "";
+    return /\w/.test(currentChar);
+  }
+  equals(other) {
+    return this.offset === other.offset && this.measuredText == other.measuredText;
+  }
+  isAtStart() {
+    return this.offset == 0;
+  }
+  isAtEnd() {
+    return this.offset == this.text.length;
+  }
+  get text() {
+    return this.measuredText.text;
+  }
+  get columns() {
+    return this.measuredText.columns + 1;
+  }
+  getPosition() {
+    return this.measuredText.getPositionFromOffset(this.offset);
+  }
+  getOffset(position) {
+    return this.measuredText.getOffsetFromPosition(position);
+  }
+};
+
+// apps/cli/src/ui/hooks/useTextInputMapping.ts
+function mapInput(inputMap, defaultHandler) {
+  const handlers = new Map(inputMap);
+  return (input) => (handlers.get(input) ?? defaultHandler)(input);
+}
+
+// packages/core/src/utils/imagePaste.ts
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+var SCREENSHOT_PATH = "/tmp/kode_cli_latest_screenshot.png";
+var CLIPBOARD_ERROR_MESSAGE = "No image found in clipboard. Use Cmd + Ctrl + Shift + 4 to copy a screenshot to clipboard.";
+function getImageFromClipboard() {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  try {
+    execSync(`osascript -e 'the clipboard as \xABclass PNGf\xBB'`, {
+      stdio: "ignore"
+    });
+    execSync(
+      `osascript -e 'set png_data to (the clipboard as \xABclass PNGf\xBB)' -e 'set fp to open for access POSIX file "${SCREENSHOT_PATH}" with write permission' -e 'write png_data to fp' -e 'close access fp'`,
+      { stdio: "ignore" }
+    );
+    const imageBuffer = readFileSync(SCREENSHOT_PATH);
+    const base64Image = imageBuffer.toString("base64");
+    execSync(`rm -f "${SCREENSHOT_PATH}"`, { stdio: "ignore" });
+    return base64Image;
+  } catch {
+    return null;
+  }
+}
+
+// apps/cli/src/ui/hooks/useTextInputTryImagePaste.ts
+var IMAGE_PLACEHOLDER = "[Image pasted]";
+function tryImagePaste({
+  cursor,
+  mask,
+  onImagePaste,
+  onMessage,
+  setImagePasteErrorTimeout,
+  clearImagePasteErrorTimeout
+}) {
+  if (mask) {
+    return cursor;
+  }
+  const base64Image = getImageFromClipboard();
+  if (base64Image === null) {
+    if (process.platform !== "darwin") {
+      return cursor;
+    }
+    onMessage?.(true, CLIPBOARD_ERROR_MESSAGE);
+    clearImagePasteErrorTimeout();
+    setImagePasteErrorTimeout(
+      setTimeout(() => {
+        onMessage?.(false);
+      }, 4e3)
+    );
+    return cursor;
+  }
+  const placeholder = onImagePaste?.(base64Image);
+  return cursor.insert(
+    typeof placeholder === "string" ? placeholder : IMAGE_PLACEHOLDER
+  );
+}
+
+// apps/cli/src/ui/hooks/useTextInput.ts
+function useTextInput({
+  value: originalValue,
+  onChange,
+  onSubmit,
+  onExit,
+  onExitMessage,
+  onMessage,
+  onHistoryUp,
+  onHistoryDown,
+  onHistoryReset,
+  mask = "",
+  multiline = false,
+  cursorChar,
+  invert,
+  columns,
+  onImagePaste,
+  disableCursorMovementForUpDownKeys = false,
+  externalOffset,
+  onOffsetChange
+}) {
+  const offset = externalOffset;
+  const setOffset = onOffsetChange;
+  const cursor = Cursor.fromText(originalValue, columns, offset);
+  const [imagePasteErrorTimeout, setImagePasteErrorTimeout] = useState2(null);
+  function maybeClearImagePasteErrorTimeout() {
+    if (!imagePasteErrorTimeout) {
+      return;
+    }
+    clearTimeout(imagePasteErrorTimeout);
+    setImagePasteErrorTimeout(null);
+    onMessage?.(false);
+  }
+  function applyCursor(nextCursor) {
+    if (cursor.equals(nextCursor)) {
+      return;
+    }
+    setOffset(nextCursor.offset);
+    if (cursor.text !== nextCursor.text) {
+      onChange(nextCursor.text);
+    }
+  }
+  const handleCtrlC = useDoublePress(
+    (show) => {
+      maybeClearImagePasteErrorTimeout();
+      onExitMessage?.(show, "Ctrl-C");
+    },
+    () => onExit?.(),
+    () => {
+      if (originalValue) {
+        onChange("");
+        onHistoryReset?.();
+      }
+    }
+  );
+  const handleEscape = useDoublePress(
+    (show) => {
+      maybeClearImagePasteErrorTimeout();
+      onMessage?.(!!originalValue && show, `Press Escape again to clear`);
+    },
+    () => {
+      if (originalValue) {
+        onChange("");
+      }
+    }
+  );
+  function clear() {
+    return Cursor.fromText("", columns, 0);
+  }
+  const handleEmptyCtrlD = useDoublePress(
+    (show) => onExitMessage?.(show, "Ctrl-D"),
+    () => onExit?.()
+  );
+  function handleCtrlD() {
+    maybeClearImagePasteErrorTimeout();
+    if (cursor.text === "") {
+      handleEmptyCtrlD();
+      return cursor;
+    }
+    return cursor.del();
+  }
+  function handleImagePaste() {
+    return tryImagePaste({
+      cursor,
+      mask,
+      onImagePaste,
+      onMessage,
+      setImagePasteErrorTimeout,
+      clearImagePasteErrorTimeout: maybeClearImagePasteErrorTimeout
+    });
+  }
+  const handleCtrl = mapInput(
+    [
+      ["a", () => cursor.startOfLine()],
+      ["b", () => cursor.left()],
+      ["c", handleCtrlC],
+      ["d", handleCtrlD],
+      ["e", () => cursor.endOfLine()],
+      ["f", () => cursor.right()],
+      [
+        "h",
+        () => {
+          maybeClearImagePasteErrorTimeout();
+          return cursor.backspace();
+        }
+      ],
+      ["k", () => cursor.deleteToLineEnd()],
+      ["l", () => clear()],
+      ["n", () => downOrHistoryDown()],
+      ["p", () => upOrHistoryUp()],
+      ["u", () => cursor.deleteToLineStart()],
+      ["v", handleImagePaste],
+      ["w", () => cursor.deleteWordBefore()]
+    ],
+    () => void 0
+  );
+  const handleMeta = mapInput(
+    [
+      ["b", () => cursor.prevWord()],
+      ["f", () => cursor.nextWord()],
+      ["d", () => cursor.deleteWordAfter()]
+    ],
+    () => void 0
+  );
+  function handleEnter(key) {
+    if (!multiline) {
+      onSubmit?.(originalValue);
+      return;
+    }
+    const optionPressed = (() => {
+      if (!("option" in key)) return false;
+      const optionValue = key.option;
+      return optionValue === true;
+    })();
+    if (key.meta || optionPressed) {
+      return cursor.insert("\n");
+    }
+    onSubmit?.(originalValue);
+  }
+  function upOrHistoryUp() {
+    if (disableCursorMovementForUpDownKeys) {
+      onHistoryUp?.();
+      return cursor;
+    }
+    const cursorUp = cursor.up();
+    if (cursorUp.equals(cursor)) {
+      onHistoryUp?.();
+    }
+    return cursorUp;
+  }
+  function downOrHistoryDown() {
+    if (disableCursorMovementForUpDownKeys) {
+      onHistoryDown?.();
+      return cursor;
+    }
+    const cursorDown = cursor.down();
+    if (cursorDown.equals(cursor)) {
+      onHistoryDown?.();
+    }
+    return cursorDown;
+  }
+  function onInput(input, key) {
+    if (key.tab) {
+      return;
+    }
+    if (key.backspace || key.delete || input === "\b" || input === "\x7F" || input === "\b") {
+      applyCursor(cursor.backspace());
+      return;
+    }
+    if (!key.ctrl && !key.meta && input.length > 1) {
+      applyCursor(cursor.insert(normalizeLineEndings(input)));
+      return;
+    }
+    const nextCursor = mapKey(key)(input);
+    if (nextCursor) {
+      applyCursor(nextCursor);
+    }
+  }
+  function mapKey(key) {
+    if (key.backspace || key.delete) {
+      maybeClearImagePasteErrorTimeout();
+      return () => cursor.backspace();
+    }
+    switch (true) {
+      case key.escape:
+        return handleEscape;
+      case (key.leftArrow && (key.ctrl || key.meta || "fn" in key && key.fn)):
+        return () => cursor.prevWord();
+      case (key.rightArrow && (key.ctrl || key.meta || "fn" in key && key.fn)):
+        return () => cursor.nextWord();
+      case key.ctrl:
+        return handleCtrl;
+      case ("home" in key && key.home):
+        return () => cursor.startOfLine();
+      case ("end" in key && key.end):
+        return () => cursor.endOfLine();
+      case key.pageDown:
+        return () => cursor.endOfLine();
+      case key.pageUp:
+        return () => cursor.startOfLine();
+      case key.return:
+        return () => handleEnter(key);
+      case key.meta:
+        return handleMeta;
+      // Remove Tab handling - let completion system handle it
+      case key.upArrow:
+        return upOrHistoryUp;
+      case key.downArrow:
+        return downOrHistoryDown;
+      case key.leftArrow:
+        return () => cursor.left();
+      case key.rightArrow:
+        return () => cursor.right();
+    }
+    return function(input) {
+      switch (true) {
+        // Home key
+        case (input == "\x1B[H" || input == "\x1B[1~"):
+          return cursor.startOfLine();
+        // End key
+        case (input == "\x1B[F" || input == "\x1B[4~"):
+          return cursor.endOfLine();
+        // Handle backspace character explicitly - this is the key fix
+        case (input === "\b" || input === "\x7F" || input === "\b"):
+          maybeClearImagePasteErrorTimeout();
+          return cursor.backspace();
+        default:
+          return cursor.insert(input.replace(/\r/g, "\n"));
+      }
+    };
+  }
+  return {
+    onInput,
+    renderedValue: cursor.render(cursorChar, mask, invert),
+    offset,
+    setOffset
+  };
+}
+
+// apps/cli/src/ui/components/TextInputBracketedPaste.ts
+import React3 from "react";
+var BRACKETED_PASTE_ENABLE = "\x1B[?2004h";
+var BRACKETED_PASTE_DISABLE = "\x1B[?2004l";
+var BRACKETED_PASTE_START = "\x1B[200~";
+var BRACKETED_PASTE_END = "\x1B[201~";
+var BRACKETED_PASTE_START_NO_ESC = "[200~";
+var BRACKETED_PASTE_END_NO_ESC = "[201~";
+var bracketedPasteRefCount = 0;
+function setBracketedPasteEnabled(enabled) {
+  if (!process.stdout?.isTTY) return;
+  process.stdout.write(
+    enabled ? BRACKETED_PASTE_ENABLE : BRACKETED_PASTE_DISABLE
+  );
+}
+function acquireBracketedPasteMode() {
+  if (bracketedPasteRefCount === 0) {
+    setBracketedPasteEnabled(true);
+  }
+  bracketedPasteRefCount++;
+}
+function releaseBracketedPasteMode() {
+  bracketedPasteRefCount = Math.max(0, bracketedPasteRefCount - 1);
+  if (bracketedPasteRefCount === 0) {
+    setBracketedPasteEnabled(false);
+  }
+}
+function useBracketedPasteMode() {
+  React3.useEffect(() => {
+    acquireBracketedPasteMode();
+    return () => releaseBracketedPasteMode();
+  }, []);
+}
+function longestSuffixPrefix(haystack, needle) {
+  const max = Math.min(haystack.length, needle.length - 1);
+  for (let len = max; len > 0; len--) {
+    if (haystack.endsWith(needle.slice(0, len))) return len;
+  }
+  return 0;
+}
+function findFirstMarker(haystack, markers) {
+  let best = null;
+  for (const marker of markers) {
+    const index = haystack.indexOf(marker);
+    if (index === -1) continue;
+    if (!best || index < best.index) {
+      best = { index, marker };
+    }
+  }
+  return best;
+}
+function getSuffixKeepLength(haystack, markers) {
+  let keep = 0;
+  for (const marker of markers) {
+    keep = Math.max(keep, longestSuffixPrefix(haystack, marker));
+  }
+  return keep;
+}
+function useBracketedPasteSequences({
+  insertText,
+  onPaste
+}) {
+  const stateRef = React3.useRef({
+    mode: "normal",
+    incomplete: "",
+    buffer: ""
+  });
+  const flushBracketedPasteBuffer = React3.useCallback(
+    (rawText) => {
+      const normalized = normalizeLineEndings(rawText);
+      if (onPaste && shouldTreatAsSpecialPaste(normalized)) {
+        Promise.resolve().then(() => onPaste(normalized));
+        return;
+      }
+      insertText(normalized);
+    },
+    [insertText, onPaste]
+  );
+  return React3.useCallback(
+    (input) => {
+      const state = stateRef.current;
+      let handledAny = false;
+      let data = state.incomplete + input;
+      state.incomplete = "";
+      const startMarkers = [BRACKETED_PASTE_START, BRACKETED_PASTE_START_NO_ESC];
+      const endMarkers = [BRACKETED_PASTE_END, BRACKETED_PASTE_END_NO_ESC];
+      while (data) {
+        if (state.mode === "normal") {
+          const start = findFirstMarker(data, startMarkers);
+          if (!start) {
+            const keep = getSuffixKeepLength(data, startMarkers);
+            if (keep === 0) {
+              if (!handledAny) {
+                return false;
+              }
+              insertText(data);
+              return true;
+            }
+            const toInsert = data.slice(0, -keep);
+            if (toInsert) {
+              insertText(toInsert);
+            }
+            state.incomplete = data.slice(-keep);
+            handledAny = true;
+            return true;
+          }
+          const before = data.slice(0, start.index);
+          if (before) {
+            insertText(before);
+          }
+          data = data.slice(start.index + start.marker.length);
+          state.mode = "in_paste";
+          handledAny = true;
+          continue;
+        }
+        const end = findFirstMarker(data, endMarkers);
+        if (!end) {
+          const keep = getSuffixKeepLength(data, endMarkers);
+          const content = keep > 0 ? data.slice(0, -keep) : data;
+          if (content) {
+            state.buffer += content;
+          }
+          if (keep > 0) {
+            state.incomplete = data.slice(-keep);
+          }
+          handledAny = true;
+          return true;
+        }
+        state.buffer += data.slice(0, end.index);
+        const completedPaste = state.buffer;
+        state.buffer = "";
+        state.mode = "normal";
+        flushBracketedPasteBuffer(completedPaste);
+        data = data.slice(end.index + end.marker.length);
+        handledAny = true;
+        continue;
+      }
+      return true;
+    },
+    [flushBracketedPasteBuffer, insertText]
+  );
+}
+
+// apps/cli/src/ui/components/TextInput.tsx
+function TextInput({
+  value: originalValue,
+  placeholder = "",
+  focus = true,
+  mask,
+  multiline = false,
+  highlightPastedText = false,
+  showCursor = true,
+  onChange,
+  onSubmit,
+  onExit,
+  onHistoryUp,
+  onHistoryDown,
+  onExitMessage,
+  onMessage,
+  onHistoryReset,
+  columns,
+  onImagePaste,
+  onPaste,
+  isDimmed = false,
+  disableCursorMovementForUpDownKeys = false,
+  onSpecialKey,
+  cursorOffset,
+  onChangeCursorOffset
+}) {
+  const { onInput, renderedValue } = useTextInput({
+    value: originalValue,
+    onChange,
+    onSubmit,
+    onExit,
+    onExitMessage,
+    onMessage,
+    onHistoryReset,
+    onHistoryUp,
+    onHistoryDown,
+    focus,
+    mask,
+    multiline,
+    cursorChar: showCursor ? " " : "",
+    highlightPastedText,
+    invert: chalk.inverse,
+    themeText: (text) => chalk.hex(getTheme().text)(text),
+    columns,
+    onImagePaste,
+    disableCursorMovementForUpDownKeys,
+    externalOffset: cursorOffset,
+    onOffsetChange: onChangeCursorOffset
+  });
+  useBracketedPasteMode();
+  const [pasteState, setPasteState] = React4.useState({ chunks: [], timeoutId: null });
+  const handleBracketedPasteSequences = useBracketedPasteSequences({
+    insertText: (text) => onInput(text, {}),
+    onPaste
+  });
+  const resetPasteTimeout = (currentTimeoutId) => {
+    if (currentTimeoutId) {
+      clearTimeout(currentTimeoutId);
+    }
+    return setTimeout(() => {
+      setPasteState(({ chunks }) => {
+        const pastedText = chunks.join("");
+        Promise.resolve().then(() => onPaste(pastedText));
+        return { chunks: [], timeoutId: null };
+      });
+    }, 500);
+  };
+  const wrappedOnInput = (input, key) => {
+    if (/^(?:\x1b)?\[13;2(?:u|~)$/.test(input)) {
+      onInput("\r", { ...key, return: true, meta: false, shift: false });
+      return;
+    }
+    if (/^(?:\x1b)?\[13;(?:3|4)(?:u|~)$/.test(input)) {
+      onInput("\r", { ...key, return: true, meta: true });
+      return;
+    }
+    if (input === "\n") {
+      if (multiline) {
+        onInput("\n", key);
+        return;
+      }
+      onInput("\r", { ...key, return: true });
+      return;
+    }
+    if (input === "\x1B\r" || input === "\x1B\n") {
+      onInput("\r", {
+        ...key,
+        return: true,
+        meta: true
+      });
+      return;
+    }
+    if (onSpecialKey && onSpecialKey(input, key)) {
+      return;
+    }
+    if (key.backspace || key.delete || input === "\b" || input === "\x7F" || input === "\b") {
+      onInput(input, {
+        ...key,
+        backspace: true
+      });
+      return;
+    }
+    if (input && handleBracketedPasteSequences(input)) {
+      return;
+    }
+    if (onPaste && shouldAggregatePasteChunk(input, pasteState.timeoutId !== null)) {
+      setPasteState(({ chunks, timeoutId }) => {
+        return {
+          chunks: [...chunks, input],
+          timeoutId: resetPasteTimeout(timeoutId)
+        };
+      });
+      return;
+    }
+    onInput(input, key);
+  };
+  useInput2(wrappedOnInput, { isActive: focus });
+  let renderedPlaceholder = placeholder ? chalk.hex(getTheme().secondaryText)(placeholder) : void 0;
+  if (showCursor && focus) {
+    renderedPlaceholder = placeholder.length > 0 ? chalk.inverse(placeholder[0]) + chalk.hex(getTheme().secondaryText)(placeholder.slice(1)) : chalk.inverse(" ");
+  }
+  const showPlaceholder = originalValue.length == 0 && placeholder;
+  return /* @__PURE__ */ React4.createElement(Text3, { wrap: "truncate-end", dimColor: isDimmed }, showPlaceholder ? renderedPlaceholder : renderedValue);
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ApiKeyScreen.tsx
+function ApiKeyScreen({
+  theme,
+  exitState,
+  selectedProvider,
+  apiKey,
+  cursorOffset,
+  handleApiKeyChange,
+  handleApiKeySubmit,
+  handleCursorOffsetChange,
+  apiKeyCleanedNotification,
+  isLoadingModels,
+  providerBaseUrl,
+  modelLoadError,
+  formatApiKeyDisplay,
+  getProviderLabel
+}) {
+  const modelTypeText = "this model profile";
+  return /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React5.createElement(
+    Box3,
+    {
+      flexDirection: "column",
+      gap: 1,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: 1
+    },
+    /* @__PURE__ */ React5.createElement(Text4, { bold: true }, "API Key Setup", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React5.createElement(Text4, { bold: true }, "Enter your ", getProviderLabel(selectedProvider, 0).split(" (")[0], " ", "API key for ", modelTypeText, ":"), /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React5.createElement(Text4, { color: theme.secondaryText }, "This key will be stored locally and used to access the", " ", selectedProvider, " API.", /* @__PURE__ */ React5.createElement(Newline, null), "Your key is never sent to our servers.", /* @__PURE__ */ React5.createElement(Newline, null), /* @__PURE__ */ React5.createElement(Newline, null), selectedProvider === "kimi" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} Get your API key from:", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "https://platform.moonshot.cn/console/api-keys")), selectedProvider === "deepseek" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} Get your API key from:", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "https://platform.deepseek.com/api_keys")), selectedProvider === "siliconflow" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} Get your API key from:", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "https://cloud.siliconflow.cn/i/oJWsm6io")), selectedProvider === "qwen" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} Get your API key from:", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "https://bailian.console.aliyun.com/?tab=model#/api-key")), selectedProvider === "glm" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} Get your API key from:", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "https://open.bigmodel.cn (API Keys section)")), selectedProvider === "glm-coding" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} This is for GLM Coding Plan API.", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "Use the same API key as regular GLM"), /* @__PURE__ */ React5.createElement(Newline, null), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "Note: This uses a special endpoint for coding tasks.")), selectedProvider === "minimax" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} Get your API key from:", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "https://www.minimax.io/platform/user-center/basic-information")), selectedProvider === "minimax-coding" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} Get your Coding Plan API key from:", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "https://platform.minimaxi.com/user-center/payment/coding-plan"), /* @__PURE__ */ React5.createElement(Newline, null), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "Note: This requires a MiniMax Coding Plan subscription.")), selectedProvider === "baidu-qianfan" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} Get your API key from:", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "https://console.bce.baidu.com/iam/#/iam/accesslist")), selectedProvider === "anthropic" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} Get your API key from your provider dashboard."), selectedProvider === "openai" && /* @__PURE__ */ React5.createElement(React5.Fragment, null, "\u{1F4A1} Get your API key from:", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "https://platform.openai.com/api-keys")))), /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box3, null, /* @__PURE__ */ React5.createElement(
+      TextInput,
+      {
+        placeholder: "Paste your API key here...",
+        value: apiKey,
+        onChange: handleApiKeyChange,
+        onSubmit: handleApiKeySubmit,
+        mask: "*",
+        columns: 80,
+        cursorOffset,
+        onChangeCursorOffset: handleCursorOffsetChange,
+        showCursor: true
+      }
+    )), apiKey && /* @__PURE__ */ React5.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text4, { color: theme.secondaryText }, "Key: ", formatApiKeyDisplay(apiKey), " (", apiKey.length, " chars)"))), apiKeyCleanedNotification && /* @__PURE__ */ React5.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text4, { color: theme.success }, "\u2713 API key cleaned: removed line breaks and trimmed whitespace")), /* @__PURE__ */ React5.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text4, null, /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion, dimColor: !apiKey }, "[Submit API Key]"), /* @__PURE__ */ React5.createElement(Text4, null, " - Press Enter to validate and continue"))), isLoadingModels && /* @__PURE__ */ React5.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "Validating API key and fetching models..."), providerBaseUrl && /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "Endpoint: ", providerBaseUrl, "/v1/models")), modelLoadError && /* @__PURE__ */ React5.createElement(Box3, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Text4, { color: "red" }, "\u274C API Key Validation Failed"), /* @__PURE__ */ React5.createElement(Text4, { color: "red" }, modelLoadError), providerBaseUrl && /* @__PURE__ */ React5.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "Attempted endpoint: ", providerBaseUrl, "/v1/models")), /* @__PURE__ */ React5.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text4, { color: theme.warning }, "Please check your API key and try again."))), /* @__PURE__ */ React5.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "Press ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "Enter"), " to continue,", " ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "Tab"), " to", " ", selectedProvider === "anthropic" || selectedProvider === "kimi" || selectedProvider === "deepseek" || selectedProvider === "qwen" || selectedProvider === "glm" || selectedProvider === "glm-coding" || selectedProvider === "minimax" || selectedProvider === "minimax-coding" || selectedProvider === "baidu-qianfan" || selectedProvider === "siliconflow" || selectedProvider === "custom-openai" ? "skip to manual model input" : "skip using a key", ", or ", /* @__PURE__ */ React5.createElement(Text4, { color: theme.suggestion }, "Esc"), " to go back")))
+  ));
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/BaseUrlScreen.tsx
+import React6 from "react";
+import { Box as Box4, Newline as Newline2, Text as Text5 } from "ink";
+function BaseUrlScreen({
+  theme,
+  exitState,
+  selectedProvider,
+  isLoadingModels,
+  modelLoadError,
+  customBaseUrl,
+  setCustomBaseUrl,
+  handleCustomBaseUrlSubmit,
+  customBaseUrlCursorOffset,
+  setCustomBaseUrlCursorOffset,
+  providerBaseUrl,
+  setProviderBaseUrl,
+  handleProviderBaseUrlSubmit,
+  providerBaseUrlCursorOffset,
+  setProviderBaseUrlCursorOffset
+}) {
+  const isCustomOpenAI = selectedProvider === "custom-openai";
+  if (isCustomOpenAI) {
+    return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React6.createElement(
+      Box4,
+      {
+        flexDirection: "column",
+        gap: 1,
+        borderStyle: "round",
+        borderColor: theme.secondaryBorder,
+        paddingX: 2,
+        paddingY: 1
+      },
+      /* @__PURE__ */ React6.createElement(Text5, { bold: true }, "Custom API Server Setup", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+      /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React6.createElement(Text5, { bold: true }, "Enter your custom API URL:"), /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React6.createElement(Text5, { color: theme.secondaryText }, "This is the base URL for your OpenAI-compatible API.", /* @__PURE__ */ React6.createElement(Newline2, null), "For example: https://api.example.com/v1")), /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(
+        TextInput,
+        {
+          placeholder: "https://api.example.com/v1",
+          value: customBaseUrl,
+          onChange: setCustomBaseUrl,
+          onSubmit: handleCustomBaseUrlSubmit,
+          columns: 100,
+          cursorOffset: customBaseUrlCursorOffset,
+          onChangeCursorOffset: setCustomBaseUrlCursorOffset,
+          showCursor: !isLoadingModels,
+          focus: !isLoadingModels
+        }
+      )), /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, null, /* @__PURE__ */ React6.createElement(
+        Text5,
+        {
+          color: isLoadingModels ? theme.secondaryText : theme.suggestion
+        },
+        "[Submit Base URL]"
+      ), /* @__PURE__ */ React6.createElement(Text5, null, " - Press Enter or click to continue"))), /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Press ", /* @__PURE__ */ React6.createElement(Text5, { color: theme.suggestion }, "Enter"), " to continue or", " ", /* @__PURE__ */ React6.createElement(Text5, { color: theme.suggestion }, "Esc"), " to go back")))
+    ));
+  }
+  const providerName = providers[selectedProvider]?.name || selectedProvider;
+  const defaultUrl = providers[selectedProvider]?.baseURL || "";
+  return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React6.createElement(
+    Box4,
+    {
+      flexDirection: "column",
+      gap: 1,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: 1
+    },
+    /* @__PURE__ */ React6.createElement(Text5, { bold: true }, providerName, " API Configuration", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React6.createElement(Text5, { bold: true }, "Configure the API endpoint for ", providerName, ":"), /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React6.createElement(Text5, { color: theme.secondaryText }, selectedProvider === "ollama" ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, "This is the URL of your Ollama server.", /* @__PURE__ */ React6.createElement(Newline2, null), "Default is http://localhost:11434/v1 for local Ollama installations.") : /* @__PURE__ */ React6.createElement(React6.Fragment, null, "This is the base URL for the ", providerName, " API.", /* @__PURE__ */ React6.createElement(Newline2, null), "You can modify this URL or press Enter to use the default."))), /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(
+      TextInput,
+      {
+        placeholder: defaultUrl,
+        value: providerBaseUrl,
+        onChange: setProviderBaseUrl,
+        onSubmit: handleProviderBaseUrlSubmit,
+        columns: 100,
+        cursorOffset: providerBaseUrlCursorOffset,
+        onChangeCursorOffset: setProviderBaseUrlCursorOffset,
+        showCursor: !isLoadingModels,
+        focus: !isLoadingModels
+      }
+    )), /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, null, /* @__PURE__ */ React6.createElement(
+      Text5,
+      {
+        color: isLoadingModels ? theme.secondaryText : theme.suggestion
+      },
+      "[Submit Base URL]"
+    ), /* @__PURE__ */ React6.createElement(Text5, null, " - Press Enter or click to continue"))), isLoadingModels && /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: theme.success }, selectedProvider === "ollama" ? "Connecting to Ollama server..." : `Connecting to ${providerName}...`)), modelLoadError && /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: "red" }, "Error: ", modelLoadError)), /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Press ", /* @__PURE__ */ React6.createElement(Text5, { color: theme.suggestion }, "Enter"), " to continue or", " ", /* @__PURE__ */ React6.createElement(Text5, { color: theme.suggestion }, "Esc"), " to go back")))
+  ));
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ConfirmationScreen.tsx
+import React7 from "react";
+import { Box as Box5, Text as Text6 } from "ink";
+
+// apps/cli/src/ui/ui/components/model-selector/options.ts
+var REASONING_EFFORT_OPTIONS = [
+  { label: "Low - Faster responses, less thorough reasoning", value: "low" },
+  { label: "Medium - Balanced speed and reasoning depth", value: "medium" },
+  {
+    label: "High - Slower responses, more thorough reasoning",
+    value: "high"
+  }
+];
+var CONTEXT_LENGTH_OPTIONS = [
+  { label: "32K tokens", value: 32e3 },
+  { label: "64K tokens", value: 64e3 },
+  { label: "128K tokens", value: 128e3 },
+  { label: "200K tokens", value: 2e5 },
+  { label: "256K tokens", value: 256e3 },
+  { label: "300K tokens", value: 3e5 },
+  { label: "512K tokens", value: 512e3 },
+  { label: "1000K tokens", value: 1e6 },
+  { label: "2000K tokens", value: 2e6 },
+  { label: "3000K tokens", value: 3e6 },
+  { label: "5000K tokens", value: 5e6 },
+  { label: "10000K tokens", value: 1e7 }
+];
+var DEFAULT_CONTEXT_LENGTH = 128e3;
+var MAX_TOKENS_OPTIONS = [
+  { label: "1K tokens", value: 1024 },
+  { label: "2K tokens", value: 2048 },
+  { label: "4K tokens", value: 4096 },
+  { label: "8K tokens (recommended)", value: 8192 },
+  { label: "16K tokens", value: 16384 },
+  { label: "32K tokens", value: 32768 },
+  { label: "64K tokens", value: 65536 },
+  { label: "128K tokens", value: 131072 }
+];
+var DEFAULT_MAX_TOKENS = 8192;
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ConfirmationScreen.tsx
+function ConfirmationScreen({
+  theme,
+  exitState,
+  selectedProvider,
+  selectedModel,
+  resourceName,
+  ollamaBaseUrl,
+  customBaseUrl,
+  apiKey,
+  maxTokens,
+  contextLength,
+  supportsReasoningEffort,
+  reasoningEffort,
+  validationError,
+  formatApiKeyDisplay,
+  getProviderLabel
+}) {
+  const providerDisplayName = getProviderLabel(selectedProvider, 0).split(
+    " ("
+  )[0];
+  const showsApiKey = selectedProvider !== "ollama";
+  return /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React7.createElement(
+    Box5,
+    {
+      flexDirection: "column",
+      gap: 1,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: 1
+    },
+    /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Configuration Confirmation", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Confirm your model configuration:"), /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React7.createElement(Text6, { color: theme.secondaryText }, "Please review your selections before saving.")), validationError && /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", marginY: 1, paddingX: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: theme.error, bold: true }, "\u26A0 Configuration Error:"), /* @__PURE__ */ React7.createElement(Text6, { color: theme.error }, validationError)), /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", marginY: 1, paddingX: 1 }, /* @__PURE__ */ React7.createElement(Text6, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Provider: "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, providerDisplayName)), selectedProvider === "azure" && /* @__PURE__ */ React7.createElement(Text6, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Resource Name: "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, resourceName)), selectedProvider === "ollama" && /* @__PURE__ */ React7.createElement(Text6, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Server URL: "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, ollamaBaseUrl)), selectedProvider === "custom-openai" && /* @__PURE__ */ React7.createElement(Text6, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "API Base URL: "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, customBaseUrl)), /* @__PURE__ */ React7.createElement(Text6, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Model: "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, selectedModel)), apiKey && showsApiKey && /* @__PURE__ */ React7.createElement(Text6, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "API Key: "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, formatApiKeyDisplay(apiKey))), maxTokens && /* @__PURE__ */ React7.createElement(Text6, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Max Tokens: "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, maxTokens)), /* @__PURE__ */ React7.createElement(Text6, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Context Length: "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, CONTEXT_LENGTH_OPTIONS.find((opt) => opt.value === contextLength)?.label || `${contextLength.toLocaleString()} tokens`)), supportsReasoningEffort && /* @__PURE__ */ React7.createElement(Text6, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Reasoning Effort: "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, reasoningEffort))), /* @__PURE__ */ React7.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Press ", /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, "Esc"), " to go back to model parameters or ", /* @__PURE__ */ React7.createElement(Text6, { color: theme.suggestion }, "Enter"), " to save configuration")))
+  ));
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ConnectionTestScreen.tsx
+import React8 from "react";
+import { Box as Box6, Newline as Newline3, Text as Text7 } from "ink";
+function ConnectionTestScreen({
+  theme,
+  exitState,
+  selectedProvider,
+  getProviderLabel,
+  isTestingConnection,
+  connectionTestResult
+}) {
+  const providerDisplayName = getProviderLabel(selectedProvider, 0).split(
+    " ("
+  )[0];
+  return /* @__PURE__ */ React8.createElement(Box6, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React8.createElement(
+    Box6,
+    {
+      flexDirection: "column",
+      gap: 1,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: 1
+    },
+    /* @__PURE__ */ React8.createElement(Text7, { bold: true }, "Connection Test", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React8.createElement(Box6, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React8.createElement(Text7, { bold: true }, "Testing connection to ", providerDisplayName, "..."), /* @__PURE__ */ React8.createElement(Box6, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React8.createElement(Text7, { color: theme.secondaryText }, "This will verify your configuration by sending a test request to the API.", selectedProvider === "minimax" && /* @__PURE__ */ React8.createElement(React8.Fragment, null, /* @__PURE__ */ React8.createElement(Newline3, null), "For MiniMax, we'll test both v2 and v1 endpoints to find the best one."))), !connectionTestResult && !isTestingConnection && /* @__PURE__ */ React8.createElement(Box6, { marginY: 1 }, /* @__PURE__ */ React8.createElement(Text7, null, /* @__PURE__ */ React8.createElement(Text7, { color: theme.suggestion }, "Press Enter"), " to start the connection test")), isTestingConnection && /* @__PURE__ */ React8.createElement(Box6, { marginY: 1 }, /* @__PURE__ */ React8.createElement(Text7, { color: theme.suggestion }, "\u{1F504} Testing connection...")), connectionTestResult && /* @__PURE__ */ React8.createElement(Box6, { flexDirection: "column", marginY: 1, paddingX: 1 }, /* @__PURE__ */ React8.createElement(
+      Text7,
+      {
+        color: connectionTestResult.success ? theme.success : "red"
+      },
+      connectionTestResult.message
+    ), connectionTestResult.endpoint && /* @__PURE__ */ React8.createElement(Text7, { color: theme.secondaryText }, "Endpoint: ", connectionTestResult.endpoint), connectionTestResult.details && /* @__PURE__ */ React8.createElement(Text7, { color: theme.secondaryText }, "Details: ", connectionTestResult.details), connectionTestResult.success ? /* @__PURE__ */ React8.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { color: theme.success }, "\u2705 Automatically proceeding to confirmation...")) : /* @__PURE__ */ React8.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, null, /* @__PURE__ */ React8.createElement(Text7, { color: theme.suggestion }, "Press Enter"), " to retry test, or ", /* @__PURE__ */ React8.createElement(Text7, { color: theme.suggestion }, "Esc"), " to go back"))), /* @__PURE__ */ React8.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "Press ", /* @__PURE__ */ React8.createElement(Text7, { color: theme.suggestion }, "Esc"), " to go back to context length")))
+  ));
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ContextLengthScreen.tsx
+import React9 from "react";
+import { Box as Box7, Text as Text8 } from "ink";
+function ContextLengthScreen({
+  theme,
+  exitState,
+  contextLength
+}) {
+  const selectedOption = CONTEXT_LENGTH_OPTIONS.find((opt) => opt.value === contextLength) || CONTEXT_LENGTH_OPTIONS[2];
+  return /* @__PURE__ */ React9.createElement(Box7, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React9.createElement(
+    Box7,
+    {
+      flexDirection: "column",
+      gap: 1,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: 1
+    },
+    /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "Context Length Configuration", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React9.createElement(Box7, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "Choose the context window length for your model:"), /* @__PURE__ */ React9.createElement(Box7, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React9.createElement(Text8, { color: theme.secondaryText }, "This determines how much conversation history and context the model can process at once. Higher values allow for longer conversations but may increase costs.")), /* @__PURE__ */ React9.createElement(Box7, { flexDirection: "column", marginY: 1 }, CONTEXT_LENGTH_OPTIONS.map((option, index) => {
+      const isSelected = option.value === contextLength;
+      return /* @__PURE__ */ React9.createElement(Box7, { key: option.value, flexDirection: "row" }, /* @__PURE__ */ React9.createElement(Text8, { color: isSelected ? "blue" : void 0 }, isSelected ? "\u2192 " : "  ", option.label, option.value === DEFAULT_CONTEXT_LENGTH ? " (recommended)" : ""));
+    })), /* @__PURE__ */ React9.createElement(Box7, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "Selected:", " ", /* @__PURE__ */ React9.createElement(Text8, { color: theme.suggestion }, selectedOption.label))))
+  ), /* @__PURE__ */ React9.createElement(Box7, { marginLeft: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "\u2191/\u2193 to select \xB7 Enter to continue \xB7 Esc to go back")));
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ModelInputScreen.tsx
+import React10 from "react";
+import { Box as Box8, Newline as Newline4, Text as Text9 } from "ink";
+function ModelInputScreen({
+  theme,
+  exitState,
+  selectedProvider,
+  customModelName,
+  setCustomModelName,
+  handleCustomModelSubmit,
+  customModelNameCursorOffset,
+  setCustomModelNameCursorOffset
+}) {
+  const modelTypeText = "this model profile";
+  let screenTitle = "Manual Model Setup";
+  let description = "Enter the model name manually";
+  let placeholder = "gpt-4";
+  let examples = 'For example: "gpt-4", "gpt-3.5-turbo", etc.';
+  if (selectedProvider === "azure") {
+    screenTitle = "Azure Model Setup";
+    description = `Enter your Azure OpenAI deployment name for ${modelTypeText}:`;
+    examples = 'For example: "gpt-4", "gpt-35-turbo", etc.';
+    placeholder = "gpt-4";
+  } else if (selectedProvider === "anthropic") {
+    screenTitle = "Model Setup";
+    description = `Enter the model name for ${modelTypeText}:`;
+    examples = 'For example: "claude-3-5-sonnet-latest", "claude-3-5-haiku-latest", etc.';
+    placeholder = "claude-3-5-sonnet-latest";
+  } else if (selectedProvider === "bigdream") {
+    screenTitle = "BigDream Model Setup";
+    description = `Enter the BigDream model name for ${modelTypeText}:`;
+    examples = 'For example: "claude-3-5-sonnet-latest", "claude-3-5-haiku-latest", etc.';
+    placeholder = "claude-3-5-sonnet-latest";
+  } else if (selectedProvider === "kimi") {
+    screenTitle = "Kimi Model Setup";
+    description = `Enter the Kimi model name for ${modelTypeText}:`;
+    examples = 'For example: "kimi-k2-0711-preview"';
+    placeholder = "kimi-k2-0711-preview";
+  } else if (selectedProvider === "deepseek") {
+    screenTitle = "DeepSeek Model Setup";
+    description = `Enter the DeepSeek model name for ${modelTypeText}:`;
+    examples = 'For example: "deepseek-chat", "deepseek-coder", "deepseek-reasoner", etc.';
+    placeholder = "deepseek-chat";
+  } else if (selectedProvider === "siliconflow") {
+    screenTitle = "SiliconFlow Model Setup";
+    description = `Enter the SiliconFlow model name for ${modelTypeText}:`;
+    examples = 'For example: "Qwen/Qwen2.5-72B-Instruct", "meta-llama/Meta-Llama-3.1-8B-Instruct", etc.';
+    placeholder = "Qwen/Qwen2.5-72B-Instruct";
+  } else if (selectedProvider === "qwen") {
+    screenTitle = "Qwen Model Setup";
+    description = `Enter the Qwen model name for ${modelTypeText}:`;
+    examples = 'For example: "qwen-plus", "qwen-turbo", "qwen-max", etc.';
+    placeholder = "qwen-plus";
+  } else if (selectedProvider === "glm") {
+    screenTitle = "GLM Model Setup";
+    description = `Enter the GLM model name for ${modelTypeText}:`;
+    examples = 'For example: "glm-4", "glm-4v", "glm-3-turbo", etc.';
+    placeholder = "glm-4";
+  } else if (selectedProvider === "glm-coding") {
+    screenTitle = "GLM Coding Plan Model Setup";
+    description = `Enter the GLM model name for ${modelTypeText}:`;
+    examples = 'For Coding Plan, typically use: "GLM-4.6" or other GLM models';
+    placeholder = "GLM-4.6";
+  } else if (selectedProvider === "minimax") {
+    screenTitle = "MiniMax Model Setup";
+    description = `Enter the MiniMax model name for ${modelTypeText}:`;
+    examples = 'For example: "abab6.5s-chat", "abab6.5g-chat", "abab5.5s-chat", etc.';
+    placeholder = "abab6.5s-chat";
+  } else if (selectedProvider === "minimax-coding") {
+    screenTitle = "MiniMax Coding Plan Model Setup";
+    description = `Enter the MiniMax model name for ${modelTypeText}:`;
+    examples = 'For Coding Plan, use: "MiniMax-M2"';
+    placeholder = "MiniMax-M2";
+  } else if (selectedProvider === "baidu-qianfan") {
+    screenTitle = "Baidu Qianfan Model Setup";
+    description = `Enter the Baidu Qianfan model name for ${modelTypeText}:`;
+    examples = 'For example: "ERNIE-4.0-8K", "ERNIE-3.5-8K", "ERNIE-Speed-128K", etc.';
+    placeholder = "ERNIE-4.0-8K";
+  } else if (selectedProvider === "custom-openai") {
+    screenTitle = "Custom API Model Setup";
+    description = `Enter the model name for ${modelTypeText}:`;
+    examples = "Enter the exact model name as supported by your API endpoint.";
+    placeholder = "model-name";
+  }
+  return /* @__PURE__ */ React10.createElement(Box8, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React10.createElement(
+    Box8,
+    {
+      flexDirection: "column",
+      gap: 1,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: 1
+    },
+    /* @__PURE__ */ React10.createElement(Text9, { bold: true }, screenTitle, " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React10.createElement(Box8, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React10.createElement(Text9, { bold: true }, description), /* @__PURE__ */ React10.createElement(Box8, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React10.createElement(Text9, { color: theme.secondaryText }, selectedProvider === "azure" ? "This is the deployment name you configured in your Azure OpenAI resource." : selectedProvider === "anthropic" ? "This should match a model identifier supported by your API endpoint." : selectedProvider === "bigdream" ? "This should be a valid model identifier supported by BigDream." : selectedProvider === "kimi" ? "This should be a valid Kimi model identifier from Moonshot AI." : selectedProvider === "deepseek" ? "This should be a valid DeepSeek model identifier." : selectedProvider === "siliconflow" ? "This should be a valid SiliconFlow model identifier." : selectedProvider === "qwen" ? "This should be a valid Qwen model identifier from Alibaba Cloud." : selectedProvider === "glm" ? "This should be a valid GLM model identifier from Zhipu AI." : selectedProvider === "minimax" ? "This should be a valid MiniMax model identifier." : selectedProvider === "baidu-qianfan" ? "This should be a valid Baidu Qianfan model identifier." : "This should match the model name supported by your API endpoint.", /* @__PURE__ */ React10.createElement(Newline4, null), examples)), /* @__PURE__ */ React10.createElement(Box8, null, /* @__PURE__ */ React10.createElement(
+      TextInput,
+      {
+        placeholder,
+        value: customModelName,
+        onChange: setCustomModelName,
+        onSubmit: handleCustomModelSubmit,
+        columns: 100,
+        cursorOffset: customModelNameCursorOffset,
+        onChangeCursorOffset: setCustomModelNameCursorOffset,
+        showCursor: true
+      }
+    )), /* @__PURE__ */ React10.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, null, /* @__PURE__ */ React10.createElement(Text9, { color: theme.suggestion, dimColor: !customModelName }, "[Submit Model Name]"), /* @__PURE__ */ React10.createElement(Text9, null, " - Press Enter or click to continue"))), /* @__PURE__ */ React10.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "Press ", /* @__PURE__ */ React10.createElement(Text9, { color: theme.suggestion }, "Enter"), " to continue or", " ", /* @__PURE__ */ React10.createElement(Text9, { color: theme.suggestion }, "Esc"), " to go back")))
+  ));
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ModelParamsScreen.tsx
+import React11 from "react";
+import { Box as Box9, Text as Text10 } from "ink";
+function isReasoningEffortOption(value) {
+  return value === "low" || value === "medium" || value === "high";
+}
+function ModelParamsScreen({
+  theme,
+  exitState,
+  selectedModel,
+  formFields,
+  activeFieldIndex,
+  setActiveFieldIndex,
+  maxTokens,
+  setMaxTokens,
+  setSelectedMaxTokensPreset,
+  setMaxTokensCursorOffset,
+  reasoningEffortOptions,
+  reasoningEffort,
+  setReasoningEffort
+}) {
+  return /* @__PURE__ */ React11.createElement(Box9, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React11.createElement(
+    Box9,
+    {
+      flexDirection: "column",
+      gap: 1,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: 1
+    },
+    /* @__PURE__ */ React11.createElement(Text10, { bold: true }, "Model Parameters", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React11.createElement(Box9, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React11.createElement(Text10, { bold: true }, "Configure parameters for ", selectedModel, ":"), /* @__PURE__ */ React11.createElement(Box9, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React11.createElement(Text10, { color: theme.secondaryText }, "Use ", /* @__PURE__ */ React11.createElement(Text10, { color: theme.suggestion }, "Tab"), " to navigate between fields. Press ", /* @__PURE__ */ React11.createElement(Text10, { color: theme.suggestion }, "Enter"), " to submit.")), /* @__PURE__ */ React11.createElement(Box9, { flexDirection: "column" }, formFields.map((field, index) => /* @__PURE__ */ React11.createElement(Box9, { flexDirection: "column", marginY: 1, key: field.name }, field.component !== "button" ? /* @__PURE__ */ React11.createElement(React11.Fragment, null, /* @__PURE__ */ React11.createElement(
+      Text10,
+      {
+        bold: true,
+        color: activeFieldIndex === index ? theme.success : void 0
+      },
+      field.label
+    ), field.description && /* @__PURE__ */ React11.createElement(Text10, { color: theme.secondaryText }, field.description)) : /* @__PURE__ */ React11.createElement(
+      Text10,
+      {
+        bold: true,
+        color: activeFieldIndex === index ? theme.success : void 0
+      },
+      field.label
+    ), /* @__PURE__ */ React11.createElement(Box9, { marginY: 1 }, activeFieldIndex === index ? field.component === "select" ? field.name === "maxTokens" ? /* @__PURE__ */ React11.createElement(
+      Select,
+      {
+        options: field.options || [],
+        onChange: (value) => {
+          const numValue = parseInt(value);
+          setMaxTokens(numValue.toString());
+          setSelectedMaxTokensPreset(numValue);
+          setMaxTokensCursorOffset(numValue.toString().length);
+          setTimeout(() => {
+            setActiveFieldIndex(index + 1);
+          }, 100);
+        },
+        defaultValue: field.defaultValue,
+        visibleOptionCount: 10
+      }
+    ) : /* @__PURE__ */ React11.createElement(
+      Select,
+      {
+        options: reasoningEffortOptions,
+        onChange: (value) => {
+          if (isReasoningEffortOption(value)) {
+            setReasoningEffort(value);
+          }
+          setTimeout(() => {
+            setActiveFieldIndex(index + 1);
+          }, 100);
+        },
+        defaultValue: reasoningEffort ?? void 0,
+        visibleOptionCount: 8
+      }
+    ) : null : field.name === "maxTokens" ? /* @__PURE__ */ React11.createElement(Text10, { color: theme.secondaryText }, "Current:", " ", /* @__PURE__ */ React11.createElement(Text10, { color: theme.suggestion }, MAX_TOKENS_OPTIONS.find(
+      (opt) => opt.value === parseInt(maxTokens)
+    )?.label || `${maxTokens} tokens`)) : field.name === "reasoningEffort" ? /* @__PURE__ */ React11.createElement(Text10, { color: theme.secondaryText }, "Current:", " ", /* @__PURE__ */ React11.createElement(Text10, { color: theme.suggestion }, reasoningEffort)) : null))), /* @__PURE__ */ React11.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "Press ", /* @__PURE__ */ React11.createElement(Text10, { color: theme.suggestion }, "Tab"), " to navigate,", " ", /* @__PURE__ */ React11.createElement(Text10, { color: theme.suggestion }, "Enter"), " to continue, or", " ", /* @__PURE__ */ React11.createElement(Text10, { color: theme.suggestion }, "Esc"), " to go back"))))
+  ));
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ModelSelectionScreen.tsx
+import React12 from "react";
+import { Box as Box10, Text as Text11 } from "ink";
+function ModelSelectionScreen({
+  theme,
+  exitState,
+  selectedProvider,
+  availableModels,
+  modelSearchQuery,
+  modelSearchCursorOffset,
+  handleModelSearchChange,
+  handleModelSearchCursorOffsetChange,
+  modelOptions,
+  handleModelSelection,
+  getProviderLabel
+}) {
+  const modelTypeText = "this model profile";
+  return /* @__PURE__ */ React12.createElement(Box10, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React12.createElement(
+    Box10,
+    {
+      flexDirection: "column",
+      gap: 1,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: 1
+    },
+    /* @__PURE__ */ React12.createElement(Text11, { bold: true }, "Model Selection", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React12.createElement(Box10, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React12.createElement(Text11, { bold: true }, "Select a model from", " ", getProviderLabel(selectedProvider, availableModels.length).split(
+      " ("
+    )[0], " ", "for ", modelTypeText, ":"), /* @__PURE__ */ React12.createElement(Box10, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React12.createElement(Text11, { color: theme.secondaryText }, "This model profile can be assigned to different pointers (main, task, compact, quick) for various use cases.")), /* @__PURE__ */ React12.createElement(Box10, { marginY: 1 }, /* @__PURE__ */ React12.createElement(Text11, { bold: true }, "Search models:"), /* @__PURE__ */ React12.createElement(
+      TextInput,
+      {
+        placeholder: "Type to filter models...",
+        value: modelSearchQuery,
+        onChange: handleModelSearchChange,
+        columns: 100,
+        cursorOffset: modelSearchCursorOffset,
+        onChangeCursorOffset: handleModelSearchCursorOffsetChange,
+        showCursor: true,
+        focus: true
+      }
+    )), modelOptions.length > 0 ? /* @__PURE__ */ React12.createElement(React12.Fragment, null, /* @__PURE__ */ React12.createElement(
+      Select,
+      {
+        options: modelOptions,
+        onChange: handleModelSelection,
+        visibleOptionCount: 15
+      }
+    ), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "Showing ", modelOptions.length, " of ", availableModels.length, " models")) : /* @__PURE__ */ React12.createElement(Box10, null, availableModels.length > 0 ? /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, "No models match your search. Try a different query.") : /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, "No models available for this provider.")), /* @__PURE__ */ React12.createElement(Box10, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "Press ", /* @__PURE__ */ React12.createElement(Text11, { color: theme.suggestion }, "Esc"), " to go back to API key input")))
+  ));
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/PartnerCodingPlansScreen.tsx
+import React13 from "react";
+import { Box as Box11, Newline as Newline5, Text as Text12 } from "ink";
+function PartnerCodingPlansScreen({
+  theme,
+  exitState,
+  containerPaddingY,
+  containerGap,
+  tightLayout,
+  compactLayout,
+  codingPlanOptions,
+  codingPlanFocusIndex,
+  codingReservedLines,
+  getSafeVisibleOptionCount,
+  renderWindowedOptions
+}) {
+  const footerMarginTop = tightLayout ? 0 : 1;
+  return /* @__PURE__ */ React13.createElement(Box11, { flexDirection: "column", gap: containerGap }, /* @__PURE__ */ React13.createElement(
+    Box11,
+    {
+      flexDirection: "column",
+      gap: containerGap,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: containerPaddingY
+    },
+    /* @__PURE__ */ React13.createElement(Text12, { bold: true }, "Partner Coding Plans", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React13.createElement(Box11, { flexDirection: "column", gap: containerGap }, /* @__PURE__ */ React13.createElement(Text12, { bold: true }, "Select a partner coding plan for specialized programming assistance:"), /* @__PURE__ */ React13.createElement(Box11, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React13.createElement(Text12, { color: theme.secondaryText }, compactLayout ? "Specialized coding models from partners." : /* @__PURE__ */ React13.createElement(React13.Fragment, null, "These are specialized models optimized for coding and development tasks.", /* @__PURE__ */ React13.createElement(Newline5, null), "They require specific coding plan subscriptions from the respective providers."))), renderWindowedOptions(
+      codingPlanOptions,
+      codingPlanFocusIndex,
+      getSafeVisibleOptionCount(
+        5,
+        codingPlanOptions.length,
+        codingReservedLines
+      )
+    ), /* @__PURE__ */ React13.createElement(Box11, { marginTop: footerMarginTop }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "Press ", /* @__PURE__ */ React13.createElement(Text12, { color: theme.suggestion }, "Esc"), " to go back to main menu")))
+  ));
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/PartnerProvidersScreen.tsx
+import React14 from "react";
+import { Box as Box12, Text as Text13 } from "ink";
+function PartnerProvidersScreen({
+  theme,
+  exitState,
+  containerPaddingY,
+  containerGap,
+  compactLayout,
+  tightLayout,
+  partnerProviderOptions,
+  partnerProviderFocusIndex,
+  partnerReservedLines,
+  getSafeVisibleOptionCount,
+  renderWindowedOptions
+}) {
+  const footerMarginTop = tightLayout ? 0 : 1;
+  return /* @__PURE__ */ React14.createElement(Box12, { flexDirection: "column", gap: containerGap }, /* @__PURE__ */ React14.createElement(
+    Box12,
+    {
+      flexDirection: "column",
+      gap: containerGap,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: containerPaddingY
+    },
+    /* @__PURE__ */ React14.createElement(Text13, { bold: true }, "Partner Providers", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React14.createElement(Box12, { flexDirection: "column", gap: containerGap }, /* @__PURE__ */ React14.createElement(Text13, { bold: true }, "Select a partner AI provider for this model profile:"), /* @__PURE__ */ React14.createElement(Box12, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React14.createElement(Text13, { color: theme.secondaryText }, compactLayout ? "Choose an official partner provider." : "Choose from official partner providers to access their models and services.")), renderWindowedOptions(
+      partnerProviderOptions,
+      partnerProviderFocusIndex,
+      getSafeVisibleOptionCount(
+        6,
+        partnerProviderOptions.length,
+        partnerReservedLines
+      )
+    ), /* @__PURE__ */ React14.createElement(Box12, { marginTop: footerMarginTop }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "Press ", /* @__PURE__ */ React14.createElement(Text13, { color: theme.suggestion }, "Esc"), " to go back to main menu")))
+  ));
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ProviderSelectionScreen.tsx
+import React16 from "react";
+import { Box as Box14, Newline as Newline6, Text as Text15 } from "ink";
+
+// apps/cli/src/ui/ui/components/model-selector/ScreenContainer.tsx
+import React15 from "react";
+import { Box as Box13, Text as Text14 } from "ink";
+function ScreenContainer({
+  title,
+  exitState,
+  children,
+  paddingY = 1,
+  gap = 1
+}) {
+  const theme = getTheme();
+  return /* @__PURE__ */ React15.createElement(
+    Box13,
+    {
+      flexDirection: "column",
+      gap,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY
+    },
+    /* @__PURE__ */ React15.createElement(Text14, { bold: true }, title, " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    children
+  );
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ProviderSelectionScreen.tsx
+function ProviderSelectionScreen({
+  theme,
+  exitState,
+  containerPaddingY,
+  containerGap,
+  compactLayout,
+  tightLayout,
+  mainMenuOptions,
+  providerFocusIndex,
+  providerReservedLines,
+  getSafeVisibleOptionCount,
+  renderWindowedOptions
+}) {
+  return /* @__PURE__ */ React16.createElement(
+    ScreenContainer,
+    {
+      title: "Provider Selection",
+      exitState,
+      paddingY: containerPaddingY,
+      gap: containerGap,
+      children: /* @__PURE__ */ React16.createElement(Box14, { flexDirection: "column", gap: containerGap }, /* @__PURE__ */ React16.createElement(Text15, { bold: true }, "Select your preferred AI provider for this model profile:"), /* @__PURE__ */ React16.createElement(Box14, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React16.createElement(Text15, { color: theme.secondaryText }, compactLayout ? "Choose the provider to use for this profile." : /* @__PURE__ */ React16.createElement(React16.Fragment, null, "Choose the provider you want to use for this model profile.", /* @__PURE__ */ React16.createElement(Newline6, null), "This will determine which models are available to you."))), renderWindowedOptions(
+        mainMenuOptions,
+        providerFocusIndex,
+        getSafeVisibleOptionCount(
+          5,
+          mainMenuOptions.length,
+          providerReservedLines
+        )
+      ), /* @__PURE__ */ React16.createElement(Box14, { marginTop: tightLayout ? 0 : 1 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "You can change this later by running", " ", /* @__PURE__ */ React16.createElement(Text15, { color: theme.suggestion }, "/model"), " again")))
+    }
+  );
+}
+
+// apps/cli/src/ui/ui/components/model-selector/screens/ResourceNameScreen.tsx
+import React17 from "react";
+import { Box as Box15, Newline as Newline7, Text as Text16 } from "ink";
+function ResourceNameScreen({
+  theme,
+  exitState,
+  resourceName,
+  setResourceName,
+  handleResourceNameSubmit,
+  resourceNameCursorOffset,
+  setResourceNameCursorOffset
+}) {
+  return /* @__PURE__ */ React17.createElement(Box15, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React17.createElement(
+    Box15,
+    {
+      flexDirection: "column",
+      gap: 1,
+      borderStyle: "round",
+      borderColor: theme.secondaryBorder,
+      paddingX: 2,
+      paddingY: 1
+    },
+    /* @__PURE__ */ React17.createElement(Text16, { bold: true }, "Azure Resource Setup", " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""),
+    /* @__PURE__ */ React17.createElement(Box15, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React17.createElement(Text16, { bold: true }, "Enter your Azure OpenAI resource name:"), /* @__PURE__ */ React17.createElement(Box15, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React17.createElement(Text16, { color: theme.secondaryText }, "This is the name of your Azure OpenAI resource (without the full domain).", /* @__PURE__ */ React17.createElement(Newline7, null), 'For example, if your endpoint is "https://myresource.openai.azure.com", enter "myresource".')), /* @__PURE__ */ React17.createElement(Box15, null, /* @__PURE__ */ React17.createElement(
+      TextInput,
+      {
+        placeholder: "myazureresource",
+        value: resourceName,
+        onChange: setResourceName,
+        onSubmit: handleResourceNameSubmit,
+        columns: 100,
+        cursorOffset: resourceNameCursorOffset,
+        onChangeCursorOffset: setResourceNameCursorOffset,
+        showCursor: true
+      }
+    )), /* @__PURE__ */ React17.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, null, /* @__PURE__ */ React17.createElement(Text16, { color: theme.suggestion, dimColor: !resourceName }, "[Submit Resource Name]"), /* @__PURE__ */ React17.createElement(Text16, null, " - Press Enter or click to continue"))), /* @__PURE__ */ React17.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "Press ", /* @__PURE__ */ React17.createElement(Text16, { color: theme.suggestion }, "Enter"), " to continue or", " ", /* @__PURE__ */ React17.createElement(Text16, { color: theme.suggestion }, "Esc"), " to go back")))
+  ));
+}
+
+// apps/cli/src/ui/components/ModelSelector/ModelSelectorView.tsx
+function ModelSelectorView(props) {
+  function getSafeVisibleOptionCount(requestedCount, optionLength, reservedLines = 10) {
+    const rows = props.terminalRows;
+    const available = Math.max(1, rows - reservedLines);
+    return Math.max(1, Math.min(requestedCount, optionLength, available));
+  }
+  function renderWindowedOptions(options, focusedIndex, maxVisible) {
+    if (options.length === 0) {
+      return /* @__PURE__ */ React18.createElement(Text17, { color: props.theme.secondaryText }, "No options available.");
+    }
+    const visibleCount = Math.max(1, Math.min(maxVisible, options.length));
+    const half = Math.floor(visibleCount / 2);
+    const start = Math.max(
+      0,
+      Math.min(focusedIndex - half, Math.max(0, options.length - visibleCount))
+    );
+    const end = Math.min(options.length, start + visibleCount);
+    const showUp = start > 0;
+    const showDown = end < options.length;
+    return /* @__PURE__ */ React18.createElement(Box16, { flexDirection: "column", gap: 0 }, showUp && /* @__PURE__ */ React18.createElement(Text17, { color: props.theme.secondaryText }, figures.arrowUp, " More"), options.slice(start, end).map((opt, idx) => {
+      const absoluteIndex = start + idx;
+      const isFocused = absoluteIndex === focusedIndex;
+      return /* @__PURE__ */ React18.createElement(Box16, { key: opt.value, flexDirection: "row" }, /* @__PURE__ */ React18.createElement(
+        Text17,
+        {
+          color: isFocused ? props.theme.kode : props.theme.secondaryText
+        },
+        isFocused ? figures.pointer : " "
+      ), /* @__PURE__ */ React18.createElement(
+        Text17,
+        {
+          color: isFocused ? props.theme.text : props.theme.secondaryText,
+          bold: isFocused
+        },
+        " ",
+        opt.label
+      ));
+    }), showDown && /* @__PURE__ */ React18.createElement(Text17, { color: props.theme.secondaryText }, figures.arrowDown, " More"));
+  }
+  if (props.currentScreen === "apiKey") {
+    return /* @__PURE__ */ React18.createElement(
+      ApiKeyScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        selectedProvider: props.selectedProvider,
+        apiKey: props.apiKey,
+        cursorOffset: props.cursorOffset,
+        handleApiKeyChange: props.handleApiKeyChange,
+        handleApiKeySubmit: props.handleApiKeySubmit,
+        handleCursorOffsetChange: props.handleCursorOffsetChange,
+        apiKeyCleanedNotification: props.apiKeyCleanedNotification,
+        isLoadingModels: props.isLoadingModels,
+        providerBaseUrl: props.providerBaseUrl,
+        modelLoadError: props.modelLoadError,
+        formatApiKeyDisplay: props.formatApiKeyDisplay,
+        getProviderLabel: props.getProviderLabel
+      }
+    );
+  }
+  if (props.currentScreen === "model") {
+    return /* @__PURE__ */ React18.createElement(
+      ModelSelectionScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        selectedProvider: props.selectedProvider,
+        availableModels: props.availableModels,
+        modelSearchQuery: props.modelSearchQuery,
+        modelSearchCursorOffset: props.modelSearchCursorOffset,
+        handleModelSearchChange: props.handleModelSearchChange,
+        handleModelSearchCursorOffsetChange: props.handleModelSearchCursorOffsetChange,
+        modelOptions: props.modelOptions,
+        handleModelSelection: props.handleModelSelection,
+        getProviderLabel: props.getProviderLabel
+      }
+    );
+  }
+  if (props.currentScreen === "modelParams") {
+    const formFields = props.getFormFieldsForModelParams();
+    return /* @__PURE__ */ React18.createElement(
+      ModelParamsScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        selectedModel: props.selectedModel,
+        formFields,
+        activeFieldIndex: props.activeFieldIndex,
+        setActiveFieldIndex: props.setActiveFieldIndex,
+        maxTokens: props.maxTokens,
+        setMaxTokens: props.setMaxTokens,
+        setSelectedMaxTokensPreset: props.setSelectedMaxTokensPreset,
+        setMaxTokensCursorOffset: props.setMaxTokensCursorOffset,
+        reasoningEffortOptions: props.reasoningEffortOptions,
+        reasoningEffort: props.reasoningEffort,
+        setReasoningEffort: props.setReasoningEffort
+      }
+    );
+  }
+  if (props.currentScreen === "resourceName") {
+    return /* @__PURE__ */ React18.createElement(
+      ResourceNameScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        resourceName: props.resourceName,
+        setResourceName: props.setResourceName,
+        handleResourceNameSubmit: props.handleResourceNameSubmit,
+        resourceNameCursorOffset: props.resourceNameCursorOffset,
+        setResourceNameCursorOffset: props.setResourceNameCursorOffset
+      }
+    );
+  }
+  if (props.currentScreen === "baseUrl") {
+    return /* @__PURE__ */ React18.createElement(
+      BaseUrlScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        selectedProvider: props.selectedProvider,
+        isLoadingModels: props.isLoadingModels,
+        modelLoadError: props.modelLoadError,
+        customBaseUrl: props.customBaseUrl,
+        setCustomBaseUrl: props.setCustomBaseUrl,
+        handleCustomBaseUrlSubmit: props.handleCustomBaseUrlSubmit,
+        customBaseUrlCursorOffset: props.customBaseUrlCursorOffset,
+        setCustomBaseUrlCursorOffset: props.setCustomBaseUrlCursorOffset,
+        providerBaseUrl: props.providerBaseUrl,
+        setProviderBaseUrl: props.setProviderBaseUrl,
+        handleProviderBaseUrlSubmit: props.handleProviderBaseUrlSubmit,
+        providerBaseUrlCursorOffset: props.providerBaseUrlCursorOffset,
+        setProviderBaseUrlCursorOffset: props.setProviderBaseUrlCursorOffset
+      }
+    );
+  }
+  if (props.currentScreen === "modelInput") {
+    return /* @__PURE__ */ React18.createElement(
+      ModelInputScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        selectedProvider: props.selectedProvider,
+        customModelName: props.customModelName,
+        setCustomModelName: props.setCustomModelName,
+        handleCustomModelSubmit: props.handleCustomModelSubmit,
+        customModelNameCursorOffset: props.customModelNameCursorOffset,
+        setCustomModelNameCursorOffset: props.setCustomModelNameCursorOffset
+      }
+    );
+  }
+  if (props.currentScreen === "contextLength") {
+    return /* @__PURE__ */ React18.createElement(
+      ContextLengthScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        contextLength: props.contextLength
+      }
+    );
+  }
+  if (props.currentScreen === "connectionTest") {
+    return /* @__PURE__ */ React18.createElement(
+      ConnectionTestScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        selectedProvider: props.selectedProvider,
+        getProviderLabel: props.getProviderLabel,
+        isTestingConnection: props.isTestingConnection,
+        connectionTestResult: props.connectionTestResult
+      }
+    );
+  }
+  if (props.currentScreen === "confirmation") {
+    return /* @__PURE__ */ React18.createElement(
+      ConfirmationScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        selectedProvider: props.selectedProvider,
+        selectedModel: props.selectedModel,
+        resourceName: props.resourceName,
+        ollamaBaseUrl: props.ollamaBaseUrl,
+        customBaseUrl: props.customBaseUrl,
+        apiKey: props.apiKey,
+        maxTokens: props.maxTokens,
+        contextLength: props.contextLength,
+        supportsReasoningEffort: props.supportsReasoningEffort,
+        reasoningEffort: props.reasoningEffort,
+        validationError: props.validationError,
+        formatApiKeyDisplay: props.formatApiKeyDisplay,
+        getProviderLabel: props.getProviderLabel
+      }
+    );
+  }
+  if (props.currentScreen === "partnerProviders") {
+    return /* @__PURE__ */ React18.createElement(
+      PartnerProvidersScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        containerPaddingY: props.containerPaddingY,
+        containerGap: props.containerGap,
+        compactLayout: props.compactLayout,
+        tightLayout: props.tightLayout,
+        partnerProviderOptions: props.partnerProviderOptions,
+        partnerProviderFocusIndex: props.partnerProviderFocusIndex,
+        partnerReservedLines: props.partnerReservedLines,
+        getSafeVisibleOptionCount,
+        renderWindowedOptions
+      }
+    );
+  }
+  if (props.currentScreen === "partnerCodingPlans") {
+    return /* @__PURE__ */ React18.createElement(
+      PartnerCodingPlansScreen,
+      {
+        theme: props.theme,
+        exitState: props.exitState,
+        containerPaddingY: props.containerPaddingY,
+        containerGap: props.containerGap,
+        tightLayout: props.tightLayout,
+        compactLayout: props.compactLayout,
+        codingPlanOptions: props.codingPlanOptions,
+        codingPlanFocusIndex: props.codingPlanFocusIndex,
+        codingReservedLines: props.codingReservedLines,
+        getSafeVisibleOptionCount,
+        renderWindowedOptions
+      }
+    );
+  }
+  return /* @__PURE__ */ React18.createElement(
+    ProviderSelectionScreen,
+    {
+      theme: props.theme,
+      exitState: props.exitState,
+      containerPaddingY: props.containerPaddingY,
+      containerGap: props.containerGap,
+      compactLayout: props.compactLayout,
+      tightLayout: props.tightLayout,
+      mainMenuOptions: props.mainMenuOptions,
+      providerFocusIndex: props.providerFocusIndex,
+      providerReservedLines: props.providerReservedLines,
+      getSafeVisibleOptionCount,
+      renderWindowedOptions
+    }
+  );
+}
+
+// apps/cli/src/ui/components/ModelSelector/useModelSelectorController.tsx
+import { useEffect as useEffect2, useMemo as useMemo4 } from "react";
+import { useStdout } from "ink";
+
+// apps/cli/src/ui/ui/components/model-selector/printModelConfig.ts
+import chalk2 from "chalk";
+function printModelConfig() {
+  const config = getGlobalConfig();
+  const modelProfiles = config.modelProfiles || [];
+  const activeProfiles = modelProfiles.filter((p) => p.isActive);
+  if (activeProfiles.length === 0) {
+    process.stdout.write(
+      `${chalk2.gray("  \u23BF  No active model profiles configured")}
+`
+    );
+    return;
+  }
+  const profileSummary = activeProfiles.map((p) => `${p.name} (${p.provider}: ${p.modelName})`).join(" | ");
+  process.stdout.write(`${chalk2.gray(`  \u23BF  ${profileSummary}`)}
+`);
+}
+
+// apps/cli/src/ui/components/ModelSelector/useModelSelectorInput.ts
+import { useInput as useInput3 } from "ink";
+function useModelSelectorInput(args) {
+  useInput3((input, key) => {
+    if (args.currentScreen === "provider") {
+      if (key.upArrow) {
+        args.setProviderFocusIndex(
+          (prev) => args.mainMenuOptions.length === 0 ? 0 : (prev - 1 + args.mainMenuOptions.length) % args.mainMenuOptions.length
+        );
+        return;
+      }
+      if (key.downArrow) {
+        args.setProviderFocusIndex(
+          (prev) => args.mainMenuOptions.length === 0 ? 0 : (prev + 1) % args.mainMenuOptions.length
+        );
+        return;
+      }
+      if (key.return) {
+        const opt = args.mainMenuOptions[args.providerFocusIndex];
+        if (opt) {
+          args.handleProviderSelection(opt.value);
+        }
+        return;
+      }
+    }
+    if (args.currentScreen === "partnerProviders") {
+      if (key.upArrow) {
+        args.setPartnerProviderFocusIndex(
+          (prev) => args.partnerProviderOptions.length === 0 ? 0 : (prev - 1 + args.partnerProviderOptions.length) % args.partnerProviderOptions.length
+        );
+        return;
+      }
+      if (key.downArrow) {
+        args.setPartnerProviderFocusIndex(
+          (prev) => args.partnerProviderOptions.length === 0 ? 0 : (prev + 1) % args.partnerProviderOptions.length
+        );
+        return;
+      }
+      if (key.return) {
+        const opt = args.partnerProviderOptions[args.partnerProviderFocusIndex];
+        if (opt) {
+          args.handleProviderSelection(opt.value);
+        }
+        return;
+      }
+    }
+    if (args.currentScreen === "partnerCodingPlans") {
+      if (key.upArrow) {
+        args.setCodingPlanFocusIndex(
+          (prev) => args.codingPlanOptions.length === 0 ? 0 : (prev - 1 + args.codingPlanOptions.length) % args.codingPlanOptions.length
+        );
+        return;
+      }
+      if (key.downArrow) {
+        args.setCodingPlanFocusIndex(
+          (prev) => args.codingPlanOptions.length === 0 ? 0 : (prev + 1) % args.codingPlanOptions.length
+        );
+        return;
+      }
+      if (key.return) {
+        const opt = args.codingPlanOptions[args.codingPlanFocusIndex];
+        if (opt) {
+          args.handleProviderSelection(opt.value);
+        }
+        return;
+      }
+    }
+    if (args.currentScreen === "apiKey" && key.return) {
+      if (args.apiKey) {
+        void args.handleApiKeySubmit(args.apiKey);
+      }
+      return;
+    }
+    if (args.currentScreen === "apiKey" && key.tab) {
+      if (args.selectedProvider === "anthropic" || args.selectedProvider === "kimi" || args.selectedProvider === "deepseek" || args.selectedProvider === "qwen" || args.selectedProvider === "glm" || args.selectedProvider === "glm-coding" || args.selectedProvider === "minimax" || args.selectedProvider === "minimax-coding" || args.selectedProvider === "baidu-qianfan" || args.selectedProvider === "siliconflow" || args.selectedProvider === "custom-openai") {
+        args.navigateTo("modelInput");
+        return;
+      }
+      void args.fetchModelsWithRetry().catch((error) => {
+        console.error("Final error after retries:", error);
+      });
+      return;
+    }
+    if (args.currentScreen === "resourceName" && key.return) {
+      if (args.resourceName) {
+        args.handleResourceNameSubmit(args.resourceName);
+      }
+      return;
+    }
+    if (args.currentScreen === "baseUrl" && key.return) {
+      if (args.selectedProvider === "custom-openai") {
+        args.handleCustomBaseUrlSubmit(args.customBaseUrl);
+      } else {
+        args.handleProviderBaseUrlSubmit(args.providerBaseUrl);
+      }
+      return;
+    }
+    if (args.currentScreen === "modelInput" && key.return) {
+      if (args.customModelName) {
+        args.handleCustomModelSubmit(args.customModelName);
+      }
+      return;
+    }
+    if (args.currentScreen === "confirmation" && key.return) {
+      void args.handleConfirmation().catch((error) => {
+        console.error("Error in handleConfirmation:", error);
+        args.setValidationError(
+          error instanceof Error ? error.message : "Unexpected error occurred"
+        );
+      });
+      return;
+    }
+    if (args.currentScreen === "connectionTest") {
+      if (key.return) {
+        if (!args.isTestingConnection && !args.connectionTestResult) {
+          args.handleConnectionTest();
+        } else if (args.connectionTestResult && args.connectionTestResult.success) {
+          args.navigateTo("confirmation");
+        } else if (args.connectionTestResult && !args.connectionTestResult.success) {
+          args.handleConnectionTest();
+        }
+        return;
+      }
+    }
+    if (args.currentScreen === "contextLength") {
+      if (key.return) {
+        args.handleContextLengthSubmit();
+        return;
+      }
+      if (key.upArrow) {
+        const currentIndex = CONTEXT_LENGTH_OPTIONS.findIndex(
+          (opt) => opt.value === args.contextLength
+        );
+        const newIndex = currentIndex > 0 ? currentIndex - 1 : currentIndex === -1 ? CONTEXT_LENGTH_OPTIONS.findIndex(
+          (opt) => opt.value === DEFAULT_CONTEXT_LENGTH
+        ) || 0 : CONTEXT_LENGTH_OPTIONS.length - 1;
+        args.setContextLength(CONTEXT_LENGTH_OPTIONS[newIndex].value);
+        return;
+      }
+      if (key.downArrow) {
+        const currentIndex = CONTEXT_LENGTH_OPTIONS.findIndex(
+          (opt) => opt.value === args.contextLength
+        );
+        const newIndex = currentIndex === -1 ? CONTEXT_LENGTH_OPTIONS.findIndex(
+          (opt) => opt.value === DEFAULT_CONTEXT_LENGTH
+        ) || 0 : (currentIndex + 1) % CONTEXT_LENGTH_OPTIONS.length;
+        args.setContextLength(CONTEXT_LENGTH_OPTIONS[newIndex].value);
+        return;
+      }
+    }
+    if (args.currentScreen === "apiKey" && (key.ctrl && input === "v" || key.meta && input === "v")) {
+      args.setModelLoadError(
+        "Please use your terminal's paste functionality or type the API key manually"
+      );
+      return;
+    }
+    if (args.currentScreen === "modelParams" && key.tab) {
+      const formFields = args.getFormFieldsForModelParams();
+      args.setActiveFieldIndex((current) => (current + 1) % formFields.length);
+      return;
+    }
+    if (args.currentScreen === "modelParams" && key.return) {
+      const formFields = args.getFormFieldsForModelParams();
+      const currentField = formFields[args.activeFieldIndex];
+      if (currentField?.name === "submit" || args.activeFieldIndex === formFields.length - 1) {
+        args.handleModelParamsSubmit();
+      } else if (currentField?.component === "select") {
+        args.setActiveFieldIndex(
+          (current) => Math.min(current + 1, formFields.length - 1)
+        );
+      }
+      return;
+    }
+  });
+}
+
+// apps/cli/src/ui/components/ModelSelector/useModelSelectorMenus.ts
+import { useEffect, useMemo as useMemo2 } from "react";
+function useModelSelectorMenus(args) {
+  function getProviderLabel(provider, modelCount) {
+    if (providers[provider]) {
+      const wipTag = "(WIP)";
+      return `${providers[provider].name} ${providers[provider].status === "wip" ? wipTag : ""}`;
+    }
+    return `${provider}`;
+  }
+  const mainMenuOptions = useMemo2(
+    () => [
+      { value: "custom-openai", label: "Custom OpenAI-Compatible API" },
+      { value: "custom-anthropic", label: "Custom Messages API (v1/messages)" },
+      { value: "partnerProviders", label: "Partner Providers \u2192" },
+      { value: "partnerCodingPlans", label: "Partner Coding Plans \u2192" },
+      {
+        value: "ollama",
+        label: getProviderLabel("ollama", models_default.ollama?.length || 0)
+      }
+    ],
+    []
+  );
+  const rankedProviders = useMemo2(
+    () => [
+      "openai",
+      "anthropic",
+      "gemini",
+      "glm",
+      "kimi",
+      "minimax",
+      "qwen",
+      "deepseek",
+      "openrouter",
+      "burncloud",
+      "siliconflow",
+      "baidu-qianfan",
+      "mistral",
+      "xai",
+      "groq",
+      "azure"
+    ],
+    []
+  );
+  const partnerProviders = useMemo2(
+    () => rankedProviders.filter(
+      (provider) => providers[provider] && !provider.includes("coding") && provider !== "custom-openai" && provider !== "ollama"
+    ),
+    [rankedProviders]
+  );
+  const codingPlanProviders = useMemo2(
+    () => Object.keys(providers).filter((provider) => provider.includes("coding")),
+    []
+  );
+  const partnerProviderOptions = useMemo2(
+    () => partnerProviders.map((provider) => {
+      const modelCount = models_default[provider]?.length || 0;
+      return {
+        label: getProviderLabel(provider, modelCount),
+        value: provider
+      };
+    }),
+    [partnerProviders]
+  );
+  const codingPlanOptions = useMemo2(
+    () => codingPlanProviders.map((provider) => {
+      const modelCount = models_default[provider]?.length || 0;
+      return {
+        label: getProviderLabel(provider, modelCount),
+        value: provider
+      };
+    }),
+    [codingPlanProviders]
+  );
+  const providerReservedLines = 8 + args.containerPaddingY * 2 + args.containerGap * 2;
+  const partnerReservedLines = 10 + args.containerPaddingY * 2 + args.containerGap * 3;
+  const codingReservedLines = partnerReservedLines;
+  const clampIndex = (index, length) => length === 0 ? 0 : Math.max(0, Math.min(index, length - 1));
+  useEffect(() => {
+    args.setProviderFocusIndex((prev) => clampIndex(prev, mainMenuOptions.length));
+  }, [args, mainMenuOptions.length]);
+  useEffect(() => {
+    args.setPartnerProviderFocusIndex(
+      (prev) => clampIndex(prev, partnerProviderOptions.length)
+    );
+  }, [args, partnerProviderOptions.length]);
+  useEffect(() => {
+    args.setCodingPlanFocusIndex(
+      (prev) => clampIndex(prev, codingPlanOptions.length)
+    );
+  }, [args, codingPlanOptions.length]);
+  return {
+    mainMenuOptions,
+    partnerProviderOptions,
+    codingPlanOptions,
+    providerReservedLines,
+    partnerReservedLines,
+    codingReservedLines,
+    getProviderLabel
+  };
+}
+
+// apps/cli/src/ui/components/ModelSelector/useModelSelectorModelOptions.ts
+import { useMemo as useMemo3 } from "react";
+function formatNumber(num) {
+  if (num >= 1e6) return `${(num / 1e6).toFixed(1)}M`;
+  if (num >= 1e3) return `${(num / 1e3).toFixed(0)}K`;
+  return num.toString();
+}
+function getModelDetails(model) {
+  const details = [];
+  if (model.context_length) {
+    details.push(`${formatNumber(model.context_length)} tokens`);
+  } else if (model.max_tokens) {
+    details.push(`${formatNumber(model.max_tokens)} tokens`);
+  }
+  if (model.supports_vision) details.push("vision");
+  if (model.supports_function_calling) details.push("tools");
+  return details.length > 0 ? ` (${details.join(", ")})` : "";
+}
+function sortModelsByPriority(models) {
+  const priorityKeywords = [
+    "claude",
+    "kimi",
+    "deepseek",
+    "minimax",
+    "o3",
+    "gpt",
+    "qwen"
+  ];
+  return models.sort((a, b) => {
+    const aModelLower = a.model?.toLowerCase() || "";
+    const bModelLower = b.model?.toLowerCase() || "";
+    const aHasPriority = priorityKeywords.some(
+      (keyword) => aModelLower.includes(keyword)
+    );
+    const bHasPriority = priorityKeywords.some(
+      (keyword) => bModelLower.includes(keyword)
+    );
+    if (aHasPriority && !bHasPriority) return -1;
+    if (!aHasPriority && bHasPriority) return 1;
+    return a.model.localeCompare(b.model);
+  });
+}
+function useModelSelectorModelOptions(args) {
+  const ourModelNames = useMemo3(() => {
+    return new Set(
+      (models_default[args.selectedProvider] || []).map(
+        (model) => model.model
+      )
+    );
+  }, [args.selectedProvider]);
+  const filteredModels = useMemo3(() => {
+    return args.modelSearchQuery ? args.availableModels.filter(
+      (model) => model.model?.toLowerCase().includes(args.modelSearchQuery.toLowerCase())
+    ) : args.availableModels;
+  }, [args.availableModels, args.modelSearchQuery]);
+  const sortedFilteredModels = useMemo3(
+    () => sortModelsByPriority([...filteredModels]),
+    [filteredModels]
+  );
+  const modelOptions = useMemo3(
+    () => sortedFilteredModels.map((model) => {
+      const _isInOurModels = ourModelNames.has(model.model);
+      return {
+        label: `${model.model}${getModelDetails(model)}`,
+        value: model.model
+      };
+    }),
+    [ourModelNames, sortedFilteredModels]
+  );
+  return { modelOptions };
+}
+
+// apps/cli/src/ui/components/ModelSelector/useModelSelectorState.tsx
+import { useState as useState3 } from "react";
+
+// apps/cli/src/ui/ui/components/model-selector/state.ts
+function createInitialScreenStack(_opts) {
+  return ["provider"];
+}
+function getCurrentScreen(stack) {
+  return stack[stack.length - 1] ?? "provider";
+}
+function pushScreen(stack, screen) {
+  return [...stack, screen];
+}
+function handleBackNavigation(stack) {
+  const currentScreen = getCurrentScreen(stack);
+  if (currentScreen === "partnerProviders" || currentScreen === "partnerCodingPlans") {
+    return { stack: ["provider"], effect: { type: "resetProviderFocus" } };
+  }
+  if (currentScreen === "provider") {
+    return { stack, effect: { type: "exit" } };
+  }
+  if (stack.length > 1) {
+    return { stack: stack.slice(0, -1), effect: null };
+  }
+  return { stack: ["provider"], effect: { type: "resetProviderFocus" } };
+}
+
+// apps/cli/src/ui/components/ModelSelector/useModelSelectorState.tsx
+function useModelSelectorState(opts) {
+  const config = getGlobalConfig();
+  const [screenStack, setScreenStack] = useState3(
+    () => createInitialScreenStack({ skipModelType: opts.skipModelType })
+  );
+  const currentScreen = getCurrentScreen(screenStack);
+  const navigateTo = (screen) => {
+    setScreenStack((prev) => pushScreen(prev, screen));
+  };
+  const [selectedProvider, setSelectedProvider] = useState3(
+    config.primaryProvider ?? "anthropic"
+  );
+  const [selectedModel, setSelectedModel] = useState3("");
+  const [apiKey, setApiKey] = useState3("");
+  const [maxTokens, setMaxTokens] = useState3(
+    config.maxTokens?.toString() || DEFAULT_MAX_TOKENS.toString()
+  );
+  const [maxTokensMode, setMaxTokensMode] = useState3(
+    "preset"
+  );
+  const [selectedMaxTokensPreset, setSelectedMaxTokensPreset] = useState3(config.maxTokens || DEFAULT_MAX_TOKENS);
+  const [reasoningEffort, setReasoningEffort] = useState3("medium");
+  const [supportsReasoningEffort, setSupportsReasoningEffort] = useState3(false);
+  const [contextLength, setContextLength] = useState3(
+    DEFAULT_CONTEXT_LENGTH
+  );
+  const [activeFieldIndex, setActiveFieldIndex] = useState3(0);
+  const [maxTokensCursorOffset, setMaxTokensCursorOffset] = useState3(0);
+  const [apiKeyCleanedNotification, setApiKeyCleanedNotification] = useState3(false);
+  const [availableModels, setAvailableModels] = useState3([]);
+  const [isLoadingModels, setIsLoadingModels] = useState3(false);
+  const [modelLoadError, setModelLoadError] = useState3(null);
+  const [modelSearchQuery, setModelSearchQuery] = useState3("");
+  const [modelSearchCursorOffset, setModelSearchCursorOffset] = useState3(0);
+  const [cursorOffset, setCursorOffset] = useState3(0);
+  const [apiKeyEdited, setApiKeyEdited] = useState3(false);
+  const [providerFocusIndex, setProviderFocusIndex] = useState3(0);
+  const [partnerProviderFocusIndex, setPartnerProviderFocusIndex] = useState3(0);
+  const [codingPlanFocusIndex, setCodingPlanFocusIndex] = useState3(0);
+  const [fetchRetryCount, setFetchRetryCount] = useState3(0);
+  const [isRetrying, setIsRetrying] = useState3(false);
+  const [isTestingConnection, setIsTestingConnection] = useState3(false);
+  const [connectionTestResult, setConnectionTestResult] = useState3(null);
+  const [validationError, setValidationError] = useState3(null);
+  const [resourceName, setResourceName] = useState3("");
+  const [resourceNameCursorOffset, setResourceNameCursorOffset] = useState3(0);
+  const [customModelName, setCustomModelName] = useState3("");
+  const [customModelNameCursorOffset, setCustomModelNameCursorOffset] = useState3(0);
+  const [ollamaBaseUrl, setOllamaBaseUrl] = useState3(
+    "http://localhost:11434/v1"
+  );
+  const [customBaseUrl, setCustomBaseUrl] = useState3("");
+  const [customBaseUrlCursorOffset, setCustomBaseUrlCursorOffset] = useState3(0);
+  const [providerBaseUrl, setProviderBaseUrl] = useState3("");
+  const [providerBaseUrlCursorOffset, setProviderBaseUrlCursorOffset] = useState3(0);
+  return {
+    screenStack,
+    setScreenStack,
+    currentScreen,
+    navigateTo,
+    selectedProvider,
+    setSelectedProvider,
+    selectedModel,
+    setSelectedModel,
+    apiKey,
+    setApiKey,
+    maxTokens,
+    setMaxTokens,
+    maxTokensMode,
+    setMaxTokensMode,
+    selectedMaxTokensPreset,
+    setSelectedMaxTokensPreset,
+    reasoningEffort,
+    setReasoningEffort,
+    supportsReasoningEffort,
+    setSupportsReasoningEffort,
+    contextLength,
+    setContextLength,
+    activeFieldIndex,
+    setActiveFieldIndex,
+    maxTokensCursorOffset,
+    setMaxTokensCursorOffset,
+    apiKeyCleanedNotification,
+    setApiKeyCleanedNotification,
+    availableModels,
+    setAvailableModels,
+    isLoadingModels,
+    setIsLoadingModels,
+    modelLoadError,
+    setModelLoadError,
+    modelSearchQuery,
+    setModelSearchQuery,
+    modelSearchCursorOffset,
+    setModelSearchCursorOffset,
+    cursorOffset,
+    setCursorOffset,
+    apiKeyEdited,
+    setApiKeyEdited,
+    providerFocusIndex,
+    setProviderFocusIndex,
+    partnerProviderFocusIndex,
+    setPartnerProviderFocusIndex,
+    codingPlanFocusIndex,
+    setCodingPlanFocusIndex,
+    fetchRetryCount,
+    setFetchRetryCount,
+    isRetrying,
+    setIsRetrying,
+    isTestingConnection,
+    setIsTestingConnection,
+    connectionTestResult,
+    setConnectionTestResult,
+    validationError,
+    setValidationError,
+    resourceName,
+    setResourceName,
+    resourceNameCursorOffset,
+    setResourceNameCursorOffset,
+    customModelName,
+    setCustomModelName,
+    customModelNameCursorOffset,
+    setCustomModelNameCursorOffset,
+    ollamaBaseUrl,
+    setOllamaBaseUrl,
+    customBaseUrl,
+    setCustomBaseUrl,
+    customBaseUrlCursorOffset,
+    setCustomBaseUrlCursorOffset,
+    providerBaseUrl,
+    setProviderBaseUrl,
+    providerBaseUrlCursorOffset,
+    setProviderBaseUrlCursorOffset
+  };
+}
+
+// apps/cli/src/ui/ui/components/model-selector/actions/connectionTest/openAICompatibility.ts
+var OPENAI_COMPATIBLE_PROVIDERS = /* @__PURE__ */ new Set([
+  "minimax",
+  "kimi",
+  "deepseek",
+  "siliconflow",
+  "qwen",
+  "glm",
+  "baidu-qianfan",
+  "openai",
+  "mistral",
+  "xai",
+  "groq",
+  "custom-openai"
+]);
+function isOpenAICompatibleProvider(provider) {
+  return OPENAI_COMPATIBLE_PROVIDERS.has(provider);
+}
+
+// apps/cli/src/ui/ui/components/model-selector/actions/connectionTest/testChatEndpoint.ts
+function asRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  if (Array.isArray(value)) return null;
+  return value;
+}
+async function testChatEndpoint({
+  baseURL,
+  endpointPath,
+  endpointName,
+  selectedProvider,
+  selectedModel,
+  apiKey,
+  maxTokens
+}) {
+  const testURL = `${baseURL.replace(/\/+$/, "")}${endpointPath}`;
+  const testPayload = {
+    model: selectedModel,
+    messages: [
+      {
+        role: "user",
+        content: 'Please respond with exactly "YES" (in capital letters) to confirm this connection is working.'
+      }
+    ],
+    max_tokens: Math.max(parseInt(maxTokens) || 8192, 8192),
+    temperature: 0,
+    stream: false
+  };
+  if (selectedModel && selectedModel.toLowerCase().includes("gpt-5")) {
+    debug.api("GPT5_PARAMETER_FIX_APPLY", { model: selectedModel });
+    if (typeof testPayload.max_tokens === "number") {
+      testPayload.max_completion_tokens = testPayload.max_tokens;
+      delete testPayload.max_tokens;
+      debug.api("GPT5_PARAMETER_FIX_MAX_TOKENS", {
+        model: selectedModel,
+        max_completion_tokens: testPayload.max_completion_tokens
+      });
+    }
+    if (typeof testPayload.temperature === "number" && testPayload.temperature !== 1) {
+      debug.api("GPT5_PARAMETER_FIX_TEMPERATURE", {
+        model: selectedModel,
+        from: testPayload.temperature,
+        to: 1
+      });
+      testPayload.temperature = 1;
+    }
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (selectedProvider === "azure") {
+    headers["api-key"] = apiKey;
+  } else {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  try {
+    const response = await fetch(testURL, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(testPayload)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      debug.api("CONNECTION_TEST_RESPONSE", {
+        provider: selectedProvider,
+        endpoint: endpointPath,
+        ok: true
+      });
+      let responseContent = "";
+      const record = data;
+      if (record && Array.isArray(record.choices) && record.choices.length > 0) {
+        const firstChoice = record.choices[0];
+        const message = firstChoice?.message ?? null;
+        responseContent = String(message?.content ?? "");
+      } else if (record && typeof record.reply === "string") {
+        responseContent = record.reply;
+      } else if (record && record.output) {
+        const output = record.output;
+        responseContent = String(output?.text ?? record.output ?? "");
+      }
+      debug.api("CONNECTION_TEST_RESPONSE_PARSED", {
+        provider: selectedProvider,
+        endpoint: endpointPath,
+        contentLength: responseContent.length
+      });
+      const containsYes = responseContent.toLowerCase().includes("yes");
+      if (containsYes) {
+        return {
+          success: true,
+          message: `\u2705 Connection test passed with ${endpointName}`,
+          endpoint: endpointPath,
+          details: `Model responded correctly: "${responseContent.trim()}"`
+        };
+      }
+      return {
+        success: false,
+        message: `\u26A0\uFE0F ${endpointName} connected but model response unexpected`,
+        endpoint: endpointPath,
+        details: `Expected "YES" but got: "${responseContent.trim() || "(empty response)"}"`
+      };
+    }
+    const errorData = await response.json().catch(() => null);
+    const errorRecord = asRecord(errorData);
+    const nestedErrorMessage = (() => {
+      const nestedError = asRecord(errorRecord?.error);
+      const nestedMessage = nestedError?.message;
+      return typeof nestedMessage === "string" ? nestedMessage : null;
+    })();
+    const errorMessage = nestedErrorMessage || (typeof errorRecord?.message === "string" ? errorRecord.message : null) || response.statusText;
+    return {
+      success: false,
+      message: `\u274C ${endpointName} failed (${response.status})`,
+      endpoint: endpointPath,
+      details: `Error: ${errorMessage}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `\u274C ${endpointName} connection failed`,
+      endpoint: endpointPath,
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/actions/connectionTest/testProviderSpecificEndpoint.ts
+async function testProviderSpecificEndpoint({
+  baseURL,
+  selectedProvider,
+  apiKey
+}) {
+  if (selectedProvider === "anthropic" || selectedProvider === "bigdream") {
+    try {
+      debug.api("PROVIDER_CONNECTION_TEST_NATIVE_SDK", {
+        provider: selectedProvider
+      });
+      let testBaseURL = void 0;
+      if (selectedProvider === "bigdream") {
+        testBaseURL = baseURL || "https://api-key.info";
+      } else if (selectedProvider === "anthropic") {
+        testBaseURL = baseURL && baseURL !== "https://api.anthropic.com" ? baseURL : void 0;
+      }
+      const isValid = await verifyApiKey(apiKey, testBaseURL, selectedProvider);
+      if (isValid) {
+        return {
+          success: true,
+          message: `\u2705 ${selectedProvider} connection test passed`,
+          endpoint: "/messages",
+          details: "API key verified using native SDK"
+        };
+      }
+      return {
+        success: false,
+        message: `\u274C ${selectedProvider} API key verification failed`,
+        endpoint: "/messages",
+        details: "Invalid API key. Please check your API key and try again."
+      };
+    } catch (error) {
+      debug.warn("PROVIDER_CONNECTION_TEST_NATIVE_SDK_ERROR", {
+        provider: selectedProvider,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        success: false,
+        message: `\u274C ${selectedProvider} connection failed`,
+        endpoint: "/messages",
+        details: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  return {
+    success: true,
+    message: `\u2705 Configuration saved for ${selectedProvider}`,
+    details: "Provider-specific testing not implemented yet"
+  };
+}
+
+// apps/cli/src/ui/ui/components/model-selector/actions/connectionTest/performConnectionTest.ts
+async function performConnectionTest({
+  selectedProvider,
+  selectedModel,
+  apiKey,
+  maxTokens,
+  providerBaseUrl,
+  customBaseUrl,
+  resourceName
+}) {
+  try {
+    let testBaseURL = providerBaseUrl || providers[selectedProvider]?.baseURL || "";
+    if (selectedProvider === "azure") {
+      testBaseURL = `https://${resourceName}.openai.azure.com/openai/deployments/${selectedModel}`;
+    } else if (selectedProvider === "custom-openai") {
+      testBaseURL = customBaseUrl;
+    }
+    const isOpenAICompatible = isOpenAICompatibleProvider(selectedProvider);
+    if (isOpenAICompatible) {
+      const isGPT5 = selectedModel?.toLowerCase().includes("gpt-5");
+      if (isGPT5) {
+        debug.api("GPT5_CONNECTION_TEST_USING_SPECIALIZED", {
+          model: selectedModel,
+          provider: selectedProvider
+        });
+        const configValidation = validateGPT5Config({
+          model: selectedModel,
+          apiKey,
+          baseURL: testBaseURL,
+          maxTokens: parseInt(maxTokens) || 8192,
+          provider: selectedProvider
+        });
+        if (!configValidation.valid) {
+          return {
+            success: false,
+            message: "\u274C GPT-5 configuration validation failed",
+            details: configValidation.errors.join("\n")
+          };
+        }
+        return await testGPT5Connection({
+          model: selectedModel,
+          apiKey,
+          baseURL: testBaseURL,
+          maxTokens: parseInt(maxTokens) || 8192,
+          provider: selectedProvider
+        });
+      }
+      const endpointsToTry = [];
+      if (selectedProvider === "minimax") {
+        endpointsToTry.push(
+          { path: "/text/chatcompletion_v2", name: "MiniMax v2 (recommended)" },
+          { path: "/chat/completions", name: "Standard OpenAI" }
+        );
+      } else {
+        endpointsToTry.push({
+          path: "/chat/completions",
+          name: "Standard OpenAI"
+        });
+      }
+      let lastError = null;
+      for (const endpoint of endpointsToTry) {
+        try {
+          const testResult = await testChatEndpoint({
+            baseURL: testBaseURL,
+            endpointPath: endpoint.path,
+            endpointName: endpoint.name,
+            selectedProvider,
+            selectedModel,
+            apiKey,
+            maxTokens
+          });
+          if (testResult.success) {
+            return testResult;
+          }
+          lastError = testResult;
+        } catch (error) {
+          lastError = {
+            success: false,
+            message: `Failed to test ${endpoint.name}`,
+            endpoint: endpoint.path,
+            details: error instanceof Error ? error.message : String(error)
+          };
+        }
+      }
+      return lastError || {
+        success: false,
+        message: "All endpoints failed",
+        details: "No endpoints could be reached"
+      };
+    }
+    return await testProviderSpecificEndpoint({
+      baseURL: testBaseURL,
+      selectedProvider,
+      apiKey
+    });
+  } catch (error) {
+    return {
+      success: false,
+      message: "Connection test failed",
+      details: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/actions/connectionTest/runConnectionTestFlow.ts
+async function runConnectionTestFlow({
+  params,
+  navigateTo,
+  setTimeoutFn,
+  performConnectionTestFn
+}) {
+  const result = await (performConnectionTestFn ?? performConnectionTest)(
+    params
+  );
+  if (result.success) {
+    const schedule = setTimeoutFn ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+    schedule(() => {
+      navigateTo("confirmation");
+    }, 2e3);
+  }
+  return result;
+}
+
+// apps/cli/src/ui/ui/components/model-selector/actions/providerSelection.ts
+function handleProviderSelection(provider, deps) {
+  const {
+    navigateTo,
+    setPartnerProviderFocusIndex,
+    setCodingPlanFocusIndex,
+    setSelectedProvider,
+    setProviderBaseUrl,
+    saveConfiguration,
+    onDone,
+    selectedModel
+  } = deps;
+  if (provider === "partnerProviders") {
+    setPartnerProviderFocusIndex(0);
+    navigateTo("partnerProviders");
+    return;
+  } else if (provider === "partnerCodingPlans") {
+    setCodingPlanFocusIndex(0);
+    navigateTo("partnerCodingPlans");
+    return;
+  } else if (provider === "custom-anthropic") {
+    setSelectedProvider("anthropic");
+    setProviderBaseUrl("");
+    navigateTo("baseUrl");
+    return;
+  }
+  const providerType = provider;
+  setSelectedProvider(providerType);
+  if (provider === "custom") {
+    saveConfiguration(providerType, selectedModel || "");
+    onDone();
+  } else if (provider === "custom-openai" || provider === "ollama") {
+    const defaultBaseUrl = providers[providerType]?.baseURL || "";
+    setProviderBaseUrl(defaultBaseUrl);
+    navigateTo("baseUrl");
+  } else {
+    const defaultBaseUrl = providers[providerType]?.baseURL || "";
+    setProviderBaseUrl(defaultBaseUrl);
+    navigateTo("apiKey");
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/actions/saveConfiguration.ts
+async function saveModelConfiguration({
+  provider,
+  model,
+  providerBaseUrl,
+  resourceName,
+  customBaseUrl,
+  apiKey,
+  maxTokens,
+  contextLength,
+  reasoningEffort,
+  getModelManagerFn
+}) {
+  let baseURL = providerBaseUrl || providers[provider]?.baseURL || "";
+  let actualProvider = provider;
+  if (provider === "anthropic") {
+    actualProvider = "anthropic";
+    baseURL = baseURL || "https://api.anthropic.com";
+  }
+  if (provider === "azure") {
+    baseURL = `https://${resourceName}.openai.azure.com/openai/deployments/${model}`;
+  } else if (provider === "custom-openai") {
+    baseURL = customBaseUrl;
+  }
+  const modelManager = (getModelManagerFn ?? getModelManager)();
+  const displayModel = model || "default";
+  const modelDisplayName = `${providers[actualProvider]?.name || actualProvider} ${displayModel}`.trim();
+  const modelConfig = {
+    name: modelDisplayName,
+    provider: actualProvider,
+    modelName: model || actualProvider,
+    // Use provider name if no specific model
+    baseURL,
+    apiKey: apiKey || "",
+    maxTokens: parseInt(maxTokens) || DEFAULT_MAX_TOKENS,
+    contextLength: contextLength || DEFAULT_CONTEXT_LENGTH,
+    reasoningEffort
+  };
+  return await modelManager.addModel(modelConfig);
+}
+function applyPointersForNewModel({
+  modelId,
+  isOnboarding,
+  targetPointer,
+  setModelPointerFn,
+  setAllPointersToModelFn
+}) {
+  const setModelPointerImpl = setModelPointerFn ?? setModelPointer;
+  const setAllPointersImpl = setAllPointersToModelFn ?? setAllPointersToModel;
+  setModelPointerImpl("main", modelId);
+  if (isOnboarding) {
+    setAllPointersImpl(modelId);
+  } else if (targetPointer && targetPointer !== "main") {
+    setModelPointerImpl(targetPointer, modelId);
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/actions/fetchModels.ts
+import OpenAI from "openai";
+async function fetchModelsForProvider({
+  selectedProvider,
+  apiKey,
+  providerBaseUrl,
+  customBaseUrl,
+  modelFetchers,
+  setIsLoadingModels,
+  setModelLoadError,
+  setAvailableModels,
+  navigateTo
+}) {
+  setIsLoadingModels(true);
+  setModelLoadError(null);
+  try {
+    if (selectedProvider === "anthropic") {
+      const anthropicModels = await modelFetchers.fetchAnthropicCompatibleProviderModels({
+        apiKey,
+        providerBaseUrl,
+        setModelLoadError
+      });
+      setAvailableModels(anthropicModels);
+      navigateTo("model");
+      return anthropicModels;
+    }
+    if (selectedProvider === "custom-openai") {
+      const customModels = await modelFetchers.fetchCustomOpenAIModels({
+        apiKey,
+        customBaseUrl,
+        setModelLoadError
+      });
+      setAvailableModels(customModels);
+      navigateTo("model");
+      return customModels;
+    }
+    if (selectedProvider === "gemini") {
+      const geminiModels = await modelFetchers.fetchGeminiModels({
+        apiKey,
+        setModelLoadError
+      });
+      setAvailableModels(geminiModels);
+      navigateTo("model");
+      return geminiModels;
+    }
+    if (selectedProvider === "kimi") {
+      const kimiModels = await modelFetchers.fetchKimiModels({
+        apiKey,
+        providerBaseUrl,
+        setModelLoadError
+      });
+      setAvailableModels(kimiModels);
+      navigateTo("model");
+      return kimiModels;
+    }
+    if (selectedProvider === "deepseek") {
+      const deepseekModels = await modelFetchers.fetchDeepSeekModels({
+        apiKey,
+        providerBaseUrl,
+        setModelLoadError
+      });
+      setAvailableModels(deepseekModels);
+      navigateTo("model");
+      return deepseekModels;
+    }
+    if (selectedProvider === "siliconflow") {
+      const siliconflowModels = await modelFetchers.fetchSiliconFlowModels({
+        apiKey,
+        providerBaseUrl,
+        setModelLoadError
+      });
+      setAvailableModels(siliconflowModels);
+      navigateTo("model");
+      return siliconflowModels;
+    }
+    if (selectedProvider === "qwen") {
+      const qwenModels = await modelFetchers.fetchQwenModels({
+        apiKey,
+        providerBaseUrl,
+        setModelLoadError
+      });
+      setAvailableModels(qwenModels);
+      navigateTo("model");
+      return qwenModels;
+    }
+    if (selectedProvider === "glm") {
+      const glmModels = await modelFetchers.fetchGLMModels({
+        apiKey,
+        providerBaseUrl,
+        setModelLoadError
+      });
+      setAvailableModels(glmModels);
+      navigateTo("model");
+      return glmModels;
+    }
+    if (selectedProvider === "baidu-qianfan") {
+      const baiduModels = await modelFetchers.fetchBaiduQianfanModels({
+        apiKey,
+        providerBaseUrl,
+        setModelLoadError
+      });
+      setAvailableModels(baiduModels);
+      navigateTo("model");
+      return baiduModels;
+    }
+    if (selectedProvider === "azure") {
+      navigateTo("modelInput");
+      return [];
+    }
+    let baseURL = providerBaseUrl || providers[selectedProvider]?.baseURL;
+    if (selectedProvider === "custom-openai") {
+      baseURL = customBaseUrl;
+    }
+    const openai = new OpenAI({
+      apiKey: apiKey || "dummy-key-for-ollama",
+      // Ollama doesn't need a real key
+      baseURL,
+      dangerouslyAllowBrowser: true
+    });
+    const response = await openai.models.list();
+    const fetchedModels = [];
+    for (const model of response.data) {
+      const record = model;
+      const modelName = typeof record.modelName === "string" && record.modelName || typeof record.id === "string" && record.id || typeof record.name === "string" && record.name || typeof record.model === "string" && record.model || "unknown";
+      const modelInfo = models_default[selectedProvider]?.find(
+        (m) => m.model === modelName
+      );
+      fetchedModels.push({
+        model: modelName,
+        provider: selectedProvider,
+        max_tokens: modelInfo?.max_output_tokens,
+        supports_vision: modelInfo?.supports_vision || false,
+        supports_function_calling: modelInfo?.supports_function_calling || false,
+        supports_reasoning_effort: modelInfo?.supports_reasoning_effort || false
+      });
+    }
+    setAvailableModels(fetchedModels);
+    navigateTo("model");
+    return fetchedModels;
+  } catch (error) {
+    console.error("Error fetching models:", error);
+    throw error;
+  } finally {
+    setIsLoadingModels(false);
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers.ts
+var modelFetchers_exports = {};
+__export(modelFetchers_exports, {
+  fetchAnthropicCompatibleProviderModels: () => fetchAnthropicCompatibleProviderModels,
+  fetchBaiduQianfanModels: () => fetchBaiduQianfanModels,
+  fetchCustomOpenAIModels: () => fetchCustomOpenAIModels,
+  fetchDeepSeekModels: () => fetchDeepSeekModels,
+  fetchGLMModels: () => fetchGLMModels,
+  fetchGeminiModels: () => fetchGeminiModels,
+  fetchKimiModels: () => fetchKimiModels,
+  fetchMinimaxModels: () => fetchMinimaxModels,
+  fetchQwenModels: () => fetchQwenModels,
+  fetchSiliconFlowModels: () => fetchSiliconFlowModels
+});
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers/anthropic.ts
+async function fetchAnthropicModels(baseURL, apiKey) {
+  try {
+    const response = await fetch(`${baseURL}/v1/models`, {
+      method: "GET",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 401) {
+        throw new Error(
+          "Invalid API key. Please check your API key and try again."
+        );
+      } else if (response.status === 403) {
+        throw new Error("API key does not have permission to access models.");
+      } else if (response.status === 404) {
+        throw new Error(
+          "API endpoint not found. This provider may not support model listing."
+        );
+      } else if (response.status === 429) {
+        throw new Error(
+          "Too many requests. Please wait a moment and try again."
+        );
+      } else if (response.status >= 500) {
+        throw new Error(
+          "API service is temporarily unavailable. Please try again later."
+        );
+      } else {
+        throw new Error(`Unable to connect to API (${response.status}).`);
+      }
+    }
+    const data = await response.json();
+    let models = [];
+    if (data && data.data && Array.isArray(data.data)) {
+      models = data.data;
+    } else if (Array.isArray(data)) {
+      models = data;
+    } else if (data && data.models && Array.isArray(data.models)) {
+      models = data.models;
+    } else {
+      throw new Error("API returned unexpected response format.");
+    }
+    return models;
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("API key") || error.message.includes("API endpoint") || error.message.includes("API service") || error.message.includes("response format"))) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.includes("fetch")) {
+      throw new Error(
+        "Unable to connect to the API. Please check the base URL and your internet connection."
+      );
+    }
+    throw new Error(
+      "Failed to fetch models from API. Please check your configuration and try again."
+    );
+  }
+}
+async function fetchAnthropicCompatibleModelsWithFallback({
+  baseURL,
+  provider,
+  apiKey,
+  apiKeyUrl,
+  setModelLoadError
+}) {
+  let lastError = null;
+  try {
+    const models = await fetchAnthropicModels(baseURL, apiKey);
+    return models.map((model) => ({
+      model: model.modelName || model.id || model.name || model.model || "unknown",
+      provider,
+      max_tokens: model.max_tokens || 8192,
+      supports_vision: model.supports_vision || true,
+      supports_function_calling: model.supports_function_calling || true,
+      supports_reasoning_effort: false
+    }));
+  } catch (error) {
+    lastError = error;
+    debug.warn("MODEL_FETCH_NATIVE_API_FAILED", {
+      provider,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  try {
+    const models = await fetchCustomModels(baseURL, apiKey);
+    return models.map((model) => ({
+      model: model.modelName || model.id || model.name || model.model || "unknown",
+      provider,
+      max_tokens: model.max_tokens || 8192,
+      supports_vision: model.supports_vision || false,
+      supports_function_calling: model.supports_function_calling || true,
+      supports_reasoning_effort: false
+    }));
+  } catch (error) {
+    lastError = error;
+    debug.warn("MODEL_FETCH_OPENAI_API_FAILED", {
+      provider,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  let errorMessage = `Failed to fetch ${provider} models using both native and OpenAI-compatible API formats`;
+  if (lastError instanceof Error) {
+    errorMessage = lastError.message;
+  }
+  if (errorMessage.includes("API key")) {
+    errorMessage += apiKeyUrl ? `
+
+\u{1F4A1} Tip: Get your API key from ${apiKeyUrl}` : "\n\n\u{1F4A1} Tip: Check that your API key is set and valid for this provider";
+  } else if (errorMessage.includes("permission")) {
+    errorMessage += `
+
+\u{1F4A1} Tip: Make sure your API key has access to the ${provider} API`;
+  } else if (errorMessage.includes("connection")) {
+    errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
+  }
+  setModelLoadError(errorMessage);
+  throw new Error(errorMessage);
+}
+async function fetchAnthropicCompatibleProviderModels({
+  apiKey,
+  providerBaseUrl,
+  setModelLoadError
+}) {
+  const defaultBaseURL = "https://api.anthropic.com";
+  const apiKeyUrl = "";
+  const actualProvider = "anthropic";
+  const baseURL = providerBaseUrl || defaultBaseURL;
+  return fetchAnthropicCompatibleModelsWithFallback({
+    baseURL,
+    provider: actualProvider,
+    apiKey,
+    apiKeyUrl,
+    setModelLoadError
+  });
+}
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers/baiduQianfan.ts
+async function fetchBaiduQianfanModels({
+  apiKey,
+  providerBaseUrl,
+  setModelLoadError
+}) {
+  try {
+    const baseURL = providerBaseUrl || "https://qianfan.baidubce.com/v2";
+    const models = await fetchCustomModels(baseURL, apiKey);
+    return models.map((model) => ({
+      model: model.modelName || model.id || model.name || model.model || "unknown",
+      provider: "baidu-qianfan",
+      max_tokens: model.max_tokens || 8192,
+      supports_vision: false,
+      supports_function_calling: true,
+      supports_reasoning_effort: false
+    }));
+  } catch (error) {
+    let errorMessage = "Failed to fetch Baidu Qianfan models";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+    }
+    if (errorMessage.includes("API key")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://console.bce.baidu.com/iam/#/iam/accesslist";
+    } else if (errorMessage.includes("permission")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the Baidu Qianfan API";
+    } else if (errorMessage.includes("connection")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
+    }
+    setModelLoadError(errorMessage);
+    throw error;
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers/customOpenAI.ts
+async function fetchCustomOpenAIModels({
+  apiKey,
+  customBaseUrl,
+  setModelLoadError
+}) {
+  try {
+    const models = await fetchCustomModels(customBaseUrl, apiKey);
+    return models.map((model) => ({
+      model: model.modelName || model.id || model.name || model.model || "unknown",
+      provider: "custom-openai",
+      max_tokens: model.max_tokens || 4096,
+      supports_vision: false,
+      // Default to false, could be enhanced
+      supports_function_calling: true,
+      supports_reasoning_effort: false
+    }));
+  } catch (error) {
+    let errorMessage = "Failed to fetch custom API models";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+    }
+    if (errorMessage.includes("API key")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Check that your API key is valid for this endpoint";
+    } else if (errorMessage.includes("endpoint not found")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Make sure the base URL ends with /v1 and supports OpenAI-compatible API";
+    } else if (errorMessage.includes("connect")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Verify the base URL is correct and accessible";
+    } else if (errorMessage.includes("response format")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: This API may not be fully OpenAI-compatible";
+    }
+    setModelLoadError(errorMessage);
+    throw error;
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers/deepseek.ts
+async function fetchDeepSeekModels({
+  apiKey,
+  providerBaseUrl,
+  setModelLoadError
+}) {
+  try {
+    const baseURL = providerBaseUrl || "https://api.deepseek.com";
+    const models = await fetchCustomModels(baseURL, apiKey);
+    return models.map((model) => ({
+      model: model.modelName || model.id || model.name || model.model || "unknown",
+      provider: "deepseek",
+      max_tokens: model.max_tokens || 8192,
+      supports_vision: false,
+      // Default to false, could be enhanced
+      supports_function_calling: true,
+      supports_reasoning_effort: false
+    }));
+  } catch (error) {
+    let errorMessage = "Failed to fetch DeepSeek models";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+    }
+    if (errorMessage.includes("API key")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://platform.deepseek.com/api_keys";
+    } else if (errorMessage.includes("permission")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the DeepSeek API";
+    } else if (errorMessage.includes("connection")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
+    }
+    setModelLoadError(errorMessage);
+    throw error;
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers/gemini.ts
+async function fetchGeminiModels({
+  apiKey,
+  setModelLoadError
+}) {
+  try {
+    const response = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
+    );
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(
+        errorData.error?.message || `API error: ${response.status}`
+      );
+    }
+    const { models } = await response.json();
+    return models.filter(
+      (model) => model.supportedGenerationMethods.includes("generateContent")
+    ).map((model) => ({
+      model: model.name.replace("models/", ""),
+      provider: "gemini",
+      max_tokens: model.outputTokenLimit,
+      supports_vision: model.supportedGenerationMethods.includes("generateContent"),
+      supports_function_calling: model.supportedGenerationMethods.includes("generateContent")
+    }));
+  } catch (error) {
+    setModelLoadError(error instanceof Error ? error.message : "Unknown error");
+    throw error;
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers/glm.ts
+async function fetchGLMModels({
+  apiKey,
+  providerBaseUrl,
+  setModelLoadError
+}) {
+  try {
+    const baseURL = providerBaseUrl || "https://open.bigmodel.cn/api/paas/v4";
+    const models = await fetchCustomModels(baseURL, apiKey);
+    return models.map((model) => ({
+      model: model.modelName || model.id || model.name || model.model || "unknown",
+      provider: "glm",
+      max_tokens: model.max_tokens || 8192,
+      supports_vision: false,
+      supports_function_calling: true,
+      supports_reasoning_effort: false
+    }));
+  } catch (error) {
+    let errorMessage = "Failed to fetch GLM models";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+    }
+    if (errorMessage.includes("API key")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://open.bigmodel.cn (API Keys section)";
+    } else if (errorMessage.includes("permission")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the GLM API";
+    } else if (errorMessage.includes("connection")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
+    }
+    setModelLoadError(errorMessage);
+    throw error;
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers/kimi.ts
+async function fetchKimiModels({
+  apiKey,
+  providerBaseUrl,
+  setModelLoadError
+}) {
+  try {
+    const baseURL = providerBaseUrl || "https://api.moonshot.cn/v1";
+    const models = await fetchCustomModels(baseURL, apiKey);
+    return models.map((model) => ({
+      model: model.modelName || model.id || model.name || model.model || "unknown",
+      provider: "kimi",
+      max_tokens: model.max_tokens || 8192,
+      supports_vision: false,
+      // Default to false, could be enhanced
+      supports_function_calling: true,
+      supports_reasoning_effort: false
+    }));
+  } catch (error) {
+    let errorMessage = "Failed to fetch Kimi models";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+    }
+    if (errorMessage.includes("API key")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://platform.moonshot.cn/console/api-keys";
+    } else if (errorMessage.includes("permission")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the Kimi API";
+    } else if (errorMessage.includes("connection")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
+    }
+    setModelLoadError(errorMessage);
+    throw error;
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers/minimax.ts
+async function fetchMinimaxModels({
+  apiKey,
+  providerBaseUrl,
+  setModelLoadError
+}) {
+  try {
+    const baseURL = providerBaseUrl || "https://api.minimaxi.com/v1";
+    const models = await fetchCustomModels(baseURL, apiKey);
+    return models.map((model) => ({
+      model: model.modelName || model.id || model.name || model.model || "unknown",
+      provider: "minimax",
+      max_tokens: model.max_tokens || 8192,
+      supports_vision: false,
+      supports_function_calling: true,
+      supports_reasoning_effort: false
+    }));
+  } catch (error) {
+    let errorMessage = "Failed to fetch MiniMax models";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+    }
+    if (errorMessage.includes("API key")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://www.minimax.io/platform/user-center/basic-information";
+    } else if (errorMessage.includes("permission")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the MiniMax API";
+    } else if (errorMessage.includes("connection")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
+    }
+    setModelLoadError(errorMessage);
+    throw error;
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers/qwen.ts
+async function fetchQwenModels({
+  apiKey,
+  providerBaseUrl,
+  setModelLoadError
+}) {
+  try {
+    const baseURL = providerBaseUrl || "https://dashscope.aliyuncs.com/compatible-mode/v1";
+    const models = await fetchCustomModels(baseURL, apiKey);
+    return models.map((model) => ({
+      model: model.modelName || model.id || model.name || model.model || "unknown",
+      provider: "qwen",
+      max_tokens: model.max_tokens || 8192,
+      supports_vision: false,
+      supports_function_calling: true,
+      supports_reasoning_effort: false
+    }));
+  } catch (error) {
+    let errorMessage = "Failed to fetch Qwen models";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+    }
+    if (errorMessage.includes("API key")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://bailian.console.aliyun.com/?tab=model#/api-key";
+    } else if (errorMessage.includes("permission")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the Qwen API";
+    } else if (errorMessage.includes("connection")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
+    }
+    setModelLoadError(errorMessage);
+    throw error;
+  }
+}
+
+// apps/cli/src/ui/ui/components/model-selector/modelFetchers/siliconflow.ts
+async function fetchSiliconFlowModels({
+  apiKey,
+  providerBaseUrl,
+  setModelLoadError
+}) {
+  try {
+    const baseURL = providerBaseUrl || "https://api.siliconflow.cn/v1";
+    const models = await fetchCustomModels(baseURL, apiKey);
+    return models.map((model) => ({
+      model: model.modelName || model.id || model.name || model.model || "unknown",
+      provider: "siliconflow",
+      max_tokens: model.max_tokens || 8192,
+      supports_vision: false,
+      // Default to false, could be enhanced
+      supports_function_calling: true,
+      supports_reasoning_effort: false
+    }));
+  } catch (error) {
+    let errorMessage = "Failed to fetch SiliconFlow models";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+    }
+    if (errorMessage.includes("API key")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://cloud.siliconflow.cn/i/oJWsm6io";
+    } else if (errorMessage.includes("permission")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the SiliconFlow API";
+    } else if (errorMessage.includes("connection")) {
+      errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
+    }
+    setModelLoadError(errorMessage);
+    throw error;
+  }
+}
+
+// apps/cli/src/ui/components/ModelSelector/fetchOllamaModels.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getNestedValue(value, path) {
+  let current = value;
+  for (const key of path) {
+    if (!isRecord(current)) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function toPositiveFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+async function fetchOllamaModels(args) {
+  try {
+    const response = await fetch(`${args.ollamaBaseUrl}/models`);
+    if (!response.ok) {
+      throw new Error(`HTTP error ${response.status}: ${response.statusText}`);
+    }
+    const responseData = await response.json();
+    let models = [];
+    if (isRecord(responseData) && Array.isArray(responseData.data)) {
+      models = responseData.data;
+    } else if (isRecord(responseData) && Array.isArray(responseData.models)) {
+      models = responseData.models;
+    } else if (Array.isArray(responseData)) {
+      models = responseData;
+    } else {
+      throw new Error("Invalid response from Ollama API: missing models array");
+    }
+    const getModelName = (model) => {
+      if (typeof model === "string") return model;
+      if (!isRecord(model)) return "";
+      const candidates = [
+        model.id,
+        model.name,
+        model.modelName,
+        model.model,
+        model.model_name
+      ];
+      for (const c of candidates) {
+        if (typeof c === "string") return c;
+      }
+      return "";
+    };
+    const ollamaModels = models.map((model) => ({
+      model: getModelName(model),
+      provider: "ollama",
+      max_tokens: DEFAULT_MAX_TOKENS,
+      supports_vision: false,
+      supports_function_calling: true,
+      supports_reasoning_effort: false
+    }));
+    const validModels = ollamaModels.filter((model) => model.model);
+    const normalizeOllamaRoot = (url) => {
+      try {
+        const u = new URL(url);
+        let pathname = u.pathname.replace(/\/+$/g, "").replace(/^$/, "");
+        if (pathname.endsWith("/v1")) {
+          pathname = pathname.slice(0, -3);
+        }
+        u.pathname = pathname;
+        return u.toString().replace(/\/+$/g, "");
+      } catch {
+        return url.replace(/\/v1\/?$/g, "");
+      }
+    };
+    const extractContextTokens = (data) => {
+      if (!isRecord(data)) return null;
+      const modelInfoValue = data.model_info;
+      if (isRecord(modelInfoValue)) {
+        for (const key of Object.keys(modelInfoValue)) {
+          if (key.endsWith(".context_length") || key.endsWith("_context_length")) {
+            const val = toPositiveFiniteNumber(modelInfoValue[key]);
+            if (val) return val;
+          }
+        }
+      }
+      const paths = [
+        ["parameters", "num_ctx"],
+        ["model_info", "num_ctx"],
+        ["config", "num_ctx"],
+        ["details", "context_length"],
+        ["context_length"],
+        ["num_ctx"],
+        ["max_tokens"],
+        ["max_new_tokens"]
+      ];
+      const candidates = paths.map((path) => toPositiveFiniteNumber(getNestedValue(data, path))).filter((v) => typeof v === "number");
+      if (candidates.length > 0) return Math.max(...candidates);
+      const parametersValue = getNestedValue(data, ["parameters"]);
+      if (typeof parametersValue === "string") {
+        const m = parametersValue.match(/num_ctx\s*[:=]\s*(\d+)/i);
+        if (!m) return null;
+        const n = parseInt(m[1], 10);
+        return Number.isFinite(n) && n > 0 ? n : null;
+      }
+      return null;
+    };
+    const ollamaRoot = normalizeOllamaRoot(args.ollamaBaseUrl);
+    const enrichedModels = await Promise.all(
+      validModels.map(async (m) => {
+        try {
+          const showResp = await fetch(`${ollamaRoot}/api/show`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: m.model })
+          });
+          if (showResp.ok) {
+            const showData = await showResp.json();
+            const ctx = extractContextTokens(showData);
+            if (typeof ctx === "number" && isFinite(ctx) && ctx > 0) {
+              return { ...m, context_length: ctx };
+            }
+          }
+          return m;
+        } catch {
+          return m;
+        }
+      })
+    );
+    args.setAvailableModels(enrichedModels);
+    if (enrichedModels.length > 0) {
+      args.navigateTo("model");
+    } else {
+      args.setModelLoadError("No models found in your Ollama installation");
+    }
+    return enrichedModels;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("fetch")) {
+      args.setModelLoadError(
+        `Could not connect to Ollama server at ${args.ollamaBaseUrl}. Make sure Ollama is running and the URL is correct.`
+      );
+    } else {
+      args.setModelLoadError(`Error loading Ollama models: ${errorMessage}`);
+    }
+    console.error("Error fetching Ollama models:", error);
+    return [];
+  }
+}
+
+// apps/cli/src/ui/components/ModelSelector/useModelSelectorModelFlow.tsx
+function useModelSelectorModelFlow(state) {
+  async function fetchModels() {
+    return await fetchModelsForProvider({
+      selectedProvider: state.selectedProvider,
+      apiKey: state.apiKey,
+      providerBaseUrl: state.providerBaseUrl,
+      customBaseUrl: state.customBaseUrl,
+      modelFetchers: modelFetchers_exports,
+      setIsLoadingModels: state.setIsLoadingModels,
+      setModelLoadError: state.setModelLoadError,
+      setAvailableModels: state.setAvailableModels,
+      navigateTo: state.navigateTo
+    });
+  }
+  async function fetchModelsWithRetry() {
+    const MAX_RETRIES = 2;
+    let lastError = null;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      state.setFetchRetryCount(attempt);
+      state.setIsRetrying(attempt > 1);
+      if (attempt > 1) {
+        state.setModelLoadError(
+          `Attempt ${attempt}/${MAX_RETRIES}: Retrying model discovery...`
+        );
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      }
+      try {
+        const models = await fetchModels();
+        state.setFetchRetryCount(0);
+        state.setIsRetrying(false);
+        state.setModelLoadError(null);
+        return models;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        debug.warn("MODEL_FETCH_RETRY_FAILED", {
+          attempt,
+          maxRetries: MAX_RETRIES,
+          error: lastError.message,
+          provider: state.selectedProvider
+        });
+        if (attempt === MAX_RETRIES) break;
+      }
+    }
+    state.setIsRetrying(false);
+    const errorMessage = lastError?.message || "Unknown error";
+    state.setModelLoadError(
+      `Failed to validate API key after ${MAX_RETRIES} attempts: ${errorMessage}
+
+Please check your API key and try again, or press Tab to manually enter model name.`
+    );
+    throw new Error(`API key validation failed: ${errorMessage}`);
+  }
+  async function handleApiKeySubmit(key) {
+    const cleanedKey = key.replace(/[\r\n]/g, "").trim();
+    state.setApiKey(cleanedKey);
+    state.setModelLoadError(null);
+    if (state.selectedProvider === "azure") {
+      state.navigateTo("resourceName");
+      return;
+    }
+    try {
+      state.setIsLoadingModels(true);
+      const models = await fetchModelsWithRetry();
+      if (models.length === 0) {
+        state.navigateTo("modelInput");
+      }
+    } catch (error) {
+      console.error("API key validation failed:", error);
+    } finally {
+      state.setIsLoadingModels(false);
+    }
+  }
+  function handleResourceNameSubmit(name) {
+    state.setResourceName(name);
+    state.navigateTo("modelInput");
+  }
+  function handleCustomBaseUrlSubmit(url) {
+    const cleanUrl = url.replace(/\/+$/, "");
+    state.setCustomBaseUrl(cleanUrl);
+    state.navigateTo("apiKey");
+  }
+  function handleProviderBaseUrlSubmit(url) {
+    const cleanUrl = url.replace(/\/+$/, "");
+    state.setProviderBaseUrl(cleanUrl);
+    if (state.selectedProvider === "ollama") {
+      state.setOllamaBaseUrl(cleanUrl);
+      state.setIsLoadingModels(true);
+      state.setModelLoadError(null);
+      fetchOllamaModels({
+        ollamaBaseUrl: cleanUrl,
+        setAvailableModels: state.setAvailableModels,
+        setModelLoadError: state.setModelLoadError,
+        navigateTo: () => state.navigateTo("model")
+      }).finally(() => {
+        state.setIsLoadingModels(false);
+      });
+    } else {
+      state.navigateTo("apiKey");
+    }
+  }
+  function handleCustomModelSubmit(model) {
+    state.setCustomModelName(model);
+    state.setSelectedModel(model);
+    state.setSupportsReasoningEffort(false);
+    state.setReasoningEffort(null);
+    state.setMaxTokensMode("preset");
+    state.setSelectedMaxTokensPreset(DEFAULT_MAX_TOKENS);
+    state.setMaxTokens(DEFAULT_MAX_TOKENS.toString());
+    state.setMaxTokensCursorOffset(DEFAULT_MAX_TOKENS.toString().length);
+    state.navigateTo("modelParams");
+    state.setActiveFieldIndex(0);
+  }
+  function handleModelSelection(model) {
+    state.setSelectedModel(model);
+    const modelInfo = state.availableModels.find((m) => m.model === model);
+    state.setSupportsReasoningEffort(
+      Boolean(modelInfo?.supports_reasoning_effort)
+    );
+    if (!modelInfo?.supports_reasoning_effort) {
+      state.setReasoningEffort(null);
+    }
+    state.setContextLength(modelInfo?.context_length ?? DEFAULT_CONTEXT_LENGTH);
+    const modelMaxTokens = modelInfo?.max_tokens;
+    if (typeof modelMaxTokens === "number" && Number.isFinite(modelMaxTokens)) {
+      const matchingPreset = MAX_TOKENS_OPTIONS.find(
+        (option) => option.value === modelMaxTokens
+      );
+      if (matchingPreset) {
+        state.setMaxTokensMode("preset");
+        state.setSelectedMaxTokensPreset(modelMaxTokens);
+        state.setMaxTokens(modelMaxTokens.toString());
+      } else {
+        state.setMaxTokensMode("custom");
+        state.setMaxTokens(modelMaxTokens.toString());
+      }
+      state.setMaxTokensCursorOffset(modelMaxTokens.toString().length);
+    } else {
+      state.setMaxTokensMode("preset");
+      state.setSelectedMaxTokensPreset(DEFAULT_MAX_TOKENS);
+      state.setMaxTokens(DEFAULT_MAX_TOKENS.toString());
+      state.setMaxTokensCursorOffset(DEFAULT_MAX_TOKENS.toString().length);
+    }
+    state.navigateTo("modelParams");
+    state.setActiveFieldIndex(0);
+  }
+  const handleModelParamsSubmit = () => {
+    if (!CONTEXT_LENGTH_OPTIONS.find((opt) => opt.value === state.contextLength)) {
+      state.setContextLength(DEFAULT_CONTEXT_LENGTH);
+    }
+    state.navigateTo("contextLength");
+  };
+  const getFormFieldsForModelParams = () => {
+    const fields = [
+      {
+        name: "maxTokens",
+        label: "Maximum Tokens",
+        description: "Select the maximum number of tokens to generate.",
+        component: "select",
+        options: MAX_TOKENS_OPTIONS.map((option) => ({
+          label: option.label,
+          value: option.value.toString()
+        })),
+        defaultValue: state.maxTokens
+      }
+    ];
+    if (state.supportsReasoningEffort) {
+      fields.push({
+        name: "reasoningEffort",
+        label: "Reasoning Effort",
+        description: "Controls reasoning depth for complex problems.",
+        component: "select"
+      });
+    }
+    fields.push({ name: "submit", label: "Continue \u2192", component: "button" });
+    return fields;
+  };
+  const reasoningEffortOptions = REASONING_EFFORT_OPTIONS;
+  const handleContextLengthSubmit = () => state.navigateTo("connectionTest");
+  return {
+    fetchModelsWithRetry,
+    handleApiKeySubmit,
+    handleResourceNameSubmit,
+    handleCustomBaseUrlSubmit,
+    handleProviderBaseUrlSubmit,
+    handleCustomModelSubmit,
+    handleModelSelection,
+    handleModelParamsSubmit,
+    getFormFieldsForModelParams,
+    reasoningEffortOptions,
+    handleContextLengthSubmit
+  };
+}
+
+// apps/cli/src/ui/components/ModelSelector/useModelSelectorTextHandlers.ts
+function useModelSelectorTextHandlers(state) {
+  function handleCursorOffsetChange(offset) {
+    state.setCursorOffset(offset);
+  }
+  function formatApiKeyDisplay(key) {
+    if (!key) return "";
+    if (key.length <= 10) return "*".repeat(key.length);
+    const prefix = key.slice(0, 4);
+    const suffix = key.slice(-4);
+    const middleLength = Math.max(0, key.length - 8);
+    const middle = "*".repeat(Math.min(middleLength, 30));
+    return `${prefix}${middle}${suffix}`;
+  }
+  function handleApiKeyChange(value) {
+    state.setApiKeyEdited(true);
+    const cleanedValue = value.replace(/[\\r\\n]/g, "").trim();
+    if (value !== cleanedValue && value.length > 0) {
+      state.setApiKeyCleanedNotification(true);
+      setTimeout(() => state.setApiKeyCleanedNotification(false), 3e3);
+    }
+    state.setApiKey(cleanedValue);
+    state.setCursorOffset(cleanedValue.length);
+  }
+  function handleModelSearchChange(value) {
+    state.setModelSearchQuery(value);
+    state.setModelSearchCursorOffset(value.length);
+  }
+  function handleModelSearchCursorOffsetChange(offset) {
+    state.setModelSearchCursorOffset(offset);
+  }
+  return {
+    handleCursorOffsetChange,
+    formatApiKeyDisplay,
+    handleApiKeyChange,
+    handleModelSearchChange,
+    handleModelSearchCursorOffsetChange
+  };
+}
+
+// apps/cli/src/ui/components/ModelSelector/useModelSelectorActions.tsx
+function useModelSelectorActions({ props, state, onDone }) {
+  const modelFlow = useModelSelectorModelFlow(state);
+  const textHandlers = useModelSelectorTextHandlers(state);
+  async function saveConfiguration(provider, model) {
+    try {
+      return await saveModelConfiguration({
+        provider,
+        model,
+        providerBaseUrl: state.providerBaseUrl,
+        resourceName: state.resourceName,
+        customBaseUrl: state.customBaseUrl,
+        apiKey: state.apiKey,
+        maxTokens: state.maxTokens,
+        contextLength: state.contextLength,
+        reasoningEffort: state.reasoningEffort ?? void 0
+      });
+    } catch (error) {
+      state.setValidationError(
+        error instanceof Error ? error.message : "Failed to add model"
+      );
+      return null;
+    }
+  }
+  async function handleConfirmation() {
+    state.setValidationError(null);
+    const modelId = await saveConfiguration(
+      state.selectedProvider,
+      state.selectedModel
+    );
+    if (!modelId) return;
+    applyPointersForNewModel({
+      modelId,
+      isOnboarding: Boolean(props.isOnboarding),
+      targetPointer: props.targetPointer
+    });
+    onDone();
+  }
+  const handleBack = () => {
+    const { stack: nextStack, effect } = handleBackNavigation(state.screenStack);
+    if (effect?.type === "resetProviderFocus") {
+      state.setProviderFocusIndex(0);
+    }
+    if (effect?.type === "exit") {
+      if (props.onCancel) props.onCancel();
+      else onDone();
+      return;
+    }
+    if (nextStack !== state.screenStack) {
+      state.setScreenStack(nextStack);
+    }
+  };
+  function handleProviderSelection2(provider) {
+    handleProviderSelection(provider, {
+      navigateTo: state.navigateTo,
+      setPartnerProviderFocusIndex: state.setPartnerProviderFocusIndex,
+      setCodingPlanFocusIndex: state.setCodingPlanFocusIndex,
+      setSelectedProvider: state.setSelectedProvider,
+      setProviderBaseUrl: state.setProviderBaseUrl,
+      saveConfiguration,
+      onDone,
+      selectedModel: state.selectedModel
+    });
+  }
+  async function handleConnectionTest() {
+    state.setIsTestingConnection(true);
+    state.setConnectionTestResult(null);
+    try {
+      const result = await runConnectionTestFlow({
+        params: {
+          selectedProvider: state.selectedProvider,
+          selectedModel: state.selectedModel,
+          apiKey: state.apiKey,
+          maxTokens: state.maxTokens,
+          providerBaseUrl: state.providerBaseUrl,
+          customBaseUrl: state.customBaseUrl,
+          resourceName: state.resourceName
+        },
+        navigateTo: () => state.navigateTo("confirmation")
+      });
+      state.setConnectionTestResult(result);
+    } finally {
+      state.setIsTestingConnection(false);
+    }
+  }
+  return {
+    handleBack,
+    handleProviderSelection: handleProviderSelection2,
+    ...modelFlow,
+    handleConnectionTest,
+    handleConfirmation,
+    ...textHandlers
+  };
+}
+
+// apps/cli/src/ui/ui/components/model-selector/useEscapeNavigation.ts
+import { useRef as useRef2 } from "react";
+import { useInput as useInput4 } from "ink";
+function useEscapeNavigation(onEscape, _abortController) {
+  const handledRef = useRef2(false);
+  useInput4(
+    (_input, key) => {
+      if (key.escape && !handledRef.current) {
+        handledRef.current = true;
+        setTimeout(() => {
+          handledRef.current = false;
+        }, 100);
+        onEscape();
+      }
+    },
+    { isActive: true }
+  );
+}
+
+// apps/cli/src/ui/components/ModelSelector/useModelSelectorController.tsx
+function useModelSelectorController(props) {
+  const theme = getTheme();
+  const { stdout } = useStdout();
+  const terminalRows = stdout?.rows ?? 24;
+  const compactLayout = terminalRows <= 22;
+  const tightLayout = terminalRows <= 18;
+  const containerPaddingY = tightLayout ? 0 : compactLayout ? 0 : 1;
+  const containerGap = tightLayout ? 0 : 1;
+  const exitState = useExitOnCtrlCD(() => process.exit(0));
+  const exitStateForScreens = useMemo4(
+    () => ({ pending: exitState.pending, keyName: exitState.keyName ?? "" }),
+    [exitState.pending, exitState.keyName]
+  );
+  const onDone = () => {
+    printModelConfig();
+    props.onDone();
+  };
+  const state = useModelSelectorState({
+    skipModelType: props.skipModelType ?? false
+  });
+  const menus = useModelSelectorMenus({
+    containerPaddingY,
+    containerGap,
+    setProviderFocusIndex: state.setProviderFocusIndex,
+    setPartnerProviderFocusIndex: state.setPartnerProviderFocusIndex,
+    setCodingPlanFocusIndex: state.setCodingPlanFocusIndex
+  });
+  const { modelOptions } = useModelSelectorModelOptions({
+    selectedProvider: state.selectedProvider,
+    availableModels: state.availableModels,
+    modelSearchQuery: state.modelSearchQuery
+  });
+  useEffect2(() => {
+    if (!state.apiKeyEdited && state.selectedProvider) {
+      const envKey = `${state.selectedProvider.toUpperCase()}_API_KEY`;
+      if (process.env[envKey]) {
+        state.setApiKey(process.env[envKey]);
+      } else {
+        state.setApiKey("");
+      }
+    }
+  }, [state.apiKeyEdited, state.selectedProvider, state.setApiKey]);
+  useEffect2(() => {
+    if (state.currentScreen === "contextLength" && !CONTEXT_LENGTH_OPTIONS.find((opt) => opt.value === state.contextLength)) {
+      state.setContextLength(DEFAULT_CONTEXT_LENGTH);
+    }
+  }, [state.contextLength, state.currentScreen, state.setContextLength]);
+  const actions = useModelSelectorActions({ props, state, onDone });
+  useEscapeNavigation(actions.handleBack, props.abortController);
+  useModelSelectorInput({
+    currentScreen: state.currentScreen,
+    mainMenuOptions: menus.mainMenuOptions,
+    providerFocusIndex: state.providerFocusIndex,
+    setProviderFocusIndex: state.setProviderFocusIndex,
+    partnerProviderOptions: menus.partnerProviderOptions,
+    partnerProviderFocusIndex: state.partnerProviderFocusIndex,
+    setPartnerProviderFocusIndex: state.setPartnerProviderFocusIndex,
+    codingPlanOptions: menus.codingPlanOptions,
+    codingPlanFocusIndex: state.codingPlanFocusIndex,
+    setCodingPlanFocusIndex: state.setCodingPlanFocusIndex,
+    selectedProvider: state.selectedProvider,
+    apiKey: state.apiKey,
+    resourceName: state.resourceName,
+    providerBaseUrl: state.providerBaseUrl,
+    customBaseUrl: state.customBaseUrl,
+    customModelName: state.customModelName,
+    contextLength: state.contextLength,
+    setContextLength: state.setContextLength,
+    isTestingConnection: state.isTestingConnection,
+    connectionTestResult: state.connectionTestResult,
+    activeFieldIndex: state.activeFieldIndex,
+    setActiveFieldIndex: state.setActiveFieldIndex,
+    handleProviderSelection: actions.handleProviderSelection,
+    handleApiKeySubmit: actions.handleApiKeySubmit,
+    fetchModelsWithRetry: actions.fetchModelsWithRetry,
+    navigateTo: state.navigateTo,
+    handleResourceNameSubmit: actions.handleResourceNameSubmit,
+    handleCustomBaseUrlSubmit: actions.handleCustomBaseUrlSubmit,
+    handleProviderBaseUrlSubmit: actions.handleProviderBaseUrlSubmit,
+    handleCustomModelSubmit: actions.handleCustomModelSubmit,
+    handleConfirmation: actions.handleConfirmation,
+    setValidationError: state.setValidationError,
+    handleConnectionTest: actions.handleConnectionTest,
+    handleContextLengthSubmit: actions.handleContextLengthSubmit,
+    setModelLoadError: state.setModelLoadError,
+    getFormFieldsForModelParams: actions.getFormFieldsForModelParams,
+    handleModelParamsSubmit: actions.handleModelParamsSubmit
+  });
+  return {
+    theme,
+    exitState: exitStateForScreens,
+    terminalRows,
+    compactLayout,
+    tightLayout,
+    containerPaddingY,
+    containerGap,
+    currentScreen: state.currentScreen,
+    selectedProvider: state.selectedProvider,
+    selectedModel: state.selectedModel,
+    apiKey: state.apiKey,
+    cursorOffset: state.cursorOffset,
+    handleApiKeyChange: actions.handleApiKeyChange,
+    handleApiKeySubmit: actions.handleApiKeySubmit,
+    handleCursorOffsetChange: actions.handleCursorOffsetChange,
+    apiKeyCleanedNotification: state.apiKeyCleanedNotification,
+    isLoadingModels: state.isLoadingModels,
+    modelLoadError: state.modelLoadError,
+    providerBaseUrl: state.providerBaseUrl,
+    setProviderBaseUrl: state.setProviderBaseUrl,
+    providerBaseUrlCursorOffset: state.providerBaseUrlCursorOffset,
+    setProviderBaseUrlCursorOffset: state.setProviderBaseUrlCursorOffset,
+    customBaseUrl: state.customBaseUrl,
+    setCustomBaseUrl: state.setCustomBaseUrl,
+    customBaseUrlCursorOffset: state.customBaseUrlCursorOffset,
+    setCustomBaseUrlCursorOffset: state.setCustomBaseUrlCursorOffset,
+    customModelName: state.customModelName,
+    setCustomModelName: state.setCustomModelName,
+    customModelNameCursorOffset: state.customModelNameCursorOffset,
+    setCustomModelNameCursorOffset: state.setCustomModelNameCursorOffset,
+    resourceName: state.resourceName,
+    setResourceName: state.setResourceName,
+    resourceNameCursorOffset: state.resourceNameCursorOffset,
+    setResourceNameCursorOffset: state.setResourceNameCursorOffset,
+    availableModels: state.availableModels,
+    modelSearchQuery: state.modelSearchQuery,
+    modelSearchCursorOffset: state.modelSearchCursorOffset,
+    handleModelSearchChange: actions.handleModelSearchChange,
+    handleModelSearchCursorOffsetChange: actions.handleModelSearchCursorOffsetChange,
+    modelOptions,
+    handleResourceNameSubmit: actions.handleResourceNameSubmit,
+    handleCustomBaseUrlSubmit: actions.handleCustomBaseUrlSubmit,
+    handleProviderBaseUrlSubmit: actions.handleProviderBaseUrlSubmit,
+    handleCustomModelSubmit: actions.handleCustomModelSubmit,
+    handleModelSelection: actions.handleModelSelection,
+    handleModelParamsSubmit: actions.handleModelParamsSubmit,
+    maxTokens: state.maxTokens,
+    setMaxTokens: state.setMaxTokens,
+    setSelectedMaxTokensPreset: state.setSelectedMaxTokensPreset,
+    setMaxTokensCursorOffset: state.setMaxTokensCursorOffset,
+    supportsReasoningEffort: state.supportsReasoningEffort,
+    reasoningEffortOptions: actions.reasoningEffortOptions,
+    reasoningEffort: state.reasoningEffort,
+    setReasoningEffort: state.setReasoningEffort,
+    contextLength: state.contextLength,
+    isTestingConnection: state.isTestingConnection,
+    connectionTestResult: state.connectionTestResult,
+    validationError: state.validationError,
+    ollamaBaseUrl: state.ollamaBaseUrl,
+    activeFieldIndex: state.activeFieldIndex,
+    setActiveFieldIndex: state.setActiveFieldIndex,
+    getFormFieldsForModelParams: actions.getFormFieldsForModelParams,
+    mainMenuOptions: menus.mainMenuOptions,
+    providerFocusIndex: state.providerFocusIndex,
+    providerReservedLines: menus.providerReservedLines,
+    partnerProviderOptions: menus.partnerProviderOptions,
+    partnerProviderFocusIndex: state.partnerProviderFocusIndex,
+    partnerReservedLines: menus.partnerReservedLines,
+    codingPlanOptions: menus.codingPlanOptions,
+    codingPlanFocusIndex: state.codingPlanFocusIndex,
+    codingReservedLines: menus.codingReservedLines,
+    formatApiKeyDisplay: actions.formatApiKeyDisplay,
+    getProviderLabel: menus.getProviderLabel
+  };
+}
+
+// apps/cli/src/ui/components/ModelSelector/ModelSelector.tsx
+function ModelSelector(props) {
+  const viewProps = useModelSelectorController(props);
+  return /* @__PURE__ */ React19.createElement(ModelSelectorView, { ...viewProps });
+}
+
+// apps/cli/src/ui/components/Onboarding.tsx
+function Onboarding({ onDone }) {
+  const [currentStepIndex, setCurrentStepIndex] = useState4(0);
+  const [showModelSelector, setShowModelSelector] = useState4(false);
+  const config = getGlobalConfig();
+  const [selectedTheme, setSelectedTheme] = useState4(
+    DEFAULT_GLOBAL_CONFIG.theme
+  );
+  const theme = getTheme();
+  function goToNextStep() {
+    if (currentStepIndex < steps.length - 1) {
+      const nextIndex = currentStepIndex + 1;
+      setCurrentStepIndex(nextIndex);
+    }
+  }
+  function handleThemeSelection(newTheme) {
+    saveGlobalConfig({
+      ...config,
+      theme: newTheme
+    });
+    goToNextStep();
+  }
+  function handleThemePreview(newTheme) {
+    setSelectedTheme(newTheme);
+  }
+  function handleProviderSelectionDone() {
+    goToNextStep();
+  }
+  function handleModelSelectionDone() {
+    onDone();
+  }
+  const exitState = useExitOnCtrlCD(() => process.exit(0));
+  useInput5(
+    async (_, key) => {
+      const currentStep = steps[currentStepIndex];
+      if (key.return && currentStep && ["usage", "providers", "model"].includes(currentStep.id)) {
+        if (currentStep.id === "model") {
+          setShowModelSelector(true);
+        } else if (currentStepIndex === steps.length - 1) {
+          onDone();
+        } else {
+          await clearTerminal();
+          goToNextStep();
+        }
+      }
+    },
+    { isActive: !showModelSelector }
+  );
+  const themeStep = /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column", gap: 1, paddingLeft: 1 }, /* @__PURE__ */ React20.createElement(Text18, null, "Let's get started."), /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column" }, /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "Choose the option that looks best when you select it:"), /* @__PURE__ */ React20.createElement(Text18, { dimColor: true }, "To change this later, run /config")), /* @__PURE__ */ React20.createElement(
+    Select,
+    {
+      options: [
+        { label: "Light text", value: "dark" },
+        { label: "Dark text", value: "light" },
+        {
+          label: "Light text (colorblind-friendly)",
+          value: "dark-daltonized"
+        },
+        {
+          label: "Dark text (colorblind-friendly)",
+          value: "light-daltonized"
+        }
+      ],
+      onFocus: handleThemePreview,
+      onChange: handleThemeSelection
+    }
+  ), /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column" }, /* @__PURE__ */ React20.createElement(
+    Box17,
+    {
+      paddingLeft: 1,
+      marginRight: 1,
+      borderStyle: "round",
+      borderColor: "gray",
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React20.createElement(
+      StructuredDiff,
+      {
+        patch: {
+          oldStart: 1,
+          newStart: 1,
+          oldLines: 3,
+          newLines: 3,
+          lines: [
+            "function greet() {",
+            '-  console.log("Hello, World!");',
+            '+  console.log("Hello, anon!");',
+            "}"
+          ]
+        },
+        dim: false,
+        width: 40,
+        overrideTheme: selectedTheme
+      }
+    )
+  )));
+  const providersStep = /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column", gap: 1, paddingLeft: 1 }, /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React20.createElement(Text18, { color: theme.secondaryText }, "Next, let's select your preferred AI provider and model.")), /* @__PURE__ */ React20.createElement(
+    ModelSelector,
+    {
+      onDone: handleProviderSelectionDone,
+      skipModelType: true,
+      isOnboarding: true
+    }
+  ));
+  const usageStep = /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column", gap: 1, paddingLeft: 1 }, /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "Using ", PRODUCT_NAME, " effectively:"), /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React20.createElement(OrderedList, null, /* @__PURE__ */ React20.createElement(OrderedList.Item, null, /* @__PURE__ */ React20.createElement(Text18, null, "Start in your project directory", /* @__PURE__ */ React20.createElement(Newline8, null), /* @__PURE__ */ React20.createElement(Text18, { color: theme.secondaryText }, "Files are automatically added to context when needed."), /* @__PURE__ */ React20.createElement(Newline8, null))), /* @__PURE__ */ React20.createElement(OrderedList.Item, null, /* @__PURE__ */ React20.createElement(Text18, null, "Use ", PRODUCT_NAME, " as a development partner", /* @__PURE__ */ React20.createElement(Newline8, null), /* @__PURE__ */ React20.createElement(Text18, { color: theme.secondaryText }, "Get help with file analysis, editing, bash commands,", /* @__PURE__ */ React20.createElement(Newline8, null), "and git history.", /* @__PURE__ */ React20.createElement(Newline8, null)))), /* @__PURE__ */ React20.createElement(OrderedList.Item, null, /* @__PURE__ */ React20.createElement(Text18, null, "Provide clear context", /* @__PURE__ */ React20.createElement(Newline8, null), /* @__PURE__ */ React20.createElement(Text18, { color: theme.secondaryText }, "Be as specific as you would with another engineer. ", /* @__PURE__ */ React20.createElement(Newline8, null), "The better the context, the better the results. ", /* @__PURE__ */ React20.createElement(Newline8, null)))))), /* @__PURE__ */ React20.createElement(PressEnterToContinue, null));
+  const modelStep = /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column", gap: 1, paddingLeft: 1 }, /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "Configure your models:"), /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column", width: 70 }, /* @__PURE__ */ React20.createElement(Text18, null, "You can customize which models ", PRODUCT_NAME, " uses for different tasks.", /* @__PURE__ */ React20.createElement(Newline8, null), /* @__PURE__ */ React20.createElement(Text18, { color: theme.secondaryText }, "Let's set up your preferred models for large and small tasks.")), /* @__PURE__ */ React20.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React20.createElement(Text18, null, "Press ", /* @__PURE__ */ React20.createElement(Text18, { color: theme.suggestion }, "Enter"), " to continue to the model selection screen."))), /* @__PURE__ */ React20.createElement(PressEnterToContinue, null));
+  const steps = [];
+  steps.push({ id: "theme", component: themeStep });
+  steps.push({ id: "usage", component: usageStep });
+  steps.push({ id: "model", component: modelStep });
+  if (showModelSelector) {
+    return /* @__PURE__ */ React20.createElement(
+      ModelSelector,
+      {
+        onDone: handleModelSelectionDone,
+        skipModelType: true,
+        isOnboarding: true
+      }
+    );
+  }
+  return /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React20.createElement(React20.Fragment, null, /* @__PURE__ */ React20.createElement(Box17, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React20.createElement(Text18, { bold: true }, PRODUCT_NAME, " ", exitState.pending ? `(press ${exitState.keyName} again to exit)` : ""), steps[currentStepIndex]?.component)));
+}
+function WelcomeBox() {
+  const theme = getTheme();
+  return /* @__PURE__ */ React20.createElement(
+    Box17,
+    {
+      borderColor: theme.kode,
+      borderStyle: "round",
+      paddingX: 1,
+      width: MIN_LOGO_WIDTH
+    },
+    /* @__PURE__ */ React20.createElement(Text18, null, /* @__PURE__ */ React20.createElement(Text18, { color: theme.kode }, "\u273B"), " Welcome to", " ", /* @__PURE__ */ React20.createElement(Text18, { bold: true }, PRODUCT_NAME), " research preview!")
+  );
+}
+
+export {
+  useDoublePress,
+  useExitOnCtrlCD,
+  StructuredDiff,
+  TextInput,
+  setTerminalTitle,
+  clearTerminal,
+  Logo,
+  ModelSelector,
+  Onboarding,
+  WelcomeBox
+};