@cc-monitoring/proxy-core 0.1.4 → 0.1.5

package/dist/utils/openai-converter.js

@@ -0,0 +1,293 @@
+import { Transform } from 'stream';
+/**
+ * Recursively cleans a JSON Schema for OpenAI API compatibility.
+ * Removes '$schema' and 'additionalProperties'.
+ * For string types, removes 'format' unless it's 'date-time' or 'enum'.
+ */
+function recursivelyCleanSchema(schema) {
+    if (schema === null || typeof schema !== 'object')
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map(item => recursivelyCleanSchema(item));
+    const newSchema = {};
+    for (const key in schema) {
+        if (Object.prototype.hasOwnProperty.call(schema, key)) {
+            if (key === '$schema' || key === 'additionalProperties')
+                continue;
+            newSchema[key] = recursivelyCleanSchema(schema[key]);
+        }
+    }
+    if (newSchema.type === 'string' && newSchema.format) {
+        const supportedFormats = ['date-time', 'enum'];
+        if (!supportedFormats.includes(newSchema.format)) {
+            delete newSchema.format;
+        }
+    }
+    return newSchema;
+}
+/**
+ * Converts a Claude API request body to OpenAI format.
+ */
+export function convertClaudeToOpenAIRequest(claudeRequest, modelName) {
+    const openaiMessages = [];
+    if (claudeRequest.system) {
+        const systemContent = typeof claudeRequest.system === 'string'
+            ? claudeRequest.system
+            : Array.isArray(claudeRequest.system)
+                ? claudeRequest.system.map((block) => block.type === 'text' ? block.text : '').join('\n')
+                : String(claudeRequest.system);
+        openaiMessages.push({ role: 'system', content: systemContent });
+    }
+    for (const message of claudeRequest.messages) {
+        if (message.role === 'user') {
+            if (Array.isArray(message.content)) {
+                const toolResults = message.content.filter(c => c.type === 'tool_result');
+                const otherContent = message.content.filter(c => c.type !== 'tool_result');
+                if (toolResults.length > 0) {
+                    toolResults.forEach(block => {
+                        openaiMessages.push({
+                            role: 'tool',
+                            tool_call_id: block.tool_use_id,
+                            content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content),
+                        });
+                    });
+                }
+                if (otherContent.length > 0) {
+                    openaiMessages.push({
+                        role: 'user',
+                        content: otherContent.map(block => block.type === 'text'
+                            ? { type: 'text', text: block.text }
+                            : { type: 'image_url', image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` } })
+                    });
+                }
+            }
+            else {
+                openaiMessages.push({ role: 'user', content: message.content });
+            }
+        }
+        else if (message.role === 'assistant') {
+            const textParts = [];
+            const toolCalls = [];
+            if (Array.isArray(message.content)) {
+                message.content.forEach(block => {
+                    if (block.type === 'text') {
+                        textParts.push(block.text);
+                    }
+                    else if (block.type === 'tool_use') {
+                        toolCalls.push({
+                            id: block.id,
+                            type: 'function',
+                            function: { name: block.name, arguments: JSON.stringify(block.input || {}) },
+                        });
+                    }
+                });
+            }
+            const assistantMessage = {
+                role: 'assistant',
+                content: textParts.join('\n') || null
+            };
+            if (toolCalls.length > 0) {
+                assistantMessage.tool_calls = toolCalls;
+            }
+            openaiMessages.push(assistantMessage);
+        }
+    }
+    const openaiRequest = {
+        model: modelName,
+        messages: openaiMessages,
+        max_tokens: claudeRequest.max_tokens,
+        temperature: claudeRequest.temperature,
+        top_p: claudeRequest.top_p,
+        stream: claudeRequest.stream,
+        stop: claudeRequest.stop_sequences,
+    };
+    if (claudeRequest.tools) {
+        openaiRequest.tools = claudeRequest.tools.map((tool) => {
+            const cleanedParameters = recursivelyCleanSchema(tool.input_schema);
+            return {
+                type: 'function',
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: cleanedParameters,
+                },
+            };
+        });
+    }
+    if (claudeRequest.tool_choice) {
+        if (claudeRequest.tool_choice.type === 'auto' || claudeRequest.tool_choice.type === 'any') {
+            openaiRequest.tool_choice = 'auto';
+        }
+        else if (claudeRequest.tool_choice.type === 'tool') {
+            openaiRequest.tool_choice = { type: 'function', function: { name: claudeRequest.tool_choice.name } };
+        }
+    }
+    return openaiRequest;
+}
+/**
+ * Converts a non-streaming OpenAI response to Claude format.
+ */
+export function convertOpenAIToClaudeResponse(openaiResponse, model) {
+    const choice = openaiResponse.choices[0];
+    const contentBlocks = [];
+    if (choice.message.content) {
+        contentBlocks.push({ type: 'text', text: choice.message.content });
+    }
+    if (choice.message.tool_calls) {
+        choice.message.tool_calls.forEach((call) => {
+            contentBlocks.push({
+                type: 'tool_use',
+                id: call.id,
+                name: call.function.name,
+                input: JSON.parse(call.function.arguments),
+            });
+        });
+    }
+    const stopReasonMap = {
+        stop: 'end_turn',
+        length: 'max_tokens',
+        tool_calls: 'tool_use'
+    };
+    return {
+        id: openaiResponse.id,
+        type: 'message',
+        role: 'assistant',
+        model,
+        content: contentBlocks,
+        stop_reason: stopReasonMap[choice.finish_reason] || 'end_turn',
+        usage: {
+            input_tokens: openaiResponse.usage.prompt_tokens,
+            output_tokens: openaiResponse.usage.completion_tokens,
+        },
+    };
+}
+/**
+ * Builds headers for OpenAI-compatible API requests.
+ */
+export function buildOpenAIHeaders(apiKey) {
+    return {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+    };
+}
+/**
+ * Creates a Node.js Transform stream that converts OpenAI SSE chunks to Claude SSE events.
+ */
+export function createStreamTransformer(model) {
+    let initialized = false;
+    let buffer = '';
+    const messageId = `msg_${Math.random().toString(36).substr(2, 9)}`;
+    const toolCalls = {};
+    let contentBlockIndex = 0;
+    const sendEvent = (event, data) => {
+        return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    };
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            if (!initialized) {
+                this.push(sendEvent('message_start', {
+                    type: 'message_start',
+                    message: {
+                        id: messageId,
+                        type: 'message',
+                        role: 'assistant',
+                        model,
+                        content: [],
+                        stop_reason: null,
+                        usage: { input_tokens: 0, output_tokens: 0 }
+                    }
+                }));
+                this.push(sendEvent('content_block_start', {
+                    type: 'content_block_start',
+                    index: 0,
+                    content_block: { type: 'text', text: '' }
+                }));
+                initialized = true;
+            }
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                const data = line.substring(6);
+                if (data.trim() === '[DONE]') {
+                    // Send closing events
+                    this.push(sendEvent('content_block_stop', { type: 'content_block_stop', index: 0 }));
+                    Object.values(toolCalls).forEach(tc => {
+                        if (tc.started) {
+                            this.push(sendEvent('content_block_stop', { type: 'content_block_stop', index: tc.claudeIndex }));
+                        }
+                    });
+                    let finalStopReason = 'end_turn';
+                    try {
+                        const lastChunk = JSON.parse(lines[lines.length - 2].substring(6));
+                        const finishReason = lastChunk.choices[0].finish_reason;
+                        if (finishReason === 'tool_calls')
+                            finalStopReason = 'tool_use';
+                        if (finishReason === 'length')
+                            finalStopReason = 'max_tokens';
+                    }
+                    catch { }
+                    this.push(sendEvent('message_delta', {
+                        type: 'message_delta',
+                        delta: { stop_reason: finalStopReason, stop_sequence: null },
+                        usage: { output_tokens: 0 }
+                    }));
+                    this.push(sendEvent('message_stop', { type: 'message_stop' }));
+                    callback();
+                    this.destroy();
+                    return;
+                }
+                try {
+                    const openaiChunk = JSON.parse(data);
+                    const delta = openaiChunk.choices[0]?.delta;
+                    if (!delta)
+                        continue;
+                    if (delta.content) {
+                        this.push(sendEvent('content_block_delta', {
+                            type: 'content_block_delta',
+                            index: 0,
+                            delta: { type: 'text_delta', text: delta.content }
+                        }));
+                    }
+                    if (delta.tool_calls) {
+                        for (const tc_delta of delta.tool_calls) {
+                            const index = tc_delta.index;
+                            if (!toolCalls[index]) {
+                                toolCalls[index] = { id: '', name: '', args: '', claudeIndex: 0, started: false };
+                            }
+                            if (tc_delta.id)
+                                toolCalls[index].id = tc_delta.id;
+                            if (tc_delta.function?.name)
+                                toolCalls[index].name = tc_delta.function.name;
+                            if (tc_delta.function?.arguments)
+                                toolCalls[index].args += tc_delta.function.arguments;
+                            if (toolCalls[index].id && toolCalls[index].name && !toolCalls[index].started) {
+                                contentBlockIndex++;
+                                toolCalls[index].claudeIndex = contentBlockIndex;
+                                toolCalls[index].started = true;
+                                this.push(sendEvent('content_block_start', {
+                                    type: 'content_block_start',
+                                    index: contentBlockIndex,
+                                    content_block: { type: 'tool_use', id: toolCalls[index].id, name: toolCalls[index].name, input: {} }
+                                }));
+                            }
+                            if (toolCalls[index].started && tc_delta.function?.arguments) {
+                                this.push(sendEvent('content_block_delta', {
+                                    type: 'content_block_delta',
+                                    index: toolCalls[index].claudeIndex,
+                                    delta: { type: 'input_json_delta', partial_json: tc_delta.function.arguments }
+                                }));
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore JSON parse errors in SSE chunks
+                }
+            }
+            callback();
+        }
+    });
+}

package/dist/utils/providers-db.d.ts

@@ -11,6 +11,7 @@ export interface Provider {
     subagent_model: string | null;
     provider: string;
     default: boolean;
+    is_openai_compatible: boolean;
     created_at: string;
     updated_at: string;
 }
@@ -25,6 +26,7 @@ export interface ProviderInput {
     subagent_model?: string;
     provider: string;
     default?: boolean;
+    is_openai_compatible?: boolean;
 }
 export interface ProviderValidationError {
     index?: number;

package/dist/utils/providers-db.js

@@ -1,10 +1,22 @@
 const REQUIRED_FIELDS = ['name', 'provider'];
 export function listProviders(db) {
     const rows = db.prepare('SELECT * FROM providers ORDER BY created_at DESC').all();
-    return rows.map(r => {
-        const { is_default, ...rest } = r;
-        return { ...rest, default: !!is_default };
-    });
+    return rows.map(r => ({
+        id: r.id,
+        name: r.name,
+        base_url: r.base_url,
+        api_key: r.api_key,
+        model: r.model,
+        haiku_model: r.haiku_model,
+        sonnet_model: r.sonnet_model,
+        opus_model: r.opus_model,
+        subagent_model: r.subagent_model,
+        provider: r.provider,
+        default: !!r.is_default,
+        is_openai_compatible: !!r.is_openai_compatible,
+        created_at: r.created_at,
+        updated_at: r.updated_at,
+    }));
 }
 /**
  * Destructive full replacement: deletes ALL existing providers then inserts the given list.
@@ -16,13 +28,13 @@ export function listProviders(db) {
 export function saveProviders(db, providers) {
     const deleteAll = db.prepare('DELETE FROM providers');
     const insertOne = db.prepare(`
-    INSERT INTO providers (name, base_url, api_key, model, haiku_model, sonnet_model, opus_model, subagent_model, provider, is_default)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO providers (name, base_url, api_key, model, haiku_model, sonnet_model, opus_model, subagent_model, provider, is_default, is_openai_compatible)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
     const transaction = db.transaction(() => {
         deleteAll.run();
         for (const p of providers) {
-            insertOne.run(p.name, p.base_url && p.base_url.trim() !== '' ? p.base_url : null, p.api_key && p.api_key.trim() !== '' ? p.api_key : null, p.model && p.model.trim() !== '' ? p.model : null, p.haiku_model && p.haiku_model.trim() !== '' ? p.haiku_model : null, p.sonnet_model && p.sonnet_model.trim() !== '' ? p.sonnet_model : null, p.opus_model && p.opus_model.trim() !== '' ? p.opus_model : null, p.subagent_model && p.subagent_model.trim() !== '' ? p.subagent_model : null, p.provider, p.default ? 1 : 0);
+            insertOne.run(p.name, p.base_url && p.base_url.trim() !== '' ? p.base_url : null, p.api_key && p.api_key.trim() !== '' ? p.api_key : null, p.model && p.model.trim() !== '' ? p.model : null, p.haiku_model && p.haiku_model.trim() !== '' ? p.haiku_model : null, p.sonnet_model && p.sonnet_model.trim() !== '' ? p.sonnet_model : null, p.opus_model && p.opus_model.trim() !== '' ? p.opus_model : null, p.subagent_model && p.subagent_model.trim() !== '' ? p.subagent_model : null, p.provider, p.default ? 1 : 0, p.is_openai_compatible ? 1 : 0);
         }
     });
     transaction();

package/dist/utils/request-writer.d.ts

@@ -45,7 +45,23 @@ export interface RequestSummary {
     usage?: TokenUsage;
 }
 export declare function extractTokenUsage(events: any[] | undefined): TokenUsage | undefined;
+export declare const EVENT_BATCH_SIZE = 10;
+/**
+ * Flush a batch of SSE events to the response_events table.
+ * Called during streaming every ~10 events to avoid in-memory accumulation.
+ */
+export declare function flushEventBatch(sessionId: string, requestId: string, batch: Array<{
+    index: number;
+    type?: string;
+    data: unknown;
+}>, startIndex: number): void;
+/**
+ * Delete response_events rows for a request (used when cloudRequestId differs from local requestId).
+ */
+export declare function deleteResponseEvents(requestId: string, sessionId: string): void;
 export declare function saveRequestDB(sessionId: string, requestId: string, data: RequestData): Promise<void>;
+export declare function updateRequestTokens(requestId: string, sessionId: string, usage: TokenUsage | undefined): void;
+export declare function deleteRequestRow(requestId: string, sessionId: string): void;
 export declare function loadRequestDB(compositeId: string): Promise<RequestData>;
 export declare function listRequestDB(limit?: number, before?: string): Promise<{
     requests: RequestSummary[];
@@ -53,3 +69,7 @@ export declare function listRequestDB(limit?: number, before?: string): Promise<
 }>;
 export declare function cleanOldRequestsDB(daysToKeep?: number): Promise<void>;
 export declare function sessionIdExists(sessionId: string): boolean;
+export declare function loadSessionHistory(sessionId: string): {
+    messages: any[];
+    system?: any;
+} | null;

package/dist/utils/request-writer.js

@@ -1,14 +1,62 @@
-import { initDatabase } from './db.js';
+import { initDatabase, getDatabase } from './db.js';
+import { parseUpstreamEvents } from './inject-loop.js';
 export function extractTokenUsage(events) {
     if (!events)
         return undefined;
     const messageDelta = events.find((e) => e?.type === 'message_delta');
     return messageDelta?.usage;
 }
+// --- SSE Event Batch Writer (incremental DB writes during streaming) ---
+export const EVENT_BATCH_SIZE = 10;
+// Cached prepared statements for batch writes
+let insertEventStmt = null;
+let deleteRequestStmt = null;
+let cachedDbInstance = null;
+// Invalidate cached stmts when DB instance changes (tests create fresh DB per suite)
+function ensureStmtCacheValid(db) {
+    if (db !== cachedDbInstance) {
+        insertEventStmt = null;
+        deleteRequestStmt = null;
+        cachedDbInstance = db;
+    }
+}
+/**
+ * Flush a batch of SSE events to the response_events table.
+ * Called during streaming every ~10 events to avoid in-memory accumulation.
+ */
+export function flushEventBatch(sessionId, requestId, batch, startIndex) {
+    const db = getDatabase();
+    ensureStmtCacheValid(db);
+    if (!insertEventStmt) {
+        insertEventStmt = db.prepare('INSERT INTO response_events (request_id, session_id, event_index, event_type, event_data) VALUES (?, ?, ?, ?, ?)');
+    }
+    for (let i = 0; i < batch.length; i++) {
+        const event = batch[i];
+        insertEventStmt.run(requestId, sessionId, startIndex + i, event.type ?? null, JSON.stringify(event.data));
+    }
+}
+/**
+ * Delete response_events rows for a request (used when cloudRequestId differs from local requestId).
+ */
+export function deleteResponseEvents(requestId, sessionId) {
+    const db = getDatabase();
+    db.prepare('DELETE FROM response_events WHERE request_id = ? AND session_id = ?').run(requestId, sessionId);
+}
+// --- Request DB Operations ---
 // Save request to SQLite database
 export async function saveRequestDB(sessionId, requestId, data) {
     const db = initDatabase();
-    const usage = extractTokenUsage(data.response?.events);
+    const events = data.response?.events;
+    const usage = events ? extractTokenUsage(events) : undefined;
+    // For JSON responses (non-streaming), events are still in the array — flush them first
+    if (events && events.length > 0) {
+        const batch = events.map((e, i) => ({
+            index: i,
+            type: e?.type ?? undefined,
+            data: e
+        }));
+        flushEventBatch(sessionId, requestId, batch, 0);
+    }
     const stmt = db.prepare(`
     INSERT OR REPLACE INTO requests (
       request_id, session_id, timestamp, method, path, status_code, response_time,
@@ -22,7 +70,22 @@ export async function saveRequestDB(sessionId, requestId, data) {
   `);
     stmt.run(requestId, sessionId, data.timestamp, data.request.method, data.request.path, data.response?.statusCode ?? 0, data.response?.completedAt && data.timestamp
         ? Math.round(new Date(data.response.completedAt).getTime() - new Date(data.timestamp).getTime())
-        : 0, data.apiKey || null, data.proxyApiKey || null, data.baseUrl || null, data.model || null, data.machineId || null, usage?.input_tokens || null, usage?.output_tokens || null, usage?.cache_read_input_tokens || null, usage?.cache_creation_input_tokens || null, JSON.stringify(data.request.headers), data.request.body ? JSON.stringify(data.request.body) : null, data.response?.headers ? JSON.stringify(data.response.headers) : null, data.response?.events ? JSON.stringify(data.response?.events) : null, data.response?.completedAt || null, data.response?.closedAt || null, data.response?.error || null);
+        : 0, data.apiKey || null, data.proxyApiKey || null, data.baseUrl || null, data.model || null, data.machineId || null, usage?.input_tokens || null, usage?.output_tokens || null, usage?.cache_read_input_tokens || null, usage?.cache_creation_input_tokens || null, JSON.stringify(data.request.headers), data.request.body ? JSON.stringify(data.request.body) : null, data.response?.headers ? JSON.stringify(data.response.headers) : null, null, // response_events now stored in separate table
+    data.response?.completedAt || null, data.response?.closedAt || null, data.response?.error || null);
+}
+// Update token columns for a request (streaming: usage extracted from tailBuffer after save)
+export function updateRequestTokens(requestId, sessionId, usage) {
+    const db = getDatabase();
+    db.prepare('UPDATE requests SET input_tokens = ?, output_tokens = ?, cache_read_tokens = ?, cache_creation_tokens = ? WHERE request_id = ? AND session_id = ?').run(usage?.input_tokens || null, usage?.output_tokens || null, usage?.cache_read_input_tokens || null, usage?.cache_creation_input_tokens || null, requestId, sessionId);
+}
+// Delete a request row by requestId + sessionId (for pending → completed replacement)
+export function deleteRequestRow(requestId, sessionId) {
+    const db = getDatabase();
+    ensureStmtCacheValid(db);
+    if (!deleteRequestStmt) {
+        deleteRequestStmt = db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?');
+    }
+    deleteRequestStmt.run(requestId, sessionId);
 }
 // Load single request by compositeId (sessionId:requestId)
 export async function loadRequestDB(compositeId) {
@@ -39,6 +102,35 @@ export async function loadRequestDB(compositeId) {
     if (!row) {
         throw new Error(`Request not found: ${compositeId}`);
     }
+    // Load events from separate table; fallback to old JSON column for historical data
+    const eventRows = db.prepare(`
+    SELECT event_index, event_type, event_data FROM response_events
+    WHERE request_id = ? AND session_id = ?
+    ORDER BY event_index ASC
+  `).all(requestId, sessionId);
+    let events;
+    if (eventRows.length > 0) {
+        events = eventRows.map(r => {
+            try {
+                return JSON.parse(r.event_data);
+            }
+            catch {
+                return { raw: r.event_data };
+            }
+        });
+    }
+    else if (row.response_events) {
+        // Fallback: historical data stored events in the requests.response_events JSON column
+        try {
+            events = JSON.parse(row.response_events);
+        }
+        catch {
+            events = [];
+        }
+    }
+    else {
+        events = [];
+    }
     return {
         requestId: row.request_id,
         sessionId: row.session_id,
@@ -57,7 +149,7 @@ export async function loadRequestDB(compositeId) {
         response: {
             statusCode: row.status_code,
             headers: row.response_headers ? JSON.parse(row.response_headers) : undefined,
-            events: row.response_events ? JSON.parse(row.response_events) : undefined,
+            events: events.length > 0 ? events : undefined,
             completedAt: row.completed_at,
             closedAt: row.closed_at,
             error: row.error
@@ -115,6 +207,8 @@ export async function cleanOldRequestsDB(daysToKeep = 7) {
     }
     const db = initDatabase();
     const cutoff = new Date(Date.now() - daysToKeep * 86400000).toISOString();
+    // Delete response_events first (foreign data), then requests
+    db.prepare(`DELETE FROM response_events WHERE request_id IN (SELECT request_id FROM requests WHERE timestamp < ?)`).run(cutoff);
     db.prepare(`DELETE FROM requests WHERE timestamp < ?`).run(cutoff);
 }
 // Check if a sessionId exists in the database
@@ -125,3 +219,89 @@ export function sessionIdExists(sessionId) {
   `).get(sessionId);
     return !!row;
 }
+// Load session history for multi-turn chat resume
+// Returns the last request's messages + assistant response, to prepend to new messages
+export function loadSessionHistory(sessionId) {
+    const db = initDatabase();
+    // Get the last completed request for this session
+    const row = db.prepare(`
+    SELECT request_id, request_body, response_headers
+    FROM requests
+    WHERE session_id = ? AND completed_at IS NOT NULL AND status_code = 200
+    ORDER BY timestamp DESC
+    LIMIT 1
+  `).get(sessionId);
+    if (!row)
+        return null;
+    let requestBody = null;
+    try {
+        requestBody = row.request_body ? JSON.parse(row.request_body) : null;
+    }
+    catch {
+        return null;
+    }
+    // Load response events from separate table; fallback to old JSON column for historical data
+    const eventRows = db.prepare(`
+    SELECT event_data FROM response_events
+    WHERE request_id = ? AND session_id = ?
+    ORDER BY event_index ASC
+  `).all(row.request_id, sessionId);
+    let responseEvents;
+    if (eventRows.length > 0) {
+        try {
+            responseEvents = eventRows.map(r => JSON.parse(r.event_data));
+        }
+        catch {
+            responseEvents = [];
+        }
+    }
+    else {
+        // Fallback: read from old requests.response_events JSON column
+        const legacyRow = db.prepare('SELECT response_events FROM requests WHERE request_id = ? AND session_id = ?')
+            .get(row.request_id, sessionId);
+        try {
+            responseEvents = legacyRow?.response_events ? JSON.parse(legacyRow.response_events) : [];
+        }
+        catch {
+            responseEvents = [];
+        }
+    }
+    if (!requestBody?.messages)
+        return null;
+    // Rebuild conversation: previous messages from request_body + assistant response from response_events
+    const messages = [...requestBody.messages];
+    // Extract assistant content from response events
+    // For JSON responses, the first event is the full response with .content
+    // For SSE responses, need to parse content blocks
+    const firstEvent = responseEvents[0];
+    if (firstEvent?.type === 'message' && firstEvent?.content) {
+        // JSON (non-streaming) response
+        messages.push({ role: 'assistant', content: firstEvent.content });
+    }
+    else if (responseEvents.length > 1) {
+        // SSE response — rebuild content blocks from events
+        const parsed = parseUpstreamEvents(responseEvents);
+        const assistantContent = [];
+        for (const block of parsed.blocks) {
+            if (block.type === 'text' && block.text) {
+                assistantContent.push({ type: 'text', text: block.text });
+            }
+            else if (block.type === 'tool_use') {
+                assistantContent.push({ type: 'tool_use', id: block.id, name: block.name, input: block.input });
+            }
+        }
+        // Find tool_result blocks in subsequent events
+        for (const event of responseEvents) {
+            if (event?.type === 'tool_result' || (event?.role === 'user' && Array.isArray(event?.content))) {
+                messages.push({ role: 'user', content: event.content });
+            }
+        }
+        if (assistantContent.length > 0) {
+            messages.push({ role: 'assistant', content: assistantContent });
+        }
+    }
+    return {
+        messages,
+        system: requestBody.system || requestBody.system_prompt
+    };
+}

package/dist/utils/sse-stream-processor.d.ts

@@ -0,0 +1,27 @@
+import type { ServerResponse } from 'http';
+import { type ParsedUpstream } from './inject-loop.js';
+/**
+ * SSE 增量流式处理器：边转发原始 chunk 到客户端，边增量解析事件累积状态。
+ * stream end 后提供 getParsedUpstream() 和 hasInjectedToolUse() 供注入检测。
+ *
+ * 跨 chunk 行边界通过 leftover 缓冲处理（参考 SSEAccumulator）。
+ */
+export declare class SSEStreamProcessor {
+    events: any[];
+    private contentBlocks;
+    private stopReason;
+    private usage;
+    private leftover;
+    private raw;
+    constructor(raw: ServerResponse);
+    /** 处理一个 chunk：转发到 reply.raw + 增量解析事件 */
+    processChunk(chunk: Buffer): void;
+    /** 处理 leftover 中残留的最后一行（stream end 后调用） */
+    flushLeftover(): void;
+    /** 增量解析单个事件，更新 contentBlocks / stopReason / usage */
+    private processEvent;
+    /** 从累积状态构建 ParsedUpstream */
+    getParsedUpstream(): ParsedUpstream;
+    /** 检测是否有注入的 MCP tool_use */
+    hasInjectedToolUse(): boolean;
+}