claude-sdk-proxy 3.2.1 → 3.3.0

package/README.md

@@ -16,6 +16,8 @@ Any Anthropic/OpenAI client → claude-sdk-proxy (:3456) → Claude Agent SDK
 - **Full tool use** — proper `tool_use` content blocks, `stop_reason: "tool_use"`, `input_json_delta` streaming
 - **Built-in agent tools** — Claude has access to Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch
 - **API key protection** — optional `CLAUDE_PROXY_API_KEY` to secure network-exposed instances
+- **Session persistence** — SDK sessions survive proxy restarts via `persistSession: true`; automatic reset detection when message count drops
+- **Exact usage tracking** — real `input_tokens`, `output_tokens`, `cache_read_input_tokens`, and `cache_creation_input_tokens` from the SDK (no rough estimates)
 - **Streaming SSE** — `message_start` emitted immediately; 15s heartbeat keeps connections alive
 - **Request timeout** — configurable per-request timeout (default 5 minutes)
 - **Graceful shutdown** — SIGINT/SIGTERM handlers wait for in-flight requests
@@ -159,6 +161,7 @@ Client tool mode is auto-detected when the request has a `tools` array and the s
 | `GET` | `/v1/models/:id` | Get model details |
 | `POST` | `/v1/messages` | Create a message (streaming or non-streaming) |
 | `POST` | `/v1/messages/count_tokens` | Estimate token count |
+| `DELETE` | `/sessions/:id` | Invalidate a cached session |
 | `POST` | `/v1/chat/completions` | OpenAI-compatible chat completions |
 | `GET` | `/v1/chat/models` | List models (OpenAI format) |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-sdk-proxy",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "description": "Anthropic Messages API proxy backed by Claude Agent SDK — use Claude Max with any API client",
   "type": "module",
   "main": "./src/proxy/server.ts",

package/src/proxy/server.ts

@@ -213,6 +213,13 @@ function roughTokens(text: string): number {
   return Math.ceil((text ?? "").length / 4)
 }
 
+function buildUsage(input: number, output: number, cacheRead: number, cacheCreation: number) {
+  const usage: Record<string, number> = { input_tokens: input, output_tokens: output }
+  if (cacheRead > 0) usage.cache_read_input_tokens = cacheRead
+  if (cacheCreation > 0) usage.cache_creation_input_tokens = cacheCreation
+  return usage
+}
+
 // ── Conversation label extraction ────────────────────────────────────────────
 // Openclaw embeds "Conversation info (untrusted metadata)" in the last user
 // message containing a JSON block with conversation_label. Extract it to use
@@ -376,6 +383,17 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
     return c.json(result)
   })
 
+  app.delete("/sessions/:id", (c) => {
+    const id = decodeURIComponent(c.req.param("id"))
+    const stored = sessionStore.get(id)
+    if (stored) {
+      sessionStore.invalidate(id)
+      logInfo("session.api_reset", { conversationId: id, sdkSessionId: stored.sdkSessionId })
+      return c.json({ ok: true, invalidated: id })
+    }
+    return c.json({ ok: false, error: "session not found" }, 404)
+  })
+
   app.get("/debug/traces", (c) => {
     const limit = parseInt(c.req.query("limit") ?? "20", 10)
     return c.json(traceStore.getRecentTraces(limit))
@@ -655,19 +673,30 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
       let resumeSessionId: string | undefined
       let isResuming = false
 
-      if (conversationId && messages.length > 1) {
+      if (conversationId) {
         const stored = sessionStore.get(conversationId)
         if (stored && stored.model === model) {
-          resumeSessionId = stored.sdkSessionId
-          isResuming = true
-          logInfo("session.resuming", {
-            reqId,
-            conversationId,
-            sdkSessionId: resumeSessionId,
-            storedMsgCount: stored.messageCount,
-            currentMsgCount: messages.length,
-            resumeCount: stored.resumeCount,
-          })
+          if (messages.length < stored.messageCount) {
+            // Client reset detected: message count dropped
+            logInfo("session.reset_detected", {
+              reqId, conversationId,
+              sdkSessionId: stored.sdkSessionId,
+              storedMsgCount: stored.messageCount,
+              currentMsgCount: messages.length,
+            })
+            sessionStore.invalidate(conversationId)
+          } else {
+            resumeSessionId = stored.sdkSessionId
+            isResuming = true
+            logInfo("session.resuming", {
+              reqId,
+              conversationId,
+              sdkSessionId: resumeSessionId,
+              storedMsgCount: stored.messageCount,
+              currentMsgCount: messages.length,
+              resumeCount: stored.resumeCount,
+            })
+          }
         }
       }
 
@@ -679,6 +708,11 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
       let promptInput: string | AsyncIterable<any>
       // promptText: always the text-only version for token counting and logging
       promptText = serializeContent(lastMsg.content)
+      // Track real usage from SDK stream events
+      let sdkInputTokens = 0
+      let sdkOutputTokens = 0
+      let sdkCacheReadTokens = 0
+      let sdkCacheCreationTokens = 0
 
       if (isResuming && resumeSessionId) {
         systemPrompt = (systemContext || "").trim() || undefined
@@ -778,6 +812,16 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
             if (message.type === "system" && (message as any).subtype === "init") {
               capturedSessionId = (message as any).session_id
             }
+            if (message.type === "result") {
+              const r = message as any
+              if (r.session_id) capturedSessionId = r.session_id
+              if (r.usage) {
+                sdkInputTokens = r.usage.input_tokens ?? sdkInputTokens
+                sdkOutputTokens = r.usage.output_tokens ?? sdkOutputTokens
+                sdkCacheReadTokens = r.usage.cache_read_input_tokens ?? sdkCacheReadTokens
+                sdkCacheCreationTokens = r.usage.cache_creation_input_tokens ?? sdkCacheCreationTokens
+              }
+            }
             if (hasTools && message.type === "stream_event") {
               const ev = (message as any).event as any
               if (ev.type === "content_block_start") {
@@ -813,6 +857,11 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                 }
               } else if (ev.type === "message_delta") {
                 if (ev.delta?.stop_reason) capturedStopReason = ev.delta.stop_reason
+                if (ev.usage?.output_tokens) sdkOutputTokens = ev.usage.output_tokens
+              } else if (ev.type === "message_start" && ev.message?.usage) {
+                if (ev.message.usage.input_tokens) sdkInputTokens = ev.message.usage.input_tokens
+                if (ev.message.usage.cache_read_input_tokens) sdkCacheReadTokens = ev.message.usage.cache_read_input_tokens
+                if (ev.message.usage.cache_creation_input_tokens) sdkCacheCreationTokens = ev.message.usage.cache_creation_input_tokens
               }
             } else if (!hasTools && message.type === "assistant") {
               let turnText = ""
@@ -820,6 +869,10 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                 if (block.type === "text") turnText += block.text
               }
               fullText = turnText
+              // Capture usage from assistant message
+              const msgUsage = (message as any).message?.usage
+              if (msgUsage?.input_tokens) sdkInputTokens = msgUsage.input_tokens
+              if (msgUsage?.output_tokens) sdkOutputTokens = msgUsage.output_tokens
             }
           }
           traceStore.phase(reqId, "sdk_done")
@@ -827,7 +880,7 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
           // Store session mapping for future resumption
           if (conversationId && capturedSessionId) {
             if (isResuming) {
-              sessionStore.recordResume(conversationId)
+              sessionStore.recordResume(conversationId, messages.length)
               logInfo("session.resumed_ok", { reqId, conversationId, sdkSessionId: capturedSessionId })
             } else {
               sessionStore.set(conversationId, capturedSessionId, model, messages.length)
@@ -860,6 +913,16 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
               if (message.type === "system" && (message as any).subtype === "init") {
                 capturedSessionId = (message as any).session_id
               }
+              if (message.type === "result") {
+                const r = message as any
+                if (r.session_id) capturedSessionId = r.session_id
+                if (r.usage) {
+                  sdkInputTokens = r.usage.input_tokens ?? sdkInputTokens
+                  sdkOutputTokens = r.usage.output_tokens ?? sdkOutputTokens
+                  sdkCacheReadTokens = r.usage.cache_read_input_tokens ?? sdkCacheReadTokens
+                  sdkCacheCreationTokens = r.usage.cache_creation_input_tokens ?? sdkCacheCreationTokens
+                }
+              }
               if (hasTools && message.type === "stream_event") {
                 const ev = (message as any).event as any
                 if (ev.type === "content_block_start") {
@@ -890,6 +953,11 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                   }
                 } else if (ev.type === "message_delta") {
                   if (ev.delta?.stop_reason) capturedStopReason = ev.delta.stop_reason
+                  if (ev.usage?.output_tokens) sdkOutputTokens = ev.usage.output_tokens
+                } else if (ev.type === "message_start" && ev.message?.usage) {
+                  if (ev.message.usage.input_tokens) sdkInputTokens = ev.message.usage.input_tokens
+                  if (ev.message.usage.cache_read_input_tokens) sdkCacheReadTokens = ev.message.usage.cache_read_input_tokens
+                  if (ev.message.usage.cache_creation_input_tokens) sdkCacheCreationTokens = ev.message.usage.cache_creation_input_tokens
                 }
               } else if (!hasTools && message.type === "assistant") {
                 let turnText = ""
@@ -897,6 +965,9 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                   if (block.type === "text") turnText += block.text
                 }
                 fullText = turnText
+                const msgUsage = (message as any).message?.usage
+                if (msgUsage?.input_tokens) sdkInputTokens = msgUsage.input_tokens
+                if (msgUsage?.output_tokens) sdkOutputTokens = msgUsage.output_tokens
               }
             }
             traceStore.phase(reqId, "sdk_done")
@@ -937,10 +1008,12 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
             id: generateId("msg_"),
             type: "message", role: "assistant", content,
             model: body.model, stop_reason: stopReason, stop_sequence: null,
-            usage: { input_tokens: roughTokens(promptText), output_tokens: roughTokens(fullText) }
+            usage: buildUsage(sdkInputTokens, sdkOutputTokens, sdkCacheReadTokens, sdkCacheCreationTokens)
           })
         }
 
+        logDebug("usage.tokens", { reqId, sdkInput: sdkInputTokens, sdkOutput: sdkOutputTokens, cacheRead: sdkCacheReadTokens, cacheCreation: sdkCacheCreationTokens })
+
         if (!fullText || !fullText.trim()) fullText = "..."
         traceStore.complete(reqId, { outputLen: fullText.length })
 
@@ -949,7 +1022,7 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
           type: "message", role: "assistant",
           content: [{ type: "text", text: fullText }],
           model: body.model, stop_reason: "end_turn", stop_sequence: null,
-          usage: { input_tokens: roughTokens(promptText), output_tokens: roughTokens(fullText) }
+          usage: buildUsage(sdkInputTokens, sdkOutputTokens, sdkCacheReadTokens, sdkCacheCreationTokens)
         })
       }
 
@@ -1015,14 +1088,21 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
               }
             }, 15_000)
 
-            sse("message_start", {
-              type: "message_start",
-              message: {
-                id: messageId, type: "message", role: "assistant", content: [],
-                model: body.model, stop_reason: null, stop_sequence: null,
-                usage: { input_tokens: roughTokens(promptText), output_tokens: 1 }
+            // Defer message_start until SDK provides real input_tokens
+            let messageStartSent = false
+            const emitMessageStart = () => {
+              if (!messageStartSent) {
+                messageStartSent = true
+                sse("message_start", {
+                  type: "message_start",
+                  message: {
+                    id: messageId, type: "message", role: "assistant", content: [],
+                    model: body.model, stop_reason: null, stop_sequence: null,
+                    usage: buildUsage(sdkInputTokens, 1, sdkCacheReadTokens, sdkCacheCreationTokens)
+                  }
+                })
               }
-            })
+            }
 
             if (hasTools) {
               // ── With tools: forward native SDK stream events directly as SSE ──
@@ -1041,6 +1121,15 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
 
               // Helper to forward a stream event directly as SSE
               const forwardStreamEvent = (ev: any) => {
+                if (ev.type === "message_start" && ev.message?.usage) {
+                  if (ev.message.usage.input_tokens) sdkInputTokens = ev.message.usage.input_tokens
+                  if (ev.message.usage.cache_read_input_tokens) sdkCacheReadTokens = ev.message.usage.cache_read_input_tokens
+                  if (ev.message.usage.cache_creation_input_tokens) sdkCacheCreationTokens = ev.message.usage.cache_creation_input_tokens
+                  emitMessageStart()
+                  return
+                }
+                // Ensure message_start is sent before any content blocks
+                emitMessageStart()
                 if (ev.type === "content_block_start") {
                   const cb = ev.content_block
                   if (cb?.type === "tool_use") {
@@ -1064,6 +1153,7 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                   blockIdx++
                 } else if (ev.type === "message_delta") {
                   if (ev.delta?.stop_reason) capturedStopReason = ev.delta.stop_reason
+                  if (ev.usage?.output_tokens) sdkOutputTokens = ev.usage.output_tokens
                 }
               }
 
@@ -1077,6 +1167,16 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                   if (message.type === "system" && (message as any).subtype === "init") {
                     capturedSessionId = (message as any).session_id
                   }
+                  if (message.type === "result") {
+                    const r = message as any
+                    if (r.session_id) capturedSessionId = r.session_id
+                    if (r.usage) {
+                      sdkInputTokens = r.usage.input_tokens ?? sdkInputTokens
+                      sdkOutputTokens = r.usage.output_tokens ?? sdkOutputTokens
+                      sdkCacheReadTokens = r.usage.cache_read_input_tokens ?? sdkCacheReadTokens
+                      sdkCacheCreationTokens = r.usage.cache_creation_input_tokens ?? sdkCacheCreationTokens
+                    }
+                  }
                   if (message.type === "stream_event") {
                     const ev = (message as any).event as any
                     if (!trace!.firstTokenAt && (ev.type === "content_block_delta" || ev.type === "content_block_start")) {
@@ -1091,7 +1191,7 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                 // Store session mapping
                 if (conversationId && capturedSessionId) {
                   if (isResuming) {
-                    sessionStore.recordResume(conversationId)
+                    sessionStore.recordResume(conversationId, messages.length)
                   } else {
                     sessionStore.set(conversationId, capturedSessionId, model, messages.length)
                   }
@@ -1123,6 +1223,16 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                     if (message.type === "system" && (message as any).subtype === "init") {
                       capturedSessionId = (message as any).session_id
                     }
+                    if (message.type === "result") {
+                      const r = message as any
+                      if (r.session_id) capturedSessionId = r.session_id
+                      if (r.usage) {
+                        sdkInputTokens = r.usage.input_tokens ?? sdkInputTokens
+                        sdkOutputTokens = r.usage.output_tokens ?? sdkOutputTokens
+                        sdkCacheReadTokens = r.usage.cache_read_input_tokens ?? sdkCacheReadTokens
+                        sdkCacheCreationTokens = r.usage.cache_creation_input_tokens ?? sdkCacheCreationTokens
+                      }
+                    }
                     if (message.type === "stream_event") {
                       const ev = (message as any).event as any
                       if (!trace!.firstTokenAt && (ev.type === "content_block_delta" || ev.type === "content_block_start")) {
@@ -1149,6 +1259,9 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
 
               traceStore.phase(reqId, "responding")
 
+              // Ensure message_start is sent even if no SDK events came
+              emitMessageStart()
+
               // If no blocks were emitted at all, emit a placeholder text block
               if (!hasEmittedAnyBlock) {
                 sse("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } })
@@ -1157,7 +1270,7 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
               }
 
               const stopReason = toolCallCount > 0 ? "tool_use" : (capturedStopReason ?? "end_turn")
-              sse("message_delta", { type: "message_delta", delta: { stop_reason: stopReason, stop_sequence: null }, usage: { output_tokens: roughTokens(fullText) } })
+              sse("message_delta", { type: "message_delta", delta: { stop_reason: stopReason, stop_sequence: null }, usage: { output_tokens: sdkOutputTokens } })
               sse("message_stop", { type: "message_stop" })
               controller.close()
 
@@ -1166,7 +1279,7 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
             }
 
             // ── No tools: stream text deltas directly ─────────────────────
-            sse("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } })
+            let contentBlockStartSent = false
 
             let fullText = ""
             let hasStreamed = false
@@ -1188,8 +1301,25 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                 if (message.type === "system" && (message as any).subtype === "init") {
                   capturedSessionId2 = (message as any).session_id
                 }
+                if (message.type === "result") {
+                  const r = message as any
+                  if (r.session_id) capturedSessionId2 = r.session_id
+                  if (r.usage) {
+                    sdkInputTokens = r.usage.input_tokens ?? sdkInputTokens
+                    sdkOutputTokens = r.usage.output_tokens ?? sdkOutputTokens
+                    sdkCacheReadTokens = r.usage.cache_read_input_tokens ?? sdkCacheReadTokens
+                    sdkCacheCreationTokens = r.usage.cache_creation_input_tokens ?? sdkCacheCreationTokens
+                  }
+                }
                 if (message.type === "stream_event") {
                   const ev = message.event as any
+                  // Capture usage from SDK message_start (real input tokens)
+                  if (ev.type === "message_start" && ev.message?.usage) {
+                    if (ev.message.usage.input_tokens) sdkInputTokens = ev.message.usage.input_tokens
+                    if (ev.message.usage.cache_read_input_tokens) sdkCacheReadTokens = ev.message.usage.cache_read_input_tokens
+                    if (ev.message.usage.cache_creation_input_tokens) sdkCacheCreationTokens = ev.message.usage.cache_creation_input_tokens
+                    emitMessageStart()
+                  }
                   // Detect first content event BEFORE sdkEvent records it
                   if (!trace!.firstTokenAt && (ev.type === "content_block_delta" || ev.type === "content_block_start")) {
                     traceStore.phase(reqId, "sdk_streaming")
@@ -1197,12 +1327,20 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                   if (ev.type === "content_block_delta" && ev.delta?.type === "text_delta") {
                     const text = ev.delta.text ?? ""
                     if (text) {
+                      // Ensure message_start and content_block_start are sent before first delta
+                      emitMessageStart()
+                      if (!contentBlockStartSent) {
+                        contentBlockStartSent = true
+                        sse("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } })
+                      }
                       fullText += text
                       hasStreamed = true
                       traceStore.updateOutput(reqId, fullText.length)
                       checkOutputSize(fullText.length)
                       sse("content_block_delta", { type: "content_block_delta", index: 0, delta: { type: "text_delta", text } })
                     }
+                  } else if (ev.type === "message_delta" && ev.usage?.output_tokens) {
+                    sdkOutputTokens = ev.usage.output_tokens
                   }
                 }
                 traceStore.sdkEvent(reqId, sdkEventCount, message.type, subtype)
@@ -1212,7 +1350,7 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
               // Store session mapping
               if (conversationId && capturedSessionId2) {
                 if (isResuming) {
-                  sessionStore.recordResume(conversationId)
+                  sessionStore.recordResume(conversationId, messages.length)
                 } else {
                   sessionStore.set(conversationId, capturedSessionId2, model, messages.length)
                 }
@@ -1239,20 +1377,43 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
                   if (message.type === "system" && (message as any).subtype === "init") {
                     capturedSessionId2 = (message as any).session_id
                   }
+                  if (message.type === "result") {
+                    const r = message as any
+                    if (r.session_id) capturedSessionId2 = r.session_id
+                    if (r.usage) {
+                      sdkInputTokens = r.usage.input_tokens ?? sdkInputTokens
+                      sdkOutputTokens = r.usage.output_tokens ?? sdkOutputTokens
+                      sdkCacheReadTokens = r.usage.cache_read_input_tokens ?? sdkCacheReadTokens
+                      sdkCacheCreationTokens = r.usage.cache_creation_input_tokens ?? sdkCacheCreationTokens
+                    }
+                  }
                   if (message.type === "stream_event") {
                     const ev = message.event as any
+                    if (ev.type === "message_start" && ev.message?.usage) {
+                      if (ev.message.usage.input_tokens) sdkInputTokens = ev.message.usage.input_tokens
+                      if (ev.message.usage.cache_read_input_tokens) sdkCacheReadTokens = ev.message.usage.cache_read_input_tokens
+                      if (ev.message.usage.cache_creation_input_tokens) sdkCacheCreationTokens = ev.message.usage.cache_creation_input_tokens
+                      emitMessageStart()
+                    }
                     if (!trace!.firstTokenAt && (ev.type === "content_block_delta" || ev.type === "content_block_start")) {
                       traceStore.phase(reqId, "sdk_streaming")
                     }
                     if (ev.type === "content_block_delta" && ev.delta?.type === "text_delta") {
                       const text = ev.delta.text ?? ""
                       if (text) {
+                        emitMessageStart()
+                        if (!contentBlockStartSent) {
+                          contentBlockStartSent = true
+                          sse("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } })
+                        }
                         fullText += text
                         hasStreamed = true
                         traceStore.updateOutput(reqId, fullText.length)
                         checkOutputSize(fullText.length)
                         sse("content_block_delta", { type: "content_block_delta", index: 0, delta: { type: "text_delta", text } })
                       }
+                    } else if (ev.type === "message_delta" && ev.usage?.output_tokens) {
+                      sdkOutputTokens = ev.usage.output_tokens
                     }
                   }
                   traceStore.sdkEvent(reqId, sdkEventCount, message.type, subtype)
@@ -1273,12 +1434,19 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
               releaseQueue()
             }
 
+            // Ensure message_start and content_block_start are emitted even if no stream events came
+            emitMessageStart()
+            if (!contentBlockStartSent) {
+              contentBlockStartSent = true
+              sse("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } })
+            }
+
             if (!hasStreamed) {
               sse("content_block_delta", { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "..." } })
             }
 
             sse("content_block_stop", { type: "content_block_stop", index: 0 })
-            sse("message_delta", { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: roughTokens(fullText) } })
+            sse("message_delta", { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: sdkOutputTokens } })
             sse("message_stop", { type: "message_stop" })
             controller.close()
 

package/src/session-store.ts

@@ -43,11 +43,9 @@ class SessionStore {
   constructor(ttlMs = DEFAULT_TTL_MS) {
     this.ttlMs = ttlMs
     this.load()
-    // Clear all sessions on startup — SDK sessions don't survive proxy restarts
+    // SDK sessions persist on disk via persistSession: true — keep our mappings
     if (this.sessions.size > 0) {
-      logInfo("session-store.startup_clear", { cleared: this.sessions.size })
-      this.sessions.clear()
-      this.save()
+      logInfo("session-store.loaded_sessions", { count: this.sessions.size })
     }
   }
 
@@ -87,10 +85,11 @@ class SessionStore {
   }
 
   /** Record a successful resume */
-  recordResume(conversationId: string): void {
+  recordResume(conversationId: string, messageCount: number): void {
     const entry = this.sessions.get(conversationId)
     if (entry) {
       entry.resumeCount++
+      entry.messageCount = messageCount
       entry.lastUsed = Date.now()
       this.save()
     }