cortico-provider-deepseek 0.1.3

package/dist/console.js

@@ -0,0 +1,1234 @@
+// ../../Cortico/src/web/shared/console-protocol.ts
+var CONSOLE_LANGUAGE_HEADER = "x-cortico-language";
+var CONSOLE_AUTH_HEADER = "x-cortico-auth";
+var CONTROL_CHARS_RE = new RegExp(`[${String.fromCharCode(0)}-${String.fromCharCode(31)}${String.fromCharCode(127)}]`);
+
+// ../../Cortico/src/web/shared/client-panel.ts
+var ConsoleInvokeError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "ConsoleInvokeError";
+    this.status = status;
+  }
+};
+
+// ../../Cortico/src/web/shared/path-picker.ts
+var PATH_PICKER_ROUTE = "/api/path-picker";
+
+// ../../Cortico/src/web/client/core/language.ts
+var STORAGE_KEY = "cortico.console.language";
+function readLanguage(doc) {
+  let preference = null;
+  try {
+    preference = doc.defaultView?.localStorage.getItem(STORAGE_KEY) ?? null;
+  } catch {
+  }
+  const language = preference === "zh" || preference === "en" ? preference : doc.documentElement.lang.toLowerCase().startsWith("en") ? "en" : "zh";
+  doc.documentElement.lang = language === "zh" ? "zh-CN" : "en";
+  return language;
+}
+function readStamp() {
+  try {
+    return readLanguage(document);
+  } catch {
+    return "zh";
+  }
+}
+var LANGUAGE = readStamp();
+function pick(table) {
+  return LANGUAGE === "en" ? table.en : table.zh;
+}
+function languageHeaders() {
+  return { [CONSOLE_LANGUAGE_HEADER]: LANGUAGE };
+}
+
+// ../../Cortico/src/web/client/core/api.ts
+var zh = {
+  httpStatus: (status, snippet2) => `HTTP ${status}\uFF1A${snippet2}`,
+  notJson: (status, snippet2) => `\u54CD\u5E94\u4E0D\u662F\u5408\u6CD5 JSON\uFF08HTTP ${status}\uFF09\uFF1A${snippet2}`
+};
+var en = {
+  httpStatus: (status, snippet2) => `HTTP ${status}: ${snippet2}`,
+  notJson: (status, snippet2) => `Response is not valid JSON (HTTP ${status}): ${snippet2}`
+};
+var S = pick({ zh, en });
+var SNIPPET_MAX = 200;
+function snippet(text) {
+  const s = text.trim();
+  return s.length > SNIPPET_MAX ? `${s.slice(0, SNIPPET_MAX)}\u2026` : s;
+}
+function isAbortError(err) {
+  return err?.name === "AbortError";
+}
+function normalizeError(err, status) {
+  if (isAbortError(err)) throw err;
+  if (err instanceof ConsoleInvokeError) throw err;
+  throw new ConsoleInvokeError(String(err), status);
+}
+async function send(path, init, opts) {
+  try {
+    const res = await fetch(path, {
+      ...init,
+      headers: { ...languageHeaders(), ...init.headers },
+      ...opts?.signal ? { signal: opts.signal } : {},
+      ...opts?.keepalive ? { keepalive: true } : {}
+    });
+    if (res.status === 401 && res.headers.get(CONSOLE_AUTH_HEADER) !== null) location.reload();
+    return res;
+  } catch (err) {
+    normalizeError(err, 0);
+  }
+}
+async function readText(res) {
+  try {
+    return await res.text();
+  } catch (err) {
+    normalizeError(err, res.status);
+  }
+}
+async function throwHttpError(res) {
+  const text = await readText(res);
+  let message = `HTTP ${res.status}`;
+  try {
+    const parsed = JSON.parse(text);
+    const err = parsed?.error;
+    if (typeof err === "string" && err !== "") message = err;
+  } catch {
+    if (text.trim() !== "") message = S.httpStatus(res.status, snippet(text));
+  }
+  throw new ConsoleInvokeError(message, res.status);
+}
+async function readJson(res) {
+  if (!res.ok) await throwHttpError(res);
+  if (res.status === 204) return null;
+  const text = await readText(res);
+  if (text.trim() === "") return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new ConsoleInvokeError(S.notJson(res.status, snippet(text)), res.status);
+  }
+}
+async function get(path, opts) {
+  return readJson(await send(path, { method: "GET" }, opts));
+}
+async function post(path, body, opts) {
+  const init = {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body ?? {})
+  };
+  return readJson(await send(path, init, opts));
+}
+async function pickPath(options, opts) {
+  const response = await post(PATH_PICKER_ROUTE, options, opts);
+  return response.path;
+}
+
+// ../../Cortico/src/web/client/ui/icons.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var SHAPES = {
+  terminal: [
+    ["path", { d: "m4 17 6-6-6-6" }],
+    ["path", { d: "M12 19h8" }]
+  ],
+  activity: [
+    ["path", { d: "M3 12h4l2-7 4 14 2-7h6" }]
+  ],
+  chart: [
+    ["path", { d: "M4 19V9" }],
+    ["path", { d: "M10 19V5" }],
+    ["path", { d: "M16 19v-7" }],
+    ["path", { d: "M22 19H2" }]
+  ],
+  boxes: [
+    ["path", { d: "m12 2 7 4-7 4-7-4 7-4Z" }],
+    ["path", { d: "m5 10 7 4 7-4" }],
+    ["path", { d: "m5 14 7 4 7-4" }]
+  ],
+  bot: [
+    ["rect", { x: "5", y: "7", width: "14", height: "12", rx: "3" }],
+    ["path", { d: "M12 3v4" }],
+    ["circle", { cx: "9", cy: "13", r: "1" }],
+    ["circle", { cx: "15", cy: "13", r: "1" }]
+  ],
+  settings: [
+    ["circle", { cx: "12", cy: "12", r: "3" }],
+    ["path", { d: "M19.4 15a1.7 1.7 0 0 0 .3 1.9l.1.1-2.8 2.8-.1-.1a1.7 1.7 0 0 0-1.9-.3 1.7 1.7 0 0 0-1 1.5V21h-4v-.1a1.7 1.7 0 0 0-1-1.5 1.7 1.7 0 0 0-1.9.3l-.1.1L4.2 17l.1-.1a1.7 1.7 0 0 0 .3-1.9 1.7 1.7 0 0 0-1.5-1H3v-4h.1a1.7 1.7 0 0 0 1.5-1 1.7 1.7 0 0 0-.3-1.9L4.2 7 7 4.2l.1.1A1.7 1.7 0 0 0 9 4.6a1.7 1.7 0 0 0 1-1.5V3h4v.1a1.7 1.7 0 0 0 1 1.5 1.7 1.7 0 0 0 1.9-.3l.1-.1L19.8 7l-.1.1a1.7 1.7 0 0 0-.3 1.9 1.7 1.7 0 0 0 1.5 1h.1v4h-.1a1.7 1.7 0 0 0-1.5 1Z" }]
+  ],
+  play: [["path", { d: "m8 5 11 7-11 7V5Z" }]],
+  power: [
+    ["path", { d: "M12 3v8" }],
+    ["path", { d: "M17.7 6.3a8 8 0 1 1-11.4 0" }]
+  ],
+  pause: [
+    ["rect", { x: "7", y: "5", width: "3", height: "14", rx: "1" }],
+    ["rect", { x: "14", y: "5", width: "3", height: "14", rx: "1" }]
+  ],
+  image: [
+    ["rect", { x: "3", y: "4", width: "18", height: "16", rx: "3" }],
+    ["circle", { cx: "9", cy: "10", r: "2" }],
+    ["path", { d: "m21 15-4-4L5 20" }]
+  ],
+  "folder-open": [
+    ["path", { d: "M3 6h6l2 2h10" }],
+    ["path", { d: "M3 6v13h15l3-8H6l-3 8" }]
+  ],
+  download: [
+    ["path", { d: "M12 3v12" }],
+    ["path", { d: "m7 10 5 5 5-5" }],
+    ["path", { d: "M5 21h14" }]
+  ],
+  cpu: [
+    ["rect", { x: "5", y: "5", width: "14", height: "14", rx: "2" }],
+    ["rect", { x: "9", y: "9", width: "6", height: "6", rx: "1" }],
+    ["path", { d: "M9 2v3M15 2v3M9 19v3M15 19v3M2 9h3M2 15h3M19 9h3M19 15h3" }]
+  ],
+  text: [
+    ["path", { d: "M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" }],
+    ["path", { d: "M14 2v4a2 2 0 0 0 2 2h4" }],
+    ["path", { d: "M10 9H8M16 13H8M16 17H8" }]
+  ],
+  eye: [
+    ["path", { d: "M2 12s3.5-6 10-6 10 6 10 6-3.5 6-10 6S2 12 2 12Z" }],
+    ["circle", { cx: "12", cy: "12", r: "3" }]
+  ],
+  "eye-off": [
+    ["path", { d: "M3 3l18 18" }],
+    ["path", { d: "M10.6 5.2A10.9 10.9 0 0 1 12 5c6.5 0 10 7 10 7a17.3 17.3 0 0 1-3.2 4" }],
+    ["path", { d: "M6.6 6.6C3.8 8.5 2 12 2 12s3.5 7 10 7c1.6 0 3-.4 4.3-1" }],
+    ["path", { d: "M9.9 9.9a3 3 0 0 0 4.2 4.2" }]
+  ],
+  pencil: [
+    ["path", { d: "M4 20h4.2L19.4 8.8a2.3 2.3 0 0 0-3.2-3.2L5 16.8V20Z" }],
+    ["path", { d: "m12.6 6.5 4.9 4.9" }]
+  ],
+  refresh: [
+    ["path", { d: "M21 12a9 9 0 1 1-2.6-6.4" }],
+    ["path", { d: "M21 3v6h-6" }]
+  ],
+  trash: [
+    ["path", { d: "M4 7h16" }],
+    ["path", { d: "M9.5 7V5h5v2" }],
+    ["path", { d: "M6.5 7v12a2 2 0 0 0 2 2h7a2 2 0 0 0 2-2V7" }],
+    ["path", { d: "M10 11v6" }],
+    ["path", { d: "M14 11v6" }]
+  ]
+};
+function shapesInto(doc, parent, shapes) {
+  for (const [tag, attrs] of shapes) {
+    const child = doc.createElementNS(SVG_NS, tag);
+    for (const [key, value] of Object.entries(attrs)) child.setAttribute(key, value);
+    parent.appendChild(child);
+  }
+}
+function icon(doc, name, cls = "icon") {
+  const svg = doc.createElementNS(SVG_NS, "svg");
+  svg.setAttribute("viewBox", "0 0 24 24");
+  svg.setAttribute("fill", "none");
+  svg.setAttribute("stroke", "currentColor");
+  svg.setAttribute("stroke-width", "1.8");
+  svg.setAttribute("stroke-linecap", "round");
+  svg.setAttribute("stroke-linejoin", "round");
+  svg.setAttribute("aria-hidden", "true");
+  svg.setAttribute("class", cls);
+  shapesInto(doc, svg, SHAPES[name]);
+  return svg;
+}
+
+// ../../Cortico/src/web/client/features/config/strings.ts
+var zh2 = {
+  loading: "\u52A0\u8F7D\u4E2D\u2026",
+  optionCurrent: "(\u5F53\u524D)",
+  ownerPersona: "Persona",
+  chooseFile: "\u9009\u62E9\u6587\u4EF6",
+  chooseDirectory: "\u9009\u62E9\u76EE\u5F55",
+  recommendedDir: (dir) => `\u63A8\u8350\u76EE\u5F55\uFF1A${dir}`,
+  download: "\u4E0B\u8F7D",
+  on: "\u5F00\u542F",
+  leaveBlank: "\u7559\u7A7A",
+  saving: "\u4FDD\u5B58\u4E2D\u2026",
+  saveFailed: (err) => "\u5931\u8D25: " + err,
+  emptyDefault: "\u6B64\u9875\u6CA1\u6709\u914D\u7F6E\u9879\u3002",
+  noSchema: "\u672A\u63D0\u4F9B\u914D\u7F6E\u9879\u3002",
+  restartWorld: "\u91CD\u542F World \u751F\u6548",
+  restartProcess: "\u91CD\u542F\u751F\u6548",
+  loadFailed: (err) => "\u914D\u7F6E\u9879\u52A0\u8F7D\u5931\u8D25: " + err
+};
+var en2 = {
+  loading: "Loading\u2026",
+  optionCurrent: "(current)",
+  ownerPersona: "Persona",
+  chooseFile: "Choose file",
+  chooseDirectory: "Choose directory",
+  recommendedDir: (dir) => `Recommended directory: ${dir}`,
+  download: "Download",
+  on: "On",
+  leaveBlank: "Leave blank",
+  saving: "Saving\u2026",
+  saveFailed: (err) => "Failed: " + err,
+  emptyDefault: "No configuration fields on this page.",
+  noSchema: "No configuration fields provided.",
+  restartWorld: "takes effect after World restart",
+  restartProcess: "takes effect after restart",
+  loadFailed: (err) => "Failed to load config: " + err
+};
+var S2 = pick({ zh: zh2, en: en2 });
+
+// ../../Cortico/src/web/client/features/config/view.ts
+function mergeOptionList(live, current) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (value, label) => {
+    if (seen.has(value)) return;
+    seen.add(value);
+    out.push({ value, label });
+  };
+  for (const item of live) add(item.value, item.label);
+  if (!seen.has(current)) add(current, current || S2.optionCurrent);
+  return out;
+}
+function fillSelect(ui, sel, items, current) {
+  sel.replaceChildren();
+  for (const item of items) {
+    const opt = ui.h("option", null, item.label);
+    opt.value = item.value;
+    sel.appendChild(opt);
+  }
+  sel.value = current;
+}
+var OWNER_LABEL = {
+  "persona": S2.ownerPersona
+};
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function isAbort(err) {
+  return err?.name === "AbortError";
+}
+function optionsField(ui, kind, current, onChange, signal) {
+  const sel = ui.select({
+    options: mergeOptionList([], current),
+    value: current,
+    onChange
+  });
+  let seq = 0;
+  const refresh = () => {
+    const n = ++seq;
+    void get(
+      `/api/config/options/${encodeURIComponent(kind)}`,
+      signal ? { signal } : void 0
+    ).then((d) => {
+      if (n !== seq || signal?.aborted) return;
+      const live = Array.isArray(d.options) ? d.options : [];
+      fillSelect(ui, sel, mergeOptionList(live, sel.value), sel.value);
+    }).catch((err) => {
+      if (isAbort(err) || signal?.aborted) return;
+    });
+  };
+  const listenOpts = signal ? { signal } : void 0;
+  sel.addEventListener("pointerdown", refresh, listenOpts);
+  sel.addEventListener("focus", refresh, listenOpts);
+  refresh();
+  return { node: sel, read: () => sel.value };
+}
+function httpDownloadHref(raw) {
+  try {
+    const url = new URL(raw);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.href : null;
+  } catch {
+    return null;
+  }
+}
+function pathField(ui, prop, current, onChange, signal) {
+  const spec = prop["x-path"];
+  const input = ui.input({ type: "text", value: current, onChange });
+  const controls = ui.h("div", "pathfield-controls");
+  const choose = ui.button("", {
+    size: "sm",
+    onClick: () => {
+      choose.disabled = true;
+      void pickPath({
+        kind: spec.kind,
+        title: prop.title,
+        currentPath: input.value.trim() || void 0,
+        recommendedDir: spec.recommendedDir,
+        extensions: spec.extensions
+      }, signal ? { signal } : void 0).then((selected) => {
+        if (!selected || signal?.aborted) return;
+        input.value = selected;
+        onChange();
+      }).catch((err) => {
+        if (isAbort(err) || signal?.aborted) return;
+        ui.toast(errText(err), "bad");
+      }).finally(() => {
+        choose.disabled = false;
+      });
+    }
+  });
+  choose.className += " pathpick";
+  choose.title = spec.kind === "file" ? S2.chooseFile : S2.chooseDirectory;
+  choose.setAttribute("aria-label", choose.title);
+  choose.appendChild(icon(choose.ownerDocument, "folder-open"));
+  controls.append(input, choose);
+  const field = ui.h("div", "pathfield");
+  field.appendChild(controls);
+  const meta = ui.h("div", "pathfield-meta");
+  if (spec.recommendedDir) {
+    const recommended = ui.h("span", "pathrecommended", S2.recommendedDir(spec.recommendedDir));
+    recommended.title = spec.recommendedDir;
+    meta.appendChild(recommended);
+  }
+  const download = prop["x-download"];
+  const href = download ? httpDownloadHref(download.href) : null;
+  if (download && href) {
+    const link = ui.h("a", "pathdownload");
+    link.setAttribute("href", href);
+    link.setAttribute("target", "_blank");
+    link.setAttribute("rel", "noopener noreferrer");
+    link.append(icon(link.ownerDocument, "download"), ui.h("span", null, download.label || S2.download));
+    meta.appendChild(link);
+  }
+  if (meta.children.length) field.appendChild(meta);
+  return { node: field, read: () => input.value };
+}
+function configField(ui, prop, val, onChange, signal) {
+  const changed = () => onChange?.();
+  if (prop.type === "boolean") {
+    const box = ui.checkbox(S2.on, { checked: !!val, onChange: changed });
+    return { node: box.el, read: () => box.checked };
+  }
+  if (prop.type === "string") {
+    if (prop["x-options"]) {
+      return optionsField(ui, prop["x-options"], val == null ? "" : String(val), changed, signal);
+    }
+    if (Array.isArray(prop.enum)) {
+      const sel = ui.select({
+        options: prop.enum,
+        value: val == null ? prop.enum[0] : String(val),
+        onChange: changed
+      });
+      return { node: sel, read: () => sel.value };
+    }
+    if (prop["x-path"]) {
+      return pathField(ui, prop, val == null ? "" : String(val), changed, signal);
+    }
+    const inp = ui.input({ type: "text", value: val == null ? "" : String(val), onChange: changed });
+    return { node: inp, read: () => inp.value };
+  }
+  if (prop.type === "integer" || prop.type === "number") {
+    const scale = prop["x-scale"] || 1;
+    const inp = ui.input({ type: "number", onChange: changed });
+    if (prop.minimum != null) inp.min = String(prop.minimum / scale);
+    if (prop.maximum != null) inp.max = String(prop.maximum / scale);
+    if (prop.multipleOf != null) inp.step = String(prop.multipleOf / scale);
+    if (prop.nullable) {
+      inp.value = val == null ? "" : String(Number(val) / scale);
+      inp.placeholder = S2.leaveBlank;
+      return {
+        node: inp,
+        read: () => inp.value.trim() === "" ? null : Number(inp.value) * scale
+      };
+    }
+    inp.value = String((Number(val) || 0) / scale);
+    return { node: inp, read: () => Number(inp.value) * scale };
+  }
+  const itemType = prop.items?.type;
+  if (prop.type === "array" && (itemType === "integer" || itemType === "number")) {
+    const scale = prop["x-scale"] || 1;
+    const spec = prop.items || {};
+    const mk = (v) => {
+      const inp = ui.input({ type: "number", value: String((Number(v) || 0) / scale), onChange: changed });
+      if (spec.minimum != null) inp.min = String(spec.minimum / scale);
+      if (spec.maximum != null) inp.max = String(spec.maximum / scale);
+      return inp;
+    };
+    const pair = Array.isArray(val) ? val : [0, 0];
+    const a = mk(pair[0]);
+    const b = mk(pair[1]);
+    const wrap = ui.h("div", "pairfield");
+    wrap.append(a, ui.h("span", "pairsep", "\u2013"), b);
+    return {
+      node: wrap,
+      read: () => [Number(a.value) * scale, Number(b.value) * scale]
+    };
+  }
+  return { node: ui.h("span", "tdesc", JSON.stringify(val)), read: null };
+}
+
+// ../../Cortico/src/providers/openai-responses-compat/strings.ts
+var panelZh = {
+  title: "\u601D\u7EF4\u94FE",
+  encrypted: "\u52A0\u5BC6",
+  plaintext: "\u660E\u6587",
+  detect: "\u6211\u4E0D\u77E5\u9053,\u6D4B\u4E00\u4E0B",
+  detecting: "\u63A2\u6D4B\u4E2D",
+  saved: "\u5DF2\u4FDD\u5B58",
+  accepted: "\u901A\u8FC7",
+  rejected: (status, error) => `\u88AB\u62D2${status ? ` ${status}` : ""}:${error}`,
+  skipped: "\u672A\u6D4B",
+  outcome: (bare, withReasoning) => `\u4E0D\u5E26\u601D\u7EF4\u94FE\u7684\u5408\u6210\u8C03\u7528:${bare};\u5E26\u660E\u6587\u601D\u7EF4\u94FE:${withReasoning}`,
+  applied: (label) => `\u5DF2\u8BBE\u4E3A${label}`,
+  undetermined: "\u5224\u65AD\u4E0D\u51FA,\u8BBE\u7F6E\u672A\u6539"
+};
+var panelEn = {
+  title: "Reasoning",
+  encrypted: "Encrypted",
+  plaintext: "Plaintext",
+  detect: "Not sure, test it",
+  detecting: "Testing",
+  saved: "Saved",
+  accepted: "accepted",
+  rejected: (status, error) => `rejected${status ? ` ${status}` : ""}: ${error}`,
+  skipped: "not tested",
+  outcome: (bare, withReasoning) => `Synthetic call without reasoning: ${bare}; with plaintext reasoning: ${withReasoning}`,
+  applied: (label) => `Set to ${label}`,
+  undetermined: "Undetermined; the setting is unchanged"
+};
+var panel = { zh: panelZh, en: panelEn };
+
+// ../../Cortico/src/providers/openai-responses-compat/console/reasoning-panel.ts
+var reasoningPanel = {
+  mount: async (ctx) => {
+    const { ui, root } = ctx;
+    const S3 = ctx.language === "en" ? panel.en : panel.zh;
+    const name = ctx.scope.instance;
+    const path = `providers.${name}.options.reasoningReplay`;
+    const textPath = `providers.${name}.options.syntheticReasoningText`;
+    const labels = { encrypted: S3.encrypted, plaintext: S3.plaintext };
+    const card = ui.sheet({ title: S3.title });
+    const message = ui.msgline();
+    root.append(card.el, message);
+    const outcome = (probe) => !probe ? S3.skipped : probe.ok ? S3.accepted : S3.rejected(probe.status, probe.error);
+    const describe = (result) => `${S3.outcome(outcome(result.bare), outcome(result.withReasoning))}\u3002${result.verdict ? S3.applied(labels[result.verdict]) : S3.undetermined}`;
+    async function save(groupId, key, value) {
+      try {
+        await ctx.setConfig(groupId, { [key]: value });
+        message.textContent = S3.saved;
+      } catch (error) {
+        message.textContent = String(error);
+      }
+    }
+    async function detect(button) {
+      const release = ui.disable(button);
+      message.textContent = S3.detecting;
+      try {
+        message.textContent = describe(await ctx.invoke("detect", [{ name }]));
+      } catch (error) {
+        message.textContent = String(error);
+      } finally {
+        release.dispose();
+      }
+      await load();
+    }
+    async function load() {
+      let state;
+      try {
+        state = await ctx.invoke("state", [{ name }]);
+      } catch (error) {
+        message.textContent = String(error);
+        return;
+      }
+      if (ctx.signal.aborted) return;
+      const { group, values } = state.config[0];
+      const property = group.schema.properties[path];
+      const current = values[path];
+      const select = ui.select({
+        value: typeof current === "string" && current ? current : "encrypted",
+        options: Object.entries(labels).map(([value, label]) => ({ value, label })),
+        onChange: (value) => void save(group.id, path, value)
+      });
+      select.setAttribute("aria-label", property.title);
+      const button = ui.button(S3.detect, { onClick: () => void detect(button) });
+      const row = ui.rowbar();
+      row.append(select, button);
+      card.body.replaceChildren(ui.field(property.title, row));
+      if (property.description) card.body.append(ui.msgline(property.description));
+      const textProperty = group.schema.properties[textPath];
+      const text = configField(ui, textProperty, values[textPath], () => {
+        if (text.read) void save(group.id, textPath, String(text.read()).trim());
+      }, ctx.signal);
+      text.node.setAttribute("aria-label", textProperty.title);
+      card.body.append(ui.field(textProperty.title, text.node));
+      if (textProperty.description) card.body.append(ui.msgline(textProperty.description));
+    }
+    await load();
+  }
+};
+
+// ../../Cortico/src/providers/openai-responses-compat/console/client.ts
+var client_default = { panels: { reasoning: reasoningPanel } };
+
+// ../../Cortico/src/web/client/console-pages/builtins/llm-settings/strings.ts
+var zh3 = {
+  saved: "\u5DF2\u4FDD\u5B58\uFF0C\u4E0B\u4E00\u6B21\u8BF7\u6C42\u751F\u6548\u3002",
+  instancesTitle: "\u4F9B\u5E94\u5B9E\u4F8B",
+  instancesDescription: "\u6BCF\u4E2A\u5B9E\u4F8B\u72EC\u7ACB\u4FDD\u5B58\u8FDE\u63A5\u3001\u6A21\u578B\u6863\u4E0E\u62A5\u4EF7\u3002\u5F53\u524D\u8BF7\u6C42\u4E0E\u5DF2\u542F\u52A8\u7684\u540E\u53F0\u4F1A\u8BDD\u4FDD\u6301\u539F\u6709\u7ED1\u5B9A\u3002",
+  activeSuffix: " \xB7 \u5F53\u524D",
+  instanceField: "\u4F9B\u5E94\u5B9E\u4F8B",
+  newInstanceName: "\u65B0\u5B9E\u4F8B\u540D\u79F0",
+  newInstanceUrl: "HTTP(S) \u4F9B\u5E94\u5730\u5740",
+  addInstance: "\u6DFB\u52A0\u5B9E\u4F8B",
+  connectionTitle: "\u8FDE\u63A5",
+  connectionDescription: "\u5730\u5740\u4E0E\u5BC6\u94A5\u5168\u5C40\u5171\u7528\uFF1A\u522B\u7684\u90E8\u7F72\u9009\u4E2D\u540C\u4E00\u5B9E\u4F8B\u65F6\u8BFB\u7684\u662F\u540C\u4E00\u4EFD\u3002",
+  baseUrl: "\u4F9B\u5E94\u5730\u5740",
+  secretName: "\u5BC6\u94A5\u53D8\u91CF\u540D",
+  secretNamePlaceholder: "\u73AF\u5883\u53D8\u91CF\u540D\uFF1B\u7559\u7A7A = \u65E0\u9274\u6743",
+  secretStatus: "\u5BC6\u94A5",
+  secretSource: { env: "\u8FDB\u7A0B\u73AF\u5883", file: "\u7AEF\u70B9 .env", none: "\u672A\u914D\u7F6E" },
+  secretValue: "\u5BC6\u94A5\u503C",
+  secretValuePlaceholder: "\u53EA\u5199\u5165\u7AEF\u70B9 .env\uFF0C\u4E0D\u56DE\u663E",
+  saveSecret: "\u5199\u5165\u5BC6\u94A5",
+  secretSaved: "\u5BC6\u94A5\u5DF2\u5199\u5165\u7AEF\u70B9 .env\u3002",
+  secretNameFirst: "\u5148\u4FDD\u5B58\u5BC6\u94A5\u53D8\u91CF\u540D\uFF0C\u518D\u5199\u5165\u5BC6\u94A5\u503C\u3002",
+  multimodal: "\u63A5\u53D7\u56FE\u7247\u8F93\u5165",
+  endpointPath: "\u8BF7\u6C42\u8DEF\u5F84",
+  extraHeaders: "\u9644\u52A0\u8BF7\u6C42\u5934\uFF08JSON \u5BF9\u8C61\uFF09",
+  extraBody: "\u9644\u52A0\u8BF7\u6C42\u4F53\uFF08JSON \u5BF9\u8C61\uFF09",
+  jsonObjectRequired: (label) => `${label} \u5FC5\u987B\u662F JSON \u5BF9\u8C61`,
+  advancedProtocolTitle: "\u534F\u8BAE\u4E0E\u8BF7\u6C42\u6269\u5C55",
+  advancedProtocolDescription: "\u9488\u5BF9 OpenAI Responses \u517C\u5BB9\u7AEF\u70B9\u7684\u9AD8\u7EA7\u914D\u7F6E\uFF08\u7AEF\u70B9\u8DEF\u5F84\u4E0E\u9644\u52A0 JSON \u5B57\u6BB5\uFF09\u3002",
+  modelFieldLabel: "\u6A21\u578B\u6807\u8BC6",
+  effortFieldLabel: "\u63A8\u7406\u5F3A\u5EA6",
+  temperatureFieldLabel: "\u91C7\u6837\u6E29\u5EA6",
+  specTitle: "\u6A21\u578B\u6863",
+  specDescription: "\u914D\u7F6E\u6B64\u5B9E\u4F8B\u8C03\u7528\u7684\u6A21\u578B\u53CA\u63A8\u7406\u3001\u6E29\u5EA6\u548C Token \u9650\u5236\u7B49\u751F\u6210\u53C2\u6570\u3002",
+  modelName: "\u660E\u786E\u6A21\u578B\u540D",
+  fetchModels: "\u53D6\u6A21\u578B\u5217\u8868",
+  modelsFetched: (count) => `\u53D6\u5230 ${count} \u4E2A\u6A21\u578B\u3002`,
+  modelListFailed: (message) => `\u53D6\u4E0D\u5230\u6A21\u578B\u5217\u8868\uFF1A${message}`,
+  selectModel: "\u9009\u62E9\u6A21\u578B",
+  unsupportedTier: (current) => `\u5F53\u524D\u6863\u4F4D\u672A\u652F\u6301\uFF1A${current}`,
+  thinkingOn: "\u5F00\u542F",
+  thinkingOff: "\u5173\u95ED",
+  effortPlaceholder: "\u63A8\u7406\u5F3A\u5EA6\uFF1B\u7A7A = \u7AEF\u70B9\u9ED8\u8BA4\uFF0Cnone = \u5173\u95ED",
+  effortAria: "\u63A8\u7406\u5F3A\u5EA6",
+  temperaturePlaceholder: "\u6E29\u5EA6\u9ED8\u8BA4",
+  modelAria: "\u6A21\u578B",
+  tierAria: "\u63A8\u7406\u6863\u4F4D",
+  temperatureAria: "\u6E29\u5EA6",
+  maxTokens: "\u6700\u5927\u8F93\u51FA token",
+  contextWindow: "\u4E0A\u4E0B\u6587\u7A97\u53E3",
+  serviceTier: "\u670D\u52A1\u6863",
+  serverDefault: "\u670D\u52A1\u7AEF\u9ED8\u8BA4",
+  activate: "\u8BBE\u4E3A\u5F53\u524D\u4F9B\u5E94\u5B9E\u4F8B",
+  probe: "\u6D4B\u8BD5\u53EF\u7528\u6027",
+  probeTitle: "\u6D4B\u8BD5\u7ED3\u679C",
+  probeStatus: "\u72B6\u6001",
+  probeOk: "\u6210\u529F",
+  probeFailed: "\u5931\u8D25",
+  probeLatency: "\u8017\u65F6",
+  probeModel: "\u56DE\u663E\u6A21\u578B",
+  probeUsage: "\u7528\u91CF",
+  probeUsageLine: (input, cached, output, reasoning) => `\u8F93\u5165 ${input} \xB7 \u7F13\u5B58\u547D\u4E2D ${cached} \xB7 \u8F93\u51FA ${output} \xB7 \u63A8\u7406 ${reasoning}`,
+  probeEncrypted: "\u52A0\u5BC6\u601D\u7EF4\u94FE",
+  yes: "\u6709",
+  no: "\u65E0",
+  probeCost: "\u672C\u6B21\u8D39\u7528",
+  duplicate: "\u590D\u5236",
+  duplicateName: "\u526F\u672C\u540D\u79F0",
+  duplicateConfirm: "\u590D\u5236\u4E3A",
+  duplicated: "\u5DF2\u590D\u5236\u3002",
+  delete: "\u5220\u9664",
+  deleteConfirmTitle: (name) => `\u5220\u9664\u5B9E\u4F8B ${name}\uFF1F`,
+  deleteConfirmBody: "\u7AEF\u70B9\u914D\u7F6E\u4E0E .env \u4E00\u5E76\u5220\u9664\u3002\u522B\u7684\u90E8\u7F72\u82E5\u9009\u4E2D\u4E86\u5B83\uFF0C\u65E0\u6CD5\u5728\u6B64\u5F97\u77E5\u3002",
+  deleted: "\u5DF2\u5220\u9664\u3002",
+  pricingTitle: "\u62A5\u4EF7",
+  pricingDescription: "\u5386\u53F2\u6D41\u6C34\u56FA\u5B9A\u4F7F\u7528\u8BF7\u6C42\u65F6\u7684\u62A5\u4EF7\u3002\u81EA\u5B9A\u4E49\u62A5\u4EF7\u6309\u6A21\u578B\u4E0E\u8D39\u7528\u53E3\u5F84\u8986\u76D6\u6A21\u5757\u9ED8\u8BA4\u503C\u3002",
+  pricingUnset: "\u672A\u8BBE\u81EA\u5B9A\u4E49\u62A5\u4EF7\uFF1A\u4F18\u5148\u4F7F\u7528\u6A21\u5757\u4EF7\u76EE\uFF1B\u82E5\u65E0\u9002\u7528\u4EF7\u76EE\uFF0C\u4EC5\u8BB0\u5F55 token\uFF0C\u4E0D\u8BA1\u91D1\u989D\u3002",
+  meters: {
+    input: "\u8F93\u5165",
+    cachedInput: "\u7F13\u5B58\u547D\u4E2D",
+    uncachedInput: "\u672A\u7F13\u5B58\u8F93\u5165",
+    output: "\u8F93\u51FA",
+    reasoning: "\u63A8\u7406",
+    total: "\u603B\u91CF"
+  },
+  marginal: "\u8FB9\u9645\u8D39\u7528",
+  equivalent: "API \u7B49\u4EF7\u8D39\u7528",
+  perMillion: (label, rate) => `${label} ${rate}/\u767E\u4E07`,
+  free: "\u5DF2\u660E\u786E\u514D\u8D39",
+  bandsNote: "\u542B\u8F93\u5165\u9636\u68AF\u6216\u670D\u52A1\u6863\uFF1B\u6309\u672C\u6B21\u5B9E\u9645\u7528\u91CF\u4E0E\u670D\u52A1\u6863\u8BA1\u8D39\u3002",
+  rateCached: "\u7F13\u5B58\u547D\u4E2D / \u767E\u4E07 token",
+  rateUncached: "\u672A\u7F13\u5B58\u8F93\u5165 / \u767E\u4E07 token",
+  rateOutput: "\u8F93\u51FA / \u767E\u4E07 token",
+  currencyField: "\u5E01\u79CD",
+  costFormNote: "\u57FA\u7840\u8D39\u7387\u7EDF\u4E00\u9002\u7528\u4E8E\u5168\u90E8\u6A21\u578B\uFF1B\u9636\u68AF\u6216\u591A\u6A21\u578B\u89C4\u5219\u8BF7\u5728\u4E0B\u65B9\u5B8C\u6574\u89C4\u5219\u4E2D\u914D\u7F6E\u3002",
+  costFormOverridden: "\u5F53\u524D\u62A5\u4EF7\u4E0D\u662F\u4E09\u683C\u8868\u80FD\u8868\u8FBE\u7684\u5F62\u72B6\uFF0C\u4EE5\u4E0B\u65B9\u5B8C\u6574\u89C4\u5219\u4E3A\u51C6\uFF1B\u6539\u52A8\u4E09\u683C\u8868\u4F1A\u8986\u76D6\u5B83\u3002",
+  editFull: "\u9AD8\u7EA7\u5B9A\u4EF7\u89C4\u5219 (JSON)",
+  fullNote: "\u7A7A\u6570\u7EC4\u6062\u590D\u6A21\u5757\u9ED8\u8BA4\u62A5\u4EF7\uFF1Brules \u4E3A\u7A7A\u6570\u7EC4\u8868\u793A\u660E\u786E\u514D\u8D39\u3002\u5B8C\u6574\u89C4\u5219\u652F\u6301\u8F93\u5165\u9636\u68AF\u3001\u670D\u52A1\u6863\u53CA\u989D\u5916\u8BA1\u91CF\u5355\u4F4D\u3002",
+  viewSnapshot: "\u67E5\u770B\u5F53\u524D\u751F\u6548\u62A5\u4EF7\u5FEB\u7167"
+};
+var en3 = {
+  saved: "Saved; applies from the next request.",
+  instancesTitle: "Provider instances",
+  instancesDescription: "Each instance keeps its own connection, model spec and pricing. In-flight requests and running background sessions keep their existing binding.",
+  activeSuffix: " \xB7 active",
+  instanceField: "Provider instance",
+  newInstanceName: "New instance name",
+  newInstanceUrl: "HTTP(S) provider URL",
+  addInstance: "Add instance",
+  connectionTitle: "Connection",
+  connectionDescription: "URL and key are global: other deployments selecting this instance read the same copy.",
+  baseUrl: "Provider URL",
+  secretName: "Key variable name",
+  secretNamePlaceholder: "Environment variable name; empty = no auth",
+  secretStatus: "API key",
+  secretSource: { env: "process env", file: "endpoint .env", none: "not set" },
+  secretValue: "Key value",
+  secretValuePlaceholder: "Written to the endpoint .env only; never shown",
+  saveSecret: "Save key",
+  secretSaved: "Key written to the endpoint .env.",
+  secretNameFirst: "Save the key variable name before writing a key value.",
+  multimodal: "Accepts image input",
+  endpointPath: "Request path",
+  extraHeaders: "Extra headers (JSON object)",
+  extraBody: "Extra body (JSON object)",
+  jsonObjectRequired: (label) => `${label} must be a JSON object`,
+  advancedProtocolTitle: "Protocol & Request Overrides",
+  advancedProtocolDescription: "Advanced options for OpenAI Responses compatible endpoints (custom path and extra JSON fields).",
+  modelFieldLabel: "Model identifier",
+  effortFieldLabel: "Reasoning effort",
+  temperatureFieldLabel: "Sampling temperature",
+  specTitle: "Model",
+  specDescription: "Configure model identifier, reasoning effort, temperature and token limits for this instance.",
+  modelName: "Exact model name",
+  fetchModels: "Fetch models",
+  modelsFetched: (count) => `Fetched ${count} models.`,
+  modelListFailed: (message) => `Could not fetch the model list: ${message}`,
+  selectModel: "Pick a model",
+  unsupportedTier: (current) => `Unsupported current tier: ${current}`,
+  thinkingOn: "on",
+  thinkingOff: "off",
+  effortPlaceholder: "Reasoning effort; empty = endpoint default, none = off",
+  effortAria: "Reasoning effort",
+  temperaturePlaceholder: "Default temperature",
+  modelAria: "Model",
+  tierAria: "Reasoning tier",
+  temperatureAria: "Temperature",
+  maxTokens: "Max output tokens",
+  contextWindow: "Context window",
+  serviceTier: "Service tier",
+  serverDefault: "Server default",
+  activate: "Set as active provider instance",
+  probe: "Test endpoint",
+  probeTitle: "Test result",
+  probeStatus: "Status",
+  probeOk: "ok",
+  probeFailed: "failed",
+  probeLatency: "Latency",
+  probeModel: "Model echoed",
+  probeUsage: "Usage",
+  probeUsageLine: (input, cached, output, reasoning) => `input ${input} \xB7 cached ${cached} \xB7 output ${output} \xB7 reasoning ${reasoning}`,
+  probeEncrypted: "Encrypted reasoning",
+  yes: "yes",
+  no: "no",
+  probeCost: "Cost of this call",
+  duplicate: "Duplicate",
+  duplicateName: "Copy name",
+  duplicateConfirm: "Duplicate as",
+  duplicated: "Duplicated.",
+  delete: "Delete",
+  deleteConfirmTitle: (name) => `Delete instance ${name}?`,
+  deleteConfirmBody: "Removes the endpoint config and its .env. Whether another deployment selects it cannot be known here.",
+  deleted: "Deleted.",
+  pricingTitle: "Pricing",
+  pricingDescription: "Historical records keep the quote in effect at request time. Custom quotes override module defaults per model and cost basis.",
+  pricingUnset: "No custom pricing: module prices apply when available; otherwise only tokens are recorded.",
+  meters: {
+    input: "Input",
+    cachedInput: "Cache hit",
+    uncachedInput: "Uncached input",
+    output: "Output",
+    reasoning: "Reasoning",
+    total: "Total"
+  },
+  marginal: "Marginal cost",
+  equivalent: "API-equivalent cost",
+  perMillion: (label, rate) => `${label} ${rate}/M`,
+  free: "Explicitly free",
+  bandsNote: "Includes input bands or service tiers; billed by actual usage and service tier per request.",
+  rateCached: "Cache hit / M tokens",
+  rateUncached: "Uncached input / M tokens",
+  rateOutput: "Output / M tokens",
+  currencyField: "Currency",
+  costFormNote: "Base rates apply to all models; input bands and service tiers go in the full rules below.",
+  costFormOverridden: "The saved pricing is not a shape the three-rate form can express; the full rules below apply. Editing the form replaces them.",
+  editFull: "Advanced Pricing Rules (JSON)",
+  fullNote: "An empty array restores the module default quote; an empty rules array means explicitly free. Full rules support input bands, service tiers and extra meters.",
+  viewSnapshot: "View active pricing snapshot"
+};
+var panel2 = { zh: zh3, en: en3 };
+
+// ../../Cortico/src/web/client/console-pages/builtins/llm-settings/pricing-panel.ts
+var FORM_METERS = ["cachedInput", "uncachedInput", "output"];
+function readSimple(saved) {
+  if (saved.length !== 1) return null;
+  const definition = saved[0];
+  if (!definition || typeof definition !== "object") return null;
+  const models = definition.models;
+  if (!Array.isArray(models) || models.length !== 1 || models[0] !== "*") return null;
+  if (definition.basis !== "marginal" || typeof definition.currency !== "string") return null;
+  if (definition.inputBands !== void 0 || definition.serviceTiers !== void 0) return null;
+  const rules = definition.rules;
+  if (!Array.isArray(rules) || rules.length !== FORM_METERS.length) return null;
+  const rates = FORM_METERS.map((meter) => {
+    const rule = rules.find((rule2) => rule2.meter === meter);
+    return rule && typeof rule.perMillion === "number" ? rule.perMillion : NaN;
+  });
+  if (rates.some((rate) => Number.isNaN(rate))) return null;
+  return { currency: definition.currency, rates };
+}
+function writeSimple(cost) {
+  return [
+    {
+      models: ["*"],
+      currency: cost.currency,
+      basis: "marginal",
+      source: "console",
+      rules: FORM_METERS.map((meter, i) => ({ meter, perMillion: cost.rates[i] }))
+    }
+  ];
+}
+function pricingEditor(ui, saved, quotes, commit, language, draft) {
+  const S3 = language === "en" ? panel2.en : panel2.zh;
+  const card = ui.sheet({
+    title: S3.pricingTitle,
+    desc: S3.pricingDescription
+  });
+  const labels = S3.meters;
+  for (const row of quotes) {
+    for (const quote of row.quotes) {
+      card.body.append(
+        ui.kv([
+          {
+            k: row.model,
+            v: `${quote.currency} \xB7 ${quote.basis === "marginal" ? S3.marginal : S3.equivalent}`
+          }
+        ]),
+        ui.msgline(
+          quote.rules.length ? quote.rules.map((rule) => S3.perMillion(labels[rule.meter] ?? rule.meter, rule.perMillion)).join(" \xB7 ") : S3.free
+        ),
+        ui.msgline(quote.source)
+      );
+      if (quote.inputBands?.length || quote.serviceTiers)
+        card.body.append(ui.msgline(S3.bandsNote));
+    }
+  }
+  const unset = saved.length === 0;
+  const pricingNote = ui.h("p", "field-note pricing-note");
+  const updateNote = (pricing) => {
+    pricingNote.textContent = pricing.length ? "" : S3.pricingUnset;
+    pricingNote.hidden = pricing.length > 0;
+  };
+  updateNote(saved);
+  card.body.append(pricingNote);
+  const simple = unset ? null : readSimple(saved);
+  const raw = ui.textarea({
+    rows: 10,
+    value: draft?.raw ?? JSON.stringify(simple ? writeSimple(simple) : saved, null, 2),
+    onChange: commitDraft
+  });
+  const currency = ui.input({ value: simple?.currency ?? "USD", onChange: writeThrough });
+  currency.setAttribute("aria-label", S3.currencyField);
+  const problem = ui.msgline();
+  const rateLabels = [S3.rateCached, S3.rateUncached, S3.rateOutput];
+  const rates = rateLabels.map((label, i) => {
+    const input = ui.input({
+      type: "number",
+      value: simple ? String(simple.rates[i]) : "",
+      onChange: writeThrough
+    });
+    input.min = "0";
+    input.step = "any";
+    input.setAttribute("aria-label", label);
+    return input;
+  });
+  function writeThrough() {
+    const blank = rates.every((input) => input.value.trim() === "");
+    raw.value = blank ? "[]" : JSON.stringify(
+      writeSimple({
+        currency: currency.value.trim() || "USD",
+        rates: rates.map((input) => Number(input.value) || 0)
+      }),
+      null,
+      2
+    );
+    commitDraft();
+  }
+  function commitDraft() {
+    try {
+      const pricing = JSON.parse(raw.value.trim() || "[]");
+      if (!Array.isArray(pricing)) throw new Error(S3.pricingTitle + ": JSON array required");
+      problem.textContent = "";
+      problem.classList.remove("bad");
+      raw.setAttribute("aria-invalid", "false");
+      updateNote(pricing);
+      commit(pricing);
+      draft?.onRaw(raw.value);
+      return true;
+    } catch (error) {
+      problem.textContent = String(error);
+      problem.classList.add("bad");
+      raw.setAttribute("aria-invalid", "true");
+      draft?.onRaw(raw.value);
+      return false;
+    }
+  }
+  card.body.append(
+    ui.field(S3.currencyField, currency),
+    ...rates.map((input, i) => ui.field(rateLabels[i], input)),
+    ui.msgline(simple || unset ? S3.costFormNote : S3.costFormOverridden)
+  );
+  const advanced = ui.h("details", "pricing-rules");
+  advanced.open = !simple && !unset;
+  advanced.append(ui.h("summary", null, S3.editFull), raw, ui.msgline(S3.fullNote), problem);
+  const preview = ui.h("details", "pricing-snapshot");
+  preview.append(
+    ui.h("summary", null, S3.viewSnapshot),
+    ui.h("pre", "mono", JSON.stringify(quotes, null, 2))
+  );
+  card.body.append(advanced, preview);
+  if (draft?.raw !== void 0) commitDraft();
+  return { el: card.el, body: card.body, validate: commitDraft };
+}
+
+// pricing.ts
+var defaultPricingSchedule = {
+  windows: [
+    { from: "09:00", to: "12:00" },
+    { from: "14:00", to: "18:00" }
+  ],
+  exceptDates: [
+    "2026-01-01",
+    "2026-01-02",
+    "2026-01-03",
+    "2026-02-15",
+    "2026-02-16",
+    "2026-02-17",
+    "2026-02-18",
+    "2026-02-19",
+    "2026-02-20",
+    "2026-02-21",
+    "2026-02-22",
+    "2026-02-23",
+    "2026-04-04",
+    "2026-04-05",
+    "2026-04-06",
+    "2026-05-01",
+    "2026-05-02",
+    "2026-05-03",
+    "2026-05-04",
+    "2026-05-05",
+    "2026-06-19",
+    "2026-06-20",
+    "2026-06-21",
+    "2026-09-25",
+    "2026-09-26",
+    "2026-09-27",
+    "2026-10-01",
+    "2026-10-02",
+    "2026-10-03",
+    "2026-10-04",
+    "2026-10-05",
+    "2026-10-06",
+    "2026-10-07"
+  ]
+};
+var TIME = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
+var DATE = /^\d{4}-\d{2}-\d{2}$/;
+function parsePricingSchedule(value) {
+  if (value === void 0 || value === "") return structuredClone(defaultPricingSchedule);
+  let parsed;
+  try {
+    parsed = typeof value === "string" ? JSON.parse(value) : value;
+  } catch {
+    throw new Error("Invalid DeepSeek pricing schedule JSON");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Invalid DeepSeek pricing schedule");
+  const candidate = parsed;
+  if (!Array.isArray(candidate.windows) || candidate.windows.length !== 2 || candidate.windows.some((window) => !window || !TIME.test(window.from) || !TIME.test(window.to) || window.from >= window.to) || candidate.windows[0].to > candidate.windows[1].from) {
+    throw new Error("Peak windows must be two ordered, non-overlapping HH:MM ranges");
+  }
+  if (!Array.isArray(candidate.exceptDates) || candidate.exceptDates.some((date) => {
+    if (typeof date !== "string" || !DATE.test(date)) return true;
+    const value2 = /* @__PURE__ */ new Date(`${date}T00:00:00.000Z`);
+    return !Number.isFinite(value2.valueOf()) || value2.toISOString().slice(0, 10) !== date;
+  })) throw new Error("Exception dates must use YYYY-MM-DD");
+  return {
+    windows: candidate.windows.map(({ from, to }) => ({ from, to })),
+    exceptDates: [...new Set(candidate.exceptDates)].sort()
+  };
+}
+function currentPricingBand(scheduleValue, at) {
+  const schedule = parsePricingSchedule(scheduleValue);
+  const parts = new Intl.DateTimeFormat("en-GB", {
+    timeZone: "Asia/Shanghai",
+    weekday: "short",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(at);
+  const part = (type) => parts.find((item) => item.type === type)?.value ?? "";
+  const date = `${part("year")}-${part("month")}-${part("day")}`;
+  const weekday = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"].indexOf(part("weekday")) + 1;
+  const time = `${part("hour")}:${part("minute")}`;
+  if (weekday < 1 || weekday > 5 || schedule.exceptDates.includes(date)) return "offPeak";
+  return schedule.windows.some(({ from, to }) => from <= time && time < to) ? "peak" : "offPeak";
+}
+
+// console/pricing-panel.ts
+var pricingPanel = {
+  mount: async (ctx) => {
+    const zh4 = ctx.language === "zh";
+    const S3 = zh4 ? {
+      title: "DeepSeek \u5B98\u65B9\u4EF7\u76EE",
+      current: "\u5F53\u524D\u8BA1\u4EF7\u6863\u4F4D",
+      peak: "\u9AD8\u5CF0",
+      offPeak: "\u7A7A\u95F2",
+      model: "\u6A21\u578B",
+      meter: "\u7528\u91CF",
+      cached: "\u8F93\u5165\uFF08\u7F13\u5B58\u547D\u4E2D\uFF09",
+      uncached: "\u8F93\u5165\uFF08\u7F13\u5B58\u672A\u547D\u4E2D\uFF09",
+      output: "\u8F93\u51FA",
+      custom: "\u7AEF\u70B9\u81EA\u5B9A\u4E49\u62A5\u4EF7",
+      customOn: "\u5DF2\u8BBE\u7F6E\u8986\u76D6",
+      fallback: "\u672A\u8BBE\u7F6E\uFF0C\u4F7F\u7528\u6A21\u5757\u4EF7\u76EE",
+      save: "\u5E94\u7528\u62A5\u4EF7",
+      saved: "\u62A5\u4EF7\u5DF2\u5199\u5165\u8FDE\u63A5\u8349\u7A3F\uFF1B\u4FDD\u5B58\u8FDE\u63A5\u540E\u751F\u6548",
+      savedNow: "\u62A5\u4EF7\u5DF2\u4FDD\u5B58",
+      choose: "DeepSeek \u7AEF\u70B9",
+      loadError: "\u65E0\u6CD5\u8BFB\u53D6\u4EF7\u76EE",
+      noInstances: "\u6CA1\u6709\u53EF\u7528\u7684 DeepSeek \u7AEF\u70B9"
+    } : {
+      title: "DeepSeek official rates",
+      current: "Active pricing band",
+      peak: "Peak",
+      offPeak: "Off-peak",
+      model: "Model",
+      meter: "Usage",
+      cached: "Input (cache hit)",
+      uncached: "Input (cache miss)",
+      output: "Output",
+      custom: "Endpoint-specific quote",
+      customOn: "Override configured",
+      fallback: "Unset; using module rates",
+      save: "Apply quote",
+      saved: "Quote staged; save the connection to apply it",
+      savedNow: "Quote saved",
+      choose: "DeepSeek endpoint",
+      loadError: "Unable to load rates",
+      noInstances: "No DeepSeek endpoints are available"
+    };
+    const message = ctx.ui.msgline();
+    const selector = ctx.scope.instance ? null : ctx.ui.select({
+      options: [],
+      onChange: (name) => void load(name)
+    });
+    if (selector) ctx.root.append(ctx.ui.field(S3.choose, selector));
+    ctx.root.append(message);
+    let currentCard = null;
+    let endpointNames = [];
+    if (ctx.scope.instance) {
+      endpointNames = [ctx.scope.instance];
+    } else {
+      try {
+        const instances = await ctx.invoke("instances");
+        endpointNames = instances.map(({ name }) => name);
+      } catch (error) {
+        message.textContent = `${S3.loadError}: ${String(error)}`;
+        return;
+      }
+      if (!endpointNames.length) {
+        message.textContent = S3.noInstances;
+        return;
+      }
+      selector.replaceChildren(...endpointNames.map((name) => {
+        const option = ctx.ui.h("option", null, name);
+        option.value = name;
+        return option;
+      }));
+    }
+    if (ctx.signal.aborted) return;
+    await load(endpointNames[0]);
+    async function load(name) {
+      try {
+        const state = await ctx.invoke("state", [{ name }]);
+        if (ctx.signal.aborted) return;
+        render(state);
+        message.textContent = "";
+      } catch (error) {
+        message.textContent = `${S3.loadError}: ${String(error)}`;
+      }
+    }
+    function render(state) {
+      const card = ctx.ui.sheet({ title: S3.title });
+      const band = currentPricingBand(state.schedule, /* @__PURE__ */ new Date());
+      card.body.append(ctx.ui.statgrid([
+        { k: S3.model, v: state.official.models.join(", ") },
+        { k: S3.current, v: band === "peak" ? S3.peak : S3.offPeak, accent: true }
+      ]));
+      const table = ctx.ui.table({ head: [S3.meter, S3.peak, S3.offPeak] });
+      const peakRules = state.official.timeWindows?.[0]?.rules ?? [];
+      const labels = /* @__PURE__ */ new Map([
+        ["cachedInput", S3.cached],
+        ["uncachedInput", S3.uncached],
+        ["output", S3.output]
+      ]);
+      for (const rule of state.official.rules) {
+        const peak = peakRules.find((item) => item.meter === rule.meter)?.perMillion ?? rule.perMillion;
+        const format = (rate) => `\xA5${rate.toFixed(2)} / 1M`;
+        table.addRow([
+          labels.get(rule.meter) ?? rule.meter,
+          band === "peak" ? ctx.ui.chip(format(peak), "accent") : format(peak),
+          band === "offPeak" ? ctx.ui.chip(format(rule.perMillion), "accent") : format(rule.perMillion)
+        ]);
+      }
+      card.body.append(table.el, ctx.ui.msgline(`${state.official.source} \xB7 Asia/Shanghai`));
+      const details = ctx.ui.foldSheet("deepseek-custom-pricing", { title: S3.custom });
+      details.el.classList.add("deepseek-custom-pricing");
+      details.note.textContent = state.custom.length ? S3.customOn : S3.fallback;
+      let customPricing = state.custom;
+      const editor = pricingEditor(ctx.ui, state.custom, [], (value) => {
+        customPricing = value;
+      }, ctx.language);
+      details.body.append(editor.body);
+      const save = ctx.ui.button(S3.save, { variant: "primary", onClick: () => void savePricing() });
+      details.body.append(ctx.ui.actions().appendChild(save));
+      card.body.append(details.el);
+      if (currentCard) currentCard.replaceWith(card.el);
+      else ctx.root.insertBefore(card.el, message);
+      currentCard = card.el;
+      async function savePricing() {
+        if (!editor.validate()) return;
+        const release = ctx.ui.disable(save);
+        try {
+          const updated = await ctx.invoke("save", [{ name: state.name, pricing: customPricing }]);
+          message.textContent = updated.editing ? S3.saved : S3.savedNow;
+          render(updated);
+        } catch (error) {
+          message.textContent = String(error);
+        } finally {
+          release.dispose();
+        }
+      }
+    }
+  }
+};
+
+// console/schedule-panel.ts
+var schedulePanel = {
+  mount: async (ctx) => {
+    const zh4 = ctx.language === "zh";
+    const S3 = zh4 ? {
+      current: "\u5F53\u524D\u8BA1\u4EF7\u65F6\u6BB5",
+      peak: "\u9AD8\u5CF0",
+      offPeak: "\u7A7A\u95F2",
+      timezone: "\u5317\u4EAC\u65F6\u95F4\uFF08Asia/Shanghai\uFF09",
+      windows: "\u9AD8\u5CF0\u65F6\u6BB5",
+      weekday: "\u5468\u4E00\u81F3\u5468\u4E94\uFF1B\u5468\u672B\u59CB\u7EC8\u4E3A\u7A7A\u95F2\u65F6\u6BB5",
+      exceptions: "\u4F8B\u5916\u65E5\u671F\uFF08\u6BCF\u884C YYYY-MM-DD\uFF09",
+      from: "\u5F00\u59CB",
+      to: "\u7ED3\u675F",
+      save: "\u4FDD\u5B58\u65F6\u6BB5",
+      saved: "\u5CF0\u8C37\u8BBE\u7F6E\u5DF2\u4FDD\u5B58",
+      invalid: "\u65F6\u6BB5\u683C\u5F0F\u9519\u8BEF\uFF1B\u8BF7\u586B\u5199 HH:MM\uFF0C\u4F8B\u5916\u65E5\u671F\u6BCF\u884C\u586B\u5199 YYYY-MM-DD\u3002",
+      refreshError: "\u65E0\u6CD5\u8BFB\u53D6\u5CF0\u8C37\u8BBE\u7F6E"
+    } : {
+      current: "Active pricing band",
+      peak: "Peak",
+      offPeak: "Off-peak",
+      timezone: "China Standard Time (Asia/Shanghai)",
+      windows: "Peak windows",
+      weekday: "Monday to Friday; weekends are always off-peak",
+      exceptions: "Exception dates (one YYYY-MM-DD per line)",
+      from: "From",
+      to: "To",
+      save: "Save schedule",
+      saved: "Pricing schedule saved",
+      invalid: "Invalid time or date format. Use HH:MM and one YYYY-MM-DD date per line.",
+      refreshError: "Unable to load pricing schedule"
+    };
+    const status = ctx.ui.foldSheet("deepseek-schedule", { title: S3.current });
+    const message = ctx.ui.msgline();
+    ctx.root.append(status.el, message);
+    let state;
+    try {
+      state = await ctx.invoke("state", [{ name: ctx.scope.instance }]);
+    } catch (error) {
+      message.textContent = `${S3.refreshError}: ${String(error)}`;
+      return;
+    }
+    if (ctx.signal.aborted) return;
+    const updateStatus = (band = currentPricingBand(state.schedule, /* @__PURE__ */ new Date())) => {
+      const now = /* @__PURE__ */ new Date();
+      const time = new Intl.DateTimeFormat(zh4 ? "zh-CN" : "en-GB", {
+        timeZone: "Asia/Shanghai",
+        dateStyle: "medium",
+        timeStyle: "short",
+        hourCycle: "h23"
+      }).format(now);
+      status.note.textContent = `${band === "peak" ? S3.peak : S3.offPeak} \xB7 ${time} \xB7 ${S3.timezone}`;
+    };
+    updateStatus(state.band);
+    ctx.interval(updateStatus, 3e4);
+    const starts = state.schedule.windows.map((window) => ctx.ui.input({ value: window.from, placeholder: "09:00", cls: "mono" }));
+    const ends = state.schedule.windows.map((window) => ctx.ui.input({ value: window.to, placeholder: "12:00", cls: "mono" }));
+    const windows = ctx.ui.rowbar();
+    windows.classList.add("deepseek-window-grid");
+    windows.style.alignItems = "stretch";
+    state.schedule.windows.forEach((_, index) => {
+      const group = ctx.ui.h("div", "deepseek-window");
+      group.style.flex = "1 1 280px";
+      group.style.minWidth = "0";
+      const times = ctx.ui.rowbar();
+      times.style.flexWrap = "nowrap";
+      for (const [label, input] of [[S3.from, starts[index]], [S3.to, ends[index]]]) {
+        const field = ctx.ui.field(label, input);
+        field.style.flex = "1 1 0";
+        field.style.minWidth = "0";
+        times.append(field);
+      }
+      group.append(ctx.ui.h("div", "fieldlabel", zh4 ? `\u65F6\u6BB5 ${index + 1}` : `Window ${index + 1}`), times);
+      windows.append(group);
+    });
+    status.body.append(ctx.ui.section(S3.windows), ctx.ui.msgline(S3.weekday), windows);
+    const exceptionDates = ctx.ui.textarea({ rows: 6, value: state.schedule.exceptDates.join("\n"), cls: "mono" });
+    status.body.append(ctx.ui.field(S3.exceptions, exceptionDates));
+    const save = ctx.ui.button(S3.save, { variant: "primary", onClick: () => void saveSchedule() });
+    status.body.append(ctx.ui.actions().appendChild(save));
+    async function saveSchedule() {
+      const schedule = {
+        windows: starts.map((input, index) => ({ from: input.value.trim(), to: ends[index].value.trim() })),
+        exceptDates: exceptionDates.value.split(/\r?\n/).map((date) => date.trim()).filter(Boolean)
+      };
+      if (schedule.windows.some(({ from, to }) => !/^\d{2}:\d{2}$/.test(from) || !/^\d{2}:\d{2}$/.test(to)) || schedule.exceptDates.some((date) => !/^\d{4}-\d{2}-\d{2}$/.test(date))) {
+        message.textContent = S3.invalid;
+        return;
+      }
+      const release = ctx.ui.disable(save);
+      try {
+        state = await ctx.invoke("save", [{ name: state.name, schedule }]);
+        message.textContent = S3.saved;
+        updateStatus(state.band);
+      } catch (error) {
+        message.textContent = String(error);
+      } finally {
+        release.dispose();
+      }
+    }
+  }
+};
+
+// console/client.ts
+var client_default2 = {
+  ...client_default,
+  panels: { ...client_default.panels, schedule: schedulePanel, pricing: pricingPanel }
+};
+export {
+  client_default2 as default
+};