feat: add compression time to /dcp stats

Author: spoons-and-mirrors

index.ts

@@ -13,6 +13,7 @@ import {
     createChatMessageHandler,
     createChatMessageTransformHandler,
     createCommandExecuteHandler,
+    createEventHandler,
     createSystemPromptHandler,
     createTextCompleteHandler,
 } from "./lib/hooks"
@@ -68,6 +69,7 @@ const plugin: Plugin = (async (ctx) => {
         ) as any,
         "chat.message": createChatMessageHandler(state, logger, config, hostPermissions),
         "experimental.text.complete": createTextCompleteHandler(),
+        event: createEventHandler(state, logger),
         "command.execute.before": createCommandExecuteHandler(
             ctx.client,
             state,

lib/commands/stats.ts

@@ -22,6 +22,7 @@ function formatStatsMessage(
     sessionTokens: number,
     sessionTools: number,
     sessionMessages: number,
+    sessionCompressionTimeMs: number,
     allTime: AggregatedStats,
 ): string {
     const lines: string[] = []
@@ -35,6 +36,7 @@ function formatStatsMessage(
     lines.push(`  Tokens pruned:   ~${formatTokenCount(sessionTokens)}`)
     lines.push(`  Tools pruned:     ${sessionTools}`)
     lines.push(`  Messages pruned:  ${sessionMessages}`)
+    lines.push(`  LLM summary time: ${formatCompressionTime(sessionCompressionTimeMs)}`)
     lines.push("")
     lines.push("All-time:")
     lines.push("─".repeat(60))
@@ -46,11 +48,21 @@ function formatStatsMessage(
     return lines.join("\n")
 }
 
+function formatCompressionTime(ms: number): string {
+    if (ms < 1000) {
+        return `${ms} ms`
+    }
+
+    const seconds = ms / 1000
+    return `${seconds.toFixed(seconds < 10 ? 2 : 1)} s`
+}
+
 export async function handleStatsCommand(ctx: StatsCommandContext): Promise<void> {
     const { client, state, logger, sessionId, messages } = ctx
 
     // Session stats from in-memory state
     const sessionTokens = state.stats.totalPruneTokens
+    const sessionCompressionTimeMs = state.stats.compressionTimeMs
 
     const prunedToolIds = new Set<string>(state.prune.tools.keys())
     for (const block of state.prune.messages.blocksById.values()) {
@@ -72,7 +84,13 @@ export async function handleStatsCommand(ctx: StatsCommandContext): Promise<void
     // All-time stats from storage files
     const allTime = await loadAllSessionStats(logger)
 
-    const message = formatStatsMessage(sessionTokens, sessionTools, sessionMessages, allTime)
+    const message = formatStatsMessage(
+        sessionTokens,
+        sessionTools,
+        sessionMessages,
+        sessionCompressionTimeMs,
+        allTime,
+    )
 
     const params = getCurrentParams(state, messages, logger)
     await sendIgnoredMessage(client, sessionId, message, params, logger)
@@ -81,6 +99,7 @@ export async function handleStatsCommand(ctx: StatsCommandContext): Promise<void
         sessionTokens,
         sessionTools,
         sessionMessages,
+        sessionCompressionTimeMs,
         allTimeTokens: allTime.totalTokens,
         allTimeTools: allTime.totalTools,
         allTimeMessages: allTime.totalMessages,

lib/compress/message.ts

@@ -48,7 +48,6 @@ export function createCompressMessageTool(ctx: ToolContext): ReturnType<typeof t
         async execute(args, toolCtx) {
             const input = args as CompressMessageToolArgs
             validateArgs(input)
-
             const { rawMessages, searchContext } = await prepareSession(
                 ctx,
                 toolCtx,

lib/compress/range.ts

@@ -59,7 +59,6 @@ export function createCompressRangeTool(ctx: ToolContext): ReturnType<typeof too
         async execute(args, toolCtx) {
             const input = args as CompressRangeToolArgs
             validateArgs(input)
-
             const { rawMessages, searchContext } = await prepareSession(
                 ctx,
                 toolCtx,

lib/hooks.ts

@@ -266,6 +266,56 @@ export function createTextCompleteHandler() {
     }
 }
 
+export function createEventHandler(state: SessionState, logger: Logger) {
+    return async (input: { event: any }) => {
+        if (!state.sessionId) {
+            return
+        }
+
+        if (input.event.type !== "message.part.updated") {
+            return
+        }
+
+        const { sessionID, part, time } = input.event.properties
+        if (sessionID !== state.sessionId || part.type !== "tool" || part.tool !== "compress") {
+            return
+        }
+
+        if (part.state.status === "pending") {
+            if (state.compressionStarts.has(part.callID)) {
+                return
+            }
+
+            state.compressionStarts.set(part.callID, time)
+            logger.debug("Recorded compress input start", {
+                callID: part.callID,
+                startedAt: time,
+            })
+            return
+        }
+
+        if (part.state.status === "running") {
+            const startedAt = state.compressionStarts.get(part.callID)
+            if (startedAt === undefined) {
+                return
+            }
+
+            state.compressionStarts.delete(part.callID)
+            const durationMs = Math.max(0, time - startedAt)
+            state.stats.compressionTimeMs += durationMs
+
+            logger.info("Recorded compress input generation time", {
+                callID: part.callID,
+                durationMs,
+                totalDurationMs: state.stats.compressionTimeMs,
+            })
+            return
+        }
+
+        state.compressionStarts.delete(part.callID)
+    }
+}
+
 export function createChatMessageHandler(
     state: SessionState,
     logger: Logger,

lib/state/state.ts

@@ -80,7 +80,9 @@ export function createSessionState(): SessionState {
         stats: {
             pruneTokenCounter: 0,
             totalPruneTokens: 0,
+            compressionTimeMs: 0,
         },
+        compressionStarts: new Map<string, number>(),
         toolParameters: new Map<string, ToolParameterEntry>(),
         subAgentResultCache: new Map<string, string>(),
         toolIdList: [],
@@ -115,7 +117,9 @@ export function resetSessionState(state: SessionState): void {
     state.stats = {
         pruneTokenCounter: 0,
         totalPruneTokens: 0,
+        compressionTimeMs: 0,
     }
+    state.compressionStarts.clear()
     state.toolParameters.clear()
     state.subAgentResultCache.clear()
     state.toolIdList = []
@@ -176,5 +180,6 @@ export async function ensureSessionInitialized(
     state.stats = {
         pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
         totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+        compressionTimeMs: persisted.stats?.compressionTimeMs || 0,
     }
 }

lib/state/types.ts

@@ -19,6 +19,7 @@ export interface ToolParameterEntry {
 export interface SessionStats {
     pruneTokenCounter: number
     totalPruneTokens: number
+    compressionTimeMs: number
 }
 
 export interface PrunedMessageEntry {
@@ -96,6 +97,7 @@ export interface SessionState {
     prune: Prune
     nudges: Nudges
     stats: SessionStats
+    compressionStarts: Map<string, number>
     toolParameters: Map<string, ToolParameterEntry>
     subAgentResultCache: Map<string, string>
     toolIdList: string[]

tests/hooks-permission.test.ts

@@ -5,6 +5,7 @@ import {
     createChatMessageHandler,
     createChatMessageTransformHandler,
     createCommandExecuteHandler,
+    createEventHandler,
     createTextCompleteHandler,
 } from "../lib/hooks"
 import { Logger } from "../lib/logger"
@@ -152,3 +153,100 @@ test("text complete strips hallucinated metadata tags", async () => {
 
     assert.equal(output.text, "alpha  omega")
 })
+
+test("event hook records compress input generation duration", async () => {
+    const state = createSessionState()
+    state.sessionId = "session-1"
+    const handler = createEventHandler(state, new Logger(false))
+
+    await handler({
+        event: {
+            type: "message.part.updated",
+            properties: {
+                sessionID: "session-1",
+                time: 100,
+                part: {
+                    type: "tool",
+                    tool: "compress",
+                    callID: "call-1",
+                    state: {
+                        status: "pending",
+                        input: {},
+                        raw: "",
+                    },
+                },
+            },
+        },
+    })
+
+    await handler({
+        event: {
+            type: "message.part.updated",
+            properties: {
+                sessionID: "session-1",
+                time: 325,
+                part: {
+                    type: "tool",
+                    tool: "compress",
+                    callID: "call-1",
+                    state: {
+                        status: "running",
+                        input: { topic: "x" },
+                        time: { start: 325 },
+                    },
+                },
+            },
+        },
+    })
+
+    assert.equal(state.stats.compressionTimeMs, 225)
+    assert.equal(state.compressionStarts.has("call-1"), false)
+})
+
+test("event hook ignores non-compress tool parts", async () => {
+    const state = createSessionState()
+    state.sessionId = "session-1"
+    const handler = createEventHandler(state, new Logger(false))
+
+    await handler({
+        event: {
+            type: "message.part.updated",
+            properties: {
+                sessionID: "session-1",
+                time: 120,
+                part: {
+                    type: "tool",
+                    tool: "bash",
+                    callID: "call-2",
+                    state: {
+                        status: "pending",
+                        input: {},
+                        raw: "",
+                    },
+                },
+            },
+        },
+    })
+
+    await handler({
+        event: {
+            type: "message.part.updated",
+            properties: {
+                sessionID: "session-1",
+                time: 220,
+                part: {
+                    type: "tool",
+                    tool: "bash",
+                    callID: "call-2",
+                    state: {
+                        status: "running",
+                        input: {},
+                        time: { start: 220 },
+                    },
+                },
+            },
+        },
+    })
+
+    assert.equal(state.stats.compressionTimeMs, 0)
+})