@relayplane/proxy 1.8.34 → 1.8.37

package/dist/standalone-proxy.js

@@ -71,6 +71,7 @@ const path = __importStar(require("node:path"));
 const core_1 = require("@relayplane/core");
 const model_suggestions_js_1 = require("./utils/model-suggestions.js");
 const telemetry_js_1 = require("./telemetry.js");
+const lifecycle_telemetry_js_1 = require("./lifecycle-telemetry.js");
 const config_js_1 = require("./config.js");
 const index_js_1 = require("./mesh/index.js");
 const response_cache_js_1 = require("./response-cache.js");
@@ -93,6 +94,7 @@ const estimateRateMap = new Map();
 // Without this, IPs that make one request and disappear stay in the map forever.
 setInterval(() => (0, estimate_js_1.purgeExpiredRateLimitEntries)(estimateRateMap, Date.now()), 5 * 60 * 1000);
 const osmosis_store_js_1 = require("./osmosis-store.js");
+const session_tracker_js_1 = require("./session-tracker.js");
 const PROXY_VERSION = (() => {
     try {
         const pkgPath = path.join(__dirname, '..', 'package.json');
@@ -391,6 +393,10 @@ function sendCloudTelemetry(taskType, model, tokensIn, tokensOut, latencyMs, suc
         setImmediate(() => (0, signup_nudge_js_1.checkAndShowNudge)());
         // Star nudge fires at 50 requests (separate from signup nudge at 100)
         setImmediate(() => (0, star_nudge_js_1.checkAndShowStarNudge)());
+        // Lifecycle event: fire proxy.activated once on first successful request
+        if (success) {
+            setImmediate(() => (0, lifecycle_telemetry_js_1.maybeFireActivated)());
+        }
     }
     catch {
         // Telemetry should never break the proxy
@@ -2553,6 +2559,9 @@ td{padding:8px 12px;border-bottom:1px solid #111318}
 <table><thead><tr><th>Agent</th><th>Requests</th><th>Total Cost</th><th>Last Active</th><th></th></tr></thead><tbody id="agents"></tbody></table></div>
 <div class="section"><h2>Provider Status</h2><div class="prov" id="providers"></div></div>
 <div class="section collapsible collapsed"><h2>Learning</h2><div id="learning-panel" style="display:flex;flex-direction:column;gap:12px"><div id="learning-stats" style="display:flex;gap:12px;flex-wrap:wrap"></div><div id="learning-recent"></div><div style="margin-top:8px;padding:10px 14px;background:#0f1720;border:1px solid #1e3a5f;border-radius:8px;font-size:.8rem;color:#60a5fa">Network: Join the network to share with 1,000+ agent installations &rarr; <a href="https://relayplane.com/pricing" style="color:#34d399">Upgrade</a></div></div></div>
+<div class="section collapsible collapsed" id="sessions-section"><h2>Sessions <span id="sessionsLabel" style="font-size:.75rem;color:#64748b;font-weight:400">(last 7d)</span></h2>
+<table><thead><tr><th>Session ID</th><th>Source</th><th>Started</th><th>Duration</th><th>Requests</th><th>Tokens In</th><th>Tokens Out</th><th>Cost</th><th>Status</th></tr></thead><tbody id="sessions"></tbody></table>
+<div id="sessions-upsell" style="display:none;margin-top:12px;padding:10px 14px;background:#1a1020;border:1px solid #7c3aed55;border-radius:8px;font-size:.8rem;color:#a78bfa">3+ sessions totalling over $2 this week — <a href="https://relayplane.com/pricing" style="color:#34d399">Upgrade to Pro</a> for full session analytics &amp; budget controls.</div></div>
 <div class="section"><h2>Recent Runs <span id="historyLabel" style="font-size:.75rem;color:#64748b;font-weight:400">(7d window, history-capped)</span></h2>
 <table><thead><tr><th>Time</th><th>Agent</th><th>Model</th><th class="col-tt">Task Type</th><th class="col-cx">Complexity</th><th>Tokens In</th><th>Tokens Out</th><th class="col-cache">Cache Create</th><th class="col-cache">Cache Read</th><th>Cost</th><th>Latency</th><th>Status</th></tr></thead><tbody id="runs"></tbody></table></div>
 <script>
@@ -2561,6 +2570,30 @@ document.querySelectorAll('.section.collapsible h2').forEach(h2=>h2.addEventList
 function fmt(n,d=2){return typeof n==='number'?n.toFixed(d):'-'}
 function fmtTime(s){const d=new Date(s);return d.toLocaleTimeString()}
 function dur(s){const h=Math.floor(s/3600),m=Math.floor(s%3600/60);return h?h+'h '+m+'m':m+'m'}
+async function loadSessions(){
+  try{
+    const [sessR,activeR]=await Promise.all([
+      fetch('/v1/sessions?limit=20&days=7').then(r=>r.json()).catch(()=>({sessions:[]})),
+      fetch('/v1/sessions/active').then(r=>r.json()).catch(()=>({sessions:[]}))
+    ]);
+    const activeIds=new Set((activeR.sessions||[]).map(s=>s.id));
+    const sessions=sessR.sessions||[];
+    const el=$('sessions');
+    if(!el)return;
+    el.innerHTML=sessions.length?sessions.map(s=>{
+      const isActive=activeIds.has(s.id)||s.active;
+      const dur=s.duration_ms>0?Math.round(s.duration_ms/1000)+'s':'—';
+      const badge=isActive?'<span class="badge ok" style="font-size:.7rem">LIVE</span>':'<span style="color:#64748b;font-size:.75rem">idle</span>';
+      const srcBadge=s.session_source==='claude-code'?'<span style="color:#60a5fa;font-size:.75rem">claude-code</span>':'<span style="color:#94a3b8;font-size:.75rem">synthetic</span>';
+      const sid=s.id.length>20?s.id.slice(0,20)+'…':s.id;
+      return '<tr><td style="font-family:monospace;font-size:.8rem" title="'+s.id+'">'+sid+'</td><td>'+srcBadge+'</td><td>'+fmtTime(new Date(s.started_at).toISOString())+'</td><td>'+dur+'</td><td>'+s.request_count+'</td><td>'+(s.total_tokens_in||0)+'</td><td>'+(s.total_tokens_out||0)+'</td><td>$'+fmt(s.total_cost_usd,4)+'</td><td>'+badge+'</td></tr>';
+    }).join(''):'<tr><td colspan=9 style="color:#64748b">No sessions recorded yet</td></tr>';
+    // Pro upsell: 3+ sessions with total cost > $2 this week
+    const totalCost=sessions.reduce((s,r)=>s+(r.total_cost_usd||0),0);
+    const upsell=$('sessions-upsell');
+    if(upsell) upsell.style.display=(sessions.length>=3&&totalCost>2)?'block':'none';
+  }catch(e){console.error('sessions load error',e)}
+}
 async function load(){
   try{
     const [health,stats,runsR,sav,provH,agentsR]=await Promise.all([
@@ -2705,7 +2738,7 @@ async function loadLearning(){
     }
   }catch(e){console.error('learning load error',e)}
 }
-load();loadLearning();setInterval(load,5000);setInterval(loadLearning,30000);
+load();loadLearning();loadSessions();setInterval(load,5000);setInterval(loadLearning,30000);setInterval(loadSessions,10000);
 </script><footer style="text-align:center;padding:20px 0;color:#475569;font-size:.75rem;border-top:1px solid #1e293b;margin-top:20px">🔒 Request content stays on your machine. Never sent to cloud.</footer></body></html>`;
 }
 async function getKnowledgeStats() {
@@ -2861,6 +2894,8 @@ async function startProxy(config = {}) {
     // Check once at startup whether the nudges have already been shown
     (0, signup_nudge_js_1.initNudge)();
     (0, star_nudge_js_1.initStarNudge)();
+    // Lifecycle event: daily session heartbeat
+    setImmediate(() => (0, lifecycle_telemetry_js_1.maybeSendSessionHeartbeat)());
     // Flush history on shutdown
     const handleShutdown = () => {
         (0, agent_tracker_js_1.flushAgentRegistry)();
@@ -3299,6 +3334,136 @@ async function startProxy(config = {}) {
                 }
                 return;
             }
+            // === Budget endpoints ===
+            if (req.method === 'GET' && pathname === '/control/budget') {
+                const status = budgetManager.getStatus();
+                const cfg = budgetManager.getConfig();
+                const now = Date.now();
+                const weekCutoff = now - 7 * 86400000;
+                const monthCutoff = now - 30 * 86400000;
+                const weekCost = requestHistory
+                    .filter(r => new Date(r.timestamp).getTime() >= weekCutoff)
+                    .reduce((s, r) => s + r.costUsd, 0);
+                const monthCost = requestHistory
+                    .filter(r => new Date(r.timestamp).getTime() >= monthCutoff)
+                    .reduce((s, r) => s + r.costUsd, 0);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    today_usd: Math.round(status.dailySpend * 10000) / 10000,
+                    limit_usd: status.dailyLimit,
+                    pct_used: Math.round(status.dailyPercent * 10) / 10,
+                    remaining_usd: Math.max(0, Math.round((status.dailyLimit - status.dailySpend) * 10000) / 10000),
+                    this_week_usd: Math.round(weekCost * 10000) / 10000,
+                    this_month_usd: Math.round(monthCost * 10000) / 10000,
+                    enabled: cfg.enabled,
+                    on_breach: cfg.onBreach,
+                    alert_thresholds: cfg.alertThresholds,
+                    hourly_usd: Math.round(status.hourlySpend * 10000) / 10000,
+                    hourly_limit_usd: status.hourlyLimit,
+                    hourly_pct_used: Math.round(status.hourlyPercent * 10) / 10,
+                    breached: status.breached,
+                    breach_type: status.breachType,
+                }));
+                return;
+            }
+            if (req.method === 'POST' && pathname === '/control/budget/set') {
+                try {
+                    const body = await readJsonBody(req);
+                    const amount = Number(body.dailyUsd);
+                    if (!body.dailyUsd || isNaN(amount) || amount <= 0) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'dailyUsd must be a positive number' }));
+                        return;
+                    }
+                    budgetManager.setLimits({ dailyUsd: amount });
+                    budgetManager.updateConfig({ enabled: true });
+                    proxyConfig = normalizeProxyConfig({
+                        ...proxyConfig,
+                        budget: { ...proxyConfig.budget, dailyUsd: amount, enabled: true },
+                    });
+                    await saveProxyConfig(configPath, proxyConfig);
+                    startConfigWatcher();
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, dailyUsd: amount }));
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+                return;
+            }
+            if (req.method === 'POST' && pathname === '/control/budget/set-alert') {
+                try {
+                    const body = await readJsonBody(req);
+                    const pct = Number(body.threshold);
+                    if (!body.threshold || isNaN(pct) || pct <= 0 || pct > 100) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'threshold must be 1-100' }));
+                        return;
+                    }
+                    const current = budgetManager.getConfig();
+                    const thresholds = [...new Set([...current.alertThresholds, pct])].sort((a, b) => a - b);
+                    budgetManager.updateConfig({ alertThresholds: thresholds });
+                    proxyConfig = normalizeProxyConfig({
+                        ...proxyConfig,
+                        budget: { ...proxyConfig.budget, alertThresholds: thresholds },
+                    });
+                    await saveProxyConfig(configPath, proxyConfig);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, alertThresholds: thresholds }));
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+                return;
+            }
+            if (req.method === 'POST' && pathname === '/control/budget/reset') {
+                budgetManager.reset();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, message: 'Daily spend counter reset' }));
+                return;
+            }
+            if (req.method === 'POST' && pathname === '/control/model') {
+                try {
+                    const body = await readJsonBody(req);
+                    if (!body.model) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'model required' }));
+                        return;
+                    }
+                    const previousRouting = proxyConfig.routing;
+                    const target = body.model;
+                    // Update all complexity tiers to the requested model
+                    proxyConfig = normalizeProxyConfig({
+                        ...proxyConfig,
+                        routing: {
+                            ...proxyConfig.routing,
+                            complexity: {
+                                enabled: proxyConfig.routing?.complexity?.enabled ?? true,
+                                simple: target,
+                                moderate: target,
+                                complex: target,
+                            },
+                        },
+                    });
+                    await saveProxyConfig(configPath, proxyConfig);
+                    startConfigWatcher();
+                    const prevModel = previousRouting?.complexity?.complex ?? previousRouting?.complexity?.moderate ?? 'unknown';
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        switched: true,
+                        previous: prevModel,
+                        current: target,
+                        reason: body.reason ?? '',
+                    }));
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+                return;
+            }
         }
         if (req.method === 'POST' && pathname === '/control/kill') {
             try {
@@ -3670,6 +3835,36 @@ async function startProxy(config = {}) {
             }
             return;
         }
+        // === Session Intelligence endpoints ===
+        if (req.method === 'GET' && pathname === '/v1/sessions') {
+            const queryString = url.includes('?') ? url.split('?')[1] ?? '' : '';
+            const params = new URLSearchParams(queryString);
+            const limit = Math.min(parseInt(params.get('limit') || '20', 10), 100);
+            const days = parseInt(params.get('days') || '7', 10);
+            const sessions = (0, session_tracker_js_1.getSessions)({ limit, days });
+            const now = Date.now();
+            const activeCutoff = now - 5 * 60 * 1000;
+            const result = sessions.map(s => ({
+                ...s,
+                active: s.last_seen_at >= activeCutoff,
+                duration_ms: s.last_seen_at - s.started_at,
+            }));
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ sessions: result, total: result.length }));
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/v1/sessions/active') {
+            const active = (0, session_tracker_js_1.getActiveSessions)();
+            const now = Date.now();
+            const result = active.map(s => ({
+                ...s,
+                active: true,
+                duration_ms: s.last_seen_at - s.started_at,
+            }));
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ sessions: result, total: result.length }));
+            return;
+        }
         // Extract auth context from incoming request
         const ctx = extractRequestContext(req);
         const anthropicEnvKey = process.env['ANTHROPIC_API_KEY'];
@@ -3709,6 +3904,8 @@ async function startProxy(config = {}) {
                 res.end(JSON.stringify({ error: 'Invalid JSON' }));
                 return;
             }
+            // Extract session ID (X-Claude-Code-Session-Id or synthetic)
+            const { sessionId: nativeSessionId, sessionSource: nativeSessionSource } = (0, session_tracker_js_1.getSessionId)(req, requestBody['model']);
             // Extract agent fingerprint and explicit agent ID
             const nativeSystemPrompt = (0, agent_tracker_js_1.extractSystemPromptFromBody)(requestBody);
             const nativeExplicitAgentId = getHeaderValue(req, 'x-relayplane-agent') || undefined;
@@ -4253,6 +4450,8 @@ async function startProxy(config = {}) {
                 if (nativeAgentFingerprint && nativeAgentFingerprint !== 'unknown') {
                     (0, agent_tracker_js_1.updateAgentCost)(nativeAgentFingerprint, nativeCostUsd);
                 }
+                // ── Session Intelligence: upsert session record ──
+                (0, session_tracker_js_1.upsertSession)(nativeSessionId, nativeSessionSource, nativeCostUsd, nativeTokIn, nativeTokOut);
                 // ── Post-request: budget spend + anomaly detection ──
                 postRequestRecord(targetModel || requestedModel, nativeTokIn, nativeTokOut, nativeCostUsd);
                 if (recordTelemetry) {
@@ -4397,6 +4596,8 @@ async function startProxy(config = {}) {
             return;
         }
         const isStreaming = request.stream === true;
+        // Extract session ID for chat/completions
+        const { sessionId: chatSessionId, sessionSource: chatSessionSource } = (0, session_tracker_js_1.getSessionId)(req, request.model);
         // Extract agent fingerprint for chat/completions
         const chatSystemPrompt = (0, agent_tracker_js_1.extractSystemPromptFromBody)(request);
         const chatExplicitAgentId = getHeaderValue(req, 'x-relayplane-agent') || undefined;
@@ -4751,7 +4952,7 @@ async function startProxy(config = {}) {
         const startTime = Date.now();
         // Handle streaming vs non-streaming
         if (isStreaming) {
-            await handleStreamingRequest(res, request, targetProvider, targetModel, apiKey, ctx, relay, promptText, taskType, confidence, useCascade ? 'cascade' : routingMode, recordTelemetry, startTime, log, cooldownManager, cooldownsEnabled, complexity, chatCacheHash, chatCacheBypass, chatAgentFingerprint, chatExplicitAgentId);
+            await handleStreamingRequest(res, request, targetProvider, targetModel, apiKey, ctx, relay, promptText, taskType, confidence, useCascade ? 'cascade' : routingMode, recordTelemetry, startTime, log, cooldownManager, cooldownsEnabled, complexity, chatCacheHash, chatCacheBypass, chatAgentFingerprint, chatExplicitAgentId, chatSessionId, chatSessionSource);
         }
         else {
             if (useCascade && cascadeConfig) {
@@ -4794,6 +4995,7 @@ async function startProxy(config = {}) {
                     updateLastHistoryEntry(cascadeTokensIn, cascadeTokensOut, cascadeCost, chatCascadeRespModel, cascadeCacheCreation, cascadeCacheRead, chatAgentFingerprint, chatExplicitAgentId);
                     if (chatAgentFingerprint && chatAgentFingerprint !== 'unknown')
                         (0, agent_tracker_js_1.updateAgentCost)(chatAgentFingerprint, cascadeCost);
+                    (0, session_tracker_js_1.upsertSession)(chatSessionId, chatSessionSource, cascadeCost, cascadeTokensIn, cascadeTokensOut);
                     if (recordTelemetry) {
                         try {
                             const runResult = await relay.run({
@@ -4852,7 +5054,8 @@ async function startProxy(config = {}) {
                 }
             }
             else {
-                await handleNonStreamingRequest(res, request, targetProvider, targetModel, apiKey, ctx, relay, promptText, taskType, confidence, routingMode, recordTelemetry, startTime, log, cooldownManager, cooldownsEnabled, complexity, chatAgentFingerprint, chatExplicitAgentId, useAnthropicEnvKey);
+                await handleNonStreamingRequest(res, request, targetProvider, targetModel, apiKey, ctx, relay, promptText, taskType, confidence, routingMode, recordTelemetry, startTime, log, cooldownManager, cooldownsEnabled, complexity, chatAgentFingerprint, chatExplicitAgentId, useAnthropicEnvKey, // pass for cross-provider cascade API key resolution (GH #38)
+                chatSessionId, chatSessionSource);
             }
         }
     });
@@ -5017,7 +5220,7 @@ async function executeNonStreamingProviderRequest(request, targetProvider, targe
     }
     return { responseData, ok: true, status: 200 };
 }
-async function handleStreamingRequest(res, request, targetProvider, targetModel, apiKey, ctx, relay, promptText, taskType, confidence, routingMode, recordTelemetry, startTime, log, cooldownManager, cooldownsEnabled, complexity = 'simple', cacheHash, cacheBypass, agentFingerprint, agentId) {
+async function handleStreamingRequest(res, request, targetProvider, targetModel, apiKey, ctx, relay, promptText, taskType, confidence, routingMode, recordTelemetry, startTime, log, cooldownManager, cooldownsEnabled, complexity = 'simple', cacheHash, cacheBypass, agentFingerprint, agentId, sessionId, sessionSource) {
     let providerResponse;
     try {
         switch (targetProvider) {
@@ -5226,6 +5429,8 @@ async function handleStreamingRequest(res, request, targetProvider, targetModel,
     updateLastHistoryEntry(streamTokensIn, streamTokensOut, streamCost, undefined, streamCacheCreation || undefined, streamCacheRead || undefined, agentFingerprint, agentId);
     if (agentFingerprint && agentFingerprint !== 'unknown')
         (0, agent_tracker_js_1.updateAgentCost)(agentFingerprint, streamCost);
+    if (sessionId && sessionSource)
+        (0, session_tracker_js_1.upsertSession)(sessionId, sessionSource, streamCost, streamTokensIn, streamTokensOut);
     // ── Post-request: budget spend + anomaly detection ──
     try {
         (0, budget_js_1.getBudgetManager)().recordSpend(streamCost, targetModel);
@@ -5263,7 +5468,7 @@ async function handleStreamingRequest(res, request, targetProvider, targetModel,
  */
 async function handleNonStreamingRequest(res, request, targetProvider, targetModel, apiKey, ctx, relay, promptText, taskType, confidence, routingMode, recordTelemetry, startTime, log, cooldownManager, cooldownsEnabled, complexity = 'simple', agentFingerprint, agentId, 
 /** Anthropic env API key — required for cross-provider cascade API key resolution (GH #38) */
-anthropicEnvKeyForCascade) {
+anthropicEnvKeyForCascade, sessionId, sessionSource) {
     let responseData;
     try {
         const result = await executeNonStreamingProviderRequest(request, targetProvider, targetModel, apiKey, ctx);
@@ -5360,6 +5565,8 @@ anthropicEnvKeyForCascade) {
     updateLastHistoryEntry(tokensIn, tokensOut, cost, nonStreamRespModel, cacheCreationTokens || undefined, cacheReadTokens || undefined, agentFingerprint, agentId);
     if (agentFingerprint && agentFingerprint !== 'unknown')
         (0, agent_tracker_js_1.updateAgentCost)(agentFingerprint, cost);
+    if (sessionId && sessionSource)
+        (0, session_tracker_js_1.upsertSession)(sessionId, sessionSource, cost, tokensIn, tokensOut);
     // ── Post-request: budget spend + anomaly detection ──
     try {
         (0, budget_js_1.getBudgetManager)().recordSpend(cost, targetModel);