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

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

@@ -1,5 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import { commandEnvironment, resolveCommandPath, runAsyncCommand, WINDOWS, withCommandSignal } from './process-utils.js';
+import { parseMagpieWebProviders } from './magpie-management.js';
 const MAGPIE_CATALOG_TTL_MS = 60_000;
 const MAGPIE_MODEL_METADATA_TTL_MS = 60_000;
 const MAGPIE_FAILURE_CACHE_TTL_MS = 5_000;
@@ -8,10 +9,13 @@ 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 MAGPIE_PROVIDER_CATALOG_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_MAGPIE_SESSION_SCAN_ROWS = 10_000;
+const MAX_MAGPIE_SESSION_IDENTITIES = 16;
 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._:/-]*)+';
 const MAGPIE_AGENT_BY_ADAPTER = {
@@ -62,6 +66,7 @@ export class MagpieUsageService {
     dashboardCache = new Map();
     dashboardRefreshes = new Map();
     quotaLogoCache = new Map();
+    providerCatalog;
     constructor(options = {}) {
         this.readModels = options.readModels ?? readMagpieModels;
         // An injected catalog reader represents the whole fake CLI boundary in
@@ -305,45 +310,119 @@ export class MagpieUsageService {
             || !Number.isSafeInteger(options.limit) || options.limit < 1 || options.limit > 100)
             return null;
         const sessionId = options.sessionId === undefined ? null : cleanText(options.sessionId);
+        const sessionIds = options.sessionIds === undefined
+            ? []
+            : options.sessionIds.map(cleanText);
         const sessionAgent = options.sessionAgent === undefined ? null : cleanText(options.sessionAgent);
         if ((options.sessionId !== undefined && sessionId === null)
+            || sessionIds.some((value) => value === null)
+            || sessionIds.length > MAX_MAGPIE_SESSION_IDENTITIES
             || (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)
+            || ((sessionId === null) !== (sessionAgent === null))
+            || (sessionIds.length > 0 && sessionId === null))
             return null;
-        const root = asRecord(response.value);
-        const rawRows = root?.rows;
-        if (!Array.isArray(rawRows) || rawRows.length > 500)
+        const requestedSessionIds = sessionId === null
+            ? []
+            : [...new Set([sessionId, ...sessionIds.filter((value) => value !== null)])];
+        if (requestedSessionIds.length > MAX_MAGPIE_SESSION_IDENTITIES)
             return null;
-        const candidates = rawRows.flatMap((row) => {
+        const readCandidatePage = async (offset, limit, querySessionId) => {
+            const query = new URLSearchParams({ period: magpieWebPeriod(options.period), limit: String(limit), offset: String(offset) });
+            if (querySessionId !== null)
+                query.set('q', querySessionId);
+            const response = await this.readWebJson(`/api/usage/requests?${query.toString()}`, signal);
+            if (!response.ok)
+                return null;
+            const root = asRecord(response.value);
+            const rows = root?.rows;
+            if (!Array.isArray(rows) || rows.length > 500)
+                return null;
+            return { rows, total: safeCount(root?.total) };
+        };
+        if (sessionId === null) {
+            const page = await readCandidatePage(options.offset, options.limit, null);
+            if (page === null)
+                return null;
+            const providerRecords = page.rows.some((row) => routeText(asRecord(row)?.agent) === 'codex')
+                ? await this.readProviderCatalog(signal)
+                : [];
+            const items = parseMagpieRequestRows(page.rows, null, null, providerRecords);
+            return {
+                period: options.period,
+                offset: options.offset,
+                limit: options.limit,
+                total: page.total,
+                hasMore: page.total === null ? page.rows.length >= options.limit : options.offset + page.rows.length < page.total,
+                sessionId,
+                sessionAgent,
+                items: items.slice(0, options.limit),
+            };
+        }
+        // Magpie's `q` is a free-text candidate search, not an exact session filter.
+        // Fetch candidates from the beginning and apply the exact filter before paging;
+        // otherwise unrelated rows can consume the requested page and hide valid rows.
+        //
+        // Scanning stops one match past the requested page: enough to fill it and to prove
+        // whether another page exists. `total` therefore stays `null` while the identity's
+        // candidate window is not exhausted; the page that reads the window's end reports
+        // the exact count. Aggregated DSH sessions scan every contributing identity so one
+        // provider conversation cannot hide another.
+        const candidateLimit = 100;
+        const requestedEnd = options.offset + options.limit;
+        const rawRowsByKey = new Map();
+        let fullyScanned = true;
+        const perIdentityScanLimit = Math.floor(MAX_MAGPIE_SESSION_SCAN_ROWS / requestedSessionIds.length);
+        const acceptedAgents = MAGPIE_USAGE_AGENT_ALIASES[sessionAgent] ?? [sessionAgent];
+        const acceptedSessionIds = new Set(requestedSessionIds);
+        const matchesIn = () => [...rawRowsByKey.values()].reduce((count, 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 count;
+            if (!acceptedSessionIds.has(cleanText(record.session) ?? '') && !acceptedSessionIds.has(cleanText(record.native_session) ?? ''))
+                return count;
+            return acceptedAgents.includes(cleanText(record.agent) ?? '') ? count + 1 : count;
+        }, 0);
+        for (const querySessionId of requestedSessionIds) {
+            let candidateOffset = 0;
+            let reachedEnd = false;
+            while (!reachedEnd && candidateOffset < perIdentityScanLimit) {
+                const pageLimit = Math.min(candidateLimit, perIdentityScanLimit - candidateOffset);
+                const page = await readCandidatePage(candidateOffset, pageLimit, querySessionId);
+                if (page === null)
+                    return null;
+                for (const row of page.rows) {
+                    const key = magpieRequestRowKey(row);
+                    if (!rawRowsByKey.has(key))
+                        rawRowsByKey.set(key, row);
+                }
+                const pageLength = page.rows.length;
+                const nextOffset = candidateOffset + pageLength;
+                reachedEnd = pageLength === 0
+                    || nextOffset <= candidateOffset
+                    || (page.total === null ? pageLength < pageLimit : nextOffset >= page.total);
+                candidateOffset = nextOffset;
+                // Enough rows for this page plus one more: no need to read the rest of the window.
+                if (!reachedEnd && matchesIn() > requestedEnd)
+                    break;
+            }
+            if (!reachedEnd)
+                fullyScanned = false;
+        }
+        const rawRows = [...rawRowsByKey.values()];
+        const providerRecords = rawRows.some((row) => routeText(asRecord(row)?.agent) === 'codex')
+            ? await this.readProviderCatalog(signal)
+            : [];
+        const matching = parseMagpieRequestRows(rawRows, sessionId, sessionAgent, providerRecords, requestedSessionIds);
+        const total = fullyScanned ? matching.length : null;
         return {
             period: options.period,
             offset: options.offset,
             limit: options.limit,
             total,
-            hasMore: total === null ? rawRows.length >= options.limit : options.offset + rawRows.length < total,
+            hasMore: !fullyScanned || matching.length > requestedEnd,
             sessionId,
             sessionAgent,
-            items: candidates.slice(0, options.limit),
+            items: matching.slice(options.offset, requestedEnd),
         };
     }
     async readFromWeb(agent, modelId, sessionId, magpieSessionId, fallbackSessionId, signal, includeRoute) {
@@ -369,8 +448,12 @@ export class MagpieUsageService {
             : { ok: false };
         const routeRows = routeHistoryResult.ok ? asRecord(routeHistoryResult.value)?.rows : null;
         const routeHistoryValid = Array.isArray(routeRows) && routeRows.length <= 500;
+        const providerRecords = agent === 'codex' && routeHistoryValid
+            && routeRows.some((row) => routeText(asRecord(row)?.agent) === 'codex')
+            ? await this.readProviderCatalog(signal)
+            : [];
         const routeHistory = routeHistoryResult.ok && routeHistoryValid && resolvedSessionId !== null
-            ? readSessionRouteHistory(routeHistoryResult.value, agent, resolvedSessionId)
+            ? readSessionRouteHistory(routeHistoryResult.value, agent, resolvedSessionId, providerRecords)
             : [];
         const route = routeHistory[0]?.route ?? null;
         const routeStatus = route !== null
@@ -407,6 +490,7 @@ export class MagpieUsageService {
             usageStatus: aggregate === null ? 'unavailable' : 'available',
             aggregate,
             sessionId,
+            ...(resolvedSessionId === null ? {} : { requestSessionId: resolvedSessionId }),
             session: sessionUsage,
             routeStatus,
             route,
@@ -591,6 +675,18 @@ export class MagpieUsageService {
             return { ok: false };
         }
     }
+    /** Provider management data is the canonical source when a usage row mislabels its upstream. */
+    async readProviderCatalog(signal) {
+        const cached = this.providerCatalog;
+        if (cached !== undefined && this.now() - cached.loadedAt < MAGPIE_PROVIDER_CATALOG_TTL_MS)
+            return cached.records;
+        const response = await this.readWebJson('/api/providers', signal);
+        const parsed = response.ok ? parseMagpieWebProviders(response.value) : null;
+        const records = parsed?.records ?? [];
+        if (parsed !== null)
+            this.providerCatalog = { records, loadedAt: this.now() };
+        return records;
+    }
 }
 function awaitWithSignal(task, signal) {
     if (signal === undefined)
@@ -864,53 +960,124 @@ export function magpieUsageAgentAliases(adapterId) {
  * native DSH use different identities across Magpie versions.
  */
 export function attachMagpieSessionNames(dashboard, bindings) {
-    if (!Array.isArray(dashboard.sessions) || bindings.length === 0)
+    if (!Array.isArray(dashboard.sessions))
         return dashboard;
-    const names = new Map();
+    const owners = new Map();
     const ambiguous = new Set();
+    const ownerByGroup = new Map();
     for (const binding of bindings) {
-        const name = cleanSessionName(binding.name);
         const dshSessionId = cleanText(binding.dshSessionId);
-        if (name === null || dshSessionId === null)
+        const name = cleanSessionName(binding.name);
+        if (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.
+        // Magpie versions may record either the provider conversation ID or the
+        // DSH ID; both exact identities represent the same DSH session.
         const providerSessionId = cleanText(binding.providerSessionId);
-        const ids = new Set((binding.adapterId === 'dsh'
-            ? [dshSessionId]
-            : binding.adapterId === 'command-code'
-                ? [dshSessionId, providerSessionId]
-                : [providerSessionId]).filter((value) => value !== null));
+        const ids = new Set([dshSessionId, providerSessionId].filter((value) => value !== null));
+        const groupKey = `dsh\u0000${dshSessionId}`;
+        const owner = ownerByGroup.get(groupKey) ?? {
+            groupKey,
+            dshSessionId,
+            agent: magpieAgentForAdapter(binding.adapterId) ?? binding.adapterId,
+            name,
+            ids: [...new Set(ids)],
+        };
+        if (ownerByGroup.has(groupKey)) {
+            ownerByGroup.set(groupKey, {
+                ...owner,
+                name: owner.name === null || name === null || owner.name === name ? owner.name ?? name : null,
+                ids: [...new Set([...owner.ids, ...ids])],
+            });
+        }
+        else {
+            ownerByGroup.set(groupKey, owner);
+        }
+        const currentOwner = ownerByGroup.get(groupKey);
         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);
+                const previous = owners.get(key);
+                if (previous !== undefined && previous.groupKey !== groupKey) {
+                    owners.delete(key);
                     ambiguous.add(key);
                 }
                 else {
-                    names.set(key, name);
+                    owners.set(key, currentOwner);
                 }
             }
         }
     }
-    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)
+    for (const [key, owner] of owners) {
+        const currentOwner = ownerByGroup.get(owner.groupKey);
+        if (currentOwner !== undefined)
+            owners.set(key, currentOwner);
+    }
+    const grouped = new Map();
+    for (const row of dashboard.sessions) {
+        const aliasKey = `${row.agent}\u0000${row.id}`;
+        const owner = ambiguous.has(aliasKey) ? undefined : owners.get(aliasKey);
+        const groupKey = owner?.groupKey ?? `raw\u0000${row.agent}\u0000${row.id}`;
+        const current = grouped.get(groupKey);
+        if (current === undefined) {
+            const ids = new Set(owner?.ids ?? [row.id]);
+            ids.add(row.id);
+            const session = owner === undefined
+                ? row
+                : {
+                    ...row,
+                    id: owner.dshSessionId,
+                    agent: owner.agent,
+                    ...(owner.name === null ? {} : { dshSessionName: owner.name }),
+                    sessionIds: [...ids],
+                };
+            grouped.set(groupKey, { session, ids });
+            continue;
+        }
+        for (const id of owner?.ids ?? [row.id])
+            current.ids.add(id);
+        current.ids.add(row.id);
+        current.session = mergeMagpieUsageSessions(current.session, row, owner);
+    }
+    const sessions = [...grouped.values()].map(({ session, ids }) => {
+        if (ids.size <= 1 && session.sessionIds === undefined)
             return session;
-        changed = true;
-        return { ...session, dshSessionName: name };
+        return { ...session, sessionIds: [...ids] };
     });
-    return changed ? { ...dashboard, sessions } : dashboard;
+    if (sessions.length === dashboard.sessions.length && sessions.every((session, index) => session === dashboard.sessions[index]))
+        return dashboard;
+    return { ...dashboard, sessions };
+}
+function mergeMagpieUsageSessions(current, row, owner) {
+    return {
+        ...current,
+        id: owner?.dshSessionId ?? current.id,
+        agent: owner?.agent ?? current.agent,
+        calls: sumMagpieUsageMetric(current.calls, row.calls),
+        errors: sumMagpieUsageMetric(current.errors, row.errors),
+        retried: sumMagpieUsageMetric(current.retried, row.retried),
+        inputTokens: sumMagpieUsageMetric(current.inputTokens, row.inputTokens),
+        outputTokens: sumMagpieUsageMetric(current.outputTokens, row.outputTokens),
+        cacheReadTokens: sumMagpieUsageMetric(current.cacheReadTokens, row.cacheReadTokens),
+        cacheWriteTokens: sumMagpieUsageMetric(current.cacheWriteTokens, row.cacheWriteTokens),
+        reasoningTokens: sumMagpieUsageMetric(current.reasoningTokens, row.reasoningTokens),
+        cost: sumMagpieUsageMetric(current.cost, row.cost),
+        unpriced: sumMagpieUsageMetric(current.unpriced, row.unpriced),
+        credits: sumMagpieUsageMetric(current.credits, row.credits),
+        credited: sumMagpieUsageMetric(current.credited, row.credited),
+        timed: sumMagpieUsageMetric(current.timed, row.timed),
+        ttftMs: sumMagpieUsageMetric(current.ttftMs, row.ttftMs),
+        decodeMs: sumMagpieUsageMetric(current.decodeMs, row.decodeMs),
+        decodeTokens: sumMagpieUsageMetric(current.decodeTokens, row.decodeTokens),
+        decodeCount: sumMagpieUsageMetric(current.decodeCount, row.decodeCount),
+        ...(current.dshSessionName === undefined && owner?.name !== null && owner?.name !== undefined
+            ? { dshSessionName: owner.name }
+            : {}),
+    };
+}
+function sumMagpieUsageMetric(left, right) {
+    return left === null && right === null ? null : (left ?? 0) + (right ?? 0);
 }
 function isMagpieAgentId(value) {
     return value.length <= 64 && /^[a-z0-9][a-z0-9-]*$/u.test(value);
@@ -999,7 +1166,7 @@ function readSession(value, agent, sessionId) {
     return record !== null && usageAgent !== null && totals !== null ? { id: sessionId, agent: usageAgent, ...totals } : null;
 }
 /** Read the durable request ledger when Magpie's short in-memory trace has expired. */
-function readSessionRouteHistory(value, agent, sessionId) {
+function readSessionRouteHistory(value, agent, sessionId, providerRecords = []) {
     const rows = asRecord(value)?.rows;
     if (!Array.isArray(rows) || rows.length > 500)
         return [];
@@ -1009,9 +1176,11 @@ function readSessionRouteHistory(value, agent, sessionId) {
         const rowAgent = cleanText(record?.agent);
         const session = cleanText(record?.session);
         const nativeSession = cleanText(record?.native_session);
-        const provider = routeText(record?.provider);
         if (record === null || rowAgent === null || !usageAgents.includes(rowAgent)
-            || (session !== sessionId && nativeSession !== sessionId) || provider === null)
+            || (session !== sessionId && nativeSession !== sessionId))
+            return [];
+        const provider = normalizeMagpieRequestProvider(record, providerRecords);
+        if (provider === null)
             return [];
         const requested = routeText(record.req);
         const model = routeText(record.model);
@@ -1393,9 +1562,32 @@ function readMagpieUsageSessions(value) {
         return record === null || id === null || agent === null ? [] : [{ id, agent, ...readMagpieUsageMetrics(record) }];
     });
 }
-function parseMagpieRequest(record) {
+function parseMagpieRequestRows(rows, sessionId, sessionAgent, providerRecords = [], sessionIds = sessionId === null ? [] : [sessionId]) {
+    const acceptedAgents = sessionAgent === null ? null : MAGPIE_USAGE_AGENT_ALIASES[sessionAgent] ?? [sessionAgent];
+    const acceptedSessionIds = new Set(sessionIds);
+    return rows.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);
+        if (sessionId !== null
+            && (!acceptedSessionIds.has(candidateSession ?? '') && !acceptedSessionIds.has(nativeSession ?? '')
+                || agent === null || acceptedAgents === null || !acceptedAgents.includes(agent)))
+            return [];
+        const item = parseMagpieRequest(record, providerRecords);
+        return item === null ? [] : [sessionId === null ? item : { ...item, sessionId }];
+    });
+}
+function magpieRequestRowKey(value) {
+    const record = asRecord(value);
+    const routeId = safeRouteId(record?.route_id);
+    return routeId === null ? JSON.stringify(record) : `route:${routeId}`;
+}
+function parseMagpieRequest(record, providerRecords = []) {
     const agent = routeText(record.agent);
-    const provider = routeText(record.provider);
+    const provider = normalizeMagpieRequestProvider(record, providerRecords);
     const requestedModel = routeText(record.req);
     const servedModel = routeText(record.served);
     const group = requestedModel?.startsWith('group/') === true ? requestedModel.slice('group/'.length) : null;
@@ -1404,7 +1596,7 @@ function parseMagpieRequest(record) {
         time: routeText(record.t),
         agent,
         provider,
-        account: routeText(record.providerAccount),
+        account: normalizeMagpieRequestAccount(record, provider, providerRecords),
         requestedModel,
         servedModel,
         group,
@@ -1425,6 +1617,40 @@ function parseMagpieRequest(record) {
         sessionId: cleanText(record.session) ?? cleanText(record.native_session),
     };
 }
+/** Session-filtered rows can omit the account label; use only the matching provider's safe catalog label. */
+function normalizeMagpieRequestAccount(record, provider, providerRecords) {
+    const account = routeText(record.providerAccount);
+    if (account !== null || provider === null)
+        return account;
+    const matches = providerRecords.filter((item) => item.id === provider);
+    return matches.length === 1 ? matches[0].account : null;
+}
+/**
+ * Magpie's usage ledger can retain a stale provider id after an Agent provider
+ * is renamed. Reconcile only Codex rows against the read-only provider catalog;
+ * arbitrary provider ids must remain untouched when the evidence is ambiguous.
+ */
+function normalizeMagpieRequestProvider(record, providerRecords) {
+    const provider = routeText(record.provider);
+    if (provider === null || routeText(record.agent)?.toLocaleLowerCase() !== 'codex')
+        return provider;
+    const codexProviders = providerRecords.filter((item) => item.accountAgent?.toLocaleLowerCase() === 'codex');
+    if (codexProviders.length === 0)
+        return provider;
+    const modelValues = [record.model, record.served, record.req]
+        .map(routeText)
+        .filter((value) => value !== null);
+    const matches = codexProviders.filter((candidate) => candidate.models.some((model) => modelValues.some((value) => magpieModelMatchesProvider(value, model.id, candidate.id))));
+    if (matches.length === 1)
+        return matches[0].id;
+    return codexProviders.length === 1 ? codexProviders[0].id : provider;
+}
+function magpieModelMatchesProvider(value, modelId, providerId) {
+    if (value === modelId)
+        return true;
+    const prefix = `${providerId}/`;
+    return modelId.startsWith(prefix) && value === modelId.slice(prefix.length);
+}
 function firstRouteText(record, keys) {
     for (const key of keys) {
         const value = routeText(record[key]);