smartcontext-proxy 0.1.0

package/src/storage/lancedb.ts

@@ -0,0 +1,169 @@
+import { connect, type Connection, type Table } from '@lancedb/lancedb';
+import fs from 'node:fs';
+import path from 'node:path';
+import type { StorageAdapter, Chunk, ScoredChunk, SearchOptions, Exchange } from './types.js';
+
+export class LanceDBAdapter implements StorageAdapter {
+  name = 'lancedb';
+  private db!: Connection;
+  private chunksTable!: Table;
+  private logsDir: string;
+  private dbPath: string;
+
+  constructor(private basePath: string = path.join(process.env['HOME'] || '.', '.smartcontext', 'data')) {
+    this.dbPath = path.join(basePath, 'vectors');
+    this.logsDir = path.join(basePath, 'logs');
+  }
+
+  async initialize(): Promise<void> {
+    fs.mkdirSync(this.dbPath, { recursive: true });
+    fs.mkdirSync(this.logsDir, { recursive: true });
+
+    this.db = await 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: Chunk[]): Promise<void> {
+    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: number[], options: SearchOptions): Promise<ScoredChunk[]> {
+    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: ScoredChunk[] = results.map((r) => {
+      // LanceDB returns _distance (L2), convert to similarity score
+      const distance = (r as Record<string, unknown>)['_distance'] as number;
+      let score = 1 / (1 + distance); // Convert L2 distance to similarity
+
+      const boosts: Record<string, number> = {};
+
+      // 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: string[] = JSON.parse(r.files || '[]');
+        const hasMatch = options.fileBoost.patterns.some((p) =>
+          files.some((f: string) => 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: string, exchange: Exchange): Promise<void> {
+    const logFile = path.join(this.logsDir, `${sessionId}.jsonl`);
+    const line = JSON.stringify(exchange) + '\n';
+    fs.appendFileSync(logFile, line);
+  }
+
+  async getSessionLog(sessionId: string): Promise<Exchange[]> {
+    const logFile = path.join(this.logsDir, `${sessionId}.jsonl`);
+    if (!fs.existsSync(logFile)) return [];
+
+    return fs.readFileSync(logFile, 'utf-8')
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  }
+
+  async getStats(): Promise<{ chunks: number; sessions: number; diskBytes: number }> {
+    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 = fs.readdirSync(this.logsDir).filter((f) => f.endsWith('.jsonl')).length;
+
+    // Rough disk usage
+    let diskBytes = 0;
+    const walk = (dir: string) => {
+      if (!fs.existsSync(dir)) return;
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) walk(full);
+        else diskBytes += fs.statSync(full).size;
+      }
+    };
+    walk(this.basePath);
+
+    return { chunks, sessions, diskBytes };
+  }
+
+  async close(): Promise<void> {
+    // LanceDB doesn't require explicit close
+  }
+}

package/src/storage/types.ts

@@ -0,0 +1,47 @@
+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/src/test/context.test.ts

@@ -0,0 +1,165 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { chunkConversation, estimateTokens } from '../context/chunker.js';
+import { packContext, getModelContextLimit } from '../context/budget.js';
+import type { CanonicalMessage } from '../context/canonical.js';
+import type { ScoredChunk } from '../storage/types.js';
+
+describe('Chunker', () => {
+  it('estimates tokens roughly correctly', () => {
+    const text = 'Hello world, this is a test message.';
+    const tokens = estimateTokens(text);
+    assert.ok(tokens > 5 && tokens < 20, `Expected 5-20 tokens, got ${tokens}`);
+  });
+
+  it('chunks a simple conversation into exchange pairs', () => {
+    const messages: CanonicalMessage[] = [
+      { 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 = chunkConversation(messages, 'test-session');
+    assert.strictEqual(chunks.length, 2);
+    assert.ok(chunks[0].text.includes('What is TypeScript'));
+    assert.ok(chunks[0].text.includes('superset of JavaScript'));
+    assert.ok(chunks[1].text.includes('How do I install'));
+  });
+
+  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: CanonicalMessage[] = [
+      { role: 'user', content: 'Tell me everything about programming.' },
+      { role: 'assistant', content: longResponse },
+    ];
+
+    const chunks = chunkConversation(messages, 'test-session');
+    assert.ok(chunks.length > 1, `Expected >1 chunks for long response, got ${chunks.length}`);
+    for (const chunk of chunks) {
+      assert.ok(chunk.metadata.tokenCount <= 2500, `Chunk too large: ${chunk.metadata.tokenCount} tokens`);
+    }
+  });
+
+  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: CanonicalMessage[] = [
+      { role: 'user', content: 'Show me code' },
+      { role: 'assistant', content: response },
+    ];
+
+    const chunks = chunkConversation(messages, 'test-session');
+    // Code block should be in one chunk
+    const codeChunk = chunks.find((c) => c.text.includes('```typescript'));
+    assert.ok(codeChunk, 'Should have a chunk with the code block');
+    assert.ok(codeChunk.text.includes('console.log("world")'), 'Code block should be complete');
+  });
+
+  it('extracts file paths from text', () => {
+    const messages: CanonicalMessage[] = [
+      { 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 = chunkConversation(messages, 'test-session');
+    assert.ok(chunks[0].metadata.files!.length > 0, 'Should extract file paths');
+  });
+
+  it('assigns unique IDs to chunks', () => {
+    const messages: CanonicalMessage[] = [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi' },
+      { role: 'user', content: 'Bye' },
+      { role: 'assistant', content: 'Goodbye' },
+    ];
+
+    const chunks = chunkConversation(messages, 'test-session');
+    const ids = new Set(chunks.map((c) => c.id));
+    assert.strictEqual(ids.size, chunks.length, 'All chunk IDs should be unique');
+  });
+});
+
+describe('Budget', () => {
+  it('knows context limits for common models', () => {
+    assert.strictEqual(getModelContextLimit('claude-opus-4-6'), 200000);
+    assert.strictEqual(getModelContextLimit('gpt-4o'), 128000);
+    assert.strictEqual(getModelContextLimit('unknown-model'), 128000);
+  });
+
+  it('packs context within budget', () => {
+    const messages: CanonicalMessage[] = Array(20).fill(null).map((_, i) => ({
+      role: i % 2 === 0 ? 'user' as const : 'assistant' as const,
+      content: `Message ${i}: `.padEnd(200, 'x'),
+    }));
+
+    const mockChunks: ScoredChunk[] = [
+      {
+        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 = packContext(
+      'You are a helpful assistant.',
+      messages,
+      mockChunks,
+      'claude-opus-4-6',
+      3,   // tier1_exchanges
+      500, // tier3_reserve
+      8192, // response_reserve
+    );
+
+    assert.ok(packed.tier1Messages.length > 0, 'Should have tier 1 messages');
+    assert.ok(packed.tier2Chunks.length > 0, 'Should have tier 2 chunks');
+    assert.ok(packed.optimizedTokens < packed.originalTokens, 'Should save tokens');
+    assert.ok(packed.savingsPercent > 0, 'Should have positive savings');
+  });
+
+  it('handles empty retrieval', () => {
+    const messages: CanonicalMessage[] = [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi there' },
+    ];
+
+    const packed = packContext('System prompt', messages, [], 'gpt-4o', 3, 500, 8192);
+    assert.strictEqual(packed.tier2Chunks.length, 0);
+    assert.strictEqual(packed.savingsPercent, 0);
+  });
+});
+
+describe('Metrics', () => {
+  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();
+    assert.strictEqual(stats.totalRequests, 2);
+    assert.strictEqual(stats.totalOriginalTokens, 1500);
+    assert.strictEqual(stats.totalOptimizedTokens, 500);
+    assert.ok(stats.totalSavingsPercent > 50);
+    assert.ok(stats.byProvider['anthropic']);
+    assert.ok(stats.byModel['gpt-4o']);
+  });
+});

package/src/test/dashboard.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import http from 'node:http';
+import { ProxyServer } from '../proxy/server.js';
+import { buildConfig } from '../config/auto-detect.js';
+
+function httpRequest(
+  url: string,
+  options: http.RequestOptions,
+  body?: string,
+): Promise<{ status: number; headers: http.IncomingHttpHeaders; body: string }> {
+  return new Promise((resolve, reject) => {
+    const req = http.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();
+  });
+}
+
+describe('Dashboard & API', () => {
+  let proxy: ProxyServer;
+  const PORT = 14810;
+
+  before(async () => {
+    const config = 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 ProxyServer(config);
+    await proxy.start();
+  });
+
+  after(async () => {
+    await proxy.stop();
+  });
+
+  it('serves dashboard at root path', async () => {
+    const res = await httpRequest(`http://127.0.0.1:${PORT}/`, { method: 'GET' });
+    assert.strictEqual(res.status, 200);
+    assert.ok(res.headers['content-type']?.includes('text/html'));
+    assert.ok(res.body.includes('SmartContext Proxy'));
+    assert.ok(res.body.includes('Total Requests'));
+  });
+
+  it('returns status via /_sc/status', async () => {
+    const res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/status`, { method: 'GET' });
+    assert.strictEqual(res.status, 200);
+    const data = JSON.parse(res.body);
+    assert.strictEqual(data.state, 'running');
+    assert.ok(data.uptime >= 0);
+  });
+
+  it('returns stats via /_sc/stats', async () => {
+    const res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/stats`, { method: 'GET' });
+    assert.strictEqual(res.status, 200);
+    const data = JSON.parse(res.body);
+    assert.strictEqual(data.totalRequests, 0);
+    assert.ok('byProvider' in data);
+    assert.ok('byModel' in data);
+  });
+
+  it('pause/resume works', async () => {
+    // Pause
+    let res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/pause`, { method: 'POST' });
+    assert.strictEqual(res.status, 200);
+    let data = JSON.parse(res.body);
+    assert.strictEqual(data.state, 'paused');
+
+    // Check status
+    res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/status`, { method: 'GET' });
+    data = JSON.parse(res.body);
+    assert.strictEqual(data.state, 'paused');
+
+    // Resume
+    res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/resume`, { method: 'POST' });
+    data = JSON.parse(res.body);
+    assert.strictEqual(data.state, 'running');
+  });
+
+  it('returns feed via /_sc/feed', async () => {
+    const res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/feed`, { method: 'GET' });
+    assert.strictEqual(res.status, 200);
+    const data = JSON.parse(res.body);
+    assert.ok(Array.isArray(data));
+  });
+
+  it('returns 404 for unknown API path', async () => {
+    const res = await httpRequest(`http://127.0.0.1:${PORT}/_sc/nonexistent`, { method: 'GET' });
+    assert.strictEqual(res.status, 404);
+  });
+});

package/src/test/proxy.test.ts

@@ -0,0 +1,218 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import http from 'node:http';
+import { ProxyServer } from '../proxy/server.js';
+import { buildConfig } from '../config/auto-detect.js';
+
+/** Create a mock LLM provider server */
+function createMockProvider(port: number): Promise<http.Server> {
+  return new Promise((resolve) => {
+    const server = http.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: string,
+  options: http.RequestOptions,
+  body?: string,
+): Promise<{ status: number; headers: http.IncomingHttpHeaders; body: string }> {
+  return new Promise((resolve, reject) => {
+    const req = http.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();
+  });
+}
+
+describe('SmartContext Proxy', () => {
+  let proxy: ProxyServer;
+  let mockServer: http.Server;
+  const PROXY_PORT = 14800;
+  const MOCK_PORT = 14801;
+
+  before(async () => {
+    // Start mock provider
+    mockServer = await createMockProvider(MOCK_PORT);
+
+    // Start proxy pointing to mock provider
+    const config = 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 ProxyServer(config);
+    await proxy.start();
+  });
+
+  after(async () => {
+    await proxy.stop();
+    mockServer.close();
+  });
+
+  it('health endpoint returns ok', async () => {
+    const res = await httpRequest(`http://127.0.0.1:${PROXY_PORT}/health`, { method: 'GET' });
+    assert.strictEqual(res.status, 200);
+    const data = JSON.parse(res.body);
+    assert.strictEqual(data.ok, true);
+  });
+
+  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' },
+    }, '{}');
+    assert.strictEqual(res.status, 404);
+  });
+
+  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',
+    });
+    assert.strictEqual(res.status, 405);
+  });
+
+  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,
+    );
+
+    assert.strictEqual(res.status, 200);
+    const data = JSON.parse(res.body);
+    assert.strictEqual(data.content[0].text, 'Hello from mock provider!');
+    assert.strictEqual(data.role, 'assistant');
+  });
+
+  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,
+    );
+
+    assert.strictEqual(res.status, 200);
+    assert.ok(res.body.includes('Hello'));
+    assert.ok(res.body.includes('there'));
+    assert.ok(res.body.includes('message_stop'));
+  });
+
+  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,
+    );
+
+    assert.strictEqual(res.status, 200);
+    const data = JSON.parse(res.body);
+    assert.ok(data.content);
+  });
+
+  it('auto-detect finds providers from config', () => {
+    const providers = proxy.getProviderNames();
+    assert.ok(providers.includes('anthropic'));
+    assert.ok(providers.includes('openai'));
+    assert.ok(providers.includes('ollama'));
+  });
+});