feat: add reasoning block extraction and improve onTool strategy

- Extract and log reasoning blocks from session messages for debugging
- Include encrypted content size from OpenAI, Anthropic, and Google providers
- Enable ai-analysis strategy by default on context_pruning tool calls
- Handle reasoning type parts in message minimization
- Fix README.md config key typo (plugins -> plugin)
- Add comments explaining provider workarounds

Author: Tarquinen

README.md

@@ -13,7 +13,7 @@ Add to your OpenCode config:
 ```jsonc
 // opencode.jsonc
 {
-  "plugins": ["@tarquinen/[email protected]"]
+  "plugin": ["@tarquinen/[email protected]"]
 }
 ```
 

index.ts

@@ -100,14 +100,33 @@ const plugin: Plugin = (async (ctx) => {
                             })
 
                             if (logger.enabled) {
+                                // Fetch session messages to extract reasoning blocks
+                                let sessionMessages: any[] | undefined
+                                try {
+                                    const activeSessions = allSessions.data?.filter(s => !s.parentID) || []
+                                    if (activeSessions.length > 0) {
+                                        const mostRecentSession = activeSessions[0]
+                                        const messagesResponse = await ctx.client.session.messages({
+                                            path: { id: mostRecentSession.id },
+                                            query: { limit: 100 }
+                                        })
+                                        sessionMessages = Array.isArray(messagesResponse.data)
+                                            ? messagesResponse.data
+                                            : Array.isArray(messagesResponse) ? messagesResponse : undefined
+                                    }
+                                } catch (e) {
+                                    // Silently continue without session messages
+                                }
+
                                 await logger.saveWrappedContext(
                                     "global",
                                     body.messages,
                                     {
                                         url: typeof input === 'string' ? input : 'URL object',
                                         replacedCount,
                                         totalMessages: body.messages.length
-                                    }
+                                    },
+                                    sessionMessages
                                 )
                             }
 

lib/config.ts

@@ -35,7 +35,7 @@ const defaultConfig: PluginConfig = {
     pruning_summary: 'detailed',
     strategies: {
         onIdle: ['deduplication', 'ai-analysis'],
-        onTool: ['deduplication']
+        onTool: ['deduplication', 'ai-analysis']
     }
 }
 
@@ -114,7 +114,7 @@ function createDefaultConfig(): void {
     // Strategies to run when session goes idle
     "onIdle": ["deduplication", "ai-analysis"],
     // Strategies to run when AI calls context_pruning tool
-    "onTool": ["deduplication"]
+    "onTool": ["deduplication", "ai-analysis"]
   },
   // Summary display: "off", "minimal", or "detailed"
   "pruning_summary": "detailed",

lib/logger.ts

@@ -147,7 +147,42 @@ export class Logger {
         return result
     }
 
-    async saveWrappedContext(sessionID: string, messages: any[], metadata: any) {
+    private extractReasoningBlocks(sessionMessages: any[]): any[] {
+        const reasoningBlocks: any[] = []
+
+        for (const msg of sessionMessages) {
+            if (!msg.parts) continue
+
+            for (const part of msg.parts) {
+                if (part.type === "reasoning") {
+                    // Calculate encrypted content size for different providers
+                    let encryptedContentLength = 0
+                    if (part.metadata?.openai?.reasoningEncryptedContent) {
+                        encryptedContentLength = part.metadata.openai.reasoningEncryptedContent.length
+                    } else if (part.metadata?.anthropic?.signature) {
+                        encryptedContentLength = part.metadata.anthropic.signature.length
+                    } else if (part.metadata?.google?.thoughtSignature) {
+                        encryptedContentLength = part.metadata.google.thoughtSignature.length
+                    }
+
+                    reasoningBlocks.push({
+                        messageId: msg.id,
+                        messageRole: msg.role,
+                        text: part.text,
+                        textLength: part.text?.length || 0,
+                        encryptedContentLength,
+                        time: part.time,
+                        hasMetadata: !!part.metadata,
+                        metadataKeys: part.metadata ? Object.keys(part.metadata) : []
+                    })
+                }
+            }
+        }
+
+        return reasoningBlocks
+    }
+
+    async saveWrappedContext(sessionID: string, messages: any[], metadata: any, sessionMessages?: any[]) {
         if (!this.enabled) return
 
         try {
@@ -197,11 +232,24 @@ export class Logger {
                     }
                 }
             } else {
+                // Extract reasoning blocks from session messages if available
+                const reasoningBlocks = sessionMessages
+                    ? this.extractReasoningBlocks(sessionMessages)
+                    : []
+
                 content = {
                     timestamp: new Date().toISOString(),
                     sessionID,
                     metadata,
-                    messages
+                    messages,
+                    ...(reasoningBlocks.length > 0 && {
+                        reasoning: {
+                            count: reasoningBlocks.length,
+                            totalTextCharacters: reasoningBlocks.reduce((sum, b) => sum + b.textLength, 0),
+                            totalEncryptedCharacters: reasoningBlocks.reduce((sum, b) => sum + b.encryptedContentLength, 0),
+                            blocks: reasoningBlocks
+                        }
+                    })
                 }
             }
 

lib/model-selector.ts

@@ -8,7 +8,7 @@ export interface ModelInfo {
 
 export const FALLBACK_MODELS: Record<string, string> = {
     openai: 'gpt-5-mini',
-    anthropic: 'claude-haiku-4-5',
+    anthropic: 'claude-haiku-4-5', //This model isn't broken in opencode-auth-provider
     google: 'gemini-2.5-flash',
     deepseek: 'deepseek-chat',
     xai: 'grok-4-fast',
@@ -28,6 +28,7 @@ const PROVIDER_PRIORITY = [
     'opencode'
 ];
 
+// TODO: some anthropic provided models aren't supported by the opencode-auth-provider package, so this provides a temporary workaround
 const SKIP_PROVIDERS = ['github-copilot', 'anthropic'];
 
 export interface ModelSelectionResult {

lib/prompt.ts

@@ -26,6 +26,28 @@ function minimizeMessages(messages: any[], alreadyPrunedIds?: string[], protecte
                         }
                     }
 
+                    // TODO: This should use the opencode normalized system instead of per provider settings
+                    if (part.type === 'reasoning') {
+                        // Calculate encrypted content size if present
+                        let encryptedContentLength = 0
+                        if (part.metadata?.openai?.reasoningEncryptedContent) {
+                            encryptedContentLength = part.metadata.openai.reasoningEncryptedContent.length
+                        } else if (part.metadata?.anthropic?.signature) {
+                            encryptedContentLength = part.metadata.anthropic.signature.length
+                        } else if (part.metadata?.google?.thoughtSignature) {
+                            encryptedContentLength = part.metadata.google.thoughtSignature.length
+                        }
+
+                        return {
+                            type: 'reasoning',
+                            text: part.text,
+                            textLength: part.text?.length || 0,
+                            encryptedContentLength,
+                            ...(part.time && { time: part.time }),
+                            ...(part.metadata && { metadataKeys: Object.keys(part.metadata) })
+                        }
+                    }
+
                     if (part.type === 'tool') {
                         const callIDLower = part.callID?.toLowerCase()
                         const isAlreadyPruned = prunedIdsSet.has(callIDLower)