@jingyi0605/codingns4dsh 0.2.1-rc.2 → 0.2.1-rc.3

package/data/build/dist/host/cli-adapters/magpie-usage.js

@@ -7,8 +7,10 @@ const MAX_MAGPIE_MODEL_METADATA_CACHE_ENTRIES = 4;
 const MAGPIE_MINIMUM_CLI_VERSION = [0, 1, 1295];
 const MAGPIE_CLI_TIMEOUT_MS = 10_000;
 const MAGPIE_HTTP_TIMEOUT_MS = 3_000;
+const MAGPIE_DASHBOARD_CACHE_TTL_MS = 15_000;
 const MAX_MAGPIE_CLI_OUTPUT_BYTES = 512 * 1024;
 const MAX_MAGPIE_RESPONSE_BYTES = 2 * 1024 * 1024;
+const MAX_MAGPIE_ICON_FETCHES = 64;
 const MAX_MAGPIE_MODELS = 10_000;
 const MAX_MODEL_TOKEN_LIMIT = 1_000_000_000;
 const MAGPIE_MODEL_ID_PATTERN = '[A-Za-z0-9][A-Za-z0-9._-]*(?:/[A-Za-z0-9][A-Za-z0-9._:/-]*)+';
@@ -39,11 +41,7 @@ const MAGPIE_USAGE_AGENT_ALIASES = {
     // usage ledger, while its verified model catalog uses `commandcode`.
     commandcode: ['commandcode', 'codingns4dsh'],
 };
-/**
- * Reads Magpie's public local Gateway API only after its CLI confirms that the
- * current Agent model is in that Agent's catalog. No Agent or Magpie config
- * files are opened here; the provider session ID is supplied by the Host.
- */
+/** Reads usage from the authenticated local Magpie Web API and exact-matches session identity. */
 export class MagpieUsageService {
     readModels;
     readVersion;
@@ -51,6 +49,8 @@ export class MagpieUsageService {
     now;
     timeoutMs;
     lifetimeSignal;
+    webApi;
+    onDashboardTiming;
     /** Agent CLI verification remains isolated; model metadata below is Gateway-wide and shared. */
     catalogs = new Map();
     catalogLoads = new Map();
@@ -59,6 +59,9 @@ export class MagpieUsageService {
     modelMetadataLoads = new Map();
     versionCheck;
     versionLoad;
+    dashboardCache = new Map();
+    dashboardRefreshes = new Map();
+    quotaLogoCache = new Map();
     constructor(options = {}) {
         this.readModels = options.readModels ?? readMagpieModels;
         // An injected catalog reader represents the whole fake CLI boundary in
@@ -70,6 +73,8 @@ export class MagpieUsageService {
         this.now = options.now ?? Date.now;
         this.timeoutMs = options.timeoutMs ?? MAGPIE_HTTP_TIMEOUT_MS;
         this.lifetimeSignal = options.lifetimeSignal;
+        this.webApi = options.webApi;
+        this.onDashboardTiming = options.onDashboardTiming;
     }
     async read(session, signal, includeRoute = false, dshSessionId) {
         signal?.throwIfAborted();
@@ -77,10 +82,6 @@ export class MagpieUsageService {
         const requestedModelId = cleanText(session.modelId);
         if (agent === null || requestedModelId === null)
             return null;
-        const catalog = await this.loadCatalog(agent, signal);
-        const modelId = resolveCatalogModelId(agent, requestedModelId, catalog, requestedModelId);
-        if (catalog === null || modelId === null)
-            return null;
         const providerSessionId = cleanText(session.providerSessionId);
         const nativeSessionId = cleanText(dshSessionId);
         // Native DSH requests use the DSH session ID as their Magpie session
@@ -88,7 +89,19 @@ export class MagpieUsageService {
         const sessionId = providerSessionId !== null && providerSessionId !== nativeSessionId
             ? providerSessionId
             : agent === 'dsh' ? nativeSessionId : null;
-        return this.readFromGateway(agent, requestedModelId, catalog.gatewayOrigin, sessionId, signal, includeRoute);
+        // Command Code's ACP child tags loopback Magpie requests with the DSH
+        // session ID injected by the Host, so the ledger key differs from the ACP
+        // session ID shown in the panel. Older Hosts without that ID keep the
+        // provider ID so the panel still reports the same "no usage" state.
+        const magpieSessionId = agent === 'commandcode' ? nativeSessionId ?? sessionId : sessionId;
+        // During a rolling update the ACP child may still tag requests with its ACP
+        // session ID; fall back to it when the DSH-ID ledger row is absent.
+        const fallbackSessionId = agent === 'commandcode' && nativeSessionId !== null && sessionId !== null && nativeSessionId !== sessionId
+            ? sessionId
+            : null;
+        if (magpieSessionId === null)
+            return null;
+        return this.readFromWeb(agent, requestedModelId, sessionId, magpieSessionId, fallbackSessionId, signal, includeRoute);
     }
     /**
      * Mark Magpie models and enrich their public metadata. The marker is
@@ -174,47 +187,201 @@ export class MagpieUsageService {
         const metadata = await this.loadModelMetadata(catalog, signal);
         return metadata?.get(id) ?? null;
     }
-    async readFromGateway(agent, modelId, gatewayOrigin, sessionId, signal, includeRoute) {
+    /** Read bounded, graph-ready usage and quota data through authenticated Magpie Web. */
+    async readDashboard(period, signal) {
+        signal?.throwIfAborted();
+        const cached = this.dashboardCache.get(period);
+        if (cached !== undefined) {
+            if (this.now() - cached.loadedAt >= MAGPIE_DASHBOARD_CACHE_TTL_MS) {
+                void this.refreshDashboard(period).catch(() => undefined);
+            }
+            return cached.dashboard;
+        }
+        return this.refreshDashboard(period, signal);
+    }
+    /** Stream cumulative dashboard snapshots as each independent Web API part is ready. */
+    async *readDashboardStream(period, signal, force = false) {
+        signal?.throwIfAborted();
+        const cached = this.dashboardCache.get(period);
+        if (!force && cached !== undefined) {
+            const stale = this.now() - cached.loadedAt >= MAGPIE_DASHBOARD_CACHE_TTL_MS;
+            yield { part: 'cache', dashboard: cached.dashboard, stale };
+            if (!stale)
+                return;
+        }
+        let latest;
+        for await (const chunk of this.readDashboardNetwork(period, signal)) {
+            latest = chunk.dashboard;
+            yield chunk;
+        }
+        if (latest !== undefined)
+            this.dashboardCache.set(period, { dashboard: latest, loadedAt: this.now() });
+    }
+    async refreshDashboard(period, signal) {
+        const pending = this.dashboardRefreshes.get(period);
+        if (pending !== undefined)
+            return awaitWithSignal(pending, signal);
+        const request = (async () => {
+            let latest;
+            for await (const chunk of this.readDashboardNetwork(period, signal))
+                latest = chunk.dashboard;
+            if (latest === undefined)
+                throw new Error('Magpie dashboard returned no snapshot');
+            this.dashboardCache.set(period, { dashboard: latest, loadedAt: this.now() });
+            return latest;
+        })().finally(() => {
+            if (this.dashboardRefreshes.get(period) === request)
+                this.dashboardRefreshes.delete(period);
+        });
+        this.dashboardRefreshes.set(period, request);
+        return awaitWithSignal(request, signal);
+    }
+    async *readDashboardNetwork(period, signal) {
+        const capturedAt = new Date(this.now()).toISOString();
+        let dashboard = emptyMagpieDashboard(period, capturedAt);
+        let quotas = null;
+        let logoLoad;
+        const results = new Map([
+            ['usage', this.timedDashboardRead('usage', () => this.readWebJson(`/api/usage?period=${magpieWebPeriod(period)}`, signal))],
+            ['quotas', this.timedDashboardRead('quotas', () => this.readWebJson('/api/usage/quotas', signal))],
+            ['history', this.timedDashboardRead('history', () => this.readWebJson('/api/usage/quotas/history?days=30', signal))],
+        ]);
+        const completed = new Map();
+        while (results.size > 0) {
+            const result = await Promise.race(results.values());
+            results.delete(result.part);
+            const response = asRecord(result.value);
+            const partOk = result.ok && response?.ok === true;
+            const partValue = partOk ? response.value : undefined;
+            completed.set(result.part, partOk);
+            if (result.part === 'usage') {
+                const parsed = partOk ? parseMagpieDashboardUsage(partValue) : null;
+                dashboard = {
+                    ...dashboard,
+                    usageStatus: parsed === null ? 'unavailable' : 'available',
+                    aggregate: parsed?.aggregate ?? null,
+                    series: parsed?.series ?? [],
+                    agents: parsed?.agents ?? [],
+                    providers: parsed?.providers ?? [],
+                    models: parsed?.models ?? [],
+                    accounts: parsed?.accounts ?? [],
+                    sessions: parsed?.sessions ?? [],
+                    sessionCount: parsed?.sessionCount ?? null,
+                };
+            }
+            else if (result.part === 'quotas') {
+                quotas = partOk ? parseMagpieQuotaCards(partValue) : null;
+                dashboard = { ...dashboard, quotaStatus: quotas === null ? 'unavailable' : 'available', quotas: quotas ?? [] };
+                if (quotas !== null)
+                    logoLoad = this.timedDashboardRead('quota-logos', () => this.attachQuotaLogos(quotas, signal)).then((result) => result.value);
+            }
+            else {
+                const parsed = partOk ? parseMagpieQuotaHistory(partValue) : null;
+                dashboard = { ...dashboard, quotaHistoryStatus: parsed === null ? 'unavailable' : 'available', quotaHistory: parsed ?? [] };
+            }
+            yield { part: result.part, dashboard, stale: false };
+        }
+        dashboard = { ...dashboard, availabilityIssue: [...completed.values()].every((ok) => !ok) ? 'web-api-unavailable' : null };
+        yield { part: 'complete', dashboard, stale: false };
+        if (logoLoad !== undefined) {
+            dashboard = { ...dashboard, quotas: await logoLoad };
+            yield { part: 'logos', dashboard, stale: false };
+        }
+    }
+    async timedDashboardRead(part, read) {
+        const started = this.now();
+        try {
+            return { part: part === 'quota-logos' ? 'logos' : part, value: await read(), ok: true };
+        }
+        finally {
+            this.onDashboardTiming?.({ part, elapsedMs: Math.max(0, this.now() - started) });
+        }
+    }
+    /** Read one bounded Web API ledger page and exact-match session identities on Host. */
+    async readRequestPage(options, signal) {
+        signal?.throwIfAborted();
+        if (!isMagpieDashboardPeriod(options.period)
+            || !Number.isSafeInteger(options.offset) || options.offset < 0 || options.offset > 1_000_000
+            || !Number.isSafeInteger(options.limit) || options.limit < 1 || options.limit > 100)
+            return null;
+        const sessionId = options.sessionId === undefined ? null : cleanText(options.sessionId);
+        const sessionAgent = options.sessionAgent === undefined ? null : cleanText(options.sessionAgent);
+        if ((options.sessionId !== undefined && sessionId === null)
+            || (options.sessionAgent !== undefined && (sessionAgent === null || !isMagpieAgentId(sessionAgent)))
+            || ((sessionId === null) !== (sessionAgent === null)))
+            return null;
+        const query = new URLSearchParams({ period: magpieWebPeriod(options.period), limit: String(options.limit), offset: String(options.offset) });
+        if (sessionId !== null)
+            query.set('q', sessionId);
+        const response = await this.readWebJson(`/api/usage/requests?${query.toString()}`, signal);
+        if (!response.ok)
+            return null;
+        const root = asRecord(response.value);
+        const rawRows = root?.rows;
+        if (!Array.isArray(rawRows) || rawRows.length > 500)
+            return null;
+        const candidates = rawRows.flatMap((row) => {
+            const record = asRecord(row);
+            if (record === null)
+                return [];
+            const candidateSession = cleanText(record.session);
+            const nativeSession = cleanText(record.native_session);
+            const agent = cleanText(record.agent);
+            const acceptedAgents = sessionAgent === null ? [] : MAGPIE_USAGE_AGENT_ALIASES[sessionAgent] ?? [sessionAgent];
+            if (sessionId !== null
+                && (candidateSession !== sessionId && nativeSession !== sessionId || agent === null || !acceptedAgents.includes(agent)))
+                return [];
+            const item = parseMagpieRequest(record);
+            return item === null ? [] : [sessionId === null ? item : { ...item, sessionId }];
+        });
+        const total = sessionId === null ? safeCount(root?.total) : null;
+        return {
+            period: options.period,
+            offset: options.offset,
+            limit: options.limit,
+            total,
+            hasMore: total === null ? rawRows.length >= options.limit : options.offset + rawRows.length < total,
+            sessionId,
+            sessionAgent,
+            items: candidates.slice(0, options.limit),
+        };
+    }
+    async readFromWeb(agent, modelId, sessionId, magpieSessionId, fallbackSessionId, signal, includeRoute) {
         const capturedAt = new Date(this.now()).toISOString();
-        if (gatewayOrigin === null)
-            return unavailableMagpieSnapshot(agent, modelId, sessionId, this.now(), capturedAt);
         const [usageResult, quotaResult] = await Promise.all([
-            this.readGatewayJson(gatewayOrigin, '/v1/magpie/usage?period=today', signal),
-            this.readGatewayJson(gatewayOrigin, '/v1/magpie/quotas', signal),
+            this.readWebJson('/api/usage?period=today', signal),
+            this.readWebJson('/api/usage/quotas', signal),
         ]);
         const aggregate = usageResult.ok ? readTotals(usageResult.value) : null;
-        const sessionUsage = usageResult.ok && sessionId !== null
-            ? readSession(usageResult.value, agent, sessionId)
+        const primarySession = usageResult.ok && magpieSessionId !== null
+            ? readSession(usageResult.value, agent, magpieSessionId)
+            : null;
+        const fallbackSession = primarySession === null && usageResult.ok && fallbackSessionId !== null
+            ? readSession(usageResult.value, agent, fallbackSessionId)
             : null;
-        // A providerSessionId is not enough to prove that Magpie knows this Agent
-        // session. Require the exact Agent + ID pair in Magpie's own usage result
-        // before asking the route endpoint, and then verify its echoed identity.
-        const canReadRoute = includeRoute && sessionId !== null && sessionId.length <= 128 && sessionUsage !== null;
-        const routeResultPromise = canReadRoute
-            ? this.readGatewayJson(gatewayOrigin, `/v1/magpie/route?session=${encodeURIComponent(sessionId)}`, signal)
-            : Promise.resolve({ ok: false });
-        const routeHistoryResultPromise = canReadRoute
-            ? this.readGatewayJson(gatewayOrigin, `/v1/magpie/usage/requests?period=today&q=${encodeURIComponent(sessionId)}&limit=100`, signal)
-            : Promise.resolve({ ok: false });
-        const [routeResult, routeHistoryResult] = await Promise.all([routeResultPromise, routeHistoryResultPromise]);
-        const routeRead = sessionId === null
-            ? { status: 'session-unavailable', route: null }
-            : !includeRoute
-                ? { status: 'not-requested', route: null }
-                : !canReadRoute
-                    ? { status: 'unavailable', route: null }
-                    : !routeResult.ok
-                        ? { status: 'unavailable', route: null }
-                        : readRoute(routeResult.value, sessionId);
-        const routeHistory = routeHistoryResult.ok && sessionId !== null && sessionUsage !== null
-            ? readSessionRouteHistory(routeHistoryResult.value, agent, sessionId)
+        const sessionUsage = primarySession ?? fallbackSession;
+        const resolvedSessionId = primarySession !== null ? magpieSessionId : fallbackSession !== null ? fallbackSessionId : magpieSessionId;
+        if (sessionUsage === null)
+            return null;
+        const canReadRoute = includeRoute && resolvedSessionId !== null && resolvedSessionId.length <= 128;
+        const routeHistoryResult = canReadRoute
+            ? await this.readWebJson(`/api/usage/requests?period=today&offset=0&limit=100&q=${encodeURIComponent(resolvedSessionId)}`, signal)
+            : { ok: false };
+        const routeRows = routeHistoryResult.ok ? asRecord(routeHistoryResult.value)?.rows : null;
+        const routeHistoryValid = Array.isArray(routeRows) && routeRows.length <= 500;
+        const routeHistory = routeHistoryResult.ok && routeHistoryValid && resolvedSessionId !== null
+            ? readSessionRouteHistory(routeHistoryResult.value, agent, resolvedSessionId)
             : [];
-        const route = routeRead.route === null
-            ? routeHistory[0]?.route ?? null
-            : enrichRouteWithHistory(routeRead.route, routeHistory);
+        const route = routeHistory[0]?.route ?? null;
         const routeStatus = route !== null
             ? 'available'
-            : routeRead.status;
+            : resolvedSessionId === null
+                ? 'session-unavailable'
+                : !includeRoute
+                    ? 'not-requested'
+                    : !canReadRoute || !routeHistoryValid
+                        ? 'unavailable'
+                        : 'no-route';
         const allQuotas = quotaResult.ok ? parseMagpieQuotas(quotaResult.value) : null;
         const routeProviders = [...new Set([
                 providerFromRoute(route),
@@ -224,9 +391,15 @@ export class MagpieUsageService {
             ? routeProviders
             : [providerFromModelId(modelId, agent)].filter((provider) => provider !== null);
         const upstreamProvider = upstreamProviders[0] ?? null;
-        const quotas = allQuotas === null
+        const sessionQuotas = allQuotas === null
             ? []
             : filterSessionQuotas(allQuotas, upstreamProviders, routeHistory);
+        const matchingQuotas = markSessionAccounts(sessionQuotas, routeHistory, route);
+        const quotas = allQuotas === null ? [] : await this.attachQuotaLogos(matchingQuotas, signal);
+        // 同厂商的其它账号单独下发：客户端分组展示，但绝不参与本会话余量。
+        const siblingQuotas = allQuotas === null
+            ? []
+            : await this.attachQuotaLogos(otherProviderAccounts(allQuotas, upstreamProviders, sessionQuotas), signal);
         return {
             agent,
             modelId,
@@ -241,8 +414,47 @@ export class MagpieUsageService {
             upstreamProviders,
             quotaStatus: allQuotas === null ? 'unavailable' : upstreamProviders.length === 0 ? 'provider-unavailable' : 'available',
             quotas,
+            ...(siblingQuotas.length === 0 ? {} : { providerAccounts: siblingQuotas }),
         };
     }
+    async attachQuotaLogos(quotas, signal) {
+        const requestAssetDataUrl = this.webApi?.requestAssetDataUrl;
+        if (typeof requestAssetDataUrl !== 'function')
+            return quotas;
+        const icons = [...new Set(quotas
+                .map((quota) => quota.icon)
+                .filter((icon) => icon !== undefined))].slice(0, MAX_MAGPIE_ICON_FETCHES);
+        if (icons.length === 0)
+            return quotas;
+        const logos = new Map();
+        await Promise.all(icons.map(async (icon) => {
+            const cached = this.quotaLogoCache.get(icon);
+            const logo = cached === undefined ? await this.readMagpieLogoDataUrl(icon, signal) : cached;
+            if (cached === undefined)
+                this.quotaLogoCache.set(icon, logo);
+            logos.set(icon, logo);
+        }));
+        return quotas.map((quota) => {
+            const logoDataUrl = quota.icon === undefined ? null : logos.get(quota.icon) ?? null;
+            return logoDataUrl === null ? quota : { ...quota, logoDataUrl };
+        });
+    }
+    async readMagpieLogoDataUrl(icon, signal) {
+        const requestAssetDataUrl = this.webApi?.requestAssetDataUrl;
+        if (typeof requestAssetDataUrl !== 'function')
+            return null;
+        for (const path of magpieIconAssetPaths(icon)) {
+            try {
+                const value = await requestAssetDataUrl.call(this.webApi, path, signal === undefined ? {} : { signal });
+                if (value !== null && value !== '')
+                    return value;
+            }
+            catch {
+                signal?.throwIfAborted();
+            }
+        }
+        return null;
+    }
     async loadCatalog(agent, signal) {
         const cached = this.catalogs.get(agent);
         const cacheTtl = cached?.catalog === null ? MAGPIE_FAILURE_CACHE_TTL_MS : MAGPIE_CATALOG_TTL_MS;
@@ -264,7 +476,12 @@ export class MagpieUsageService {
                     .catch(() => null);
             const [supported, catalog] = await Promise.all([supportedRequest, catalogRequest]);
             const result = supported ? catalog : null;
-            this.catalogs.set(agent, { catalog: result, loadedAt: this.now() });
+            const unavailableIssue = result !== null
+                ? null
+                : !supported
+                    ? this.versionCheck?.executableAvailable === true ? 'cli-version-unsupported' : 'cli-unavailable'
+                    : 'model-catalog-unavailable';
+            this.catalogs.set(agent, { catalog: result, unavailableIssue, loadedAt: this.now() });
             return result;
         })
             .catch(() => null)
@@ -320,13 +537,13 @@ export class MagpieUsageService {
         if (this.versionLoad !== undefined)
             return awaitWithSignal(this.versionLoad, signal);
         const load = this.readVersion(this.lifetimeSignal)
-            .then((value) => parseMagpieCliVersion(value))
-            .then((supported) => {
-            this.versionCheck = { supported, checkedAt: this.now() };
+            .then((value) => {
+            const supported = parseMagpieCliVersion(value);
+            this.versionCheck = { supported, executableAvailable: value !== null, checkedAt: this.now() };
             return supported;
         })
             .catch(() => {
-            this.versionCheck = { supported: false, checkedAt: this.now() };
+            this.versionCheck = { supported: false, executableAvailable: false, checkedAt: this.now() };
             return false;
         })
             .finally(() => { if (this.versionLoad === load)
@@ -363,22 +580,17 @@ export class MagpieUsageService {
             return { ok: false };
         }
     }
-}
-function unavailableMagpieSnapshot(agent, modelId, sessionId, now, capturedAt = new Date(now).toISOString()) {
-    return {
-        agent,
-        modelId,
-        capturedAt,
-        usageStatus: 'unavailable',
-        aggregate: null,
-        sessionId,
-        session: null,
-        routeStatus: sessionId === null ? 'session-unavailable' : 'unavailable',
-        route: null,
-        upstreamProvider: providerFromModelId(modelId, agent),
-        quotaStatus: 'unavailable',
-        quotas: [],
-    };
+    async readWebJson(path, signal) {
+        if (this.webApi === undefined)
+            return { ok: false };
+        try {
+            return { ok: true, value: await this.webApi.requestJson(path, signal === undefined ? {} : { signal }) };
+        }
+        catch {
+            signal?.throwIfAborted();
+            return { ok: false };
+        }
+    }
 }
 function awaitWithSignal(task, signal) {
     if (signal === undefined)
@@ -635,13 +847,71 @@ async function runMagpieCommand(args, signal) {
 }
 /**
  * Magpie IDs normally match adapter IDs. Keep naming differences explicit;
- * every result is still checked against Magpie's own catalog output before
- * any Gateway request is made.
+ * it is used for exact Agent identity matching in Magpie usage records.
  */
 export function magpieAgentForAdapter(adapterId) {
     const agent = MAGPIE_AGENT_BY_ADAPTER[adapterId];
     return agent !== undefined && isMagpieAgentId(agent) ? agent : null;
 }
+/** Return the exact Magpie Agent identities accepted for one adapter. */
+export function magpieUsageAgentAliases(adapterId) {
+    const agent = magpieAgentForAdapter(adapterId);
+    return agent === null ? [] : MAGPIE_USAGE_AGENT_ALIASES[agent] ?? [agent];
+}
+/**
+ * Enrich dashboard session rows only after an exact `(Agent, session ID)` match.
+ * Provider session IDs and DSH IDs are both candidates because Command Code and
+ * native DSH use different identities across Magpie versions.
+ */
+export function attachMagpieSessionNames(dashboard, bindings) {
+    if (!Array.isArray(dashboard.sessions) || bindings.length === 0)
+        return dashboard;
+    const names = new Map();
+    const ambiguous = new Set();
+    for (const binding of bindings) {
+        const name = cleanSessionName(binding.name);
+        const dshSessionId = cleanText(binding.dshSessionId);
+        if (name === null || dshSessionId === null)
+            continue;
+        // Match the identity strategy used by compact usage: native DSH uses its
+        // DSH ID, Command Code may use either injected DSH or ACP ID, and other
+        // adapters use only their Provider session ID.
+        const providerSessionId = cleanText(binding.providerSessionId);
+        const ids = new Set((binding.adapterId === 'dsh'
+            ? [dshSessionId]
+            : binding.adapterId === 'command-code'
+                ? [dshSessionId, providerSessionId]
+                : [providerSessionId]).filter((value) => value !== null));
+        for (const agent of magpieUsageAgentAliases(binding.adapterId)) {
+            for (const id of ids) {
+                const key = `${agent}\u0000${id}`;
+                if (ambiguous.has(key))
+                    continue;
+                const previous = names.get(key);
+                if (previous !== undefined && previous !== name) {
+                    names.delete(key);
+                    ambiguous.add(key);
+                }
+                else {
+                    names.set(key, name);
+                }
+            }
+        }
+    }
+    if (names.size === 0)
+        return dashboard;
+    let changed = false;
+    const sessions = dashboard.sessions.map((session) => {
+        if (session.dshSessionName !== undefined)
+            return session;
+        const name = names.get(`${session.agent}\u0000${session.id}`);
+        if (name === undefined)
+            return session;
+        changed = true;
+        return { ...session, dshSessionName: name };
+    });
+    return changed ? { ...dashboard, sessions } : dashboard;
+}
 function isMagpieAgentId(value) {
     return value.length <= 64 && /^[a-z0-9][a-z0-9-]*$/u.test(value);
 }
@@ -728,46 +998,6 @@ function readSession(value, agent, sessionId) {
     const usageAgent = cleanText(record?.agent);
     return record !== null && usageAgent !== null && totals !== null ? { id: sessionId, agent: usageAgent, ...totals } : null;
 }
-function readRoute(value, expectedSessionId) {
-    const envelope = asRecord(value);
-    if (envelope === null || cleanText(envelope.session) !== expectedSessionId || !('route' in envelope))
-        return { status: 'unavailable', route: null };
-    if (envelope.route === null)
-        return { status: 'no-route', route: null };
-    const record = asRecord(envelope.route);
-    if (record === null)
-        return { status: 'unavailable', route: null };
-    const tries = Array.isArray(record.tries)
-        ? record.tries.slice(0, 20).flatMap((item) => {
-            const attempt = asRecord(item);
-            if (attempt === null)
-                return [];
-            const model = routeText(attempt.model);
-            const provider = routeText(attempt.provider);
-            return [{
-                    model: model !== null && provider !== null && !model.includes('/') ? `${provider}/${model}` : model ?? provider,
-                    failed: routeText(attempt.fail) !== null,
-                }];
-        })
-        : [];
-    return {
-        status: 'available',
-        route: {
-            asked: routeText(record.asked),
-            group: routeText(record.group),
-            rule: readRule(record.rule),
-            model: routeText(record.model),
-            effort: routeText(record.effort),
-            tries,
-            done: typeof record.done === 'boolean' ? record.done : null,
-            status: routeStatusText(record.status),
-            served: routeText(record.served),
-            routeId: safeRouteId(record.id),
-            time: routeText(record.time),
-            providerAccount: routeText(record.providerAccount),
-        },
-    };
-}
 /** Read the durable request ledger when Magpie's short in-memory trace has expired. */
 function readSessionRouteHistory(value, agent, sessionId) {
     const rows = asRecord(value)?.rows;
@@ -814,18 +1044,19 @@ function routeTime(value) {
     const time = Date.parse(value);
     return Number.isFinite(time) ? time : 0;
 }
-function enrichRouteWithHistory(route, history) {
-    if (route.routeId === undefined || route.routeId === null)
-        return route;
-    const record = history.find((item) => item.route.routeId === route.routeId);
-    if (record === undefined)
-        return route;
-    return {
-        ...route,
-        time: route.time ?? record.route.time ?? null,
-        providerAccount: route.providerAccount ?? record.account,
-    };
-}
+/**
+ * 选出本会话确实使用过的上游账号配额。
+ *
+ * 归属必须严格：请求历史里没有出现的账号不能算作本会话的配额。
+ *
+ * - 账号维度能对上：只留命中的账号。
+ * - 上游不提供账号名（Codex 这类量贩账号没有 `user`），无从按账号筛选：保留该厂商
+ *   全部候选。过去这里返回空数组，`quotaStatus` 仍是 `available`，界面就只剩下
+ *   "上游没有报告配额窗口"的空态 —— 明明识别出了 `glorinfo-api-platform`，却看不到
+ *   它的额度。
+ * - 有账号记录但一条都不匹配：返回空，宁可显示"没有可用配额"也不能把别的账号的额度
+ *   说成本会话的。
+ */
 function filterSessionQuotas(quotas, providers, history) {
     return providers.flatMap((provider) => {
         const candidates = quotas.filter((quota) => quota.provider === provider);
@@ -834,7 +1065,53 @@ function filterSessionQuotas(quotas, providers, history) {
             .map((record) => record.account));
         if (accounts.size === 0)
             return candidates;
-        return candidates.filter((quota) => quota.user !== null && accounts.has(quota.user));
+        const matched = candidates.filter((quota) => quota.user !== null && accounts.has(quota.user));
+        return matched.length > 0 ? matched : candidates.filter((quota) => quota.user === null);
+    });
+}
+/**
+ * 与本会话同一厂商、但本会话没用过的其它账号。
+ *
+ * 单独返回而不是并进 `quotas`：客户端用它们做"同厂商账号分组"的补充展示，
+ * 但这些账号的额度绝不参与本会话余量判断。顺序沿用上游。
+ */
+function otherProviderAccounts(quotas, providers, sessionQuotas) {
+    const claimed = new Set(sessionQuotas.map((quota) => `${quota.provider}\u0000${quota.user ?? ''}`));
+    return providers.flatMap((provider) => quotas
+        .filter((quota) => quota.provider === provider)
+        .filter((quota) => quota.user !== null && !claimed.has(`${quota.provider}\u0000${quota.user}`)));
+}
+/**
+ * 标记本会话实际使用过的账号。
+ *
+ * 只有能追溯到会话请求记录的账号才标 `active`；route 的账号字段优先于请求历史，
+ * 因为它来自 Magpie 对这一次请求的精确归属。
+ *
+ * 账号名比对必须同时限定厂商：不同厂商的账号名会重名（WorkBuddy 与 WorkBuddy AI 都有
+ * `zj59122704501@gmail.com`），只比名字会把别的厂商的账号标成本会话正在使用。
+ * 无法确认时保持未标记，客户端据此显示"未知活动账号"，而不是随便挑一个账号当"正在使用"。
+ */
+function markSessionAccounts(quotas, history, route) {
+    const used = new Set(history
+        .filter((record) => record.account !== null)
+        .map((record) => `${record.provider}\u0000${record.account}`));
+    const routedProvider = providerFromRoute(route);
+    const routedAccount = route?.providerAccount ?? null;
+    const routedKey = routedAccount === null || routedProvider === null ? null : `${routedProvider}\u0000${routedAccount}`;
+    if (used.size === 0 && routedKey === null)
+        return quotas;
+    // 每个厂商只承认一个活动账号：精确路由优先，其次是首个命中的历史账号。
+    const claimed = new Set();
+    return quotas.map((quota) => {
+        if (quota.user === null)
+            return quota;
+        const key = `${quota.provider}\u0000${quota.user}`;
+        if (claimed.has(key))
+            return quota;
+        if (key !== routedKey && !used.has(key))
+            return quota;
+        claimed.add(key);
+        return { ...quota, active: true };
     });
 }
 function safeRouteId(value) {
@@ -866,6 +1143,100 @@ export function parseMagpieQuotas(value) {
         quotas.push({
             provider,
             name,
+            ...optionalQuotaIcon(record.icon),
+            kind: routeText(record.kind),
+            user: routeText(record.user),
+            plan: routeText(record.plan),
+            alias: routeText(record.alias),
+            balance: routeText(record.balance),
+            readAt: routeText(record.readAt),
+            windows,
+            ...sessionQuotaDaily(record),
+            ...readQuotaAccountMeta(record),
+        });
+    }
+    return quotas;
+}
+/** Normalize the live aggregate and per-dimension usage response. */
+export function parseMagpieDashboardUsage(value) {
+    const root = asRecord(value);
+    if (root === null)
+        return null;
+    const hasMetrics = ['calls', 'errors', 'input', 'output', 'cache_read', 'cache_write', 'cost'].some((key) => key in root);
+    if (!hasMetrics && !Array.isArray(root.series) && !Array.isArray(root.sessions))
+        return null;
+    const series = readMagpieSeries(root.series);
+    const agents = readMagpieUsageGroups(root.agents, 'agent');
+    const providers = readMagpieUsageGroups(root.providerKeys ?? root.providers, 'provider');
+    const models = readMagpieUsageGroups(root.models, 'model');
+    const accounts = readMagpieUsageGroups(root.accounts, 'account');
+    const sessions = readMagpieUsageSessions(root.sessions);
+    if (series === null || agents === null || providers === null || models === null || accounts === null || sessions === null)
+        return null;
+    return {
+        aggregate: readMagpieUsageMetrics(root),
+        series,
+        agents,
+        providers,
+        models,
+        accounts,
+        sessions,
+        sessionCount: safeCount(root.sessionCount),
+    };
+}
+/** Normalize quota cards while preserving nullable values and bounded history. */
+export function parseMagpieQuotaCards(value) {
+    const root = asRecord(value);
+    const rows = Array.isArray(value) ? value : Array.isArray(root?.data) ? root.data : null;
+    if (rows === null || rows.length > 512)
+        return null;
+    const quotas = [];
+    for (const row of rows) {
+        const record = asRecord(row);
+        const provider = routeText(record?.provider);
+        const name = routeText(record?.name);
+        if (record === null || provider === null || name === null
+            || !Array.isArray(record.windows) || record.windows.length > 64)
+            return null;
+        const windows = record.windows.flatMap((item) => {
+            const window = asRecord(item);
+            const windowName = routeText(window?.name);
+            if (window === null || windowName === null)
+                return [];
+            return [{
+                    name: windowName,
+                    usedPercent: quotaUsedPercent(window),
+                    remainingPercent: quotaRemainingPercent(window),
+                    resetsAt: routeText(window.resetsAt),
+                    display: routeText(window.display),
+                    amount: safeDecimal(window.amount),
+                    limit: safeDecimal(window.limit),
+                    unit: routeText(window.unit),
+                    holdsWhy: routeText(window.holdsWhy),
+                    runsOutAt: routeText(window.runsOutAt),
+                    runsOut: safeDecimal(window.runsOut),
+                }];
+        });
+        if (windows.length !== record.windows.length)
+            return null;
+        const dailyRecord = record.daily === undefined ? null : asRecord(record.daily);
+        const dailyPoints = dailyRecord === null ? [] : dailyRecord.days;
+        if (dailyRecord !== null && (!Array.isArray(dailyPoints) || dailyPoints.length > 366))
+            return null;
+        const days = (Array.isArray(dailyPoints) ? dailyPoints : []).flatMap((item) => {
+            const point = asRecord(item);
+            const day = routeText(point?.day);
+            if (point === null || day === null)
+                return [];
+            const used = safeDecimal(point.used);
+            return [{ day, used }];
+        });
+        if (days.length !== (Array.isArray(dailyPoints) ? dailyPoints.length : 0))
+            return null;
+        quotas.push({
+            provider,
+            name,
+            ...optionalQuotaIcon(record.icon),
             kind: routeText(record.kind),
             user: routeText(record.user),
             plan: routeText(record.plan),
@@ -873,22 +1244,369 @@ export function parseMagpieQuotas(value) {
             balance: routeText(record.balance),
             readAt: routeText(record.readAt),
             windows,
+            daily: { since: routeText(dailyRecord?.since), days },
+            ...readQuotaAccountMeta(record),
         });
     }
     return quotas;
 }
+export function parseMagpieQuotaHistory(value) {
+    const root = asRecord(value);
+    const rows = Array.isArray(value) ? value : Array.isArray(root?.data) ? root.data : null;
+    if (rows === null || rows.length > 512)
+        return null;
+    const history = [];
+    for (const row of rows) {
+        const record = asRecord(row);
+        const provider = routeText(record?.provider);
+        if (record === null || provider === null || !Array.isArray(record.lines) || record.lines.length > 64)
+            return null;
+        const lines = record.lines.flatMap((item) => {
+            const line = asRecord(item);
+            const name = routeText(line?.name);
+            if (line === null || name === null || !Array.isArray(line.points) || line.points.length > 2_000)
+                return [];
+            const points = line.points.flatMap((pointValue) => {
+                const point = asRecord(pointValue);
+                const at = routeText(point?.at);
+                return point === null || at === null ? [] : [{
+                        at,
+                        left: safeDecimal(point.left),
+                        start: routeText(point.start),
+                        resetsAt: routeText(point.resetsAt),
+                    }];
+            });
+            if (points.length !== line.points.length)
+                return [];
+            return [{ name, points }];
+        });
+        if (lines.length !== record.lines.length)
+            return null;
+        history.push({ provider, user: routeText(record.user), lines });
+    }
+    return history;
+}
+function readMagpieUsageMetrics(record) {
+    return {
+        calls: safeCount(record.calls),
+        errors: safeCount(record.errors),
+        retried: safeCount(record.retried),
+        inputTokens: safeCount(record.input),
+        outputTokens: safeCount(record.output),
+        cacheReadTokens: safeCount(record.cache_read),
+        cacheWriteTokens: safeCount(record.cache_write),
+        reasoningTokens: safeCount(record.reasoning),
+        cost: safeDecimal(record.cost),
+        unpriced: safeDecimal(record.unpriced),
+        credits: safeDecimal(record.credits),
+        credited: safeDecimal(record.credited),
+        timed: safeCount(record.timed),
+        ttftMs: safeDecimal(record.ttft_ms),
+        decodeMs: safeDecimal(record.decode_ms),
+        decodeTokens: safeCount(record.decode_out),
+        decodeCount: safeCount(record.decode_n),
+    };
+}
+function readMagpieSeries(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 2_000)
+        return null;
+    return value.flatMap((item) => {
+        const record = asRecord(item);
+        return record === null ? [] : [{
+                time: routeText(record.time),
+                label: routeText(record.label),
+                ...readMagpieUsageMetrics(record),
+            }];
+    });
+}
+function readMagpieUsageGroups(value, dimension) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 2_000)
+        return null;
+    const idKeys = {
+        agent: ['id', 'agent'],
+        provider: ['provider', 'id'],
+        model: ['model', 'id'],
+        account: ['account', 'id'],
+    };
+    const groups = value.flatMap((item) => {
+        const record = asRecord(item);
+        if (record === null)
+            return [];
+        const id = firstRouteText(record, idKeys[dimension]);
+        if (id === null)
+            return [];
+        return [{
+                id,
+                name: routeText(record.name),
+                provider: routeText(record.provider),
+                model: routeText(record.model),
+                account: routeText(record.account),
+                agent: routeText(record.agent ?? record.id),
+                ...readMagpieUsageMetrics(record),
+            }];
+    });
+    if (dimension !== 'provider')
+        return groups;
+    const byProvider = new Map();
+    for (const group of groups) {
+        const current = byProvider.get(group.id);
+        if (current === undefined) {
+            byProvider.set(group.id, group);
+            continue;
+        }
+        byProvider.set(group.id, {
+            ...current,
+            calls: sumNullable(current.calls, group.calls),
+            errors: sumNullable(current.errors, group.errors),
+            retried: sumNullable(current.retried, group.retried),
+            inputTokens: sumNullable(current.inputTokens, group.inputTokens),
+            outputTokens: sumNullable(current.outputTokens, group.outputTokens),
+            cacheReadTokens: sumNullable(current.cacheReadTokens, group.cacheReadTokens),
+            cacheWriteTokens: sumNullable(current.cacheWriteTokens, group.cacheWriteTokens),
+            reasoningTokens: sumNullable(current.reasoningTokens, group.reasoningTokens),
+            cost: sumNullable(current.cost, group.cost),
+            unpriced: sumNullable(current.unpriced, group.unpriced),
+            credits: sumNullable(current.credits, group.credits),
+            credited: sumNullable(current.credited, group.credited),
+            timed: sumNullable(current.timed, group.timed),
+            ttftMs: null,
+            decodeMs: null,
+            decodeTokens: sumNullable(current.decodeTokens, group.decodeTokens),
+            decodeCount: sumNullable(current.decodeCount, group.decodeCount),
+        });
+    }
+    return [...byProvider.values()];
+}
+function readMagpieUsageSessions(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 2_000)
+        return null;
+    return value.flatMap((item) => {
+        const record = asRecord(item);
+        const id = cleanText(record?.id);
+        const agent = cleanText(record?.agent);
+        return record === null || id === null || agent === null ? [] : [{ id, agent, ...readMagpieUsageMetrics(record) }];
+    });
+}
+function parseMagpieRequest(record) {
+    const agent = routeText(record.agent);
+    const provider = routeText(record.provider);
+    const requestedModel = routeText(record.req);
+    const servedModel = routeText(record.served);
+    const group = requestedModel?.startsWith('group/') === true ? requestedModel.slice('group/'.length) : null;
+    return {
+        routeId: safeRouteId(record.route_id),
+        time: routeText(record.t),
+        agent,
+        provider,
+        account: routeText(record.providerAccount),
+        requestedModel,
+        servedModel,
+        group,
+        effort: routeText(record.effort),
+        inputTokens: safeCount(record.in),
+        outputTokens: safeCount(record.out),
+        cacheReadTokens: safeCount(record.cache_read),
+        cacheWriteTokens: safeCount(record.cache_write),
+        reasoningTokens: safeCount(record.reasoning),
+        cost: safeDecimal(record.cost),
+        priced: typeof record.priced === 'boolean' ? record.priced : null,
+        status: routeStatusText(record.status),
+        durationMs: safeDecimal(record.ms),
+        ttftMs: safeDecimal(record.ttft_ms),
+        firstTextMs: safeDecimal(record.first_text_ms),
+        firstReasoningMs: safeDecimal(record.first_reasoning_ms),
+        flowMs: safeDecimal(record.flow_ms),
+        sessionId: cleanText(record.session) ?? cleanText(record.native_session),
+    };
+}
+function firstRouteText(record, keys) {
+    for (const key of keys) {
+        const value = routeText(record[key]);
+        if (value !== null)
+            return value;
+    }
+    return null;
+}
+function sumNullable(left, right) {
+    return left === null && right === null ? null : (left ?? 0) + (right ?? 0);
+}
+function isMagpieDashboardPeriod(value) {
+    return value === 'today' || value === 'week' || value === 'month' || value === 'all';
+}
+function magpieWebPeriod(period) {
+    switch (period) {
+        case 'today': return 'today';
+        case 'week': return '7d';
+        case 'month': return '30d';
+        case 'all': return 'all';
+    }
+}
+function emptyMagpieDashboard(period, capturedAt) {
+    return {
+        period,
+        capturedAt,
+        availabilityIssue: null,
+        usageStatus: 'unavailable',
+        aggregate: null,
+        series: [],
+        agents: [],
+        providers: [],
+        models: [],
+        accounts: [],
+        sessions: [],
+        sessionCount: null,
+        quotaStatus: 'unavailable',
+        quotas: [],
+        quotaHistoryStatus: 'unavailable',
+        quotaHistory: [],
+    };
+}
+/**
+ * 窗口使用的百分比。
+ *
+ * Magpie 的 `used` 始终是 0–100 的百分比（见其 `auth.usage` 契约），但 `remaining`
+ * 不一定：同一份数据里既有 `remaining: 96` 这种百分比，也有 `remaining: 86.57`
+ * 配 `amount: 322.25 / limit: 2400` 这种"剩余量"。凡是带 `limit`（或 `amount`）的窗口，
+ * `remaining` 一律按数量解释，不能直接当成 0–100 的百分比，否则 WorkBuddy 的
+ * `322 / 2400` 会被读成"剩余 86.57%"，和 `display` 里的数量对不上。
+ */
+function quotaUsedPercent(record) {
+    return safePercent(record.used);
+}
+function quotaRemainingPercent(record) {
+    const counted = safeDecimal(record.limit) !== null || safeDecimal(record.amount) !== null;
+    if (counted) {
+        const used = quotaUsedPercent(record);
+        return used === null ? null : 100 - used;
+    }
+    return safePercent(record.remaining);
+}
 function readQuotaWindow(record, name) {
     return {
         name,
-        usedPercent: safePercent(record.used),
-        remainingPercent: safePercent(record.remaining),
+        usedPercent: quotaUsedPercent(record),
+        remainingPercent: quotaRemainingPercent(record),
         resetsAt: routeText(record.resetsAt),
         display: routeText(record.display),
         amount: safeDecimal(record.amount),
         limit: safeDecimal(record.limit),
         unit: routeText(record.unit),
         holdsWhy: routeText(record.holdsWhy),
+        startsAt: routeText(record.startsAt),
+        runsOut: safeDecimal(record.runsOut),
+        runsOutAt: routeText(record.runsOutAt),
+    };
+}
+/**
+ * Read the daily check-in result of providers that have one (WorkBuddy, Trae, MiniMax).
+ *
+ * `outcome` stays an upstream string: the client only localizes the outcomes it knows, so a
+ * new vendor state never gets presented as a successful check-in.
+ */
+function readQuotaCheckin(value) {
+    const record = asRecord(value);
+    if (record === null)
+        return null;
+    const checkin = {
+        day: routeText(record.day),
+        at: routeText(record.at),
+        outcome: routeText(record.outcome),
+        credit: safeDecimal(record.credit),
+        streak: safeCount(record.streak),
     };
+    return Object.values(checkin).every((item) => item === null) ? null : checkin;
+}
+function readQuotaDaily(value) {
+    const record = asRecord(value);
+    if (record === null)
+        return undefined;
+    const points = record.days;
+    if (!Array.isArray(points) || points.length > 366)
+        return undefined;
+    const days = points.flatMap((item) => {
+        const point = asRecord(item);
+        const day = routeText(point?.day);
+        return point === null || day === null ? [] : [{ day, used: safeDecimal(point.used) }];
+    });
+    if (days.length !== points.length)
+        return undefined;
+    return { since: routeText(record.since), days };
+}
+/**
+ * Read a provider's remaining reset cards without exposing the vendor's raw record.
+ *
+ * `count` 缺失与 0 不同：上游在 0 张时会省略整个对象，因此这里只在对象存在时才返回，
+ * 客户端把缺失显示为"未知"而不是"没有可用重置卡"。
+ */
+function readQuotaResets(value) {
+    const record = asRecord(value);
+    if (record === null)
+        return null;
+    const eachPoints = record.each;
+    const each = Array.isArray(eachPoints)
+        ? eachPoints.flatMap((item) => {
+            const point = asRecord(item);
+            if (point === null)
+                return [];
+            return [{ window: routeText(point.window), until: routeText(point.until) }];
+        }).slice(0, 64)
+        : [];
+    return {
+        count: safeCount(record.count),
+        until: routeText(record.until),
+        each,
+        byWindow: record.byWindow === true,
+        fiveHour: safeCount(record.fiveHour),
+        weekly: safeCount(record.weekly),
+    };
+}
+/** 会话级配额卡只带上 `daily`；上游缺字段时整个属性不出现。 */
+function sessionQuotaDaily(record) {
+    const daily = readQuotaDaily(record.daily);
+    return daily === undefined ? {} : { daily };
+}
+/**
+ * Read the account-level fields shared by both quota parsers.
+ *
+ * `/api/usage/quotas` (session popover) and the dashboard read the same rows; keeping these
+ * fields in one place stops the two views drifting apart. Absent values stay `undefined` so
+ * older Magpie builds keep working.
+ */
+function readQuotaAccountMeta(record) {
+    const checkin = readQuotaCheckin(record.checkin);
+    const resets = readQuotaResets(record.resets);
+    return {
+        ...(typeof record.active === 'boolean' ? { active: record.active } : {}),
+        ...(checkin === null ? {} : { checkin }),
+        ...(record.checkins === true ? { checkins: true } : {}),
+        error: routeText(record.error),
+        until: routeText(record.until),
+        renew: routeText(record.renew),
+        ...(resets === null ? {} : { resets }),
+        credits: routeText(record.credits),
+    };
+}
+function optionalQuotaIcon(value) {
+    const icon = routeText(value);
+    if (icon === null)
+        return {};
+    if (/^file:[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/u.test(icon))
+        return { icon };
+    return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(icon) ? { icon } : {};
+}
+function magpieIconAssetPaths(icon) {
+    if (/^file:[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/u.test(icon)) {
+        return [`/api/icons/${encodeURIComponent(icon.slice('file:'.length))}`];
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(icon))
+        return [];
+    return [`/icons/${icon}.svg`, `/icons/${icon}.png`];
 }
 function providerFromRoute(route) {
     if (route === null)
@@ -947,6 +1665,12 @@ function cleanText(value) {
     const text = value.trim();
     return text === '' || text.length > 512 || /[\u0000-\u001f\u007f]/u.test(text) ? null : text;
 }
+function cleanSessionName(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim().replace(/[\u0000-\u001f\u007f]/gu, '').slice(0, 240);
+    return text === '' ? null : text;
+}
 /** Pi and Command Code store Magpie selections with a local `magpie/` provider prefix. */
 function resolveCatalogModelId(agent, requestedModelId, catalog, modelName) {
     if (catalog === null)