smartcontext-proxy 0.1.0

package/dist/metrics/collector.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsCollector = void 0;
+class MetricsCollector {
+    metrics = [];
+    startTime = Date.now();
+    record(metric) {
+        this.metrics.push(metric);
+    }
+    getRecent(limit = 50) {
+        return this.metrics.slice(-limit);
+    }
+    getStats() {
+        const total = this.metrics.length;
+        if (total === 0) {
+            return {
+                totalRequests: 0,
+                totalOriginalTokens: 0,
+                totalOptimizedTokens: 0,
+                totalSavingsPercent: 0,
+                avgLatencyOverheadMs: 0,
+                avgChunksRetrieved: 0,
+                byProvider: {},
+                byModel: {},
+            };
+        }
+        let totalOriginal = 0;
+        let totalOptimized = 0;
+        let totalLatency = 0;
+        let totalChunks = 0;
+        const byProvider = {};
+        const byModel = {};
+        for (const m of this.metrics) {
+            totalOriginal += m.originalTokens;
+            totalOptimized += m.optimizedTokens;
+            totalLatency += m.latencyOverheadMs;
+            totalChunks += m.chunksRetrieved;
+            // By provider
+            if (!byProvider[m.provider])
+                byProvider[m.provider] = { requests: 0, tokensSaved: 0, savingsPercent: 0 };
+            byProvider[m.provider].requests++;
+            byProvider[m.provider].tokensSaved += m.originalTokens - m.optimizedTokens;
+            // By model
+            if (!byModel[m.model])
+                byModel[m.model] = { requests: 0, tokensSaved: 0, savingsPercent: 0 };
+            byModel[m.model].requests++;
+            byModel[m.model].tokensSaved += m.originalTokens - m.optimizedTokens;
+        }
+        // Calculate percentages
+        for (const stats of Object.values(byProvider)) {
+            stats.savingsPercent = totalOriginal > 0 ? Math.round((stats.tokensSaved / totalOriginal) * 100) : 0;
+        }
+        for (const stats of Object.values(byModel)) {
+            stats.savingsPercent = totalOriginal > 0 ? Math.round((stats.tokensSaved / totalOriginal) * 100) : 0;
+        }
+        return {
+            totalRequests: total,
+            totalOriginalTokens: totalOriginal,
+            totalOptimizedTokens: totalOptimized,
+            totalSavingsPercent: totalOriginal > 0 ? Math.round((1 - totalOptimized / totalOriginal) * 100) : 0,
+            avgLatencyOverheadMs: Math.round(totalLatency / total),
+            avgChunksRetrieved: Math.round(totalChunks / total * 10) / 10,
+            byProvider,
+            byModel,
+        };
+    }
+    getUptime() {
+        return Date.now() - this.startTime;
+    }
+}
+exports.MetricsCollector = MetricsCollector;
+//# sourceMappingURL=collector.js.map

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,15 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalRequest } from '../context/canonical.js';
+export declare class AnthropicAdapter 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/providers/anthropic.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicAdapter = void 0;
+class AnthropicAdapter {
+    baseUrl;
+    name = 'anthropic';
+    constructor(baseUrl = 'https://api.anthropic.com') {
+        this.baseUrl = baseUrl;
+    }
+    parseRequest(body, headers) {
+        const b = body;
+        const messages = [];
+        let systemPrompt;
+        // Extract system prompt
+        if (typeof b.system === 'string') {
+            systemPrompt = b.system;
+        }
+        else if (Array.isArray(b.system)) {
+            systemPrompt = b.system
+                .map((s) => s.text || '')
+                .join('\n');
+        }
+        // Convert messages
+        if (Array.isArray(b.messages)) {
+            for (const msg of b.messages) {
+                messages.push(this.parseMessage(msg));
+            }
+        }
+        return {
+            messages,
+            systemPrompt,
+            model: b.model || 'unknown',
+            stream: !!b.stream,
+            maxTokens: b.max_tokens,
+            temperature: b.temperature,
+            tools: b.tools,
+            rawHeaders: headers,
+            providerAuth: this.extractApiKey(headers),
+        };
+    }
+    serializeRequest(canonical) {
+        const body = {
+            model: canonical.model,
+            messages: canonical.messages.map((m) => this.serializeMessage(m)),
+            stream: canonical.stream,
+        };
+        if (canonical.systemPrompt) {
+            body.system = canonical.systemPrompt;
+        }
+        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/anthropic/v1/messages → https://api.anthropic.com/v1/messages
+        const stripped = originalPath.replace(/^\/v1\/anthropic/, '');
+        return `${this.baseUrl}${stripped}`;
+    }
+    extractApiKey(headers) {
+        return headers['x-api-key'] || '';
+    }
+    contentType() {
+        return 'application/json';
+    }
+    authHeaders(apiKey) {
+        return {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+        };
+    }
+    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 };
+                }
+                // Pass through tool_use, tool_result, image blocks as-is
+                return { ...block, type: block.type };
+            });
+        }
+        else {
+            content = '';
+        }
+        return {
+            role: role,
+            content,
+        };
+    }
+    serializeMessage(msg) {
+        return {
+            role: msg.role,
+            content: msg.content,
+        };
+    }
+}
+exports.AnthropicAdapter = AnthropicAdapter;
+//# sourceMappingURL=anthropic.js.map

package/dist/providers/google.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalRequest } from '../context/canonical.js';
+export declare class GoogleAdapter 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>;
+}

package/dist/providers/google.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAdapter = void 0;
+class GoogleAdapter {
+    baseUrl;
+    name = 'google';
+    constructor(baseUrl = 'https://generativelanguage.googleapis.com') {
+        this.baseUrl = baseUrl;
+    }
+    parseRequest(body, headers) {
+        // Stub: pass through as-is for Phase 1
+        const b = body;
+        return {
+            messages: [],
+            model: 'unknown',
+            stream: !!b.stream,
+            rawHeaders: headers,
+            providerAuth: this.extractApiKey(headers),
+        };
+    }
+    serializeRequest(canonical) {
+        // Stub: not implemented for Phase 1
+        return {};
+    }
+    forwardUrl(originalPath) {
+        const stripped = originalPath.replace(/^\/v1\/google/, '');
+        return `${this.baseUrl}${stripped}`;
+    }
+    extractApiKey(headers) {
+        return headers['x-goog-api-key'] || '';
+    }
+    contentType() {
+        return 'application/json';
+    }
+    authHeaders(apiKey) {
+        return { 'x-goog-api-key': apiKey };
+    }
+}
+exports.GoogleAdapter = GoogleAdapter;
+//# sourceMappingURL=google.js.map

package/dist/providers/ollama.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalRequest } from '../context/canonical.js';
+export declare class OllamaAdapter 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>;
+}

package/dist/providers/ollama.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaAdapter = void 0;
+class OllamaAdapter {
+    baseUrl;
+    name = 'ollama';
+    constructor(baseUrl = 'http://localhost:11434') {
+        this.baseUrl = baseUrl;
+    }
+    parseRequest(body, headers) {
+        const b = body;
+        const messages = [];
+        let systemPrompt;
+        if (Array.isArray(b.messages)) {
+            for (const msg of b.messages) {
+                if (msg.role === 'system') {
+                    systemPrompt = msg.content;
+                    continue;
+                }
+                messages.push({
+                    role: msg.role,
+                    content: msg.content || '',
+                });
+            }
+        }
+        return {
+            messages,
+            systemPrompt,
+            model: b.model || 'unknown',
+            stream: b.stream !== false, // Ollama streams by default
+            maxTokens: b.options ? b.options.num_predict : undefined,
+            temperature: b.options ? b.options.temperature : undefined,
+            rawHeaders: headers,
+            providerAuth: '',
+        };
+    }
+    serializeRequest(canonical) {
+        const messages = [];
+        if (canonical.systemPrompt) {
+            messages.push({ role: 'system', content: canonical.systemPrompt });
+        }
+        for (const msg of canonical.messages) {
+            messages.push({
+                role: msg.role,
+                content: typeof msg.content === 'string'
+                    ? msg.content
+                    : msg.content.filter((b) => b.type === 'text').map((b) => b.text || '').join('\n'),
+            });
+        }
+        const body = {
+            model: canonical.model,
+            messages,
+            stream: canonical.stream,
+        };
+        const options = {};
+        if (canonical.maxTokens)
+            options.num_predict = canonical.maxTokens;
+        if (canonical.temperature !== undefined)
+            options.temperature = canonical.temperature;
+        if (Object.keys(options).length > 0)
+            body.options = options;
+        return body;
+    }
+    forwardUrl(originalPath) {
+        // /v1/ollama/api/chat → http://localhost:11434/api/chat
+        const stripped = originalPath.replace(/^\/v1\/ollama/, '');
+        return `${this.baseUrl}${stripped}`;
+    }
+    extractApiKey(headers) {
+        return headers['authorization']?.replace(/^Bearer\s+/i, '') || '';
+    }
+    contentType() {
+        return 'application/json';
+    }
+    authHeaders(apiKey) {
+        if (!apiKey)
+            return {};
+        return { 'Authorization': `Bearer ${apiKey}` };
+    }
+}
+exports.OllamaAdapter = OllamaAdapter;
+//# sourceMappingURL=ollama.js.map

package/dist/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/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/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/providers/types.js

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

package/dist/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/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/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;
+}