grov 0.2.3 → 0.5.3

package/dist/lib/utils.d.ts

@@ -5,6 +5,11 @@
  * Truncate a string to a maximum length, adding ellipsis if truncated.
  */
 export declare function truncate(str: string, maxLength: number): string;
+/**
+ * Smart truncate: cleans markdown noise, prefers sentence/punctuation boundaries.
+ * Used for reasoning content that may contain markdown tables, bullets, etc.
+ */
+export declare function smartTruncate(text: string, maxLen?: number): string;
 /**
  * Capitalize the first letter of a string.
  */

package/dist/lib/utils.js

@@ -9,6 +9,51 @@ export function truncate(str, maxLength) {
         return str;
     return str.substring(0, maxLength - 3) + '...';
 }
+/**
+ * Smart truncate: cleans markdown noise, prefers sentence/punctuation boundaries.
+ * Used for reasoning content that may contain markdown tables, bullets, etc.
+ */
+export function smartTruncate(text, maxLen = 120) {
+    // 1. Clean markdown noise
+    let clean = text
+        .replace(/\|[^|]+\|/g, '') // markdown table cells
+        .replace(/^[-*]\s*/gm, '') // bullet points
+        .replace(/#{1,6}\s*/g, '') // headers
+        .replace(/\n+/g, ' ') // newlines to space
+        .replace(/\s+/g, ' ') // multiple spaces to one
+        .trim();
+    // 2. If short enough, return as-is
+    if (clean.length <= maxLen)
+        return clean;
+    // 3. Try to keep complete sentences
+    const sentences = clean.match(/[^.!?]+[.!?]+/g) || [];
+    let result = '';
+    for (const sentence of sentences) {
+        if ((result + sentence).length <= maxLen) {
+            result += sentence;
+        }
+        else {
+            break;
+        }
+    }
+    // 4. If we got at least one meaningful sentence, return it
+    if (result.length > 20)
+        return result.trim();
+    // 5. Fallback: find punctuation boundary
+    const truncated = clean.slice(0, maxLen);
+    const breakPoints = [
+        truncated.lastIndexOf('. '),
+        truncated.lastIndexOf(', '),
+        truncated.lastIndexOf('; '),
+        truncated.lastIndexOf(': '),
+        truncated.lastIndexOf(' - '),
+        truncated.lastIndexOf(' '),
+    ].filter(p => p > maxLen * 0.6);
+    const cutPoint = breakPoints.length > 0
+        ? Math.max(...breakPoints)
+        : truncated.lastIndexOf(' ');
+    return truncated.slice(0, cutPoint > 0 ? cutPoint : maxLen).trim() + '...';
+}
 /**
  * Capitalize the first letter of a string.
  */

package/dist/proxy/action-parser.d.ts

@@ -10,9 +10,11 @@ export interface AnthropicResponse {
     usage: {
         input_tokens: number;
         output_tokens: number;
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
     };
 }
-export type ContentBlock = TextBlock | ToolUseBlock;
+export type ContentBlock = TextBlock | ToolUseBlock | ThinkingBlock;
 export interface TextBlock {
     type: 'text';
     text: string;
@@ -23,6 +25,10 @@ export interface ToolUseBlock {
     name: string;
     input: Record<string, unknown>;
 }
+export interface ThinkingBlock {
+    type: 'thinking';
+    thinking: string;
+}
 export interface ParsedAction {
     toolName: string;
     toolId: string;
@@ -37,12 +43,14 @@ export interface ParsedAction {
  */
 export declare function parseToolUseBlocks(response: AnthropicResponse): ParsedAction[];
 /**
- * Extract token usage from response
+ * Extract token usage from response (including cache metrics)
  */
 export declare function extractTokenUsage(response: AnthropicResponse): {
     inputTokens: number;
     outputTokens: number;
     totalTokens: number;
+    cacheCreation: number;
+    cacheRead: number;
 };
 /**
  * Check if response contains any file-modifying actions

package/dist/proxy/action-parser.js

@@ -132,13 +132,15 @@ function extractPathFromGlobPattern(pattern) {
     return nonGlobParts.length > 0 ? nonGlobParts.join('/') : null;
 }
 /**
- * Extract token usage from response
+ * Extract token usage from response (including cache metrics)
  */
 export function extractTokenUsage(response) {
     return {
         inputTokens: response.usage.input_tokens,
         outputTokens: response.usage.output_tokens,
-        totalTokens: response.usage.input_tokens + response.usage.output_tokens
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+        cacheCreation: response.usage.cache_creation_input_tokens || 0,
+        cacheRead: response.usage.cache_read_input_tokens || 0,
     };
 }
 /**

package/dist/proxy/cache.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Global team memory cache
+ * - Calculated ONCE on first request, reused for ALL subsequent requests
+ * - Invalidated only on: sync completion (in .then() callback), proxy restart
+ * - Ensures system prompt prefix stays CONSTANT for Anthropic cache preservation
+ */
+export declare let globalTeamMemoryCache: {
+    projectPath: string;
+    content: string;
+} | null;
+/**
+ * Invalidate the global team memory cache
+ * Called after successful sync to cloud (in .then() callback)
+ * This ensures cache is only invalidated AFTER data is in cloud
+ */
+export declare function invalidateTeamMemoryCache(): void;
+/**
+ * Set the global team memory cache
+ * @param projectPath - Project path for cache key
+ * @param content - Formatted team memory content
+ */
+export declare function setTeamMemoryCache(projectPath: string, content: string): void;
+/**
+ * Get the current cache content if it matches the project path
+ * @param projectPath - Project path to check
+ * @returns Cached content or null if not cached/different project
+ */
+export declare function getTeamMemoryCache(projectPath: string): string | null;
+/**
+ * Check if cache exists for a specific project
+ */
+export declare function hasCacheForProject(projectPath: string): boolean;
+/**
+ * Get current cache project path (for logging/debugging)
+ */
+export declare function getCacheProjectPath(): string | null;

package/dist/proxy/cache.js

@@ -0,0 +1,51 @@
+// Phase 0 verified
+// Cache management for team memory injection
+// Shared between server.ts and response-processor.ts to avoid circular dependencies
+/**
+ * Global team memory cache
+ * - Calculated ONCE on first request, reused for ALL subsequent requests
+ * - Invalidated only on: sync completion (in .then() callback), proxy restart
+ * - Ensures system prompt prefix stays CONSTANT for Anthropic cache preservation
+ */
+export let globalTeamMemoryCache = null;
+/**
+ * Invalidate the global team memory cache
+ * Called after successful sync to cloud (in .then() callback)
+ * This ensures cache is only invalidated AFTER data is in cloud
+ */
+export function invalidateTeamMemoryCache() {
+    globalTeamMemoryCache = null;
+    console.log('[CACHE] Team memory cache invalidated');
+}
+/**
+ * Set the global team memory cache
+ * @param projectPath - Project path for cache key
+ * @param content - Formatted team memory content
+ */
+export function setTeamMemoryCache(projectPath, content) {
+    globalTeamMemoryCache = { projectPath, content };
+    console.log(`[CACHE] Team memory cache set for project: ${projectPath} (${content.length} chars)`);
+}
+/**
+ * Get the current cache content if it matches the project path
+ * @param projectPath - Project path to check
+ * @returns Cached content or null if not cached/different project
+ */
+export function getTeamMemoryCache(projectPath) {
+    if (globalTeamMemoryCache && globalTeamMemoryCache.projectPath === projectPath) {
+        return globalTeamMemoryCache.content;
+    }
+    return null;
+}
+/**
+ * Check if cache exists for a specific project
+ */
+export function hasCacheForProject(projectPath) {
+    return globalTeamMemoryCache?.projectPath === projectPath;
+}
+/**
+ * Get current cache project path (for logging/debugging)
+ */
+export function getCacheProjectPath() {
+    return globalTeamMemoryCache?.projectPath || null;
+}

package/dist/proxy/config.d.ts

@@ -12,6 +12,7 @@ export declare const config: {
     ENABLE_TLS: boolean;
     LOG_LEVEL: string;
     LOG_REQUESTS: boolean;
+    EXTENDED_CACHE_ENABLED: boolean;
 };
 export declare const FORWARD_HEADERS: string[];
 export declare const SENSITIVE_HEADERS: string[];

package/dist/proxy/config.js

@@ -19,6 +19,8 @@ export const config = {
     // Logging
     LOG_LEVEL: process.env.LOG_LEVEL || 'info',
     LOG_REQUESTS: process.env.LOG_REQUESTS !== 'false',
+    // Extended Cache - preserve Anthropic prompt cache during idle
+    EXTENDED_CACHE_ENABLED: process.env.GROV_EXTENDED_CACHE === 'true',
 };
 // Headers to forward to Anthropic (whitelist approach)
 export const FORWARD_HEADERS = [

package/dist/proxy/extended-cache.d.ts

@@ -0,0 +1,10 @@
+export interface ExtendedCacheEntry {
+    headers: Record<string, string>;
+    rawBody: Buffer;
+    timestamp: number;
+    keepAliveCount: number;
+}
+export declare const extendedCache: Map<string, ExtendedCacheEntry>;
+export declare function log(msg: string): void;
+export declare function evictOldestCacheEntry(): void;
+export declare function checkExtendedCache(): Promise<void>;

package/dist/proxy/extended-cache.js

@@ -0,0 +1,155 @@
+// Extended Cache - Keep Anthropic cache alive during idle
+// Sends minimal keep-alive requests to prevent cache TTL expiration
+import { forwardToAnthropic } from './forwarder.js';
+export const extendedCache = new Map();
+// Timing constants
+const EXTENDED_CACHE_IDLE_THRESHOLD = 4 * 60 * 1000; // 4 minutes (under 5-min TTL)
+const EXTENDED_CACHE_MAX_IDLE = 10 * 60 * 1000; // 10 minutes total
+const EXTENDED_CACHE_MAX_KEEPALIVES = 2;
+const EXTENDED_CACHE_MAX_ENTRIES = 100; // Max concurrent sessions (memory cap)
+export function log(msg) {
+    console.log(`[CACHE] ${msg}`);
+}
+export function evictOldestCacheEntry() {
+    if (extendedCache.size < EXTENDED_CACHE_MAX_ENTRIES)
+        return;
+    let oldestId = null;
+    let oldestTime = Infinity;
+    for (const [id, entry] of extendedCache) {
+        if (entry.timestamp < oldestTime) {
+            oldestTime = entry.timestamp;
+            oldestId = id;
+        }
+    }
+    if (oldestId) {
+        extendedCache.delete(oldestId);
+        log(`Extended cache: evicted ${oldestId.substring(0, 8)} (capacity limit)`);
+    }
+}
+async function sendExtendedCacheKeepAlive(projectPath, entry) {
+    const projectName = projectPath.split('/').pop() || projectPath;
+    let rawBodyStr = entry.rawBody.toString('utf-8');
+    // 1. Find messages array and add "." message before closing bracket
+    const messagesMatch = rawBodyStr.match(/"messages"\s*:\s*\[/);
+    if (!messagesMatch || messagesMatch.index === undefined) {
+        throw new Error('Cannot find messages array in rawBody');
+    }
+    // Find closing bracket of messages array (handling nested arrays/objects)
+    const messagesStart = messagesMatch.index + messagesMatch[0].length;
+    let bracketDepth = 1; // We're inside the [ already
+    let braceDepth = 0; // Track {} for objects
+    let inString = false; // Track if we're inside a string
+    let messagesEnd = messagesStart;
+    for (let i = messagesStart; i < rawBodyStr.length && bracketDepth > 0; i++) {
+        const char = rawBodyStr[i];
+        const prevChar = i > 0 ? rawBodyStr[i - 1] : '';
+        // Handle string boundaries (skip escaped quotes)
+        if (char === '"' && prevChar !== '\\') {
+            inString = !inString;
+            continue;
+        }
+        // Skip everything inside strings
+        if (inString)
+            continue;
+        // Track brackets and braces
+        if (char === '[')
+            bracketDepth++;
+        else if (char === ']')
+            bracketDepth--;
+        else if (char === '{')
+            braceDepth++;
+        else if (char === '}')
+            braceDepth--;
+        // Found the closing bracket of messages array
+        if (bracketDepth === 0) {
+            messagesEnd = i;
+            break;
+        }
+    }
+    // Safety check: did we find the end?
+    if (bracketDepth !== 0) {
+        throw new Error(`Could not find closing bracket of messages array (depth=${bracketDepth})`);
+    }
+    // Check if array has content (anything between messagesStart and messagesEnd)
+    const arrayContent = rawBodyStr.slice(messagesStart, messagesEnd).trim();
+    const messagesIsEmpty = arrayContent.length === 0;
+    // Insert minimal user message before closing bracket
+    const keepAliveMsg = messagesIsEmpty
+        ? '{"role":"user","content":"."}'
+        : ',{"role":"user","content":"."}';
+    log(`Extended cache: SEND keep-alive project=${projectName} msg_array_size=${messagesEnd - messagesStart}`);
+    rawBodyStr = rawBodyStr.slice(0, messagesEnd) + keepAliveMsg + rawBodyStr.slice(messagesEnd);
+    // NOTE: We do NOT modify max_tokens or stream!
+    // Keeping them identical preserves the cache prefix for byte-exact matching.
+    // Claude will respond briefly to "." anyway, and forwarder handles streaming.
+    // 2. Validate JSON after manipulation
+    try {
+        JSON.parse(rawBodyStr);
+    }
+    catch (e) {
+        throw new Error(`Invalid JSON after modifications: ${e instanceof Error ? e.message : 'unknown'}`);
+    }
+    // 3. Forward to Anthropic using same undici path as regular requests
+    const result = await forwardToAnthropic({}, entry.headers, undefined, Buffer.from(rawBodyStr, 'utf-8'));
+    if (result.statusCode !== 200) {
+        throw new Error(`Keep-alive failed: ${result.statusCode}`);
+    }
+    // Log cache metrics
+    const usage = result.body.usage;
+    const cacheRead = usage?.cache_read_input_tokens || 0;
+    const cacheCreate = usage?.cache_creation_input_tokens || 0;
+    const inputTokens = usage?.input_tokens || 0;
+    log(`Extended cache: keep-alive for ${projectName} - cache_read=${cacheRead}, cache_create=${cacheCreate}, input=${inputTokens}`);
+}
+export async function checkExtendedCache() {
+    const now = Date.now();
+    const projectsToKeepAlive = [];
+    // First pass: cleanup stale/maxed entries, collect projects needing keep-alive
+    for (const [projectPath, entry] of extendedCache) {
+        const idleTime = now - entry.timestamp;
+        const projectName = projectPath.split('/').pop() || projectPath;
+        // Stale cleanup: user left after 10 minutes
+        if (idleTime > EXTENDED_CACHE_MAX_IDLE) {
+            extendedCache.delete(projectPath);
+            log(`Extended cache: cleared ${projectName} (stale)`);
+            continue;
+        }
+        // Skip if not idle enough yet
+        if (idleTime < EXTENDED_CACHE_IDLE_THRESHOLD) {
+            continue;
+        }
+        // Skip if already sent max keep-alives
+        if (entry.keepAliveCount >= EXTENDED_CACHE_MAX_KEEPALIVES) {
+            extendedCache.delete(projectPath);
+            log(`Extended cache: cleared ${projectName} (max retries)`);
+            continue;
+        }
+        projectsToKeepAlive.push({ projectPath, entry });
+    }
+    // Second pass: send all keep-alives in PARALLEL
+    const keepAlivePromises = [];
+    for (const { projectPath, entry } of projectsToKeepAlive) {
+        const projectName = projectPath.split('/').pop() || projectPath;
+        const promise = sendExtendedCacheKeepAlive(projectPath, entry)
+            .then(() => {
+            entry.timestamp = Date.now();
+            entry.keepAliveCount++;
+        })
+            .catch((err) => {
+            extendedCache.delete(projectPath);
+            // Handle both Error instances and ForwardError objects
+            const errMsg = err instanceof Error
+                ? err.message
+                : (err && typeof err === 'object' && 'message' in err)
+                    ? String(err.message)
+                    : JSON.stringify(err);
+            const errType = err && typeof err === 'object' && 'type' in err ? ` [${err.type}]` : '';
+            log(`Extended cache: cleared ${projectName} (error${errType}: ${errMsg})`);
+        });
+        keepAlivePromises.push(promise);
+    }
+    // Wait for all keep-alives to complete
+    if (keepAlivePromises.length > 0) {
+        await Promise.all(keepAlivePromises);
+    }
+}

package/dist/proxy/forwarder.d.ts

@@ -4,6 +4,7 @@ export interface ForwardResult {
     headers: Record<string, string | string[]>;
     body: AnthropicResponse | Record<string, unknown>;
     rawBody: string;
+    wasSSE: boolean;
 }
 export interface ForwardError {
     type: 'timeout' | 'network' | 'parse' | 'unknown';
@@ -13,11 +14,16 @@ export interface ForwardError {
 /**
  * Forward request to Anthropic API
  * Buffers full response for processing
+ *
+ * @param body - Parsed body for logging
+ * @param headers - Request headers
+ * @param logger - Optional logger
+ * @param rawBody - Raw request bytes (preserves exact bytes for cache)
  */
 export declare function forwardToAnthropic(body: Record<string, unknown>, headers: Record<string, string | string[] | undefined>, logger?: {
     info: (msg: string, data?: Record<string, unknown>) => void;
     error: (msg: string, data?: Record<string, unknown>) => void;
-}): Promise<ForwardResult>;
+}, rawBody?: Buffer): Promise<ForwardResult>;
 /**
  * Check if error is a ForwardError
  */

package/dist/proxy/forwarder.js

@@ -10,13 +10,139 @@ const agent = new Agent({
     autoSelectFamilyAttemptTimeout: 500, // Try next address family after 500ms
 });
 import { config, buildSafeHeaders, maskSensitiveValue } from './config.js';
+/**
+ * Parse SSE stream and reconstruct final message
+ * SSE format: "event: <type>\ndata: <json>\n\n"
+ */
+function parseSSEResponse(sseText) {
+    const lines = sseText.split('\n');
+    let message = null;
+    const contentBlocks = [];
+    const contentDeltas = new Map();
+    let finalUsage = null;
+    let stopReason = null;
+    let currentEvent = '';
+    let currentData = '';
+    for (const line of lines) {
+        if (line.startsWith('event: ')) {
+            currentEvent = line.slice(7).trim();
+        }
+        else if (line.startsWith('data: ')) {
+            currentData = line.slice(6);
+            try {
+                const data = JSON.parse(currentData);
+                switch (data.type) {
+                    case 'message_start':
+                        // Initialize message from message_start event
+                        message = data.message;
+                        break;
+                    case 'content_block_start':
+                        // Add new content block
+                        if (data.content_block) {
+                            contentBlocks[data.index] = data.content_block;
+                            if (data.content_block.type === 'text') {
+                                contentDeltas.set(data.index, []);
+                            }
+                            else if (data.content_block.type === 'thinking') {
+                                // Initialize thinking with empty string, will accumulate via deltas
+                                contentBlocks[data.index] = { type: 'thinking', thinking: '' };
+                            }
+                        }
+                        break;
+                    case 'content_block_delta':
+                        // Accumulate text deltas
+                        if (data.delta?.type === 'text_delta' && data.delta.text) {
+                            const deltas = contentDeltas.get(data.index) || [];
+                            deltas.push(data.delta.text);
+                            contentDeltas.set(data.index, deltas);
+                        }
+                        else if (data.delta?.type === 'thinking_delta' && data.delta.thinking) {
+                            // Handle thinking blocks
+                            const block = contentBlocks[data.index];
+                            if (block && block.type === 'thinking') {
+                                block.thinking += data.delta.thinking;
+                            }
+                        }
+                        else if (data.delta?.type === 'input_json_delta' && data.delta.partial_json) {
+                            // Handle tool input streaming
+                            const block = contentBlocks[data.index];
+                            if (block && block.type === 'tool_use') {
+                                // Accumulate partial JSON - will need to parse at the end
+                                const partialKey = `tool_partial_${data.index}`;
+                                const existing = contentDeltas.get(data.index) || [];
+                                existing.push(data.delta.partial_json);
+                                contentDeltas.set(data.index, existing);
+                            }
+                        }
+                        break;
+                    case 'message_delta':
+                        // Final usage and stop_reason
+                        if (data.usage) {
+                            finalUsage = data.usage;
+                        }
+                        if (data.delta?.stop_reason) {
+                            stopReason = data.delta.stop_reason;
+                        }
+                        break;
+                }
+            }
+            catch {
+                // Ignore unparseable data lines
+            }
+        }
+    }
+    if (!message) {
+        return null;
+    }
+    // Reconstruct content blocks with accumulated text/input
+    for (let i = 0; i < contentBlocks.length; i++) {
+        const block = contentBlocks[i];
+        if (!block)
+            continue;
+        const deltas = contentDeltas.get(i);
+        if (deltas && deltas.length > 0) {
+            if (block.type === 'text') {
+                block.text = deltas.join('');
+            }
+            else if (block.type === 'tool_use') {
+                // Parse accumulated partial JSON for tool input
+                try {
+                    const fullJson = deltas.join('');
+                    block.input = JSON.parse(fullJson);
+                }
+                catch {
+                    // Keep original input if parsing fails
+                }
+            }
+        }
+    }
+    // Build final response
+    const response = {
+        id: message.id || '',
+        type: 'message',
+        role: 'assistant',
+        content: contentBlocks.filter(Boolean),
+        model: message.model || '',
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage: finalUsage || message.usage || { input_tokens: 0, output_tokens: 0 },
+    };
+    return response;
+}
 /**
  * Forward request to Anthropic API
  * Buffers full response for processing
+ *
+ * @param body - Parsed body for logging
+ * @param headers - Request headers
+ * @param logger - Optional logger
+ * @param rawBody - Raw request bytes (preserves exact bytes for cache)
  */
-export async function forwardToAnthropic(body, headers, logger) {
+export async function forwardToAnthropic(body, headers, logger, rawBody) {
     const targetUrl = `${config.ANTHROPIC_BASE_URL}/v1/messages`;
     const safeHeaders = buildSafeHeaders(headers);
+    // Use raw bytes if available (preserves cache), otherwise re-serialize
+    const requestBody = rawBody || JSON.stringify(body);
     // Log request (mask sensitive data)
     if (logger && config.LOG_REQUESTS) {
         const maskedHeaders = {};
@@ -28,6 +154,8 @@ export async function forwardToAnthropic(body, headers, logger) {
             model: body.model,
             messageCount: Array.isArray(body.messages) ? body.messages.length : 0,
             headers: maskedHeaders,
+            usingRawBody: !!rawBody,
+            bodySize: rawBody?.length || JSON.stringify(body).length,
         });
     }
     try {
@@ -37,7 +165,7 @@ export async function forwardToAnthropic(body, headers, logger) {
                 ...safeHeaders,
                 'content-type': 'application/json',
             },
-            body: JSON.stringify(body),
+            body: requestBody,
             bodyTimeout: config.REQUEST_TIMEOUT,
             headersTimeout: config.REQUEST_TIMEOUT,
             dispatcher: agent,
@@ -48,14 +176,29 @@ export async function forwardToAnthropic(body, headers, logger) {
             chunks.push(Buffer.from(chunk));
         }
         const rawBody = Buffer.concat(chunks).toString('utf-8');
+        // Check if response is SSE streaming
+        const contentType = response.headers['content-type'];
+        const isSSE = typeof contentType === 'string' && contentType.includes('text/event-stream');
         // Parse response
         let parsedBody;
-        try {
-            parsedBody = JSON.parse(rawBody);
+        if (isSSE) {
+            // Parse SSE and reconstruct final message
+            const sseMessage = parseSSEResponse(rawBody);
+            if (sseMessage) {
+                parsedBody = sseMessage;
+            }
+            else {
+                parsedBody = { error: 'Failed to parse SSE response', raw: rawBody.substring(0, 500) };
+            }
         }
-        catch {
-            // Return raw body if not JSON
-            parsedBody = { error: 'Invalid JSON response', raw: rawBody.substring(0, 500) };
+        else {
+            // Regular JSON response
+            try {
+                parsedBody = JSON.parse(rawBody);
+            }
+            catch {
+                parsedBody = { error: 'Invalid JSON response', raw: rawBody.substring(0, 500) };
+            }
         }
         // Convert headers to record
         const responseHeaders = {};
@@ -64,11 +207,17 @@ export async function forwardToAnthropic(body, headers, logger) {
                 responseHeaders[key] = value;
             }
         }
+        // If we parsed SSE, change content-type to JSON for Claude Code
+        if (isSSE) {
+            responseHeaders['content-type'] = 'application/json';
+        }
         if (logger && config.LOG_REQUESTS) {
             logger.info('Received from Anthropic', {
                 statusCode: response.statusCode,
                 bodyLength: rawBody.length,
                 hasUsage: 'usage' in parsedBody,
+                wasSSE: isSSE,
+                parseSuccess: !('error' in parsedBody),
             });
         }
         return {
@@ -76,6 +225,7 @@ export async function forwardToAnthropic(body, headers, logger) {
             headers: responseHeaders,
             body: parsedBody,
             rawBody,
+            wasSSE: isSSE,
         };
     }
     catch (error) {

package/dist/proxy/handlers/preprocess.d.ts

@@ -0,0 +1,20 @@
+import type { MessagesRequestBody } from '../types.js';
+export declare function getPendingPlanClear(): {
+    projectPath: string;
+    summary: string;
+} | null;
+export declare function setPendingPlanClear(value: {
+    projectPath: string;
+    summary: string;
+}): void;
+export declare function clearPendingPlan(): void;
+export declare function preProcessRequest(body: MessagesRequestBody, sessionInfo: {
+    sessionId: string;
+    promptCount: number;
+    projectPath: string;
+}, logger: {
+    info: (data: Record<string, unknown>) => void;
+}, detectRequestType: (messages: Array<{
+    role: string;
+    content: unknown;
+}>, projectPath: string) => 'first' | 'continuation' | 'retry'): Promise<MessagesRequestBody>;