@royalcat/opencode-dcp-rc 4.0.0 → 4.0.2

package/lib/v2/index.ts

@@ -4,8 +4,14 @@ 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 { installResponseScrubHook, type OutputScrubConfig } from "./scrub"
 import { createCommandExecuteHandler, createSystemPromptHandler } from "../hooks"
 import {
     createSessionState,
@@ -56,6 +62,14 @@ export async function setup(ctx: Plugin.Context) {
         return
     }
     const logger = new Logger(config.debug)
+    const usageTracker = createCompressionUsageTracker()
+    const scrub: OutputScrubConfig = {
+        modelOutput: config.compress.scrubModelOutput,
+        messageIds: config.compress.scrubMessageIds,
+    }
+    await installCompressionUsageHook(ctx, usageTracker, logger, scrub)
+    await installHttpUsageHook(ctx, usageTracker, logger)
+    await installResponseScrubHook(ctx, scrub, logger)
     const prompts = new PromptStore(
         logger,
         ctx.location.directory,
@@ -251,7 +265,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 +275,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 +311,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({