nvicode 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# nvicode
+
+Run Claude Code through NVIDIA-hosted models using a local Anthropic-compatible gateway.
+
+## Install
+
+Published package:
+
+```sh
+npm install -g nvicode
+```
+
+Local development:
+
+```sh
+npm install
+npm run build
+ln -sf "$(pwd)/dist/cli.js" ~/.local/bin/nvicode
+```
+
+## Usage
+
+Choose a model and save your NVIDIA API key:
+
+```sh
+nvicode select model
+```
+
+Launch Claude Code through the local gateway:
+
+```sh
+nvicode launch claude
+```
+
+Useful commands:
+
+```sh
+nvicode models
+nvicode config
+nvicode auth
+nvicode launch claude -p "Reply with exactly OK"
+```
+
+The launcher 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`.
+
+If no NVIDIA API key is saved yet, `nvicode` prompts for one on first use.
+
+## Notes
+
+- `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.
+- Claude Code remains the frontend; the selected NVIDIA model becomes the backend.

package/dist/cli.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline/promises";
+import { constants, openSync } from "node:fs";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { getNvicodePaths, loadConfig, saveConfig, } from "./config.js";
+import { createProxyServer } from "./proxy.js";
+import { CURATED_MODELS, getRecommendedModels } from "./models.js";
+const __filename = fileURLToPath(import.meta.url);
+const usage = () => {
+    console.log(`nvicode
+
+Commands:
+  nvicode select model        Select and save a NVIDIA model
+  nvicode models              Show recommended coding models
+  nvicode auth                Save or update NVIDIA API key
+  nvicode config              Show current nvicode config
+  nvicode launch claude [...] Launch Claude Code through nvicode
+  nvicode serve               Run the local proxy in the foreground
+`);
+};
+const question = async (prompt) => {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        return (await rl.question(prompt)).trim();
+    }
+    finally {
+        rl.close();
+    }
+};
+const ensureConfigured = async () => {
+    let config = await loadConfig();
+    let changed = false;
+    if (!config.apiKey) {
+        if (!process.stdin.isTTY) {
+            throw new Error("Missing NVIDIA API key. Run `nvicode auth` first.");
+        }
+        const apiKey = await question("NVIDIA API key: ");
+        if (!apiKey) {
+            throw new Error("NVIDIA API key is required.");
+        }
+        config = {
+            ...config,
+            apiKey,
+        };
+        changed = true;
+    }
+    if (!config.model) {
+        const [first] = await getRecommendedModels(config.apiKey);
+        config = {
+            ...config,
+            model: first?.id || CURATED_MODELS[0].id,
+        };
+        changed = true;
+    }
+    if (changed) {
+        config = await saveConfig(config);
+    }
+    return config;
+};
+const runAuth = async () => {
+    const config = await loadConfig();
+    const apiKey = await question(config.apiKey ? "NVIDIA API key (leave blank to keep current): " : "NVIDIA API key: ");
+    if (!apiKey && config.apiKey) {
+        console.log("Kept existing NVIDIA API key.");
+        return;
+    }
+    if (!apiKey) {
+        throw new Error("NVIDIA API key is required.");
+    }
+    await saveConfig({
+        ...config,
+        apiKey,
+    });
+    console.log("Saved NVIDIA API key.");
+};
+const printModels = async (apiKey) => {
+    const models = apiKey ? await getRecommendedModels(apiKey) : CURATED_MODELS;
+    models.forEach((model, index) => {
+        console.log(`${index + 1}. ${model.label}`);
+        console.log(`   ${model.id}`);
+        console.log(`   ${model.description}`);
+    });
+};
+const runSelectModel = async () => {
+    const config = await ensureConfigured();
+    const models = await getRecommendedModels(config.apiKey);
+    console.log("Recommended NVIDIA coding models:");
+    await printModels(config.apiKey);
+    console.log("Type a number from the list or enter a custom model id.");
+    const answer = await question("Model selection: ");
+    const index = Number(answer);
+    const chosenModel = Number.isInteger(index) && index >= 1 && index <= models.length
+        ? models[index - 1]?.id
+        : answer.trim();
+    if (!chosenModel) {
+        throw new Error("Model selection is required.");
+    }
+    await saveConfig({
+        ...config,
+        model: chosenModel,
+    });
+    console.log(`Saved model: ${chosenModel}`);
+};
+const runConfig = async () => {
+    const config = await loadConfig();
+    const paths = getNvicodePaths();
+    console.log(`Config file: ${paths.configFile}`);
+    console.log(`State dir:   ${paths.stateDir}`);
+    console.log(`Model:       ${config.model}`);
+    console.log(`Proxy port:  ${config.proxyPort}`);
+    console.log(`Thinking:    ${config.thinking ? "on" : "off"}`);
+    console.log(`API key:     ${config.apiKey ? "saved" : "missing"}`);
+};
+const waitForHealthyProxy = async (port) => {
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+        try {
+            const response = await fetch(`http://127.0.0.1:${port}/health`);
+            if (response.ok) {
+                return true;
+            }
+        }
+        catch {
+            // ignore and retry
+        }
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    return false;
+};
+const ensureProxyRunning = async (config) => {
+    if (await waitForHealthyProxy(config.proxyPort)) {
+        return;
+    }
+    const paths = getNvicodePaths();
+    await fs.mkdir(paths.stateDir, { recursive: true });
+    const logFd = openSync(paths.logFile, "a");
+    const child = spawn(process.execPath, [__filename, "serve"], {
+        detached: true,
+        env: {
+            ...process.env,
+        },
+        stdio: ["ignore", logFd, logFd],
+    });
+    child.unref();
+    await fs.writeFile(paths.pidFile, `${child.pid}\n`);
+    if (!(await waitForHealthyProxy(config.proxyPort))) {
+        throw new Error(`nvicode proxy failed to start. See ${paths.logFile}`);
+    }
+};
+const isExecutable = async (filePath) => {
+    try {
+        await fs.access(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const resolveClaudeBinary = async () => {
+    const nativeInPath = await findExecutableInPath("claude-native");
+    if (nativeInPath) {
+        return nativeInPath;
+    }
+    const versionsDir = path.join(os.homedir(), ".local", "share", "claude", "versions");
+    try {
+        const entries = await fs.readdir(versionsDir);
+        const latest = entries.sort((left, right) => left.localeCompare(right, undefined, {
+            numeric: true,
+            sensitivity: "base",
+        })).at(-1);
+        if (latest) {
+            return path.join(versionsDir, latest);
+        }
+    }
+    catch {
+        // continue
+    }
+    const claudeInPath = await findExecutableInPath("claude");
+    if (claudeInPath) {
+        return claudeInPath;
+    }
+    throw new Error("Unable to locate Claude Code binary.");
+};
+const findExecutableInPath = async (name) => {
+    const pathEntries = (process.env.PATH || "").split(path.delimiter);
+    for (const entry of pathEntries) {
+        if (!entry) {
+            continue;
+        }
+        const candidate = path.join(entry, name);
+        if (await isExecutable(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+};
+const runLaunchClaude = async (args) => {
+    const config = await ensureConfigured();
+    await ensureProxyRunning(config);
+    const claudeBinary = await resolveClaudeBinary();
+    const child = spawn(claudeBinary, args, {
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            ANTHROPIC_BASE_URL: `http://127.0.0.1:${config.proxyPort}`,
+            ANTHROPIC_AUTH_TOKEN: config.proxyToken,
+            ANTHROPIC_API_KEY: "",
+            ANTHROPIC_MODEL: config.model,
+            CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1",
+            ANTHROPIC_CUSTOM_MODEL_OPTION: config.model,
+            ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: "nvicode custom model",
+            ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION: "Claude Code via local NVIDIA gateway",
+        },
+    });
+    await new Promise((resolve, reject) => {
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                reject(new Error(`Claude exited with signal ${signal}`));
+                return;
+            }
+            process.exitCode = code ?? 0;
+            resolve();
+        });
+        child.on("error", reject);
+    });
+};
+const runServe = async () => {
+    const config = await ensureConfigured();
+    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.model}`);
+    const shutdown = () => {
+        server.close(() => process.exit(0));
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+};
+const main = async () => {
+    const args = process.argv.slice(2);
+    const [command, ...rest] = args;
+    if (!command || command === "--help" || command === "-h") {
+        usage();
+        return;
+    }
+    if (command === "serve") {
+        await runServe();
+        return;
+    }
+    if (command === "models") {
+        const config = await loadConfig();
+        await printModels(config.apiKey || undefined);
+        return;
+    }
+    if (command === "auth") {
+        await runAuth();
+        return;
+    }
+    if (command === "config") {
+        await runConfig();
+        return;
+    }
+    if ((command === "select" && rest[0] === "model") ||
+        command === "select-model") {
+        await runSelectModel();
+        return;
+    }
+    if (command === "launch") {
+        if (rest[0] !== "claude") {
+            throw new Error("Only `nvicode launch claude` is supported right now.");
+        }
+        await runLaunchClaude(rest.slice(1));
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+};
+void main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/config.js

@@ -0,0 +1,56 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const DEFAULT_PROXY_PORT = 8788;
+const DEFAULT_MODEL = "moonshotai/kimi-k2.5";
+export const getNvicodePaths = () => {
+    const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".local", "share");
+    const stateHome = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
+    const configDir = path.join(configHome, "nvicode");
+    const stateDir = path.join(stateHome, "nvicode");
+    return {
+        configDir,
+        configFile: path.join(configDir, "config.json"),
+        stateDir,
+        logFile: path.join(stateDir, "proxy.log"),
+        pidFile: path.join(stateDir, "proxy.pid"),
+    };
+};
+const withDefaults = (config) => ({
+    apiKey: config.apiKey?.trim() || "",
+    model: config.model?.trim() || DEFAULT_MODEL,
+    proxyPort: Number.isInteger(config.proxyPort) && config.proxyPort > 0
+        ? config.proxyPort
+        : DEFAULT_PROXY_PORT,
+    proxyToken: config.proxyToken?.trim() || randomUUID(),
+    thinking: config.thinking ?? false,
+});
+export const loadConfig = async () => {
+    const paths = getNvicodePaths();
+    try {
+        const raw = await fs.readFile(paths.configFile, "utf8");
+        return withDefaults(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return withDefaults({});
+        }
+        throw error;
+    }
+};
+export const saveConfig = async (config) => {
+    const paths = getNvicodePaths();
+    await fs.mkdir(paths.configDir, { recursive: true });
+    await fs.mkdir(paths.stateDir, { recursive: true });
+    const resolved = withDefaults(config);
+    await fs.writeFile(paths.configFile, `${JSON.stringify(resolved, null, 2)}\n`);
+    return resolved;
+};
+export const updateConfig = async (patch) => {
+    const current = await loadConfig();
+    return await saveConfig({
+        ...current,
+        ...patch,
+    });
+};

package/dist/models.js

@@ -0,0 +1,61 @@
+export const CURATED_MODELS = [
+    {
+        id: "moonshotai/kimi-k2.5",
+        label: "Kimi K2.5",
+        description: "Strong coding and agentic workflow model.",
+    },
+    {
+        id: "qwen/qwen3-coder-480b-a35b-instruct",
+        label: "Qwen3 Coder 480B",
+        description: "Large coding-focused Qwen model.",
+    },
+    {
+        id: "z-ai/glm5",
+        label: "GLM5",
+        description: "General purpose reasoning model with code capability.",
+    },
+    {
+        id: "deepseek-ai/deepseek-v3.2",
+        label: "DeepSeek V3.2",
+        description: "General coding and reasoning model.",
+    },
+    {
+        id: "mistralai/codestral-22b-instruct-v0.1",
+        label: "Codestral 22B",
+        description: "Compact coding-specialized model.",
+    },
+    {
+        id: "qwen/qwen2.5-coder-32b-instruct",
+        label: "Qwen2.5 Coder 32B",
+        description: "Smaller coding-focused Qwen model.",
+    },
+];
+const MODELS_URL = "https://integrate.api.nvidia.com/v1/models";
+export const fetchAvailableModelIds = async (apiKey) => {
+    const response = await fetch(MODELS_URL, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Unable to fetch NVIDIA models: HTTP ${response.status} ${response.statusText}`);
+    }
+    const body = (await response.json());
+    const ids = new Set();
+    for (const model of body.data ?? []) {
+        if (typeof model.id === "string" && model.id.length > 0) {
+            ids.add(model.id);
+        }
+    }
+    return ids;
+};
+export const getRecommendedModels = async (apiKey) => {
+    try {
+        const available = await fetchAvailableModelIds(apiKey);
+        const curated = CURATED_MODELS.filter((model) => available.has(model.id));
+        return curated.length > 0 ? curated : CURATED_MODELS;
+    }
+    catch {
+        return CURATED_MODELS;
+    }
+};

package/dist/proxy.js

@@ -0,0 +1,503 @@
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+const NVIDIA_URL = "https://integrate.api.nvidia.com/v1/chat/completions";
+const sendJson = (response, statusCode, payload) => {
+    response.writeHead(statusCode, {
+        "Content-Type": "application/json",
+    });
+    response.end(JSON.stringify(payload));
+};
+const sendAnthropicError = (response, statusCode, type, message) => {
+    sendJson(response, statusCode, {
+        type: "error",
+        error: {
+            type,
+            message,
+        },
+    });
+};
+const readRequestBody = async (request) => {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+};
+const extractBearerToken = (request) => {
+    const header = request.headers.authorization;
+    if (!header) {
+        return null;
+    }
+    const match = /^Bearer\s+(.+)$/i.exec(header);
+    return match?.[1]?.trim() || null;
+};
+const stringifyContent = (value) => {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => stringifyContent(entry)).join("\n");
+    }
+    if (value &&
+        typeof value === "object" &&
+        "type" in value &&
+        value.type === "text" &&
+        "text" in value &&
+        typeof value.text === "string") {
+        return value.text || "";
+    }
+    if (value === undefined || value === null) {
+        return "";
+    }
+    return JSON.stringify(value);
+};
+const normalizeSystemPrompt = (system) => {
+    if (!system) {
+        return null;
+    }
+    if (typeof system === "string") {
+        return system;
+    }
+    const text = system.map((block) => block.text).join("\n\n");
+    return text || null;
+};
+const flushUserParts = (messages, parts) => {
+    if (parts.length === 0) {
+        return;
+    }
+    messages.push({
+        role: "user",
+        content: parts.length === 1 && parts[0]?.type === "text"
+            ? parts[0].text
+            : [...parts],
+    });
+    parts.length = 0;
+};
+const mapUserMessage = (message) => {
+    if (typeof message.content === "string") {
+        return [
+            {
+                role: "user",
+                content: message.content,
+            },
+        ];
+    }
+    const mapped = [];
+    const parts = [];
+    for (const block of message.content) {
+        if (block.type === "text") {
+            parts.push({ type: "text", text: block.text });
+            continue;
+        }
+        if (block.type === "image") {
+            const mediaType = block.source?.media_type || "application/octet-stream";
+            const data = block.source?.data;
+            if (!data) {
+                continue;
+            }
+            parts.push({
+                type: "image_url",
+                image_url: {
+                    url: `data:${mediaType};base64,${data}`,
+                },
+            });
+            continue;
+        }
+        if (block.type === "tool_result") {
+            flushUserParts(mapped, parts);
+            mapped.push({
+                role: "tool",
+                tool_call_id: block.tool_use_id,
+                content: stringifyContent(block.content),
+            });
+        }
+    }
+    flushUserParts(mapped, parts);
+    return mapped;
+};
+const mapAssistantMessage = (message) => {
+    if (typeof message.content === "string") {
+        return [
+            {
+                role: "assistant",
+                content: message.content,
+            },
+        ];
+    }
+    const textParts = [];
+    const toolCalls = [];
+    for (const block of message.content) {
+        if (block.type === "text") {
+            textParts.push(block.text);
+            continue;
+        }
+        if (block.type === "tool_use") {
+            toolCalls.push({
+                id: block.id,
+                type: "function",
+                function: {
+                    name: block.name,
+                    arguments: JSON.stringify(block.input ?? {}),
+                },
+            });
+        }
+    }
+    return [
+        {
+            role: "assistant",
+            content: textParts.length > 0 ? textParts.join("\n\n") : null,
+            ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+        },
+    ];
+};
+const mapMessages = (payload) => {
+    const mapped = [];
+    const system = normalizeSystemPrompt(payload.system);
+    if (system) {
+        mapped.push({
+            role: "system",
+            content: system,
+        });
+    }
+    for (const message of payload.messages ?? []) {
+        if (message.role === "user") {
+            mapped.push(...mapUserMessage(message));
+            continue;
+        }
+        if (message.role === "assistant") {
+            mapped.push(...mapAssistantMessage(message));
+        }
+    }
+    return mapped;
+};
+const mapTools = (tools) => {
+    if (!tools || tools.length === 0) {
+        return undefined;
+    }
+    return tools.map((tool) => ({
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema ?? {
+                type: "object",
+                properties: {},
+            },
+        },
+    }));
+};
+const mapToolChoice = (toolChoice) => {
+    if (!toolChoice || typeof toolChoice !== "object") {
+        return undefined;
+    }
+    const type = toolChoice.type;
+    if (type === "auto") {
+        return "auto";
+    }
+    if (type === "any") {
+        return "required";
+    }
+    if (type === "tool" &&
+        typeof toolChoice.name === "string") {
+        return {
+            type: "function",
+            function: {
+                name: toolChoice.name,
+            },
+        };
+    }
+    return undefined;
+};
+const safeParseJson = (value) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return {
+            raw: value,
+        };
+    }
+};
+const mapStopReason = (finishReason) => {
+    switch (finishReason) {
+        case "tool_calls":
+            return "tool_use";
+        case "length":
+            return "max_tokens";
+        case "stop":
+        default:
+            return "end_turn";
+    }
+};
+const mapResponseContent = (choice) => {
+    const content = [];
+    const message = choice?.message;
+    if (typeof message?.content === "string" && message.content.length > 0) {
+        content.push({
+            type: "text",
+            text: message.content,
+        });
+    }
+    else if (Array.isArray(message?.content)) {
+        const text = message.content
+            .map((part) => (typeof part.text === "string" ? part.text : ""))
+            .filter((entry) => entry.length > 0)
+            .join("\n");
+        if (text.length > 0) {
+            content.push({
+                type: "text",
+                text,
+            });
+        }
+    }
+    if (content.length === 0 &&
+        typeof message?.reasoning === "string" &&
+        message.reasoning.trim().length > 0) {
+        content.push({
+            type: "text",
+            text: message.reasoning,
+        });
+    }
+    for (const toolCall of message?.tool_calls ?? []) {
+        const name = toolCall.function?.name;
+        if (!name) {
+            continue;
+        }
+        content.push({
+            type: "tool_use",
+            id: toolCall.id || `toolu_${randomUUID()}`,
+            name,
+            input: safeParseJson(toolCall.function?.arguments || "{}"),
+        });
+    }
+    if (content.length === 0) {
+        content.push({
+            type: "text",
+            text: "",
+        });
+    }
+    return content;
+};
+const chunkText = (value, chunkSize = 1024) => {
+    if (!value) {
+        return [""];
+    }
+    const chunks = [];
+    for (let index = 0; index < value.length; index += chunkSize) {
+        chunks.push(value.slice(index, index + chunkSize));
+    }
+    return chunks;
+};
+const writeSse = (response, event, payload) => {
+    response.write(`event: ${event}\n`);
+    response.write(`data: ${JSON.stringify(payload)}\n\n`);
+};
+const estimateTokens = (payload) => {
+    const raw = JSON.stringify(payload);
+    return Math.max(1, Math.ceil(raw.length / 4));
+};
+const callNvidia = async (config, payload) => {
+    const targetModel = payload.model && payload.model.includes("/") && !payload.model.startsWith("claude-")
+        ? payload.model
+        : config.model;
+    const requestBody = {
+        model: targetModel,
+        messages: mapMessages(payload),
+        max_tokens: payload.max_tokens ?? 16_384,
+        stream: false,
+    };
+    if (typeof payload.temperature === "number") {
+        requestBody.temperature = payload.temperature;
+    }
+    if (typeof payload.top_p === "number") {
+        requestBody.top_p = payload.top_p;
+    }
+    if (payload.stop_sequences && payload.stop_sequences.length > 0) {
+        requestBody.stop = payload.stop_sequences;
+    }
+    const tools = mapTools(payload.tools);
+    if (tools) {
+        requestBody.tools = tools;
+    }
+    const toolChoice = mapToolChoice(payload.tool_choice);
+    if (toolChoice) {
+        requestBody.tool_choice = toolChoice;
+    }
+    if (config.thinking) {
+        requestBody.chat_template_kwargs = {
+            thinking: true,
+        };
+    }
+    const response = await fetch(NVIDIA_URL, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(requestBody),
+    });
+    const raw = await response.text();
+    if (!response.ok) {
+        throw new Error(`NVIDIA API HTTP ${response.status}: ${raw}`);
+    }
+    return {
+        targetModel,
+        upstream: JSON.parse(raw),
+    };
+};
+export const createProxyServer = (config) => {
+    return createServer(async (request, response) => {
+        try {
+            const url = new URL(request.url || "/", "http://127.0.0.1");
+            if (request.method === "OPTIONS") {
+                response.writeHead(204);
+                response.end();
+                return;
+            }
+            if (url.pathname === "/health") {
+                sendJson(response, 200, {
+                    ok: true,
+                    model: config.model,
+                    port: config.proxyPort,
+                    thinking: config.thinking,
+                });
+                return;
+            }
+            const token = extractBearerToken(request);
+            if (token !== config.proxyToken) {
+                sendAnthropicError(response, 401, "authentication_error", "Invalid nvicode proxy token");
+                return;
+            }
+            if (request.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
+                const rawBody = await readRequestBody(request);
+                const payload = JSON.parse(rawBody);
+                sendJson(response, 200, {
+                    input_tokens: estimateTokens({
+                        system: payload.system ?? null,
+                        messages: payload.messages ?? [],
+                        tools: payload.tools ?? [],
+                    }),
+                });
+                return;
+            }
+            if (request.method === "POST" && url.pathname === "/v1/messages") {
+                const rawBody = await readRequestBody(request);
+                const payload = JSON.parse(rawBody);
+                const { upstream, targetModel } = await callNvidia(config, payload);
+                const choice = upstream.choices?.[0];
+                const mappedContent = mapResponseContent(choice);
+                const anthropicResponse = {
+                    id: upstream.id || `msg_${randomUUID()}`,
+                    type: "message",
+                    role: "assistant",
+                    model: targetModel,
+                    content: mappedContent,
+                    stop_reason: mapStopReason(choice?.finish_reason),
+                    stop_sequence: null,
+                    usage: {
+                        input_tokens: upstream.usage?.prompt_tokens ??
+                            estimateTokens({
+                                system: payload.system ?? null,
+                                messages: payload.messages ?? [],
+                                tools: payload.tools ?? [],
+                            }),
+                        output_tokens: upstream.usage?.completion_tokens ?? 0,
+                    },
+                };
+                if (!payload.stream) {
+                    sendJson(response, 200, anthropicResponse);
+                    return;
+                }
+                response.writeHead(200, {
+                    "Cache-Control": "no-cache, no-transform",
+                    Connection: "keep-alive",
+                    "Content-Type": "text/event-stream",
+                });
+                writeSse(response, "message_start", {
+                    type: "message_start",
+                    message: {
+                        ...anthropicResponse,
+                        content: [],
+                        stop_reason: null,
+                        usage: {
+                            input_tokens: anthropicResponse.usage.input_tokens,
+                            output_tokens: 0,
+                        },
+                    },
+                });
+                mappedContent.forEach((block, index) => {
+                    if (block.type === "text") {
+                        writeSse(response, "content_block_start", {
+                            type: "content_block_start",
+                            index,
+                            content_block: {
+                                type: "text",
+                                text: "",
+                            },
+                        });
+                        for (const chunk of chunkText(block.text)) {
+                            writeSse(response, "content_block_delta", {
+                                type: "content_block_delta",
+                                index,
+                                delta: {
+                                    type: "text_delta",
+                                    text: chunk,
+                                },
+                            });
+                        }
+                        writeSse(response, "content_block_stop", {
+                            type: "content_block_stop",
+                            index,
+                        });
+                        return;
+                    }
+                    if (block.type === "tool_use") {
+                        writeSse(response, "content_block_start", {
+                            type: "content_block_start",
+                            index,
+                            content_block: {
+                                type: "tool_use",
+                                id: block.id,
+                                name: block.name,
+                                input: {},
+                            },
+                        });
+                        writeSse(response, "content_block_delta", {
+                            type: "content_block_delta",
+                            index,
+                            delta: {
+                                type: "input_json_delta",
+                                partial_json: JSON.stringify(block.input ?? {}),
+                            },
+                        });
+                        writeSse(response, "content_block_stop", {
+                            type: "content_block_stop",
+                            index,
+                        });
+                    }
+                });
+                writeSse(response, "message_delta", {
+                    type: "message_delta",
+                    delta: {
+                        stop_reason: anthropicResponse.stop_reason,
+                        stop_sequence: null,
+                    },
+                    usage: {
+                        output_tokens: anthropicResponse.usage.output_tokens,
+                    },
+                });
+                writeSse(response, "message_stop", {
+                    type: "message_stop",
+                });
+                response.end();
+                return;
+            }
+            sendAnthropicError(response, 404, "not_found_error", `Unsupported route: ${request.method || "GET"} ${url.pathname}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            sendAnthropicError(response, 500, "api_error", message);
+        }
+    });
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "nvicode",
+  "version": "0.1.0",
+  "description": "Run Claude Code through NVIDIA-hosted models using a local Anthropic-compatible gateway.",
+  "author": "Dinesh Potla",
+  "keywords": [
+    "claude-code",
+    "nvidia",
+    "kimi",
+    "qwen",
+    "glm",
+    "gateway",
+    "cli"
+  ],
+  "type": "module",
+  "bin": {
+    "nvicode": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsx src/cli.ts"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dineshpotla/nvicode.git"
+  },
+  "homepage": "https://github.com/dineshpotla/nvicode#readme",
+  "bugs": {
+    "url": "https://github.com/dineshpotla/nvicode/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.8",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.2"
+  }
+}