refactor: consolidate format handlers with FormatDescriptor pattern and fix tool ID case handling

Author: Tarquinen

index.ts

@@ -45,7 +45,7 @@ const plugin: Plugin = (async (ctx) => {
 
     // Wire up tool name lookup from the cached tool parameters
     toolTracker.getToolName = (callId: string) => {
-        const entry = state.toolParameters.get(callId)
+        const entry = state.toolParameters.get(callId.toLowerCase())
         return entry?.tool
     }
 

lib/fetch-wrapper/formats/gemini.ts

@@ -0,0 +1,173 @@
+import type { FormatDescriptor, ToolOutput } from "../types"
+import { PRUNED_CONTENT_MESSAGE } from "../types"
+import type { PluginState } from "../../state"
+import type { Logger } from "../../logger"
+import type { ToolTracker } from "../../api-formats/synth-instruction"
+import { injectSynthGemini, trackNewToolResultsGemini } from "../../api-formats/synth-instruction"
+import { injectPrunableListGemini } from "../../api-formats/prunable-list"
+
+/**
+ * Format descriptor for Google/Gemini API.
+ * 
+ * Uses body.contents array with:
+ * - parts[].functionCall for tool invocations
+ * - parts[].functionResponse for tool results
+ * 
+ * IMPORTANT: Gemini doesn't include tool call IDs in its native format.
+ * We use position-based correlation via state.googleToolCallMapping which maps
+ * "toolName:index" -> "toolCallId" (populated by hooks.ts from message events).
+ */
+export const geminiFormat: FormatDescriptor = {
+    name: 'gemini',
+
+    detect(body: any): boolean {
+        return body.contents && Array.isArray(body.contents)
+    },
+
+    getDataArray(body: any): any[] | undefined {
+        return body.contents
+    },
+
+    cacheToolParameters(_data: any[], _state: PluginState, _logger?: Logger): void {
+        // Gemini format doesn't include tool parameters in the request body.
+        // Tool parameters are captured via message events in hooks.ts and stored
+        // in state.googleToolCallMapping for position-based correlation.
+        // No-op here.
+    },
+
+    injectSynth(data: any[], instruction: string, nudgeText: string): boolean {
+        return injectSynthGemini(data, instruction, nudgeText)
+    },
+
+    trackNewToolResults(data: any[], tracker: ToolTracker, protectedTools: Set<string>): number {
+        return trackNewToolResultsGemini(data, tracker, protectedTools)
+    },
+
+    injectPrunableList(data: any[], injection: string): boolean {
+        return injectPrunableListGemini(data, injection)
+    },
+
+    extractToolOutputs(data: any[], state: PluginState): ToolOutput[] {
+        const outputs: ToolOutput[] = []
+
+        // We need the position mapping to correlate functionResponses to tool call IDs
+        // Find the mapping from any active session
+        let positionMapping: Map<string, string> | undefined
+        for (const [_sessionId, mapping] of state.googleToolCallMapping) {
+            if (mapping && mapping.size > 0) {
+                positionMapping = mapping
+                break
+            }
+        }
+
+        if (!positionMapping) {
+            return outputs
+        }
+
+        // Track position counters per tool name
+        const toolPositionCounters = new Map<string, number>()
+
+        for (const content of data) {
+            if (!Array.isArray(content.parts)) continue
+
+            for (const part of content.parts) {
+                if (part.functionResponse) {
+                    const funcName = part.functionResponse.name?.toLowerCase()
+                    if (funcName) {
+                        const currentIndex = toolPositionCounters.get(funcName) || 0
+                        toolPositionCounters.set(funcName, currentIndex + 1)
+
+                        const positionKey = `${funcName}:${currentIndex}`
+                        const toolCallId = positionMapping.get(positionKey)
+
+                        if (toolCallId) {
+                            outputs.push({
+                                id: toolCallId.toLowerCase(),
+                                toolName: funcName
+                            })
+                        }
+                    }
+                }
+            }
+        }
+
+        return outputs
+    },
+
+    replaceToolOutput(data: any[], toolId: string, prunedMessage: string, state: PluginState): boolean {
+        // Find the position mapping
+        let positionMapping: Map<string, string> | undefined
+        for (const [_sessionId, mapping] of state.googleToolCallMapping) {
+            if (mapping && mapping.size > 0) {
+                positionMapping = mapping
+                break
+            }
+        }
+
+        if (!positionMapping) {
+            return false
+        }
+
+        const toolIdLower = toolId.toLowerCase()
+        const toolPositionCounters = new Map<string, number>()
+        let replaced = false
+
+        for (let i = 0; i < data.length; i++) {
+            const content = data[i]
+            if (!Array.isArray(content.parts)) continue
+
+            let contentModified = false
+            const newParts = content.parts.map((part: any) => {
+                if (part.functionResponse) {
+                    const funcName = part.functionResponse.name?.toLowerCase()
+                    if (funcName) {
+                        const currentIndex = toolPositionCounters.get(funcName) || 0
+                        toolPositionCounters.set(funcName, currentIndex + 1)
+
+                        const positionKey = `${funcName}:${currentIndex}`
+                        const mappedToolId = positionMapping!.get(positionKey)
+
+                        if (mappedToolId?.toLowerCase() === toolIdLower) {
+                            contentModified = true
+                            replaced = true
+                            // Preserve thoughtSignature if present (required for Gemini 3 Pro)
+                            return {
+                                ...part,
+                                functionResponse: {
+                                    ...part.functionResponse,
+                                    response: {
+                                        name: part.functionResponse.name,
+                                        content: prunedMessage
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return part
+            })
+
+            if (contentModified) {
+                data[i] = { ...content, parts: newParts }
+            }
+        }
+
+        return replaced
+    },
+
+    hasToolOutputs(data: any[]): boolean {
+        return data.some((content: any) =>
+            Array.isArray(content.parts) &&
+            content.parts.some((part: any) => part.functionResponse)
+        )
+    },
+
+    getLogMetadata(data: any[], replacedCount: number, inputUrl: string): Record<string, any> {
+        return {
+            url: inputUrl,
+            replacedCount,
+            totalContents: data.length,
+            format: 'google-gemini'
+        }
+    }
+}

lib/fetch-wrapper/formats/index.ts

@@ -0,0 +1,3 @@
+export { openaiChatFormat } from './openai-chat'
+export { openaiResponsesFormat } from './openai-responses'
+export { geminiFormat } from './gemini'

lib/fetch-wrapper/formats/openai-chat.ts

@@ -0,0 +1,130 @@
+import type { FormatDescriptor, ToolOutput } from "../types"
+import { PRUNED_CONTENT_MESSAGE } from "../types"
+import type { PluginState } from "../../state"
+import type { Logger } from "../../logger"
+import type { ToolTracker } from "../../api-formats/synth-instruction"
+import { cacheToolParametersFromMessages } from "../../state/tool-cache"
+import { injectSynth, trackNewToolResults } from "../../api-formats/synth-instruction"
+import { injectPrunableList } from "../../api-formats/prunable-list"
+
+/**
+ * Format descriptor for OpenAI Chat Completions and Anthropic APIs.
+ * 
+ * OpenAI Chat format:
+ * - Messages with role='tool' and tool_call_id
+ * - Assistant messages with tool_calls[] array
+ * 
+ * Anthropic format:
+ * - Messages with role='user' containing content[].type='tool_result' and tool_use_id
+ * - Assistant messages with content[].type='tool_use'
+ */
+export const openaiChatFormat: FormatDescriptor = {
+    name: 'openai-chat',
+
+    detect(body: any): boolean {
+        return body.messages && Array.isArray(body.messages)
+    },
+
+    getDataArray(body: any): any[] | undefined {
+        return body.messages
+    },
+
+    cacheToolParameters(data: any[], state: PluginState, logger?: Logger): void {
+        cacheToolParametersFromMessages(data, state, logger)
+    },
+
+    injectSynth(data: any[], instruction: string, nudgeText: string): boolean {
+        return injectSynth(data, instruction, nudgeText)
+    },
+
+    trackNewToolResults(data: any[], tracker: ToolTracker, protectedTools: Set<string>): number {
+        return trackNewToolResults(data, tracker, protectedTools)
+    },
+
+    injectPrunableList(data: any[], injection: string): boolean {
+        return injectPrunableList(data, injection)
+    },
+
+    extractToolOutputs(data: any[], state: PluginState): ToolOutput[] {
+        const outputs: ToolOutput[] = []
+
+        for (const m of data) {
+            // OpenAI Chat format: role='tool' with tool_call_id
+            if (m.role === 'tool' && m.tool_call_id) {
+                const metadata = state.toolParameters.get(m.tool_call_id.toLowerCase())
+                outputs.push({
+                    id: m.tool_call_id.toLowerCase(),
+                    toolName: metadata?.tool
+                })
+            }
+
+            // Anthropic format: role='user' with content[].type='tool_result'
+            if (m.role === 'user' && Array.isArray(m.content)) {
+                for (const part of m.content) {
+                    if (part.type === 'tool_result' && part.tool_use_id) {
+                        const metadata = state.toolParameters.get(part.tool_use_id.toLowerCase())
+                        outputs.push({
+                            id: part.tool_use_id.toLowerCase(),
+                            toolName: metadata?.tool
+                        })
+                    }
+                }
+            }
+        }
+
+        return outputs
+    },
+
+    replaceToolOutput(data: any[], toolId: string, prunedMessage: string, _state: PluginState): boolean {
+        const toolIdLower = toolId.toLowerCase()
+        let replaced = false
+
+        for (let i = 0; i < data.length; i++) {
+            const m = data[i]
+
+            // OpenAI Chat format
+            if (m.role === 'tool' && m.tool_call_id?.toLowerCase() === toolIdLower) {
+                data[i] = { ...m, content: prunedMessage }
+                replaced = true
+            }
+
+            // Anthropic format
+            if (m.role === 'user' && Array.isArray(m.content)) {
+                let messageModified = false
+                const newContent = m.content.map((part: any) => {
+                    if (part.type === 'tool_result' && part.tool_use_id?.toLowerCase() === toolIdLower) {
+                        messageModified = true
+                        return { ...part, content: prunedMessage }
+                    }
+                    return part
+                })
+                if (messageModified) {
+                    data[i] = { ...m, content: newContent }
+                    replaced = true
+                }
+            }
+        }
+
+        return replaced
+    },
+
+    hasToolOutputs(data: any[]): boolean {
+        for (const m of data) {
+            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
+    },
+
+    getLogMetadata(data: any[], replacedCount: number, inputUrl: string): Record<string, any> {
+        return {
+            url: inputUrl,
+            replacedCount,
+            totalMessages: data.length
+        }
+    }
+}