responses-proxy 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# responses-proxy
+
+AI routing proxy with multi-provider fallback, RTK token saver, and web dashboard.
+
+## Quick Start
+
+```bash
+npm install -g responses-proxy
+responses-proxy
+```
+
+Dashboard opens at `http://localhost:8318`
+
+## Usage
+
+```bash
+responses-proxy                    # Start with defaults
+responses-proxy --port 9000        # Custom port
+responses-proxy --no-browser       # Don't open browser
+responses-proxy --help             # Show options
+```
+
+## Features
+
+- **Multi-provider routing** — Route through Kiro, OpenAI, Anthropic, DeepSeek, etc.
+- **RTK Token Saver** — Compress tool outputs, save 20-40% tokens per request
+- **Model Combos** — Named fallback chains (9Router-style)
+- **Prompt Cache** — Maximize cache hit rates across sessions
+- **CLI Tools** — Auto-configure Claude Code, Codex, Cursor, Cline
+- **Web Dashboard** — Full management UI at localhost
+- **Docker support** — Deploy anywhere with Docker Compose
+
+## Configure CLI Tools
+
+```
+Claude Code / Codex / Cursor / Cline:
+  Endpoint: http://localhost:8318/v1
+  API Key: [copy from dashboard]
+  Model: kr/claude-sonnet-4.5
+```
+
+## Docker
+
+```bash
+docker run -d --name responses-proxy -p 8318:8318 \
+  -v "$HOME/.responses-proxy:/app/logs" \
+  ghcr.io/phamtuandat/responses-proxy:latest
+```
+
+## Documentation
+
+- GitHub: https://github.com/phamtuandat/responses-proxy
+
+## License
+
+MIT

package/cli.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * responses-proxy CLI — starts the proxy server and opens the dashboard.
+ *
+ * Usage:
+ *   npx responses-proxy
+ *   responses-proxy --port 8318
+ *   responses-proxy --no-browser
+ */
+
+const { spawn, exec } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+
+const pkg = require("./package.json");
+const args = process.argv.slice(2);
+
+// Defaults
+const DEFAULT_PORT = 8318;
+let port = DEFAULT_PORT;
+let host = "0.0.0.0";
+let noBrowser = false;
+
+// Parse args
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--port" || args[i] === "-p") {
+    port = parseInt(args[i + 1], 10) || DEFAULT_PORT;
+    i++;
+  } else if (args[i] === "--host" || args[i] === "-H") {
+    host = args[i + 1] || "0.0.0.0";
+    i++;
+  } else if (args[i] === "--no-browser" || args[i] === "-n") {
+    noBrowser = true;
+  } else if (args[i] === "--help" || args[i] === "-h") {
+    console.log(`
+responses-proxy v${pkg.version}
+
+Usage: responses-proxy [options]
+
+Options:
+  -p, --port <port>   Port to run the server (default: ${DEFAULT_PORT})
+  -H, --host <host>   Host to bind (default: 0.0.0.0)
+  -n, --no-browser    Don't open browser automatically
+  -h, --help          Show this help message
+  -v, --version       Show version
+`);
+    process.exit(0);
+  } else if (args[i] === "--version" || args[i] === "-v") {
+    console.log(pkg.version);
+    process.exit(0);
+  }
+}
+
+// Resolve paths
+const serverPath = path.join(__dirname, "dist", "server.js");
+
+if (!fs.existsSync(serverPath)) {
+  console.error("Error: Built server not found at", serverPath);
+  console.error("Run 'npm run build' first, or reinstall the package.");
+  process.exit(1);
+}
+
+// Data directory
+const dataDir = path.join(os.homedir(), ".responses-proxy");
+fs.mkdirSync(path.join(dataDir, "sessions"), { recursive: true });
+
+const displayHost = host === "0.0.0.0" ? "localhost" : host;
+const url = `http://${displayHost}:${port}`;
+
+console.log(`
+┌─────────────────────────────────────────┐
+│  responses-proxy v${pkg.version.padEnd(25)}│
+│  ${url.padEnd(39)}│
+│  Dashboard: ${(url + "/").padEnd(27)}│
+│  API: ${(url + "/v1").padEnd(33)}│
+└─────────────────────────────────────────┘
+`);
+
+// Spawn server
+const server = spawn(process.execPath, [serverPath], {
+  cwd: __dirname,
+  stdio: "inherit",
+  env: {
+    ...process.env,
+    PORT: String(port),
+    HOST: host,
+    APP_DB_PATH: path.join(dataDir, "app.sqlite"),
+    SESSION_LOG_DIR: path.join(dataDir, "sessions"),
+    CUSTOMER_KEY_DB_PATH: path.join(dataDir, "telegram-bot.sqlite"),
+    KIRO_DB_PATH: path.join(dataDir, "kiro.sqlite"),
+  },
+});
+
+// Open browser after short delay
+if (!noBrowser) {
+  setTimeout(() => {
+    const openCmd =
+      process.platform === "darwin" ? `open "${url}"` :
+      process.platform === "win32" ? `start "" "${url}"` :
+      `xdg-open "${url}"`;
+    exec(openCmd, { windowsHide: true }, () => {});
+  }, 2000);
+}
+
+// Handle exit
+function cleanup() {
+  if (server.pid) {
+    try { process.kill(server.pid, "SIGTERM"); } catch {}
+  }
+}
+
+process.on("SIGINT", () => { cleanup(); process.exit(0); });
+process.on("SIGTERM", () => { cleanup(); process.exit(0); });
+
+server.on("close", (code) => {
+  process.exit(code || 0);
+});

package/dist/anthropic-messages.js

@@ -0,0 +1,383 @@
+import { randomUUID } from "node:crypto";
+import { estimateTokens, } from "./kiro-codewhisperer.js";
+/**
+ * Translates between the Anthropic Messages API (what Claude Code speaks) and the
+ * structured turn/tool model the Kiro/CodeWhisperer forwarder consumes.
+ *
+ * Anthropic request → { turns, tools } for buildCodeWhispererRequestFromTurns.
+ * CodeWhisperer response → Anthropic `message` JSON or the Anthropic SSE event
+ * sequence (message_start → content_block_* → message_delta → message_stop).
+ */
+const ANTHROPIC_MAX_TOKENS_DEFAULT = 32000;
+function readString(value) {
+    return typeof value === "string" ? value : "";
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** Extract plain text from an Anthropic system field (string or text-block array). */
+function extractSystemText(system) {
+    if (typeof system === "string") {
+        return system.trim();
+    }
+    if (!Array.isArray(system)) {
+        return "";
+    }
+    const parts = [];
+    for (const block of system) {
+        if (typeof block === "object" && block !== null) {
+            const record = block;
+            if (record.type === "text" && typeof record.text === "string") {
+                parts.push(record.text);
+            }
+        }
+    }
+    return parts.join("\n\n").trim();
+}
+/** Extract text from a tool_result `content` (string or array of text blocks). */
+function extractToolResultText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const block of content) {
+        if (typeof block === "object" && block !== null) {
+            const record = block;
+            if (typeof record.text === "string") {
+                parts.push(record.text);
+            }
+        }
+    }
+    return parts.join("");
+}
+/** Parse an Anthropic message `content` (string or block array) into its parts. */
+function parseMessageContent(content) {
+    const result = { text: "", toolUses: [], toolResults: [] };
+    if (typeof content === "string") {
+        result.text = content;
+        return result;
+    }
+    if (!Array.isArray(content)) {
+        return result;
+    }
+    const textParts = [];
+    for (const block of content) {
+        if (typeof block !== "object" || block === null) {
+            continue;
+        }
+        const record = block;
+        switch (record.type) {
+            case "text":
+                if (typeof record.text === "string") {
+                    textParts.push(record.text);
+                }
+                break;
+            case "tool_use":
+                result.toolUses.push({
+                    toolUseId: readString(record.id),
+                    name: readString(record.name),
+                    input: typeof record.input === "object" && record.input !== null
+                        ? record.input
+                        : {},
+                });
+                break;
+            case "tool_result":
+                result.toolResults.push({
+                    toolUseId: readString(record.tool_use_id),
+                    content: extractToolResultText(record.content),
+                    status: record.is_error === true ? "error" : "success",
+                });
+                break;
+            default:
+                // image / other blocks are not translated in v1.
+                break;
+        }
+    }
+    result.text = textParts.join("");
+    return result;
+}
+/** Parse Anthropic `tools` into CodeWhisperer tool specs (input_schema → inputSchema). */
+function parseTools(tools) {
+    if (!Array.isArray(tools)) {
+        return [];
+    }
+    const specs = [];
+    for (const tool of tools) {
+        if (typeof tool !== "object" || tool === null) {
+            continue;
+        }
+        const record = tool;
+        const name = readString(record.name);
+        if (!name) {
+            continue;
+        }
+        const schema = typeof record.input_schema === "object" && record.input_schema !== null
+            ? record.input_schema
+            : {};
+        specs.push({
+            name,
+            description: readString(record.description) || undefined,
+            inputSchema: schema,
+        });
+    }
+    return specs;
+}
+/**
+ * Parse an Anthropic Messages request body into structured turns + tools. The
+ * system prompt is folded into the first user turn (CodeWhisperer has no system
+ * slot), matching how the Responses path handles instructions.
+ */
+export function parseAnthropicRequest(body) {
+    const systemText = extractSystemText(body.system);
+    const rawMessages = Array.isArray(body.messages) ? body.messages : [];
+    const turns = [];
+    for (const message of rawMessages) {
+        if (typeof message !== "object" || message === null) {
+            continue;
+        }
+        const record = message;
+        const role = record.role === "assistant" ? "assistant" : "user";
+        const parsed = parseMessageContent(record.content);
+        if (role === "assistant") {
+            turns.push({
+                role: "assistant",
+                content: parsed.text,
+                ...(parsed.toolUses.length > 0 ? { toolUses: parsed.toolUses } : {}),
+            });
+        }
+        else {
+            turns.push({
+                role: "user",
+                content: parsed.text,
+                ...(parsed.toolResults.length > 0 ? { toolResults: parsed.toolResults } : {}),
+            });
+        }
+    }
+    if (systemText) {
+        const firstUserIndex = turns.findIndex((turn) => turn.role === "user");
+        if (firstUserIndex >= 0) {
+            const existing = turns[firstUserIndex];
+            turns[firstUserIndex] = {
+                ...existing,
+                content: existing.content ? `${systemText}\n\n${existing.content}` : systemText,
+            };
+        }
+        else {
+            turns.unshift({ role: "user", content: systemText });
+        }
+    }
+    const inputText = [systemText, ...turns.map((turn) => turn.content)].filter(Boolean).join("\n");
+    return {
+        model: readString(body.model),
+        turns,
+        tools: parseTools(body.tools),
+        maxTokens: readNumber(body.max_tokens) ?? ANTHROPIC_MAX_TOKENS_DEFAULT,
+        temperature: readNumber(body.temperature),
+        topP: readNumber(body.top_p),
+        stream: body.stream === true,
+        inputText,
+    };
+}
+function newMessageId() {
+    return `msg_${randomUUID().replace(/-/g, "")}`;
+}
+/** Build a non-streaming Anthropic `message` response from collected output. */
+export function buildAnthropicMessage(args) {
+    const content = [];
+    if (args.text) {
+        content.push({ type: "text", text: args.text });
+    }
+    for (const toolUse of args.toolUses) {
+        content.push({
+            type: "tool_use",
+            id: toolUse.toolUseId,
+            name: toolUse.name,
+            input: toolUse.input,
+        });
+    }
+    // Anthropic requires at least one content block.
+    if (content.length === 0) {
+        content.push({ type: "text", text: "" });
+    }
+    return {
+        id: args.messageId ?? newMessageId(),
+        type: "message",
+        role: "assistant",
+        model: args.model,
+        content,
+        stop_reason: args.toolUses.length > 0 ? "tool_use" : "end_turn",
+        stop_sequence: null,
+        usage: { input_tokens: args.inputTokens, output_tokens: args.outputTokens },
+    };
+}
+/** Build the `/v1/messages/count_tokens` response body (estimated). */
+export function buildCountTokensResponse(inputText) {
+    return { input_tokens: estimateTokens(inputText) };
+}
+function sseFrame(event, data) {
+    return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+/**
+ * Stateful emitter for the Anthropic Messages SSE sequence. Drives content blocks
+ * as text and tool-use deltas arrive from the CodeWhisperer stream, opening/closing
+ * indexed blocks per the Anthropic protocol:
+ *   message_start → (content_block_start → content_block_delta* → content_block_stop)*
+ *   → message_delta → message_stop
+ */
+export class AnthropicSseEmitter {
+    messageId;
+    model;
+    inputTokens;
+    nextIndex = 0;
+    current = null;
+    sawToolUse = false;
+    startedToolIds = new Set();
+    constructor(args) {
+        this.messageId = args.messageId ?? newMessageId();
+        this.model = args.model;
+        this.inputTokens = args.inputTokens;
+    }
+    /** Opening frames: message_start + an initial ping. */
+    start() {
+        return [
+            sseFrame("message_start", {
+                type: "message_start",
+                message: {
+                    id: this.messageId,
+                    type: "message",
+                    role: "assistant",
+                    model: this.model,
+                    content: [],
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: { input_tokens: this.inputTokens, output_tokens: 0 },
+                },
+            }),
+            sseFrame("ping", { type: "ping" }),
+        ];
+    }
+    closeCurrent() {
+        if (!this.current) {
+            return [];
+        }
+        const frame = sseFrame("content_block_stop", {
+            type: "content_block_stop",
+            index: this.current.index,
+        });
+        this.current = null;
+        return [frame];
+    }
+    /** Emit a text delta, opening a text content block if one is not already open. */
+    textDelta(text) {
+        if (!text) {
+            return [];
+        }
+        const frames = [];
+        if (this.current && this.current.type !== "text") {
+            frames.push(...this.closeCurrent());
+        }
+        if (!this.current) {
+            const index = this.nextIndex++;
+            this.current = { index, type: "text" };
+            frames.push(sseFrame("content_block_start", {
+                type: "content_block_start",
+                index,
+                content_block: { type: "text", text: "" },
+            }));
+        }
+        frames.push(sseFrame("content_block_delta", {
+            type: "content_block_delta",
+            index: this.current.index,
+            delta: { type: "text_delta", text },
+        }));
+        return frames;
+    }
+    /** Emit a tool-use delta, managing tool_use content blocks (one per toolUseId). */
+    toolUseDelta(delta) {
+        this.sawToolUse = true;
+        const frames = [];
+        const isNewBlock = !this.current ||
+            this.current.type !== "tool" ||
+            this.current.toolUseId !== delta.toolUseId;
+        if (isNewBlock) {
+            frames.push(...this.closeCurrent());
+            const index = this.nextIndex++;
+            this.current = { index, type: "tool", toolUseId: delta.toolUseId };
+            this.startedToolIds.add(delta.toolUseId);
+            frames.push(sseFrame("content_block_start", {
+                type: "content_block_start",
+                index,
+                content_block: {
+                    type: "tool_use",
+                    id: delta.toolUseId,
+                    name: delta.name ?? "",
+                    input: {},
+                },
+            }));
+        }
+        if (delta.inputDelta) {
+            frames.push(sseFrame("content_block_delta", {
+                type: "content_block_delta",
+                index: this.current.index,
+                delta: { type: "input_json_delta", partial_json: delta.inputDelta },
+            }));
+        }
+        return frames;
+    }
+    /** Closing frames: close any open block, message_delta (stop_reason + usage), message_stop. */
+    finish(outputTokens) {
+        const frames = [];
+        frames.push(...this.closeCurrent());
+        frames.push(sseFrame("message_delta", {
+            type: "message_delta",
+            delta: {
+                stop_reason: this.sawToolUse ? "tool_use" : "end_turn",
+                stop_sequence: null,
+            },
+            usage: { output_tokens: outputTokens },
+        }));
+        frames.push(sseFrame("message_stop", { type: "message_stop" }));
+        return frames;
+    }
+}
+/** Build an Anthropic-shaped error envelope. */
+export function buildAnthropicError(type, message) {
+    return { type: "error", error: { type, message } };
+}
+function humanizeModelId(id) {
+    return id
+        .split(/[-.]/)
+        .map((part) => (part ? part[0].toUpperCase() + part.slice(1) : part))
+        .join(" ");
+}
+/**
+ * Build an Anthropic-format model listing (`GET /v1/models`). Claude Code performs
+ * a preflight model lookup against this endpoint and refuses to start if the
+ * configured model is absent, so we surface every Kiro model id/alias here.
+ */
+export function buildAnthropicModelsList(modelIds) {
+    const seen = new Set();
+    const data = [];
+    for (const id of modelIds) {
+        const trimmed = id.trim();
+        if (!trimmed || seen.has(trimmed)) {
+            continue;
+        }
+        seen.add(trimmed);
+        data.push({
+            type: "model",
+            id: trimmed,
+            display_name: humanizeModelId(trimmed),
+            created_at: "2025-01-01T00:00:00Z",
+        });
+    }
+    return {
+        data,
+        has_more: false,
+        first_id: data.length > 0 ? data[0].id : null,
+        last_id: data.length > 0 ? data[data.length - 1].id : null,
+    };
+}