smartcontext-proxy 0.1.0

package/dist/test/proxy.test.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_http_1 = __importDefault(require("node:http"));
+const server_js_1 = require("../proxy/server.js");
+const auto_detect_js_1 = require("../config/auto-detect.js");
+/** Create a mock LLM provider server */
+function createMockProvider(port) {
+    return new Promise((resolve) => {
+        const server = node_http_1.default.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, options, body) {
+    return new Promise((resolve, reject) => {
+        const req = node_http_1.default.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();
+    });
+}
+(0, node_test_1.describe)('SmartContext Proxy', () => {
+    let proxy;
+    let mockServer;
+    const PROXY_PORT = 14800;
+    const MOCK_PORT = 14801;
+    (0, node_test_1.before)(async () => {
+        // Start mock provider
+        mockServer = await createMockProvider(MOCK_PORT);
+        // Start proxy pointing to mock provider
+        const config = (0, auto_detect_js_1.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 server_js_1.ProxyServer(config);
+        await proxy.start();
+    });
+    (0, node_test_1.after)(async () => {
+        await proxy.stop();
+        mockServer.close();
+    });
+    (0, node_test_1.it)('health endpoint returns ok', async () => {
+        const res = await httpRequest(`http://127.0.0.1:${PROXY_PORT}/health`, { method: 'GET' });
+        node_assert_1.default.strictEqual(res.status, 200);
+        const data = JSON.parse(res.body);
+        node_assert_1.default.strictEqual(data.ok, true);
+    });
+    (0, node_test_1.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' },
+        }, '{}');
+        node_assert_1.default.strictEqual(res.status, 404);
+    });
+    (0, node_test_1.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',
+        });
+        node_assert_1.default.strictEqual(res.status, 405);
+    });
+    (0, node_test_1.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);
+        node_assert_1.default.strictEqual(res.status, 200);
+        const data = JSON.parse(res.body);
+        node_assert_1.default.strictEqual(data.content[0].text, 'Hello from mock provider!');
+        node_assert_1.default.strictEqual(data.role, 'assistant');
+    });
+    (0, node_test_1.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);
+        node_assert_1.default.strictEqual(res.status, 200);
+        node_assert_1.default.ok(res.body.includes('Hello'));
+        node_assert_1.default.ok(res.body.includes('there'));
+        node_assert_1.default.ok(res.body.includes('message_stop'));
+    });
+    (0, node_test_1.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);
+        node_assert_1.default.strictEqual(res.status, 200);
+        const data = JSON.parse(res.body);
+        node_assert_1.default.ok(data.content);
+    });
+    (0, node_test_1.it)('auto-detect finds providers from config', () => {
+        const providers = proxy.getProviderNames();
+        node_assert_1.default.ok(providers.includes('anthropic'));
+        node_assert_1.default.ok(providers.includes('openai'));
+        node_assert_1.default.ok(providers.includes('ollama'));
+    });
+});
+//# sourceMappingURL=proxy.test.js.map

package/dist/ui/dashboard.d.ts

@@ -0,0 +1,2 @@
+import type { MetricsCollector } from '../metrics/collector.js';
+export declare function renderDashboard(metrics: MetricsCollector, paused: boolean): string;

package/dist/ui/dashboard.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDashboard = renderDashboard;
+function renderDashboard(metrics, paused) {
+    const stats = metrics.getStats();
+    const recent = metrics.getRecent(20);
+    const uptime = metrics.getUptime();
+    const uptimeStr = formatDuration(uptime);
+    const statusBadge = paused
+        ? '<span class="badge paused">PAUSED</span>'
+        : '<span class="badge running">RUNNING</span>';
+    const savingsAmount = estimateCostSaved(stats.totalOriginalTokens - stats.totalOptimizedTokens);
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>SmartContext Proxy</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif; background: #0f1117; color: #e1e4e8; }
+  .container { max-width: 1200px; margin: 0 auto; padding: 20px; }
+  header { display: flex; justify-content: space-between; align-items: center; padding: 16px 0; border-bottom: 1px solid #21262d; margin-bottom: 24px; }
+  h1 { font-size: 20px; font-weight: 600; }
+  h2 { font-size: 16px; font-weight: 600; margin-bottom: 12px; color: #8b949e; }
+  .badge { padding: 4px 12px; border-radius: 12px; font-size: 12px; font-weight: 600; text-transform: uppercase; }
+  .badge.running { background: #238636; color: #fff; }
+  .badge.paused { background: #d29922; color: #000; }
+  .controls { display: flex; gap: 8px; }
+  .btn { padding: 6px 16px; border-radius: 6px; border: 1px solid #30363d; background: #21262d; color: #e1e4e8; cursor: pointer; font-size: 13px; }
+  .btn:hover { background: #30363d; }
+  .btn.primary { background: #238636; border-color: #238636; }
+  .btn.warn { background: #d29922; border-color: #d29922; color: #000; }
+  .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 16px; margin-bottom: 24px; }
+  .card { background: #161b22; border: 1px solid #21262d; border-radius: 8px; padding: 20px; }
+  .card .value { font-size: 32px; font-weight: 700; color: #58a6ff; }
+  .card .label { font-size: 13px; color: #8b949e; margin-top: 4px; }
+  .card.savings .value { color: #3fb950; }
+  table { width: 100%; border-collapse: collapse; }
+  th, td { padding: 8px 12px; text-align: left; border-bottom: 1px solid #21262d; font-size: 13px; }
+  th { color: #8b949e; font-weight: 600; }
+  .mono { font-family: 'SF Mono', 'Fira Code', monospace; font-size: 12px; }
+  .savings-pct { color: #3fb950; font-weight: 600; }
+  .pass { color: #8b949e; }
+  .tab-bar { display: flex; gap: 0; border-bottom: 1px solid #21262d; margin-bottom: 16px; }
+  .tab { padding: 8px 16px; cursor: pointer; border-bottom: 2px solid transparent; color: #8b949e; font-size: 14px; }
+  .tab.active { color: #e1e4e8; border-bottom-color: #58a6ff; }
+  .tab-content { display: none; }
+  .tab-content.active { display: block; }
+  .refresh-note { font-size: 11px; color: #484f58; text-align: right; margin-top: 8px; }
+</style>
+</head>
+<body>
+<div class="container">
+  <header>
+    <h1>SmartContext Proxy ${statusBadge}</h1>
+    <div class="controls">
+      ${paused
+        ? '<button class="btn primary" onclick="api(\'/_sc/resume\')">Resume</button>'
+        : '<button class="btn warn" onclick="api(\'/_sc/pause\')">Pause</button>'}
+    </div>
+  </header>
+
+  <div class="grid">
+    <div class="card savings">
+      <div class="value">$${savingsAmount}</div>
+      <div class="label">Estimated Saved</div>
+    </div>
+    <div class="card">
+      <div class="value">${stats.totalRequests}</div>
+      <div class="label">Total Requests</div>
+    </div>
+    <div class="card">
+      <div class="value">${stats.totalSavingsPercent}%</div>
+      <div class="label">Avg Token Savings</div>
+    </div>
+    <div class="card">
+      <div class="value">${stats.avgLatencyOverheadMs}ms</div>
+      <div class="label">Avg Latency Overhead</div>
+    </div>
+  </div>
+
+  <div class="tab-bar">
+    <div class="tab active" onclick="switchTab('feed')">Live Feed</div>
+    <div class="tab" onclick="switchTab('providers')">By Provider</div>
+    <div class="tab" onclick="switchTab('models')">By Model</div>
+  </div>
+
+  <div id="tab-feed" class="tab-content active">
+    <h2>Recent Requests</h2>
+    <table>
+      <thead><tr><th>ID</th><th>Time</th><th>Provider/Model</th><th>Original</th><th>Optimized</th><th>Savings</th><th>Chunks</th><th>Latency</th></tr></thead>
+      <tbody>
+        ${recent.reverse().map((r) => `
+          <tr>
+            <td class="mono">#${r.id}</td>
+            <td class="mono">${new Date(r.timestamp).toLocaleTimeString()}</td>
+            <td>${r.provider}/${r.model}</td>
+            <td class="mono">${formatTokens(r.originalTokens)}</td>
+            <td class="mono">${formatTokens(r.optimizedTokens)}</td>
+            <td class="${r.passThrough ? 'pass' : 'savings-pct'}">${r.passThrough ? 'pass' : `-${r.savingsPercent}%`}</td>
+            <td class="mono">${r.chunksRetrieved}</td>
+            <td class="mono">${r.latencyOverheadMs}ms</td>
+          </tr>
+        `).join('')}
+      </tbody>
+    </table>
+  </div>
+
+  <div id="tab-providers" class="tab-content">
+    <h2>Savings by Provider</h2>
+    <table>
+      <thead><tr><th>Provider</th><th>Requests</th><th>Tokens Saved</th><th>Savings %</th></tr></thead>
+      <tbody>
+        ${Object.entries(stats.byProvider).map(([name, s]) => `
+          <tr>
+            <td>${name}</td>
+            <td class="mono">${s.requests}</td>
+            <td class="mono">${formatTokens(s.tokensSaved)}</td>
+            <td class="savings-pct">${s.savingsPercent}%</td>
+          </tr>
+        `).join('')}
+      </tbody>
+    </table>
+  </div>
+
+  <div id="tab-models" class="tab-content">
+    <h2>Savings by Model</h2>
+    <table>
+      <thead><tr><th>Model</th><th>Requests</th><th>Tokens Saved</th><th>Savings %</th></tr></thead>
+      <tbody>
+        ${Object.entries(stats.byModel).map(([name, s]) => `
+          <tr>
+            <td>${name}</td>
+            <td class="mono">${s.requests}</td>
+            <td class="mono">${formatTokens(s.tokensSaved)}</td>
+            <td class="savings-pct">${s.savingsPercent}%</td>
+          </tr>
+        `).join('')}
+      </tbody>
+    </table>
+  </div>
+
+  <div class="refresh-note">Uptime: ${uptimeStr} | Auto-refresh: 10s</div>
+</div>
+<script>
+function switchTab(name) {
+  document.querySelectorAll('.tab-content').forEach(t => t.classList.remove('active'));
+  document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+  document.getElementById('tab-' + name).classList.add('active');
+  event.target.classList.add('active');
+}
+async function api(path) {
+  await fetch(path, { method: 'POST' });
+  location.reload();
+}
+setTimeout(() => location.reload(), 10000);
+</script>
+</body>
+</html>`;
+}
+function formatTokens(n) {
+    if (n >= 1000000)
+        return `${(n / 1000000).toFixed(1)}M`;
+    if (n >= 1000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return String(n);
+}
+function formatDuration(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    if (s < 3600)
+        return `${Math.floor(s / 60)}m ${s % 60}s`;
+    return `${Math.floor(s / 3600)}h ${Math.floor((s % 3600) / 60)}m`;
+}
+/** Rough cost estimate based on Anthropic/OpenAI pricing */
+function estimateCostSaved(tokensSaved) {
+    // Assume avg $15/1M input tokens (Opus pricing)
+    const cost = (tokensSaved / 1000000) * 15;
+    return cost.toFixed(2);
+}
+//# sourceMappingURL=dashboard.js.map

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "smartcontext-proxy",
+  "version": "0.1.0",
+  "description": "Intelligent context window optimization proxy for LLM APIs",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "bin": {
+    "smartcontext-proxy": "dist/src/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "test": "node --test dist/src/test/*.test.js",
+    "lint": "tsc --noEmit"
+  },
+  "keywords": [
+    "llm",
+    "proxy",
+    "context",
+    "optimization",
+    "anthropic",
+    "openai",
+    "ollama"
+  ],
+  "author": "Emil Vrána",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "@lancedb/lancedb": "^0.27.1"
+  }
+}

package/src/config/auto-detect.ts

@@ -0,0 +1,51 @@
+import type { ProviderConfig, SmartContextConfig } from './schema.js';
+import { DEFAULT_CONFIG } from './defaults.js';
+
+const PROVIDER_ENV_MAP: Record<string, { envKey: string; baseUrl: string }> = {
+  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',
+  },
+};
+
+export function detectProviders(): Record<string, ProviderConfig> {
+  const providers: Record<string, ProviderConfig> = {};
+
+  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;
+}
+
+export function buildConfig(overrides?: Partial<SmartContextConfig>): SmartContextConfig {
+  const providers = detectProviders();
+
+  return {
+    ...DEFAULT_CONFIG,
+    providers,
+    ...overrides,
+    proxy: { ...DEFAULT_CONFIG.proxy, ...overrides?.proxy },
+    context: { ...DEFAULT_CONFIG.context, ...overrides?.context },
+    logging: { ...DEFAULT_CONFIG.logging, ...overrides?.logging },
+  };
+}

package/src/config/defaults.ts

@@ -0,0 +1,26 @@
+import type { SmartContextConfig } from './schema.js';
+
+export const DEFAULT_CONFIG: SmartContextConfig = {
+  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,
+  },
+};

package/src/config/schema.ts

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

@@ -0,0 +1,126 @@
+import type { ScoredChunk } from '../storage/types.js';
+import type { CanonicalMessage } from './canonical.js';
+import { getTextContent } from './canonical.js';
+import { estimateTokens } from './chunker.js';
+
+/** Known model context window sizes */
+const MODEL_CONTEXT_LIMITS: Record<string, number> = {
+  '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;
+
+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 function getModelContextLimit(model: string): number {
+  // 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.
+ */
+export function packContext(
+  systemPrompt: string | undefined,
+  messages: CanonicalMessage[],
+  retrievedChunks: ScoredChunk[],
+  model: string,
+  tier1Exchanges: number,
+  tier3Reserve: number,
+  responseReserve: number,
+): PackedContext {
+  const contextLimit = getModelContextLimit(model);
+
+  // Calculate original tokens
+  const originalTokens =
+    estimateTokens(systemPrompt || '') +
+    messages.reduce((sum, m) => sum + estimateTokens(getTextContent(m)), 0);
+
+  const systemPromptTokens = estimateTokens(systemPrompt || '');
+
+  // Extract Tier 1: last N exchanges (user+assistant pairs)
+  const tier1Messages: CanonicalMessage[] = [];
+  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 + estimateTokens(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: ScoredChunk[] = [];
+  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: BudgetAllocation = {
+    systemPromptTokens,
+    tier1Tokens,
+    tier2Budget,
+    tier3Reserve,
+    responseReserve,
+    totalAvailable,
+  };
+
+  return {
+    systemPrompt,
+    tier1Messages,
+    tier2Chunks,
+    tier3Summary,
+    allocation,
+    originalTokens,
+    optimizedTokens,
+    savingsPercent: originalTokens > 0
+      ? Math.round((1 - optimizedTokens / originalTokens) * 100)
+      : 0,
+  };
+}