refactor: modularize fetch wrapper and extract shared state into separate modules

- Split monolithic index.ts into focused modules for better maintainability
- Extract fetch wrapper into lib/fetch-wrapper/ with format-specific handlers:
  - openai-chat.ts: OpenAI Chat Completions & Anthropic format
  - openai-responses.ts: OpenAI Responses API format (GPT-5)
  - gemini.ts: Google/Gemini format with position-based correlation
  - types.ts: Shared types and utility functions
- Create lib/state.ts for centralized plugin state management
- Create lib/hooks.ts for event and chat.params handlers
- Create lib/pruning-tool.ts for context_pruning tool definition
- Create lib/tool-cache.ts for tool parameter caching utilities
- Reduce index.ts from 500+ lines to ~80 lines of initialization code

Author: Tarquinen

index.ts

@@ -0,0 +1,131 @@
+import type { FetchHandlerContext, FetchHandlerResult } from "./types"
+import {
+    PRUNED_CONTENT_MESSAGE,
+    getAllPrunedIds,
+    fetchSessionMessages
+} from "./types"
+
+/**
+ * Handles Google/Gemini format (body.contents array with functionResponse parts).
+ * Uses position-based correlation since Google's native format doesn't include tool call IDs.
+ */
+export async function handleGemini(
+    body: any,
+    ctx: FetchHandlerContext,
+    inputUrl: string
+): Promise<FetchHandlerResult> {
+    if (!body.contents || !Array.isArray(body.contents)) {
+        return { modified: false, body }
+    }
+
+    // Check for functionResponse parts in any content item
+    const hasFunctionResponses = body.contents.some((content: any) =>
+        Array.isArray(content.parts) &&
+        content.parts.some((part: any) => part.functionResponse)
+    )
+
+    if (!hasFunctionResponses) {
+        return { modified: false, body }
+    }
+
+    const { allSessions, allPrunedIds } = await getAllPrunedIds(ctx.client, ctx.state)
+
+    if (allPrunedIds.size === 0) {
+        return { modified: false, body }
+    }
+
+    // Find the active session to get the position mapping
+    const activeSessions = allSessions.data?.filter((s: any) => !s.parentID) || []
+    let positionMapping: Map<string, string> | undefined
+
+    for (const session of activeSessions) {
+        const mapping = ctx.state.googleToolCallMapping.get(session.id)
+        if (mapping && mapping.size > 0) {
+            positionMapping = mapping
+            break
+        }
+    }
+
+    if (!positionMapping) {
+        ctx.logger.info("fetch", "No Google tool call mapping found, skipping pruning for Gemini format")
+        return { modified: false, body }
+    }
+
+    // Build position counters to track occurrence of each tool name
+    const toolPositionCounters = new Map<string, number>()
+    let replacedCount = 0
+    let totalFunctionResponses = 0
+
+    body.contents = body.contents.map((content: any) => {
+        if (!Array.isArray(content.parts)) return content
+
+        let contentModified = false
+        const newParts = content.parts.map((part: any) => {
+            if (part.functionResponse) {
+                totalFunctionResponses++
+                const funcName = part.functionResponse.name?.toLowerCase()
+
+                if (funcName) {
+                    // Get current position for this tool name and increment counter
+                    const currentIndex = toolPositionCounters.get(funcName) || 0
+                    toolPositionCounters.set(funcName, currentIndex + 1)
+
+                    // Look up the tool call ID using position
+                    const positionKey = `${funcName}:${currentIndex}`
+                    const toolCallId = positionMapping!.get(positionKey)
+
+                    if (toolCallId && allPrunedIds.has(toolCallId)) {
+                        contentModified = true
+                        replacedCount++
+                        // Preserve thoughtSignature if present (required for Gemini 3 Pro)
+                        // Only replace the response content, not the structure
+                        return {
+                            ...part,
+                            functionResponse: {
+                                ...part.functionResponse,
+                                response: PRUNED_CONTENT_MESSAGE
+                            }
+                        }
+                    }
+                }
+            }
+            return part
+        })
+
+        if (contentModified) {
+            return { ...content, parts: newParts }
+        }
+        return content
+    })
+
+    if (replacedCount > 0) {
+        ctx.logger.info("fetch", "Replaced pruned tool outputs (Google/Gemini)", {
+            replaced: replacedCount,
+            total: totalFunctionResponses
+        })
+
+        if (ctx.logger.enabled) {
+            let sessionMessages: any[] | undefined
+            if (activeSessions.length > 0) {
+                const mostRecentSession = activeSessions[0]
+                sessionMessages = await fetchSessionMessages(ctx.client, mostRecentSession.id)
+            }
+
+            await ctx.logger.saveWrappedContext(
+                "global",
+                body.contents,
+                {
+                    url: inputUrl,
+                    replacedCount,
+                    totalContents: body.contents.length,
+                    format: 'google-gemini'
+                },
+                sessionMessages
+            )
+        }
+
+        return { modified: true, body }
+    }
+
+    return { modified: false, body }
+}

lib/fetch-wrapper/gemini.ts

@@ -0,0 +1,80 @@
+import type { PluginState } from "../state"
+import type { Logger } from "../logger"
+import type { FetchHandlerContext } from "./types"
+import { handleOpenAIChatAndAnthropic } from "./openai-chat"
+import { handleGemini } from "./gemini"
+import { handleOpenAIResponses } from "./openai-responses"
+
+export type { FetchHandlerContext, FetchHandlerResult } from "./types"
+
+/**
+ * Creates a wrapped global fetch that intercepts API calls and performs
+ * context pruning on tool outputs that have been marked for removal.
+ * 
+ * Supports four API formats:
+ * 1. OpenAI Chat Completions (body.messages with role='tool')
+ * 2. Anthropic (body.messages with role='user' containing tool_result)
+ * 3. Google/Gemini (body.contents with functionResponse parts)
+ * 4. OpenAI Responses API (body.input with function_call_output items)
+ */
+export function installFetchWrapper(
+    state: PluginState,
+    logger: Logger,
+    client: any
+): () => void {
+    const originalGlobalFetch = globalThis.fetch
+    
+    const ctx: FetchHandlerContext = {
+        state,
+        logger,
+        client
+    }
+
+    globalThis.fetch = async (input: any, init?: any) => {
+        if (init?.body && typeof init.body === 'string') {
+            try {
+                const body = JSON.parse(init.body)
+                const inputUrl = typeof input === 'string' ? input : 'URL object'
+                let modified = false
+
+                // Try each format handler in order
+                // OpenAI Chat Completions & Anthropic style (body.messages)
+                if (body.messages && Array.isArray(body.messages)) {
+                    const result = await handleOpenAIChatAndAnthropic(body, ctx, inputUrl)
+                    if (result.modified) {
+                        modified = true
+                    }
+                }
+
+                // Google/Gemini style (body.contents)
+                if (body.contents && Array.isArray(body.contents)) {
+                    const result = await handleGemini(body, ctx, inputUrl)
+                    if (result.modified) {
+                        modified = true
+                    }
+                }
+
+                // OpenAI Responses API style (body.input)
+                if (body.input && Array.isArray(body.input)) {
+                    const result = await handleOpenAIResponses(body, ctx, inputUrl)
+                    if (result.modified) {
+                        modified = true
+                    }
+                }
+
+                if (modified) {
+                    init.body = JSON.stringify(body)
+                }
+            } catch (e) {
+                // Silently ignore parsing errors - pass through to original fetch
+            }
+        }
+
+        return originalGlobalFetch(input, init)
+    }
+
+    // Return cleanup function to restore original fetch
+    return () => {
+        globalThis.fetch = originalGlobalFetch
+    }
+}

lib/fetch-wrapper/index.ts

@@ -0,0 +1,107 @@
+import type { FetchHandlerContext, FetchHandlerResult } from "./types"
+import {
+    PRUNED_CONTENT_MESSAGE,
+    getAllPrunedIds,
+    fetchSessionMessages,
+    getMostRecentActiveSession
+} from "./types"
+import { cacheToolParametersFromMessages } from "../tool-cache"
+
+/**
+ * Handles OpenAI Chat Completions format (body.messages with role='tool').
+ * Also handles Anthropic format (role='user' with tool_result content parts).
+ */
+export async function handleOpenAIChatAndAnthropic(
+    body: any,
+    ctx: FetchHandlerContext,
+    inputUrl: string
+): Promise<FetchHandlerResult> {
+    if (!body.messages || !Array.isArray(body.messages)) {
+        return { modified: false, body }
+    }
+
+    // Cache tool parameters from messages
+    cacheToolParametersFromMessages(body.messages, ctx.state)
+
+    // Check for tool messages in both formats:
+    // 1. OpenAI style: role === 'tool'
+    // 2. Anthropic style: role === 'user' with content containing tool_result
+    const toolMessages = body.messages.filter((m: any) => {
+        if (m.role === 'tool') return true
+        if (m.role === 'user' && Array.isArray(m.content)) {
+            for (const part of m.content) {
+                if (part.type === 'tool_result') return true
+            }
+        }
+        return false
+    })
+
+    const { allSessions, allPrunedIds } = await getAllPrunedIds(ctx.client, ctx.state)
+
+    if (toolMessages.length === 0 || allPrunedIds.size === 0) {
+        return { modified: false, body }
+    }
+
+    let replacedCount = 0
+
+    body.messages = body.messages.map((m: any) => {
+        // OpenAI style: role === 'tool' with tool_call_id
+        if (m.role === 'tool' && allPrunedIds.has(m.tool_call_id?.toLowerCase())) {
+            replacedCount++
+            return {
+                ...m,
+                content: PRUNED_CONTENT_MESSAGE
+            }
+        }
+
+        // Anthropic style: role === 'user' with content array containing tool_result
+        if (m.role === 'user' && Array.isArray(m.content)) {
+            let messageModified = false
+            const newContent = m.content.map((part: any) => {
+                if (part.type === 'tool_result' && allPrunedIds.has(part.tool_use_id?.toLowerCase())) {
+                    messageModified = true
+                    replacedCount++
+                    return {
+                        ...part,
+                        content: PRUNED_CONTENT_MESSAGE
+                    }
+                }
+                return part
+            })
+            if (messageModified) {
+                return { ...m, content: newContent }
+            }
+        }
+
+        return m
+    })
+
+    if (replacedCount > 0) {
+        ctx.logger.info("fetch", "Replaced pruned tool outputs", {
+            replaced: replacedCount,
+            total: toolMessages.length
+        })
+
+        if (ctx.logger.enabled) {
+            const mostRecentSession = getMostRecentActiveSession(allSessions)
+            const sessionMessages = mostRecentSession
+                ? await fetchSessionMessages(ctx.client, mostRecentSession.id)
+                : undefined
+
+            await ctx.logger.saveWrappedContext(
+                "global",
+                body.messages,
+                {
+                    url: inputUrl,
+                    replacedCount,
+                    totalMessages: body.messages.length
+                },
+                sessionMessages
+            )
+        }
+
+        return { modified: true, body }
+    }
+
+    return { modified: false, body }
+}