smartcontext-proxy 0.1.0

package/dist/src/providers/openai.d.ts

@@ -0,0 +1,15 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalRequest } from '../context/canonical.js';
+export declare class OpenAIAdapter implements ProviderAdapter {
+    baseUrl: string;
+    name: string;
+    constructor(baseUrl?: string);
+    parseRequest(body: unknown, headers: Record<string, string>): CanonicalRequest;
+    serializeRequest(canonical: CanonicalRequest): unknown;
+    forwardUrl(originalPath: string): string;
+    extractApiKey(headers: Record<string, string>): string;
+    contentType(): string;
+    authHeaders(apiKey: string): Record<string, string>;
+    private parseMessage;
+    private serializeMessage;
+}

package/dist/src/providers/openai.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIAdapter = void 0;
+class OpenAIAdapter {
+    baseUrl;
+    name = 'openai';
+    constructor(baseUrl = 'https://api.openai.com') {
+        this.baseUrl = baseUrl;
+    }
+    parseRequest(body, headers) {
+        const b = body;
+        const messages = [];
+        let systemPrompt;
+        if (Array.isArray(b.messages)) {
+            for (const msg of b.messages) {
+                // OpenAI puts system prompt as a message with role=system
+                if (msg.role === 'system') {
+                    systemPrompt = typeof msg.content === 'string'
+                        ? msg.content
+                        : msg.content?.map((c) => c.text || '').join('\n');
+                    continue;
+                }
+                messages.push(this.parseMessage(msg));
+            }
+        }
+        return {
+            messages,
+            systemPrompt,
+            model: b.model || 'unknown',
+            stream: !!b.stream,
+            maxTokens: (b.max_tokens ?? b.max_completion_tokens),
+            temperature: b.temperature,
+            tools: b.tools,
+            rawHeaders: headers,
+            providerAuth: this.extractApiKey(headers),
+        };
+    }
+    serializeRequest(canonical) {
+        const messages = [];
+        if (canonical.systemPrompt) {
+            messages.push({ role: 'system', content: canonical.systemPrompt });
+        }
+        for (const msg of canonical.messages) {
+            messages.push(this.serializeMessage(msg));
+        }
+        const body = {
+            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) {
+        // /v1/openai/v1/chat/completions → https://api.openai.com/v1/chat/completions
+        const stripped = originalPath.replace(/^\/v1\/openai/, '');
+        return `${this.baseUrl}${stripped}`;
+    }
+    extractApiKey(headers) {
+        const auth = headers['authorization'] || '';
+        return auth.replace(/^Bearer\s+/i, '');
+    }
+    contentType() {
+        return 'application/json';
+    }
+    authHeaders(apiKey) {
+        return {
+            'Authorization': `Bearer ${apiKey}`,
+        };
+    }
+    parseMessage(msg) {
+        const role = msg.role;
+        let content;
+        if (typeof msg.content === 'string') {
+            content = msg.content;
+        }
+        else if (Array.isArray(msg.content)) {
+            content = msg.content.map((block) => {
+                if (block.type === 'text') {
+                    return { type: 'text', text: block.text };
+                }
+                return { ...block, type: block.type };
+            });
+        }
+        else if (msg.content === null || msg.content === undefined) {
+            // Assistant messages with tool_calls may have null content
+            content = '';
+        }
+        else {
+            content = '';
+        }
+        const canonical = { role: role, content };
+        // Preserve tool_calls on assistant messages
+        if (msg.tool_calls) {
+            canonical.metadata = { tools: msg.tool_calls.map((t) => t.function?.name || 'unknown') };
+        }
+        return canonical;
+    }
+    serializeMessage(msg) {
+        return {
+            role: msg.role === 'tool' ? 'tool' : msg.role,
+            content: msg.content,
+        };
+    }
+}
+exports.OpenAIAdapter = OpenAIAdapter;
+//# sourceMappingURL=openai.js.map

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

@@ -0,0 +1,18 @@
+import type { CanonicalRequest } 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/dist/src/providers/types.js

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

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

@@ -0,0 +1,12 @@
+import type { ProviderAdapter } from '../providers/types.js';
+import type { SmartContextConfig } from '../config/schema.js';
+export declare class Router {
+    private adapters;
+    constructor(config: SmartContextConfig);
+    /** Extract provider name from URL path: /v1/{provider}/... */
+    resolve(path: string): {
+        adapter: ProviderAdapter;
+        providerName: string;
+    } | null;
+    getProviderNames(): string[];
+}

package/dist/src/proxy/router.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const anthropic_js_1 = require("../providers/anthropic.js");
+const openai_js_1 = require("../providers/openai.js");
+const ollama_js_1 = require("../providers/ollama.js");
+const google_js_1 = require("../providers/google.js");
+class Router {
+    adapters = new Map();
+    constructor(config) {
+        // Register adapters for detected providers
+        const providers = config.providers;
+        if (providers.anthropic) {
+            this.adapters.set('anthropic', new anthropic_js_1.AnthropicAdapter(providers.anthropic.baseUrl));
+        }
+        if (providers.openai) {
+            this.adapters.set('openai', new openai_js_1.OpenAIAdapter(providers.openai.baseUrl));
+        }
+        if (providers.ollama) {
+            this.adapters.set('ollama', new ollama_js_1.OllamaAdapter(providers.ollama.baseUrl));
+        }
+        if (providers.google) {
+            this.adapters.set('google', new google_js_1.GoogleAdapter(providers.google.baseUrl));
+        }
+        if (providers.openrouter) {
+            // OpenRouter uses OpenAI-compatible API
+            this.adapters.set('openrouter', new openai_js_1.OpenAIAdapter(providers.openrouter.baseUrl || 'https://openrouter.ai/api'));
+        }
+    }
+    /** Extract provider name from URL path: /v1/{provider}/... */
+    resolve(path) {
+        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() {
+        return Array.from(this.adapters.keys());
+    }
+}
+exports.Router = Router;
+//# sourceMappingURL=router.js.map

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

@@ -0,0 +1,25 @@
+import type { SmartContextConfig } from '../config/schema.js';
+import { MetricsCollector } from '../metrics/collector.js';
+import type { EmbeddingAdapter } from '../embedding/types.js';
+import type { StorageAdapter } from '../storage/types.js';
+export declare class ProxyServer {
+    private server;
+    private router;
+    private config;
+    private requestCount;
+    private optimizer;
+    private metrics;
+    private paused;
+    constructor(config: SmartContextConfig, embedding?: EmbeddingAdapter, storage?: StorageAdapter);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getProviderNames(): string[];
+    getMetrics(): MetricsCollector;
+    setPaused(paused: boolean): void;
+    isPaused(): boolean;
+    private handleRequest;
+    private handleApiRequest;
+    private proxyRequest;
+    private readBody;
+    private log;
+}

package/dist/src/proxy/server.js

@@ -0,0 +1,265 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyServer = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_url_1 = require("node:url");
+const router_js_1 = require("./router.js");
+const stream_js_1 = require("./stream.js");
+const optimizer_js_1 = require("../context/optimizer.js");
+const collector_js_1 = require("../metrics/collector.js");
+const chunker_js_1 = require("../context/chunker.js");
+const canonical_js_1 = require("../context/canonical.js");
+const dashboard_js_1 = require("../ui/dashboard.js");
+class ProxyServer {
+    server;
+    router;
+    config;
+    requestCount = 0;
+    optimizer = null;
+    metrics = new collector_js_1.MetricsCollector();
+    paused = false;
+    constructor(config, embedding, storage) {
+        this.config = config;
+        this.router = new router_js_1.Router(config);
+        this.server = node_http_1.default.createServer((req, res) => this.handleRequest(req, res));
+        if (embedding && storage) {
+            this.optimizer = new optimizer_js_1.ContextOptimizer(embedding, storage, config.context);
+        }
+    }
+    async start() {
+        const { port, host } = this.config.proxy;
+        return new Promise((resolve) => {
+            this.server.listen(port, host, () => resolve());
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            this.server.close(() => resolve());
+        });
+    }
+    getProviderNames() {
+        return this.router.getProviderNames();
+    }
+    getMetrics() {
+        return this.metrics;
+    }
+    setPaused(paused) {
+        this.paused = paused;
+    }
+    isPaused() {
+        return this.paused;
+    }
+    async handleRequest(req, res) {
+        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((0, dashboard_js_1.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 }));
+            }
+        }
+    }
+    async handleApiRequest(path, method, req, res) {
+        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}` }));
+        }
+    }
+    async proxyRequest(clientReq, clientRes, adapter, path) {
+        const startTime = Date.now();
+        const bodyBuf = await this.readBody(clientReq);
+        const body = JSON.parse(bodyBuf.toString());
+        const headers = {};
+        for (const [key, val] of Object.entries(clientReq.headers)) {
+            if (typeof val === 'string')
+                headers[key] = val;
+        }
+        const canonical = adapter.parseRequest(body, headers);
+        const originalTokens = (0, chunker_js_1.estimateTokens)(canonical.systemPrompt || '') +
+            canonical.messages.reduce((sum, m) => sum + (0, chunker_js_1.estimateTokens)((0, canonical_js_1.getTextContent)(m)), 0);
+        let forwardBody;
+        let optimizedTokens = originalTokens;
+        let savingsPercent = 0;
+        let chunksRetrieved = 0;
+        let topScore = 0;
+        let passThrough = true;
+        let reason;
+        // 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 node_url_1.URL(adapter.forwardUrl(path));
+        const apiKey = canonical.providerAuth || this.config.providers[adapter.name]?.apiKey || '';
+        const forwardHeaders = {
+            '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:' ? node_https_1.default : node_http_1.default;
+        const providerRes = await new Promise((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 (0, stream_js_1.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}`);
+            });
+        }
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => resolve(Buffer.concat(chunks)));
+            req.on('error', reject);
+        });
+    }
+    log(level, message) {
+        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}`);
+        }
+    }
+}
+exports.ProxyServer = ProxyServer;
+//# sourceMappingURL=server.js.map

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

@@ -0,0 +1,8 @@
+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 declare function streamResponse(providerRes: IncomingMessage, clientRes: ServerResponse): Promise<Buffer>;

package/dist/src/proxy/stream.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamResponse = streamResponse;
+/**
+ * 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.
+ */
+async function streamResponse(providerRes, clientRes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        // Copy status and headers
+        clientRes.writeHead(providerRes.statusCode || 200, providerRes.headers);
+        providerRes.on('data', (chunk) => {
+            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();
+        });
+    });
+}
+//# sourceMappingURL=stream.js.map

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

@@ -0,0 +1,21 @@
+import type { StorageAdapter, Chunk, ScoredChunk, SearchOptions, Exchange } from './types.js';
+export declare class LanceDBAdapter implements StorageAdapter {
+    private basePath;
+    name: string;
+    private db;
+    private chunksTable;
+    private logsDir;
+    private dbPath;
+    constructor(basePath?: 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>;
+}