@cc-monitoring/proxy-core 0.1.4 → 0.1.5

package/dist/utils/db.js

@@ -52,6 +52,18 @@ export function initDatabase() {
         applySchemaV5(db);
         db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (5)').run();
     }
+    if (currentVersion < 6) {
+        applySchemaV6(db);
+        db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (6)').run();
+    }
+    if (currentVersion < 7) {
+        applySchemaV7(db);
+        db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (7)').run();
+    }
+    if (currentVersion < 8) {
+        applySchemaV8(db);
+        db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (8)').run();
+    }
     return db;
 }
 export function applySchemaV2(db) {
@@ -197,6 +209,48 @@ export function applySchemaV5(db) {
     // Create index for machine_id
     db.exec(`CREATE INDEX IF NOT EXISTS idx_requests_machine_id ON requests(machine_id)`);
 }
+export function applySchemaV6(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS mcp_servers (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT UNIQUE NOT NULL,
+      transport_type TEXT NOT NULL CHECK(transport_type IN ('stdio', 'sse', 'streamable-http')),
+      command TEXT,
+      args TEXT,
+      env TEXT,
+      url TEXT,
+      headers TEXT,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+      updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_mcp_servers_name ON mcp_servers(name)');
+}
+export function applySchemaV7(db) {
+    // Add is_openai_compatible column for OpenAI format conversion toggle
+    const columns = db.prepare("PRAGMA table_info(providers)").all();
+    if (!columns.some(c => c.name === 'is_openai_compatible')) {
+        db.exec('ALTER TABLE providers ADD COLUMN is_openai_compatible INTEGER NOT NULL DEFAULT 0');
+    }
+}
+export function applySchemaV8(db) {
+    // Separate table for streaming SSE events — eliminates in-memory accumulation
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS response_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      request_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      event_index INTEGER NOT NULL,
+      event_type TEXT,
+      event_data TEXT NOT NULL
+    )
+  `);
+    db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_response_events_request
+    ON response_events(request_id, session_id, event_index)
+  `);
+}
 export function closeDatabase() {
     if (db) {
         db.close();

package/dist/utils/inject-loop.d.ts

@@ -1,3 +1,5 @@
+import type { ServerResponse } from 'http';
+import type { SSEStreamProcessor } from './sse-stream-processor.js';
 /**
  * 内部循环（后端）——命中注入 tool 后，proxy 代行「执行 tool -> 追加对话 -> 再调上游」，
  * 直到模型给出 end_turn 的最终文本，再由调用方合成 SSE 回写给客户端。
@@ -28,7 +30,7 @@ export interface InjectLoopResult {
     stoppedByLimit: boolean;
 }
 /**
- * 内部循环：命中已启用 tool -> 执行 exec -> 追加对话 -> 再调上游 -> 直到 end_turn。
+ * SSE 内部循环：命中已启用 tool -> 执行 exec -> 追加对话 -> 再调上游 -> 直到 end_turn。
  * opts.body 会被原地追加 messages。
  *
  * @param opts.events 首次上游响应事件（已确认命中注入 tool）
@@ -41,3 +43,52 @@ export declare function runInjectLoop(opts: {
     callUpstream: (body: any) => Promise<any[]>;
     maxIterations?: number;
 }): Promise<InjectLoopResult>;
+/**
+ * SSE 流式注入循环：命中已启用 tool → 执行 exec → 追加对话 → 再调上游 → 新 SSE 流式转发到同一 reply.raw。
+ * 每次迭代作为独立 DB 记录。客户端实时看到续接 SSE。
+ *
+ * 与 runInjectLoop 的区别：
+ * - 不缓冲上游响应，直接流式转发
+ * - 不返回合成 text，客户端已实时收到原始 SSE
+ * - 每次迭代用 SSEStreamProcessor 边转发边解析
+ */
+export interface StreamingInjectLoopResult {
+    iterations: number;
+    stoppedByLimit: boolean;
+}
+export declare function runStreamingInjectLoop(opts: {
+    initialParsed: ParsedUpstream;
+    body: any;
+    callUpstream: (body: any) => Promise<{
+        response: Response;
+        requestId: string;
+    }>;
+    streamAndParse: (response: Response) => Promise<{
+        processor: SSEStreamProcessor;
+        statusCode: number;
+    }>;
+    sessionId: string;
+    saveIterationDB: (requestId: string, processor: SSEStreamProcessor, statusCode: number, requestBody: any) => Promise<void>;
+    raw: ServerResponse;
+    maxIterations?: number;
+}): Promise<StreamingInjectLoopResult>;
+export interface JsonInjectLoopResult {
+    finalBody: any;
+    iterations: number;
+    stoppedByLimit: boolean;
+}
+/**
+ * JSON 内部循环：非流式请求中命中 MCP tool -> 执行 exec -> 追加对话 -> 再调上游 -> 直到 end_turn。
+ * 与 SSE 版 runInjectLoop 对称，但处理 parsed JSON response body 而非 SSE event 数组。
+ *
+ * @param opts.initialBody 首次上游 JSON 响应（已确认命中 MCP tool）
+ * @param opts.requestBody 请求体（messages 会被原地追加）
+ * @param opts.callUpstream 用给定 body 再次调上游，返回 parsed JSON body
+ * @param opts.maxIterations 死循环护栏
+ */
+export declare function runJsonInjectLoop(opts: {
+    initialBody: any;
+    requestBody: any;
+    callUpstream: (body: any) => Promise<any>;
+    maxIterations?: number;
+}): Promise<JsonInjectLoopResult>;

package/dist/utils/inject-loop.js

@@ -89,7 +89,7 @@ function collectText(parsed) {
         .join('');
 }
 /**
- * 内部循环：命中已启用 tool -> 执行 exec -> 追加对话 -> 再调上游 -> 直到 end_turn。
+ * SSE 内部循环：命中已启用 tool -> 执行 exec -> 追加对话 -> 再调上游 -> 直到 end_turn。
  * opts.body 会被原地追加 messages。
  *
  * @param opts.events 首次上游响应事件（已确认命中注入 tool）
@@ -105,7 +105,7 @@ export async function runInjectLoop(opts) {
         if (!call || parsed.stopReason !== 'tool_use') {
             return { text: collectText(parsed), iterations, stoppedByLimit: false };
         }
-        const tool = findEnabledTool(call.name); // findInjectedCall 已保证存在
+        const tool = findEnabledTool(call.name);
         const result = await tool.exec(call.input);
         opts.body.messages.push({ role: 'assistant', content: blocksToAssistantContent(parsed.blocks) });
         opts.body.messages.push({
@@ -118,3 +118,71 @@ export async function runInjectLoop(opts) {
     }
     return { text: collectText(parsed) || '(内部循环达到最大轮次)', iterations, stoppedByLimit: true };
 }
+export async function runStreamingInjectLoop(opts) {
+    const maxIterations = opts.maxIterations ?? 3;
+    let parsed = opts.initialParsed;
+    let iterations = 0;
+    while (iterations < maxIterations) {
+        if (opts.raw.destroyed)
+            break;
+        const call = findInjectedCall(parsed);
+        if (!call || parsed.stopReason !== 'tool_use') {
+            return { iterations, stoppedByLimit: false };
+        }
+        // 执行注入的 tool
+        const tool = findEnabledTool(call.name);
+        const result = await tool.exec(call.input);
+        // 追加 assistant + tool_result 消息
+        opts.body.messages.push({ role: 'assistant', content: blocksToAssistantContent(parsed.blocks) });
+        opts.body.messages.push({
+            role: 'user',
+            content: [{ type: 'tool_result', tool_use_id: call.id, content: result }]
+        });
+        // 调上游，获取流式响应
+        const { response, requestId } = await opts.callUpstream(opts.body);
+        // 流式转发到客户端 + 增量解析
+        const { processor, statusCode } = await opts.streamAndParse(response);
+        // 保存这次迭代到 DB
+        await opts.saveIterationDB(requestId, processor, statusCode, opts.body);
+        parsed = processor.getParsedUpstream();
+        processor.flushLeftover();
+        iterations++;
+    }
+    const stoppedByLimit = iterations >= (opts.maxIterations ?? 3) &&
+        parsed.stopReason === 'tool_use' &&
+        !!findInjectedCall(parsed);
+    return { iterations, stoppedByLimit };
+}
+/**
+ * JSON 内部循环：非流式请求中命中 MCP tool -> 执行 exec -> 追加对话 -> 再调上游 -> 直到 end_turn。
+ * 与 SSE 版 runInjectLoop 对称，但处理 parsed JSON response body 而非 SSE event 数组。
+ *
+ * @param opts.initialBody 首次上游 JSON 响应（已确认命中 MCP tool）
+ * @param opts.requestBody 请求体（messages 会被原地追加）
+ * @param opts.callUpstream 用给定 body 再次调上游，返回 parsed JSON body
+ * @param opts.maxIterations 死循环护栏
+ */
+export async function runJsonInjectLoop(opts) {
+    const maxIterations = opts.maxIterations ?? 3;
+    let lastResponse = opts.initialBody;
+    let iterations = 0;
+    while (iterations < maxIterations) {
+        const toolCalls = (lastResponse.content || []).filter((b) => b.type === 'tool_use');
+        const hitCall = toolCalls.find((b) => findEnabledTool(b.name));
+        if (!hitCall || lastResponse.stop_reason !== 'tool_use')
+            break;
+        const tool = findEnabledTool(hitCall.name);
+        const result = await tool.exec(hitCall.input);
+        opts.requestBody.messages.push({ role: 'assistant', content: lastResponse.content });
+        opts.requestBody.messages.push({
+            role: 'user',
+            content: [{ type: 'tool_result', tool_use_id: hitCall.id, content: result }]
+        });
+        lastResponse = await opts.callUpstream(opts.requestBody);
+        iterations++;
+    }
+    const stoppedByLimit = iterations >= maxIterations &&
+        lastResponse.stop_reason === 'tool_use' &&
+        (lastResponse.content || []).some((b) => b.type === 'tool_use' && findEnabledTool(b.name));
+    return { finalBody: lastResponse, iterations, stoppedByLimit };
+}

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

@@ -0,0 +1,35 @@
+import Database from 'better-sqlite3';
+export type TransportType = 'stdio' | 'sse' | 'streamable-http';
+export interface McpServer {
+    id: number;
+    name: string;
+    transport_type: TransportType;
+    command: string | null;
+    args: string | null;
+    env: string | null;
+    url: string | null;
+    headers: string | null;
+    enabled: boolean;
+    created_at: string;
+    updated_at: string;
+}
+export interface McpServerInput {
+    name: string;
+    transport_type: TransportType;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    enabled?: boolean;
+}
+export interface McpServerError {
+    field: string;
+    message: string;
+}
+export declare function listMcpServers(db: Database.Database): McpServer[];
+export declare function getMcpServer(db: Database.Database, id: number): McpServer | undefined;
+export declare function createMcpServer(db: Database.Database, input: McpServerInput): McpServer;
+export declare function updateMcpServer(db: Database.Database, id: number, input: Partial<McpServerInput>): McpServer | undefined;
+export declare function deleteMcpServer(db: Database.Database, id: number): boolean;
+export declare function validateMcpServerInput(input: McpServerInput): McpServerError[];

package/dist/utils/mcp-db.js

@@ -0,0 +1,79 @@
+export function listMcpServers(db) {
+    const rows = db.prepare('SELECT * FROM mcp_servers ORDER BY created_at DESC')
+        .all();
+    return rows.map(r => ({ ...r, enabled: !!r.enabled }));
+}
+export function getMcpServer(db, id) {
+    const row = db.prepare('SELECT * FROM mcp_servers WHERE id = ?').get(id);
+    return row ? { ...row, enabled: !!row.enabled } : undefined;
+}
+export function createMcpServer(db, input) {
+    const errors = validateMcpServerInput(input);
+    if (errors.length)
+        throw new Error(errors.map(e => `${e.field}: ${e.message}`).join('; '));
+    const insert = db.prepare(`
+    INSERT INTO mcp_servers (name, transport_type, command, args, env, url, headers, enabled)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    insert.run(input.name, input.transport_type, input.command || null, input.args ? JSON.stringify(input.args) : null, input.env ? JSON.stringify(input.env) : null, input.url || null, input.headers ? JSON.stringify(input.headers) : null, input.enabled !== false ? 1 : 0);
+    const row = db.prepare('SELECT * FROM mcp_servers WHERE name = ?').get(input.name);
+    return { ...row, enabled: !!row.enabled };
+}
+export function updateMcpServer(db, id, input) {
+    const existing = getMcpServer(db, id);
+    if (!existing)
+        return undefined;
+    const merged = {
+        name: input.name ?? existing.name,
+        transport_type: input.transport_type ?? existing.transport_type,
+        command: input.command ?? existing.command ?? undefined,
+        args: input.args ?? (existing.args ? JSON.parse(existing.args) : undefined),
+        env: input.env ?? (existing.env ? JSON.parse(existing.env) : undefined),
+        url: input.url ?? existing.url ?? undefined,
+        headers: input.headers ?? (existing.headers ? JSON.parse(existing.headers) : undefined),
+        enabled: input.enabled ?? existing.enabled
+    };
+    const errors = validateMcpServerInput(merged);
+    if (errors.length)
+        throw new Error(errors.map(e => `${e.field}: ${e.message}`).join('; '));
+    db.prepare(`
+    UPDATE mcp_servers SET name=?, transport_type=?, command=?, args=?, env=?, url=?, headers=?, enabled=?, updated_at=CURRENT_TIMESTAMP
+    WHERE id=?
+  `).run(merged.name, merged.transport_type, merged.command || null, merged.args ? JSON.stringify(merged.args) : null, merged.env ? JSON.stringify(merged.env) : null, merged.url || null, merged.headers ? JSON.stringify(merged.headers) : null, merged.enabled !== false ? 1 : 0, id);
+    return getMcpServer(db, id);
+}
+export function deleteMcpServer(db, id) {
+    const result = db.prepare('DELETE FROM mcp_servers WHERE id = ?').run(id);
+    return result.changes > 0;
+}
+export function validateMcpServerInput(input) {
+    const errors = [];
+    if (!input.name || input.name.trim() === '') {
+        errors.push({ field: 'name', message: 'name is required' });
+    }
+    const validTypes = ['stdio', 'sse', 'streamable-http'];
+    if (!validTypes.includes(input.transport_type)) {
+        errors.push({ field: 'transport_type', message: `must be one of: ${validTypes.join(',')}` });
+    }
+    // Transport-specific validation
+    if (input.transport_type === 'stdio') {
+        if (!input.command || input.command.trim() === '') {
+            errors.push({ field: 'command', message: 'command is required for stdio transport' });
+        }
+    }
+    else {
+        // HTTP-based transport (sse / streamable-http)
+        if (!input.url || input.url.trim() === '') {
+            errors.push({ field: 'url', message: 'url is required for HTTP transport' });
+        }
+        if (input.url) {
+            try {
+                new URL(input.url);
+            }
+            catch {
+                errors.push({ field: 'url', message: 'url must be a valid URL' });
+            }
+        }
+    }
+    return errors;
+}

package/dist/utils/mcp-manager.d.ts

@@ -0,0 +1,36 @@
+import type { McpServer } from './mcp-db.js';
+import type { InjectableTool } from '../tools/types.js';
+declare class McpManager {
+    private connections;
+    /** Init: seed config.json mcpServers into DB, then connect all enabled servers */
+    init(): Promise<void>;
+    /** Connect to one MCP server */
+    private connectServer;
+    /** Create transport based on server config */
+    private createTransport;
+    /** Periodic health check via ping */
+    private startHealthCheck;
+    private clearHealthCheck;
+    /** Reconnect with exponential backoff */
+    private scheduleReconnect;
+    private clearReconnect;
+    /** Get all tools from connected servers */
+    getMcpTools(): InjectableTool[];
+    /** Get all connections with status info (for API) */
+    getConnectionsInfo(): Array<{
+        serverId: number;
+        serverName: string;
+        status: string;
+        toolCount: number;
+    }>;
+    /** Add a new server (after REST API create) */
+    addServer(server: McpServer): Promise<void>;
+    /** Remove a server (before REST API delete) */
+    removeServer(serverId: number): Promise<void>;
+    /** Reconnect a server (after config update) */
+    reconnectServer(serverId: number): Promise<void>;
+    /** Close all connections */
+    close(): Promise<void>;
+}
+export declare const mcpManager: McpManager;
+export {};

package/dist/utils/mcp-manager.js

@@ -0,0 +1,215 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { listMcpServers } from './mcp-db.js';
+import { mcpToolToInjectable } from '../tools/mcp-bridge.js';
+import { getDatabase } from './db.js';
+import { loadConfig } from '../config/index.js';
+import { createMcpServer } from './mcp-db.js';
+class McpManager {
+    constructor() {
+        Object.defineProperty(this, "connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /** Init: seed config.json mcpServers into DB, then connect all enabled servers */
+    async init() {
+        const db = getDatabase();
+        // Seed config.json mcpServers into DB (skip duplicates by name)
+        try {
+            const config = await loadConfig();
+            const cfgServers = config.mcpServers ?? [];
+            if (cfgServers.length > 0) {
+                const existing = listMcpServers(db);
+                for (const s of cfgServers) {
+                    if (!existing.some(e => e.name === s.name)) {
+                        createMcpServer(db, s);
+                    }
+                }
+            }
+        }
+        catch {
+            // Config seeding is optional; ignore errors
+        }
+        // Connect to all enabled servers
+        const servers = listMcpServers(db).filter(s => s.enabled);
+        for (const server of servers) {
+            await this.connectServer(server);
+        }
+    }
+    /** Connect to one MCP server */
+    async connectServer(server) {
+        // Disconnect existing connection if present
+        const existing = this.connections.get(server.id);
+        if (existing) {
+            this.clearHealthCheck(existing);
+            this.clearReconnect(existing);
+            try {
+                await existing.client.close();
+            }
+            catch { /* ignore */ }
+        }
+        const transport = this.createTransport(server);
+        const client = new Client({ name: 'cc-monitoring-proxy', version: '0.1.4' });
+        const conn = {
+            client,
+            transport,
+            serverId: server.id,
+            serverName: server.name,
+            status: 'connecting',
+            tools: [],
+            reconnectAttempts: 0,
+            serverConfig: server
+        };
+        this.connections.set(server.id, conn);
+        try {
+            await client.connect(transport);
+            conn.status = 'connected';
+            // Discover tools
+            const { tools } = await client.listTools();
+            conn.tools = tools.map(t => mcpToolToInjectable(t, server.name, client));
+            this.startHealthCheck(conn);
+        }
+        catch (err) {
+            conn.status = 'disconnected';
+            conn.tools = [];
+            console.error(`[MCP] connect failed: ${server.name} (${server.transport_type}) — ${err instanceof Error ? err.message : String(err)}`);
+            this.scheduleReconnect(conn, server);
+        }
+    }
+    /** Create transport based on server config */
+    createTransport(server) {
+        if (server.transport_type === 'stdio') {
+            const env = server.env
+                ? { ...process.env, ...JSON.parse(server.env) }
+                : process.env;
+            // Split command string: "npx -y foo" → command="npx", args=["-y","foo"]
+            // StdioClientTransport uses spawn(command, args), command must be a single binary.
+            const parts = server.command.trim().split(/\s+/);
+            const cmd = parts[0];
+            const cmdArgs = parts.slice(1);
+            const storedArgs = server.args ? JSON.parse(server.args) : [];
+            const mergedArgs = [...cmdArgs, ...storedArgs];
+            return new StdioClientTransport({
+                command: cmd,
+                args: mergedArgs.length > 0 ? mergedArgs : undefined,
+                env
+            });
+        }
+        if (server.transport_type === 'streamable-http') {
+            const opts = {
+                url: new URL(server.url)
+            };
+            if (server.headers) {
+                opts.requestInit = { headers: JSON.parse(server.headers) };
+            }
+            return new StreamableHTTPClientTransport(opts.url, opts.requestInit ? { requestInit: opts.requestInit } : undefined);
+        }
+        if (server.transport_type === 'sse') {
+            return new SSEClientTransport(new URL(server.url));
+        }
+        throw new Error(`Unknown transport type: ${server.transport_type}`);
+    }
+    /** Periodic health check via ping */
+    startHealthCheck(conn) {
+        conn.healthTimer = setInterval(async () => {
+            try {
+                await conn.client.ping();
+            }
+            catch {
+                conn.status = 'disconnected';
+                conn.tools = [];
+                this.clearHealthCheck(conn);
+                this.scheduleReconnect(conn, conn.serverConfig);
+            }
+        }, 30000);
+    }
+    clearHealthCheck(conn) {
+        if (conn.healthTimer) {
+            clearInterval(conn.healthTimer);
+            conn.healthTimer = undefined;
+        }
+    }
+    /** Reconnect with exponential backoff */
+    scheduleReconnect(conn, server) {
+        const delay = Math.min(2 ** conn.reconnectAttempts * 1000, 30000);
+        conn.reconnectAttempts++;
+        conn.reconnectTimer = setTimeout(async () => {
+            try {
+                await this.connectServer(server);
+            }
+            catch {
+                // Will schedule another reconnect in connectServer
+            }
+        }, delay);
+    }
+    clearReconnect(conn) {
+        if (conn.reconnectTimer) {
+            clearTimeout(conn.reconnectTimer);
+            conn.reconnectTimer = undefined;
+        }
+    }
+    /** Get all tools from connected servers */
+    getMcpTools() {
+        return Array.from(this.connections.values())
+            .filter(c => c.status === 'connected')
+            .flatMap(c => c.tools);
+    }
+    /** Get all connections with status info (for API) */
+    getConnectionsInfo() {
+        return Array.from(this.connections.values()).map(c => ({
+            serverId: c.serverId,
+            serverName: c.serverName,
+            status: c.status,
+            toolCount: c.tools.length
+        }));
+    }
+    /** Add a new server (after REST API create) */
+    async addServer(server) {
+        if (server.enabled) {
+            await this.connectServer(server);
+        }
+    }
+    /** Remove a server (before REST API delete) */
+    async removeServer(serverId) {
+        const conn = this.connections.get(serverId);
+        if (conn) {
+            this.clearHealthCheck(conn);
+            this.clearReconnect(conn);
+            try {
+                await conn.client.close();
+            }
+            catch { /* ignore */ }
+            this.connections.delete(serverId);
+        }
+    }
+    /** Reconnect a server (after config update) */
+    async reconnectServer(serverId) {
+        const db = getDatabase();
+        const server = listMcpServers(db).find(s => s.id === serverId);
+        if (server && server.enabled) {
+            await this.connectServer(server);
+        }
+        else {
+            // Server disabled — disconnect
+            await this.removeServer(serverId);
+        }
+    }
+    /** Close all connections */
+    async close() {
+        for (const conn of this.connections.values()) {
+            this.clearHealthCheck(conn);
+            this.clearReconnect(conn);
+            try {
+                await conn.client.close();
+            }
+            catch { /* ignore */ }
+        }
+        this.connections.clear();
+    }
+}
+export const mcpManager = new McpManager();

package/dist/utils/openai-converter.d.ts

@@ -0,0 +1,99 @@
+import { Transform } from 'stream';
+interface ClaudeTool {
+    name: string;
+    description?: string;
+    input_schema: any;
+}
+type ClaudeContent = string | Array<{
+    type: 'text' | 'image' | 'tool_use' | 'tool_result';
+    text?: string;
+    source?: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+    id?: string;
+    name?: string;
+    input?: any;
+    tool_use_id?: string;
+    content?: any;
+}>;
+interface ClaudeMessage {
+    role: 'user' | 'assistant';
+    content: ClaudeContent;
+}
+interface ClaudeMessagesRequest {
+    model: string;
+    messages: ClaudeMessage[];
+    system?: string | Array<{
+        type: 'text';
+        text: string;
+    }>;
+    max_tokens: number;
+    stop_sequences?: string[];
+    stream?: boolean;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    tools?: ClaudeTool[];
+    tool_choice?: {
+        type: 'auto' | 'any' | 'tool';
+        name?: string;
+    };
+}
+interface OpenAIMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | Array<{
+        type: 'text' | 'image_url';
+        text?: string;
+        image_url?: {
+            url: string;
+        };
+    }>;
+    tool_calls?: OpenAIToolCall[];
+    tool_call_id?: string;
+}
+interface OpenAIToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface OpenAIRequest {
+    model: string;
+    messages: OpenAIMessage[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stop?: string[];
+    stream?: boolean;
+    tools?: Array<{
+        type: 'function';
+        function: any;
+    }>;
+    tool_choice?: 'auto' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+}
+/**
+ * Converts a Claude API request body to OpenAI format.
+ */
+export declare function convertClaudeToOpenAIRequest(claudeRequest: ClaudeMessagesRequest, modelName: string): OpenAIRequest;
+/**
+ * Converts a non-streaming OpenAI response to Claude format.
+ */
+export declare function convertOpenAIToClaudeResponse(openaiResponse: any, model: string): any;
+/**
+ * Builds headers for OpenAI-compatible API requests.
+ */
+export declare function buildOpenAIHeaders(apiKey: string): Record<string, string>;
+/**
+ * Creates a Node.js Transform stream that converts OpenAI SSE chunks to Claude SSE events.
+ */
+export declare function createStreamTransformer(model: string): Transform;
+export {};