responses-proxy 0.1.0

package/dist/normalize-request.test.js

@@ -0,0 +1,277 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { normalizeResponsesRequestWithCache } from "./normalize-request.js";
+test("equivalent requests reuse the same static key despite tool order and volatile metadata", () => {
+    const first = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        input: [
+            { role: "assistant", content: "Existing context" },
+            { role: "user", content: "Latest user turn" },
+        ],
+        instructions: "You are a helpful agent.\n\nUse tools when needed.\n",
+        tools: [
+            {
+                type: "function",
+                name: "b_tool",
+                parameters: { type: "object", properties: { q: { type: "string" } } },
+            },
+            {
+                type: "function",
+                name: "a_tool",
+                parameters: { properties: { id: { type: "string" } }, type: "object" },
+            },
+        ],
+        metadata: {
+            request_id: "req-1",
+            trace_id: "trace-1",
+            tenant: "alpha",
+        },
+    }, {
+        promptCacheRedesignEnabled: true,
+    });
+    const second = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        input: [
+            { role: "assistant", content: "Existing context" },
+            { role: "user", content: "Latest user turn" },
+        ],
+        instructions: "You are a helpful agent.\nUse tools when needed.",
+        tools: [
+            {
+                type: "function",
+                name: "a_tool",
+                parameters: { type: "object", properties: { id: { type: "string" } } },
+            },
+            {
+                type: "function",
+                name: "b_tool",
+                parameters: { properties: { q: { type: "string" } }, type: "object" },
+            },
+        ],
+        metadata: {
+            tenant: "alpha",
+            request_id: "req-2",
+            trace_id: "trace-2",
+        },
+    }, {
+        promptCacheRedesignEnabled: true,
+    });
+    assert.equal(first.cacheLayout.familyId, second.cacheLayout.familyId);
+    assert.equal(first.cacheLayout.staticKey, second.cacheLayout.staticKey);
+});
+test("changing only the latest user turn changes request key but preserves static key", () => {
+    const baseRequest = {
+        model: "cx/gpt-5.4-xhigh",
+        input: [
+            { role: "assistant", content: "Earlier answer" },
+            { role: "user", content: "What is the plan?" },
+        ],
+        instructions: "You are a helpful agent.",
+    };
+    const first = normalizeResponsesRequestWithCache(baseRequest, {
+        promptCacheRedesignEnabled: true,
+    });
+    const second = normalizeResponsesRequestWithCache({
+        ...baseRequest,
+        input: [
+            { role: "assistant", content: "Earlier answer" },
+            { role: "user", content: "What is the revised plan?" },
+        ],
+    }, {
+        promptCacheRedesignEnabled: true,
+    });
+    assert.equal(first.cacheLayout.staticKey, second.cacheLayout.staticKey);
+    assert.notEqual(first.cacheLayout.requestKey, second.cacheLayout.requestKey);
+});
+test("changing previous response id does not fragment the static key", () => {
+    const baseRequest = {
+        model: "cx/gpt-5.4-xhigh",
+        input: [
+            { role: "assistant", content: "Earlier answer" },
+            { role: "user", content: "Continue" },
+        ],
+        instructions: "You are a helpful agent.",
+    };
+    const first = normalizeResponsesRequestWithCache({
+        ...baseRequest,
+        previous_response_id: "resp-1",
+    }, {
+        promptCacheRedesignEnabled: true,
+    });
+    const second = normalizeResponsesRequestWithCache({
+        ...baseRequest,
+        previous_response_id: "resp-2",
+    }, {
+        promptCacheRedesignEnabled: true,
+    });
+    assert.equal(first.cacheLayout.staticKey, second.cacheLayout.staticKey);
+});
+test("long chat history does not fragment static key when only transcript grows", () => {
+    const first = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        instructions: "You are a helpful agent.",
+        input: [
+            { role: "user", content: "Turn 1" },
+            { role: "assistant", content: "Reply 1" },
+            { role: "user", content: "Turn 2" },
+            { role: "assistant", content: "Reply 2" },
+            { role: "user", content: "Latest turn A" },
+        ],
+    }, {
+        promptCacheRedesignEnabled: true,
+        promptCacheSummaryKeepRecentItems: 2,
+    });
+    const second = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        instructions: "You are a helpful agent.",
+        input: [
+            { role: "user", content: "Turn 1" },
+            { role: "assistant", content: "Reply 1" },
+            { role: "user", content: "Turn 2" },
+            { role: "assistant", content: "Reply 2" },
+            { role: "user", content: "Latest turn B" },
+        ],
+    }, {
+        promptCacheRedesignEnabled: true,
+        promptCacheSummaryKeepRecentItems: 2,
+    });
+    assert.equal(first.cacheLayout.staticKey, second.cacheLayout.staticKey);
+    assert.notEqual(first.cacheLayout.requestKey, second.cacheLayout.requestKey);
+});
+test("preserves messages payload when provider capability flag is enabled", () => {
+    const normalized = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        messages: [
+            { role: "system", content: "You are Codex." },
+            { role: "user", content: "Audit RTK flow" },
+        ],
+    }, {
+        preserveMessagesPayload: true,
+    });
+    assert.deepEqual(normalized.request.input, [
+        { role: "system", content: "You are Codex." },
+        { role: "user", content: "Audit RTK flow" },
+    ]);
+    assert.equal(normalized.request.instructions, undefined);
+});
+test("family retention rules apply by family prefix", () => {
+    const normalized = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        input: [{ role: "user", content: "Hello" }],
+    }, {
+        promptCacheRedesignEnabled: true,
+        defaultPromptCacheRetention: "24h",
+        promptCacheRetentionByFamilyEnabled: true,
+        promptCacheRetentionByFamilyRules: [
+            {
+                prefix: "family:cx-gpt-5-4-xhigh",
+                retention: "72h",
+            },
+        ],
+    });
+    assert.equal(normalized.request.prompt_cache_retention, "72h");
+});
+test("static key retention rules take precedence over family retention rules", () => {
+    const base = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        input: [
+            { role: "assistant", content: "Stable context" },
+            { role: "user", content: "Hello" },
+        ],
+    }, {
+        promptCacheRedesignEnabled: true,
+    });
+    const normalized = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        input: [
+            { role: "assistant", content: "Stable context" },
+            { role: "user", content: "Different latest turn" },
+        ],
+    }, {
+        promptCacheRedesignEnabled: true,
+        defaultPromptCacheRetention: "24h",
+        promptCacheRetentionByFamilyEnabled: true,
+        promptCacheRetentionByFamilyRules: [
+            {
+                prefix: base.cacheLayout.familyId,
+                retention: "48h",
+            },
+        ],
+        promptCacheRetentionByStaticKeyEnabled: true,
+        promptCacheRetentionByStaticKeyRules: [
+            {
+                prefix: base.cacheLayout.staticKey,
+                retention: "96h",
+            },
+        ],
+    });
+    assert.equal(normalized.cacheLayout.staticKey, base.cacheLayout.staticKey);
+    assert.equal(normalized.request.prompt_cache_retention, "96h");
+});
+test("strip policy removes max_output_tokens including injected defaults", () => {
+    const normalized = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        input: [{ role: "user", content: "Hello" }],
+    }, {
+        openClawTokenOptimizationEnabled: true,
+        defaultMaxOutputTokens: 1200,
+        maxOutputTokensPolicy: {
+            mode: "strip",
+        },
+    });
+    assert.equal("max_output_tokens" in normalized.request, false);
+});
+test("direct input with legacy tool role is normalized before forwarding", () => {
+    const normalized = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        input: [
+            {
+                role: "assistant",
+                content: "Calling tool",
+            },
+            {
+                role: "tool",
+                tool_call_id: "call_123",
+                content: "tool result payload",
+            },
+        ],
+    });
+    assert.deepEqual(normalized.request.input, [
+        {
+            role: "assistant",
+            content: "Calling tool",
+        },
+        {
+            type: "function_call_output",
+            call_id: "call_123",
+            output: "tool result payload",
+        },
+    ]);
+});
+test("legacy tool role without tool_call_id falls back to assistant content", () => {
+    const normalized = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        input: [
+            {
+                role: "tool",
+                content: "orphaned tool output",
+            },
+        ],
+    });
+    assert.deepEqual(normalized.request.input, [
+        {
+            role: "assistant",
+            content: "orphaned tool output",
+        },
+    ]);
+});
+test("ignores nullable reasoning and text fields", () => {
+    const normalized = normalizeResponsesRequestWithCache({
+        model: "cx/gpt-5.4-xhigh",
+        input: [{ role: "user", content: "Hello" }],
+        reasoning: null,
+        text: null,
+    });
+    assert.equal("reasoning" in normalized.request, false);
+    assert.equal("text" in normalized.request, false);
+});

package/dist/omv-public-firewall.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import test from "node:test";
+const scriptPath = path.resolve(process.cwd(), "scripts", "omv-public-firewall.sh");
+const script = readFileSync(scriptPath, "utf8");
+test("omv firewall rollback only deletes guard table", () => {
+    assert.match(script, /nft delete table inet "\$TABLE"/);
+    assert.doesNotMatch(script, /nft list ruleset/);
+    assert.doesNotMatch(script, /BACKUP_FILE/);
+});

package/dist/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "responses-proxy-runtime",
+  "version": "0.1.0",
+  "private": true,
+  "dependencies": {
+    "@fastify/websocket": "^11.2.0",
+    "better-sqlite3": "^12.9.0",
+    "chart.js": "^4.5.1",
+    "date-fns": "^4.4.0",
+    "fastify": "^5.6.1",
+    "grammy": "^1.42.0",
+    "react": "^19.2.5",
+    "react-chartjs-2": "^5.3.1",
+    "react-dom": "^19.2.5",
+    "zod": "^4.1.5"
+  }
+}

package/dist/prompt-cache-state.js

@@ -0,0 +1,146 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import BetterSqlite3 from "better-sqlite3";
+const DEFAULT_CACHE_HIT_STREAK_TTL_MS = 6 * 60 * 60 * 1000;
+const DEFAULT_MAX_CACHE_HIT_STREAK_SESSIONS = 2000;
+export class PromptCacheStateStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static create(dbFile) {
+        mkdirSync(path.dirname(dbFile), { recursive: true });
+        const db = new BetterSqlite3(dbFile);
+        ensureSchema(db);
+        return new PromptCacheStateStore(db);
+    }
+    loadLatestObservations() {
+        const rows = this.db
+            .prepare(`SELECT scope, payload, updated_at
+         FROM prompt_cache_observations
+         ORDER BY updated_at DESC, scope ASC`)
+            .all();
+        const byProvider = new Map();
+        let latest;
+        for (const row of rows) {
+            const observation = parseObservation(row.payload);
+            if (!observation) {
+                continue;
+            }
+            if (!latest || observation.timestamp > latest.timestamp) {
+                latest = observation;
+            }
+            if (row.scope.startsWith("provider:") && observation.providerId) {
+                const existing = byProvider.get(observation.providerId);
+                if (!existing || observation.timestamp > existing.timestamp) {
+                    byProvider.set(observation.providerId, observation);
+                }
+            }
+        }
+        return {
+            latest,
+            byProvider,
+        };
+    }
+    saveLatestObservation(observation) {
+        const payload = JSON.stringify(observation);
+        const upsert = this.db.prepare(`
+      INSERT INTO prompt_cache_observations (scope, payload, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(scope) DO UPDATE SET
+        payload = excluded.payload,
+        updated_at = excluded.updated_at
+    `);
+        this.db.exec("BEGIN");
+        try {
+            upsert.run("latest", payload, observation.timestamp);
+            if (observation.providerId) {
+                upsert.run(`provider:${observation.providerId}`, payload, observation.timestamp);
+            }
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    recordCacheResult(sessionKey, cachedTokens, options = {}) {
+        if (cachedTokens === undefined) {
+            return undefined;
+        }
+        const nowMs = options.nowMs ?? Date.now();
+        const ttlMs = options.ttlMs ?? DEFAULT_CACHE_HIT_STREAK_TTL_MS;
+        const maxSessions = options.maxSessions ?? DEFAULT_MAX_CACHE_HIT_STREAK_SESSIONS;
+        const cacheHit = cachedTokens > 0;
+        this.pruneExpiredSessionStates(nowMs, ttlMs);
+        const existing = this.db
+            .prepare(`SELECT session_key, consecutive_cache_hits, updated_at
+         FROM prompt_cache_sessions
+         WHERE session_key = ?`)
+            .get(sessionKey);
+        const previousHits = existing && nowMs - existing.updated_at <= ttlMs ? existing.consecutive_cache_hits : 0;
+        const consecutiveCacheHits = cacheHit ? previousHits + 1 : 0;
+        this.db
+            .prepare(`INSERT INTO prompt_cache_sessions (session_key, consecutive_cache_hits, updated_at)
+         VALUES (?, ?, ?)
+         ON CONFLICT(session_key) DO UPDATE SET
+           consecutive_cache_hits = excluded.consecutive_cache_hits,
+           updated_at = excluded.updated_at`)
+            .run(sessionKey, consecutiveCacheHits, nowMs);
+        this.trimOverflowSessions(maxSessions);
+        return {
+            cacheHit,
+            consecutiveCacheHits,
+        };
+    }
+    pruneExpiredSessionStates(nowMs, ttlMs) {
+        this.db
+            .prepare("DELETE FROM prompt_cache_sessions WHERE updated_at < ?")
+            .run(nowMs - ttlMs);
+    }
+    trimOverflowSessions(maxSessions) {
+        const row = this.db
+            .prepare("SELECT COUNT(*) AS total FROM prompt_cache_sessions")
+            .get();
+        const overflow = row.total - maxSessions;
+        if (overflow <= 0) {
+            return;
+        }
+        this.db
+            .prepare(`DELETE FROM prompt_cache_sessions
+         WHERE session_key IN (
+           SELECT session_key
+           FROM prompt_cache_sessions
+           ORDER BY updated_at ASC, session_key ASC
+           LIMIT ?
+         )`)
+            .run(overflow);
+    }
+}
+function ensureSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS prompt_cache_observations (
+      scope TEXT PRIMARY KEY,
+      payload TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS prompt_cache_sessions (
+      session_key TEXT PRIMARY KEY,
+      consecutive_cache_hits INTEGER NOT NULL DEFAULT 0,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_prompt_cache_sessions_updated_at
+    ON prompt_cache_sessions(updated_at);
+  `);
+}
+function parseObservation(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed.requestId === "string" ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/prompt-cache-state.test.js

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { PromptCacheStateStore } from "./prompt-cache-state.js";
+test("persists latest prompt cache observation across store recreation", () => {
+    const tempDir = mkdtempSync(path.join(os.tmpdir(), "responses-proxy-cache-state-"));
+    const dbFile = path.join(tempDir, "app.sqlite");
+    try {
+        const firstStore = PromptCacheStateStore.create(dbFile);
+        firstStore.saveLatestObservation({
+            requestId: "req-1",
+            providerId: "provider-a",
+            model: "cx/gpt-5.4",
+            familyId: "family:model:core:abc",
+            staticKey: "static:family:model:core:abc:def",
+            requestKey: "request:static:family:model:core:abc:def:ghi",
+            promptCacheKey: "request:static:family:model:core:abc:def:ghi",
+            promptCacheRetention: "24h",
+            cacheHit: true,
+            cachedTokens: 123,
+            cacheSavedPercent: 61.5,
+            stream: false,
+            timestamp: "2026-04-18T08:00:00.000Z",
+        });
+        const secondStore = PromptCacheStateStore.create(dbFile);
+        const loaded = secondStore.loadLatestObservations();
+        assert.equal(loaded.latest?.requestId, "req-1");
+        assert.equal(loaded.latest?.providerId, "provider-a");
+        assert.equal(loaded.byProvider.get("provider-a")?.staticKey, "static:family:model:core:abc:def");
+    }
+    finally {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+});
+test("persists cache hit streak across store recreation", () => {
+    const tempDir = mkdtempSync(path.join(os.tmpdir(), "responses-proxy-cache-state-"));
+    const dbFile = path.join(tempDir, "app.sqlite");
+    try {
+        const firstStore = PromptCacheStateStore.create(dbFile);
+        const first = firstStore.recordCacheResult("session-a", 20, {
+            nowMs: 1_000,
+            ttlMs: 10_000,
+        });
+        assert.deepEqual(first, {
+            cacheHit: true,
+            consecutiveCacheHits: 1,
+        });
+        const secondStore = PromptCacheStateStore.create(dbFile);
+        const second = secondStore.recordCacheResult("session-a", 30, {
+            nowMs: 2_000,
+            ttlMs: 10_000,
+        });
+        assert.deepEqual(second, {
+            cacheHit: true,
+            consecutiveCacheHits: 2,
+        });
+        const third = secondStore.recordCacheResult("session-a", 0, {
+            nowMs: 3_000,
+            ttlMs: 10_000,
+        });
+        assert.deepEqual(third, {
+            cacheHit: false,
+            consecutiveCacheHits: 0,
+        });
+    }
+    finally {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+});