context-doctor 0.2.0

package/dist/profile.js

@@ -0,0 +1,197 @@
+/**
+ * The profiler: turns a normalized conversation into a breakdown of where
+ * tokens go, plus a list of actionable findings ("what's eating my window").
+ */
+import { createHash } from "node:crypto";
+import { contextWindowFor, estimateTokens, MESSAGE_OVERHEAD_TOKENS, providerFor } from "./tokens.js";
+import { estimatedTtftSeconds, inputCostUsd, pricingFor } from "./pricing.js";
+function categoryOf(m) {
+    switch (m.kind) {
+        case "system": return "system";
+        case "user": return "user";
+        case "assistant": return "assistant";
+        case "tool_call": return "tool_calls";
+        case "tool_result": return "tool_results";
+        default: return "other";
+    }
+}
+function preview(text, len = 90) {
+    const clean = text.replace(/\s+/g, " ").trim();
+    return clean.length > len ? clean.slice(0, len) + "…" : clean;
+}
+function contentHash(text) {
+    return createHash("sha1").update(text.replace(/\s+/g, " ").trim()).digest("hex");
+}
+const BASE64_RE = /(?:data:[\w/+.-]+;base64,|[A-Za-z0-9+/]{500,}={0,2})/;
+export function profileConversation(conv, model) {
+    const perMessage = conv.messages.map((m) => ({
+        msg: m,
+        tokens: estimateTokens(m.text) + MESSAGE_OVERHEAD_TOKENS,
+    }));
+    const totalTokens = perMessage.reduce((sum, p) => sum + p.tokens, 0);
+    const categories = {
+        system: 0, user: 0, assistant: 0, tool_calls: 0, tool_results: 0, other: 0,
+    };
+    for (const p of perMessage)
+        categories[categoryOf(p.msg)] += p.tokens;
+    const findings = [];
+    // -- Large individual tool results ------------------------------------------
+    for (const p of perMessage) {
+        if (p.msg.kind === "tool_result" && p.tokens > 2000) {
+            findings.push({
+                id: "large_tool_result",
+                severity: p.tokens > 8000 ? "high" : "warn",
+                estSavings: Math.round(p.tokens * 0.8),
+                message: `Tool result at message #${p.msg.index}${p.msg.toolName ? ` (${p.msg.toolName})` : ""} is ~${p.tokens} tokens.`,
+                suggestion: "Truncate or summarize large tool outputs before they enter history; keep only the fields the model actually used.",
+                messages: [p.msg.index],
+            });
+        }
+    }
+    // -- Exact duplicate content ------------------------------------------------
+    const seen = new Map();
+    for (const p of perMessage) {
+        if (p.msg.text.length < 300)
+            continue; // small repeats are cheap
+        const h = contentHash(p.msg.text);
+        const first = seen.get(h);
+        if (first !== undefined) {
+            findings.push({
+                id: "duplicate_content",
+                severity: "warn",
+                estSavings: p.tokens - MESSAGE_OVERHEAD_TOKENS,
+                message: `Message #${p.msg.index} duplicates the content of message #${first} (~${p.tokens} tokens).`,
+                suggestion: "Replace repeated content with a short reference to the first occurrence.",
+                messages: [first, p.msg.index],
+            });
+        }
+        else {
+            seen.set(h, p.msg.index);
+        }
+    }
+    // -- Repeated identical tool calls ------------------------------------------
+    const callSeen = new Map();
+    for (const p of perMessage) {
+        if (p.msg.kind !== "tool_call" || !p.msg.toolCallText)
+            continue;
+        const key = contentHash(p.msg.toolCallText);
+        const list = callSeen.get(key) ?? [];
+        list.push(p.msg.index);
+        callSeen.set(key, list);
+    }
+    for (const [, idxs] of callSeen) {
+        if (idxs.length > 1) {
+            findings.push({
+                id: "repeated_tool_call",
+                severity: "info",
+                estSavings: 0,
+                message: `The same tool call (with identical arguments) appears ${idxs.length} times (messages #${idxs.join(", #")}).`,
+                suggestion: "Repeated identical calls usually mean the earlier result scrolled out of the model's attention — cache results or surface them in a compact recap instead of re-calling.",
+                messages: idxs,
+            });
+        }
+    }
+    // -- Base64 / binary blobs ---------------------------------------------------
+    for (const p of perMessage) {
+        if (BASE64_RE.test(p.msg.text)) {
+            findings.push({
+                id: "base64_blob",
+                severity: "high",
+                estSavings: Math.round(p.tokens * 0.9),
+                message: `Message #${p.msg.index} contains a base64/binary blob (~${p.tokens} tokens of mostly meaningless characters).`,
+                suggestion: "Never put base64 in text content — use the provider's file/image APIs or replace with a file reference.",
+                messages: [p.msg.index],
+            });
+        }
+    }
+    // -- Long history ------------------------------------------------------------
+    const turnCount = conv.messages.filter((m) => m.kind === "user" || m.kind === "assistant").length;
+    if (turnCount > 40) {
+        const olderHalf = perMessage.slice(0, Math.floor(perMessage.length / 2));
+        const olderTokens = olderHalf.reduce((s, p) => s + p.tokens, 0);
+        findings.push({
+            id: "long_history",
+            severity: "warn",
+            estSavings: Math.round(olderTokens * 0.7),
+            message: `Conversation has ${turnCount} turns; the older half holds ~${olderTokens} tokens.`,
+            suggestion: "Summarize the older half of the conversation into a compact recap and drop the raw turns (context-doctor optimize --strategy prune-history).",
+            messages: [],
+        });
+    }
+    // -- System prompt share -----------------------------------------------------
+    if (totalTokens > 0 && categories.system / totalTokens > 0.25 && categories.system > 2000) {
+        findings.push({
+            id: "large_system_prompt",
+            severity: "info",
+            estSavings: 0,
+            message: `System prompt is ~${categories.system} tokens (${Math.round((categories.system / totalTokens) * 100)}% of the context).`,
+            suggestion: "A big system prompt is fine IF it is stable — put it first and use prompt caching (Anthropic: cache_control; OpenAI: automatic prefix caching) so you stop paying full price for it every call.",
+            messages: [],
+        });
+    }
+    // -- Cache-friendly ordering (advisory) --------------------------------------
+    if (providerFor(model) === "anthropic" || providerFor(model) === "openai") {
+        findings.push({
+            id: "cache_ordering",
+            severity: "info",
+            estSavings: 0,
+            message: "Prompt caching only matches a byte-identical prefix.",
+            suggestion: "Keep stable content (system prompt, tool definitions, reference docs) at the start and never interleave it with per-request content — a single changed byte early in the prompt invalidates the cache for everything after it.",
+            messages: [],
+        });
+    }
+    // -- Window pressure ---------------------------------------------------------
+    const window = contextWindowFor(model);
+    const usagePct = window ? (totalTokens / window) * 100 : undefined;
+    if (usagePct !== undefined && usagePct > 70) {
+        findings.push({
+            id: "near_window_limit",
+            severity: usagePct > 90 ? "high" : "warn",
+            estSavings: 0,
+            message: `Context is at ~${usagePct.toFixed(0)}% of ${model}'s window.`,
+            suggestion: "Models degrade well before the hard limit (lost-in-the-middle). Compact now rather than when the request fails.",
+            messages: [],
+        });
+    }
+    const largestMessages = perMessage
+        .map((p) => ({
+        index: p.msg.index,
+        role: p.msg.role,
+        kind: p.msg.kind,
+        tokens: p.tokens,
+        preview: preview(p.msg.text),
+        toolName: p.msg.toolName,
+    }))
+        .sort((a, b) => b.tokens - a.tokens)
+        .slice(0, 5);
+    const severityRank = { high: 0, warn: 1, info: 2 };
+    findings.sort((a, b) => severityRank[a.severity] - severityRank[b.severity] || b.estSavings - a.estSavings);
+    const totalEstSavings = findings.reduce((s, f) => s + f.estSavings, 0);
+    const pricing = pricingFor(model);
+    let cost;
+    if (pricing) {
+        const perCallUsd = inputCostUsd(totalTokens, pricing);
+        const savingsPerCallUsd = inputCostUsd(totalEstSavings, pricing);
+        cost = {
+            perCallUsd,
+            per1kCallsUsd: perCallUsd * 1000,
+            savingsPerCallUsd,
+            savingsPer1kCallsUsd: savingsPerCallUsd * 1000,
+            ttftSeconds: estimatedTtftSeconds(totalTokens),
+            ttftSavedSeconds: estimatedTtftSeconds(totalEstSavings),
+        };
+    }
+    return {
+        totalTokens,
+        model,
+        contextWindow: window,
+        usagePct,
+        messageCount: conv.messages.length,
+        categories,
+        largestMessages,
+        findings,
+        totalEstSavings,
+        cost,
+        sourceFormat: conv.sourceFormat,
+    };
+}

package/dist/proxy.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Always-on optimization: a local reverse proxy that sits between your app
+ * and the Anthropic/OpenAI APIs. Every request's message history is optimized
+ * in flight (dedupe, trim stale tool results, strip base64) before being
+ * forwarded — no code changes in your app, just a base-URL env var:
+ *
+ *   ANTHROPIC_BASE_URL=http://localhost:8787        (Anthropic SDKs)
+ *   OPENAI_BASE_URL=http://localhost:8787/v1        (OpenAI SDKs)
+ *
+ * API keys pass through untouched in headers — the proxy stores nothing and
+ * talks only to the official upstream endpoints (overridable for testing).
+ * Streaming responses are piped through unchanged.
+ */
+import http from "node:http";
+import { OptimizeOptions } from "./optimize.js";
+export interface ProxyOptions extends OptimizeOptions {
+    port?: number;
+    anthropicUpstream?: string;
+    openaiUpstream?: string;
+}
+export interface ProxyStats {
+    startedAt: string;
+    requests: number;
+    optimizedRequests: number;
+    tokensBefore: number;
+    tokensAfter: number;
+    tokensSaved: number;
+    /** USD saved on input tokens, when the request's model has a known price. */
+    estUsdSaved: number;
+}
+export declare function startProxy(opts?: ProxyOptions): http.Server;

package/dist/proxy.js

@@ -0,0 +1,137 @@
+/**
+ * Always-on optimization: a local reverse proxy that sits between your app
+ * and the Anthropic/OpenAI APIs. Every request's message history is optimized
+ * in flight (dedupe, trim stale tool results, strip base64) before being
+ * forwarded — no code changes in your app, just a base-URL env var:
+ *
+ *   ANTHROPIC_BASE_URL=http://localhost:8787        (Anthropic SDKs)
+ *   OPENAI_BASE_URL=http://localhost:8787/v1        (OpenAI SDKs)
+ *
+ * API keys pass through untouched in headers — the proxy stores nothing and
+ * talks only to the official upstream endpoints (overridable for testing).
+ * Streaming responses are piped through unchanged.
+ */
+import http from "node:http";
+import { optimizeConversation } from "./optimize.js";
+import { formatTokens } from "./tokens.js";
+import { formatUsd, inputCostUsd, pricingFor } from "./pricing.js";
+/** Connection-level headers that must not be forwarded. */
+const SKIP_REQUEST_HEADERS = new Set(["host", "content-length", "connection", "transfer-encoding", "accept-encoding", "expect"]);
+const SKIP_RESPONSE_HEADERS = new Set(["content-length", "content-encoding", "transfer-encoding", "connection"]);
+function upstreamFor(url, opts) {
+    if (url.startsWith("/v1/messages"))
+        return opts.anthropicUpstream ?? "https://api.anthropic.com";
+    if (url.startsWith("/v1/chat/completions") || url.startsWith("/v1/responses") || url.startsWith("/v1/embeddings")) {
+        return opts.openaiUpstream ?? "https://api.openai.com";
+    }
+    return undefined;
+}
+export function startProxy(opts = {}) {
+    const port = opts.port ?? 8787;
+    const stats = {
+        startedAt: new Date().toISOString(),
+        requests: 0,
+        optimizedRequests: 0,
+        tokensBefore: 0,
+        tokensAfter: 0,
+        tokensSaved: 0,
+        estUsdSaved: 0,
+    };
+    const server = http.createServer(async (req, res) => {
+        const url = req.url ?? "/";
+        try {
+            if (url === "/health") {
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ ok: true, service: "context-doctor-proxy" }));
+                return;
+            }
+            if (url === "/stats") {
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ ...stats, estUsdSaved: Number(stats.estUsdSaved.toFixed(4)) }, null, 2));
+                return;
+            }
+            const upstreamBase = upstreamFor(url, opts);
+            if (!upstreamBase) {
+                res.statusCode = 404;
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ error: `context-doctor proxy: unsupported path ${url} (supported: /v1/messages, /v1/chat/completions, /v1/responses)` }));
+                return;
+            }
+            const chunks = [];
+            for await (const chunk of req)
+                chunks.push(chunk);
+            let body = Buffer.concat(chunks).toString("utf8");
+            // Optimize the message history in flight. Anything unparseable (or with
+            // no messages array, e.g. embeddings) passes through untouched.
+            stats.requests++;
+            let note = "passthrough";
+            if (req.method === "POST" && body) {
+                try {
+                    const result = optimizeConversation(body, opts);
+                    const saved = result.tokensBefore - result.tokensAfter;
+                    stats.tokensBefore += result.tokensBefore;
+                    stats.tokensAfter += result.tokensAfter;
+                    if (saved > 0) {
+                        body = JSON.stringify(result.conversation);
+                        stats.optimizedRequests++;
+                        stats.tokensSaved += saved;
+                        const pricing = pricingFor(result.conversation?.model);
+                        if (pricing)
+                            stats.estUsdSaved += inputCostUsd(saved, pricing);
+                    }
+                    note = saved > 0
+                        ? `optimized ${formatTokens(result.tokensBefore)} → ${formatTokens(result.tokensAfter)} tokens (${result.applied.length} changes)`
+                        : "clean (nothing to save)";
+                }
+                catch {
+                    /* not a conversation payload — forward as-is */
+                }
+            }
+            const headers = {};
+            for (const [key, value] of Object.entries(req.headers)) {
+                if (!SKIP_REQUEST_HEADERS.has(key.toLowerCase()) && typeof value === "string")
+                    headers[key] = value;
+            }
+            const upstreamStart = Date.now();
+            const upstream = await fetch(upstreamBase + url, {
+                method: req.method ?? "POST",
+                headers,
+                body: req.method === "GET" || req.method === "HEAD" ? undefined : body,
+            });
+            console.error(`[context-doctor] ${req.method} ${url} → ${upstream.status} in ${Date.now() - upstreamStart}ms | ${note}` +
+                (stats.tokensSaved > 0 ? ` | session total: ${formatTokens(stats.tokensSaved)} tokens ≈ ${formatUsd(stats.estUsdSaved)} saved` : ""));
+            res.statusCode = upstream.status;
+            upstream.headers.forEach((value, key) => {
+                if (!SKIP_RESPONSE_HEADERS.has(key))
+                    res.setHeader(key, value);
+            });
+            if (upstream.body) {
+                // Pipe through chunk-by-chunk so SSE streaming works unchanged.
+                const reader = upstream.body.getReader();
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    res.write(value);
+                }
+            }
+            res.end();
+        }
+        catch (e) {
+            console.error(`[context-doctor] error on ${url}: ${e.message}`);
+            if (!res.headersSent) {
+                res.statusCode = 502;
+                res.setHeader("content-type", "application/json");
+            }
+            res.end(JSON.stringify({ error: `context-doctor proxy: ${e.message}` }));
+        }
+    });
+    server.listen(port, () => {
+        console.error(`context-doctor proxy listening on http://localhost:${port}`);
+        console.error(`  Anthropic apps/SDKs: export ANTHROPIC_BASE_URL=http://localhost:${port}`);
+        console.error(`  OpenAI apps/SDKs:    export OPENAI_BASE_URL=http://localhost:${port}/v1`);
+        console.error(`  Every request's context is optimized in flight; savings are logged here.`);
+        console.error(`  Cumulative savings: http://localhost:${port}/stats`);
+    });
+    return server;
+}

package/dist/report.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Render a ContextProfile as a readable terminal/markdown report.
+ * Plain text with ASCII bars — no color deps, so output pastes cleanly
+ * anywhere (terminals, issues, chat).
+ */
+import { ContextProfile } from "./profile.js";
+export declare function renderProfile(profile: ContextProfile): string;

package/dist/report.js

@@ -0,0 +1,82 @@
+/**
+ * Render a ContextProfile as a readable terminal/markdown report.
+ * Plain text with ASCII bars — no color deps, so output pastes cleanly
+ * anywhere (terminals, issues, chat).
+ */
+import { formatTokens } from "./tokens.js";
+import { formatUsd } from "./pricing.js";
+const CATEGORY_LABELS = {
+    system: "System prompt",
+    user: "User messages",
+    assistant: "Assistant replies",
+    tool_calls: "Tool calls",
+    tool_results: "Tool results",
+    other: "Other",
+};
+const SEVERITY_MARK = { high: "✖", warn: "▲", info: "ℹ" };
+function bar(fraction, width = 28) {
+    const filled = Math.round(fraction * width);
+    return "█".repeat(filled) + "░".repeat(width - filled);
+}
+export function renderProfile(profile) {
+    const lines = [];
+    const p = profile;
+    lines.push("CONTEXT DOCTOR — profile");
+    lines.push("═".repeat(56));
+    lines.push(`Total: ~${formatTokens(p.totalTokens)} tokens across ${p.messageCount} messages (${p.sourceFormat} format)`);
+    if (p.model) {
+        const windowNote = p.contextWindow
+            ? ` of ${formatTokens(p.contextWindow)} window (${p.usagePct.toFixed(1)}%)`
+            : " (unknown window size)";
+        lines.push(`Model: ${p.model}${windowNote}`);
+    }
+    if (p.cost) {
+        lines.push(`Cost:  ~${formatUsd(p.cost.perCallUsd)} input per call · ~${formatUsd(p.cost.per1kCallsUsd)} per 1k calls · ` +
+            `~${p.cost.ttftSeconds.toFixed(1)}s of latency per call (estimates)`);
+    }
+    lines.push("");
+    // Category breakdown, largest first
+    lines.push("Where the tokens go");
+    lines.push("─".repeat(56));
+    const cats = Object.entries(p.categories)
+        .filter(([, t]) => t > 0)
+        .sort((a, b) => b[1] - a[1]);
+    const maxLabel = Math.max(...cats.map(([c]) => CATEGORY_LABELS[c].length));
+    for (const [cat, tokens] of cats) {
+        const frac = p.totalTokens > 0 ? tokens / p.totalTokens : 0;
+        lines.push(`${CATEGORY_LABELS[cat].padEnd(maxLabel)}  ${bar(frac)} ${String(Math.round(frac * 100)).padStart(3)}%  ~${formatTokens(tokens)}`);
+    }
+    lines.push("");
+    // Largest messages
+    lines.push("Largest messages");
+    lines.push("─".repeat(56));
+    for (const m of p.largestMessages) {
+        const label = m.toolName ? `${m.kind}:${m.toolName}` : m.kind;
+        lines.push(`  #${m.index} [${label}] ~${formatTokens(m.tokens)}  ${m.preview}`);
+    }
+    lines.push("");
+    // Findings
+    if (p.findings.length > 0) {
+        lines.push(`Findings (${p.findings.length})`);
+        lines.push("─".repeat(56));
+        for (const f of p.findings) {
+            const savings = f.estSavings > 0 ? ` [save ~${formatTokens(f.estSavings)}]` : "";
+            lines.push(`${SEVERITY_MARK[f.severity]} ${f.message}${savings}`);
+            lines.push(`   → ${f.suggestion}`);
+        }
+        lines.push("");
+        if (p.totalEstSavings > 0) {
+            const pct = p.totalTokens > 0 ? Math.round((p.totalEstSavings / p.totalTokens) * 100) : 0;
+            let recovery = `Potential recovery: ~${formatTokens(p.totalEstSavings)} tokens (~${pct}% of context)`;
+            if (p.cost && p.cost.savingsPerCallUsd > 0) {
+                recovery += ` ≈ ${formatUsd(p.cost.savingsPer1kCallsUsd)} per 1k calls, ${p.cost.ttftSavedSeconds.toFixed(1)}s faster per call`;
+            }
+            lines.push(recovery);
+            lines.push(`Run \`context-doctor optimize <file>\` to apply the safe fixes automatically.`);
+        }
+    }
+    else {
+        lines.push("No issues found — this context is in good shape.");
+    }
+    return lines.join("\n");
+}

package/dist/session.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Claude Code session analyzer: profile the transcripts Claude Code writes to
+ * ~/.claude/projects/<project>/<session>.jsonl, answering "where did my
+ * tokens go?" for real sessions instead of hand-exported conversations.
+ *
+ * Transcript lines are JSON objects; the ones that matter here are
+ * `{type: "user"|"assistant", message: {role, content}, isSidechain, ...}`
+ * where `message` is in Anthropic Messages format. Everything else
+ * (titles, mode changes, hook records) is metadata and skipped.
+ */
+export interface SessionInfo {
+    path: string;
+    project: string;
+    modifiedAt: Date;
+    sizeBytes: number;
+}
+export interface ParsedSession {
+    /** Conversation JSON string in Anthropic-ish format, ready for parseConversation(). */
+    conversationJson: string;
+    title?: string;
+    model?: string;
+    messageCount: number;
+    path: string;
+}
+/** All session transcripts on this machine, newest first. */
+export declare function listSessions(limit?: number): SessionInfo[];
+export declare function parseSessionFile(path: string): ParsedSession;

package/dist/session.js

@@ -0,0 +1,80 @@
+/**
+ * Claude Code session analyzer: profile the transcripts Claude Code writes to
+ * ~/.claude/projects/<project>/<session>.jsonl, answering "where did my
+ * tokens go?" for real sessions instead of hand-exported conversations.
+ *
+ * Transcript lines are JSON objects; the ones that matter here are
+ * `{type: "user"|"assistant", message: {role, content}, isSidechain, ...}`
+ * where `message` is in Anthropic Messages format. Everything else
+ * (titles, mode changes, hook records) is metadata and skipped.
+ */
+import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function projectsDir() {
+    return join(homedir(), ".claude", "projects");
+}
+/** All session transcripts on this machine, newest first. */
+export function listSessions(limit = 20) {
+    const root = projectsDir();
+    if (!existsSync(root))
+        return [];
+    const sessions = [];
+    for (const project of readdirSync(root)) {
+        const dir = join(root, project);
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            continue; // not a directory
+        }
+        for (const file of entries) {
+            if (!file.endsWith(".jsonl"))
+                continue;
+            const path = join(dir, file);
+            const stat = statSync(path);
+            sessions.push({ path, project, modifiedAt: stat.mtime, sizeBytes: stat.size });
+        }
+    }
+    return sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime()).slice(0, limit);
+}
+export function parseSessionFile(path) {
+    const raw = readFileSync(path, "utf8");
+    const messages = [];
+    let title;
+    let model;
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        // Titles are metadata lines; the last one wins.
+        if (entry.type === "custom-title" && entry.customTitle)
+            title = entry.customTitle;
+        if (entry.type === "ai-title" && entry.aiTitle && !title)
+            title = entry.aiTitle;
+        if ((entry.type !== "user" && entry.type !== "assistant") || !entry.message)
+            continue;
+        if (entry.isSidechain)
+            continue; // subagent traffic has its own context window
+        const message = entry.message;
+        if (!message.role || message.content == null)
+            continue;
+        if (typeof message.model === "string")
+            model = message.model;
+        messages.push({ role: message.role, content: message.content });
+    }
+    return {
+        conversationJson: JSON.stringify({ messages }),
+        title,
+        model,
+        messageCount: messages.length,
+        path,
+    };
+}

package/dist/test/proxy.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Proxy end-to-end test against a mock upstream: verifies in-flight
+ * optimization, tool_result preservation, header passthrough, SSE-style
+ * streaming, and the /stats endpoint.
+ */
+export {};

package/dist/test/proxy.test.js

@@ -0,0 +1,77 @@
+/**
+ * Proxy end-to-end test against a mock upstream: verifies in-flight
+ * optimization, tool_result preservation, header passthrough, SSE-style
+ * streaming, and the /stats endpoint.
+ */
+import { test, after } from "node:test";
+import assert from "node:assert/strict";
+import http from "node:http";
+import { startProxy } from "../proxy.js";
+const bigTool = "row of data | ".repeat(2000);
+const doc = "TERMS: usage is billed monthly per seat with overage charged at cycle end. ".repeat(8);
+const payload = JSON.stringify({
+    model: "claude-sonnet-5",
+    max_tokens: 100,
+    system: "You are helpful.",
+    messages: [
+        { role: "user", content: "check the data\n" + doc },
+        { role: "assistant", content: [{ type: "tool_use", id: "t1", name: "query_db", input: { q: "select *" } }] },
+        { role: "user", content: [{ type: "tool_result", tool_use_id: "t1", content: bigTool }] },
+        { role: "assistant", content: "Done." },
+        { role: "user", content: "check the data\n" + doc },
+        ...Array.from({ length: 7 }, (_, i) => ({ role: "user", content: `follow-up ${i}` })),
+    ],
+});
+let received = "";
+let receivedApiKey;
+const upstream = http.createServer((req, res) => {
+    let body = "";
+    req.on("data", (c) => (body += c));
+    req.on("end", () => {
+        received = body;
+        receivedApiKey = req.headers["x-api-key"];
+        res.writeHead(200, { "content-type": "text/event-stream" });
+        res.write("event: message_start\ndata: {}\n\n");
+        res.write("event: message_stop\ndata: {}\n\n");
+        res.end();
+    });
+});
+await new Promise((r) => upstream.listen(0, r));
+const upstreamPort = upstream.address().port;
+const proxy = startProxy({ port: 0, anthropicUpstream: `http://localhost:${upstreamPort}` });
+await new Promise((r) => proxy.once("listening", () => r()));
+const proxyPort = proxy.address().port;
+after(() => {
+    proxy.close();
+    upstream.close();
+});
+test("proxy optimizes in flight and passes through auth + streaming", async () => {
+    const resp = await fetch(`http://localhost:${proxyPort}/v1/messages`, {
+        method: "POST",
+        headers: { "content-type": "application/json", "x-api-key": "sk-test-not-real", "anthropic-version": "2023-06-01" },
+        body: payload,
+    });
+    const respText = await resp.text();
+    assert.ok(received.length < payload.length, "upstream received a smaller body");
+    const parsed = JSON.parse(received);
+    const toolBlock = parsed.messages[2].content[0];
+    assert.equal(toolBlock.type, "tool_result");
+    assert.equal(toolBlock.tool_use_id, "t1");
+    assert.equal(parsed.model, "claude-sonnet-5");
+    assert.equal(receivedApiKey, "sk-test-not-real");
+    assert.equal(resp.status, 200);
+    assert.ok(respText.includes("message_start") && respText.includes("message_stop"), "SSE streamed through");
+});
+test("/stats reports cumulative savings with dollar estimate", async () => {
+    const stats = await (await fetch(`http://localhost:${proxyPort}/stats`)).json();
+    assert.equal(stats.requests, 1);
+    assert.equal(stats.optimizedRequests, 1);
+    assert.ok(stats.tokensSaved > 1000, `saved tokens tracked (${stats.tokensSaved})`);
+    assert.ok(stats.estUsdSaved > 0, "dollar savings estimated from the request's model");
+});
+test("unsupported paths get a clear 404, health stays up", async () => {
+    const notFound = await fetch(`http://localhost:${proxyPort}/v1/nope`, { method: "POST", body: "{}" });
+    assert.equal(notFound.status, 404);
+    const health = await (await fetch(`http://localhost:${proxyPort}/health`)).json();
+    assert.equal(health.ok, true);
+});

package/dist/test/smoke.test.d.ts

@@ -0,0 +1,2 @@
+/** Smoke tests: parse → profile → optimize roundtrip for both provider formats. */
+export {};