nvicode 0.1.15 → 0.1.17

package/README.md

@@ -1,4 +1,4 @@
-# NviCode - Introducing one click Nvidia/OpenRouter keys to Claude Code. Free Claude code.
+# NviCode
 
 [![CI](https://github.com/dineshpotla/nvicode/actions/workflows/ci.yml/badge.svg)](https://github.com/dineshpotla/nvicode/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/nvicode)](https://www.npmjs.com/package/nvicode)
@@ -6,9 +6,17 @@
 [![node >=20](https://img.shields.io/badge/node-%3E%3D20-339933)](https://nodejs.org/)
 [![license: MIT](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
 
-Internally, `nvicode` sits between Claude Code and the selected provider.
-For NVIDIA, it starts a local Anthropic-compatible proxy that translates Claude Code requests to NVIDIA chat completions.
-For OpenRouter, it points Claude Code directly at OpenRouter's compatible endpoint and applies the selected model configuration.
+Route Claude Code, Codex CLI, and OpenClaw through NVIDIA or OpenRouter with one setup.
+
+`nvicode` lets you choose a provider once, save the API key once, pick a model once, and then launch the coding tool you want against that same backend.
+
+What it gives you:
+- One guided setup flow for provider, key, and model
+- Claude Code support
+- Codex CLI support
+- OpenClaw support
+- NVIDIA proxy mode with pacing and local usage tracking
+- OpenRouter direct mode for compatible models
 
 Supported environments:
 - macOS
@@ -18,37 +26,44 @@ Supported environments:
 
 ## Quickstart
 
-Install the published package:
+Install `nvicode`:
 
 ```sh
 npm install -g nvicode
 ```
 
-Set up provider, key, and model:
+Choose provider, key, and model:
 
 ```sh
 nvicode select model
 ```
 
-The setup flow asks for provider, API key, and model:
-
-- NVIDIA: get a free key from [NVIDIA Build API Keys](https://build.nvidia.com/settings/api-keys)
-- OpenRouter: use your OpenRouter API key
-
-Launch Claude Code through your selected provider:
+Launch the tool you want:
 
 ```sh
 nvicode launch claude
+nvicode launch codex
+nvicode launch openclaw
 ```
 
-The first successful `nvicode launch claude` also installs persistent plain-`claude` routing.
-After that, restarting your terminal or PC and running:
+Provider setup:
+
+- NVIDIA: get a free key from [NVIDIA Build API Keys](https://build.nvidia.com/settings/api-keys)
+- OpenRouter: use your OpenRouter API key
+
+What happens after first launch:
+- The first successful `nvicode launch claude` installs persistent plain `claude` routing.
+- The first successful `nvicode launch codex` installs persistent plain `codex` routing.
+- `nvicode launch openclaw` updates the default OpenClaw profile for the selected provider/model.
+
+After that, plain:
 
 ```sh
 claude
+codex
 ```
 
-will continue using your selected `nvicode` provider and model.
+continues using your selected `nvicode` provider and model.
 
 ## Screenshots
 
@@ -60,15 +75,35 @@ will continue using your selected `nvicode` provider and model.
 
 ![nvicode select model](https://raw.githubusercontent.com/dineshpotla/nvicode/main/assets/screenshots/select-model.png)
 
-### Launch Claude Code through your selected provider
+### Launch through your selected provider
 
 ![nvicode launch claude](https://raw.githubusercontent.com/dineshpotla/nvicode/main/assets/screenshots/launch.png)
 
+## How It Works
+
+- Claude Code:
+  - NVIDIA uses a local Anthropic-compatible proxy on `127.0.0.1:8788`
+  - OpenRouter connects directly to `https://openrouter.ai/api`
+- Codex CLI:
+  - uses the local `nvicode` proxy
+  - `nvicode` configures Codex to talk to that proxy through the Responses API
+- OpenClaw:
+  - updates the default OpenClaw config for the selected provider/model
+  - restart the gateway after config changes:
+
+```sh
+openclaw gateway restart
+```
+
 ## Commands
 
-Useful commands:
+Common commands:
 
 ```sh
+nvicode select model
+nvicode launch claude
+nvicode launch codex
+nvicode launch openclaw
 nvicode dashboard
 nvicode usage
 nvicode activity
@@ -76,25 +111,29 @@ nvicode models
 nvicode config
 nvicode auth
 nvicode launch claude -p "Reply with exactly OK"
+nvicode launch codex "Explain this project"
 ```
 
-Provider behavior:
-- NVIDIA: starts a local proxy on `127.0.0.1:8788`, points Claude Code at it with `ANTHROPIC_BASE_URL`, and forwards requests to NVIDIA `chat/completions`.
-- OpenRouter: points Claude Code directly at `https://openrouter.ai/api` using OpenRouter credentials and Anthropic-compatible model ids.
+Behavior notes:
+- `nvicode select model` asks for provider, optional API key update, and model choice in one guided flow.
+- Claude Code uses direct OpenRouter mode for OpenRouter, and proxy mode for NVIDIA.
+- Codex currently uses the local `nvicode` proxy path.
+- `nvicode usage`, `activity`, and `dashboard` are currently focused on NVIDIA proxy sessions.
+- OpenRouter does not currently produce the same local usage visibility as the NVIDIA proxy flow.
+- NVIDIA requests are paced to `40 RPM` by default. Override with `NVICODE_MAX_RPM` if your account allows more.
 
 In an interactive terminal, `nvicode usage` refreshes live every 2 seconds. When piped or redirected, it prints a single snapshot.
 
-`nvicode select model` now asks for provider, optional API key update, and model choice in one guided flow.
-If no API key is saved for the active provider yet, `nvicode` prompts for one on first use.
-By default, the proxy paces upstream NVIDIA requests at `40 RPM`. Override that with `NVICODE_MAX_RPM` if your account has a different limit.
 The usage dashboard compares your local NVIDIA run cost against Claude Opus 4.6 at `$5 / MTok input` and `$25 / MTok output`, based on Anthropic pricing as of `2026-03-30`.
 If your NVIDIA endpoint is not free, override local cost estimates with `NVICODE_INPUT_USD_PER_MTOK` and `NVICODE_OUTPUT_USD_PER_MTOK`.
-Local `usage`, `activity`, and `dashboard` commands are available for NVIDIA proxy sessions. OpenRouter sessions use OpenRouter's direct connection path instead.
 
 ## Requirements
 
-- Claude Code must already be installed on the machine.
+- Claude Code must already be installed to use `nvicode launch claude`.
+- Codex must already be installed to use `nvicode launch codex`. Install with `npm install -g @openai/codex`.
+- OpenClaw must already be installed to use `nvicode launch openclaw`. Install with `npm install -g openclaw@latest`.
 - Node.js 20 or newer is required to install `nvicode`.
+- OpenClaw itself requires Node.js `>=22.14.0`.
 - On native Windows, Claude Code itself requires Git for Windows. See the [Claude Code setup docs](https://code.claude.com/docs/en/setup).
 
 ## Local Development
@@ -112,4 +151,4 @@ npm link
 - `thinking` is disabled by default because some NVIDIA reasoning models can consume the entire output budget and return no visible answer to Claude Code.
 - The proxy supports basic text, tool calls, tool results, and token count estimation.
 - The proxy includes upstream request pacing and retries on NVIDIA `429` responses.
-- Claude Code remains the frontend; the selected provider/model becomes the backend.
+- Claude Code, Codex CLI, and OpenClaw remain the frontends; the selected provider/model becomes the backend.

package/dist/cli.js

@@ -18,16 +18,17 @@ const usage = () => {
     console.log(`nvicode
 
 Commands:
-  nvicode select model        Guided provider, key, and model selection
-  nvicode models              Show recommended models for the active provider
-  nvicode auth                Save or update the API key for the active provider
-  nvicode config              Show current nvicode config
-  nvicode usage               Show token usage and cost comparison
-  nvicode activity            Show recent request activity
-  nvicode dashboard           Show usage summary and recent activity
-  nvicode launch claude [...] Launch Claude Code through nvicode
+  nvicode select model          Guided provider, key, and model selection
+  nvicode models                Show recommended models for the active provider
+  nvicode auth                  Save or update the API key for the active provider
+  nvicode config                Show current nvicode config
+  nvicode usage                 Show token usage and cost comparison
+  nvicode activity              Show recent request activity
+  nvicode dashboard             Show usage summary and recent activity
+  nvicode launch claude [...]   Launch Claude Code through nvicode
   nvicode launch openclaw [...] Launch OpenClaw through nvicode
-  nvicode serve               Run the local proxy in the foreground
+  nvicode launch codex [...]    Launch Codex through nvicode
+  nvicode serve                 Run the local proxy in the foreground
 `);
 };
 const isWindows = process.platform === "win32";
@@ -48,9 +49,15 @@ const getClaudeCommandNames = () => isWindows ? ["claude.exe", "claude.cmd", "cl
 const getOpenClawCommandNames = () => isWindows
     ? ["openclaw.exe", "openclaw.cmd", "openclaw.bat", "openclaw"]
     : ["openclaw"];
+const getCodexCommandNames = () => isWindows
+    ? ["codex.exe", "codex.cmd", "codex.bat", "codex"]
+    : ["codex"];
 const getClaudeNativeNames = () => isWindows
     ? ["claude-native.exe", "claude-native.cmd", "claude-native.bat", "claude-native"]
     : ["claude-native"];
+const getCodexNativeNames = () => isWindows
+    ? ["codex-native.exe", "codex-native.cmd", "codex-native.bat", "codex-native"]
+    : ["codex-native"];
 const pathExists = async (targetPath) => {
     try {
         await fs.access(targetPath, constants.F_OK);
@@ -88,6 +95,22 @@ const renderClaudeWrapper = () => {
         "",
     ].join("\n");
 };
+const renderCodexWrapper = () => {
+    if (isWindows) {
+        return [
+            "@echo off",
+            `REM ${NVICODE_WRAPPER_MARKER}`,
+            `"${process.execPath}" "${__filename}" launch codex %*`,
+            "",
+        ].join("\r\n");
+    }
+    return [
+        "#!/bin/sh",
+        `# ${NVICODE_WRAPPER_MARKER}`,
+        `exec "${process.execPath}" "${__filename}" launch codex "$@"`,
+        "",
+    ].join("\n");
+};
 const question = async (prompt) => {
     const rl = createInterface({
         input: process.stdin,
@@ -565,6 +588,70 @@ const ensurePersistentClaudeRouting = async () => {
     await writeExecutableTextFile(wrapperPath, wrapperContents);
     return "installed";
 };
+const findExistingCodexNativeInDirectory = async (directory) => {
+    for (const name of getCodexNativeNames()) {
+        const candidate = path.join(directory, name);
+        if (await isExecutable(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+};
+const resolvePersistentCodexCommand = async () => {
+    for (const name of getCodexCommandNames()) {
+        const found = await findExecutableInPath(name);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+};
+const getCodexWrapperInstallPaths = async (codexCommandPath) => {
+    const directory = path.dirname(codexCommandPath);
+    const existingNative = await findExistingCodexNativeInDirectory(directory);
+    if (existingNative) {
+        return { wrapperPath: codexCommandPath, nativePath: existingNative };
+    }
+    if (isWindows && path.extname(codexCommandPath).toLowerCase() === ".exe") {
+        return {
+            wrapperPath: path.join(directory, "codex.cmd"),
+            nativePath: path.join(directory, "codex-native.exe"),
+        };
+    }
+    const extension = path.extname(codexCommandPath);
+    return {
+        wrapperPath: codexCommandPath,
+        nativePath: path.join(directory, `codex-native${extension}`),
+    };
+};
+const ensurePersistentCodexRouting = async () => {
+    const codexCommandPath = await resolvePersistentCodexCommand();
+    if (!codexCommandPath) {
+        return "skipped";
+    }
+    if (await isManagedClaudeWrapper(codexCommandPath)) {
+        const currentWrapper = await readIfExists(codexCommandPath);
+        const wrapperContents = renderCodexWrapper();
+        if (currentWrapper === wrapperContents) {
+            return "already";
+        }
+        await writeExecutableTextFile(codexCommandPath, wrapperContents);
+        return "updated";
+    }
+    const { wrapperPath, nativePath } = await getCodexWrapperInstallPaths(codexCommandPath);
+    const wrapperContents = renderCodexWrapper();
+    if (!(await pathExists(nativePath))) {
+        await fs.rename(codexCommandPath, nativePath);
+    }
+    else if (codexCommandPath !== wrapperPath && await pathExists(wrapperPath)) {
+        await fs.rm(wrapperPath, { force: true });
+    }
+    else if (codexCommandPath === wrapperPath) {
+        await fs.rm(wrapperPath, { force: true });
+    }
+    await writeExecutableTextFile(wrapperPath, wrapperContents);
+    return "installed";
+};
 const resolveClaudeBinary = async () => {
     for (const name of getClaudeNativeNames()) {
         const nativeInPath = await findExecutableInPath(name);
@@ -635,6 +722,39 @@ const resolveOpenClawBinary = async () => {
     }
     throw new Error("Unable to locate OpenClaw binary. Install OpenClaw first with `npm install -g openclaw@latest`.");
 };
+const resolveCodexBinary = async () => {
+    for (const name of getCodexNativeNames()) {
+        const nativeInPath = await findExecutableInPath(name);
+        if (nativeInPath) {
+            return nativeInPath;
+        }
+    }
+    const homeBinCandidates = isWindows
+        ? [
+            path.join(os.homedir(), ".local", "bin", "codex-native.exe"),
+            path.join(os.homedir(), ".local", "bin", "codex-native"),
+            path.join(os.homedir(), ".local", "bin", "codex.exe"),
+            path.join(os.homedir(), ".local", "bin", "codex.cmd"),
+            path.join(os.homedir(), ".local", "bin", "codex.bat"),
+            path.join(os.homedir(), ".local", "bin", "codex"),
+        ]
+        : [
+            path.join(os.homedir(), ".local", "bin", "codex-native"),
+            path.join(os.homedir(), ".local", "bin", "codex"),
+        ];
+    for (const candidate of homeBinCandidates) {
+        if (await isExecutable(candidate)) {
+            return candidate;
+        }
+    }
+    for (const name of getCodexCommandNames()) {
+        const codexInPath = await findExecutableInPath(name);
+        if (codexInPath && !(await isManagedClaudeWrapper(codexInPath))) {
+            return codexInPath;
+        }
+    }
+    throw new Error("Unable to locate Codex binary. Install Codex first with `npm install -g @openai/codex`.");
+};
 const findExecutableInPath = async (name) => {
     const pathEntries = (process.env.PATH || "").split(path.delimiter);
     for (const entry of pathEntries) {
@@ -714,8 +834,6 @@ const ensureOpenClawConfigured = async (openclawBinary, config, activeApiKey) =>
         "advanced",
         "--auth-choice",
         "custom-api-key",
-        "--secret-input-mode",
-        "ref",
         "--custom-provider-id",
         providerId,
         "--custom-compatibility",
@@ -763,7 +881,7 @@ const runLaunchOpenClaw = async (args) => {
     const openclawBinary = await resolveOpenClawBinary();
     const { env, updated } = await ensureOpenClawConfigured(openclawBinary, config, activeApiKey);
     if (updated) {
-        console.error("nvicode updated the default OpenClaw config. Restart the OpenClaw gateway to apply it: `openclaw gateway restart`.");
+        console.error("nvicode updated the default OpenClaw config. Restart the OpenClaw gateway to apply it: `openclaw gateway restart` (or `openclaw gateway run` for a foreground test).");
     }
     const child = spawnClaudeProcess(openclawBinary, args, env);
     await new Promise((resolve, reject) => {
@@ -778,6 +896,45 @@ const runLaunchOpenClaw = async (args) => {
         child.on("error", reject);
     });
 };
+const runLaunchCodex = async (args) => {
+    const config = await ensureConfigured();
+    const routingStatus = await ensurePersistentCodexRouting().catch(() => "skipped");
+    const activeModel = getActiveModel(config);
+    const codexBinary = await resolveCodexBinary();
+    await ensureProxyRunning(config);
+    const proxyBaseUrl = `http://127.0.0.1:${config.proxyPort}/v1`;
+    const env = {
+        ...process.env,
+        NVICODE_PROXY_TOKEN: config.proxyToken,
+    };
+    const hasModelFlag = args.includes("--model") || args.includes("-m");
+    const codexArgs = [
+        "-c", `model_provider="nvicode"`,
+        "-c", `model_providers.nvicode.name="nvicode proxy"`,
+        "-c", `model_providers.nvicode.base_url="${proxyBaseUrl}"`,
+        "-c", `model_providers.nvicode.env_key="NVICODE_PROXY_TOKEN"`,
+        "-c", `model_providers.nvicode.wire_api="responses"`,
+        "-c", `model_providers.nvicode.supports_websockets=false`,
+        ...(hasModelFlag ? [] : ["--model", activeModel]),
+        ...args,
+    ];
+    if (process.stdout.isTTY &&
+        (routingStatus === "installed" || routingStatus === "updated")) {
+        console.error("nvicode installed persistent `codex` routing. Future plain `codex` launches will use the selected nvicode provider and model.");
+    }
+    const child = spawnClaudeProcess(codexBinary, codexArgs, env);
+    await new Promise((resolve, reject) => {
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                reject(new Error(`Codex exited with signal ${signal}`));
+                return;
+            }
+            process.exitCode = code ?? 0;
+            resolve();
+        });
+        child.on("error", reject);
+    });
+};
 const runLaunchClaude = async (args) => {
     const config = await ensureConfigured();
     const routingStatus = await ensurePersistentClaudeRouting().catch(() => "skipped");
@@ -832,15 +989,12 @@ const runLaunchClaude = async (args) => {
 };
 const runServe = async () => {
     const config = await ensureConfigured();
-    if (config.provider !== "nvidia") {
-        throw new Error("`nvicode serve` is only available for the NVIDIA provider.");
-    }
     const server = createProxyServer(config);
     await new Promise((resolve, reject) => {
         server.once("error", reject);
         server.listen(config.proxyPort, "127.0.0.1", () => resolve());
     });
-    console.error(`nvicode proxy listening on http://127.0.0.1:${config.proxyPort} using ${config.nvidiaModel}`);
+    console.error(`nvicode proxy listening on http://127.0.0.1:${config.proxyPort} using ${getActiveModel(config)} (${config.provider})`);
     const shutdown = () => {
         server.close(() => process.exit(0));
     };
@@ -897,7 +1051,11 @@ const main = async () => {
             await runLaunchOpenClaw(rest.slice(1));
             return;
         }
-        throw new Error("Supported launch targets are `claude` and `openclaw`.");
+        if (rest[0] === "codex") {
+            await runLaunchCodex(rest.slice(1));
+            return;
+        }
+        throw new Error("Supported launch targets are `claude`, `openclaw`, and `codex`.");
     }
     throw new Error(`Unknown command: ${command}`);
 };

package/dist/proxy.js

@@ -1,7 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { appendUsageRecord, buildUsageRecord, getPricingSnapshot, } from "./usage.js";
+import { getActiveApiKey, getActiveModel } from "./config.js";
 const NVIDIA_URL = "https://integrate.api.nvidia.com/v1/chat/completions";
+const OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions";
 const DEFAULT_RETRY_DELAY_MS = 2_000;
 const MAX_NVIDIA_RETRIES = 3;
 const sleep = async (ms) => {
@@ -448,6 +450,234 @@ const callNvidia = async (config, scheduleRequest, payload) => {
         upstream: await scheduleRequest(invoke),
     };
 };
+const isInputMessage = (item) => "role" in item &&
+    (!("type" in item) || item.type === "message");
+const translateResponsesInputToMessages = (input) => {
+    const messages = [];
+    let pendingToolCalls = [];
+    const flushPendingToolCalls = () => {
+        if (pendingToolCalls.length > 0) {
+            messages.push({
+                role: "assistant",
+                content: null,
+                tool_calls: pendingToolCalls,
+            });
+            pendingToolCalls = [];
+        }
+    };
+    for (const item of input) {
+        if (isInputMessage(item)) {
+            flushPendingToolCalls();
+            const role = item.role === "developer" ? "system" : item.role;
+            if (typeof item.content === "string") {
+                messages.push({ role, content: item.content });
+            }
+            else {
+                const parts = item.content.map((part) => {
+                    if (part.type === "input_image" && part.image_url) {
+                        return { type: "image_url", image_url: { url: part.image_url } };
+                    }
+                    return { type: "text", text: part.text || "" };
+                });
+                messages.push({ role, content: parts });
+            }
+            continue;
+        }
+        if (item.type === "function_call") {
+            pendingToolCalls.push({
+                id: item.call_id,
+                type: "function",
+                function: { name: item.name, arguments: item.arguments },
+            });
+            continue;
+        }
+        if (item.type === "function_call_output") {
+            flushPendingToolCalls();
+            messages.push({
+                role: "tool",
+                tool_call_id: item.call_id,
+                content: item.output,
+            });
+        }
+    }
+    flushPendingToolCalls();
+    return messages;
+};
+const translateResponsesTools = (tools) => {
+    if (!tools || tools.length === 0)
+        return undefined;
+    return tools
+        .filter((t) => t.type === "function")
+        .map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters ?? { type: "object", properties: {} },
+            ...(t.strict !== undefined ? { strict: t.strict } : {}),
+        },
+    }));
+};
+const buildResponsesApiResponse = (upstream, requestModel) => {
+    const choice = upstream.choices?.[0];
+    const output = [];
+    const messageContent = choice?.message?.content;
+    const text = typeof messageContent === "string"
+        ? messageContent
+        : Array.isArray(messageContent)
+            ? messageContent
+                .map((p) => (typeof p.text === "string" ? p.text : ""))
+                .filter(Boolean)
+                .join("\n")
+            : "";
+    if (text.length > 0 ||
+        (!choice?.message?.tool_calls?.length &&
+            !choice?.message?.reasoning?.trim())) {
+        const finalText = text.length > 0
+            ? text
+            : choice?.message?.reasoning?.trim() || "";
+        output.push({
+            type: "message",
+            id: `msg_${randomUUID()}`,
+            role: "assistant",
+            status: "completed",
+            content: [{ type: "output_text", text: finalText }],
+        });
+    }
+    for (const tc of choice?.message?.tool_calls ?? []) {
+        const name = tc.function?.name;
+        if (!name)
+            continue;
+        output.push({
+            type: "function_call",
+            id: `fc_${randomUUID()}`,
+            call_id: tc.id || `call_${randomUUID()}`,
+            name,
+            arguments: tc.function?.arguments || "{}",
+            status: "completed",
+        });
+    }
+    if (output.length === 0) {
+        output.push({
+            type: "message",
+            id: `msg_${randomUUID()}`,
+            role: "assistant",
+            status: "completed",
+            content: [{ type: "output_text", text: "" }],
+        });
+    }
+    return {
+        id: upstream.id || `resp_${randomUUID()}`,
+        object: "response",
+        created_at: Math.floor(Date.now() / 1000),
+        status: "completed",
+        model: requestModel,
+        output,
+        usage: {
+            input_tokens: upstream.usage?.prompt_tokens ?? 0,
+            output_tokens: upstream.usage?.completion_tokens ?? 0,
+            total_tokens: (upstream.usage?.prompt_tokens ?? 0) +
+                (upstream.usage?.completion_tokens ?? 0),
+        },
+    };
+};
+const writeResponsesSseEvent = (response, type, payload) => {
+    response.write(`data: ${JSON.stringify({ type, ...payload })}\n\n`);
+};
+const streamResponsesApiResponse = (response, apiResponse) => {
+    response.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+    });
+    writeResponsesSseEvent(response, "response.created", {
+        response: { ...apiResponse, output: [], status: "in_progress" },
+    });
+    for (let i = 0; i < apiResponse.output.length; i++) {
+        const item = apiResponse.output[i];
+        if (item.type === "message") {
+            writeResponsesSseEvent(response, "response.output_item.added", {
+                output_index: i,
+                item: { ...item, content: [], status: "in_progress" },
+            });
+            for (let j = 0; j < item.content.length; j++) {
+                const part = item.content[j];
+                writeResponsesSseEvent(response, "response.content_part.added", {
+                    output_index: i,
+                    content_index: j,
+                    part: { type: "output_text", text: "" },
+                });
+                for (const chunk of chunkText(part.text)) {
+                    writeResponsesSseEvent(response, "response.output_text.delta", {
+                        output_index: i,
+                        content_index: j,
+                        delta: chunk,
+                    });
+                }
+                writeResponsesSseEvent(response, "response.output_text.done", {
+                    output_index: i,
+                    content_index: j,
+                    text: part.text,
+                });
+                writeResponsesSseEvent(response, "response.content_part.done", {
+                    output_index: i,
+                    content_index: j,
+                    part,
+                });
+            }
+            writeResponsesSseEvent(response, "response.output_item.done", {
+                output_index: i,
+                item: { ...item, status: "completed" },
+            });
+        }
+        else if (item.type === "function_call") {
+            writeResponsesSseEvent(response, "response.output_item.added", {
+                output_index: i,
+                item: { ...item, arguments: "", status: "in_progress" },
+            });
+            writeResponsesSseEvent(response, "response.function_call_arguments.delta", { output_index: i, delta: item.arguments });
+            writeResponsesSseEvent(response, "response.function_call_arguments.done", { output_index: i, arguments: item.arguments });
+            writeResponsesSseEvent(response, "response.output_item.done", {
+                output_index: i,
+                item: { ...item, status: "completed" },
+            });
+        }
+    }
+    writeResponsesSseEvent(response, "response.completed", {
+        response: apiResponse,
+    });
+    response.end();
+};
+const getUpstreamChatUrl = (config) => config.provider === "openrouter" ? OPENROUTER_URL : NVIDIA_URL;
+const callChatCompletions = async (config, scheduleRequest, body) => {
+    const upstreamUrl = getUpstreamChatUrl(config);
+    const apiKey = getActiveApiKey(config);
+    const invoke = async () => {
+        for (let attempt = 0; attempt <= MAX_NVIDIA_RETRIES; attempt += 1) {
+            const resp = await fetch(upstreamUrl, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+            });
+            const raw = await resp.text();
+            if (resp.ok)
+                return JSON.parse(raw);
+            if (resp.status === 429 && attempt < MAX_NVIDIA_RETRIES) {
+                const retryMs = parseRetryAfterMs(resp.headers.get("retry-after")) ||
+                    DEFAULT_RETRY_DELAY_MS * 2 ** attempt;
+                await sleep(retryMs);
+                continue;
+            }
+            throw new Error(`Upstream API HTTP ${resp.status}: ${raw}`);
+        }
+        throw new Error("Upstream API retry loop exhausted unexpectedly.");
+    };
+    return scheduleRequest(invoke);
+};
 export const createProxyServer = (config) => {
     const scheduleNvidiaRequest = createRequestScheduler(config.maxRequestsPerMinute);
     return createServer(async (request, response) => {
@@ -632,6 +862,43 @@ export const createProxyServer = (config) => {
                     throw error;
                 }
             }
+            if (request.method === "POST" && url.pathname === "/v1/responses") {
+                const rawBody = await readRequestBody(request);
+                const payload = JSON.parse(rawBody);
+                const targetModel = payload.model || getActiveModel(config);
+                const chatBody = {
+                    model: targetModel,
+                    messages: translateResponsesInputToMessages(payload.input),
+                    max_tokens: payload.max_output_tokens ?? 16_384,
+                    stream: false,
+                };
+                if (typeof payload.temperature === "number") {
+                    chatBody.temperature = payload.temperature;
+                }
+                if (typeof payload.top_p === "number") {
+                    chatBody.top_p = payload.top_p;
+                }
+                const tools = translateResponsesTools(payload.tools);
+                if (tools)
+                    chatBody.tools = tools;
+                try {
+                    const upstream = await callChatCompletions(config, scheduleNvidiaRequest, chatBody);
+                    const apiResponse = buildResponsesApiResponse(upstream, targetModel);
+                    if (payload.stream === false) {
+                        sendJson(response, 200, apiResponse);
+                    }
+                    else {
+                        streamResponsesApiResponse(response, apiResponse);
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    sendJson(response, 502, {
+                        error: { message: msg, type: "upstream_error", code: "upstream_error" },
+                    });
+                }
+                return;
+            }
             sendAnthropicError(response, 404, "not_found_error", `Unsupported route: ${request.method || "GET"} ${url.pathname}`);
         }
         catch (error) {

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "nvicode",
-  "version": "0.1.15",
-  "description": "NviCode - Introducing one click Nvidia/OpenRouter keys to Claude Code. Free Claude code.",
+  "version": "0.1.17",
+  "description": "Route Claude Code, Codex CLI, and OpenClaw through NVIDIA or OpenRouter with one setup.",
   "author": "Dinesh Potla",
   "keywords": [
     "claude-code",
+    "codex",
+    "openclaw",
+    "openrouter",
     "nvidia",
     "kimi",
     "qwen",