smartcontext-proxy 0.1.0

package/dist/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/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/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/config/auto-detect.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderConfig, SmartContextConfig } from './schema.js';
+export declare function detectProviders(): Record<string, ProviderConfig>;
+export declare function buildConfig(overrides?: Partial<SmartContextConfig>): SmartContextConfig;

package/dist/src/config/auto-detect.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProviders = detectProviders;
+exports.buildConfig = buildConfig;
+const defaults_js_1 = require("./defaults.js");
+const PROVIDER_ENV_MAP = {
+    anthropic: {
+        envKey: 'ANTHROPIC_API_KEY',
+        baseUrl: 'https://api.anthropic.com',
+    },
+    openai: {
+        envKey: 'OPENAI_API_KEY',
+        baseUrl: 'https://api.openai.com',
+    },
+    google: {
+        envKey: 'GOOGLE_API_KEY',
+        baseUrl: 'https://generativelanguage.googleapis.com',
+    },
+    openrouter: {
+        envKey: 'OPENROUTER_API_KEY',
+        baseUrl: 'https://openrouter.ai/api',
+    },
+};
+function detectProviders() {
+    const providers = {};
+    for (const [name, { envKey, baseUrl }] of Object.entries(PROVIDER_ENV_MAP)) {
+        const apiKey = process.env[envKey];
+        if (apiKey) {
+            providers[name] = { apiKey, baseUrl };
+        }
+    }
+    // Ollama: detect by host, no API key needed
+    const ollamaHost = process.env['OLLAMA_HOST'] || 'http://localhost:11434';
+    providers['ollama'] = { apiKey: '', baseUrl: ollamaHost };
+    return providers;
+}
+function buildConfig(overrides) {
+    const providers = detectProviders();
+    return {
+        ...defaults_js_1.DEFAULT_CONFIG,
+        providers,
+        ...overrides,
+        proxy: { ...defaults_js_1.DEFAULT_CONFIG.proxy, ...overrides?.proxy },
+        context: { ...defaults_js_1.DEFAULT_CONFIG.context, ...overrides?.context },
+        logging: { ...defaults_js_1.DEFAULT_CONFIG.logging, ...overrides?.logging },
+    };
+}
+//# sourceMappingURL=auto-detect.js.map

package/dist/src/config/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { SmartContextConfig } from './schema.js';
+export declare const DEFAULT_CONFIG: SmartContextConfig;

package/dist/src/config/defaults.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.DEFAULT_CONFIG = {
+    proxy: {
+        port: 4800,
+        host: '127.0.0.1',
+    },
+    providers: {},
+    context: {
+        tier1_exchanges: 3,
+        tier2_max_chunks: 10,
+        tier2_min_score: 0.55,
+        tier3_token_reserve: 500,
+        recency_boost: 0.15,
+        filepath_boost: 0.20,
+        dedup_threshold: 0.92,
+        confidence_gate: 0.55,
+        response_reserve_tokens: 8192,
+    },
+    logging: {
+        level: 'info',
+        raw_logs: true,
+        metrics: true,
+        debug_headers: false,
+    },
+};
+//# sourceMappingURL=defaults.js.map

package/dist/src/config/schema.d.ts

@@ -0,0 +1,30 @@
+export interface SmartContextConfig {
+    proxy: {
+        port: number;
+        host: string;
+    };
+    providers: Record<string, ProviderConfig>;
+    context: ContextConfig;
+    logging: LoggingConfig;
+}
+export interface ProviderConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+export interface ContextConfig {
+    tier1_exchanges: number;
+    tier2_max_chunks: number;
+    tier2_min_score: number;
+    tier3_token_reserve: number;
+    recency_boost: number;
+    filepath_boost: number;
+    dedup_threshold: number;
+    confidence_gate: number;
+    response_reserve_tokens: number;
+}
+export interface LoggingConfig {
+    level: 'error' | 'warn' | 'info' | 'debug';
+    raw_logs: boolean;
+    metrics: boolean;
+    debug_headers: boolean;
+}

package/dist/src/config/schema.js

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

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

@@ -0,0 +1,25 @@
+import type { ScoredChunk } from '../storage/types.js';
+import type { CanonicalMessage } from './canonical.js';
+export interface BudgetAllocation {
+    systemPromptTokens: number;
+    tier1Tokens: number;
+    tier2Budget: number;
+    tier3Reserve: number;
+    responseReserve: number;
+    totalAvailable: number;
+}
+export interface PackedContext {
+    systemPrompt?: string;
+    tier1Messages: CanonicalMessage[];
+    tier2Chunks: ScoredChunk[];
+    tier3Summary?: string;
+    allocation: BudgetAllocation;
+    originalTokens: number;
+    optimizedTokens: number;
+    savingsPercent: number;
+}
+export declare function getModelContextLimit(model: string): number;
+/**
+ * Allocate token budget across tiers and pack context.
+ */
+export declare function packContext(systemPrompt: string | undefined, messages: CanonicalMessage[], retrievedChunks: ScoredChunk[], model: string, tier1Exchanges: number, tier3Reserve: number, responseReserve: number): PackedContext;

package/dist/src/context/budget.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelContextLimit = getModelContextLimit;
+exports.packContext = packContext;
+const canonical_js_1 = require("./canonical.js");
+const chunker_js_1 = require("./chunker.js");
+/** Known model context window sizes */
+const MODEL_CONTEXT_LIMITS = {
+    'claude-opus-4-6': 200000,
+    'claude-sonnet-4-6': 200000,
+    'claude-haiku-4-5-20251001': 200000,
+    'claude-3-5-sonnet-20241022': 200000,
+    'gpt-4o': 128000,
+    'gpt-4o-mini': 128000,
+    'gpt-4-turbo': 128000,
+    'o1': 200000,
+    'o1-mini': 128000,
+};
+const DEFAULT_CONTEXT_LIMIT = 128000;
+function getModelContextLimit(model) {
+    // Check exact match
+    if (MODEL_CONTEXT_LIMITS[model])
+        return MODEL_CONTEXT_LIMITS[model];
+    // Check prefix match
+    for (const [key, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
+        if (model.startsWith(key))
+            return limit;
+    }
+    return DEFAULT_CONTEXT_LIMIT;
+}
+/**
+ * Allocate token budget across tiers and pack context.
+ */
+function packContext(systemPrompt, messages, retrievedChunks, model, tier1Exchanges, tier3Reserve, responseReserve) {
+    const contextLimit = getModelContextLimit(model);
+    // Calculate original tokens
+    const originalTokens = (0, chunker_js_1.estimateTokens)(systemPrompt || '') +
+        messages.reduce((sum, m) => sum + (0, chunker_js_1.estimateTokens)((0, canonical_js_1.getTextContent)(m)), 0);
+    const systemPromptTokens = (0, chunker_js_1.estimateTokens)(systemPrompt || '');
+    // Extract Tier 1: last N exchanges (user+assistant pairs)
+    const tier1Messages = [];
+    let exchangeCount = 0;
+    for (let i = messages.length - 1; i >= 0 && exchangeCount < tier1Exchanges; i--) {
+        tier1Messages.unshift(messages[i]);
+        if (messages[i].role === 'user')
+            exchangeCount++;
+    }
+    const tier1Tokens = tier1Messages.reduce((sum, m) => sum + (0, chunker_js_1.estimateTokens)((0, canonical_js_1.getTextContent)(m)), 0);
+    // Calculate available budget for Tier 2
+    const totalAvailable = contextLimit - systemPromptTokens - responseReserve;
+    const tier2Budget = Math.max(0, totalAvailable - tier1Tokens - tier3Reserve);
+    // Pack Tier 2 chunks greedily by score
+    const tier2Chunks = [];
+    let tier2Used = 0;
+    for (const chunk of retrievedChunks) {
+        if (tier2Used + chunk.metadata.tokenCount <= tier2Budget) {
+            tier2Chunks.push(chunk);
+            tier2Used += chunk.metadata.tokenCount;
+        }
+    }
+    // Tier 3: summary placeholder (will be filled by summary system later)
+    const tier3Summary = undefined;
+    const optimizedTokens = systemPromptTokens + tier1Tokens + tier2Used;
+    const allocation = {
+        systemPromptTokens,
+        tier1Tokens,
+        tier2Budget,
+        tier3Reserve,
+        responseReserve,
+        totalAvailable,
+    };
+    return {
+        systemPrompt,
+        tier1Messages,
+        tier2Chunks,
+        tier3Summary,
+        allocation,
+        originalTokens,
+        optimizedTokens,
+        savingsPercent: originalTokens > 0
+            ? Math.round((1 - optimizedTokens / originalTokens) * 100)
+            : 0,
+    };
+}
+//# sourceMappingURL=budget.js.map

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

@@ -0,0 +1,39 @@
+export interface ContentBlock {
+    type: 'text' | 'image' | 'tool_use' | 'tool_result';
+    text?: string;
+    [key: string]: unknown;
+}
+export interface CanonicalMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | ContentBlock[];
+    timestamp?: number;
+    metadata?: {
+        provider?: string;
+        model?: string;
+        tokens?: number;
+        files?: string[];
+        tools?: string[];
+        sessionId?: string;
+    };
+}
+export interface CanonicalRequest {
+    messages: CanonicalMessage[];
+    systemPrompt?: string;
+    model: string;
+    stream: boolean;
+    maxTokens?: number;
+    temperature?: number;
+    tools?: unknown[];
+    rawHeaders: Record<string, string>;
+    providerAuth: string;
+}
+export interface CanonicalResponse {
+    content: string | ContentBlock[];
+    model: string;
+    stopReason?: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export declare function getTextContent(msg: CanonicalMessage): string;

package/dist/src/context/canonical.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTextContent = getTextContent;
+function getTextContent(msg) {
+    if (typeof msg.content === 'string')
+        return msg.content;
+    return msg.content
+        .filter((b) => b.type === 'text' && b.text)
+        .map((b) => b.text)
+        .join('\n');
+}
+//# sourceMappingURL=canonical.js.map

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

@@ -0,0 +1,9 @@
+import type { CanonicalMessage } from './canonical.js';
+import type { Chunk } from '../storage/types.js';
+export declare function estimateTokens(text: string): number;
+/**
+ * Chunk a conversation into indexable units.
+ * Each chunk = one user-assistant exchange pair.
+ * Long responses are split at paragraph boundaries.
+ */
+export declare function chunkConversation(messages: CanonicalMessage[], sessionId: string, baseTimestamp?: number): Chunk[];