responses-proxy 0.1.0

package/dist/request-timeout-policy.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { isHermesSummaryRequest, resolveRequestTimeoutMs } from "./request-timeout-policy.js";
+test("detects Hermes context checkpoint summarization requests", () => {
+    assert.equal(isHermesSummaryRequest({
+        input: [
+            {
+                role: "user",
+                content: "You are a summarization agent creating a context checkpoint. Summarize the session.",
+            },
+        ],
+    }), true);
+});
+test("does not classify normal chat requests as Hermes summaries", () => {
+    assert.equal(isHermesSummaryRequest({
+        input: [{ role: "user", content: "Implement this Jira ticket." }],
+    }), false);
+});
+test("extends timeout only for detected Hermes summary requests when enabled", () => {
+    assert.equal(resolveRequestTimeoutMs({
+        input: [
+            {
+                type: "message",
+                role: "user",
+                content: [{ type: "input_text", text: "You are a summarization agent creating a context checkpoint." }],
+            },
+        ],
+    }, {
+        defaultTimeoutMs: 300_000,
+        summaryTimeoutMs: 900_000,
+        extendHermesSummaryTimeout: true,
+    }), 900_000);
+    assert.equal(resolveRequestTimeoutMs({
+        input: [{ role: "user", content: "Normal request" }],
+    }, {
+        defaultTimeoutMs: 300_000,
+        summaryTimeoutMs: 900_000,
+        extendHermesSummaryTimeout: true,
+    }), 300_000);
+});

package/dist/response-cache.js

@@ -0,0 +1,69 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import BetterSqlite3 from "better-sqlite3";
+export class ResponseCacheStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static create(dbFile) {
+        mkdirSync(path.dirname(dbFile), { recursive: true });
+        const db = new BetterSqlite3(dbFile);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS response_cache (
+        request_key TEXT NOT NULL,
+        provider_id TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        PRIMARY KEY (request_key, provider_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_response_cache_expires
+        ON response_cache(expires_at);
+    `);
+        return new ResponseCacheStore(db);
+    }
+    get(requestKey, providerId) {
+        const nowMs = Date.now();
+        const row = this.db
+            .prepare(`SELECT payload FROM response_cache
+         WHERE request_key = ? AND provider_id = ? AND expires_at > ?`)
+            .get(requestKey, providerId, nowMs);
+        if (!row) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(row.payload);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    set(requestKey, providerId, payload, ttlMs) {
+        const nowMs = Date.now();
+        this.db
+            .prepare(`INSERT INTO response_cache (request_key, provider_id, payload, created_at, expires_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(request_key, provider_id) DO UPDATE SET
+           payload = excluded.payload,
+           created_at = excluded.created_at,
+           expires_at = excluded.expires_at`)
+            .run(requestKey, providerId, JSON.stringify(payload), nowMs, nowMs + ttlMs);
+    }
+    prune() {
+        const result = this.db
+            .prepare("DELETE FROM response_cache WHERE expires_at <= ?")
+            .run(Date.now());
+        return result.changes;
+    }
+    stats() {
+        const nowMs = Date.now();
+        const total = this.db.prepare("SELECT COUNT(*) AS n FROM response_cache").get().n;
+        const expired = this.db.prepare("SELECT COUNT(*) AS n FROM response_cache WHERE expires_at <= ?").get(nowMs).n;
+        const bytes = this.db.prepare("SELECT COALESCE(SUM(LENGTH(payload)), 0) AS b FROM response_cache").get().b;
+        return { totalEntries: total, expiredEntries: expired, estimatedBytes: bytes };
+    }
+    flush() {
+        return this.db.prepare("DELETE FROM response_cache").run().changes;
+    }
+}

package/dist/response-cache.test.js

@@ -0,0 +1,28 @@
+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 { ResponseCacheStore } from "./response-cache.js";
+test("ResponseCacheStore stores, expires, reports stats, and flushes entries", () => {
+    const tempDir = mkdtempSync(path.join(os.tmpdir(), "responses-proxy-response-cache-"));
+    const dbFile = path.join(tempDir, "cache.sqlite");
+    try {
+        const store = ResponseCacheStore.create(dbFile);
+        store.set("request-a", "provider-a", { ok: true, value: 1 }, 60_000);
+        assert.deepEqual(store.get("request-a", "provider-a"), { ok: true, value: 1 });
+        assert.equal(store.get("request-a", "provider-b"), undefined);
+        const stats = store.stats();
+        assert.equal(stats.totalEntries, 1);
+        assert.equal(stats.expiredEntries, 0);
+        assert.equal(stats.estimatedBytes > 0, true);
+        store.set("request-expired", "provider-a", { ok: false }, -1);
+        assert.equal(store.get("request-expired", "provider-a"), undefined);
+        assert.equal(store.prune(), 1);
+        assert.equal(store.flush(), 1);
+        assert.equal(store.stats().totalEntries, 0);
+    }
+    finally {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+});

package/dist/routing-combo-repository.js

@@ -0,0 +1,300 @@
+import { randomUUID } from "node:crypto";
+export class RoutingComboRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    // Get all routing combos with summary stats
+    async getAllCombos() {
+        const comboRows = this.db.prepare(`
+      SELECT id, name, description, is_active, is_default, created_at, updated_at
+      FROM routing_combos
+      ORDER BY created_at DESC
+    `).all();
+        const combos = [];
+        for (const row of comboRows) {
+            const combo = await this.getComboById(row.id);
+            if (combo) {
+                combos.push(combo);
+            }
+        }
+        return combos;
+    }
+    // Get specific combo by ID with full configuration
+    async getComboById(id) {
+        const comboRow = this.db.prepare(`
+      SELECT id, name, description, is_active, is_default, created_at, updated_at
+      FROM routing_combos
+      WHERE id = ?
+    `).get(id);
+        if (!comboRow) {
+            return null;
+        }
+        // Get tiers
+        const tierRows = this.db.prepare(`
+      SELECT id, combo_id, name, priority, tier, is_enabled, fallback_delay, max_retries, health_threshold
+      FROM routing_tiers
+      WHERE combo_id = ?
+      ORDER BY priority ASC
+    `).all(id);
+        const tiers = [];
+        for (const tierRow of tierRows) {
+            // Get providers for this tier
+            const providerRows = this.db.prepare(`
+        SELECT id, tier_id, provider_id, weight, is_enabled, model_override
+        FROM routing_tier_providers
+        WHERE tier_id = ?
+        ORDER BY weight DESC
+      `).all(tierRow.id);
+            const providers = providerRows.map(row => ({
+                id: row.id,
+                providerId: row.provider_id,
+                weight: row.weight,
+                isEnabled: Boolean(row.is_enabled),
+                modelOverride: row.model_override || undefined
+            }));
+            tiers.push({
+                id: tierRow.id,
+                name: tierRow.name,
+                priority: tierRow.priority,
+                tier: tierRow.tier,
+                isEnabled: Boolean(tierRow.is_enabled),
+                fallbackDelay: tierRow.fallback_delay,
+                maxRetries: tierRow.max_retries,
+                healthThreshold: tierRow.health_threshold ? JSON.parse(tierRow.health_threshold) : undefined,
+                providers
+            });
+        }
+        // Get policies
+        const policyRow = this.db.prepare(`
+      SELECT combo_id, load_balancing, failover_strategy, token_budget_mode, quota_management, cost_optimization, retry_policy
+      FROM routing_combo_policies
+      WHERE combo_id = ?
+    `).get(id);
+        const policies = {
+            loadBalancing: policyRow?.load_balancing || 'weighted',
+            failoverStrategy: policyRow?.failover_strategy || 'immediate',
+            tokenBudgetMode: policyRow?.token_budget_mode || 'per_route',
+            quotaManagement: policyRow?.quota_management ? JSON.parse(policyRow.quota_management) : undefined,
+            costOptimization: policyRow?.cost_optimization ? JSON.parse(policyRow.cost_optimization) : undefined,
+            retryPolicy: policyRow?.retry_policy ? JSON.parse(policyRow.retry_policy) : undefined
+        };
+        // Get client routes
+        const clientRouteRows = this.db.prepare(`
+      SELECT client_route
+      FROM routing_combo_client_routes
+      WHERE combo_id = ?
+    `).all(id);
+        const clientRoutes = clientRouteRows.map(row => row.client_route);
+        return {
+            id: comboRow.id,
+            name: comboRow.name,
+            description: comboRow.description || undefined,
+            isActive: Boolean(comboRow.is_active),
+            isDefault: Boolean(comboRow.is_default),
+            tiers,
+            policies,
+            clientRoutes,
+            createdAt: comboRow.created_at,
+            updatedAt: comboRow.updated_at
+        };
+    }
+    // Create new routing combo
+    async createCombo(input) {
+        const id = randomUUID();
+        const now = new Date().toISOString();
+        const transaction = this.db.transaction(() => {
+            // Insert combo
+            this.db.prepare(`
+        INSERT INTO routing_combos (id, name, description, is_active, is_default, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(id, input.name, input.description || null, input.isActive ? 1 : 0, input.isDefault ? 1 : 0, now, now);
+            // Insert tiers
+            for (const tier of input.tiers) {
+                const tierId = randomUUID();
+                this.db.prepare(`
+          INSERT INTO routing_tiers (id, combo_id, name, priority, tier, is_enabled, fallback_delay, max_retries, health_threshold)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(tierId, id, tier.name, tier.priority, tier.tier, tier.isEnabled ? 1 : 0, tier.fallbackDelay, tier.maxRetries, tier.healthThreshold ? JSON.stringify(tier.healthThreshold) : null);
+                // Insert tier providers
+                for (const provider of tier.providers) {
+                    const providerId = randomUUID();
+                    this.db.prepare(`
+            INSERT INTO routing_tier_providers (id, tier_id, provider_id, weight, is_enabled, model_override)
+            VALUES (?, ?, ?, ?, ?, ?)
+          `).run(providerId, tierId, provider.providerId, provider.weight, provider.isEnabled ? 1 : 0, provider.modelOverride || null);
+                }
+            }
+            // Insert policies
+            this.db.prepare(`
+        INSERT INTO routing_combo_policies (combo_id, load_balancing, failover_strategy, token_budget_mode, quota_management, cost_optimization, retry_policy)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(id, input.policies.loadBalancing, input.policies.failoverStrategy, input.policies.tokenBudgetMode, input.policies.quotaManagement ? JSON.stringify(input.policies.quotaManagement) : null, input.policies.costOptimization ? JSON.stringify(input.policies.costOptimization) : null, input.policies.retryPolicy ? JSON.stringify(input.policies.retryPolicy) : null);
+            // Insert client routes
+            for (const clientRoute of input.clientRoutes) {
+                this.db.prepare(`
+          INSERT INTO routing_combo_client_routes (combo_id, client_route)
+          VALUES (?, ?)
+        `).run(id, clientRoute);
+            }
+        });
+        transaction();
+        const combo = await this.getComboById(id);
+        if (!combo) {
+            throw new Error('Failed to create routing combo');
+        }
+        return combo;
+    }
+    // Update existing routing combo
+    async updateCombo(id, input) {
+        const now = new Date().toISOString();
+        const transaction = this.db.transaction(() => {
+            // Update combo
+            this.db.prepare(`
+        UPDATE routing_combos
+        SET name = ?, description = ?, is_active = ?, is_default = ?, updated_at = ?
+        WHERE id = ?
+      `).run(input.name, input.description || null, input.isActive ? 1 : 0, input.isDefault ? 1 : 0, now, id);
+            // Delete existing tiers and their providers (cascade will handle providers)
+            this.db.prepare(`DELETE FROM routing_tiers WHERE combo_id = ?`).run(id);
+            // Delete existing policies
+            this.db.prepare(`DELETE FROM routing_combo_policies WHERE combo_id = ?`).run(id);
+            // Delete existing client routes
+            this.db.prepare(`DELETE FROM routing_combo_client_routes WHERE combo_id = ?`).run(id);
+            // Insert new tiers
+            for (const tier of input.tiers) {
+                const tierId = randomUUID();
+                this.db.prepare(`
+          INSERT INTO routing_tiers (id, combo_id, name, priority, tier, is_enabled, fallback_delay, max_retries, health_threshold)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(tierId, id, tier.name, tier.priority, tier.tier, tier.isEnabled ? 1 : 0, tier.fallbackDelay, tier.maxRetries, tier.healthThreshold ? JSON.stringify(tier.healthThreshold) : null);
+                // Insert tier providers
+                for (const provider of tier.providers) {
+                    const providerId = randomUUID();
+                    this.db.prepare(`
+            INSERT INTO routing_tier_providers (id, tier_id, provider_id, weight, is_enabled, model_override)
+            VALUES (?, ?, ?, ?, ?, ?)
+          `).run(providerId, tierId, provider.providerId, provider.weight, provider.isEnabled ? 1 : 0, provider.modelOverride || null);
+                }
+            }
+            // Insert new policies
+            this.db.prepare(`
+        INSERT INTO routing_combo_policies (combo_id, load_balancing, failover_strategy, token_budget_mode, quota_management, cost_optimization, retry_policy)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(id, input.policies.loadBalancing, input.policies.failoverStrategy, input.policies.tokenBudgetMode, input.policies.quotaManagement ? JSON.stringify(input.policies.quotaManagement) : null, input.policies.costOptimization ? JSON.stringify(input.policies.costOptimization) : null, input.policies.retryPolicy ? JSON.stringify(input.policies.retryPolicy) : null);
+            // Insert new client routes
+            for (const clientRoute of input.clientRoutes) {
+                this.db.prepare(`
+          INSERT INTO routing_combo_client_routes (combo_id, client_route)
+          VALUES (?, ?)
+        `).run(id, clientRoute);
+            }
+        });
+        transaction();
+        const combo = await this.getComboById(id);
+        if (!combo) {
+            throw new Error('Failed to update routing combo');
+        }
+        return combo;
+    }
+    // Delete routing combo
+    async deleteCombo(id) {
+        const combo = await this.getComboById(id);
+        if (!combo) {
+            throw new Error('Routing combo not found');
+        }
+        // Safety check: prevent deleting active combos
+        if (combo.isActive) {
+            throw new Error('Cannot delete active routing combo. Deactivate it first.');
+        }
+        // Safety check: prevent deleting default combo
+        if (combo.isDefault) {
+            throw new Error('Cannot delete default routing combo. Set another combo as default first.');
+        }
+        this.db.prepare(`DELETE FROM routing_combos WHERE id = ?`).run(id);
+    }
+    // Get combo statistics
+    async getComboStats() {
+        const totalResult = this.db.prepare(`SELECT COUNT(*) as count FROM routing_combos`).get();
+        const activeResult = this.db.prepare(`SELECT COUNT(*) as count FROM routing_combos WHERE is_active = 1`).get();
+        const clientRoutesResult = this.db.prepare(`SELECT COUNT(*) as count FROM routing_combo_client_routes`).get();
+        const tiersResult = this.db.prepare(`SELECT COUNT(*) as count FROM routing_tiers`).get();
+        return {
+            total: totalResult.count,
+            active: activeResult.count,
+            totalClientRoutes: clientRoutesResult.count,
+            averageTiersPerCombo: totalResult.count > 0 ? tiersResult.count / totalResult.count : 0
+        };
+    }
+    // Set default combo
+    async setDefaultCombo(id) {
+        const transaction = this.db.transaction(() => {
+            // Clear existing default
+            this.db.prepare(`UPDATE routing_combos SET is_default = 0`).run();
+            // Set new default
+            this.db.prepare(`UPDATE routing_combos SET is_default = 1 WHERE id = ?`).run(id);
+        });
+        transaction();
+    }
+    // Get default combo
+    async getDefaultCombo() {
+        const row = this.db.prepare(`
+      SELECT id FROM routing_combos WHERE is_default = 1 LIMIT 1
+    `).get();
+        if (!row) {
+            return null;
+        }
+        return this.getComboById(row.id);
+    }
+    // Client route assignment methods
+    // Get routing combo assigned to a client route
+    async getClientRouteCombo(clientRoute) {
+        const row = this.db.prepare(`
+      SELECT combo_id FROM routing_combo_client_routes WHERE client_route = ?
+    `).get(clientRoute);
+        return row?.combo_id || null;
+    }
+    // Assign routing combo to client route
+    async assignClientRouteCombo(clientRoute, comboId) {
+        // Verify combo exists
+        const combo = await this.getComboById(comboId);
+        if (!combo) {
+            throw new Error(`Routing combo ${comboId} not found`);
+        }
+        // Use INSERT OR REPLACE to handle both new assignments and updates
+        this.db.prepare(`
+      INSERT OR REPLACE INTO routing_combo_client_routes (combo_id, client_route)
+      VALUES (?, ?)
+    `).run(comboId, clientRoute);
+    }
+    // Remove routing combo assignment from client route
+    async unassignClientRouteCombo(clientRoute) {
+        this.db.prepare(`
+      DELETE FROM routing_combo_client_routes WHERE client_route = ?
+    `).run(clientRoute);
+    }
+    // Get all client routes assigned to a combo
+    async getComboClientRoutes(comboId) {
+        const rows = this.db.prepare(`
+      SELECT client_route FROM routing_combo_client_routes WHERE combo_id = ?
+    `).all(comboId);
+        return rows.map(row => row.client_route);
+    }
+    // Get all client route assignments
+    async getAllClientRouteAssignments() {
+        const rows = this.db.prepare(`
+      SELECT
+        rcr.client_route,
+        rcr.combo_id,
+        rc.name as combo_name
+      FROM routing_combo_client_routes rcr
+      JOIN routing_combos rc ON rcr.combo_id = rc.id
+      ORDER BY rcr.client_route
+    `).all();
+        return rows.map(row => ({
+            clientRoute: row.client_route,
+            comboId: row.combo_id,
+            comboName: row.combo_name
+        }));
+    }
+}