@leaves615/dsh-llm-ctl 0.1.0

package/lib/client.js

@@ -0,0 +1,1712 @@
+window.__ModuleLoader__.load({
+  id: "@leaves615/dsh-llm-ctl",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+    "use strict";
+    var __create = Object.create;
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __getProtoOf = Object.getPrototypeOf;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    
+    // src/client-plugin.ts
+    var client_plugin_exports = {};
+    __export(client_plugin_exports, {
+      apply: () => apply,
+      inject: () => inject,
+      pollDelayForFailures: () => pollDelayForFailures,
+      resolveSeatProvider: () => resolveSeatProvider
+    });
+    module.exports = __toCommonJS(client_plugin_exports);
+    var import_react4 = __toESM(require("react"), 1);
+    
+    // src/visibility.ts
+    function normalizePattern(pattern) {
+      return pattern.trim().toLowerCase();
+    }
+    function globMatch(pattern, value) {
+      let p = 0;
+      let v = 0;
+      let star = -1;
+      let resume = 0;
+      while (v < value.length) {
+        if (p < pattern.length && pattern[p] === "*") {
+          star = p;
+          resume = v;
+          p += 1;
+          continue;
+        }
+        if (p < pattern.length && pattern[p] === value[v]) {
+          p += 1;
+          v += 1;
+          continue;
+        }
+        if (star >= 0) {
+          p = star + 1;
+          resume += 1;
+          v = resume;
+          continue;
+        }
+        return false;
+      }
+      while (p < pattern.length && pattern[p] === "*") p += 1;
+      return p === pattern.length;
+    }
+    function matchesPattern(pattern, provider, model) {
+      const normalized = normalizePattern(pattern);
+      const separator = normalized.indexOf(":");
+      const providerGlob = separator < 0 ? "*" : normalized.slice(0, separator);
+      const modelGlob = separator < 0 ? normalized : normalized.slice(separator + 1);
+      if (!globMatch(providerGlob, provider.trim().toLowerCase())) return false;
+      return globMatch(modelGlob, model === void 0 ? "" : model.trim().toLowerCase());
+    }
+    function matchesAnyPattern(config, provider, model) {
+      const patterns = config?.hiddenPatterns;
+      if (patterns === void 0) return false;
+      return patterns.some((pattern) => matchesPattern(pattern, provider, model));
+    }
+    function isProviderVisible(provider, settings, config) {
+      const explicit = settings.providers[provider];
+      if (explicit !== void 0) return explicit;
+      return !matchesAnyPattern(config, provider, void 0);
+    }
+    function isModelVisible(provider, model, settings, config) {
+      if (settings.providers[provider] === false) return false;
+      const explicitModel = settings.models[modelKey(provider, model)];
+      if (explicitModel !== void 0) return explicitModel;
+      const explicitProvider = settings.providers[provider];
+      if (explicitProvider !== void 0) return explicitProvider;
+      return !matchesAnyPattern(config, provider, model);
+    }
+    function modelKey(provider, model) {
+      return `${provider}:${model}`;
+    }
+    
+    // src/settings-ui.ts
+    var import_react = __toESM(require("react"), 1);
+    
+    // src/concurrency.ts
+    function concurrencyFor(table, provider) {
+      const exact = table[provider];
+      if (exact !== void 0) return exact <= 0 ? Infinity : exact;
+      const fallback = table["default"];
+      if (fallback === void 0 || fallback <= 0) return Infinity;
+      return fallback;
+    }
+    
+    // src/settings-ui.ts
+    function buildProviderViews(input) {
+      const config = { hiddenPatterns: input.patterns };
+      return input.providers.map((entry) => ({
+        provider: entry.provider,
+        displayName: entry.displayName,
+        visible: isProviderVisible(entry.provider, input.settings, config),
+        models: entry.models.map((model) => ({
+          model: model.model,
+          name: model.name,
+          visible: isModelVisible(entry.provider, model.model, input.settings, config)
+        }))
+      }));
+    }
+    function summarize(views) {
+      let providers = 0;
+      let models = 0;
+      for (const view of views) {
+        if (!view.visible) providers += 1;
+        for (const model of view.models) if (!model.visible) models += 1;
+      }
+      return { providers, models, total: providers + models };
+    }
+    var rowStyle = { display: "flex", alignItems: "center", gap: 8, padding: "2px 0" };
+    var nameStyle = { flex: 1, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" };
+    var buttonStyle = {
+      border: "1px solid var(--dsw-alias-border-inverted, rgba(127,127,127,.35))",
+      background: "transparent",
+      color: "inherit",
+      borderRadius: 6,
+      padding: "1px 8px",
+      fontSize: 11,
+      cursor: "pointer"
+    };
+    var COLLAPSE_THRESHOLD = 8;
+    function defaultExpanded(count) {
+      return count <= COLLAPSE_THRESHOLD;
+    }
+    function useAutoCollapse(count) {
+      const [manual, setManual] = import_react.default.useState(void 0);
+      const collapsed = manual ?? !defaultExpanded(count);
+      const toggle2 = () => {
+        setManual(!collapsed);
+      };
+      return [collapsed, toggle2];
+    }
+    function CollapseToggle(props) {
+      return import_react.default.createElement(
+        "button",
+        {
+          type: "button",
+          style: buttonStyle,
+          title: props.collapsed ? "\u5C55\u5F00" : "\u6536\u8D77",
+          "aria-expanded": !props.collapsed,
+          onClick: () => props.onToggle()
+        },
+        (props.collapsed ? "\u25B8 " : "\u25BE ") + props.label + "\uFF08" + props.count + "\uFF09"
+      );
+    }
+    function toggle(label, visible, onToggle) {
+      return import_react.default.createElement(
+        "button",
+        {
+          type: "button",
+          style: buttonStyle,
+          title: visible ? "\u9690\u85CF" : "\u663E\u793A",
+          "aria-pressed": !visible,
+          onClick: onToggle
+        },
+        visible ? "\u{1F441}" : "\u{1F6AB}",
+        label.length > 0 ? import_react.default.createElement("span", { style: { marginLeft: 4 } }, label) : null
+      );
+    }
+    function ProviderVisibilityCard(props) {
+      const { view, actions } = props;
+      const [modelsCollapsed, toggleModels] = useAutoCollapse(view.models.length);
+      return import_react.default.createElement(
+        "div",
+        { style: { marginTop: 8, fontSize: 12 } },
+        import_react.default.createElement(
+          "div",
+          { style: rowStyle },
+          import_react.default.createElement("span", { style: nameStyle }, view.visible ? "\u63D0\u4F9B\u65B9\u53EF\u89C1" : "\u63D0\u4F9B\u65B9\u5DF2\u9690\u85CF"),
+          toggle("", view.visible, () => actions.setProvider(view.provider, !view.visible))
+        ),
+        view.models.length > 0 ? import_react.default.createElement(
+          import_react.default.Fragment,
+          null,
+          import_react.default.createElement(
+            "div",
+            { style: { ...rowStyle, paddingLeft: 12 } },
+            CollapseToggle({ collapsed: modelsCollapsed, count: view.models.length, label: "\u6A21\u578B", onToggle: toggleModels })
+          ),
+          modelsCollapsed ? null : view.models.map(
+            (model) => import_react.default.createElement(
+              "div",
+              { key: model.model, style: { ...rowStyle, paddingLeft: 12, opacity: model.visible ? 1 : 0.5 } },
+              import_react.default.createElement("span", { style: nameStyle }, model.name),
+              toggle("", model.visible, () => actions.setModel(view.provider, model.model, !model.visible))
+            )
+          )
+        ) : import_react.default.createElement(
+          "div",
+          { style: { ...rowStyle, paddingLeft: 12, opacity: 0.6, fontSize: 11 } },
+          "\u8BE5\u63D0\u4F9B\u65B9\u6682\u65E0\u6A21\u578B\u5217\u8868\uFF0C\u65E0\u6CD5\u9010\u6A21\u578B\u63A7\u5236"
+        )
+      );
+    }
+    function VisibilityFooter(props) {
+      const { summary, queue, actions } = props;
+      const parts = [];
+      if (summary.total === 0) parts.push("\u6CA1\u6709\u9690\u85CF\u7684\u6A21\u578B");
+      else parts.push(`\u5DF2\u9690\u85CF ${summary.providers} \u4E2A\u63D0\u4F9B\u65B9 / ${summary.models} \u4E2A\u6A21\u578B`);
+      if (queue.queued > 0 || queue.cooling > 0) parts.push(`\u6392\u961F ${queue.queued} \xB7 \u51B7\u5374 ${queue.cooling}`);
+      return import_react.default.createElement(
+        "div",
+        { style: { display: "flex", alignItems: "center", gap: 8, padding: "8px 0", fontSize: 12 } },
+        import_react.default.createElement("span", { style: nameStyle }, parts.join(" \xB7 ")),
+        summary.total > 0 ? import_react.default.createElement("button", { type: "button", style: buttonStyle, onClick: () => actions.resetAll() }, "\u5168\u90E8\u6062\u590D") : null
+      );
+    }
+    var pluginCardStyle = {
+      border: "0.5px solid var(--dsw-alias-border-l4, rgba(127,127,127,.28))",
+      background: "var(--dsw-alias-bg-layer-3, transparent)",
+      borderRadius: 16,
+      listStyle: "none"
+    };
+    var pluginHeaderStyle = {
+      appearance: "none",
+      width: "100%",
+      font: "inherit",
+      color: "inherit",
+      textAlign: "left",
+      cursor: "pointer",
+      background: "none",
+      border: 0,
+      borderRadius: 12,
+      display: "flex",
+      alignItems: "center",
+      gap: 12,
+      padding: "14px 16px"
+    };
+    var pluginHeadTextStyle = { display: "flex", flexDirection: "column", flex: 1, gap: 4, minWidth: 0 };
+    var pluginNameStyle = { color: "var(--dsw-alias-label-primary, inherit)", fontSize: 15, fontWeight: 600, lineHeight: 1.4 };
+    var pluginDescriptionStyle = { color: "var(--dsw-alias-label-tertiary, inherit)", fontSize: 13, lineHeight: 1.5 };
+    var pluginBodyStyle = { borderTop: "0.5px solid var(--dsw-alias-border-l2, rgba(127,127,127,.2))", margin: "0 16px", paddingBottom: 8 };
+    var pluginFieldStyle = { display: "flex", flexDirection: "column", gap: 4, padding: "12px 0 0" };
+    var pluginLabelStyle = { color: "var(--dsw-alias-label-primary, inherit)", fontSize: 13, lineHeight: 1.5 };
+    var pluginHintStyle = { color: "var(--dsw-alias-label-tertiary, inherit)", margin: 0, fontSize: 12, lineHeight: 1.5 };
+    var pluginInputStyle = {
+      border: "0.5px solid var(--dsw-alias-border-l4, rgba(127,127,127,.28))",
+      background: "var(--dsw-alias-bg-layer-3, transparent)",
+      height: 34,
+      font: "inherit",
+      color: "var(--dsw-alias-label-primary, inherit)",
+      borderRadius: 8,
+      padding: "0 12px",
+      fontSize: 13
+    };
+    var pluginFooterStyle = { borderTop: "0.5px solid var(--dsw-alias-border-l2, rgba(127,127,127,.2))", display: "flex", justifyContent: "flex-end", alignItems: "center", gap: 8, padding: "12px 0 4px" };
+    var pluginFailedStyle = { flex: 1, minWidth: 0, margin: 0, color: "var(--dsw-alias-label-error, #d33)", fontSize: 12, lineHeight: 1.5 };
+    var pluginActionStyle = { appearance: "none", font: "inherit", cursor: "pointer", border: "1px solid var(--dsw-alias-border-l2, rgba(127,127,127,.28))", color: "var(--dsw-alias-label-secondary, inherit)", background: "none", borderRadius: 8, padding: "5px 14px", fontSize: 13, lineHeight: 1.5 };
+    function PluginConfigCard(props) {
+      const { config, actions } = props;
+      const effectiveDefault = config.defaultConcurrency ?? config.defaults?.defaultConcurrency ?? 2;
+      const effectivePer = config.perProviderConcurrency ?? {};
+      const [open, setOpen] = import_react.default.useState(false);
+      const [waitSec, setWaitSec] = import_react.default.useState(() => String(Math.round(config.maxWaitMs / 1e3)));
+      const [depth, setDepth] = import_react.default.useState(() => String(config.maxQueueDepth));
+      const [defaultConc, setDefaultConc] = import_react.default.useState(() => String(effectiveDefault));
+      const [perDrafts, setPerDrafts] = import_react.default.useState(
+        () => Object.fromEntries(Object.entries(effectivePer).map(([key, value]) => [key, String(value)]))
+      );
+      const [dirty, setDirty] = import_react.default.useState(false);
+      const [saving, setSaving] = import_react.default.useState(false);
+      const [failed, setFailed] = import_react.default.useState(false);
+      const legacyHost = config.defaultConcurrency === void 0 || config.perProviderConcurrency === void 0;
+      const perTableJson = JSON.stringify(effectivePer);
+      import_react.default.useEffect(() => {
+        if (dirty || saving) return;
+        setWaitSec(String(Math.round(config.maxWaitMs / 1e3)));
+        setDepth(String(config.maxQueueDepth));
+        setDefaultConc(String(effectiveDefault));
+        setPerDrafts(Object.fromEntries(Object.entries(effectivePer).map(([key, value]) => [key, String(value)])));
+      }, [config.revision, config.maxWaitMs, config.maxQueueDepth, effectiveDefault, perTableJson, dirty, saving]);
+      const seconds = Number(waitSec);
+      const count = Number(depth);
+      const defaultCount = Number(defaultConc);
+      const perTable = (() => {
+        const table = {};
+        let bad = false;
+        for (const [key, raw] of Object.entries(perDrafts)) {
+          const trimmed = raw.trim();
+          if (trimmed === "") continue;
+          const value = Number(trimmed);
+          if (!Number.isFinite(value) || value < 0) {
+            bad = true;
+            break;
+          }
+          if (key.length > 0) table[key] = Math.floor(value);
+        }
+        return { table, bad };
+      })();
+      const invalid = !Number.isFinite(seconds) || seconds < 0 || !Number.isFinite(count) || count < 1 || !Number.isFinite(defaultCount) || defaultCount < 0 || perTable.bad;
+      const stage = (setter) => (event) => {
+        setter(event.target.value);
+        setDirty(true);
+        setFailed(false);
+      };
+      const onSave = async () => {
+        if (invalid || saving) return;
+        setSaving(true);
+        setFailed(false);
+        const nextWaitMs = Math.round(seconds * 1e3);
+        const nextDepth = Math.floor(count);
+        const nextDefault = Math.floor(defaultCount);
+        const patch = { expectedRevision: config.revision };
+        if (nextWaitMs !== config.maxWaitMs) patch.maxWaitMs = nextWaitMs;
+        if (nextDepth !== config.maxQueueDepth) patch.maxQueueDepth = nextDepth;
+        if (nextDefault !== effectiveDefault) patch.defaultConcurrency = nextDefault;
+        if (JSON.stringify(perTable.table) !== JSON.stringify(effectivePer)) patch.perProviderConcurrency = perTable.table;
+        const result = await actions.setQueue(patch);
+        setSaving(false);
+        if (result.ok) setDirty(false);
+        else setFailed(result.error ?? "\u4FDD\u5B58\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5\u3002");
+      };
+      const onDiscard = () => {
+        setWaitSec(String(Math.round(config.maxWaitMs / 1e3)));
+        setDepth(String(config.maxQueueDepth));
+        setDefaultConc(String(effectiveDefault));
+        setPerDrafts(Object.fromEntries(Object.entries(effectivePer).map(([key, value]) => [key, String(value)])));
+        setDirty(false);
+        setFailed(false);
+      };
+      const onResetDefaults = async () => {
+        if (saving) return;
+        setSaving(true);
+        setFailed(false);
+        const ok = await actions.resetQueue(config.revision);
+        setSaving(false);
+        if (ok) {
+          setDirty(false);
+          setFailed(false);
+        } else setFailed("\u4FDD\u5B58\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5\u3002");
+      };
+      const field = (input) => import_react.default.createElement(
+        "div",
+        { style: pluginFieldStyle },
+        import_react.default.createElement("label", { htmlFor: input.id, style: pluginLabelStyle }, input.label),
+        import_react.default.createElement("input", {
+          id: input.id,
+          type: "number",
+          style: pluginInputStyle,
+          min: input.min,
+          ...input.step === void 0 ? {} : { step: input.step },
+          disabled: saving,
+          value: input.value,
+          onChange: input.onEdit
+        }),
+        import_react.default.createElement("p", { style: pluginHintStyle }, invalid ? input.invalidHint : input.hint)
+      );
+      const header = import_react.default.createElement(
+        "button",
+        {
+          type: "button",
+          style: pluginHeaderStyle,
+          "aria-expanded": open,
+          "aria-label": (open ? "\u6536\u8D77\u8BBE\u7F6E: " : "\u5C55\u5F00\u8BBE\u7F6E: ") + "LLM \u6392\u961F\u63A7\u5236",
+          onClick: () => setOpen(!open)
+        },
+        import_react.default.createElement(
+          "span",
+          { style: pluginHeadTextStyle },
+          import_react.default.createElement("span", { style: pluginNameStyle }, "LLM \u6392\u961F\u63A7\u5236"),
+          import_react.default.createElement("span", { style: pluginDescriptionStyle }, "\u6309 provider \u7684\u5E76\u53D1\u4E0A\u9650\u3001\u51C6\u5165\u6392\u961F\u3001\u51B7\u5374\u7B49\u5F85\u4E0E\u91CD\u8BD5\u9884\u7B97\u3002")
+        ),
+        config.overridden && !dirty ? import_react.default.createElement("span", { style: pluginHintStyle }, "\u5DF2\u81EA\u5B9A\u4E49") : null,
+        import_react.default.createElement(
+          "svg",
+          {
+            width: 14,
+            height: 14,
+            viewBox: "0 0 14 14",
+            fill: "none",
+            xmlns: "http://www.w3.org/2000/svg",
+            style: { color: "var(--dsw-alias-label-tertiary, inherit)", flex: "none", transition: "transform .16s", transform: open ? "rotate(180deg)" : "none" }
+          },
+          import_react.default.createElement("path", { d: "M11.8486 5.5L11.4238 5.92383L8.69727 8.65137C8.44157 8.90706 8.21562 9.13382 8.01172 9.29785C7.79912 9.46883 7.55595 9.61756 7.25 9.66602C7.08435 9.69222 6.91565 9.69222 6.75 9.66602C6.44405 9.61756 6.20088 9.46883 5.98828 9.29785C5.78438 9.13382 5.55843 8.90706 5.30273 8.65137L2.57617 5.92383L2.15137 5.5L3 4.65137L3.42383 5.07617L6.15137 7.80273C6.42595 8.07732 6.59876 8.24849 6.74023 8.3623C6.87291 8.46904 6.92272 8.47813 6.9375 8.48047C6.97895 8.48703 7.02105 8.48703 7.0625 8.48047C7.07728 8.47813 7.12709 8.46904 7.25977 8.3623C7.40124 8.24849 7.57405 8.07732 7.84863 7.80273L10.5762 5.07617L11 4.65137L11.8486 5.5Z", fill: "currentColor" })
+        )
+      );
+      const stagePer = (provider) => (event) => {
+        const value = event.target.value;
+        setPerDrafts((prev) => ({ ...prev, [provider]: value }));
+        setDirty(true);
+        setFailed(false);
+      };
+      const directory = (props.providers ?? []).filter((entry) => entry.provider.length > 0);
+      const rowIds = directory.map((entry) => entry.provider);
+      for (const key of [...Object.keys(effectivePer), ...Object.keys(perDrafts)]) {
+        if (key.length > 0 && !rowIds.includes(key)) rowIds.push(key);
+      }
+      const displayNameOf = (id) => directory.find((entry) => entry.provider === id)?.displayName ?? id;
+      const lookupTable = { default: effectiveDefault, ...effectivePer };
+      const inheritHint = (id) => {
+        const effective = concurrencyFor(lookupTable, id);
+        return Number.isFinite(effective) ? `\u9ED8\u8BA4 ${effective}` : "\u4E0D\u9650\u5236\uFF08\u9ED8\u8BA4\uFF09";
+      };
+      const concurrencySection = import_react.default.createElement(
+        "div",
+        { style: pluginFieldStyle },
+        import_react.default.createElement("span", { style: pluginLabelStyle }, "\u5404\u63D0\u4F9B\u65B9\u5E76\u53D1\u4E0A\u9650"),
+        import_react.default.createElement("p", { style: pluginHintStyle }, "\u7559\u7A7A\u7EE7\u627F\u9ED8\u8BA4\uFF1B\u586B 0 \u4E3A\u8BE5\u63D0\u4F9B\u65B9\u4E0D\u9650\u5236\u3002"),
+        rowIds.length === 0 ? import_react.default.createElement("p", { style: pluginHintStyle }, "\u6682\u65E0\u5DF2\u77E5\u63D0\u4F9B\u65B9\uFF0C\u5148\u8BBE\u7F6E\u9ED8\u8BA4\u5E76\u53D1\u5373\u53EF\u3002") : rowIds.map(
+          (id) => import_react.default.createElement(
+            "div",
+            { key: id, style: { ...rowStyle, paddingLeft: 12 } },
+            import_react.default.createElement("span", { style: nameStyle }, displayNameOf(id)),
+            import_react.default.createElement("input", {
+              type: "number",
+              style: { ...pluginInputStyle, width: 88, height: 28, flex: "none" },
+              min: 0,
+              step: 1,
+              disabled: saving,
+              value: perDrafts[id] ?? "",
+              placeholder: inheritHint(id),
+              "aria-label": `${displayNameOf(id)} \u5E76\u53D1\u4E0A\u9650`,
+              onChange: stagePer(id)
+            })
+          )
+        )
+      );
+      const body = import_react.default.createElement(
+        "div",
+        { style: pluginBodyStyle },
+        legacyHost ? import_react.default.createElement("p", { style: pluginFailedStyle }, "\u68C0\u6D4B\u5230 Host \u4E3A\u65E7\u7248\u672C\uFF1A\u5E76\u53D1\u8BBE\u7F6E\u4FDD\u5B58\u4F1A\u5931\u8D25\uFF0C\u8BF7\u91CD\u8F7D\u63D2\u4EF6\u540E\u518D\u8BD5\uFF1B\u6392\u961F\u8D85\u65F6\u4E0E\u961F\u5217\u6DF1\u5EA6\u4ECD\u53EF\u4FDD\u5B58\u3002") : null,
+        field({ id: "llm-ctl-queue-max-wait", label: "\u6392\u961F\u8D85\u65F6\uFF08\u79D2\uFF09", hint: "\u5355\u8BF7\u6C42\u6392\u961F\u8010\u5FC3\uFF0C\u4E0E\u613F\u610F\u91C7\u7EB3\u7684 provider \u51B7\u5374\u5171\u7528\u4E00\u4E2A\u9884\u7B97\u3002", invalidHint: "\u8BF7\u8F93\u5165 \u2265 0 \u7684\u79D2\u6570\u3002", value: waitSec, min: 0, onEdit: stage(setWaitSec) }),
+        field({ id: "llm-ctl-queue-depth", label: "\u961F\u5217\u6DF1\u5EA6", hint: "\u540C\u4E00\u65F6\u523B\u5141\u8BB8\u6392\u961F\u7684\u6700\u5927\u8BF7\u6C42\u6570\u3002", invalidHint: "\u8BF7\u8F93\u5165 \u2265 1 \u7684\u6574\u6570\u3002", value: depth, min: 1, step: 1, onEdit: stage(setDepth) }),
+        field({ id: "llm-ctl-queue-concurrency", label: "\u9ED8\u8BA4\u5E76\u53D1\u4E0A\u9650", hint: "\u6BCF\u4E2A\u63D0\u4F9B\u65B9\u540C\u65F6\u8FDB\u884C\u7684\u8BF7\u6C42\u6570\uFF0C\u8D85\u9650\u7684\u6392\u961F\u7B49\u5F85\uFF1B0 \u8868\u793A\u4E0D\u9650\u5236\uFF08\u9ED8\u8BA4\uFF09\u3002", invalidHint: "\u8BF7\u8F93\u5165 \u2265 0 \u7684\u6574\u6570\uFF080 = \u4E0D\u9650\u5236\uFF09\u3002", value: defaultConc, min: 0, step: 1, onEdit: stage(setDefaultConc) }),
+        concurrencySection,
+        import_react.default.createElement(
+          "div",
+          { style: pluginFooterStyle },
+          failed !== false ? import_react.default.createElement("p", { style: pluginFailedStyle }, failed) : null,
+          config.overridden ? import_react.default.createElement(
+            "button",
+            { type: "button", style: pluginActionStyle, disabled: saving, onClick: () => void onResetDefaults() },
+            "\u6062\u590D\u9ED8\u8BA4"
+          ) : null,
+          import_react.default.createElement(
+            "button",
+            { type: "button", style: pluginActionStyle, disabled: !dirty || invalid || saving, onClick: onDiscard },
+            "\u653E\u5F03\u4FEE\u6539"
+          ),
+          import_react.default.createElement(
+            "button",
+            { type: "button", style: { ...pluginActionStyle, background: "var(--dsw-alias-label-primary, currentColor)", color: "var(--dsw-alias-bg-layer-3, inherit)" }, disabled: !dirty || invalid || saving, onClick: () => void onSave() },
+            saving ? "\u4FDD\u5B58\u4E2D\u2026" : "\u4FDD\u5B58"
+          )
+        )
+      );
+      return import_react.default.createElement("li", { style: pluginCardStyle }, header, open ? body : null);
+    }
+    
+    // src/menu-filter.ts
+    var EMPTY_STATE_ID = "dsh-llm-ctl-empty";
+    var DOCUMENT_POSITION_FOLLOWING = 4;
+    function isModelMenuLabel(label) {
+      const value = label.toLowerCase();
+      return value.includes("model") || label.includes("\u63A8\u7406\u7B49\u7EA7") || value.includes("effort");
+    }
+    function isElement(node) {
+      return typeof node === "object" && node !== null && typeof node.matches === "function";
+    }
+    function groupsOf(roots) {
+      const groups = roots?.groups;
+      return groups ?? void 0;
+    }
+    function menuOf(roots) {
+      const menu = roots?.menu;
+      return menu ?? void 0;
+    }
+    function documentOf(...candidates) {
+      for (const candidate of candidates) {
+        const owner = candidate?.ownerDocument;
+        if (owner !== void 0 && owner !== null) return owner;
+      }
+      return typeof document === "undefined" ? void 0 : document;
+    }
+    function classAttributeOf(element) {
+      return element.getAttribute("class") ?? "";
+    }
+    function findGroupsContainer(menu) {
+      for (const candidate of menu.querySelectorAll("div")) {
+        if (candidate.getAttribute("role") !== null) continue;
+        if (candidate.querySelector('[role="group"]') !== null) return candidate;
+      }
+      for (const child of Array.from(menu.children)) {
+        if (child.querySelector('[role="group"]') !== null) return child;
+      }
+      return menu;
+    }
+    function findModelMenu(root) {
+      try {
+        if (root === void 0 || root === null) return void 0;
+        let menu;
+        if (isElement(root) && root.matches('div[role="menu"]') && isModelMenuLabel(root.getAttribute("aria-label") ?? "")) {
+          menu = root;
+        }
+        const candidates = root.querySelectorAll('div[role="menu"]');
+        if (menu === void 0) {
+          for (const candidate of candidates) {
+            if (isModelMenuLabel(candidate.getAttribute("aria-label") ?? "")) {
+              menu = candidate;
+              break;
+            }
+          }
+        }
+        if (menu === void 0) {
+          for (const candidate of candidates) {
+            if ((candidate.getAttribute("aria-label") ?? "").trim() !== "") continue;
+            if (candidate.querySelector('[role="group"]') === null) continue;
+            menu = candidate;
+            break;
+          }
+        }
+        if (menu === void 0) return void 0;
+        return { menu, groups: findGroupsContainer(menu) };
+      } catch {
+        return void 0;
+      }
+    }
+    function readGroupTitle(group) {
+      try {
+        const titled = group.querySelector("div[id]");
+        const fromTitle = titled?.textContent?.trim() ?? "";
+        if (fromTitle !== "") return fromTitle;
+        const labelledBy = (group.getAttribute("aria-labelledby") ?? "").trim();
+        if (labelledBy !== "") {
+          const owner = group.ownerDocument;
+          for (const id of labelledBy.split(/\s+/)) {
+            const target = owner?.getElementById(id);
+            const text = target?.textContent?.trim() ?? "";
+            if (text !== "") return text;
+          }
+        }
+        return (group.getAttribute("aria-label") ?? "").trim();
+      } catch {
+        return "";
+      }
+    }
+    function readRowName(row) {
+      try {
+        const title = (row.getAttribute("title") ?? "").trim();
+        if (title !== "") return title;
+        const named = row.querySelector('[class*="modelName"]');
+        const fromClass = named?.textContent?.trim() ?? "";
+        if (fromClass !== "") return fromClass;
+        return (row.textContent ?? "").trim();
+      } catch {
+        return "";
+      }
+    }
+    function listModelRows(roots) {
+      const rows = [];
+      const groups = groupsOf(roots);
+      if (groups === void 0) return rows;
+      try {
+        for (const group of groups.querySelectorAll('section[role="group"]')) {
+          const providerName = readGroupTitle(group);
+          for (const row of group.querySelectorAll('[role="menuitemradio"]')) {
+            rows.push({ row, providerName, modelName: readRowName(row) });
+          }
+        }
+      } catch {
+      }
+      return rows;
+    }
+    function parseMenuQuery(raw) {
+      const providerTerms = [];
+      const modelTerms = [];
+      for (const token of raw.trim().toLowerCase().split(/\s+/).filter((part) => part.length > 0)) {
+        const providerTerm = token.startsWith("p:") ? token.slice(2) : token.startsWith("provider:") ? token.slice(9) : void 0;
+        if (providerTerm !== void 0) {
+          if (providerTerm.length > 0) providerTerms.push(providerTerm);
+        } else {
+          modelTerms.push(token);
+        }
+      }
+      return { providerTerms, modelTerms };
+    }
+    function matchesQuery(row, query2) {
+      const { providerTerms, modelTerms } = parseMenuQuery(query2);
+      const provider = row.providerName.toLowerCase();
+      const model = row.modelName.toLowerCase();
+      return providerTerms.every((term) => provider.includes(term)) && modelTerms.every((term) => model.includes(term) || provider.includes(term));
+    }
+    function applyMenuFilter(roots, options = {}) {
+      const result = { shown: 0, hidden: 0, groupsHidden: 0 };
+      const groups = groupsOf(roots);
+      if (groups === void 0) return result;
+      try {
+        const hideUnmatched = options?.hideUnmatched !== false;
+        const query2 = hideUnmatched ? (options?.query ?? "").trim().toLowerCase() : "";
+        const isRowVisible = options?.isRowVisible;
+        for (const group of groups.querySelectorAll('section[role="group"]')) {
+          const providerName = readGroupTitle(group);
+          const rows = group.querySelectorAll('[role="menuitemradio"]');
+          let visibleRows = 0;
+          for (const row of rows) {
+            const model = { row, providerName, modelName: readRowName(row) };
+            let visible = true;
+            if (typeof isRowVisible === "function") {
+              try {
+                visible = isRowVisible(model) !== false;
+              } catch {
+                visible = false;
+              }
+            }
+            if (visible && hideUnmatched && !matchesQuery(model, query2)) visible = false;
+            row.style.display = visible ? "" : "none";
+            if (visible) visibleRows += 1;
+            else result.hidden += 1;
+          }
+          result.shown += visibleRows;
+          if (rows.length > 0 && visibleRows === 0) {
+            group.style.display = "none";
+            result.groupsHidden += 1;
+          } else {
+            group.style.display = "";
+          }
+        }
+      } catch {
+      }
+      return result;
+    }
+    function resetMenuFilter(roots) {
+      const groups = groupsOf(roots);
+      if (groups === void 0) return;
+      try {
+        for (const group of groups.querySelectorAll('section[role="group"]')) {
+          group.style.display = "";
+          for (const row of group.querySelectorAll('[role="menuitemradio"]')) {
+            row.style.display = "";
+            delete row.dataset["llmCtlHidden"];
+          }
+        }
+      } catch {
+      }
+    }
+    function containsForeignSearch(element) {
+      if (element.matches('[class*="dsh-model-search-container"]')) return true;
+      if (element.querySelector('[class*="dsh-model-search-container"]') !== null) return true;
+      if (element.matches("input") && classAttributeOf(element).includes("dsh-model-search")) return true;
+      for (const input of element.querySelectorAll("input")) {
+        if (classAttributeOf(input).includes("dsh-model-search")) return true;
+      }
+      return false;
+    }
+    function isBefore(element, other) {
+      if (element === other) return false;
+      if (typeof element.compareDocumentPosition !== "function") return true;
+      return (element.compareDocumentPosition(other) & DOCUMENT_POSITION_FOLLOWING) !== 0;
+    }
+    function hasForeignSearchWidget(roots) {
+      const groups = groupsOf(roots);
+      const menu = menuOf(roots);
+      if (groups === void 0 || menu === void 0) return false;
+      try {
+        const previous = groups.previousElementSibling;
+        if (previous !== null && containsForeignSearch(previous)) return true;
+        const scopes = [menu];
+        const parent = menu.parentElement;
+        if (parent !== null) scopes.push(parent);
+        const anchor = groups.querySelector('section[role="group"]') ?? groups;
+        for (const scope of scopes) {
+          const widgets = scope.querySelectorAll(
+            '[class*="dsh-model-search-container"], input[class*="dsh-model-search-input"]'
+          );
+          for (const widget of widgets) {
+            if (widget === anchor || widget.contains(anchor)) continue;
+            if (!isBefore(widget, anchor)) continue;
+            return true;
+          }
+        }
+        return false;
+      } catch {
+        return false;
+      }
+    }
+    function findEmptyState(groups, menu) {
+      const parent = groups?.parentElement ?? menu?.parentElement ?? null;
+      const local = parent?.querySelector(`#${EMPTY_STATE_ID}`);
+      if (local !== void 0 && local !== null) return local;
+      const global = documentOf(groups, menu)?.getElementById(EMPTY_STATE_ID);
+      return global ?? void 0;
+    }
+    function ensureEmptyState(roots, text, actionLabel, onAction) {
+      const groups = groupsOf(roots);
+      const menu = menuOf(roots);
+      const existing = findEmptyState(groups, menu);
+      const owner = documentOf(existing, groups, menu);
+      if (owner === void 0) return roots?.menu ?? roots?.groups;
+      let element = existing;
+      try {
+        element = element ?? owner.createElement("div");
+        element.id = EMPTY_STATE_ID;
+        element.className = "dsh-llm-ctl-empty";
+        const message = owner.createElement("span");
+        message.className = "dsh-llm-ctl-empty-text";
+        message.textContent = text;
+        const action = owner.createElement("button");
+        action.type = "button";
+        action.className = "dsh-llm-ctl-empty-action";
+        action.textContent = actionLabel;
+        action.addEventListener("click", (event) => {
+          event.preventDefault();
+          try {
+            onAction();
+          } catch {
+          }
+        });
+        element.replaceChildren(message, action);
+        const parent = groups?.parentElement ?? menu?.parentElement ?? null;
+        if (parent !== null) {
+          if (groups !== void 0 && groups.parentElement === parent) parent.insertBefore(element, groups);
+          else if (element.parentElement !== parent) parent.appendChild(element);
+        }
+      } catch {
+      }
+      return element ?? (roots?.menu ?? roots?.groups);
+    }
+    function removeEmptyState(roots) {
+      try {
+        const groups = groupsOf(roots);
+        const menu = menuOf(roots);
+        findEmptyState(groups, menu)?.remove();
+      } catch {
+      }
+    }
+    
+    // src/menu-visibility.ts
+    var HIDDEN_MARKER = "llmCtlHidden";
+    function groupTitleOf(group) {
+      try {
+        const titled = group.querySelector("div[id]");
+        if (titled !== null) return (titled.textContent ?? "").trim();
+        const labelledBy = group.getAttribute("aria-labelledby");
+        if (labelledBy !== null && labelledBy.length > 0) {
+          const target = group.ownerDocument?.getElementById(labelledBy);
+          if (target !== null && target !== void 0) return (target.textContent ?? "").trim();
+        }
+        return (group.getAttribute("aria-label") ?? "").trim();
+      } catch {
+        return "";
+      }
+    }
+    function rowNameOf(row) {
+      try {
+        const title = row.getAttribute("title");
+        if (title !== null && title.trim().length > 0) return title.trim();
+        const named = row.querySelector('[class*="modelName"]');
+        if (named !== null && (named.textContent ?? "").trim().length > 0) return (named.textContent ?? "").trim();
+        return (row.textContent ?? "").trim();
+      } catch {
+        return "";
+      }
+    }
+    function applyVisibilityOnly(roots, isRowVisible) {
+      const result = { hidden: 0, restored: 0 };
+      try {
+        for (const group of roots.groups.querySelectorAll('section[role="group"]')) {
+          const providerName = groupTitleOf(group);
+          for (const row of group.querySelectorAll('[role="menuitemradio"]')) {
+            const model = { row, providerName, modelName: rowNameOf(row) };
+            let visible = true;
+            try {
+              visible = isRowVisible(model) !== false;
+            } catch {
+              visible = false;
+            }
+            if (!visible) {
+              if (row.style.display !== "none") row.style.display = "none";
+              if (row.dataset[HIDDEN_MARKER] !== "1") {
+                row.dataset[HIDDEN_MARKER] = "1";
+                result.hidden += 1;
+              }
+            } else if (row.dataset[HIDDEN_MARKER] === "1") {
+              row.style.display = "";
+              delete row.dataset[HIDDEN_MARKER];
+              result.restored += 1;
+            }
+          }
+        }
+      } catch {
+      }
+      return result;
+    }
+    
+    // src/discover-ui.ts
+    var import_react2 = __toESM(require("react"), 1);
+    function buildDiscoveredRows(input) {
+      const config = { hiddenPatterns: input.patterns };
+      const rows = [];
+      for (const entry of input.discovered) {
+        if (entry.id === "") continue;
+        rows.push({
+          id: entry.id,
+          name: entry.name ?? entry.id,
+          isNew: !input.advertisedIds.includes(entry.id),
+          visible: isModelVisible(input.provider, entry.id, input.settings, config)
+        });
+      }
+      return rows;
+    }
+    var rowStyle2 = { display: "flex", alignItems: "center", gap: 8, padding: "2px 0" };
+    var nameStyle2 = { flex: 1, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" };
+    var buttonStyle2 = {
+      border: "1px solid var(--dsw-alias-border-inverted, rgba(127,127,127,.35))",
+      background: "transparent",
+      color: "inherit",
+      borderRadius: 6,
+      padding: "1px 8px",
+      fontSize: 11,
+      cursor: "pointer"
+    };
+    var badgeStyle = {
+      border: "1px solid var(--dsw-alias-border-inverted, rgba(127,127,127,.35))",
+      borderRadius: 4,
+      padding: "0 4px",
+      fontSize: 10
+    };
+    var errorStyle = { color: "#f31260", padding: "2px 0" };
+    function RefreshModelsButton(props) {
+      const disabled = props.pending || props.disabled === true;
+      return import_react2.default.createElement(
+        "button",
+        {
+          type: "button",
+          style: buttonStyle2,
+          disabled,
+          onClick: () => props.onRefresh()
+        },
+        props.pending ? "\u5237\u65B0\u4E2D\u2026" : "\u5237\u65B0\u6E05\u5355"
+      );
+    }
+    function DiscoveredModelsList(props) {
+      const [collapsed, toggleCollapsed] = useAutoCollapse(props.rows.length);
+      if (props.rows.length === 0 && !props.pending && !props.failed) return null;
+      const failed = props.failed ?? "";
+      return import_react2.default.createElement(
+        "section",
+        { style: { marginTop: 8, fontSize: 12 } },
+        import_react2.default.createElement(
+          "div",
+          { style: rowStyle2 },
+          CollapseToggle({ collapsed, count: props.rows.length, label: "\u4E0A\u6E38\u53D1\u73B0", onToggle: toggleCollapsed }),
+          import_react2.default.createElement(RefreshModelsButton, { pending: props.pending, onRefresh: props.onRefresh })
+        ),
+        failed.length > 0 ? import_react2.default.createElement("div", { style: errorStyle }, failed) : null,
+        collapsed ? null : props.rows.map(
+          (row) => import_react2.default.createElement(
+            "div",
+            { key: row.id, style: { ...rowStyle2, opacity: row.visible ? 1 : 0.5 } },
+            import_react2.default.createElement("span", { style: nameStyle2 }, row.name),
+            row.isNew ? import_react2.default.createElement("span", { style: badgeStyle }, "\u65B0") : null,
+            import_react2.default.createElement(
+              "button",
+              {
+                type: "button",
+                style: buttonStyle2,
+                title: row.visible ? "\u9690\u85CF" : "\u663E\u793A",
+                "aria-pressed": !row.visible,
+                onClick: () => props.onToggle(props.provider, row.id, !row.visible)
+              },
+              row.visible ? "\u{1F441}" : "\u{1F6AB}"
+            )
+          )
+        )
+      );
+    }
+    
+    // src/queue-dock.ts
+    var import_react3 = __toESM(require("react"), 1);
+    var import_react_dom = require("react-dom");
+    function formatMs(ms) {
+      if (ms < 1e3) return Math.max(0, Math.round(ms)) + "ms";
+      const seconds = ms / 1e3;
+      if (seconds < 60) return (seconds < 10 ? seconds.toFixed(1) : String(Math.round(seconds))) + "s";
+      return Math.floor(seconds / 60) + "m" + Math.round(seconds % 60) + "s";
+    }
+    function buildQueueDockView(queue) {
+      const cooling = queue.lanes.filter((lane) => lane.cooldownRemainingMs > 0);
+      if (queue.waiters.length === 0 && cooling.length === 0) return void 0;
+      return { waiters: [...queue.waiters], cooling };
+    }
+    var DOCK_CANCEL_CLASS = "dsh-llm-ctl-dock-cancel";
+    var DOCK_PILL_CLASS = "dsh-llm-ctl-dock-pill";
+    var panelStyle = {
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      flexWrap: "wrap",
+      gap: "4px 12px",
+      boxSizing: "border-box",
+      width: "100%",
+      maxWidth: "var(--dsh-chat-content-width)",
+      margin: "0 auto",
+      padding: "4px calc(var(--dsh-composer-side-clearance, 16px) + 16px) 0",
+      fontSize: "var(--dsh-content-font-size-secondary, 13px)",
+      lineHeight: "calc(20px + var(--dsh-content-font-delta-secondary, 0px))",
+      color: "var(--dsw-alias-label-tertiary, #93a1c0)"
+    };
+    var anchorStyle = { display: "inline-flex", minWidth: 0 };
+    var triggerStyle = {
+      boxSizing: "border-box",
+      display: "inline-flex",
+      alignItems: "center",
+      gap: 6,
+      maxWidth: "100%",
+      padding: "1px 8px",
+      border: "none",
+      borderRadius: 24,
+      background: "transparent",
+      color: "inherit",
+      font: "inherit",
+      fontVariantNumeric: "tabular-nums",
+      lineHeight: "inherit",
+      whiteSpace: "nowrap",
+      cursor: "pointer"
+    };
+    var labelStyle = { minWidth: 0, overflow: "hidden", textOverflow: "ellipsis" };
+    var glyphStyle = { flex: "none", width: 14, height: 14 };
+    var dialogPanelStyle = {
+      position: "fixed",
+      zIndex: 1100,
+      boxSizing: "border-box",
+      transform: "translateX(-50%)",
+      width: "max-content",
+      minWidth: "min(300px, 100vw - 24px)",
+      maxWidth: "min(440px, 100vw - 24px)",
+      background: "var(--dsw-specific-menu)",
+      boxShadow: "var(--dsw-elevation-prominent)",
+      color: "var(--dsw-alias-label-secondary)",
+      border: 0,
+      borderRadius: 12,
+      padding: 16,
+      fontSize: 12,
+      lineHeight: "18px"
+    };
+    var dialogTitleStyle = {
+      display: "flex",
+      alignItems: "center",
+      gap: 6,
+      color: "var(--dsw-alias-label-primary)",
+      marginBottom: 8,
+      fontWeight: 500
+    };
+    var dialogRuleStyle = { borderTop: ".5px solid var(--dsw-alias-border-l2)", marginBottom: 10 };
+    var listStyle = {
+      listStyle: "none",
+      margin: 0,
+      padding: 0,
+      display: "flex",
+      flexDirection: "column",
+      gap: 6,
+      maxHeight: 240,
+      overflowY: "auto"
+    };
+    var rowStyle3 = { display: "flex", alignItems: "center", gap: 8, minWidth: 0 };
+    var rowBadgeStyle = { flex: "none", color: "var(--dsw-alias-label-tertiary)", fontVariantNumeric: "tabular-nums" };
+    var rowProviderStyle = {
+      flex: 1,
+      minWidth: 0,
+      overflow: "hidden",
+      textOverflow: "ellipsis",
+      whiteSpace: "nowrap",
+      color: "var(--dsw-alias-label-primary)"
+    };
+    var rowMetaStyle = { flex: "none", color: "var(--dsw-alias-label-tertiary)", fontVariantNumeric: "tabular-nums" };
+    var cancelButtonStyle = {
+      flex: "none",
+      border: "none",
+      background: "transparent",
+      color: "var(--dsw-alias-label-tertiary)",
+      borderRadius: 6,
+      padding: "2px 8px",
+      font: "inherit",
+      cursor: "pointer"
+    };
+    function QueueGlyph() {
+      return import_react3.default.createElement(
+        "svg",
+        { width: 14, height: 14, viewBox: "0 0 16 16", fill: "none", "aria-hidden": true, style: glyphStyle },
+        import_react3.default.createElement("circle", { cx: 8, cy: 8, r: 6, stroke: "currentColor", strokeWidth: 1.25 }),
+        import_react3.default.createElement("path", {
+          d: "M8 4.6V8.4L10.6 10",
+          stroke: "currentColor",
+          strokeWidth: 1.25,
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        })
+      );
+    }
+    function CoolingGlyph() {
+      return import_react3.default.createElement(
+        "svg",
+        { width: 14, height: 14, viewBox: "0 0 16 16", fill: "none", "aria-hidden": true, style: glyphStyle },
+        import_react3.default.createElement("path", {
+          d: "M8 1.5V14.5M2.4 4.75L13.6 11.25M13.6 4.75L2.4 11.25",
+          stroke: "currentColor",
+          strokeWidth: 1.25,
+          strokeLinecap: "round"
+        })
+      );
+    }
+    function DockPill(props) {
+      const { icon, label, title, children } = props;
+      const [open, setOpen] = import_react3.default.useState(false);
+      const [pos, setPos] = import_react3.default.useState(void 0);
+      const rootRef = import_react3.default.useRef(null);
+      const panelRef = import_react3.default.useRef(null);
+      import_react3.default.useEffect(() => {
+        if (!open) {
+          setPos(void 0);
+          return;
+        }
+        const anchor = rootRef.current;
+        if (anchor === null) return;
+        const rect = anchor.getBoundingClientRect();
+        setPos({ left: rect.left + rect.width / 2, bottom: window.innerHeight - rect.top + 8 });
+      }, [open]);
+      import_react3.default.useEffect(() => {
+        if (!open) return;
+        const onPointerDown = (event) => {
+          const target = event.target;
+          if (target !== null) {
+            if (rootRef.current !== null && rootRef.current.contains(target)) return;
+            if (panelRef.current !== null && panelRef.current.contains(target)) return;
+          }
+          setOpen(false);
+        };
+        const onKeyDown = (event) => {
+          if (event.key === "Escape") setOpen(false);
+        };
+        document.addEventListener("mousedown", onPointerDown, true);
+        document.addEventListener("keydown", onKeyDown);
+        return () => {
+          document.removeEventListener("mousedown", onPointerDown, true);
+          document.removeEventListener("keydown", onKeyDown);
+        };
+      }, [open]);
+      const trigger = import_react3.default.createElement(
+        "span",
+        { ref: rootRef, style: anchorStyle },
+        import_react3.default.createElement(
+          "button",
+          {
+            type: "button",
+            className: DOCK_PILL_CLASS,
+            style: triggerStyle,
+            "aria-haspopup": "dialog",
+            "aria-expanded": open,
+            "aria-label": label,
+            title: label,
+            onClick: () => setOpen(!open)
+          },
+          icon,
+          import_react3.default.createElement("span", { style: labelStyle }, label)
+        )
+      );
+      const dialog = open ? (0, import_react_dom.createPortal)(
+        import_react3.default.createElement(
+          "div",
+          {
+            ref: panelRef,
+            className: "dsh-llm-ctl-queue-dialog",
+            role: "dialog",
+            "aria-label": title,
+            style: pos === void 0 ? { ...dialogPanelStyle, visibility: "hidden" } : { ...dialogPanelStyle, ...pos }
+          },
+          import_react3.default.createElement("div", { style: dialogTitleStyle }, icon, title),
+          import_react3.default.createElement("div", { style: dialogRuleStyle, "aria-hidden": true }),
+          children
+        ),
+        document.body
+      ) : null;
+      return import_react3.default.createElement(import_react3.default.Fragment, null, trigger, dialog);
+    }
+    function QueuePill(props) {
+      const { waiters, onCancel } = props;
+      const first = waiters[0];
+      const label = first === void 0 ? "\u6392\u961F " + waiters.length : "\u6392\u961F " + waiters.length + " \xB7 ~" + formatMs(first.etaMs);
+      return import_react3.default.createElement(
+        DockPill,
+        { icon: QueueGlyph(), label, title: "\u961F\u5217\u72B6\u51B5" },
+        import_react3.default.createElement(QueueDetails, { waiters, onCancel })
+      );
+    }
+    function QueueDetails(props) {
+      const { waiters, onCancel } = props;
+      return import_react3.default.createElement(
+        "ul",
+        { style: listStyle },
+        waiters.map(
+          (waiter) => import_react3.default.createElement(
+            "li",
+            { key: waiter.queueId, style: rowStyle3 },
+            import_react3.default.createElement("span", { style: rowBadgeStyle }, "#" + waiter.position),
+            import_react3.default.createElement("span", { style: rowProviderStyle }, waiter.provider),
+            import_react3.default.createElement(
+              "span",
+              { style: rowMetaStyle },
+              (waiter.origin === "background" ? "\u540E\u53F0" : "\u5BF9\u8BDD") + " \xB7 " + formatMs(waiter.etaMs)
+            ),
+            import_react3.default.createElement(
+              "button",
+              {
+                type: "button",
+                className: DOCK_CANCEL_CLASS,
+                style: cancelButtonStyle,
+                onClick: () => onCancel(waiter.queueId)
+              },
+              "\u53D6\u6D88"
+            )
+          )
+        )
+      );
+    }
+    function CoolingPill(props) {
+      const { lanes } = props;
+      const longest = lanes.reduce((max, lane) => Math.max(max, lane.cooldownRemainingMs), 0);
+      return import_react3.default.createElement(
+        DockPill,
+        { icon: CoolingGlyph(), label: "\u51B7\u5374 " + lanes.length + " \xB7 \u6700\u957F " + formatMs(longest), title: "\u51B7\u5374\u4E2D\u7684 provider" },
+        import_react3.default.createElement(CoolingDetails, { lanes })
+      );
+    }
+    function CoolingDetails(props) {
+      const { lanes } = props;
+      return import_react3.default.createElement(
+        "ul",
+        { style: listStyle },
+        lanes.map(
+          (lane) => import_react3.default.createElement(
+            "li",
+            { key: lane.provider, style: rowStyle3 },
+            import_react3.default.createElement("span", { style: rowProviderStyle }, lane.provider),
+            import_react3.default.createElement("span", { style: rowMetaStyle }, formatMs(lane.cooldownRemainingMs))
+          )
+        )
+      );
+    }
+    function QueueDockPanel(props) {
+      const { view, onCancel } = props;
+      const children = [];
+      if (view.waiters.length > 0) {
+        children.push(import_react3.default.createElement(QueuePill, { key: "queue", waiters: view.waiters, onCancel }));
+      }
+      if (view.cooling.length > 0) {
+        children.push(import_react3.default.createElement(CoolingPill, { key: "cooling", lanes: view.cooling }));
+      }
+      return import_react3.default.createElement("div", { style: panelStyle, role: "status", "aria-live": "polite" }, children);
+    }
+    
+    // src/client-plugin.ts
+    var inject = ["slots", "remote", "remote.session"];
+    var STATE_URL = "/api/llm-ctl/state";
+    var CANCEL_URL = "/api/llm-ctl/cancel";
+    var DISCOVER_URL = "/api/llm-ctl/discover";
+    var VISIBILITY_URL = "/api/llm-ctl/visibility";
+    var VISIBILITY_RESET_URL = "/api/llm-ctl/visibility/reset";
+    var QUEUE_URL = "/api/llm-ctl/queue";
+    var QUEUE_RESET_URL = "/api/llm-ctl/queue/reset";
+    var POLL_MS = 1e3;
+    var HIDDEN_POLL_MS = 5e3;
+    var MAX_POLL_MS = 3e4;
+    var CATALOG_TTL_MS = 3e4;
+    var SEARCH_ID = "dsh-llm-ctl-search";
+    var ctxRef;
+    var latestState;
+    var catalog;
+    var catalogAt = 0;
+    var catalogRequest;
+    var attached;
+    var searchInput;
+    var query = "";
+    var timer;
+    var fetchFailures = 0;
+    var lastNotifiedSignature;
+    var observer;
+    var syncScheduled = false;
+    var subscribers = /* @__PURE__ */ new Set();
+    function notify() {
+      for (const listener of [...subscribers]) listener();
+    }
+    function useCtlState() {
+      const [, force] = import_react4.default.useState(0);
+      import_react4.default.useEffect(() => {
+        const listener = () => force((value) => value + 1);
+        subscribers.add(listener);
+        return () => {
+          subscribers.delete(listener);
+        };
+      }, []);
+      return { state: latestState, catalog };
+    }
+    function ensureMenuStyles() {
+      if (document.getElementById(`${SEARCH_ID}-style`) !== null) return;
+      const style = document.createElement("style");
+      style.id = `${SEARCH_ID}-style`;
+      style.textContent = `
+        #${SEARCH_ID} {
+          width: calc(100% - 8px);
+          margin: 4px;
+          height: 28px;
+          padding: 0 8px;
+          border: 1px solid var(--dsw-alias-border-inverted, rgba(127, 127, 127, 0.35));
+          border-radius: 6px;
+          background: transparent;
+          color: inherit;
+          font-size: 13px;
+          outline: none;
+        }
+        .dsh-llm-ctl-empty {
+          padding: 12px 8px;
+          display: flex;
+          flex-direction: column;
+          gap: 8px;
+          align-items: flex-start;
+          font-size: 12px;
+          color: var(--dsw-alias-label-secondary, #93a1c0);
+        }
+        .dsh-llm-ctl-empty-action {
+          border: 1px solid var(--dsw-alias-border-inverted, rgba(127, 127, 127, 0.35));
+          background: transparent;
+          color: inherit;
+          border-radius: 6px;
+          padding: 2px 8px;
+          font-size: 12px;
+          cursor: pointer;
+        }
+      `;
+      document.head.appendChild(style);
+    }
+    function ensureDockStyles() {
+      if (document.getElementById("dsh-llm-ctl-dock-style") !== null) return;
+      const style = document.createElement("style");
+      style.id = "dsh-llm-ctl-dock-style";
+      style.textContent = [
+        ".dsh-llm-ctl-dock-pill { background: transparent; border: none; cursor: pointer; }",
+        '.dsh-llm-ctl-dock-pill:hover, .dsh-llm-ctl-dock-pill[aria-expanded="true"] { background: var(--dsw-alias-interactive-bg-hover); color: var(--dsw-alias-label-secondary); }',
+        ".dsh-llm-ctl-dock-pill:focus-visible { outline: 2px solid var(--dsw-alias-label-tertiary); outline-offset: -2px; }",
+        ".dsh-llm-ctl-dock-cancel:hover { background: var(--dsw-alias-interactive-bg-hover); color: var(--dsw-alias-label-secondary); }",
+        ".dsh-llm-ctl-queue-dialog { cursor: default; }"
+      ].join("\n");
+      document.head.appendChild(style);
+    }
+    async function postJson(url, body) {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        credentials: "same-origin",
+        body: JSON.stringify(body)
+      });
+      let parsed;
+      try {
+        parsed = await response.json();
+      } catch {
+        parsed = void 0;
+      }
+      return { ok: response.ok, status: response.status, body: parsed };
+    }
+    async function fetchState() {
+      const response = await fetch(STATE_URL, { headers: { accept: "application/json" }, credentials: "same-origin" });
+      if (!response.ok) throw new Error(`state ${response.status}`);
+      return await response.json();
+    }
+    function refreshCatalog() {
+      if (catalogRequest !== void 0) return catalogRequest;
+      const client = ctxRef;
+      if (client === void 0) return Promise.resolve();
+      catalogRequest = (async () => {
+        try {
+          const result = await client.remote.session.modelCatalog();
+          if (result.ok && result.value !== void 0) {
+            const fresh = result.value;
+            catalogAt = Date.now();
+            if (catalog === void 0 || JSON.stringify(fresh) !== JSON.stringify(catalog)) {
+              catalog = fresh;
+              notify();
+            }
+          }
+        } catch (error) {
+          client.logger?.warn("llm-ctl: model catalog failed", error);
+        } finally {
+          catalogRequest = void 0;
+        }
+      })();
+      return catalogRequest;
+    }
+    function visibilitySettings() {
+      return latestState?.visibility.settings ?? { providers: {}, models: {} };
+    }
+    function hiddenPatterns() {
+      return latestState?.visibility.patterns ?? [];
+    }
+    function nameIndex() {
+      const index = /* @__PURE__ */ new Map();
+      for (const group of catalog?.groups ?? []) {
+        const models = /* @__PURE__ */ new Map();
+        for (const model of group.models) models.set(model.name, { provider: group.id, model: model.id });
+        index.set(group.name, models);
+      }
+      return index;
+    }
+    function providerViews() {
+      const settings = visibilitySettings();
+      const patterns = hiddenPatterns();
+      const entries = (catalog?.groups ?? []).map((group) => ({
+        provider: group.id,
+        displayName: group.name,
+        models: group.models.map((model) => ({ model: model.id, name: model.name }))
+      }));
+      const seen = new Set(entries.map((entry) => entry.provider));
+      for (const declared of latestState?.visibility.configurableProviders ?? []) {
+        if (seen.has(declared.provider)) continue;
+        seen.add(declared.provider);
+        entries.push({ provider: declared.provider, displayName: declared.displayName, models: [] });
+      }
+      return buildProviderViews({ providers: entries, settings, patterns });
+    }
+    var discoveries = /* @__PURE__ */ new Map();
+    async function refreshDiscovery(provider) {
+      const current = discoveries.get(provider);
+      if (current !== void 0 && current.pending) return;
+      discoveries.set(provider, { rows: current?.rows ?? [], pending: true, failed: void 0 });
+      notify();
+      try {
+        const response = await postJson(DISCOVER_URL, { provider });
+        const body = response.body;
+        if (!response.ok) throw new Error("discover " + response.status);
+        if (body !== void 0 && typeof body.error === "string" && body.error.length > 0) {
+          discoveries.set(provider, { rows: current?.rows ?? [], pending: false, failed: body.error });
+        } else {
+          const rows = buildDiscoveredRows({
+            provider,
+            discovered: body?.discovered ?? [],
+            advertisedIds: (catalog?.groups ?? []).find((group) => group.id === provider)?.models.map((model) => model.id) ?? [],
+            settings: visibilitySettings(),
+            patterns: hiddenPatterns()
+          });
+          discoveries.set(provider, { rows, pending: false });
+        }
+      } catch (error) {
+        discoveries.set(provider, {
+          rows: current?.rows ?? [],
+          pending: false,
+          failed: error instanceof Error ? error.message : String(error)
+        });
+      }
+      notify();
+    }
+    function applyToMenu() {
+      const roots = findModelMenu(document);
+      if (roots === void 0) return;
+      attached = roots;
+      if (listModelRows(roots).length === 0) {
+        searchInput?.remove();
+        searchInput = void 0;
+        removeEmptyState(roots);
+        return;
+      }
+      const index = nameIndex();
+      const settings = visibilitySettings();
+      const config = { hiddenPatterns: hiddenPatterns() };
+      const isRowVisible = (row) => {
+        const ids = index.get(row.providerName)?.get(row.modelName);
+        if (ids === void 0) return true;
+        return isModelVisible(ids.provider, ids.model, settings, config);
+      };
+      if (hasForeignSearchWidget(roots)) {
+        applyVisibilityOnly(roots, isRowVisible);
+        return;
+      }
+      const result = applyMenuFilter(roots, { query, isRowVisible });
+      const sibling = roots.groups.previousElementSibling;
+      const hasEmptyState = sibling !== null && sibling.nodeType === 1 && sibling.id === "dsh-llm-ctl-empty";
+      if (result.shown === 0) {
+        if (!hasEmptyState) {
+          ensureEmptyState(roots, "\u65E0\u53EF\u89C1\u6A21\u578B", "\u663E\u793A\u5168\u90E8\u9690\u85CF\u9879", () => {
+            void resetAllVisibility();
+          });
+        }
+      } else if (hasEmptyState) {
+        removeEmptyState(roots);
+      }
+    }
+    function ensureSearchBox(roots) {
+      if (listModelRows(roots).length === 0) return;
+      if (hasForeignSearchWidget(roots)) {
+        searchInput?.remove();
+        searchInput = void 0;
+        return;
+      }
+      if (searchInput !== void 0) {
+        let sibling = roots.groups.previousElementSibling;
+        while (sibling !== null) {
+          if (sibling === searchInput) {
+            if (!document.body.contains(searchInput)) break;
+            return;
+          }
+          sibling = sibling.previousElementSibling;
+        }
+        searchInput.remove();
+        searchInput = void 0;
+      }
+      const input = document.createElement("input");
+      input.id = SEARCH_ID;
+      input.type = "search";
+      input.name = "dsh-llm-ctl-model-search";
+      input.setAttribute("aria-label", "\u641C\u7D22\u6A21\u578B");
+      input.placeholder = "\u641C\u7D22\u6A21\u578B\u2026 (Ctrl+F) \xB7 p: \u9650\u5B9A\u63D0\u4F9B\u65B9";
+      input.value = query;
+      input.addEventListener("input", (event) => {
+        event.stopPropagation();
+        query = input.value;
+        applyToMenu();
+      });
+      input.addEventListener("keydown", (event) => {
+        event.stopPropagation();
+        if (event.key === "Escape") {
+          input.value = "";
+          query = "";
+          applyToMenu();
+        }
+      });
+      roots.groups.parentNode?.insertBefore(input, roots.groups);
+      searchInput = input;
+    }
+    function detachMenu() {
+      if (attached !== void 0) resetMenuFilter(attached);
+      if (attached !== void 0) removeEmptyState(attached);
+      attached = void 0;
+      searchInput?.remove();
+      searchInput = void 0;
+    }
+    function scheduleSync() {
+      if (syncScheduled) return;
+      syncScheduled = true;
+      setTimeout(() => {
+        syncScheduled = false;
+        syncMenu();
+      }, 50);
+    }
+    function syncMenu() {
+      const roots = findModelMenu(document);
+      if (roots === void 0) {
+        if (attached !== void 0) detachMenu();
+        return;
+      }
+      if (attached !== void 0 && attached.menu === roots.menu) {
+        ensureSearchBox(roots);
+        applyToMenu();
+        return;
+      }
+      detachMenu();
+      attached = roots;
+      ensureSearchBox(roots);
+      applyToMenu();
+    }
+    async function writeVisibility(input) {
+      try {
+        await postJson(VISIBILITY_URL, input);
+      } catch (error) {
+        ctxRef?.logger?.warn("llm-ctl: visibility write failed", error);
+      }
+      await tick();
+      applyToMenu();
+    }
+    async function resetAllVisibility() {
+      try {
+        await postJson(VISIBILITY_RESET_URL, {});
+      } catch (error) {
+        ctxRef?.logger?.warn("llm-ctl: visibility reset failed", error);
+      }
+      await tick();
+      applyToMenu();
+    }
+    async function writeQueue(input) {
+      try {
+        const response = await postJson(QUEUE_URL, input);
+        const body = response.body;
+        const error = typeof body?.error === "string" && body.error.length > 0 ? body.error : void 0;
+        if (!response.ok) return { ok: false, ...error === void 0 ? {} : { error } };
+        return { ok: true };
+      } catch (error) {
+        ctxRef?.logger?.warn("llm-ctl: queue write failed", error);
+        return { ok: false };
+      } finally {
+        await tick();
+        applyToMenu();
+      }
+    }
+    async function resetQueue(expectedRevision) {
+      let ok = true;
+      try {
+        ok = (await postJson(QUEUE_RESET_URL, { ...expectedRevision === void 0 ? {} : { expectedRevision } })).ok;
+      } catch (error) {
+        ctxRef?.logger?.warn("llm-ctl: queue reset failed", error);
+        ok = false;
+      }
+      await tick();
+      applyToMenu();
+      return ok;
+    }
+    function FooterSeat() {
+      const { state } = useCtlState();
+      if (state === void 0) return null;
+      const views = providerViews();
+      const cooling = state.queue.lanes.filter((lane) => lane.cooldownRemainingMs > 0).length;
+      const element = VisibilityFooter({
+        summary: summarize(views),
+        queue: { queued: state.queue.waiters.length, cooling },
+        actions: {
+          setProvider: (provider, visible) => void writeVisibility({ provider, visible }),
+          setModel: (provider, model, visible) => void writeVisibility({ provider, model, visible }),
+          resetAll: () => void resetAllVisibility()
+        }
+      });
+      return element;
+    }
+    function PluginConfigSeat() {
+      const { state } = useCtlState();
+      if (state === void 0) return null;
+      const views = providerViews();
+      const element = PluginConfigCard({
+        config: state.queueConfig,
+        providers: views.map((view) => ({ provider: view.provider, displayName: view.displayName })),
+        actions: {
+          setQueue: (input) => writeQueue(input),
+          resetQueue: (revision) => resetQueue(revision)
+        }
+      });
+      return element;
+    }
+    function resolveSeatProvider(owner, fallbackProviderId) {
+      const dispatched = owner?.provider?.provider;
+      return typeof dispatched === "string" && dispatched.length > 0 ? dispatched : fallbackProviderId;
+    }
+    function makeProviderCardSeat(fallbackProviderId) {
+      return function ProviderCardSeat(props) {
+        const { state } = useCtlState();
+        if (state === void 0) return null;
+        const rowProvider = resolveSeatProvider(props, fallbackProviderId);
+        const settings = visibilitySettings();
+        const patterns = hiddenPatterns();
+        const view = providerViews().find((candidate) => candidate.provider === rowProvider) ?? {
+          provider: rowProvider,
+          displayName: typeof props.provider?.displayName === "string" && props.provider.displayName.length > 0 ? props.provider.displayName : rowProvider,
+          visible: isProviderVisible(rowProvider, settings, { hiddenPatterns: patterns }),
+          models: []
+        };
+        const discovery = discoveries.get(rowProvider) ?? { rows: [], pending: false };
+        const actions = {
+          setProvider: (provider, visible) => void writeVisibility({ provider, visible }),
+          setModel: (provider, model, visible) => void writeVisibility({ provider, model, visible }),
+          resetAll: () => void resetAllVisibility()
+        };
+        const showEntryRefresh = discovery.rows.length === 0 && !discovery.pending && discovery.failed === void 0;
+        const element = import_react4.default.createElement(
+          import_react4.default.Fragment,
+          null,
+          ProviderVisibilityCard({ view, actions }),
+          showEntryRefresh ? RefreshModelsButton({ pending: false, onRefresh: () => void refreshDiscovery(rowProvider) }) : null,
+          DiscoveredModelsList({
+            provider: rowProvider,
+            rows: discovery.rows,
+            pending: discovery.pending,
+            failed: discovery.failed,
+            onToggle: (provider, model, visible) => void writeVisibility({ provider, model, visible }),
+            onRefresh: () => void refreshDiscovery(rowProvider)
+          })
+        );
+        return element;
+      };
+    }
+    function QueueDockSeat() {
+      const { state } = useCtlState();
+      if (state === void 0) return null;
+      const view = buildQueueDockView(state.queue);
+      if (view === void 0) return null;
+      return QueueDockPanel({ view, onCancel: (queueId) => void postJson(CANCEL_URL, { queueId }) });
+    }
+    function registerSeats(client) {
+      const slots = client.slots;
+      if (slots === void 0) return;
+      slots.inject(
+        "settings.plugin.item",
+        () => slots.register({ name: "settings.plugin.item", key: "llm-ctl", order: 100 }, PluginConfigSeat)
+      );
+      slots.inject(
+        "settings.models.footer",
+        () => slots.register({ name: "settings.models.footer", id: "llm-ctl-visibility", order: 100 }, FooterSeat)
+      );
+      slots.inject(
+        "conversation.composer.dock",
+        () => slots.register({ name: "conversation.composer.dock", id: "llm-ctl-queue", order: 1e3 }, QueueDockSeat)
+      );
+    }
+    var providerSeatsRegistered = false;
+    function ensureProviderSeats(client) {
+      if (providerSeatsRegistered) return;
+      const providers = latestState?.visibility.configurableProviders;
+      if (providers === void 0 || providers.length === 0) return;
+      const slots = client.slots;
+      if (slots === void 0) return;
+      providerSeatsRegistered = true;
+      const seen = /* @__PURE__ */ new Set();
+      for (const entry of providers) {
+        if (typeof entry.settingsNs !== "string" || entry.settingsNs.length === 0) continue;
+        if (seen.has(entry.settingsNs)) continue;
+        seen.add(entry.settingsNs);
+        slots.inject(
+          "settings.models.provider-card",
+          () => slots.register({ name: "settings.models.provider-card", key: entry.settingsNs }, makeProviderCardSeat(entry.provider))
+        );
+      }
+    }
+    function pollDelayForFailures(failures) {
+      if (failures <= 0) return POLL_MS;
+      return Math.min(POLL_MS * 2 ** failures, MAX_POLL_MS);
+    }
+    function stateSignature(state) {
+      return JSON.stringify([state.queue, state.visibility, state.reactive, state.queueConfig]);
+    }
+    function scheduleNext() {
+      timer = setTimeout(() => void loop(), pollDelayForFailures(fetchFailures));
+    }
+    async function loop() {
+      timer = void 0;
+      if (typeof document !== "undefined" && document.hidden) {
+        timer = setTimeout(() => void loop(), HIDDEN_POLL_MS);
+        return;
+      }
+      await tick();
+      if (ctxRef === void 0) return;
+      scheduleNext();
+    }
+    async function tick() {
+      try {
+        latestState = await fetchState();
+        fetchFailures = 0;
+        const signature = stateSignature(latestState);
+        if (signature !== lastNotifiedSignature) {
+          lastNotifiedSignature = signature;
+          notify();
+        }
+        if (ctxRef !== void 0) ensureProviderSeats(ctxRef);
+        if (catalog === void 0 || Date.now() - catalogAt > CATALOG_TTL_MS) void refreshCatalog();
+        syncMenu();
+      } catch (error) {
+        fetchFailures += 1;
+        ctxRef?.logger?.warn("llm-ctl: state fetch failed", error);
+      }
+    }
+    function apply(ctx) {
+      ctxRef = ctx;
+      fetchFailures = 0;
+      lastNotifiedSignature = void 0;
+      ensureMenuStyles();
+      ensureDockStyles();
+      registerSeats(ctx);
+      void refreshCatalog();
+      void tick();
+      scheduleNext();
+      observer = new MutationObserver(() => {
+        scheduleSync();
+      });
+      observer.observe(document.body, { childList: true, subtree: true });
+      ctx.effect?.(() => () => {
+        if (timer !== void 0) clearTimeout(timer);
+        timer = void 0;
+        observer?.disconnect();
+        observer = void 0;
+        detachMenu();
+        subscribers.clear();
+        ctxRef = void 0;
+      }, "llm-ctl: stop polling and menu observation");
+    }
+    
+    return module.exports;
+  }
+});