@ebony-vinyl/dsh-our-free-model 2.8.3 → 2.8.4

package/src/model-test.js

@@ -1,8 +1,24 @@
-/** Text-test validation adapted from upstream PR #491; timing, cancellation and persistence complete issue #462. */
+/**
+ * Model measurement: the text test this lane runs itself, and the figures the
+ * site publishes for the same models.
+ *
+ * The two halves answer the same question — "how is this model actually
+ * serving?" — from opposite directions. `measureModelTest` establishes it by
+ * sending the smallest request that can produce a verdict; the second half
+ * reads the site's own hourly statistics so a card can show the strip the site
+ * shows, rather than an invented one.
+ *
+ * They share a module because the release set has a hard ceiling: updaters from
+ * 1.3.1 and 2.5.9 reject any manifest listing more than 80 files, so a new
+ * module of this size cannot simply be added. Folding it in beside the
+ * measurement it complements keeps old installs upgradable.
+ *
+ * Text-test validation adapted from upstream PR #491; timing, cancellation and
+ * persistence complete issue #462.
+ */
 import { CODE, UpstreamError } from './http.js'
 import { decodeWindow } from './store.js'
 import { windowTokens } from './stream.js'
-
 export const MODEL_TEST_TIMEOUT_MS = 300_000
 
 /** Only a nonempty, normally finished tool-free answer establishes a successful text test. */
@@ -92,3 +108,265 @@ export function modelAvailability(id, snapshot, listed = false) {
     ttftMs: measured?.ttftMs, latencyMs: measured?.latencyMs,
   }
 }
+
+// ── the site's own per-model figures ─────────────────────────────────────────
+//
+// The model square at the site root draws one performance strip per card: a
+// success-rate bar of 24 hourly ticks, the average latency, the output speed,
+// and a 详情 button that opens the trend charts. These functions read the same
+// numbers from the same endpoint so the plugin's cards show the same strip
+// rather than an invented one.
+//
+// The endpoint (`GET /api/perf-metrics/summary?hours=24`) is public — no
+// credential — and answers every model in one document, each with its own
+// `recent_success_series`. It sends no CORS headers, so a page served from the
+// harness cannot call it directly; index.js hops through it.
+//
+// Two rules are enforced, both learned from the live data:
+//
+// 1. **A window that spans a channel change is not a verdict.** Two relayed
+//    models were moved onto a different upstream mid-window; their 24h rate
+//    still averages in the hours of fast failures from the lane they left, so it
+//    reads ~3% while the last hour reads ~93%. Such a model is reported as
+//    `settling` and its card draws no strip — a wrong number is worse than none.
+//
+// 2. **No endpoint, no strip.** When the site does not answer, the map is empty
+//    and every card renders exactly as it did before this feature existed.
+
+/** How long one metrics read may take before the page gets an empty map. */
+const METRICS_TIMEOUT_MS = 6000
+
+/** The window the strip describes, in hours. The site's own strip says 24. */
+export const WINDOW_HOURS = 24
+
+/**
+ * A model's window rate and its recent hour may differ by this much before the
+ * figure is withheld. The relay move left a 90-point gap; ordinary drift on a
+ * busy day stays well inside 20 (the live minimax card swings 57→96 across the
+ * day and is still shown).
+ */
+const SETTLING_GAP = 30
+
+/**
+ * The site root, derived from the lane's own base (`…/eac/v1` → `…`).
+ *
+ * The metrics endpoint lives beside the panel, not under the signed lane, so
+ * the `/eac/v1` suffix is dropped rather than rewritten. A base that does not
+ * look like a URL yields null and the feature stays off.
+ */
+export function siteRootFor(base) {
+  const text = String(base ?? '').trim()
+  if (text === '') return null
+  let url
+  try { url = new URL(text) } catch { return null }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') return null
+  // Drop the lane's own mount (`/eac/v1`, `/v1`) so the result is the site root
+  // the panel and its API are served from. A bare `/eac` is dropped too, for a
+  // base that names only the mount and no API version.
+  const path = url.pathname
+    .replace(/\/(?:eac\/)?v1\/?$/i, '')
+    .replace(/\/eac\/?$/i, '')
+    .replace(/\/+$/, '')
+  return `${url.origin}${path}`
+}
+
+/**
+ * A finite non-negative number, or null.
+ *
+ * `null` and `''` must stay null rather than becoming 0: the endpoint uses null
+ * for "no sample in this hour", and `Number(null)` is 0 — which would paint a
+ * red 0% tick, or drop a latency line to the floor, for an hour that simply had
+ * no traffic.
+ */
+function metricOf(value) {
+  if (value === null || value === undefined || value === '') return null
+  const n = Number(value)
+  return Number.isFinite(n) && n >= 0 ? n : null
+}
+
+/**
+ * One tick of the success bar.
+ *
+ * The site colours each hourly tick by its own rate — emerald at 99 and above,
+ * amber from 90, red below — so a glance reads the shape of the day, not just
+ * its average. `null` marks an hour with no sample: the site draws those grey.
+ */
+function tickOf(row) {
+  return metricOf(row?.success_rate)
+}
+
+/**
+ * Reduce one model's entry to what the card draws.
+ *
+ * Returns null when the entry carries nothing worth showing, and
+ * `{ settling: true }` when its window rate disagrees with how it is serving
+ * now by more than {@link SETTLING_GAP} points.
+ *
+ * The comparison deliberately skips the final bucket. The series ends with the
+ * hour still in progress (the endpoint's `window_end` is "now"), so that sample
+ * covers however many minutes have elapsed — three, or fifty-nine. Comparing a
+ * partial hour against a 24-hour average compares incomparable things and made
+ * the strip appear and disappear as the hour filled: on live data one model
+ * read a 34-point gap three minutes into the hour and an 18-point gap minutes
+ * later, flipping between hidden and shown. The newest *complete* hour is a
+ * settled sample, so the verdict stops flapping without changing which models
+ * are withheld.
+ *
+ * The reference is a recent hour rather than a median of the window on purpose:
+ * this endpoint reports hours with no traffic as 0 rather than null, so a median
+ * over the whole series is dominated by quiet hours and stops noticing the very
+ * upstream switch this check exists to catch.
+ */
+export function perfFrom(entry) {
+  if (entry === null || typeof entry !== 'object') return null
+  const rate = metricOf(entry.success_rate)
+  if (rate === null) return null
+  const latency = metricOf(entry.avg_latency_ms)
+  const speed = metricOf(entry.avg_tps)
+
+  const series = Array.isArray(entry.recent_success_series) ? entry.recent_success_series : []
+  const ticks = series.map(tickOf)
+  // Everything but the in-progress bucket. With a single bucket there is no
+  // complete hour to compare against, so the window rate stands unexamined.
+  const complete = ticks.slice(0, -1).filter(value => value !== null)
+  const reference = complete.length > 0 ? complete[complete.length - 1] : null
+
+  // A window rate that disagrees violently with the recent complete hour
+  // describes a window that spanned a change of upstream, not the model as it
+  // serves now.
+  if (reference !== null && Math.abs(reference - rate) > SETTLING_GAP) {
+    return { settling: true, rate, newest: reference }
+  }
+
+  return {
+    rate,
+    latencyMs: latency,
+    speed,
+    // Every hourly sample, oldest first: the bar the card draws.
+    ticks,
+    windowHours: series.length > 0 ? series.length : WINDOW_HOURS,
+  }
+}
+
+/**
+ * One point of a trend chart, from the per-model series.
+ *
+ * The site draws two charts from this one series: latency over time and
+ * availability over time. Both read the same hourly rows, so they are reduced
+ * together rather than in two passes.
+ */
+function pointOf(row) {
+  if (row === null || typeof row !== 'object') return null
+  const ts = metricOf(row.ts)
+  if (ts === null) return null
+  return {
+    ts,
+    latencyMs: metricOf(row.avg_latency_ms),
+    ttftMs: metricOf(row.avg_ttft_ms),
+    rate: metricOf(row.success_rate),
+    speed: metricOf(row.avg_tps),
+  }
+}
+
+/**
+ * The trend series for one model, oldest first.
+ *
+ * A point with no latency sample keeps its slot so the two charts stay aligned
+ * in time; the renderer skips it when drawing the line.
+ */
+export function seriesFrom(entry) {
+  const rows = Array.isArray(entry?.series) ? entry.series : []
+  return rows.map(pointOf).filter(point => point !== null)
+}
+
+/**
+ * Read one model's full trend series (`GET /api/perf-metrics?model=…`).
+ *
+ * The summary endpoint answers every model's headline figures in one request;
+ * the per-model endpoint is the only one that carries the hourly series. The
+ * card asks for this only when its 详情 is opened, so a roster of twelve cards
+ * costs one request until the reader actually looks.
+ */
+export async function readSeries({ root, modelId, fetch, signal, timeoutMs = METRICS_TIMEOUT_MS }) {
+  if (root === null || root === undefined || typeof modelId !== 'string' || modelId === '') return null
+  // Already cancelled: do not spend a round trip on a request nobody will read.
+  if (signal?.aborted === true) return null
+  const url = `${root}/api/perf-metrics?model=${encodeURIComponent(modelId)}&hours=${WINDOW_HOURS}`
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  timer.unref?.()
+  const onAbort = () => controller.abort()
+  signal?.addEventListener('abort', onAbort, { once: true })
+  try {
+    const response = await fetch(url, { signal: controller.signal, headers: { accept: 'application/json' } })
+    if (!response.ok) return null
+    const text = await response.text()
+    let payload
+    try { payload = JSON.parse(text) } catch { return null }
+    const series = seriesFrom(payload?.data)
+    if (series.length === 0) return null
+    return {
+      series,
+      windowStart: metricOf(payload?.data?.window_start),
+      windowEnd: metricOf(payload?.data?.window_end),
+    }
+  } catch {
+    return null
+  } finally {
+    clearTimeout(timer)
+    signal?.removeEventListener?.('abort', onAbort)
+  }
+}
+
+/**
+ * Read every model's figures from the site in one request.
+ *
+ * The endpoint answers all models together, so this is one round trip rather
+ * than one per model. The map is keyed by the id the site spells, which is the
+ * same id the catalog uses. Models the site does not answer for are absent
+ * rather than present-and-null: absence is what the card renders as "no strip".
+ *
+ * The site's root is deliberately not echoed back: it is the co-paid gateway's
+ * host, the seal keeps it server-side, and the page never reads it. Only the
+ * figures travel.
+ *
+ * Never throws — a failure is the same answer as "the site has no figures",
+ * which the card already handles by drawing nothing.
+ */
+export async function readPerf({ root, fetch, signal, timeoutMs = METRICS_TIMEOUT_MS }) {
+  if (root === null || root === undefined) return { models: {} }
+  // Already cancelled: do not spend a round trip on a request nobody will read.
+  if (signal?.aborted === true) return { models: {} }
+  const url = `${root}/api/perf-metrics/summary?hours=${WINDOW_HOURS}`
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  timer.unref?.()
+  const onAbort = () => controller.abort()
+  signal?.addEventListener('abort', onAbort, { once: true })
+  try {
+    const response = await fetch(url, { signal: controller.signal, headers: { accept: 'application/json' } })
+    if (!response.ok) return { models: {} }
+    const text = await response.text()
+    let payload
+    try { payload = JSON.parse(text) } catch { return { models: {} } }
+    const rows = payload?.data?.models
+    if (!Array.isArray(rows)) return { models: {} }
+    const models = {}
+    for (const row of rows) {
+      const id = typeof row?.model_name === 'string' ? row.model_name.trim() : ''
+      if (id === '') continue
+      const perf = perfFrom(row)
+      if (perf !== null) models[id] = perf
+    }
+    return {
+      models,
+      windowStart: metricOf(payload?.data?.window_start),
+      windowEnd: metricOf(payload?.data?.window_end),
+    }
+  } catch {
+    return { models: {} }
+  } finally {
+    clearTimeout(timer)
+    signal?.removeEventListener?.('abort', onAbort)
+  }
+}

package/src/o2a.js

@@ -631,6 +631,26 @@ function renameAndCompleteTools(payload, shape, { keep } = {}) {
   dropDanglingToolChoice(payload, shape, known);
   return { renames, injected, known };
 }
+function chatMessageHasContent(message) {
+  const keys = ["content", "reasoning_content", "reasoning"];
+  for (const key of keys) {
+    const value = message[key];
+    if (typeof value === "string") {
+      if (value !== "") return true;
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > 0) return true;
+      continue;
+    }
+    if (value !== null && typeof value === "object") {
+      if (Object.keys(value).length > 0) return true;
+      continue;
+    }
+    if (value !== void 0 && value !== null) return true;
+  }
+  return false;
+}
 function sanitizeToolHistory(payload, shape, known) {
   const fateOf = (name) => {
     if (typeof name !== "string" || name === "") return { verdict: "drop" };
@@ -644,13 +664,14 @@ function sanitizeToolHistory(payload, shape, known) {
     if (messages2 === null) return;
     const droppedCalls2 = /* @__PURE__ */ new Set();
     const droppedFunctions = /* @__PURE__ */ new Set();
+    const emptied = /* @__PURE__ */ new Set();
     let changed2 = false;
     for (let i = 0; i < messages2.length; i += 1) {
       const message = messages2[i];
       if (!message || typeof message !== "object") continue;
       if (Array.isArray(message.tool_calls)) {
         const kept = [];
-        let touched = false;
+        let touched = message.tool_calls.length === 0;
         for (const call of message.tool_calls) {
           const fate = fateOf(call?.function?.name);
           if (fate.verdict === "keep") {
@@ -667,33 +688,49 @@ function sanitizeToolHistory(payload, shape, known) {
           touched = true;
         }
         if (touched) {
-          messages2[i] = { ...message, tool_calls: kept };
+          if (kept.length === 0) {
+            const { tool_calls: _emptied, ...rest } = message;
+            messages2[i] = rest;
+            if (message.tool_calls.length > 0 && message.function_call === void 0) emptied.add(rest);
+          } else {
+            messages2[i] = { ...message, tool_calls: kept };
+          }
           changed2 = true;
         }
       }
-      if (message.function_call && typeof message.function_call === "object") {
-        const fate = fateOf(message.function_call.name);
+      const current = messages2[i];
+      if (current.function_call && typeof current.function_call === "object") {
+        const fate = fateOf(current.function_call.name);
         if (fate.verdict === "rename") {
-          messages2[i] = { ...message, function_call: { ...message.function_call, name: fate.official } };
+          messages2[i] = { ...current, function_call: { ...current.function_call, name: fate.official } };
           changed2 = true;
         } else if (fate.verdict === "drop") {
-          if (typeof message.function_call.name === "string") droppedFunctions.add(message.function_call.name);
-          const { function_call: _dropped, ...rest } = messages2[i];
+          if (typeof current.function_call.name === "string") droppedFunctions.add(current.function_call.name);
+          const { function_call: _dropped, ...rest } = current;
           messages2[i] = rest;
           changed2 = true;
         }
       }
-      if (message.role === "tool" && typeof message.tool_call_id === "string" && droppedCalls2.has(message.tool_call_id)) {
+      const row = messages2[i];
+      if (row.role === "tool" && typeof row.tool_call_id === "string" && droppedCalls2.has(row.tool_call_id)) {
         messages2.splice(i, 1);
         i -= 1;
         changed2 = true;
       }
-      if (message.role === "function" && typeof message.name === "string" && droppedFunctions.has(message.name)) {
+      if (row.role === "function" && typeof row.name === "string" && droppedFunctions.has(row.name)) {
         messages2.splice(i, 1);
         i -= 1;
         changed2 = true;
       }
     }
+    if (emptied.size > 0) {
+      for (let i = messages2.length - 1; i >= 0; i -= 1) {
+        if (emptied.has(messages2[i]) && !chatMessageHasContent(messages2[i])) {
+          messages2.splice(i, 1);
+          changed2 = true;
+        }
+      }
+    }
     if (changed2 && messages2.length === 0) payload.messages = [];
     return;
   }

package/src/plugins.js

@@ -660,8 +660,8 @@ export function builtinDescriptors() {
     {
       manifest: {
         id: 'core-model-workspace',
-        name: '模型工作台',
-        description: '内置的本地模型工作台页面与模型目录同步。',
+        name: '模型工作台（magpie）',
+        description: '内置的本地模型工作台页面与模型目录同步（引擎为 magpie）。',
         icon: 'panels',
         provides: ['ui'],
       },

package/src/store.js

@@ -256,6 +256,14 @@ export const SETTINGS_INITIAL = {
   feedUrl: '',
   /** Minutes between announcement-feed polls; floored at 5. */
   feedPollMinutes: 30,
+  /** Where the in-plugin feedback form submits. Empty keeps the built-in
+   *  project server; an override lets a self-hosting operator point at their
+   *  own collector. Feedback is never sent anywhere else. */
+  feedbackUrl: '',
+  /** GitHub login this install completed for the feedback form: `{ token,
+   *  login, at }`, or null. The token only authorizes feedback submission —
+   *  it is not an API credential and is never sent to a model endpoint. */
+  feedbackAuth: null,
   /** Raise OS-level notifications for new announcements and updates (the
    *  browser asks for permission on the user's click). */
   notifyOs: false,
@@ -276,6 +284,10 @@ export const SETTINGS_INITIAL = {
   /** When the running code was hot-reloaded into place, and how many times. */
   reloadedAt: 0,
   reloadCount: 0,
+  /** The `reloadedAt` the browser has already acknowledged. Stored here, not
+   *  in localStorage, so a new origin (another port or the desktop shell's
+   *  random port) does not replay the same notice. */
+  reloadNoticeSeen: 0,
   /** Version installed by the in-app upgrader, for the settings page. */
   installedVersion: '',
 }

package/src/updater.js

@@ -856,12 +856,26 @@ export function verifyInstalled(pkgDir, manifest) {
  * @param {string} pkgDir - the installed package directory
  * @returns {boolean}
  */
-export function isPackageManagerOwned(pkgDir) {
-  const profileDir = path.dirname(path.dirname(path.resolve(pkgDir)))
+export function isPackageManagerOwned(pkgDir, packageName = PACKAGE_NAME) {
+  const profileDir = profileDirOf(pkgDir)
   const lockfile = readTextFile(path.join(profileDir, 'pnpm-lock.yaml'))
-  if (lockfile !== undefined && lockfileDeclaresPackage(lockfile, PACKAGE_NAME)) return true
+  if (lockfile !== undefined && lockfileDeclaresPackage(lockfile, packageName)) return true
   const modules = readTextFile(path.join(profileDir, 'node_modules', '.modules.yaml'))
-  return modules !== undefined && modulesHoistsPackage(modules, PACKAGE_NAME)
+  return modules !== undefined && modulesHoistsPackage(modules, packageName)
+}
+
+/**
+ * The profile root a package directory belongs to.
+ *
+ * A bare install is <profile>/node_modules/<name>; a scoped one is
+ * <profile>/node_modules/@scope/<name>. Walking to node_modules instead of
+ * counting two parents keeps both layouts pointed at the profile, where pnpm
+ * writes its lockfile and .modules.yaml (issue #773).
+ */
+export function profileDirOf(pkgDir) {
+  let dir = path.resolve(pkgDir)
+  while (dir !== path.dirname(dir) && path.basename(dir) !== 'node_modules') dir = path.dirname(dir)
+  return path.dirname(dir)
 }
 
 function readTextFile(file) {
@@ -879,9 +893,10 @@ function readTextFile(file) {
  *  full install — a real tree inside the profile declared as a relative
  *  `link:`. A `file:`, tarball-URL or registry specifier does record a source
  *  pnpm can re-extract, and stays "owned". */
-function lockfileDeclaresPackage(text, name) {
+export function lockfileDeclaresPackage(text, name) {
   const lines = text.split(/\r?\n/)
-  const entry = new RegExp(`^(\\s*)${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*:\\s*$`)
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const entry = new RegExp(`^(\\s*)['"]?${escaped}['"]?\\s*:\\s*$`)
   for (let index = 0; index < lines.length; index += 1) {
     const match = entry.exec(lines[index])
     if (match === null) continue

package/vendor/channel-pack/pack.js

@@ -58738,7 +58738,10 @@ function registerChannelPackEndpoints(ctx, pool, lobsterai, qoder, qoderCn, trae
           const values = await collectCreditBalances(accounts, GEMINI, {
             resolve: (ref) => ctx.credentials.resolve(ref),
             fetchBalanceDetailed: async (credential) => {
-              const { balance, error, tier } = await fetchGeminiCreditBalance(credential, GEMINI, { force: req.force === true });
+              const { balance, error, tier } = await fetchGeminiCreditBalance(credential, GEMINI, {
+                force: req.force === true,
+                ...config.fetcher === void 0 ? {} : { fetcher: config.fetcher }
+              });
               const extra = tier === void 0 ? void 0 : { accountTier: { label: tier.label, title: `${tier.name}\uFF08${tier.id}\uFF09` } };
               return {
                 balance,
@@ -65535,7 +65538,9 @@ function apply(ctx, config = {}) {
     });
   });
   registerChannelPackRpc(ctx, pool, lobsterai, qoder, qoderCn, trae, cline, loomy, raccoon, minimax, zcode, gemini, modelAdapters, {
-    ...config
+    ...config,
+    // ⚠️ 配额等附属查询必须复用同一出口；省略会让 gemini-credits 回落到裸 fetch。
+    fetcher: network.fetch
   });
   mountOpenAiGateway(ctx, pool);
   installLoopResume(ctx);