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

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

@@ -1,5 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { commandEnvironment, resolveCommandPath, runAsyncCommand, WINDOWS, withCommandSignal } from './process-utils.js';
+import { parseMagpieWebProviders } from './magpie-management.js';
+import { parseMagpieContextResponse } from './magpie-context.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 +10,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 +67,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
@@ -76,7 +82,7 @@ export class MagpieUsageService {
         this.webApi = options.webApi;
         this.onDashboardTiming = options.onDashboardTiming;
     }
-    async read(session, signal, includeRoute = false, dshSessionId) {
+    async read(session, signal, includeRoute = false, dshSessionId, options = {}) {
         signal?.throwIfAborted();
         const agent = magpieAgentForAdapter(session.adapterId);
         const requestedModelId = cleanText(session.modelId);
@@ -84,24 +90,25 @@ export class MagpieUsageService {
             return null;
         const providerSessionId = cleanText(session.providerSessionId);
         const nativeSessionId = cleanText(dshSessionId);
-        // Native DSH requests use the DSH session ID as their Magpie session
-        // identity. Other drivers must never treat that fallback as a provider ID.
-        const sessionId = providerSessionId !== null && providerSessionId !== nativeSessionId
+        // Native DSH requests are tagged with the DSH session ID. Keep the older
+        // provider-session fallback for callers that do not have the native ID yet,
+        // and for Magpie ledgers written before native_session tagging was added.
+        const sessionId = agent === 'dsh'
+            ? nativeSessionId ?? providerSessionId
+            : providerSessionId !== null && providerSessionId !== nativeSessionId ? providerSessionId : null;
+        // Current Codex and Command Code gateway requests carry the Host's native
+        // session tag. Codex may use it only after the caller confirms Magpie.
+        const nativeTagged = agent === 'dsh' || agent === 'commandcode'
+            || agent === 'codex' && options.allowPendingSession === true;
+        const magpieSessionId = nativeTagged ? nativeSessionId ?? sessionId : sessionId;
+        // Older gateways can still index the same session by its provider ID.
+        const fallbackSessionId = nativeTagged
+            && nativeSessionId !== null && providerSessionId !== null && nativeSessionId !== providerSessionId
             ? providerSessionId
-            : agent === 'dsh' ? nativeSessionId : null;
-        // 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)
+        if (magpieSessionId === null && !options.allowPendingSession)
             return null;
-        return this.readFromWeb(agent, requestedModelId, sessionId, magpieSessionId, fallbackSessionId, signal, includeRoute);
+        return this.readFromWeb(agent, requestedModelId, sessionId, magpieSessionId, fallbackSessionId, signal, includeRoute, options.allowPendingSession === true);
     }
     /**
      * Mark Magpie models and enrich their public metadata. The marker is
@@ -187,6 +194,15 @@ export class MagpieUsageService {
         const metadata = await this.loadModelMetadata(catalog, signal);
         return metadata?.get(id) ?? null;
     }
+    /** Read one exact, sanitized context session from Magpie's internal Web API. */
+    async readContext(options, signal) {
+        signal?.throwIfAborted();
+        const days = options.days === undefined ? 7 : Math.max(1, Math.min(30, Math.trunc(options.days)));
+        const response = await this.readWebJson(`/api/context?days=${days}`, signal);
+        if (!response.ok)
+            return null;
+        return parseMagpieContextResponse(response.value, options);
+    }
     /** Read bounded, graph-ready usage and quota data through authenticated Magpie Web. */
     async readDashboard(period, signal) {
         signal?.throwIfAborted();
@@ -305,77 +321,193 @@ 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)))
+            || ((sessionId === null) !== (sessionAgent === null))
+            || (sessionIds.length > 0 && sessionId === 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)
+        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) => {
+        // Usage summaries are returned separately from the request ledger. This keeps
+        // the cards complete without preloading rows that belong to later pages.
+        const aggregatePromise = this.readRequestAggregate(options.period, sessionAgent, requestedSessionIds, signal);
+        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,
+                aggregate: await aggregatePromise,
+                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),
+            aggregate: await aggregatePromise,
+            items: matching.slice(options.offset, requestedEnd),
         };
     }
-    async readFromWeb(agent, modelId, sessionId, magpieSessionId, fallbackSessionId, signal, includeRoute) {
+    async readRequestAggregate(period, sessionAgent, sessionIds, signal) {
+        const response = await this.readWebJson(`/api/usage?period=${magpieWebPeriod(period)}`, signal);
+        if (!response.ok)
+            return null;
+        const root = usageRecord(response.value);
+        if (root === null)
+            return null;
+        if (sessionIds.length === 0)
+            return readMagpieUsageMetrics(root);
+        const sessions = root.sessions;
+        if (!Array.isArray(sessions) || sessionAgent === null)
+            return null;
+        const acceptedAgents = MAGPIE_USAGE_AGENT_ALIASES[sessionAgent] ?? [sessionAgent];
+        const acceptedIds = new Set(sessionIds);
+        let aggregate = null;
+        for (const item of sessions) {
+            const record = asRecord(item);
+            if (record === null || !acceptedIds.has(usageSessionId(record) ?? '')
+                || !acceptedAgents.includes(cleanText(record.agent) ?? ''))
+                continue;
+            aggregate = aggregate === null
+                ? readMagpieUsageMetrics(record)
+                : sumMagpieUsageMetrics(aggregate, readMagpieUsageMetrics(record));
+        }
+        return aggregate;
+    }
+    async readFromWeb(agent, modelId, sessionId, magpieSessionId, fallbackSessionId, signal, includeRoute, allowPendingSession) {
         const capturedAt = new Date(this.now()).toISOString();
-        const [usageResult, quotaResult] = await Promise.all([
+        const [usageResult, sessionResult, quotaResult] = await Promise.all([
             this.readWebJson('/api/usage?period=today', signal),
+            this.readWebJson('/api/usage?period=all', signal),
             this.readWebJson('/api/usage/quotas', signal),
         ]);
         const aggregate = usageResult.ok ? readTotals(usageResult.value) : null;
-        const primarySession = usageResult.ok && magpieSessionId !== null
-            ? readSession(usageResult.value, agent, magpieSessionId)
+        const primarySession = sessionResult.ok && magpieSessionId !== null
+            ? readSession(sessionResult.value, agent, magpieSessionId)
+            : null;
+        const fallbackSession = primarySession === null && sessionResult.ok && fallbackSessionId !== null
+            ? readSession(sessionResult.value, agent, fallbackSessionId)
             : null;
-        const fallbackSession = primarySession === null && usageResult.ok && fallbackSessionId !== null
-            ? readSession(usageResult.value, agent, fallbackSessionId)
+        // Magpie's all-time summary can omit a session already present today.
+        // Preserve that exact daily match with its scope, rather than hiding it.
+        const todaySession = primarySession === null && fallbackSession === null && allowPendingSession && usageResult.ok
+            ? (magpieSessionId === null ? null : readSession(usageResult.value, agent, magpieSessionId))
+                ?? (fallbackSessionId === null ? null : readSession(usageResult.value, agent, fallbackSessionId))
             : null;
-        const sessionUsage = primarySession ?? fallbackSession;
-        const resolvedSessionId = primarySession !== null ? magpieSessionId : fallbackSession !== null ? fallbackSessionId : magpieSessionId;
-        if (sessionUsage === null)
+        const sessionUsage = primarySession ?? fallbackSession ?? todaySession;
+        const resolvedSessionId = sessionUsage?.id ?? magpieSessionId;
+        if (sessionUsage === null && (!allowPendingSession || aggregate === null))
             return null;
-        const canReadRoute = includeRoute && resolvedSessionId !== null && resolvedSessionId.length <= 128;
+        const canReadRoute = sessionUsage !== null && 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)
+            ? await this.readWebJson(`/api/usage/requests?period=all&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 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
             ? 'available'
-            : resolvedSessionId === null
+            : sessionUsage === null || resolvedSessionId === null
                 ? 'session-unavailable'
                 : !includeRoute
                     ? 'not-requested'
@@ -387,7 +519,7 @@ export class MagpieUsageService {
                 providerFromRoute(route),
                 ...routeHistory.map((record) => record.provider),
             ].filter((provider) => provider !== null))];
-        const upstreamProviders = routeProviders.length > 0
+        const upstreamProviders = sessionUsage === null ? [] : routeProviders.length > 0
             ? routeProviders
             : [providerFromModelId(modelId, agent)].filter((provider) => provider !== null);
         const upstreamProvider = upstreamProviders[0] ?? null;
@@ -406,8 +538,10 @@ export class MagpieUsageService {
             capturedAt,
             usageStatus: aggregate === null ? 'unavailable' : 'available',
             aggregate,
-            sessionId,
+            sessionId: sessionId ?? (sessionUsage === null ? null : resolvedSessionId),
+            ...(resolvedSessionId === null ? {} : { requestSessionId: resolvedSessionId }),
             session: sessionUsage,
+            ...(todaySession === null ? {} : { sessionPeriod: 'today' }),
             routeStatus,
             route,
             upstreamProvider,
@@ -591,6 +725,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 +1010,129 @@ 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,
+        ...sumMagpieUsageMetrics(current, row),
+        id: owner?.dshSessionId ?? current.id,
+        agent: owner?.agent ?? current.agent,
+        ...(current.dshSessionName === undefined && owner?.name !== null && owner?.name !== undefined
+            ? { dshSessionName: owner.name }
+            : {}),
+    };
+}
+function sumMagpieUsageMetrics(left, right) {
+    return {
+        calls: sumMagpieUsageMetric(left.calls, right.calls),
+        errors: sumMagpieUsageMetric(left.errors, right.errors),
+        retried: sumMagpieUsageMetric(left.retried, right.retried),
+        inputTokens: sumMagpieUsageMetric(left.inputTokens, right.inputTokens),
+        outputTokens: sumMagpieUsageMetric(left.outputTokens, right.outputTokens),
+        cacheReadTokens: sumMagpieUsageMetric(left.cacheReadTokens, right.cacheReadTokens),
+        cacheWriteTokens: sumMagpieUsageMetric(left.cacheWriteTokens, right.cacheWriteTokens),
+        reasoningTokens: sumMagpieUsageMetric(left.reasoningTokens, right.reasoningTokens),
+        cost: sumMagpieUsageMetric(left.cost, right.cost),
+        unpriced: sumMagpieUsageMetric(left.unpriced, right.unpriced),
+        credits: sumMagpieUsageMetric(left.credits, right.credits),
+        credited: sumMagpieUsageMetric(left.credited, right.credited),
+        timed: sumMagpieUsageMetric(left.timed, right.timed),
+        ttftMs: sumMagpieUsageMetric(left.ttftMs, right.ttftMs),
+        decodeMs: sumMagpieUsageMetric(left.decodeMs, right.decodeMs),
+        decodeTokens: sumMagpieUsageMetric(left.decodeTokens, right.decodeTokens),
+        decodeCount: sumMagpieUsageMetric(left.decodeCount, right.decodeCount),
+    };
+}
+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);
@@ -969,7 +1191,7 @@ async function readBoundedJson(response) {
     }
 }
 function readTotals(value) {
-    const record = asRecord(value);
+    const record = usageRecord(value);
     if (record === null)
         return null;
     const calls = safeCount(record.calls);
@@ -984,22 +1206,31 @@ function readTotals(value) {
     return { calls, errors, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, costUsd };
 }
 function readSession(value, agent, sessionId) {
-    const sessions = asRecord(value)?.sessions;
+    const sessions = usageRecord(value)?.sessions;
     if (!Array.isArray(sessions))
         return null;
     const usageAgents = MAGPIE_USAGE_AGENT_ALIASES[agent] ?? [agent];
     const row = sessions.find((item) => {
         const record = asRecord(item);
         const usageAgent = cleanText(record?.agent);
-        return cleanText(record?.id) === sessionId && usageAgent !== null && usageAgents.includes(usageAgent);
+        return usageSessionId(record) === sessionId && usageAgent !== null && usageAgents.includes(usageAgent);
     });
     const record = asRecord(row);
     const totals = readTotals(record);
     const usageAgent = cleanText(record?.agent);
     return record !== null && usageAgent !== null && totals !== null ? { id: sessionId, agent: usageAgent, ...totals } : null;
 }
+/** Magpie 0.1.14xx can wrap usage payloads in `data`; older versions do not. */
+function usageRecord(value) {
+    const record = asRecord(value);
+    const data = asRecord(record?.data);
+    return data ?? record;
+}
+function usageSessionId(record) {
+    return cleanText(record?.id) ?? cleanText(record?.session) ?? cleanText(record?.native_session);
+}
 /** 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 +1240,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 +1626,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 +1660,7 @@ function parseMagpieRequest(record) {
         time: routeText(record.t),
         agent,
         provider,
-        account: routeText(record.providerAccount),
+        account: normalizeMagpieRequestAccount(record, provider, providerRecords),
         requestedModel,
         servedModel,
         group,
@@ -1425,6 +1681,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]);