@royalcat/opencode-dcp-rc 4.0.0 → 4.0.1

package/lib/compress/usage.ts

@@ -0,0 +1,168 @@
+/**
+ * Usage accounting for the hidden compression (summary) request.
+ *
+ * Provider-reported usage is preferred: OpenCode V2 generates the summary
+ * through `session.generate`, which does not surface token usage to the
+ * caller, so the numbers are captured by wrapping the resolved language
+ * model (`ctx.aisdk.hook("language")`) and reading the `finish` usage.
+ * When that path is unavailable, local tokenizer estimates are recorded
+ * instead so the plugin can still report an approximate cost.
+ */
+
+export type CompressionUsageSource = "provider" | "estimated"
+
+/** Usage of a single hidden compression request. */
+export interface CompressionUsage {
+    inputTokens: number
+    outputTokens: number
+    cacheReadTokens: number
+    cacheWriteTokens: number
+    reasoningTokens: number
+    source: CompressionUsageSource
+}
+
+/** Aggregated usage of all hidden compression requests in a session. */
+export interface CompressionUsageTotals {
+    calls: number
+    providerCalls: number
+    estimatedCalls: number
+    inputTokens: number
+    outputTokens: number
+    cacheReadTokens: number
+    cacheWriteTokens: number
+    reasoningTokens: number
+}
+
+export function emptyCompressionUsage(): CompressionUsageTotals {
+    return {
+        calls: 0,
+        providerCalls: 0,
+        estimatedCalls: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        reasoningTokens: 0,
+    }
+}
+
+function toCount(value: unknown, fallback = 0): number {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        return fallback
+    }
+    return Math.round(value)
+}
+
+/**
+ * Normalize AI SDK v3 usage (`{ inputTokens: { total, noCache, cacheRead,
+ * cacheWrite }, outputTokens: { total, text, reasoning } }`) into the plugin
+ * shape. Returns undefined when there is nothing usable to record.
+ */
+export function normalizeProviderUsage(raw: unknown): CompressionUsage | undefined {
+    if (!raw || typeof raw !== "object") {
+        return undefined
+    }
+
+    const value = raw as { inputTokens?: unknown; outputTokens?: unknown }
+    const input =
+        value.inputTokens && typeof value.inputTokens === "object"
+            ? (value.inputTokens as Record<string, unknown>)
+            : {}
+    const output =
+        value.outputTokens && typeof value.outputTokens === "object"
+            ? (value.outputTokens as Record<string, unknown>)
+            : {}
+
+    const cacheRead = toCount(input.cacheRead)
+    const cacheWrite = toCount(input.cacheWrite)
+    const uncached = toCount(input.noCache)
+    const inputFromParts = uncached + cacheRead + cacheWrite
+    const inputTotal = Math.max(toCount(input.total, inputFromParts), inputFromParts)
+
+    const reasoning = toCount(output.reasoning)
+    const outputTotal = Math.max(toCount(output.total, toCount(output.text) + reasoning), reasoning)
+
+    if (
+        inputTotal === 0 &&
+        outputTotal === 0 &&
+        cacheRead === 0 &&
+        cacheWrite === 0 &&
+        reasoning === 0
+    ) {
+        return undefined
+    }
+
+    return {
+        inputTokens: inputTotal,
+        outputTokens: outputTotal,
+        cacheReadTokens: cacheRead,
+        cacheWriteTokens: cacheWrite,
+        reasoningTokens: reasoning,
+        source: "provider",
+    }
+}
+
+/** Local fallback when the provider did not report usage. */
+export function estimatedCompressionUsage(
+    inputTokens: number,
+    outputTokens: number,
+): CompressionUsage {
+    return {
+        inputTokens: toCount(inputTokens),
+        outputTokens: toCount(outputTokens),
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        reasoningTokens: 0,
+        source: "estimated",
+    }
+}
+
+export function addCompressionUsage(
+    totals: CompressionUsageTotals,
+    usage: CompressionUsage,
+): CompressionUsageTotals {
+    return {
+        calls: totals.calls + 1,
+        providerCalls: totals.providerCalls + (usage.source === "provider" ? 1 : 0),
+        estimatedCalls: totals.estimatedCalls + (usage.source === "estimated" ? 1 : 0),
+        inputTokens: totals.inputTokens + usage.inputTokens,
+        outputTokens: totals.outputTokens + usage.outputTokens,
+        cacheReadTokens: totals.cacheReadTokens + usage.cacheReadTokens,
+        cacheWriteTokens: totals.cacheWriteTokens + usage.cacheWriteTokens,
+        reasoningTokens: totals.reasoningTokens + usage.reasoningTokens,
+    }
+}
+
+export function addCompressionUsageTotals(
+    totals: CompressionUsageTotals,
+    other: CompressionUsageTotals,
+): CompressionUsageTotals {
+    return {
+        calls: totals.calls + other.calls,
+        providerCalls: totals.providerCalls + other.providerCalls,
+        estimatedCalls: totals.estimatedCalls + other.estimatedCalls,
+        inputTokens: totals.inputTokens + other.inputTokens,
+        outputTokens: totals.outputTokens + other.outputTokens,
+        cacheReadTokens: totals.cacheReadTokens + other.cacheReadTokens,
+        cacheWriteTokens: totals.cacheWriteTokens + other.cacheWriteTokens,
+        reasoningTokens: totals.reasoningTokens + other.reasoningTokens,
+    }
+}
+
+/** Backward-compatible load of persisted totals. */
+export function normalizeCompressionUsageTotals(value: unknown): CompressionUsageTotals {
+    if (!value || typeof value !== "object") {
+        return emptyCompressionUsage()
+    }
+    const raw = value as Record<string, unknown>
+    return {
+        calls: toCount(raw.calls),
+        providerCalls: toCount(raw.providerCalls),
+        estimatedCalls: toCount(raw.estimatedCalls),
+        inputTokens: toCount(raw.inputTokens),
+        outputTokens: toCount(raw.outputTokens),
+        cacheReadTokens: toCount(raw.cacheReadTokens),
+        cacheWriteTokens: toCount(raw.cacheWriteTokens),
+        reasoningTokens: toCount(raw.reasoningTokens),
+    }
+}

package/lib/state/persistence.ts

@@ -10,6 +10,12 @@ import { homedir } from "os"
 import { join } from "path"
 import type { CompressionBlock, PrunedMessageEntry, SessionState, SessionStats } from "./types"
 import type { Logger } from "../logger"
+import {
+    addCompressionUsageTotals,
+    emptyCompressionUsage,
+    normalizeCompressionUsageTotals,
+    type CompressionUsageTotals,
+} from "../compress/usage"
 import { serializePruneMessagesState } from "./utils"
 
 /** Prune state as stored on disk */
@@ -227,6 +233,7 @@ function emptyPersistedState(manualMode: boolean): PersistedSessionState {
         stats: {
             pruneTokenCounter: 0,
             totalPruneTokens: 0,
+            compressionUsage: emptyCompressionUsage(),
         },
         lastUpdated: new Date().toISOString(),
     }
@@ -257,6 +264,7 @@ export interface AggregatedStats {
     totalTools: number
     totalMessages: number
     sessionCount: number
+    compressionUsage: CompressionUsageTotals
 }
 
 export async function loadAllSessionStats(logger: Logger): Promise<AggregatedStats> {
@@ -265,6 +273,7 @@ export async function loadAllSessionStats(logger: Logger): Promise<AggregatedSta
         totalTools: 0,
         totalMessages: 0,
         sessionCount: 0,
+        compressionUsage: emptyCompressionUsage(),
     }
 
     try {
@@ -281,14 +290,21 @@ export async function loadAllSessionStats(logger: Logger): Promise<AggregatedSta
                 const content = await fs.readFile(filePath, "utf-8")
                 const state = JSON.parse(content) as PersistedSessionState
 
-                if (state?.stats?.totalPruneTokens && state?.prune) {
-                    result.totalTokens += state.stats.totalPruneTokens
+                const usage = normalizeCompressionUsageTotals(state?.stats?.compressionUsage)
+                const hasUsage = usage.calls > 0
+
+                if (state?.prune && (state?.stats?.totalPruneTokens || hasUsage)) {
+                    result.totalTokens += state.stats?.totalPruneTokens || 0
                     result.totalTools += state.prune.tools
                         ? Object.keys(state.prune.tools).length
                         : 0
                     result.totalMessages += state.prune.messages?.byMessageId
                         ? Object.keys(state.prune.messages.byMessageId).length
                         : 0
+                    result.compressionUsage = addCompressionUsageTotals(
+                        result.compressionUsage,
+                        usage,
+                    )
                     result.sessionCount++
                 }
             } catch {

package/lib/state/state.ts

@@ -1,5 +1,6 @@
 import type { SessionState, ToolParameterEntry, WithParts } from "./types"
 import type { Logger } from "../logger"
+import { emptyCompressionUsage, normalizeCompressionUsageTotals } from "../compress/usage"
 import { applyPendingCompressionDurations } from "../compress/timing"
 import { loadManualModeSetting, loadSessionState, saveSessionState } from "./persistence"
 import {
@@ -84,6 +85,7 @@ export function createSessionState(idFormat: IdFormat = "xml"): SessionState {
         stats: {
             pruneTokenCounter: 0,
             totalPruneTokens: 0,
+            compressionUsage: emptyCompressionUsage(),
         },
         compressionTiming: {
             startsByCallId: new Map<string, number>(),
@@ -122,6 +124,7 @@ export function resetSessionState(state: SessionState): void {
     state.stats = {
         pruneTokenCounter: 0,
         totalPruneTokens: 0,
+        compressionUsage: emptyCompressionUsage(),
     }
     state.toolParameters.clear()
     state.subAgentResultCache.clear()
@@ -186,6 +189,7 @@ export async function ensureSessionInitialized(
     state.stats = {
         pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
         totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+        compressionUsage: normalizeCompressionUsageTotals(persisted.stats?.compressionUsage),
     }
 
     const applied = applyPendingCompressionDurations(state)

package/lib/state/types.ts

@@ -1,4 +1,5 @@
 import type { CompressionTimingState } from "../compress/timing"
+import type { CompressionUsageTotals } from "../compress/usage"
 import type { IdFormat } from "../message-ids"
 import { Message, Part } from "@opencode-ai/sdk/v2"
 
@@ -22,6 +23,8 @@ export interface ToolParameterEntry {
 export interface SessionStats {
     pruneTokenCounter: number
     totalPruneTokens: number
+    /** Token usage of the hidden compression (summary) requests. */
+    compressionUsage: CompressionUsageTotals
 }
 
 export interface PrunedMessageEntry {

package/lib/tui/dialogs.tsx

@@ -121,6 +121,24 @@ export function StatsDialog(props: { api: ViewApi; report: StatsReport; onBack:
                     label="Messages pruned"
                     value={`${props.report.sessionMessages}`}
                 />
+                <Metric
+                    theme={theme}
+                    label="Summary requests"
+                    value={`${props.report.sessionCompressionUsage.calls}`}
+                    hint={`${props.report.sessionCompressionUsage.providerCalls} provider · ${props.report.sessionCompressionUsage.estimatedCalls} estimated`}
+                />
+                <Metric
+                    theme={theme}
+                    label="Request in|out"
+                    value={`~${formatTokenCount(props.report.sessionCompressionUsage.inputTokens)} | ~${formatTokenCount(props.report.sessionCompressionUsage.outputTokens)}`}
+                    hint="tokens"
+                />
+                <Metric
+                    theme={theme}
+                    label="Request cache r|w"
+                    value={`~${formatTokenCount(props.report.sessionCompressionUsage.cacheReadTokens)} | ~${formatTokenCount(props.report.sessionCompressionUsage.cacheWriteTokens)}`}
+                    hint={`reasoning ~${formatTokenCount(props.report.sessionCompressionUsage.reasoningTokens)}`}
+                />
             </Card>
             <Card theme={theme} title="All time">
                 <Metric
@@ -144,6 +162,12 @@ export function StatsDialog(props: { api: ViewApi; report: StatsReport; onBack:
                     label="Sessions with DCP history"
                     value={`${props.report.allTime.sessionCount}`}
                 />
+                <Metric
+                    theme={theme}
+                    label="Summary requests"
+                    value={`${props.report.allTime.compressionUsage.calls}`}
+                    hint={`~${formatTokenCount(props.report.allTime.compressionUsage.inputTokens)} in · ~${formatTokenCount(props.report.allTime.compressionUsage.outputTokens)} out`}
+                />
             </Card>
         </DcpFrame>
     )

package/lib/v2/index.ts

@@ -4,8 +4,13 @@ import { getConfig } from "../config"
 import { Logger } from "../logger"
 import { PromptStore } from "../prompts/store"
 import { createRcCompressTool } from "../compress"
-import { RC_SUMMARY_MARKER } from "../compress/summary"
+import { extractSummaryCallId, hasSummaryMarker } from "../compress/summary"
 import { attachCompressionDuration } from "../compress/state"
+import {
+    createCompressionUsageTracker,
+    installCompressionUsageHook,
+    installHttpUsageHook,
+} from "./usage"
 import { createCommandExecuteHandler, createSystemPromptHandler } from "../hooks"
 import {
     createSessionState,
@@ -56,6 +61,9 @@ export async function setup(ctx: Plugin.Context) {
         return
     }
     const logger = new Logger(config.debug)
+    const usageTracker = createCompressionUsageTracker()
+    await installCompressionUsageHook(ctx, usageTracker, logger)
+    await installHttpUsageHook(ctx, usageTracker, logger)
     const prompts = new PromptStore(
         logger,
         ctx.location.directory,
@@ -251,7 +259,7 @@ export async function setup(ctx: Plugin.Context) {
                     (part: any) =>
                         part?.type === "text" &&
                         typeof part.text === "string" &&
-                        part.text.includes(RC_SUMMARY_MARKER),
+                        hasSummaryMarker(part.text),
                 ),
         )
         if (own.length === 0) {
@@ -261,6 +269,32 @@ export async function setup(ctx: Plugin.Context) {
         for (const name of Object.keys(event.tools ?? {})) {
             delete (event.tools as Record<string, unknown>)[name]
         }
+
+        // Local fallback estimate of the request input, used only when the
+        // provider usage cannot be captured from the language model wrapper.
+        const callId = own
+            .flatMap((message) =>
+                Array.isArray(message.content) ? (message.content as any[]) : [],
+            )
+            .filter((part) => part?.type === "text" && typeof part.text === "string")
+            .map((part) => extractSummaryCallId(part.text))
+            .find((id): id is string => !!id)
+        if (callId) {
+            const texts: string[] = []
+            for (const part of event.system ?? []) {
+                if (typeof (part as any)?.text === "string") {
+                    texts.push((part as any).text)
+                }
+            }
+            for (const message of own) {
+                for (const part of (message.content as any[]) ?? []) {
+                    if (part?.type === "text" && typeof part.text === "string") {
+                        texts.push(part.text)
+                    }
+                }
+            }
+            usageTracker.recordEstimatedInput(callId, countTokens(texts.join("\n")))
+        }
     })
 
     if (config.compress.permission !== "deny") {
@@ -271,9 +305,22 @@ export async function setup(ctx: Plugin.Context) {
                 logger,
                 config,
                 prompts,
-                generate: async (input: { sessionID: string; prompt: string }) => {
-                    const result = await ctx.session.generate(input)
-                    return result?.text ?? ""
+                generate: async (input: { sessionID: string; prompt: string; callId?: string }) => {
+                    try {
+                        const result = await ctx.session.generate({
+                            sessionID: input.sessionID,
+                            prompt: input.prompt,
+                        })
+                        const text = result?.text ?? ""
+                        const usage = input.callId
+                            ? usageTracker.resolve(input.callId, text)
+                            : undefined
+                        return { text, usage }
+                    } finally {
+                        if (input.callId) {
+                            usageTracker.discard(input.callId)
+                        }
+                    }
                 },
             }
             return createRcCompressTool(context)

package/lib/v2/rpc.ts

@@ -2,17 +2,29 @@ import { tool } from "@opencode-ai/plugin"
 
 const z = tool.schema
 const session = z.object({ sessionID: z.string() })
+const compressionUsage = z.object({
+    calls: z.number(),
+    providerCalls: z.number(),
+    estimatedCalls: z.number(),
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    cacheReadTokens: z.number(),
+    cacheWriteTokens: z.number(),
+    reasoningTokens: z.number(),
+})
 const stats = z.object({
     sessionTokens: z.number(),
     sessionSummaryTokens: z.number(),
     sessionDurationMs: z.number(),
     sessionTools: z.number(),
     sessionMessages: z.number(),
+    sessionCompressionUsage: compressionUsage,
     allTime: z.object({
         totalTokens: z.number(),
         totalTools: z.number(),
         totalMessages: z.number(),
         sessionCount: z.number(),
+        compressionUsage,
     }),
 })
 const context = z.object({