@npv12/opencode-mini-session 0.0.1

package/dist/components/HintBar.js

@@ -0,0 +1,34 @@
+import { effect as _$effect } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+/** @jsxImportSource @opentui/solid */
+
+import { For } from "solid-js";
+export function HintBar(props) {
+  return (() => {
+    var _el$ = _$createElement("box");
+    _$setProp(_el$, "flexDirection", "row");
+    _$setProp(_el$, "gap", 2);
+    _$insert(_el$, _$createComponent(For, {
+      get each() {
+        return props.items.filter(item => item.keybind);
+      },
+      children: item => (() => {
+        var _el$2 = _$createElement("text"),
+          _el$3 = _$createElement("b"),
+          _el$4 = _$createTextNode(` `);
+        _$insertNode(_el$2, _el$3);
+        _$insertNode(_el$2, _el$4);
+        _$insert(_el$3, () => item.keybind);
+        _$insert(_el$2, () => item.label, null);
+        _$effect(_$p => _$setProp(_el$2, "fg", props.context.theme.text.subdued, _$p));
+        return _el$2;
+      })()
+    }));
+    return _el$;
+  })();
+}

package/dist/config.js

@@ -0,0 +1,27 @@
+import { DEFAULT_FRESH_KEYBIND, DEFAULT_FULL_TOKEN_LIMIT, DEFAULT_KEYBIND, DEFAULT_TOGGLE_THINKING_KEYBIND } from "./constants.js";
+export function parseConfig(options) {
+  const input = options && typeof options === "object" ? options : {};
+  return {
+    model: parseStringOption(input.model),
+    variant: parseStringOption(input.variant),
+    agent: parseStringOption(input.agent),
+    tokenLimit: parsePositiveNumber(input.tokenLimit, DEFAULT_FULL_TOKEN_LIMIT),
+    keybind: parseKeybind(input.keybind, DEFAULT_KEYBIND),
+    freshKeybind: parseKeybind(input.freshKeybind, DEFAULT_FRESH_KEYBIND),
+    enableThinking: typeof input.enableThinking === "boolean" ? input.enableThinking : false,
+    toggleThinkingKeybind: parseKeybind(input.toggleThinkingKeybind, DEFAULT_TOGGLE_THINKING_KEYBIND)
+  };
+}
+function parsePositiveNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function parseKeybind(value, fallback) {
+  if (value === false) return false;
+  if (typeof value !== "string") return fallback;
+  const keybind = value.trim();
+  if (!keybind) return fallback;
+  return keybind === "none" ? false : keybind;
+}
+function parseStringOption(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}

package/dist/constants.js

@@ -0,0 +1,24 @@
+export const PLUGIN_ID = "opencode-mini-session";
+export const CMD_OPEN = "mini.open";
+export const CMD_OPEN_FRESH = "mini.open-fresh";
+export const CMD_TOGGLE_MAIN = "mini.toggle-main";
+export const CMD_TOGGLE_FRESH = "mini.toggle-fresh";
+export const CMD_HIDE = "mini.hide";
+export const CMD_CLOSE = "mini.close";
+export const CMD_CONTINUE = "mini.continue";
+export const CMD_CHANGE_MODEL = "mini.change-model";
+export const CMD_TOGGLE_THINKING = "mini.toggle-thinking";
+export const CMD_SCROLL_UP = "mini.scroll-up";
+export const CMD_SCROLL_DOWN = "mini.scroll-down";
+export const CMD_PAGE_UP = "mini.page-up";
+export const CMD_PAGE_DOWN = "mini.page-down";
+export const CMD_SUBMIT = "mini.submit";
+export const CMD_SCROLL_TOP = "mini.scroll-top";
+export const CMD_SCROLL_BOTTOM = "mini.scroll-bottom";
+export const SCROLL_LINE_DELTA = 4;
+export const SCROLL_PAGE_DELTA = 14;
+export const DEFAULT_FULL_TOKEN_LIMIT = 50_000;
+export const DEFAULT_KEYBIND = "ctrl+n";
+export const DEFAULT_FRESH_KEYBIND = "ctrl+f";
+export const DEFAULT_TOGGLE_THINKING_KEYBIND = "ctrl+o";
+export const THINKING_TEXT = "Thinking...";

package/dist/context.js

@@ -0,0 +1,72 @@
+export function getSessionEntries(context, sessionID) {
+  return context.data.session.message.list(sessionID).slice().sort((a, b) => {
+    const aTime = isFinite(a.time?.created ?? NaN) ? a.time.created : 0;
+    const bTime = isFinite(b.time?.created ?? NaN) ? b.time.created : 0;
+    return aTime - bTime;
+  });
+}
+export function buildCopiedContext(entries, tokenLimit) {
+  const chunks = entries.map(entry => {
+    const text = formatEntry(entry);
+    return text ? {
+      text,
+      tokens: estimateTokens(text)
+    } : undefined;
+  }).filter(chunk => Boolean(chunk));
+  const totalAvailableTokens = chunks.reduce((total, chunk) => total + chunk.tokens, 0);
+  const selected = [];
+  let usedTokens = 0;
+  for (let i = chunks.length - 1; i >= 0; i--) {
+    const chunk = chunks[i];
+    if (selected.length > 0 && usedTokens + chunk.tokens > tokenLimit) break;
+    selected.push(chunk.text);
+    usedTokens += chunk.tokens;
+    if (usedTokens >= tokenLimit) break;
+  }
+  if (selected.length === 0) {
+    return {
+      text: "No conversation context available.",
+      usedTokens: 0,
+      totalAvailableTokens
+    };
+  }
+  return {
+    text: selected.reverse().join("\n\n"),
+    usedTokens,
+    totalAvailableTokens
+  };
+}
+function formatEntry(entry) {
+  if (entry.type === "user") {
+    return entry.text.trim() ? `user:\n${entry.text.trim()}` : "";
+  }
+  if (entry.type === "assistant") {
+    const lines = [];
+    for (const part of entry.content) {
+      if (part.type === "text" && part.text.trim()) lines.push(part.text.trim());
+      if (part.type === "tool") lines.push(`[tool: ${part.name}${formatToolInput(part.state)}]`);
+    }
+    return lines.length > 0 ? `assistant:\n${lines.join("\n")}` : "";
+  }
+  return "";
+}
+function formatToolInput(state) {
+  const input = state.input;
+  if (!input) return "";
+  if (typeof input === "string") return input ? ` ${input}` : "";
+  const pairs = Object.entries(input).slice(0, 4).map(([k, v]) => `${k}=${summarizeValue(v)}`);
+  return pairs.length > 0 ? ` ${pairs.join(" ")}` : "";
+}
+function summarizeValue(value) {
+  if (typeof value === "string") return truncate(value.replace(/\s+/g, " "), 48);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return `[${value.length}]`;
+  if (value && typeof value === "object") return "{...}";
+  return String(value);
+}
+function truncate(value, maxLength) {
+  return value.length > maxLength ? `${value.slice(0, maxLength - 3)}...` : value;
+}
+export function estimateTokens(text) {
+  return Math.ceil(text.length / 3.4);
+}

package/dist/counter.js

@@ -0,0 +1,55 @@
+export const MINI_SESSION_WARNING_PERCENT = 85;
+export const MINI_SESSION_LIMIT_PERCENT = 95;
+export function formatTokenCount(value) {
+  if (value < 1000) return `${Math.round(value)}`;
+  if (value < 1_000_000) return `${(value / 1000).toFixed(1)}K`;
+  return `${(value / 1_000_000).toFixed(1)}M`;
+}
+export function formatPercent(value) {
+  return `${Math.round(value)}%`;
+}
+export function getUsagePercent(usedTokens, limit) {
+  if (limit <= 0) return undefined;
+  return usedTokens / limit * 100;
+}
+export function getDisplayPercent(usedTokens, limit) {
+  const percent = getUsagePercent(usedTokens, limit);
+  return percent === undefined ? undefined : Math.round(percent);
+}
+export function isMiniSessionWarning(percentUsed) {
+  return Boolean(percentUsed !== undefined && percentUsed >= MINI_SESSION_WARNING_PERCENT);
+}
+export function isMiniSessionLimitReached(percentUsed) {
+  return Boolean(percentUsed !== undefined && percentUsed >= MINI_SESSION_LIMIT_PERCENT);
+}
+export function buildFooterCounterState(options) {
+  const copiedContextTotalTokens = options.copiedContextTotalTokens ?? options.copiedContextTokens;
+  const copiedContextTruncated = options.copiedContextTokens !== undefined && copiedContextTotalTokens !== undefined && copiedContextTotalTokens > options.copiedContextTokens;
+  const copiedContext = options.mode === "main" && options.copiedContextTokens !== undefined ? {
+    usedTokens: options.copiedContextTokens,
+    totalAvailableTokens: copiedContextTotalTokens ?? options.copiedContextTokens,
+    tokenLimit: options.tokenLimit,
+    text: formatCopiedContextCounter(options.copiedContextTokens, copiedContextTotalTokens ?? options.copiedContextTokens, options.tokenLimit),
+    truncated: copiedContextTruncated
+  } : undefined;
+  const miniSession = options.lastCompletedMiniInputTokens !== undefined ? buildMiniSessionCounter(options.lastCompletedMiniInputTokens, options.modelContextWindow) : undefined;
+  return {
+    copiedContext,
+    miniSession,
+    placeholder: miniSession?.limitReached ? "Session context limit reached..." : undefined
+  };
+}
+function formatCopiedContextCounter(usedTokens, totalAvailableTokens, tokenLimit) {
+  if (totalAvailableTokens <= usedTokens) return `main ${formatTokenCount(usedTokens)}`;
+  return `main ${formatTokenCount(Math.min(usedTokens, tokenLimit))}/${formatTokenCount(totalAvailableTokens)}`;
+}
+function buildMiniSessionCounter(usedTokens, modelContextWindow) {
+  const percentUsed = modelContextWindow !== undefined ? getDisplayPercent(usedTokens, modelContextWindow) : undefined;
+  return {
+    usedTokens,
+    percentUsed,
+    text: percentUsed !== undefined ? `${formatTokenCount(usedTokens)} (${formatPercent(percentUsed)})` : formatTokenCount(usedTokens),
+    warning: isMiniSessionWarning(percentUsed),
+    limitReached: isMiniSessionLimitReached(percentUsed)
+  };
+}

package/dist/diagnostics.js

@@ -0,0 +1,59 @@
+const FALLBACK_ERROR_MESSAGE = "The side question failed.";
+const NESTED_ERROR_KEYS = ["error", "cause", "details"];
+export function extractErrorMessage(error) {
+  const message = readErrorMessage(error);
+  if (message) return message;
+  return FALLBACK_ERROR_MESSAGE;
+}
+export function getErrorMessage(cause) {
+  const extracted = extractErrorMessage(cause);
+  if (cause instanceof Error && cause.message) {
+    const normalizedMessage = normalizeErrorText(cause.message);
+    if (normalizedMessage && !isGenericErrorLabel(normalizedMessage)) {
+      return normalizedMessage;
+    }
+  }
+  if (extracted) return extracted;
+  if (cause instanceof Error && cause.name) return cause.name;
+  return FALLBACK_ERROR_MESSAGE;
+}
+function readErrorMessage(error, depth = 0) {
+  if (depth > 3 || !error) return undefined;
+  if (typeof error === "string") return normalizeErrorText(error);
+  if (Array.isArray(error)) {
+    for (const item of error) {
+      const message = readErrorMessage(item, depth + 1);
+      if (message) return message;
+    }
+    return undefined;
+  }
+  if (!isRecord(error)) return undefined;
+  const dataMessage = readDataMessage(error);
+  if (dataMessage) return dataMessage;
+  for (const key of NESTED_ERROR_KEYS) {
+    const message = readErrorMessage(error[key], depth + 1);
+    if (message) return message;
+  }
+  const directMessage = normalizeErrorText(error.message);
+  if (directMessage && !isGenericErrorLabel(directMessage)) return directMessage;
+  const name = normalizeErrorText(error.name);
+  if (name) return name;
+  return undefined;
+}
+function readDataMessage(error) {
+  const data = error.data;
+  if (!isRecord(data)) return undefined;
+  return normalizeErrorText(data.message);
+}
+function normalizeErrorText(value) {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  return trimmed.length > 600 ? `${trimmed.slice(0, 597)}...` : trimmed;
+}
+function isGenericErrorLabel(value) {
+  return /^(unknown(error)?|error)$/i.test(value.trim());
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}

package/dist/index.js

@@ -0,0 +1,157 @@
+import { memo as _$memo } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+/** @jsxImportSource @opentui/solid */
+
+import { createEffect, createSignal } from "solid-js";
+import { createOverlaySlot } from "./components/AnswerDialog.js";
+import { parseConfig } from "./config.js";
+import { PLUGIN_ID } from "./constants.js";
+import { buildGlobalCommands, buildPanelCommands } from "./keybinds.js";
+import { openMiniSession, openModelPicker } from "./session.js";
+import { resolveMiniRouteAction, runMiniRouteAction } from "./routing.js";
+function KeymapManager(props) {
+  props.context.keymap.layer(() => ({
+    mode: "global",
+    commands: props.globalCmds.map(c => ({
+      id: c.id,
+      title: c.title,
+      description: c.description,
+      group: c.group,
+      palette: c.palette,
+      slash: c.slash,
+      bind: c.bind,
+      enabled: c.enabled,
+      run: c.run
+    }))
+  }));
+  props.context.keymap.layer(() => ({
+    mode: "global",
+    priority: 1000,
+    enabled: () => Boolean(props.overlay()),
+    commands: props.panelCmds.map(c => ({
+      id: c.id,
+      title: c.title,
+      bind: c.bind,
+      enabled: c.enabled,
+      run: c.run
+    }))
+  }));
+  return [];
+}
+export default {
+  id: PLUGIN_ID,
+  setup(context) {
+    const config = parseConfig(context.options);
+    const [overlay, setOverlay] = createSignal(undefined, {
+      equals: false
+    });
+    const [selectedModel, setSelectedModel] = createSignal(undefined, {
+      equals: false
+    });
+    const [thinkingEnabled, setThinkingEnabled] = createSignal(config.enableThinking);
+    let activeDialog;
+    let activeMode;
+    let modelPickerOpen = false;
+    const thinkingPreference = {
+      get: thinkingEnabled,
+      set: setThinkingEnabled
+    };
+    const globalCmds = buildGlobalCommands({
+      context,
+      config,
+      overlay,
+      modelPickerOpen: {
+        get: () => modelPickerOpen,
+        set: v => {
+          modelPickerOpen = v;
+        }
+      },
+      triggerMiniMode: (mode, source) => triggerMiniMode(mode, source),
+      openModelPicker: () => {
+        const route = context.ui.router.current();
+        if (route.type !== "session") return;
+        openModelPicker(context, config, route.sessionID, {
+          get: selectedModel,
+          set: setSelectedModel
+        });
+      }
+    });
+    const panelCmds = buildPanelCommands({
+      context,
+      config,
+      overlay,
+      modelPickerOpen: {
+        get: () => modelPickerOpen,
+        set: v => {
+          modelPickerOpen = v;
+        }
+      },
+      triggerMiniMode: (mode, source) => triggerMiniMode(mode, source),
+      openModelPicker: () => {
+        const route = context.ui.router.current();
+        if (route.type !== "session") return;
+        openModelPicker(context, config, route.sessionID, {
+          get: selectedModel,
+          set: setSelectedModel
+        });
+      }
+    });
+    context.ui.slot({
+      append: "app",
+      render: () => [_$createComponent(KeymapManager, {
+        context: context,
+        overlay: overlay,
+        globalCmds: globalCmds,
+        panelCmds: panelCmds
+      }), _$memo(() => createOverlaySlot(overlay)())]
+    });
+    createEffect(() => {
+      const route = context.ui.router.current();
+      if (route.type === "session") return;
+      if (!activeDialog) return;
+      setOverlay(undefined);
+      context.ui.toast.show({
+        variant: "info",
+        message: "mini session closed.",
+        duration: 1000
+      });
+      void activeDialog.close();
+    });
+    async function triggerMiniMode(mode, source) {
+      const route = context.ui.router.current();
+      if (route.type !== "session") return;
+      const nextAction = resolveMiniRouteAction({
+        source,
+        requestedMode: mode,
+        activeMode,
+        isVisible: activeDialog?.isVisible()
+      });
+      await runMiniRouteAction({
+        action: nextAction,
+        activeDialog,
+        open: () => {
+          const opened = openMiniSession(context, config, mode, setOverlay, {
+            get: () => activeDialog,
+            set: d => {
+              activeDialog = d;
+              if (!d) {
+                activeMode = undefined;
+              }
+            }
+          }, {
+            get: selectedModel,
+            set: setSelectedModel
+          }, thinkingPreference, onAfterSelect => openModelPicker(context, config, route.sessionID, {
+            get: selectedModel,
+            set: setSelectedModel
+          }, () => {
+            modelPickerOpen = false;
+            onAfterSelect();
+          }));
+          if (opened) activeMode = mode;
+        }
+      });
+    }
+    return () => void activeDialog?.close();
+  }
+};

package/dist/keybinds.js

@@ -0,0 +1,152 @@
+import { CMD_CHANGE_MODEL, CMD_CLOSE, CMD_CONTINUE, CMD_HIDE, CMD_OPEN, CMD_OPEN_FRESH, CMD_PAGE_DOWN, CMD_PAGE_UP, CMD_SCROLL_BOTTOM, CMD_SCROLL_DOWN, CMD_SCROLL_TOP, CMD_SCROLL_UP, CMD_SUBMIT, CMD_TOGGLE_FRESH, CMD_TOGGLE_MAIN, CMD_TOGGLE_THINKING, SCROLL_LINE_DELTA, SCROLL_PAGE_DELTA } from "./constants.js";
+export function buildPanelCommands(ctx) {
+  const {
+    overlay,
+    modelPickerOpen
+  } = ctx;
+  const closePanel = () => {
+    if (modelPickerOpen.get()) {
+      modelPickerOpen.set(false);
+    } else {
+      overlay()?.onClose();
+    }
+  };
+  const whenOpen = () => Boolean(overlay());
+  return [{
+    id: CMD_HIDE,
+    bind: "up",
+    enabled: whenOpen,
+    run: () => overlay()?.onHide()
+  }, {
+    id: CMD_CLOSE,
+    title: "Close",
+    bind: "escape",
+    enabled: whenOpen,
+    run: closePanel
+  }, {
+    id: CMD_CLOSE,
+    bind: "ctrl+c",
+    enabled: whenOpen,
+    run: closePanel
+  }, {
+    id: CMD_CONTINUE,
+    title: "Continue",
+    bind: "shift+return",
+    enabled: whenOpen,
+    run: () => overlay()?.onContinue()
+  }, {
+    id: CMD_SUBMIT,
+    title: "Submit",
+    bind: "return",
+    enabled: whenOpen,
+    run: () => overlay()?.submit()
+  }, ...(ctx.config.toggleThinkingKeybind ? [{
+    id: CMD_TOGGLE_THINKING,
+    title: "Toggle thinking",
+    bind: ctx.config.toggleThinkingKeybind,
+    enabled: whenOpen,
+    run: () => overlay()?.onToggleThinking()
+  }] : []), {
+    id: CMD_CHANGE_MODEL,
+    title: "Change model",
+    bind: "tab",
+    enabled: whenOpen,
+    run: () => {
+      modelPickerOpen.set(true);
+      overlay()?.onChangeModel();
+    }
+  }, {
+    id: CMD_SCROLL_UP,
+    bind: "down",
+    enabled: whenOpen,
+    run: () => overlay()?.scrollBy(-SCROLL_LINE_DELTA)
+  }, {
+    id: CMD_SCROLL_DOWN,
+    bind: "down",
+    enabled: whenOpen,
+    run: () => overlay()?.scrollBy(SCROLL_LINE_DELTA)
+  }, {
+    id: CMD_PAGE_UP,
+    bind: "pageup",
+    enabled: whenOpen,
+    run: () => overlay()?.scrollBy(-SCROLL_PAGE_DELTA)
+  }, {
+    id: CMD_PAGE_DOWN,
+    bind: "pagedown",
+    enabled: whenOpen,
+    run: () => overlay()?.scrollBy(SCROLL_PAGE_DELTA)
+  }, {
+    id: CMD_SCROLL_TOP,
+    bind: "home",
+    enabled: whenOpen,
+    run: () => overlay()?.scrollTo(0)
+  }, {
+    id: CMD_SCROLL_BOTTOM,
+    bind: "end",
+    enabled: whenOpen,
+    run: () => overlay()?.scrollTo(Number.MAX_SAFE_INTEGER)
+  }];
+}
+export function buildGlobalCommands(ctx) {
+  const {
+    config,
+    triggerMiniMode,
+    openModelPicker
+  } = ctx;
+  const onSession = () => {
+    const route = ctx.context.ui.router.current();
+    return route.type === "session";
+  };
+  const commands = [];
+  if (config.keybind) {
+    commands.push({
+      id: CMD_TOGGLE_MAIN,
+      title: "Toggle mini session",
+      bind: config.keybind,
+      run: () => void triggerMiniMode("main", "keybind")
+    });
+  }
+  if (config.freshKeybind) {
+    commands.push({
+      id: CMD_TOGGLE_FRESH,
+      title: "Toggle mini fresh session",
+      bind: config.freshKeybind,
+      run: () => void triggerMiniMode("fresh", "keybind")
+    });
+  }
+  commands.push({
+    id: CMD_OPEN,
+    title: "mini",
+    description: "Open a mini session for side questions",
+    group: "Mini",
+    palette: true,
+    slash: {
+      name: "mini"
+    },
+    enabled: onSession,
+    run: () => void triggerMiniMode("main", "command")
+  }, {
+    id: CMD_OPEN_FRESH,
+    title: "mini fresh",
+    description: "Open a mini session without copied context",
+    group: "Mini",
+    palette: true,
+    slash: {
+      name: "mini-fresh"
+    },
+    enabled: onSession,
+    run: () => void triggerMiniMode("fresh", "command")
+  }, {
+    id: CMD_CHANGE_MODEL + ".global",
+    title: "mini model",
+    description: "Change the model for future mini-session questions",
+    group: "Mini",
+    palette: true,
+    slash: {
+      name: "mini-model"
+    },
+    enabled: onSession,
+    run: openModelPicker
+  });
+  return commands;
+}

package/dist/model.js

@@ -0,0 +1,75 @@
+export function parseModelOverride(value) {
+  const [providerID, ...rest] = value.split("/");
+  const id = rest.join("/");
+  if (!providerID || !id) return undefined;
+  return {
+    providerID,
+    id
+  };
+}
+export function resolveModel(modelOverride, variantOverride, entries, sessionModel) {
+  if (modelOverride) {
+    const model = parseModelOverride(modelOverride);
+    if (model) return {
+      model: {
+        ...model,
+        ...(variantOverride ? {
+          variant: variantOverride
+        } : {})
+      },
+      source: "config"
+    };
+  }
+  if (sessionModel) {
+    return {
+      model: {
+        providerID: sessionModel.providerID,
+        id: sessionModel.id,
+        variant: sessionModel.variant
+      },
+      source: "session"
+    };
+  }
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.type === "assistant" && entry.model) {
+      return {
+        model: {
+          providerID: entry.model.providerID,
+          id: entry.model.id,
+          variant: entry.model.variant
+        },
+        source: "session"
+      };
+    }
+  }
+  return {
+    model: {},
+    source: "default"
+  };
+}
+export function resolveDefaultModel(models, configuredModel, configuredVariant, sessionModel, entries) {
+  const resolved = resolveModel(configuredModel, configuredVariant, entries, sessionModel);
+  if (resolved.source !== "config") return resolved;
+  if (isAvailableModel(models, resolved.model)) return resolved;
+  return {
+    ...resolveModel(null, null, entries, sessionModel),
+    notice: `Configured mini model ${formatResolvedModel(resolved.model)} was not found. The main session model will be used.`
+  };
+}
+function isAvailableModel(models, resolved) {
+  if (!resolved.providerID || !resolved.id) return false;
+  const model = models?.find(m => m.providerID === resolved.providerID && m.id === resolved.id);
+  if (!model) return false;
+  if (!resolved.variant) return true;
+  return model.variants.some(v => v.id === resolved.variant);
+}
+export function formatResolvedModel(resolved) {
+  if (!resolved.providerID || !resolved.id) return "default";
+  const base = `${resolved.providerID}/${resolved.id}`;
+  return resolved.variant ? `${base} (${resolved.variant})` : base;
+}
+export function resolveModelContextWindow(models, resolved) {
+  if (!resolved.providerID || !resolved.id) return undefined;
+  return models?.find(m => m.providerID === resolved.providerID && m.id === resolved.id)?.limit?.context;
+}

package/dist/routing.js

@@ -0,0 +1,20 @@
+export function resolveMiniRouteAction(options) {
+  if (!options.activeMode) return "open";
+  if (options.activeMode !== options.requestedMode) return "switch";
+  if (options.isVisible === false) return "show";
+  return options.source === "keybind" ? "hide" : "show";
+}
+export async function runMiniRouteAction(options) {
+  if (options.action === "hide") {
+    options.activeDialog?.hide();
+    return;
+  }
+  if (options.action === "show") {
+    options.activeDialog?.show();
+    return;
+  }
+  if (options.action === "switch") {
+    await options.activeDialog?.close();
+  }
+  options.open();
+}