@heventure/model-provider-x 0.1.0

package/dist/proxy/server.js

@@ -0,0 +1,103 @@
+import { createServer } from "node:http";
+import { anthropicMessageToChatRequest, chatCompletionToAnthropicMessage, createAnthropicStreamEvents, formatSseEvent } from "./anthropic-chat.js";
+import { parseOpenAiSseStream } from "./sse.js";
+export async function startProxyServer(input) {
+    const profile = input.config.profiles[input.profileId];
+    if (!profile) {
+        throw new Error(`Unknown provider profile: ${input.profileId}`);
+    }
+    const host = input.host ?? input.config.proxy.host;
+    const port = input.port ?? input.config.proxy.port;
+    const fetchImpl = input.fetchImpl ?? globalThis.fetch;
+    const authToken = input.config.proxy.authToken;
+    const server = createServer(async (request, response) => {
+        try {
+            if (request.method === "GET" && request.url === "/health") {
+                writeJson(response, 200, { ok: true, profile: profile.id });
+                return;
+            }
+            if (!isAuthorized(request, authToken)) {
+                writeJson(response, 401, { error: { type: "authentication_error", message: "Missing or invalid proxy token" } });
+                return;
+            }
+            if (request.method === "GET" && request.url === "/v1/models") {
+                writeJson(response, 200, {
+                    data: profile.models.map((model) => ({ id: model, display_name: model }))
+                });
+                return;
+            }
+            if (request.method === "POST" && request.url === "/v1/messages") {
+                await handleMessages(request, response, profile, fetchImpl);
+                return;
+            }
+            writeJson(response, 404, { error: { type: "not_found_error", message: "Not found" } });
+        }
+        catch (error) {
+            writeJson(response, statusForError(error), {
+                error: { type: "invalid_request_error", message: error instanceof Error ? error.message : String(error) }
+            });
+        }
+    });
+    await new Promise((resolve) => server.listen(port, host, resolve));
+    const address = server.address();
+    return {
+        baseURL: `http://${address.address}:${address.port}`,
+        close: () => new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())))
+    };
+}
+async function handleMessages(request, response, profile, fetchImpl) {
+    const body = (await readJson(request));
+    const chatRequest = anthropicMessageToChatRequest(body);
+    const upstream = await fetchImpl(`${profile.baseURL.replace(/\/+$/, "")}/chat/completions`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            ...(profile.apiKey ? { Authorization: `Bearer ${profile.apiKey}` } : {})
+        },
+        body: JSON.stringify(chatRequest)
+    });
+    if (!upstream.ok) {
+        const message = upstream.text ? await upstream.text() : upstream.statusText;
+        writeJson(response, upstream.status ?? 502, { error: { type: "upstream_error", message } });
+        return;
+    }
+    if (body.stream) {
+        if (!upstream.body) {
+            throw new Error("Upstream streaming response did not include a body");
+        }
+        const chunks = (await parseOpenAiSseStream(upstream.body));
+        response.writeHead(200, {
+            "content-type": "text/event-stream; charset=utf-8",
+            "cache-control": "no-cache",
+            connection: "keep-alive"
+        });
+        for (const event of createAnthropicStreamEvents(chunks, body.model)) {
+            response.write(formatSseEvent(event));
+        }
+        response.end();
+        return;
+    }
+    if (!upstream.json) {
+        throw new Error("Upstream response did not include JSON");
+    }
+    writeJson(response, 200, chatCompletionToAnthropicMessage((await upstream.json())));
+}
+function isAuthorized(request, authToken) {
+    const authorization = request.headers.authorization;
+    const apiKey = request.headers["x-api-key"];
+    return authorization === `Bearer ${authToken}` || apiKey === authToken;
+}
+async function readJson(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+}
+function writeJson(response, status, body) {
+    response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+    response.end(JSON.stringify(body));
+}
+function statusForError(error) {
+    return error instanceof Error && error.message.startsWith("Unsupported Anthropic content block type") ? 400 : 500;
+}

package/dist/proxy/sse.js

@@ -0,0 +1,37 @@
+export async function parseOpenAiSseStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const chunks = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split(/\n\n/);
+        buffer = parts.pop() ?? "";
+        for (const part of parts) {
+            const parsed = parseSsePart(part);
+            if (parsed !== undefined) {
+                chunks.push(parsed);
+            }
+        }
+    }
+    const parsed = parseSsePart(buffer);
+    if (parsed !== undefined) {
+        chunks.push(parsed);
+    }
+    return chunks;
+}
+function parseSsePart(part) {
+    const data = part
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice("data:".length).trim())
+        .join("\n");
+    if (!data || data === "[DONE]") {
+        return undefined;
+    }
+    return JSON.parse(data);
+}

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/dist/targets/claude-code.js

@@ -0,0 +1,54 @@
+import { copyFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+export function getDefaultClaudeSettingsPath(homeDir = homedir()) {
+    return join(homeDir, ".claude", "settings.json");
+}
+export function mergeClaudeCodeSettings(settings, proxy) {
+    const env = {
+        ...(isRecord(settings.env) ? stringifyRecord(settings.env) : {}),
+        ANTHROPIC_BASE_URL: proxy.baseURL,
+        ANTHROPIC_AUTH_TOKEN: proxy.authToken
+    };
+    if (proxy.enableModelDiscovery) {
+        env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
+    }
+    if (proxy.defaultModel) {
+        env.ANTHROPIC_MODEL = proxy.defaultModel;
+    }
+    return {
+        ...settings,
+        env
+    };
+}
+export async function writeClaudeCodeSettings(input) {
+    const targetPath = input.targetPath ?? getDefaultClaudeSettingsPath();
+    await mkdir(dirname(targetPath), { recursive: true });
+    const exists = await fileExists(targetPath);
+    const current = exists ? JSON.parse(await readFile(targetPath, "utf8")) : {};
+    let backupPath;
+    if (exists) {
+        backupPath = `${targetPath}.${timestamp()}.bak`;
+        await copyFile(targetPath, backupPath);
+    }
+    const next = mergeClaudeCodeSettings(current, input.proxy);
+    await writeFile(targetPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    return { targetPath, backupPath };
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function stringifyRecord(record) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, String(value)]));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function timestamp() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@heventure/model-provider-x",
+  "version": "0.1.0",
+  "description": "TUI configurator and local API proxy for wiring custom model providers into OpenCode and Claude Code.",
+  "private": false,
+  "license": "MIT",
+  "author": "HHWY Inc.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HughesCuit/model-provider-x.git"
+  },
+  "bugs": {
+    "url": "https://github.com/HughesCuit/model-provider-x/issues"
+  },
+  "homepage": "https://github.com/HughesCuit/model-provider-x#readme",
+  "type": "module",
+  "main": "dist/cli/index.js",
+  "bin": {
+    "model-provider-x": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "start": "node dist/cli/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint . --ext .ts,.tsx",
+    "format": "prettier --write ."
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.3.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/node": "^24.0.0",
+    "eslint": "^9.0.0",
+    "prettier": "^3.0.0",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^3.0.0"
+  }
+}