smartcontext-proxy 0.1.0

package/dist/src/storage/lancedb.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanceDBAdapter = void 0;
+const lancedb_1 = require("@lancedb/lancedb");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+class LanceDBAdapter {
+    basePath;
+    name = 'lancedb';
+    db;
+    chunksTable;
+    logsDir;
+    dbPath;
+    constructor(basePath = node_path_1.default.join(process.env['HOME'] || '.', '.smartcontext', 'data')) {
+        this.basePath = basePath;
+        this.dbPath = node_path_1.default.join(basePath, 'vectors');
+        this.logsDir = node_path_1.default.join(basePath, 'logs');
+    }
+    async initialize() {
+        node_fs_1.default.mkdirSync(this.dbPath, { recursive: true });
+        node_fs_1.default.mkdirSync(this.logsDir, { recursive: true });
+        this.db = await (0, lancedb_1.connect)(this.dbPath);
+        // Create or open chunks table
+        const tableNames = await this.db.tableNames();
+        if (tableNames.includes('chunks')) {
+            this.chunksTable = await this.db.openTable('chunks');
+        }
+        // Table will be created lazily on first upsert with actual data
+    }
+    async upsertChunks(chunks) {
+        if (chunks.length === 0)
+            return;
+        const records = chunks.map((c) => ({
+            id: c.id,
+            text: c.text,
+            vector: c.embedding,
+            sessionId: c.sessionId,
+            timestamp: c.timestamp,
+            summary: c.metadata.summary,
+            tokenCount: c.metadata.tokenCount,
+            exchangeIndex: c.metadata.exchangeIndex,
+            files: JSON.stringify(c.metadata.files || []),
+            tools: JSON.stringify(c.metadata.tools || []),
+        }));
+        const tableNames = await this.db.tableNames();
+        if (!tableNames.includes('chunks')) {
+            this.chunksTable = await this.db.createTable('chunks', records);
+        }
+        else {
+            if (!this.chunksTable) {
+                this.chunksTable = await this.db.openTable('chunks');
+            }
+            await this.chunksTable.add(records);
+        }
+    }
+    async search(embedding, options) {
+        const tableNames = await this.db.tableNames();
+        if (!tableNames.includes('chunks'))
+            return [];
+        if (!this.chunksTable) {
+            this.chunksTable = await this.db.openTable('chunks');
+        }
+        const results = await this.chunksTable
+            .vectorSearch(embedding)
+            .limit(options.topK * 2) // Fetch extra for filtering
+            .toArray();
+        const scored = results.map((r) => {
+            // LanceDB returns _distance (L2), convert to similarity score
+            const distance = r['_distance'];
+            let score = 1 / (1 + distance); // Convert L2 distance to similarity
+            const boosts = {};
+            // Session recency boost
+            if (options.sessionBoost && r.sessionId === options.sessionBoost.sessionId) {
+                boosts.session = options.sessionBoost.boost;
+                score += options.sessionBoost.boost;
+            }
+            // File-path boost
+            if (options.fileBoost && options.fileBoost.patterns.length > 0) {
+                const files = JSON.parse(r.files || '[]');
+                const hasMatch = options.fileBoost.patterns.some((p) => files.some((f) => f.includes(p)));
+                if (hasMatch) {
+                    boosts.filepath = options.fileBoost.boost;
+                    score += options.fileBoost.boost;
+                }
+            }
+            return {
+                id: r.id,
+                text: r.text,
+                embedding: [], // Don't return embedding in search results
+                sessionId: r.sessionId,
+                timestamp: r.timestamp,
+                metadata: {
+                    summary: r.summary,
+                    tokenCount: r.tokenCount,
+                    exchangeIndex: r.exchangeIndex,
+                    files: JSON.parse(r.files || '[]'),
+                    tools: JSON.parse(r.tools || '[]'),
+                },
+                score,
+                boosts,
+            };
+        });
+        // Filter by min score and limit
+        return scored
+            .filter((c) => c.score >= options.minScore)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, options.topK);
+    }
+    async appendLog(sessionId, exchange) {
+        const logFile = node_path_1.default.join(this.logsDir, `${sessionId}.jsonl`);
+        const line = JSON.stringify(exchange) + '\n';
+        node_fs_1.default.appendFileSync(logFile, line);
+    }
+    async getSessionLog(sessionId) {
+        const logFile = node_path_1.default.join(this.logsDir, `${sessionId}.jsonl`);
+        if (!node_fs_1.default.existsSync(logFile))
+            return [];
+        return node_fs_1.default.readFileSync(logFile, 'utf-8')
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    async getStats() {
+        let chunks = 0;
+        const tableNames = await this.db.tableNames();
+        if (tableNames.includes('chunks')) {
+            if (!this.chunksTable) {
+                this.chunksTable = await this.db.openTable('chunks');
+            }
+            chunks = await this.chunksTable.countRows();
+        }
+        const sessions = node_fs_1.default.readdirSync(this.logsDir).filter((f) => f.endsWith('.jsonl')).length;
+        // Rough disk usage
+        let diskBytes = 0;
+        const walk = (dir) => {
+            if (!node_fs_1.default.existsSync(dir))
+                return;
+            for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+                const full = node_path_1.default.join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(full);
+                else
+                    diskBytes += node_fs_1.default.statSync(full).size;
+            }
+        };
+        walk(this.basePath);
+        return { chunks, sessions, diskBytes };
+    }
+    async close() {
+        // LanceDB doesn't require explicit close
+    }
+}
+exports.LanceDBAdapter = LanceDBAdapter;
+//# sourceMappingURL=lancedb.js.map

package/dist/src/storage/types.d.ts

@@ -0,0 +1,52 @@
+export interface Chunk {
+    id: string;
+    text: string;
+    embedding: number[];
+    sessionId: string;
+    timestamp: number;
+    metadata: ChunkMetadata;
+}
+export interface ChunkMetadata {
+    files?: string[];
+    tools?: string[];
+    summary: string;
+    tokenCount: number;
+    exchangeIndex: number;
+}
+export interface ScoredChunk extends Chunk {
+    score: number;
+    boosts?: Record<string, number>;
+}
+export interface SearchOptions {
+    topK: number;
+    minScore: number;
+    sessionBoost?: {
+        sessionId: string;
+        boost: number;
+    };
+    fileBoost?: {
+        patterns: string[];
+        boost: number;
+    };
+}
+export interface Exchange {
+    index: number;
+    userMessage: string;
+    assistantMessage: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+export interface StorageAdapter {
+    name: string;
+    initialize(): Promise<void>;
+    upsertChunks(chunks: Chunk[]): Promise<void>;
+    search(embedding: number[], options: SearchOptions): Promise<ScoredChunk[]>;
+    appendLog(sessionId: string, exchange: Exchange): Promise<void>;
+    getSessionLog(sessionId: string): Promise<Exchange[]>;
+    getStats(): Promise<{
+        chunks: number;
+        sessions: number;
+        diskBytes: number;
+    }>;
+    close(): Promise<void>;
+}

package/dist/src/storage/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/test/context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/test/context.test.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const chunker_js_1 = require("../context/chunker.js");
+const budget_js_1 = require("../context/budget.js");
+(0, node_test_1.describe)('Chunker', () => {
+    (0, node_test_1.it)('estimates tokens roughly correctly', () => {
+        const text = 'Hello world, this is a test message.';
+        const tokens = (0, chunker_js_1.estimateTokens)(text);
+        node_assert_1.default.ok(tokens > 5 && tokens < 20, `Expected 5-20 tokens, got ${tokens}`);
+    });
+    (0, node_test_1.it)('chunks a simple conversation into exchange pairs', () => {
+        const messages = [
+            { role: 'user', content: 'What is TypeScript?' },
+            { role: 'assistant', content: 'TypeScript is a superset of JavaScript that adds static types.' },
+            { role: 'user', content: 'How do I install it?' },
+            { role: 'assistant', content: 'Run npm install -g typescript' },
+        ];
+        const chunks = (0, chunker_js_1.chunkConversation)(messages, 'test-session');
+        node_assert_1.default.strictEqual(chunks.length, 2);
+        node_assert_1.default.ok(chunks[0].text.includes('What is TypeScript'));
+        node_assert_1.default.ok(chunks[0].text.includes('superset of JavaScript'));
+        node_assert_1.default.ok(chunks[1].text.includes('How do I install'));
+    });
+    (0, node_test_1.it)('splits long exchanges at paragraph boundaries', () => {
+        const longResponse = Array(100).fill('This is a paragraph with some detailed content about various programming concepts, design patterns, and software architecture principles that spans multiple lines.\n\n').join('');
+        const messages = [
+            { role: 'user', content: 'Tell me everything about programming.' },
+            { role: 'assistant', content: longResponse },
+        ];
+        const chunks = (0, chunker_js_1.chunkConversation)(messages, 'test-session');
+        node_assert_1.default.ok(chunks.length > 1, `Expected >1 chunks for long response, got ${chunks.length}`);
+        for (const chunk of chunks) {
+            node_assert_1.default.ok(chunk.metadata.tokenCount <= 2500, `Chunk too large: ${chunk.metadata.tokenCount} tokens`);
+        }
+    });
+    (0, node_test_1.it)('keeps code blocks atomic', () => {
+        const response = 'Here is the code:\n\n```typescript\nfunction hello() {\n  console.log("hello");\n  console.log("world");\n}\n```\n\nThat is the function.';
+        const messages = [
+            { role: 'user', content: 'Show me code' },
+            { role: 'assistant', content: response },
+        ];
+        const chunks = (0, chunker_js_1.chunkConversation)(messages, 'test-session');
+        // Code block should be in one chunk
+        const codeChunk = chunks.find((c) => c.text.includes('```typescript'));
+        node_assert_1.default.ok(codeChunk, 'Should have a chunk with the code block');
+        node_assert_1.default.ok(codeChunk.text.includes('console.log("world")'), 'Code block should be complete');
+    });
+    (0, node_test_1.it)('extracts file paths from text', () => {
+        const messages = [
+            { role: 'user', content: 'Fix the bug in `src/proxy/server.ts`' },
+            { role: 'assistant', content: 'I found the issue in /Users/vt/projects/test/index.ts' },
+        ];
+        const chunks = (0, chunker_js_1.chunkConversation)(messages, 'test-session');
+        node_assert_1.default.ok(chunks[0].metadata.files.length > 0, 'Should extract file paths');
+    });
+    (0, node_test_1.it)('assigns unique IDs to chunks', () => {
+        const messages = [
+            { role: 'user', content: 'Hello' },
+            { role: 'assistant', content: 'Hi' },
+            { role: 'user', content: 'Bye' },
+            { role: 'assistant', content: 'Goodbye' },
+        ];
+        const chunks = (0, chunker_js_1.chunkConversation)(messages, 'test-session');
+        const ids = new Set(chunks.map((c) => c.id));
+        node_assert_1.default.strictEqual(ids.size, chunks.length, 'All chunk IDs should be unique');
+    });
+});
+(0, node_test_1.describe)('Budget', () => {
+    (0, node_test_1.it)('knows context limits for common models', () => {
+        node_assert_1.default.strictEqual((0, budget_js_1.getModelContextLimit)('claude-opus-4-6'), 200000);
+        node_assert_1.default.strictEqual((0, budget_js_1.getModelContextLimit)('gpt-4o'), 128000);
+        node_assert_1.default.strictEqual((0, budget_js_1.getModelContextLimit)('unknown-model'), 128000);
+    });
+    (0, node_test_1.it)('packs context within budget', () => {
+        const messages = Array(20).fill(null).map((_, i) => ({
+            role: i % 2 === 0 ? 'user' : 'assistant',
+            content: `Message ${i}: `.padEnd(200, 'x'),
+        }));
+        const mockChunks = [
+            {
+                id: '1', text: 'chunk 1 text', embedding: [], sessionId: 's1',
+                timestamp: Date.now(), score: 0.9, metadata: {
+                    summary: 'chunk 1', tokenCount: 100, exchangeIndex: 0,
+                },
+            },
+            {
+                id: '2', text: 'chunk 2 text', embedding: [], sessionId: 's1',
+                timestamp: Date.now(), score: 0.8, metadata: {
+                    summary: 'chunk 2', tokenCount: 150, exchangeIndex: 1,
+                },
+            },
+        ];
+        const packed = (0, budget_js_1.packContext)('You are a helpful assistant.', messages, mockChunks, 'claude-opus-4-6', 3, // tier1_exchanges
+        500, // tier3_reserve
+        8192);
+        node_assert_1.default.ok(packed.tier1Messages.length > 0, 'Should have tier 1 messages');
+        node_assert_1.default.ok(packed.tier2Chunks.length > 0, 'Should have tier 2 chunks');
+        node_assert_1.default.ok(packed.optimizedTokens < packed.originalTokens, 'Should save tokens');
+        node_assert_1.default.ok(packed.savingsPercent > 0, 'Should have positive savings');
+    });
+    (0, node_test_1.it)('handles empty retrieval', () => {
+        const messages = [
+            { role: 'user', content: 'Hello' },
+            { role: 'assistant', content: 'Hi there' },
+        ];
+        const packed = (0, budget_js_1.packContext)('System prompt', messages, [], 'gpt-4o', 3, 500, 8192);
+        node_assert_1.default.strictEqual(packed.tier2Chunks.length, 0);
+        node_assert_1.default.strictEqual(packed.savingsPercent, 0);
+    });
+});
+(0, node_test_1.describe)('Metrics', () => {
+    (0, node_test_1.it)('records and aggregates correctly', async () => {
+        const { MetricsCollector } = await import('../metrics/collector.js');
+        const metrics = new MetricsCollector();
+        metrics.record({
+            id: 1, timestamp: Date.now(), provider: 'anthropic', model: 'claude-opus-4-6',
+            streaming: false, originalTokens: 1000, optimizedTokens: 300,
+            savingsPercent: 70, latencyOverheadMs: 12, chunksRetrieved: 5,
+            topScore: 0.89, passThrough: false,
+        });
+        metrics.record({
+            id: 2, timestamp: Date.now(), provider: 'openai', model: 'gpt-4o',
+            streaming: true, originalTokens: 500, optimizedTokens: 200,
+            savingsPercent: 60, latencyOverheadMs: 8, chunksRetrieved: 3,
+            topScore: 0.82, passThrough: false,
+        });
+        const stats = metrics.getStats();
+        node_assert_1.default.strictEqual(stats.totalRequests, 2);
+        node_assert_1.default.strictEqual(stats.totalOriginalTokens, 1500);
+        node_assert_1.default.strictEqual(stats.totalOptimizedTokens, 500);
+        node_assert_1.default.ok(stats.totalSavingsPercent > 50);
+        node_assert_1.default.ok(stats.byProvider['anthropic']);
+        node_assert_1.default.ok(stats.byModel['gpt-4o']);
+    });
+});
+//# sourceMappingURL=context.test.js.map

package/dist/src/test/dashboard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/test/dashboard.test.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_http_1 = __importDefault(require("node:http"));
+const server_js_1 = require("../proxy/server.js");
+const auto_detect_js_1 = require("../config/auto-detect.js");
+function httpRequest(url, options, body) {
+    return new Promise((resolve, reject) => {
+        const req = node_http_1.default.request(url, options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => resolve({ status: res.statusCode || 0, headers: res.headers, body: data }));
+        });
+        req.on('error', reject);
+        if (body)
+            req.write(body);
+        req.end();
+    });
+}
+(0, node_test_1.describe)('Dashboard & API', () => {
+    let proxy;
+    const PORT = 14810;
+    (0, node_test_1.before)(async () => {
+        const config = (0, auto_detect_js_1.buildConfig)({ proxy: { port: PORT, host: '127.0.0.1' } });
+        config.providers['anthropic'] = { apiKey: 'test', baseUrl: 'http://127.0.0.1:1' };
+        config.logging.level = 'error';
+        proxy = new server_js_1.ProxyServer(config);
+        await proxy.start();
+    });
+    (0, node_test_1.after)(async () => {
+        await proxy.stop();
+    });
+    (0, node_test_1.it)('serves dashboard at root path', async () => {
+        const res = await httpRequest(`http://127.0.0.1:${PORT}/`, { method: 'GET' });
+        node_assert_1.default.strictEqual(res.status, 200);
+        node_assert_1.default.ok(res.headers['content-type']?.includes('text/html'));
+        node_assert_1.default.ok(res.body.includes('SmartContext Proxy'));
+        node_assert_1.default.ok(res.body.includes('Total Requests'));
+    });
+    (0, node_test_1.it)('returns status via /_sc/status', async () => {
+        const res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/status`, { method: 'GET' });
+        node_assert_1.default.strictEqual(res.status, 200);
+        const data = JSON.parse(res.body);
+        node_assert_1.default.strictEqual(data.state, 'running');
+        node_assert_1.default.ok(data.uptime >= 0);
+    });
+    (0, node_test_1.it)('returns stats via /_sc/stats', async () => {
+        const res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/stats`, { method: 'GET' });
+        node_assert_1.default.strictEqual(res.status, 200);
+        const data = JSON.parse(res.body);
+        node_assert_1.default.strictEqual(data.totalRequests, 0);
+        node_assert_1.default.ok('byProvider' in data);
+        node_assert_1.default.ok('byModel' in data);
+    });
+    (0, node_test_1.it)('pause/resume works', async () => {
+        // Pause
+        let res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/pause`, { method: 'POST' });
+        node_assert_1.default.strictEqual(res.status, 200);
+        let data = JSON.parse(res.body);
+        node_assert_1.default.strictEqual(data.state, 'paused');
+        // Check status
+        res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/status`, { method: 'GET' });
+        data = JSON.parse(res.body);
+        node_assert_1.default.strictEqual(data.state, 'paused');
+        // Resume
+        res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/resume`, { method: 'POST' });
+        data = JSON.parse(res.body);
+        node_assert_1.default.strictEqual(data.state, 'running');
+    });
+    (0, node_test_1.it)('returns feed via /_sc/feed', async () => {
+        const res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/feed`, { method: 'GET' });
+        node_assert_1.default.strictEqual(res.status, 200);
+        const data = JSON.parse(res.body);
+        node_assert_1.default.ok(Array.isArray(data));
+    });
+    (0, node_test_1.it)('returns 404 for unknown API path', async () => {
+        const res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/nonexistent`, { method: 'GET' });
+        node_assert_1.default.strictEqual(res.status, 404);
+    });
+});
+//# sourceMappingURL=dashboard.test.js.map

package/dist/src/test/proxy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/test/proxy.test.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_http_1 = __importDefault(require("node:http"));
+const server_js_1 = require("../proxy/server.js");
+const auto_detect_js_1 = require("../config/auto-detect.js");
+/** Create a mock LLM provider server */
+function createMockProvider(port) {
+    return new Promise((resolve) => {
+        const server = node_http_1.default.createServer((req, res) => {
+            let body = '';
+            req.on('data', (chunk) => (body += chunk));
+            req.on('end', () => {
+                const parsed = JSON.parse(body);
+                if (parsed.stream) {
+                    // SSE streaming response
+                    res.writeHead(200, {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                    });
+                    const events = [
+                        'data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}\n\n',
+                        'data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}\n\n',
+                        'data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" there"}}\n\n',
+                        'data: {"type":"content_block_stop","index":0}\n\n',
+                        'data: {"type":"message_stop"}\n\n',
+                    ];
+                    let i = 0;
+                    const interval = setInterval(() => {
+                        if (i < events.length) {
+                            res.write(events[i]);
+                            i++;
+                        }
+                        else {
+                            clearInterval(interval);
+                            res.end();
+                        }
+                    }, 10);
+                }
+                else {
+                    // Non-streaming response
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        id: 'msg_test',
+                        type: 'message',
+                        role: 'assistant',
+                        content: [{ type: 'text', text: 'Hello from mock provider!' }],
+                        model: parsed.model || 'test-model',
+                        stop_reason: 'end_turn',
+                        usage: { input_tokens: 10, output_tokens: 5 },
+                    }));
+                }
+            });
+        });
+        server.listen(port, '127.0.0.1', () => resolve(server));
+    });
+}
+function httpRequest(url, options, body) {
+    return new Promise((resolve, reject) => {
+        const req = node_http_1.default.request(url, options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => resolve({ status: res.statusCode || 0, headers: res.headers, body: data }));
+        });
+        req.on('error', reject);
+        if (body)
+            req.write(body);
+        req.end();
+    });
+}
+(0, node_test_1.describe)('SmartContext Proxy', () => {
+    let proxy;
+    let mockServer;
+    const PROXY_PORT = 14800;
+    const MOCK_PORT = 14801;
+    (0, node_test_1.before)(async () => {
+        // Start mock provider
+        mockServer = await createMockProvider(MOCK_PORT);
+        // Start proxy pointing to mock provider
+        const config = (0, auto_detect_js_1.buildConfig)({
+            proxy: { port: PROXY_PORT, host: '127.0.0.1' },
+        });
+        // Override anthropic baseUrl to point to mock
+        config.providers['anthropic'] = {
+            apiKey: 'test-key',
+            baseUrl: `http://127.0.0.1:${MOCK_PORT}`,
+        };
+        config.providers['openai'] = {
+            apiKey: 'test-key',
+            baseUrl: `http://127.0.0.1:${MOCK_PORT}`,
+        };
+        config.logging.level = 'error'; // quiet during tests
+        proxy = new server_js_1.ProxyServer(config);
+        await proxy.start();
+    });
+    (0, node_test_1.after)(async () => {
+        await proxy.stop();
+        mockServer.close();
+    });
+    (0, node_test_1.it)('health endpoint returns ok', async () => {
+        const res = await httpRequest(`http://127.0.0.1:${PROXY_PORT}/health`, { method: 'GET' });
+        node_assert_1.default.strictEqual(res.status, 200);
+        const data = JSON.parse(res.body);
+        node_assert_1.default.strictEqual(data.ok, true);
+    });
+    (0, node_test_1.it)('returns 404 for unknown provider', async () => {
+        const res = await httpRequest(`http://127.0.0.1:${PROXY_PORT}/v1/unknown/test`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+        }, '{}');
+        node_assert_1.default.strictEqual(res.status, 404);
+    });
+    (0, node_test_1.it)('returns 405 for GET on provider path', async () => {
+        const res = await httpRequest(`http://127.0.0.1:${PROXY_PORT}/v1/anthropic/v1/messages`, {
+            method: 'GET',
+        });
+        node_assert_1.default.strictEqual(res.status, 405);
+    });
+    (0, node_test_1.it)('forwards Anthropic non-streaming request correctly', async () => {
+        const body = JSON.stringify({
+            model: 'claude-haiku-4-5-20251001',
+            max_tokens: 50,
+            messages: [{ role: 'user', content: 'Hello' }],
+        });
+        const res = await httpRequest(`http://127.0.0.1:${PROXY_PORT}/v1/anthropic/v1/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': 'test-key',
+                'anthropic-version': '2023-06-01',
+            },
+        }, body);
+        node_assert_1.default.strictEqual(res.status, 200);
+        const data = JSON.parse(res.body);
+        node_assert_1.default.strictEqual(data.content[0].text, 'Hello from mock provider!');
+        node_assert_1.default.strictEqual(data.role, 'assistant');
+    });
+    (0, node_test_1.it)('forwards Anthropic streaming request correctly', async () => {
+        const body = JSON.stringify({
+            model: 'claude-haiku-4-5-20251001',
+            max_tokens: 50,
+            stream: true,
+            messages: [{ role: 'user', content: 'Hello' }],
+        });
+        const res = await httpRequest(`http://127.0.0.1:${PROXY_PORT}/v1/anthropic/v1/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': 'test-key',
+                'anthropic-version': '2023-06-01',
+            },
+        }, body);
+        node_assert_1.default.strictEqual(res.status, 200);
+        node_assert_1.default.ok(res.body.includes('Hello'));
+        node_assert_1.default.ok(res.body.includes('there'));
+        node_assert_1.default.ok(res.body.includes('message_stop'));
+    });
+    (0, node_test_1.it)('forwards OpenAI request correctly', async () => {
+        const body = JSON.stringify({
+            model: 'gpt-4o',
+            messages: [
+                { role: 'system', content: 'You are helpful.' },
+                { role: 'user', content: 'Hello' },
+            ],
+        });
+        const res = await httpRequest(`http://127.0.0.1:${PROXY_PORT}/v1/openai/v1/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': 'Bearer test-key',
+            },
+        }, body);
+        node_assert_1.default.strictEqual(res.status, 200);
+        const data = JSON.parse(res.body);
+        node_assert_1.default.ok(data.content);
+    });
+    (0, node_test_1.it)('auto-detect finds providers from config', () => {
+        const providers = proxy.getProviderNames();
+        node_assert_1.default.ok(providers.includes('anthropic'));
+        node_assert_1.default.ok(providers.includes('openai'));
+        node_assert_1.default.ok(providers.includes('ollama'));
+    });
+});
+//# sourceMappingURL=proxy.test.js.map

package/dist/src/ui/dashboard.d.ts

@@ -0,0 +1,2 @@
+import type { MetricsCollector } from '../metrics/collector.js';
+export declare function renderDashboard(metrics: MetricsCollector, paused: boolean): string;