@heventure/model-provider-x 0.1.0

package/dist/cli/tui.js

@@ -0,0 +1,178 @@
+import { emitKeypressEvents } from "node:readline";
+const width = 60;
+const border = `+${"-".repeat(width)}+`;
+export function renderSelect(title, choices, cursor) {
+    return renderFrame(title, choices.map((choice, index) => renderChoiceLine(choice, index, index === cursor)), "Use Up/Down or j/k. Press Enter to confirm.");
+}
+export function renderMultiSelect(title, choices, cursor, selected) {
+    return renderFrame(title, choices.map((choice, index) => renderChoiceLine(choice, index, index === cursor, selected.has(index))), `Selected: ${selected.size}/${choices.filter((choice) => !choice.disabled).length}  |  Space toggles. a selects all. Enter confirms.`);
+}
+export function renderIntro() {
+    return [
+        border,
+        boxLine(color("model-provider-x", "cyan")),
+        boxLine(color("OpenAI-compatible provider setup", "muted")),
+        boxLine(""),
+        boxLine("Validates /models, generates JSON,"),
+        boxLine("and can write opencode.jsonc."),
+        boxLine("API keys are only written when you provide one."),
+        border,
+        ""
+    ].join("\n");
+}
+export function moveCursor(cursor, delta, length) {
+    if (length <= 0) {
+        return 0;
+    }
+    return (cursor + delta + length) % length;
+}
+export function toggleSelectedIndex(selected, index) {
+    const next = new Set(selected);
+    if (next.has(index)) {
+        next.delete(index);
+    }
+    else {
+        next.add(index);
+    }
+    return next;
+}
+export async function selectChoice(title, choices, streams = { input: process.stdin, output: process.stdout }) {
+    const enabledChoices = choices.filter((choice) => !choice.disabled);
+    if (enabledChoices.length === 0) {
+        throw new Error("No selectable choices are available");
+    }
+    const selected = await runKeyMenu((cursor) => renderSelect(title, choices, cursor), choices, streams, () => undefined);
+    return selected.value;
+}
+export async function multiSelectChoices(title, choices, streams = { input: process.stdin, output: process.stdout }) {
+    let selected = new Set(choices.map((choice, index) => (choice.disabled ? -1 : index)).filter((index) => index >= 0));
+    const choice = await runKeyMenu((cursor) => renderMultiSelect(title, choices, cursor, selected), choices, streams, (key, cursor) => {
+        if (key.name === "space") {
+            selected = toggleSelectedIndex(selected, cursor);
+        }
+        if (key.name === "a") {
+            selected =
+                selected.size === choices.filter((item) => !item.disabled).length
+                    ? new Set()
+                    : new Set(choices.map((item, index) => (item.disabled ? -1 : index)).filter((index) => index >= 0));
+        }
+    });
+    if (choice && selected.size === 0) {
+        throw new Error("Select at least one item");
+    }
+    return choices.filter((_choice, index) => selected.has(index)).map((item) => item.value);
+}
+export function canUseTui(input = process.stdin, output = process.stdout) {
+    return Boolean(input.isTTY && output.isTTY && typeof input.setRawMode === "function");
+}
+async function runKeyMenu(render, choices, streams, onKey) {
+    const input = streams.input;
+    const output = streams.output;
+    let cursor = firstEnabledIndex(choices);
+    emitKeypressEvents(input);
+    input.setRawMode(true);
+    input.resume();
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            input.setRawMode(false);
+            input.off("keypress", handleKeypress);
+            output.write("\n");
+        };
+        const draw = () => {
+            output.write("\x1b[2J\x1b[H");
+            output.write(render(cursor));
+        };
+        const handleKeypress = (_chunk, key) => {
+            try {
+                if (key.ctrl && key.name === "c") {
+                    cleanup();
+                    reject(new Error("Cancelled"));
+                    return;
+                }
+                if (key.name === "up" || key.name === "k") {
+                    cursor = nextEnabledIndex(choices, cursor, -1);
+                }
+                else if (key.name === "down" || key.name === "j") {
+                    cursor = nextEnabledIndex(choices, cursor, 1);
+                }
+                else if (key.name === "return") {
+                    cleanup();
+                    resolve(choices[cursor]);
+                    return;
+                }
+                else {
+                    onKey(key, cursor);
+                }
+                draw();
+            }
+            catch (error) {
+                cleanup();
+                reject(error);
+            }
+        };
+        input.on("keypress", handleKeypress);
+        draw();
+    });
+}
+function renderFrame(title, lines, footer) {
+    return [
+        border,
+        boxLine(color("model-provider-x", "cyan")),
+        boxLine(color(title, "bold")),
+        border,
+        ...lines.map((line) => boxLine(line)),
+        border,
+        boxLine(color(footer, "muted")),
+        border,
+        ""
+    ].join("\n");
+}
+function renderChoiceLine(choice, index, active, selected) {
+    const cursor = active ? color(">", "cyan") : " ";
+    const mark = selected === undefined ? "" : `${selected ? color("[x]", "green") : "[ ]"} `;
+    const ordinal = `${index + 1}.`;
+    const hint = choice.hint ? ` - ${choice.hint}` : "";
+    const disabled = choice.disabled ? " (unavailable)" : "";
+    const label = choice.disabled ? color(choice.label, "muted") : choice.label;
+    return `${cursor} ${mark}${ordinal} ${label}${color(hint, "muted")}${color(disabled, "muted")}`;
+}
+function firstEnabledIndex(choices) {
+    const index = choices.findIndex((choice) => !choice.disabled);
+    if (index === -1) {
+        throw new Error("No selectable choices are available");
+    }
+    return index;
+}
+function nextEnabledIndex(choices, cursor, delta) {
+    let next = cursor;
+    do {
+        next = moveCursor(next, delta, choices.length);
+    } while (choices[next].disabled);
+    return next;
+}
+export function stripAnsi(value) {
+    return value.replace(new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g"), "");
+}
+function boxLine(value) {
+    const visible = stripAnsi(value);
+    const trimmed = visible.length > width - 2 ? truncateAnsi(value, width - 5) : value;
+    const padding = width - stripAnsi(trimmed).length - 1;
+    return `| ${trimmed}${" ".repeat(Math.max(0, padding))}|`;
+}
+function truncateAnsi(value, maxVisible) {
+    const plain = stripAnsi(value);
+    return `${plain.slice(0, maxVisible)}...`;
+}
+function color(value, tone) {
+    if (process.env.NO_COLOR) {
+        return value;
+    }
+    const codes = {
+        bold: ["\x1b[1m", "\x1b[22m"],
+        cyan: ["\x1b[36m", "\x1b[39m"],
+        green: ["\x1b[32m", "\x1b[39m"],
+        muted: ["\x1b[2m", "\x1b[22m"]
+    };
+    const [open, close] = codes[tone];
+    return `${open}${value}${close}`;
+}

package/dist/core/config.js

@@ -0,0 +1,102 @@
+import { access, copyFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { applyEdits, format, modify, parse } from "jsonc-parser";
+export function getDefaultConfigPath(homeDir = homedir()) {
+    return join(homeDir, ".config", "opencode", "opencode.jsonc");
+}
+export async function discoverOpenCodeConfigs(options = {}) {
+    const homeDir = options.homeDir ?? homedir();
+    const env = options.env ?? process.env;
+    const candidates = [
+        { path: join(homeDir, ".config", "opencode", "opencode.jsonc"), label: "Global JSONC config" },
+        { path: join(homeDir, ".config", "opencode", "opencode.json"), label: "Global JSON config" },
+        { path: join(homeDir, ".opencode", "opencode.jsonc"), label: "Legacy JSONC config" },
+        { path: join(homeDir, ".opencode", "opencode.json"), label: "Legacy JSON config" }
+    ];
+    if (env.OPENCODE_CONFIG) {
+        candidates.push({ path: env.OPENCODE_CONFIG, label: "OPENCODE_CONFIG" });
+    }
+    if (env.OPENCODE_CONFIG_DIR) {
+        candidates.push({ path: join(env.OPENCODE_CONFIG_DIR, "opencode.jsonc"), label: "OPENCODE_CONFIG_DIR JSONC" });
+        candidates.push({ path: join(env.OPENCODE_CONFIG_DIR, "opencode.json"), label: "OPENCODE_CONFIG_DIR JSON" });
+    }
+    const seen = new Set();
+    const results = [];
+    for (const candidate of candidates) {
+        if (seen.has(candidate.path)) {
+            continue;
+        }
+        seen.add(candidate.path);
+        const exists = await fileExists(candidate.path);
+        if (!exists) {
+            continue;
+        }
+        const writable = await isWritable(candidate.path);
+        const hasProvider = options.providerId ? await configHasProvider(candidate.path, options.providerId) : false;
+        results.push({ ...candidate, exists, writable, hasProvider });
+    }
+    return results;
+}
+export function mergeProviderIntoConfigText(text, providerId, provider) {
+    let source = text.trim() ? text : "{}\n";
+    const errors = [];
+    const parsed = parse(source, errors, { allowTrailingComma: true, disallowComments: false });
+    if (errors.length > 0 || typeof parsed !== "object" || parsed === null) {
+        throw new Error("Selected OpenCode config is not valid JSON/JSONC");
+    }
+    if (!isRecord(parsed.provider)) {
+        source = applyEdits(source, modify(source, ["provider"], {}, { formattingOptions: { insertSpaces: true, tabSize: 2 } }));
+    }
+    const edited = applyEdits(source, modify(source, ["provider", providerId], provider, {
+        formattingOptions: { insertSpaces: true, tabSize: 2 }
+    }));
+    return applyEdits(edited, format(edited, undefined, { insertSpaces: true, tabSize: 2 }));
+}
+export async function writeProviderToConfig(input) {
+    await mkdir(dirname(input.targetPath), { recursive: true });
+    const exists = await fileExists(input.targetPath);
+    const current = exists ? await readFile(input.targetPath, "utf8") : "{}\n";
+    let backupPath;
+    if (exists) {
+        backupPath = `${input.targetPath}.${timestamp()}.bak`;
+        await copyFile(input.targetPath, backupPath);
+    }
+    const next = mergeProviderIntoConfigText(current, input.providerId, input.provider);
+    await writeFile(input.targetPath, next, "utf8");
+    return { targetPath: input.targetPath, backupPath };
+}
+async function configHasProvider(path, providerId) {
+    try {
+        const text = await readFile(path, "utf8");
+        const parsed = parse(text, undefined, { allowTrailingComma: true, disallowComments: false });
+        return isRecord(parsed?.provider) && Object.prototype.hasOwnProperty.call(parsed.provider, providerId);
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function isWritable(path) {
+    try {
+        await access(path, constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function timestamp() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}

package/dist/core/provider.js

@@ -0,0 +1,61 @@
+export function normalizeBaseUrl(baseURL) {
+    const normalized = baseURL.trim().replace(/\/+$/, "");
+    if (!normalized) {
+        throw new Error("API base URL is required");
+    }
+    try {
+        new URL(normalized);
+    }
+    catch {
+        throw new Error("API base URL must be a valid URL");
+    }
+    return normalized;
+}
+export async function validateAndFetchModels(input, fetchImpl = globalThis.fetch) {
+    const baseURL = normalizeBaseUrl(input.baseURL);
+    const apiKey = input.apiKey?.trim() ?? "";
+    const headers = {};
+    if (apiKey) {
+        headers.Authorization = `Bearer ${apiKey}`;
+    }
+    const response = await fetchImpl(`${baseURL}/models`, { headers });
+    if (!response.ok) {
+        throw new Error(`Provider returned ${response.status ?? "an error"} ${response.statusText ?? ""}`.trim());
+    }
+    const body = await response.json();
+    if (!isModelListResponse(body)) {
+        throw new Error("Expected /models to return an object with a data array");
+    }
+    const models = [...new Set(body.data.map((model) => model.id.trim()).filter(Boolean))];
+    if (models.length === 0) {
+        throw new Error("Provider returned no model ids");
+    }
+    return { baseURL, models };
+}
+export function buildProviderConfig(input) {
+    const baseURL = normalizeBaseUrl(input.baseURL);
+    const apiKey = input.apiKey?.trim();
+    const provider = {
+        npm: "@ai-sdk/openai-compatible",
+        name: input.providerName.trim(),
+        options: {
+            baseURL
+        },
+        models: Object.fromEntries(input.models.map((model) => [model, { name: model }]))
+    };
+    if (apiKey) {
+        provider.options.apiKey = apiKey;
+    }
+    return {
+        $schema: "https://opencode.ai/config.json",
+        provider: {
+            [input.providerId.trim()]: provider
+        }
+    };
+}
+function isModelListResponse(body) {
+    return (typeof body === "object" &&
+        body !== null &&
+        Array.isArray(body.data) &&
+        body.data.every((model) => typeof model === "object" && model !== null && typeof model.id === "string"));
+}

package/dist/core/tool-config.js

@@ -0,0 +1,82 @@
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { randomBytes } from "node:crypto";
+import { parse } from "jsonc-parser";
+export function getDefaultToolConfigPath(homeDir = homedir()) {
+    return join(homeDir, ".config", "model-provider-x", "config.jsonc");
+}
+export async function readToolConfig(path = getDefaultToolConfigPath()) {
+    if (!(await fileExists(path))) {
+        return createDefaultToolConfig();
+    }
+    const text = await readFile(path, "utf8");
+    const parsed = parse(text, undefined, { allowTrailingComma: true, disallowComments: false });
+    return normalizeToolConfig(parsed);
+}
+export async function writeToolConfig(path, config) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(normalizeToolConfig(config), null, 2)}\n`, "utf8");
+}
+export async function upsertProviderProfile(path, profile, proxy) {
+    const current = await readToolConfig(path);
+    const next = normalizeToolConfig({
+        ...current,
+        profiles: {
+            ...current.profiles,
+            [profile.id]: profile
+        },
+        proxy: {
+            ...current.proxy,
+            ...proxy
+        }
+    });
+    await writeToolConfig(path, next);
+    return next;
+}
+function createDefaultToolConfig() {
+    return {
+        profiles: {},
+        proxy: {
+            host: "127.0.0.1",
+            port: 4141,
+            authToken: `mpx-${randomBytes(18).toString("base64url")}`
+        }
+    };
+}
+function normalizeToolConfig(config) {
+    const fallback = createDefaultToolConfig();
+    const profiles = isRecord(config.profiles) ? config.profiles : {};
+    const proxy = isRecord(config.proxy) ? config.proxy : {};
+    return {
+        profiles: Object.fromEntries(Object.entries(profiles).map(([id, profile]) => {
+            const value = profile;
+            return [
+                id,
+                {
+                    id: String(value.id ?? id),
+                    name: String(value.name ?? id),
+                    baseURL: String(value.baseURL ?? ""),
+                    apiKey: value.apiKey ? String(value.apiKey) : undefined,
+                    models: Array.isArray(value.models) ? value.models.map(String) : []
+                }
+            ];
+        })),
+        proxy: {
+            host: typeof proxy.host === "string" ? proxy.host : fallback.proxy.host,
+            port: typeof proxy.port === "number" ? proxy.port : fallback.proxy.port,
+            authToken: typeof proxy.authToken === "string" ? proxy.authToken : fallback.proxy.authToken
+        }
+    };
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/proxy/anthropic-chat.js

@@ -0,0 +1,196 @@
+export function anthropicMessageToChatRequest(request) {
+    const messages = [];
+    if (request.system) {
+        messages.push({ role: "system", content: contentToText(request.system) });
+    }
+    for (const message of request.messages) {
+        messages.push(...anthropicMessageToChatMessages(message));
+    }
+    return pruneUndefined({
+        model: request.model,
+        messages,
+        max_tokens: request.max_tokens,
+        temperature: request.temperature,
+        top_p: request.top_p,
+        stop: request.stop_sequences,
+        stream: request.stream,
+        tools: request.tools?.map((tool) => ({
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema
+            }
+        }))
+    });
+}
+export function chatCompletionToAnthropicMessage(response) {
+    const choice = response.choices[0];
+    const content = chatMessageContentToAnthropicBlocks(choice?.message);
+    return {
+        id: `msg_${response.id}`,
+        type: "message",
+        role: "assistant",
+        content,
+        model: response.model,
+        stop_reason: mapFinishReason(choice?.finish_reason),
+        stop_sequence: null,
+        usage: {
+            input_tokens: response.usage?.prompt_tokens ?? 0,
+            output_tokens: response.usage?.completion_tokens ?? 0
+        }
+    };
+}
+export function createAnthropicStreamEvents(chunks, fallbackModel) {
+    const first = chunks.find((chunk) => chunk.id || chunk.model);
+    const id = `msg_${first?.id ?? `stream_${Date.now()}`}`;
+    const model = first?.model ?? fallbackModel;
+    const events = [
+        {
+            event: "message_start",
+            data: {
+                type: "message_start",
+                message: {
+                    id,
+                    type: "message",
+                    role: "assistant",
+                    content: [],
+                    model,
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: { input_tokens: 0, output_tokens: 0 }
+                }
+            }
+        }
+    ];
+    let blockOpen = false;
+    let finishReason;
+    for (const chunk of chunks) {
+        const choice = chunk.choices?.[0];
+        const text = choice?.delta?.content;
+        if (text) {
+            if (!blockOpen) {
+                blockOpen = true;
+                events.push({ event: "content_block_start", data: { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } } });
+            }
+            events.push({ event: "content_block_delta", data: { type: "content_block_delta", index: 0, delta: { type: "text_delta", text } } });
+        }
+        if (choice?.finish_reason) {
+            finishReason = choice.finish_reason;
+        }
+    }
+    if (!blockOpen) {
+        events.push({ event: "content_block_start", data: { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } } });
+    }
+    events.push({ event: "content_block_stop", data: { type: "content_block_stop", index: 0 } });
+    events.push({
+        event: "message_delta",
+        data: { type: "message_delta", delta: { stop_reason: mapFinishReason(finishReason), stop_sequence: null }, usage: { output_tokens: 0 } }
+    });
+    events.push({ event: "message_stop", data: { type: "message_stop" } });
+    return events;
+}
+export function formatSseEvent(event) {
+    return `event: ${event.event}\ndata: ${JSON.stringify(event.data)}\n\n`;
+}
+function anthropicMessageToChatMessages(message) {
+    const blocks = normalizeContent(message.content);
+    const toolResultBlocks = blocks.filter(isToolResultBlock);
+    if (toolResultBlocks.length > 0) {
+        return toolResultBlocks.map((block) => ({
+            role: "tool",
+            tool_call_id: String(block.tool_use_id),
+            content: contentToText(block.content)
+        }));
+    }
+    const toolUseBlocks = blocks.filter(isToolUseBlock);
+    const text = blocks
+        .filter(isTextBlock)
+        .map((block) => block.text)
+        .join("\n");
+    for (const block of blocks) {
+        if (block.type !== "text" && block.type !== "tool_use") {
+            throw new Error(`Unsupported Anthropic content block type: ${block.type}`);
+        }
+    }
+    if (message.role === "assistant") {
+        return [
+            {
+                role: "assistant",
+                content: text,
+                tool_calls: toolUseBlocks.map((block) => ({
+                    id: String(block.id),
+                    type: "function",
+                    function: {
+                        name: String(block.name),
+                        arguments: JSON.stringify(block.input ?? {})
+                    }
+                }))
+            }
+        ];
+    }
+    return [{ role: "user", content: text }];
+}
+function chatMessageContentToAnthropicBlocks(message) {
+    const blocks = [];
+    if (message?.content) {
+        blocks.push({ type: "text", text: message.content });
+    }
+    for (const toolCall of message?.tool_calls ?? []) {
+        blocks.push({
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: parseToolArguments(toolCall.function.arguments)
+        });
+    }
+    return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
+}
+function contentToText(content) {
+    if (!content) {
+        return "";
+    }
+    return normalizeContent(content)
+        .map((block) => {
+        if (block.type === "text") {
+            return String(block.text);
+        }
+        if (isToolResultBlock(block)) {
+            return contentToText(block.content);
+        }
+        throw new Error(`Unsupported Anthropic content block type: ${block.type}`);
+    })
+        .join("\n");
+}
+function normalizeContent(content) {
+    return typeof content === "string" ? [{ type: "text", text: content }] : content;
+}
+function isTextBlock(block) {
+    return block.type === "text";
+}
+function isToolUseBlock(block) {
+    return block.type === "tool_use";
+}
+function isToolResultBlock(block) {
+    return block.type === "tool_result";
+}
+function parseToolArguments(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return {};
+    }
+}
+function mapFinishReason(reason) {
+    if (reason === "length") {
+        return "max_tokens";
+    }
+    if (reason === "tool_calls") {
+        return "tool_use";
+    }
+    return "end_turn";
+}
+function pruneUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}