responses-proxy 0.1.0

package/dist/model-combo-repository.js

@@ -0,0 +1,147 @@
+/**
+ * Simple model combo repository — 9Router-style.
+ *
+ * A "model combo" is a named, ordered list of model strings (e.g.
+ * "cc/claude-opus-4-7", "kr/claude-sonnet-4.5") with simple fallback semantics.
+ * When a request specifies a combo name as the model, the proxy tries each model
+ * in order until one succeeds.
+ *
+ * This is intentionally simpler than the advanced routing combo system
+ * (RoutingComboRepository) which uses tiers, weights, health checks, etc.
+ */
+import { randomUUID } from "node:crypto";
+// Validate combo name: only a-z, A-Z, 0-9, -, _, .
+const VALID_NAME_REGEX = /^[a-zA-Z0-9_.\-]+$/;
+export class ModelComboRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.ensureTable();
+    }
+    ensureTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS model_combos (
+        id TEXT PRIMARY KEY,
+        name TEXT UNIQUE NOT NULL,
+        kind TEXT,
+        models TEXT NOT NULL DEFAULT '[]',
+        round_robin INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_model_combos_name ON model_combos(name);
+    `);
+    }
+    /** Get all model combos, optionally filtered by kind */
+    getAll(kind) {
+        let rows;
+        if (kind === undefined || kind === null) {
+            rows = this.db.prepare(`SELECT * FROM model_combos ORDER BY created_at ASC`).all();
+        }
+        else {
+            rows = this.db.prepare(`SELECT * FROM model_combos WHERE kind = ? ORDER BY created_at ASC`).all(kind);
+        }
+        return rows.map(rowToCombo);
+    }
+    /** Get combos without a kind (LLM combos) */
+    getLlmCombos() {
+        const rows = this.db.prepare(`SELECT * FROM model_combos WHERE kind IS NULL ORDER BY created_at ASC`).all();
+        return rows.map(rowToCombo);
+    }
+    getById(id) {
+        const row = this.db.prepare(`SELECT * FROM model_combos WHERE id = ?`).get(id);
+        return row ? rowToCombo(row) : null;
+    }
+    getByName(name) {
+        const row = this.db.prepare(`SELECT * FROM model_combos WHERE name = ?`).get(name);
+        return row ? rowToCombo(row) : null;
+    }
+    create(input) {
+        if (!input.name || !input.name.trim()) {
+            throw new ModelComboValidationError("Name is required");
+        }
+        if (!VALID_NAME_REGEX.test(input.name)) {
+            throw new ModelComboValidationError("Name can only contain letters, numbers, -, _ and .");
+        }
+        const existing = this.getByName(input.name);
+        if (existing) {
+            throw new ModelComboValidationError("Combo name already exists");
+        }
+        const id = randomUUID();
+        const now = new Date().toISOString();
+        const models = input.models || [];
+        const roundRobin = input.roundRobin ? 1 : 0;
+        this.db.prepare(`
+      INSERT INTO model_combos (id, name, kind, models, round_robin, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(id, input.name, input.kind || null, JSON.stringify(models), roundRobin, now, now);
+        return this.getById(id);
+    }
+    update(id, input) {
+        const existing = this.getById(id);
+        if (!existing) {
+            throw new ModelComboNotFoundError(id);
+        }
+        if (input.name !== undefined) {
+            if (!input.name.trim()) {
+                throw new ModelComboValidationError("Name is required");
+            }
+            if (!VALID_NAME_REGEX.test(input.name)) {
+                throw new ModelComboValidationError("Name can only contain letters, numbers, -, _ and .");
+            }
+            // Check uniqueness if name changed
+            if (input.name !== existing.name) {
+                const conflict = this.getByName(input.name);
+                if (conflict) {
+                    throw new ModelComboValidationError("Combo name already exists");
+                }
+            }
+        }
+        const now = new Date().toISOString();
+        const name = input.name ?? existing.name;
+        const kind = input.kind !== undefined ? input.kind : existing.kind;
+        const models = input.models ?? existing.models;
+        const roundRobin = input.roundRobin !== undefined ? (input.roundRobin ? 1 : 0) : (existing.roundRobin ? 1 : 0);
+        this.db.prepare(`
+      UPDATE model_combos
+      SET name = ?, kind = ?, models = ?, round_robin = ?, updated_at = ?
+      WHERE id = ?
+    `).run(name, kind || null, JSON.stringify(models), roundRobin, now, id);
+        return this.getById(id);
+    }
+    delete(id) {
+        const result = this.db.prepare(`DELETE FROM model_combos WHERE id = ?`).run(id);
+        return (result.changes ?? 0) > 0;
+    }
+}
+function rowToCombo(row) {
+    let models;
+    try {
+        models = JSON.parse(row.models);
+    }
+    catch {
+        models = [];
+    }
+    return {
+        id: row.id,
+        name: row.name,
+        kind: row.kind,
+        models,
+        roundRobin: Boolean(row.round_robin),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+// ─── Errors ───────────────────────────────────────────────────────────────────
+export class ModelComboValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ModelComboValidationError";
+    }
+}
+export class ModelComboNotFoundError extends Error {
+    constructor(id) {
+        super(`Model combo not found: ${id}`);
+        this.name = "ModelComboNotFoundError";
+    }
+}

package/dist/model-routing.js

@@ -0,0 +1,69 @@
+export function resolveModelRouting(requestBody, policy) {
+    if (!policy.enabled) {
+        return { downgraded: false };
+    }
+    const model = typeof requestBody.model === "string" ? requestBody.model : "";
+    const isExpensiveModel = /gpt-4|o1|o3|claude-3-5|claude-opus/i.test(model);
+    if (!isExpensiveModel) {
+        return { downgraded: false };
+    }
+    if (policy.skipIfTools && Array.isArray(requestBody.tools) && requestBody.tools.length > 0) {
+        return { downgraded: false };
+    }
+    if (policy.skipIfReasoning && requestBody.reasoning !== undefined) {
+        return { downgraded: false };
+    }
+    if (policy.skipIfImages && hasImageInput(requestBody)) {
+        return { downgraded: false };
+    }
+    const estimatedTokens = estimateInputTokens(requestBody);
+    if (estimatedTokens > policy.inputTokenThreshold) {
+        return { downgraded: false };
+    }
+    return {
+        downgraded: true,
+        originalModel: model,
+        resolvedModel: policy.cheapModel,
+        reason: `estimated_tokens:${estimatedTokens}<threshold:${policy.inputTokenThreshold}`,
+    };
+}
+function estimateInputTokens(body) {
+    const instructions = typeof body.instructions === "string" ? body.instructions : "";
+    const input = Array.isArray(body.input) ? body.input : [];
+    const inputText = input
+        .map((item) => {
+        if (typeof item !== "object" || item === null) {
+            return typeof item === "string" ? item : "";
+        }
+        const content = item.content;
+        if (typeof content === "string") {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            return content
+                .map((part) => typeof part === "object" && part !== null
+                ? String(part.text ?? "")
+                : "")
+                .join(" ");
+        }
+        return "";
+    })
+        .join(" ");
+    return Math.ceil((instructions.length + inputText.length) / 4);
+}
+function hasImageInput(body) {
+    const input = Array.isArray(body.input) ? body.input : [];
+    return input.some((item) => {
+        if (typeof item !== "object" || item === null) {
+            return false;
+        }
+        const content = item.content;
+        if (!Array.isArray(content)) {
+            return false;
+        }
+        return content.some((part) => typeof part === "object" &&
+            part !== null &&
+            (part.type === "image_url" ||
+                part.type === "input_image"));
+    });
+}

package/dist/model-routing.test.js

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { resolveModelRouting } from "./model-routing.js";
+const policy = {
+    enabled: true,
+    inputTokenThreshold: 2000,
+    cheapModel: "gpt-4o-mini",
+    skipIfTools: true,
+    skipIfImages: true,
+    skipIfReasoning: true,
+};
+test("resolveModelRouting downgrades small expensive text requests", () => {
+    const decision = resolveModelRouting({
+        model: "gpt-4.1",
+        instructions: "Be concise.",
+        input: [{ role: "user", content: "Hello" }],
+    }, policy);
+    assert.equal(decision.downgraded, true);
+    if (decision.downgraded) {
+        assert.equal(decision.originalModel, "gpt-4.1");
+        assert.equal(decision.resolvedModel, "gpt-4o-mini");
+        assert.match(decision.reason, /^estimated_tokens:/);
+    }
+});
+test("resolveModelRouting skips tools images reasoning and large requests", () => {
+    assert.deepEqual(resolveModelRouting({ model: "gpt-4.1", tools: [{ type: "function" }], input: [] }, policy), { downgraded: false });
+    assert.deepEqual(resolveModelRouting({
+        model: "gpt-4.1",
+        input: [
+            {
+                role: "user",
+                content: [{ type: "input_image", image_url: "https://example.test/image.png" }],
+            },
+        ],
+    }, policy), { downgraded: false });
+    assert.deepEqual(resolveModelRouting({ model: "gpt-4.1", reasoning: { effort: "high" }, input: [] }, policy), { downgraded: false });
+    assert.deepEqual(resolveModelRouting({
+        model: "gpt-4.1",
+        input: [{ role: "user", content: "x".repeat(20_000) }],
+    }, policy), { downgraded: false });
+});