@leo000001/opencode-quota-sidebar 1.13.4 → 1.13.7

package/CHANGELOG.md

@@ -4,6 +4,10 @@
 
 - Add Buzz API balance support for OpenAI-compatible providers that use a Buzz `baseURL`.
 - Document Buzz configuration, rendering, and outbound billing endpoints.
+- Keep session measured cost aligned with OpenCode root-session `message.cost` while still including descendant subagent usage in API-equivalent cost.
+- Support OpenCode long-context pricing tiers via `context_over_200k` when estimating API-equivalent cost.
+- Bump the usage billing cache version so `/qday`, `/qweek`, and `/qmonth` recompute historical API cost with the updated rules.
+- Document API-cost estimation, billing-cache behavior, and child-session aggregation semantics in the README.
 
 ## 1.13.2
 

package/README.md

@@ -290,8 +290,11 @@ Other defaults:
 - `sidebar.childrenConcurrency` controls parallel fetches for descendant session messages (default: `5`, clamped 1–10).
 - `output` includes reasoning tokens (`output = tokens.output + tokens.reasoning`). Reasoning is not rendered as a separate line.
 - API cost bills reasoning tokens at the output rate (same as completion tokens).
+- API cost is computed from OpenCode model pricing metadata, not from `message.cost`. This keeps subscription-backed providers such as OpenAI OAuth usable for API-equivalent cost estimation even when OpenCode's measured cost is `0`.
+- When OpenCode exposes a long-context tier like `context_over_200k`, the plugin uses that premium rate for the whole request once `input > 200000`, matching OpenCode's current pricing schema.
 - `quota.providers` is the extensible per-adapter switch map.
 - If API Cost is `$0.00`, it usually means the model/provider has no pricing mapping in OpenCode at the moment, so equivalent API cost cannot be estimated.
+- Usage chunks cache both measured `cost` and computed `apiCost`. `quota_summary` (`/qday`, `/qweek`, `/qmonth`) usually reads those cached aggregates first, but a billing-cache version bump or missing/legacy API-cost data will trigger a rescan and persist refreshed values.
 
 ### Buzz provider example
 
@@ -424,6 +427,13 @@ Mixed with Buzz balance:
 
 `quota_summary` also supports an optional `includeChildren` flag (only effective for `period=session`) to override the config per call. For `day`/`week`/`month` periods, children are never merged — each session is counted independently.
 
+## Billing cache behavior
+
+- Cached per-session usage stores token totals, measured `cost`, computed `apiCost`, provider breakdowns, and the incremental cursor.
+- Session-scoped sidebar aggregation can merge descendant subagents when `sidebar.includeChildren=true` (default). Measured `cost` stays aligned with the root session's OpenCode `message.cost`, while API-equivalent cost still includes descendant usage.
+- Range tools such as `/qday`, `/qweek`, and `/qmonth` do not merge children. They aggregate each session independently across the selected time window.
+- When API-cost logic changes, the plugin bumps an internal billing-cache version so historical range reports are recomputed with the new rules the next time they are queried.
+
 ## Debug logging
 
 Set `OPENCODE_QUOTA_DEBUG=1` to enable debug logging to stderr. This logs:

package/dist/cost.d.ts

@@ -6,6 +6,12 @@ export type ModelCostRates = {
     output: number;
     cacheRead: number;
     cacheWrite: number;
+    contextOver200k?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
 };
 export declare function modelCostKey(providerID: string, modelID: string): string;
 export declare function parseModelCostRates(value: unknown): ModelCostRates | undefined;

package/dist/cost.js

@@ -42,14 +42,28 @@ export function parseModelCostRates(value) {
     const output = readRate(value.output ?? value.completion);
     const cacheRead = readRate(value.cache_read ?? cache?.read);
     const cacheWrite = readRate(value.cache_write ?? cache?.write);
+    const contextOver200k = isRecord(value.context_over_200k)
+        ? {
+            input: readRate(value.context_over_200k.input),
+            output: readRate(value.context_over_200k.output),
+            cacheRead: readRate(value.context_over_200k.cache_read),
+            cacheWrite: readRate(value.context_over_200k.cache_write),
+        }
+        : undefined;
     if (input <= 0 && output <= 0 && cacheRead <= 0 && cacheWrite <= 0) {
         return undefined;
     }
+    const hasContextTier = !!contextOver200k &&
+        (contextOver200k.input > 0 ||
+            contextOver200k.output > 0 ||
+            contextOver200k.cacheRead > 0 ||
+            contextOver200k.cacheWrite > 0);
     return {
         input,
         output,
         cacheRead,
         cacheWrite,
+        contextOver200k: hasContextTier ? contextOver200k : undefined,
     };
 }
 const MODEL_COST_DIVISOR_PER_TOKEN = 1;
@@ -65,15 +79,25 @@ export function guessModelCostDivisor(rates) {
         : MODEL_COST_DIVISOR_PER_TOKEN;
 }
 export function calcEquivalentApiCostForMessage(message, rates) {
+    const info = message;
+    const effectiveRates = message.tokens.input > 200_000 && rates.contextOver200k
+        ? rates.contextOver200k
+        : rates;
+    const serviceTier = info.providerMetadata?.openai?.serviceTier ??
+        info.providerMetadata?.openai?.service_tier;
+    const priorityMultiplier = message.providerID === 'openai' && serviceTier === 'priority'
+        ? 2
+        : 1;
     // For providers that expose reasoning tokens separately, they are still
     // billed as output/completion tokens (same unit price). Our UI also merges
     // reasoning into the single Output statistic, so API cost should match that.
     const billedOutput = message.tokens.output + message.tokens.reasoning;
-    const rawCost = message.tokens.input * rates.input +
-        billedOutput * rates.output +
-        message.tokens.cache.read * rates.cacheRead +
-        message.tokens.cache.write * rates.cacheWrite;
-    const divisor = guessModelCostDivisor(rates);
+    const rawCost = (message.tokens.input * effectiveRates.input +
+        billedOutput * effectiveRates.output +
+        message.tokens.cache.read * effectiveRates.cacheRead +
+        message.tokens.cache.write * effectiveRates.cacheWrite) *
+        priorityMultiplier;
+    const divisor = guessModelCostDivisor(effectiveRates);
     const normalized = rawCost / divisor;
     return Number.isFinite(normalized) && normalized > 0 ? normalized : 0;
 }

package/dist/usage.d.ts

@@ -1,6 +1,6 @@
 import type { AssistantMessage, Message } from '@opencode-ai/sdk';
 import type { CachedSessionUsage, IncrementalCursor } from './types.js';
-export declare const USAGE_BILLING_CACHE_VERSION = 1;
+export declare const USAGE_BILLING_CACHE_VERSION = 2;
 export type ProviderUsage = {
     providerID: string;
     input: number;
@@ -47,6 +47,8 @@ export declare function summarizeMessagesIncremental(entries: Array<{
     usage: UsageSummary;
     cursor: IncrementalCursor;
 };
-export declare function mergeUsage(target: UsageSummary, source: UsageSummary): UsageSummary;
+export declare function mergeUsage(target: UsageSummary, source: UsageSummary, options?: {
+    includeCost?: boolean;
+}): UsageSummary;
 export declare function toCachedSessionUsage(summary: UsageSummary): CachedSessionUsage;
 export declare function fromCachedSessionUsage(cached: CachedSessionUsage, sessionCount?: number): UsageSummary;

package/dist/usage.js

@@ -1,4 +1,4 @@
-export const USAGE_BILLING_CACHE_VERSION = 1;
+export const USAGE_BILLING_CACHE_VERSION = 2;
 export function emptyUsageSummary() {
     return {
         input: 0,
@@ -263,13 +263,16 @@ function findLastCompletedAssistant(entries) {
     }
     return best;
 }
-export function mergeUsage(target, source) {
+export function mergeUsage(target, source, options) {
+    const includeCost = options?.includeCost !== false;
     target.input += source.input;
     target.output += source.output;
     target.cacheRead += source.cacheRead;
     target.cacheWrite += source.cacheWrite;
     target.total += source.total;
-    target.cost += source.cost;
+    if (includeCost) {
+        target.cost += source.cost;
+    }
     target.apiCost += source.apiCost;
     target.assistantMessages += source.assistantMessages;
     target.sessionCount += source.sessionCount;
@@ -281,7 +284,9 @@ export function mergeUsage(target, source) {
         existing.cacheRead += provider.cacheRead;
         existing.cacheWrite += provider.cacheWrite;
         existing.total += provider.total;
-        existing.cost += provider.cost;
+        if (includeCost) {
+            existing.cost += provider.cost;
+        }
         existing.apiCost += provider.apiCost;
         existing.assistantMessages += provider.assistantMessages;
         target.providers[provider.providerID] = existing;

package/dist/usage_service.js

@@ -143,12 +143,34 @@ export function createUsageService(deps) {
             tokens,
         };
     };
+    const extractProviderMetadata = (parts) => {
+        if (!Array.isArray(parts))
+            return undefined;
+        for (const part of parts) {
+            if (!isRecord(part))
+                continue;
+            const meta = part.metadata;
+            if (isRecord(meta))
+                return meta;
+            const stateMeta = isRecord(part.state)
+                ? part.state?.metadata
+                : undefined;
+            if (isRecord(stateMeta))
+                return stateMeta;
+        }
+        return undefined;
+    };
     const decodeMessageEntry = (value) => {
         if (!isRecord(value))
             return undefined;
         const decoded = decodeMessageInfo(value.info);
         if (!decoded)
             return undefined;
+        const metadata = extractProviderMetadata(value.parts);
+        if (metadata && decoded.role === 'assistant') {
+            const msg = decoded;
+            msg.providerMetadata = metadata;
+        }
         return { info: decoded };
     };
     const decodeMessageEntries = (value) => {
@@ -279,7 +301,11 @@ export function createUsageService(deps) {
         for (const childID of descendantIDs) {
             const cached = deps.state.sessions[childID]?.usage;
             if (cached && !isDirty(childID) && isUsageBillingCurrent(cached)) {
-                mergeUsage(merged, fromCachedSessionUsage(cached, 1));
+                // Keep measured cost aligned with OpenCode session semantics by only
+                // using child sessions for token/API-cost aggregation.
+                mergeUsage(merged, fromCachedSessionUsage(cached, 1), {
+                    includeCost: false,
+                });
             }
             else {
                 needsFetch.push(childID);
@@ -294,7 +320,7 @@ export function createUsageService(deps) {
                 return child.usage;
             });
             for (const childUsage of fetched) {
-                mergeUsage(merged, childUsage);
+                mergeUsage(merged, childUsage, { includeCost: false });
             }
         }
         return merged;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leo000001/opencode-quota-sidebar",
-  "version": "1.13.4",
+  "version": "1.13.7",
   "description": "OpenCode plugin that shows quota and token usage in session titles",
   "type": "module",
   "main": "dist/index.js",