smartcontext-proxy 0.1.0

package/src/providers/openai.ts

@@ -0,0 +1,127 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalMessage, CanonicalRequest, ContentBlock } from '../context/canonical.js';
+
+export class OpenAIAdapter implements ProviderAdapter {
+  name = 'openai';
+
+  constructor(public baseUrl: string = 'https://api.openai.com') {}
+
+  parseRequest(body: unknown, headers: Record<string, string>): CanonicalRequest {
+    const b = body as Record<string, unknown>;
+    const messages: CanonicalMessage[] = [];
+    let systemPrompt: string | undefined;
+
+    if (Array.isArray(b.messages)) {
+      for (const msg of b.messages as Array<Record<string, unknown>>) {
+        // OpenAI puts system prompt as a message with role=system
+        if (msg.role === 'system') {
+          systemPrompt = typeof msg.content === 'string'
+            ? msg.content
+            : (msg.content as Array<{ text?: string }>)?.map((c) => c.text || '').join('\n');
+          continue;
+        }
+        messages.push(this.parseMessage(msg));
+      }
+    }
+
+    return {
+      messages,
+      systemPrompt,
+      model: (b.model as string) || 'unknown',
+      stream: !!b.stream,
+      maxTokens: (b.max_tokens ?? b.max_completion_tokens) as number | undefined,
+      temperature: b.temperature as number | undefined,
+      tools: b.tools as unknown[] | undefined,
+      rawHeaders: headers,
+      providerAuth: this.extractApiKey(headers),
+    };
+  }
+
+  serializeRequest(canonical: CanonicalRequest): unknown {
+    const messages: Array<Record<string, unknown>> = [];
+
+    if (canonical.systemPrompt) {
+      messages.push({ role: 'system', content: canonical.systemPrompt });
+    }
+
+    for (const msg of canonical.messages) {
+      messages.push(this.serializeMessage(msg));
+    }
+
+    const body: Record<string, unknown> = {
+      model: canonical.model,
+      messages,
+      stream: canonical.stream,
+    };
+
+    if (canonical.maxTokens) {
+      body.max_tokens = canonical.maxTokens;
+    }
+    if (canonical.temperature !== undefined) {
+      body.temperature = canonical.temperature;
+    }
+    if (canonical.tools) {
+      body.tools = canonical.tools;
+    }
+
+    return body;
+  }
+
+  forwardUrl(originalPath: string): string {
+    // /v1/openai/v1/chat/completions → https://api.openai.com/v1/chat/completions
+    const stripped = originalPath.replace(/^\/v1\/openai/, '');
+    return `${this.baseUrl}${stripped}`;
+  }
+
+  extractApiKey(headers: Record<string, string>): string {
+    const auth = headers['authorization'] || '';
+    return auth.replace(/^Bearer\s+/i, '');
+  }
+
+  contentType(): string {
+    return 'application/json';
+  }
+
+  authHeaders(apiKey: string): Record<string, string> {
+    return {
+      'Authorization': `Bearer ${apiKey}`,
+    };
+  }
+
+  private parseMessage(msg: Record<string, unknown>): CanonicalMessage {
+    const role = msg.role as string;
+    let content: string | ContentBlock[];
+
+    if (typeof msg.content === 'string') {
+      content = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      content = (msg.content as Array<Record<string, unknown>>).map((block) => {
+        if (block.type === 'text') {
+          return { type: 'text' as const, text: block.text as string };
+        }
+        return { ...block, type: block.type as ContentBlock['type'] };
+      });
+    } else if (msg.content === null || msg.content === undefined) {
+      // Assistant messages with tool_calls may have null content
+      content = '';
+    } else {
+      content = '';
+    }
+
+    const canonical: CanonicalMessage = { role: role as CanonicalMessage['role'], content };
+
+    // Preserve tool_calls on assistant messages
+    if (msg.tool_calls) {
+      canonical.metadata = { tools: (msg.tool_calls as Array<{ function?: { name?: string } }>).map((t) => t.function?.name || 'unknown') };
+    }
+
+    return canonical;
+  }
+
+  private serializeMessage(msg: CanonicalMessage): Record<string, unknown> {
+    return {
+      role: msg.role === 'tool' ? 'tool' : msg.role,
+      content: msg.content,
+    };
+  }
+}

package/src/providers/types.ts

@@ -0,0 +1,20 @@
+import type { IncomingMessage } from 'node:http';
+import type { CanonicalRequest, CanonicalResponse } from '../context/canonical.js';
+
+export interface ProviderAdapter {
+  name: string;
+  /** Base URL for this provider's API */
+  baseUrl: string;
+  /** Parse raw request body into canonical format */
+  parseRequest(body: unknown, headers: Record<string, string>): CanonicalRequest;
+  /** Convert canonical request back to provider format for forwarding */
+  serializeRequest(canonical: CanonicalRequest): unknown;
+  /** Build the forward URL from the original request path */
+  forwardUrl(originalPath: string): string;
+  /** Extract API key from request headers */
+  extractApiKey(headers: Record<string, string>): string;
+  /** Get the content-type header for forwarding */
+  contentType(): string;
+  /** Build auth headers for the forwarded request */
+  authHeaders(apiKey: string): Record<string, string>;
+}

package/src/proxy/router.ts

@@ -0,0 +1,48 @@
+import type { ProviderAdapter } from '../providers/types.js';
+import { AnthropicAdapter } from '../providers/anthropic.js';
+import { OpenAIAdapter } from '../providers/openai.js';
+import { OllamaAdapter } from '../providers/ollama.js';
+import { GoogleAdapter } from '../providers/google.js';
+import type { SmartContextConfig } from '../config/schema.js';
+
+export class Router {
+  private adapters: Map<string, ProviderAdapter> = new Map();
+
+  constructor(config: SmartContextConfig) {
+    // Register adapters for detected providers
+    const providers = config.providers;
+
+    if (providers.anthropic) {
+      this.adapters.set('anthropic', new AnthropicAdapter(providers.anthropic.baseUrl));
+    }
+    if (providers.openai) {
+      this.adapters.set('openai', new OpenAIAdapter(providers.openai.baseUrl));
+    }
+    if (providers.ollama) {
+      this.adapters.set('ollama', new OllamaAdapter(providers.ollama.baseUrl));
+    }
+    if (providers.google) {
+      this.adapters.set('google', new GoogleAdapter(providers.google.baseUrl));
+    }
+    if (providers.openrouter) {
+      // OpenRouter uses OpenAI-compatible API
+      this.adapters.set('openrouter', new OpenAIAdapter(providers.openrouter.baseUrl || 'https://openrouter.ai/api'));
+    }
+  }
+
+  /** Extract provider name from URL path: /v1/{provider}/... */
+  resolve(path: string): { adapter: ProviderAdapter; providerName: string } | null {
+    const match = path.match(/^\/v1\/([^/]+)/);
+    if (!match) return null;
+
+    const providerName = match[1];
+    const adapter = this.adapters.get(providerName);
+    if (!adapter) return null;
+
+    return { adapter, providerName };
+  }
+
+  getProviderNames(): string[] {
+    return Array.from(this.adapters.keys());
+  }
+}

package/src/proxy/server.ts

@@ -0,0 +1,315 @@
+import http, { IncomingMessage, ServerResponse } from 'node:http';
+import https from 'node:https';
+import { URL } from 'node:url';
+import type { SmartContextConfig } from '../config/schema.js';
+import type { ProviderAdapter } from '../providers/types.js';
+import { Router } from './router.js';
+import { streamResponse } from './stream.js';
+import { ContextOptimizer } from '../context/optimizer.js';
+import { MetricsCollector, type RequestMetric } from '../metrics/collector.js';
+import type { EmbeddingAdapter } from '../embedding/types.js';
+import type { StorageAdapter } from '../storage/types.js';
+import { estimateTokens } from '../context/chunker.js';
+import { getTextContent } from '../context/canonical.js';
+import { renderDashboard } from '../ui/dashboard.js';
+
+export class ProxyServer {
+  private server: http.Server;
+  private router: Router;
+  private config: SmartContextConfig;
+  private requestCount = 0;
+  private optimizer: ContextOptimizer | null = null;
+  private metrics = new MetricsCollector();
+  private paused = false;
+
+  constructor(
+    config: SmartContextConfig,
+    embedding?: EmbeddingAdapter,
+    storage?: StorageAdapter,
+  ) {
+    this.config = config;
+    this.router = new Router(config);
+    this.server = http.createServer((req, res) => this.handleRequest(req, res));
+
+    if (embedding && storage) {
+      this.optimizer = new ContextOptimizer(embedding, storage, config.context);
+    }
+  }
+
+  async start(): Promise<void> {
+    const { port, host } = this.config.proxy;
+    return new Promise((resolve) => {
+      this.server.listen(port, host, () => resolve());
+    });
+  }
+
+  async stop(): Promise<void> {
+    return new Promise((resolve) => {
+      this.server.close(() => resolve());
+    });
+  }
+
+  getProviderNames(): string[] {
+    return this.router.getProviderNames();
+  }
+
+  getMetrics(): MetricsCollector {
+    return this.metrics;
+  }
+
+  setPaused(paused: boolean): void {
+    this.paused = paused;
+  }
+
+  isPaused(): boolean {
+    return this.paused;
+  }
+
+  private async handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    const path = req.url || '/';
+    const method = req.method || 'GET';
+
+    // Dashboard (root path)
+    if (path === '/' && method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(renderDashboard(this.metrics, this.paused));
+      return;
+    }
+
+    // Health check
+    if (path === '/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        ok: true,
+        requests: this.requestCount,
+        paused: this.paused,
+        mode: this.optimizer ? 'optimizing' : 'transparent',
+      }));
+      return;
+    }
+
+    // Internal API endpoints (/_sc/*)
+    if (path.startsWith('/_sc/')) {
+      await this.handleApiRequest(path, method, req, res);
+      return;
+    }
+
+    // Only handle POST to /v1/{provider}/*
+    if (method !== 'POST') {
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Method not allowed' }));
+      return;
+    }
+
+    const route = this.router.resolve(path);
+    if (!route) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: `Unknown provider path: ${path}` }));
+      return;
+    }
+
+    try {
+      this.requestCount++;
+      await this.proxyRequest(req, res, route.adapter, path);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Internal proxy error';
+      this.log('error', `Proxy error: ${message}`);
+      if (!res.headersSent) {
+        res.writeHead(502, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: message }));
+      }
+    }
+  }
+
+  private async handleApiRequest(
+    path: string,
+    method: string,
+    req: IncomingMessage,
+    res: ServerResponse,
+  ): Promise<void> {
+    res.setHeader('Content-Type', 'application/json');
+
+    switch (path) {
+      case '/_sc/status':
+        res.end(JSON.stringify({
+          state: this.paused ? 'paused' : 'running',
+          uptime: this.metrics.getUptime(),
+          requests: this.requestCount,
+          mode: this.optimizer ? 'optimizing' : 'transparent',
+        }));
+        break;
+
+      case '/_sc/stats':
+        res.end(JSON.stringify(this.metrics.getStats()));
+        break;
+
+      case '/_sc/feed':
+        res.end(JSON.stringify(this.metrics.getRecent(50)));
+        break;
+
+      case '/_sc/pause':
+        this.paused = true;
+        res.end(JSON.stringify({ ok: true, state: 'paused' }));
+        break;
+
+      case '/_sc/resume':
+        this.paused = false;
+        res.end(JSON.stringify({ ok: true, state: 'running' }));
+        break;
+
+      default:
+        res.writeHead(404);
+        res.end(JSON.stringify({ error: `Unknown API path: ${path}` }));
+    }
+  }
+
+  private async proxyRequest(
+    clientReq: IncomingMessage,
+    clientRes: ServerResponse,
+    adapter: ProviderAdapter,
+    path: string,
+  ): Promise<void> {
+    const startTime = Date.now();
+
+    const bodyBuf = await this.readBody(clientReq);
+    const body = JSON.parse(bodyBuf.toString());
+
+    const headers: Record<string, string> = {};
+    for (const [key, val] of Object.entries(clientReq.headers)) {
+      if (typeof val === 'string') headers[key] = val;
+    }
+
+    const canonical = adapter.parseRequest(body, headers);
+    const originalTokens =
+      estimateTokens(canonical.systemPrompt || '') +
+      canonical.messages.reduce((sum, m) => sum + estimateTokens(getTextContent(m)), 0);
+
+    let forwardBody: string;
+    let optimizedTokens = originalTokens;
+    let savingsPercent = 0;
+    let chunksRetrieved = 0;
+    let topScore = 0;
+    let passThrough = true;
+    let reason: string | undefined;
+
+    // Context optimization (if available and not paused)
+    if (this.optimizer && !this.paused) {
+      try {
+        const result = await this.optimizer.optimize(canonical);
+        passThrough = result.passThrough;
+        reason = result.reason;
+
+        if (!result.passThrough) {
+          // Use optimized context
+          canonical.messages = result.optimizedMessages;
+          if (result.systemPrompt !== undefined) {
+            canonical.systemPrompt = result.systemPrompt;
+          }
+          optimizedTokens = result.packed.optimizedTokens;
+          savingsPercent = result.packed.savingsPercent;
+        }
+
+        if (result.retrieval) {
+          chunksRetrieved = result.retrieval.chunks.length;
+          topScore = result.retrieval.topScore;
+        }
+      } catch (err) {
+        // Graceful degradation: optimization failed, forward original
+        this.log('error', `Optimization failed, passing through: ${err}`);
+        passThrough = true;
+        reason = `optimization error: ${err}`;
+      }
+    }
+
+    // Serialize for forwarding
+    if (!passThrough) {
+      forwardBody = JSON.stringify(adapter.serializeRequest(canonical));
+    } else {
+      forwardBody = JSON.stringify(body);
+    }
+
+    const forwardUrl = new URL(adapter.forwardUrl(path));
+    const apiKey = canonical.providerAuth || this.config.providers[adapter.name]?.apiKey || '';
+
+    const forwardHeaders: Record<string, string> = {
+      'Content-Type': adapter.contentType(),
+      ...adapter.authHeaders(apiKey),
+    };
+
+    if (headers['anthropic-version']) forwardHeaders['anthropic-version'] = headers['anthropic-version'];
+    if (headers['anthropic-beta']) forwardHeaders['anthropic-beta'] = headers['anthropic-beta'];
+    forwardHeaders['Content-Length'] = Buffer.byteLength(forwardBody).toString();
+
+    const latencyOverhead = Date.now() - startTime;
+    const savingsStr = passThrough ? 'pass' : `-${savingsPercent}%`;
+
+    this.log('info',
+      `#${this.requestCount} ${adapter.name}/${canonical.model} ` +
+      `${originalTokens}→${optimizedTokens} ${savingsStr} ` +
+      `${canonical.stream ? 'stream' : 'sync'} ${latencyOverhead}ms`);
+
+    // Forward to provider
+    const transport = forwardUrl.protocol === 'https:' ? https : http;
+    const providerRes = await new Promise<IncomingMessage>((resolve, reject) => {
+      const proxyReq = transport.request(forwardUrl, { method: 'POST', headers: forwardHeaders }, resolve);
+      proxyReq.on('error', reject);
+      proxyReq.write(forwardBody);
+      proxyReq.end();
+    });
+
+    // Add debug headers if enabled
+    if (this.config.logging.debug_headers && !passThrough) {
+      providerRes.headers['x-smartcontext-savings'] = `${savingsPercent}%`;
+      providerRes.headers['x-smartcontext-original-tokens'] = String(originalTokens);
+      providerRes.headers['x-smartcontext-optimized-tokens'] = String(optimizedTokens);
+      providerRes.headers['x-smartcontext-chunks'] = String(chunksRetrieved);
+      providerRes.headers['x-smartcontext-latency-ms'] = String(latencyOverhead);
+      providerRes.headers['x-smartcontext-mode'] = this.paused ? 'paused' : 'optimized';
+    }
+
+    // Stream response back
+    const responseBuffer = await streamResponse(providerRes, clientRes);
+
+    // Record metrics
+    this.metrics.record({
+      id: this.requestCount,
+      timestamp: Date.now(),
+      provider: adapter.name,
+      model: canonical.model,
+      streaming: canonical.stream,
+      originalTokens,
+      optimizedTokens,
+      savingsPercent,
+      latencyOverheadMs: latencyOverhead,
+      chunksRetrieved,
+      topScore,
+      passThrough,
+      reason,
+    });
+
+    // Async post-indexing (don't block response)
+    if (this.optimizer && !passThrough) {
+      const sessionId = canonical.rawHeaders['x-smartcontext-session'] || `auto-${this.requestCount}`;
+      this.optimizer.indexExchange(canonical.messages, sessionId).catch((err) => {
+        this.log('error', `Post-indexing failed: ${err}`);
+      });
+    }
+  }
+
+  private readBody(req: IncomingMessage): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      req.on('data', (chunk: Buffer) => chunks.push(chunk));
+      req.on('end', () => resolve(Buffer.concat(chunks)));
+      req.on('error', reject);
+    });
+  }
+
+  private log(level: string, message: string): void {
+    const timestamp = new Date().toISOString().slice(11, 23);
+    const prefix = level === 'error' ? '✗' : '→';
+    if (level === 'error' || this.config.logging.level !== 'error') {
+      console.log(`[${timestamp}] ${prefix} ${message}`);
+    }
+  }
+}

package/src/proxy/stream.ts

@@ -0,0 +1,39 @@
+import { IncomingMessage } from 'node:http';
+import type { ServerResponse } from 'node:http';
+
+/**
+ * Stream SSE response from provider to client byte-by-byte.
+ * Zero buffering — passes through as fast as possible.
+ * Returns the full buffered response body for post-indexing.
+ */
+export async function streamResponse(
+  providerRes: IncomingMessage,
+  clientRes: ServerResponse,
+): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+
+    // Copy status and headers
+    clientRes.writeHead(providerRes.statusCode || 200, providerRes.headers);
+
+    providerRes.on('data', (chunk: Buffer) => {
+      chunks.push(chunk);
+      clientRes.write(chunk);
+    });
+
+    providerRes.on('end', () => {
+      clientRes.end();
+      resolve(Buffer.concat(chunks));
+    });
+
+    providerRes.on('error', (err) => {
+      clientRes.end();
+      reject(err);
+    });
+
+    // Handle client disconnect
+    clientRes.on('close', () => {
+      providerRes.destroy();
+    });
+  });
+}