@heventure/model-provider-x 0.1.1 → 0.2.0

package/README.md

@@ -8,6 +8,7 @@ It currently supports:
 - Claude Code setup through a local Anthropic Messages-compatible proxy.
 - OpenAI-compatible `/v1/models` discovery.
 - Anthropic Messages API to OpenAI Chat Completions API conversion.
+- OpenAI Responses API to OpenAI Chat Completions API conversion for Codex.
 - Non-streaming and streaming SSE proxy responses.
 
 ## Install
@@ -56,19 +57,65 @@ node dist/cli/index.js setup --target claude-code \
 Then start the local proxy:
 
 ```bash
-node dist/cli/index.js proxy --profile unsloth
+node dist/cli/index.js proxy up --profile unsloth
 ```
 
 The Claude Code setup writes gateway environment values to `~/.claude/settings.json`.
 Upstream provider keys are stored in `~/.config/model-provider-x/config.jsonc`, not in Claude Code settings.
 
+## Codex Setup
+
+Create or update a provider profile and write Codex user config:
+
+```bash
+node dist/cli/index.js setup --target codex \
+  --provider lmstudio
+```
+
+Then start the local proxy:
+
+```bash
+node dist/cli/index.js proxy up --profile lmstudio
+```
+
+The Codex setup writes a Responses-compatible provider to `~/.codex/config.toml`.
+It also configures command-backed authentication so Codex can fetch the local proxy token automatically.
+The proxy currently supports non-streaming `/v1/responses` requests and forwards them to upstream OpenAI-compatible `/v1/chat/completions`.
+
+## Unified Setup Flow
+
+Use the unified setup wizard to install a provider into OpenCode, Codex, or Claude Code:
+
+```bash
+node dist/cli/index.js setup --provider lmstudio
+```
+
+The wizard asks whether to write the agent config through the local compatibility proxy before choosing the target agent.
+Proxy mode gives the broadest compatibility:
+
+- `/v1/responses` for Codex.
+- `/v1/chat/completions` and `/v1/completions` passthrough for OpenAI-compatible clients.
+- `/v1/messages` for Claude Code.
+
+You can force either mode non-interactively:
+
+```bash
+node dist/cli/index.js setup --target codex --provider lmstudio --proxy
+node dist/cli/index.js setup --target opencode --provider lmstudio --direct
+```
+
 ## Commands
 
 ```bash
 npx @heventure/model-provider-x --help
 npx @heventure/model-provider-x setup --target claude-code
+npx @heventure/model-provider-x setup --target codex
 npx @heventure/model-provider-x proxy --profile <id>
+npx @heventure/model-provider-x proxy up --profile <id>
+npx @heventure/model-provider-x proxy status
+npx @heventure/model-provider-x proxy down
 npx @heventure/model-provider-x config print --profile <id>
+npx @heventure/model-provider-x config api-key --profile <id>
 ```
 
 ## Development

package/dist/cli/args.js

@@ -35,6 +35,12 @@ export function parseCliArgs(argv) {
             case "--provider":
                 options.providerPreset = next();
                 break;
+            case "--proxy":
+                options.proxy = true;
+                break;
+            case "--direct":
+                options.proxy = false;
+                break;
             case "--print":
                 options.print = true;
                 break;
@@ -93,6 +99,8 @@ Options:
   --name <name>        Provider display name.
   --id <id>            Provider id used under provider.<id>.
   --provider <id>      Use a built-in provider preset, for example lmstudio or openai.
+  --proxy              Write agent config through the local compatibility proxy.
+  --direct             Write agent config directly to the upstream provider.
   --models <list>      Comma-separated model ids. Skips interactive model selection.
   --config <path>      OpenCode config path to write.
   --print              Print generated JSON and do not write config.

package/dist/cli/commands.js

@@ -21,13 +21,18 @@ export function parseCommand(argv) {
 export function commandUsage() {
     return `${usage()}
 Commands:
-  model-provider-x setup --target <opencode|claude-code> [options]
+  model-provider-x setup --target <opencode|claude-code|codex> [options]
   model-provider-x proxy --profile <id> [--host 127.0.0.1] [--port 4141]
+  model-provider-x proxy up --profile <id> [--host 127.0.0.1] [--port 4141]
+  model-provider-x proxy down
+  model-provider-x proxy status
+  model-provider-x proxy token
   model-provider-x config print --profile <id>
+  model-provider-x config api-key --profile <id>
 `;
 }
 function parseSetupCommand(argv) {
-    let target = "opencode";
+    let target;
     let profileId;
     let port;
     let host;
@@ -66,13 +71,18 @@ function parseSetupCommand(argv) {
     return { command: "setup", target, profileId, port, host, defaultModel, options: parseCliArgs(providerArgs) };
 }
 function parseProxyCommand(argv) {
+    let action = "run";
+    const args = [...argv];
+    if (args[0] === "up" || args[0] === "down" || args[0] === "status" || args[0] === "token") {
+        action = args.shift();
+    }
     let profileId;
     let host;
     let port;
-    for (let index = 0; index < argv.length; index += 1) {
-        const arg = argv[index];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
         const next = () => {
-            const value = argv[index + 1];
+            const value = args[index + 1];
             if (!value || value.startsWith("--")) {
                 throw new Error(`${arg} requires a value`);
             }
@@ -96,14 +106,14 @@ function parseProxyCommand(argv) {
                 throw new Error(`Unknown proxy argument: ${arg}`);
         }
     }
-    if (!profileId) {
+    if ((action === "run" || action === "up") && !profileId) {
         throw new Error("--profile is required");
     }
-    return { command: "proxy", profileId, host, port };
+    return { command: "proxy", action, profileId, host, port };
 }
 function parseConfigCommand(argv) {
     const [subcommand, ...rest] = argv;
-    if (subcommand !== "print") {
+    if (subcommand !== "print" && subcommand !== "api-key") {
         throw new Error(`Unknown config command: ${subcommand ?? ""}`.trim());
     }
     let profileId;
@@ -122,10 +132,10 @@ function parseConfigCommand(argv) {
     if (!profileId) {
         throw new Error("--profile is required");
     }
-    return { command: "config-print", profileId };
+    return { command: subcommand === "api-key" ? "config-api-key" : "config-print", profileId };
 }
 function parseTarget(value) {
-    if (value === "opencode" || value === "claude-code") {
+    if (value === "opencode" || value === "claude-code" || value === "codex") {
         return value;
     }
     throw new Error(`Unknown setup target: ${value}`);

package/dist/cli/index.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
+import { fileURLToPath } from "node:url";
+import { readProxyStatus, startProxyProcess, stopProxyProcess } from "../core/proxy-process.js";
 import { getDefaultToolConfigPath, readToolConfig, upsertProviderProfile } from "../core/tool-config.js";
 import { discoverOpenCodeConfigs, getDefaultConfigPath, writeProviderToConfig } from "../core/config.js";
-import { buildProviderConfig, validateAndFetchModels } from "../core/provider.js";
+import { buildProviderConfig, detectProviderCapabilities, recommendProxyMode, validateAndFetchModels } from "../core/provider.js";
 import { startProxyServer } from "../proxy/server.js";
 import { getDefaultClaudeSettingsPath, writeClaudeCodeSettings } from "../targets/claude-code.js";
+import { getDefaultCodexConfigPath, writeCodexConfig } from "../targets/codex.js";
 import { HelpRequested, parseModelSelection } from "./args.js";
 import { commandUsage, parseCommand } from "./commands.js";
 import { createModelChoices } from "./model-choices.js";
@@ -43,22 +46,16 @@ export async function runCommand(command) {
         output.write(`${JSON.stringify(profile, null, 2)}\n`);
         return;
     }
-    const config = await readToolConfig();
-    const server = await startProxyServer({
-        profileId: command.profileId,
-        config,
-        host: command.host,
-        port: command.port
-    });
-    output.write(`model-provider-x proxy listening at ${server.baseURL}\n`);
-    await new Promise((resolve) => {
-        const stop = async () => {
-            await server.close();
-            resolve();
-        };
-        process.once("SIGINT", stop);
-        process.once("SIGTERM", stop);
-    });
+    if (command.command === "config-api-key") {
+        const config = await readToolConfig();
+        const profile = config.profiles[command.profileId];
+        if (!profile?.apiKey) {
+            throw new Error(`No API key stored for provider profile: ${command.profileId}`);
+        }
+        output.write(`${profile.apiKey}\n`);
+        return;
+    }
+    await runProxyCommand(command);
 }
 export async function runCli(options) {
     const rl = createInterface({ input, output });
@@ -107,59 +104,211 @@ export async function runCli(options) {
     }
 }
 async function runSetup(command) {
-    if (command.target === "opencode") {
-        await runCli(command.options);
-        return;
-    }
-    await runClaudeCodeSetup(command);
-}
-async function runClaudeCodeSetup(command) {
     const rl = createInterface({ input, output });
     try {
         output.write(canUseTui() ? renderIntro() : "model-provider-x\n\n");
-        const providerDefaults = await resolveProviderDefaults(rl, command.options);
-        const providerName = await requiredOption(rl, command.options.providerName ?? providerDefaults.name, "Provider name");
-        const providerId = await requiredOption(rl, command.profileId ?? command.options.providerId ?? providerDefaults.id ?? slugify(providerName), "Provider id");
-        const baseURL = await requiredOption(rl, command.options.baseURL ?? providerDefaults.baseURL, "API base URL");
-        const apiKey = await resolveApiKey(rl, command.options.apiKey, providerDefaults.preset, "Upstream API key");
-        output.write("Fetching models...\n");
-        const fetched = await validateAndFetchModels({ baseURL, apiKey });
-        const selectedModels = command.options.models ??
-            (canUseTui()
-                ? await multiSelectChoices("Select Claude Code gateway models", createModelChoices(fetched.models))
-                : parseModelSelection(await rl.question(formatModelPrompt(fetched.models)), fetched.models));
-        const toolConfigPath = getDefaultToolConfigPath();
-        const config = await upsertProviderProfile(toolConfigPath, {
-            id: providerId,
-            name: providerName,
-            baseURL: fetched.baseURL,
-            apiKey: apiKey.trim() || undefined,
-            models: selectedModels
-        }, {
-            host: command.host,
-            port: command.port
-        });
-        const proxyBaseURL = `http://${config.proxy.host}:${config.proxy.port}`;
-        const result = await writeClaudeCodeSettings({
-            targetPath: getDefaultClaudeSettingsPath(),
-            proxy: {
-                baseURL: proxyBaseURL,
-                authToken: config.proxy.authToken,
-                enableModelDiscovery: true,
-                defaultModel: command.defaultModel
-            }
-        });
-        output.write(`Saved profile ${providerId} to ${toolConfigPath}\n`);
-        output.write(`Updated Claude Code settings: ${result.targetPath}\n`);
-        if (result.backupPath) {
-            output.write(`Backup: ${result.backupPath}\n`);
+        const providerInput = await collectProviderInput(rl, command);
+        output.write("Detecting provider capabilities...\n");
+        const capabilities = await detectProviderCapabilities({ baseURL: providerInput.baseURL, apiKey: providerInput.apiKey });
+        const target = await resolveSetupTarget(rl, command.target);
+        const useProxy = await resolveProxyMode(rl, command.options, capabilities, target);
+        const selection = await collectProviderSelection(rl, command, target, providerInput);
+        if (target === "opencode") {
+            await writeOpenCodeSetup(rl, command, selection, useProxy);
+            return;
         }
-        output.write(`Run proxy: model-provider-x proxy --profile ${providerId}\n`);
+        if (target === "codex") {
+            await writeCodexSetup(command, selection, useProxy);
+            return;
+        }
+        await writeClaudeCodeSetup(command, selection, useProxy);
     }
     finally {
         rl.close();
     }
 }
+async function collectProviderInput(rl, command) {
+    const providerDefaults = await resolveProviderDefaults(rl, command.options);
+    const providerName = await requiredOption(rl, command.options.providerName ?? providerDefaults.name, "Provider name");
+    const providerId = await requiredOption(rl, command.profileId ?? command.options.providerId ?? providerDefaults.id ?? slugify(providerName), "Provider id");
+    const baseURL = await requiredOption(rl, command.options.baseURL ?? providerDefaults.baseURL, "API base URL");
+    const apiKey = await resolveApiKey(rl, command.options.apiKey, providerDefaults.preset, "Upstream API key");
+    return { providerId, providerName, baseURL, apiKey };
+}
+async function collectProviderSelection(rl, command, target, providerInput) {
+    output.write("Fetching models...\n");
+    const fetched = await validateAndFetchModels({ baseURL: providerInput.baseURL, apiKey: providerInput.apiKey });
+    const selectedModels = command.options.models ??
+        (canUseTui()
+            ? await multiSelectChoices(target === "codex"
+                ? "Select Codex Responses gateway models"
+                : target === "claude-code"
+                    ? "Select Claude Code gateway models"
+                    : "Select models", createModelChoices(fetched.models))
+            : parseModelSelection(await rl.question(formatModelPrompt(fetched.models)), fetched.models));
+    const defaultModel = command.defaultModel ?? selectedModels[0];
+    if (!defaultModel) {
+        throw new Error("Select at least one model");
+    }
+    const toolConfigPath = getDefaultToolConfigPath();
+    const config = await upsertProviderProfile(toolConfigPath, {
+        id: providerInput.providerId,
+        name: providerInput.providerName,
+        baseURL: fetched.baseURL,
+        apiKey: providerInput.apiKey.trim() || undefined,
+        models: selectedModels
+    }, {
+        host: command.host,
+        port: command.port
+    });
+    return {
+        providerId: providerInput.providerId,
+        providerName: providerInput.providerName,
+        upstreamBaseURL: fetched.baseURL,
+        apiKey: providerInput.apiKey,
+        selectedModels,
+        defaultModel,
+        config,
+        toolConfigPath
+    };
+}
+async function writeOpenCodeSetup(rl, command, selection, useProxy) {
+    const baseURL = useProxy ? `http://${selection.config.proxy.host}:${selection.config.proxy.port}/v1` : selection.upstreamBaseURL;
+    const apiKey = useProxy ? selection.config.proxy.authToken : selection.apiKey;
+    const fragment = buildProviderConfig({
+        providerId: selection.providerId,
+        providerName: selection.providerName,
+        baseURL,
+        apiKey,
+        models: selection.selectedModels
+    });
+    const provider = fragment.provider[selection.providerId];
+    const targetPath = command.options.configPath ?? (await chooseConfigPath(rl, selection.providerId, command.options.yes));
+    if (!targetPath) {
+        output.write(`${JSON.stringify(fragment, null, 2)}\n`);
+        return;
+    }
+    const result = await writeProviderToConfig({ targetPath, providerId: selection.providerId, provider });
+    output.write(`Saved profile ${selection.providerId} to ${selection.toolConfigPath}\n`);
+    output.write(`Updated ${result.targetPath}\n`);
+    if (result.backupPath) {
+        output.write(`Backup: ${result.backupPath}\n`);
+    }
+    if (useProxy) {
+        const proxy = await startProxyProcess({
+            profileId: selection.providerId,
+            config: selection.config,
+            entrypoint: fileURLToPath(import.meta.url),
+            replace: true
+        });
+        output.write(`Started proxy: ${proxy.baseURL}\n`);
+    }
+}
+async function writeClaudeCodeSetup(command, selection, useProxy) {
+    const proxyBaseURL = useProxy ? `http://${selection.config.proxy.host}:${selection.config.proxy.port}` : selection.upstreamBaseURL;
+    const result = await writeClaudeCodeSettings({
+        targetPath: getDefaultClaudeSettingsPath(),
+        proxy: {
+            baseURL: proxyBaseURL,
+            authToken: useProxy ? selection.config.proxy.authToken : selection.apiKey,
+            enableModelDiscovery: useProxy,
+            defaultModel: command.defaultModel
+        }
+    });
+    output.write(`Saved profile ${selection.providerId} to ${selection.toolConfigPath}\n`);
+    output.write(`Updated Claude Code settings: ${result.targetPath}\n`);
+    if (result.backupPath) {
+        output.write(`Backup: ${result.backupPath}\n`);
+    }
+    if (useProxy) {
+        const proxy = await startProxyProcess({
+            profileId: selection.providerId,
+            config: selection.config,
+            entrypoint: fileURLToPath(import.meta.url),
+            replace: true
+        });
+        output.write(`Started proxy: ${proxy.baseURL}\n`);
+    }
+}
+async function writeCodexSetup(_command, selection, useProxy) {
+    const proxyBaseURL = useProxy
+        ? `http://${selection.config.proxy.host}:${selection.config.proxy.port}/v1`
+        : selection.upstreamBaseURL;
+    const result = await writeCodexConfig({
+        targetPath: getDefaultCodexConfigPath(),
+        providerId: selection.providerId,
+        providerName: selection.providerName,
+        baseURL: proxyBaseURL,
+        authCommand: "model-provider-x",
+        authArgs: useProxy ? ["proxy", "token"] : ["config", "api-key", "--profile", selection.providerId],
+        model: selection.defaultModel
+    });
+    output.write(`Saved profile ${selection.providerId} to ${selection.toolConfigPath}\n`);
+    output.write(`Updated Codex config: ${result.targetPath}\n`);
+    if (result.backupPath) {
+        output.write(`Backup: ${result.backupPath}\n`);
+    }
+    if (useProxy) {
+        const proxy = await startProxyProcess({
+            profileId: selection.providerId,
+            config: selection.config,
+            entrypoint: fileURLToPath(import.meta.url),
+            replace: true
+        });
+        output.write(`Started proxy: ${proxy.baseURL}\n`);
+    }
+}
+async function runProxyCommand(command) {
+    if (command.action === "up") {
+        const config = await readToolConfig();
+        const state = await startProxyProcess({
+            profileId: command.profileId,
+            config,
+            host: command.host,
+            port: command.port,
+            entrypoint: fileURLToPath(import.meta.url)
+        });
+        output.write(`Proxy running at ${state.baseURL} for profile ${state.profileId}\n`);
+        return;
+    }
+    if (command.action === "down") {
+        const status = await stopProxyProcess();
+        output.write(status.state ? `Stopped proxy for profile ${status.state.profileId}\n` : "Proxy is not running\n");
+        return;
+    }
+    if (command.action === "status") {
+        const status = await readProxyStatus();
+        if (!status.state) {
+            output.write("Proxy is not running\n");
+            return;
+        }
+        output.write(status.running
+            ? `Proxy is running at ${status.state.baseURL} for profile ${status.state.profileId} (pid ${status.state.pid})\n`
+            : `Proxy state exists but process ${status.state.pid} is not running\n`);
+        return;
+    }
+    if (command.action === "token") {
+        const config = await readToolConfig();
+        output.write(`${config.proxy.authToken}\n`);
+        return;
+    }
+    const config = await readToolConfig();
+    const server = await startProxyServer({
+        profileId: command.profileId,
+        config,
+        host: command.host,
+        port: command.port
+    });
+    output.write(`model-provider-x proxy listening at ${server.baseURL}\n`);
+    await new Promise((resolve) => {
+        const stop = async () => {
+            await server.close();
+            resolve();
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+    });
+}
 async function requiredOption(rl, value, label) {
     const answer = value ?? (await rl.question(`${label}: `));
     if (!answer.trim()) {
@@ -186,6 +335,48 @@ async function resolveProviderDefaults(rl, options) {
         preset
     };
 }
+async function resolveProxyMode(rl, options, capabilities, target) {
+    if (options.proxy !== undefined) {
+        return options.proxy;
+    }
+    const recommendedProxy = recommendProxyMode(capabilities, target);
+    if (canUseTui()) {
+        return selectChoice("Connection mode", [
+            {
+                label: "Direct provider config",
+                value: false,
+                hint: recommendedProxy ? "target API not detected" : "recommended"
+            },
+            {
+                label: "Use compatibility proxy",
+                value: true,
+                hint: recommendedProxy ? "recommended" : "maximum compatibility"
+            }
+        ]);
+    }
+    const prompt = recommendedProxy ? "Use compatibility proxy? [Y/n] " : "Use direct provider config? [Y/n] ";
+    const answer = await rl.question(prompt);
+    const accepted = !answer.trim() || answer.trim().toLowerCase() === "y";
+    return recommendedProxy ? accepted : !accepted;
+}
+async function resolveSetupTarget(rl, target) {
+    if (target) {
+        return target;
+    }
+    if (canUseTui()) {
+        return selectChoice("Choose agent platform", [
+            { label: "OpenCode", value: "opencode" },
+            { label: "Codex", value: "codex" },
+            { label: "Claude Code", value: "claude-code" }
+        ]);
+    }
+    const answer = await rl.question("Agent platform [opencode/codex/claude-code]: ");
+    const value = answer.trim() || "opencode";
+    if (value === "opencode" || value === "codex" || value === "claude-code") {
+        return value;
+    }
+    throw new Error(`Unknown setup target: ${value}`);
+}
 async function resolveApiKey(rl, apiKey, preset, label = "API key") {
     if (apiKey !== undefined) {
         return apiKey;

package/dist/core/provider.js

@@ -37,6 +37,37 @@ export async function validateAndFetchModels(input, fetchImpl = globalThis.fetch
     }
     return { baseURL, models };
 }
+export async function detectProviderCapabilities(input, fetchImpl = globalThis.fetch) {
+    const baseURL = normalizeBaseUrl(input.baseURL);
+    const apiKey = input.apiKey?.trim() ?? "";
+    const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+    const apis = new Set();
+    const models = await probe(`${baseURL}/models`, { method: "GET", headers }, fetchImpl);
+    if (models.reachable) {
+        apis.add("openai-compatible");
+    }
+    const responses = await probe(`${baseURL}/responses`, { method: "POST", headers: { ...headers, "content-type": "application/json" }, body: "{}" }, fetchImpl);
+    if (responses.reachable) {
+        apis.add("openai-responses");
+    }
+    const messages = await probe(`${baseURL}/messages`, { method: "POST", headers: { ...headers, "content-type": "application/json" }, body: "{}" }, fetchImpl);
+    if (messages.reachable) {
+        apis.add("anthropic-messages");
+    }
+    return { baseURL, apis: [...apis] };
+}
+export function targetRequiredApi(target) {
+    if (target === "codex") {
+        return "openai-responses";
+    }
+    if (target === "claude-code") {
+        return "anthropic-messages";
+    }
+    return "openai-compatible";
+}
+export function recommendProxyMode(capabilities, target) {
+    return !capabilities.apis.includes(targetRequiredApi(target));
+}
 export function buildProviderConfig(input) {
     const baseURL = normalizeBaseUrl(input.baseURL);
     const apiKey = input.apiKey?.trim();
@@ -70,3 +101,12 @@ function isOpenCodeCompatibleModel(model) {
     }
     return ["llm", "chat", "completion", "text-generation"].includes(model.type.trim().toLowerCase());
 }
+async function probe(input, init, fetchImpl) {
+    try {
+        const response = await fetchImpl(input, init);
+        return { reachable: response.ok || response.status === 400 || response.status === 401 || response.status === 422 };
+    }
+    catch {
+        return { reachable: false };
+    }
+}

package/dist/core/proxy-process.js

@@ -0,0 +1,102 @@
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+export function getDefaultProxyStatePath(homeDir = homedir()) {
+    return join(homeDir, ".config", "model-provider-x", "proxy.json");
+}
+export async function readProxyStatus(path = getDefaultProxyStatePath()) {
+    const state = await readProxyState(path);
+    if (!state) {
+        return { running: false };
+    }
+    return { running: isProcessRunning(state.pid), state };
+}
+export async function startProxyProcess(input) {
+    const profile = input.config.profiles[input.profileId];
+    if (!profile) {
+        throw new Error(`Unknown provider profile: ${input.profileId}`);
+    }
+    const statePath = input.statePath ?? getDefaultProxyStatePath();
+    const current = await readProxyStatus(statePath);
+    if (current.running && current.state?.profileId === input.profileId) {
+        return current.state;
+    }
+    if (current.running && current.state) {
+        if (input.replace) {
+            await stopProxyProcess(statePath);
+        }
+        else {
+            throw new Error(`Proxy is already running for profile ${current.state.profileId}`);
+        }
+    }
+    const host = input.host ?? input.config.proxy.host;
+    const port = input.port ?? input.config.proxy.port;
+    const entrypoint = input.entrypoint ?? process.argv[1];
+    const child = spawn(input.nodePath ?? process.execPath, [entrypoint, "proxy", "--profile", input.profileId, "--host", host, "--port", String(port)], {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env, MODEL_PROVIDER_X_API_KEY: input.config.proxy.authToken }
+    });
+    child.unref();
+    const state = {
+        pid: child.pid ?? 0,
+        profileId: input.profileId,
+        baseURL: `http://${host}:${port}`,
+        authToken: input.config.proxy.authToken,
+        startedAt: new Date().toISOString()
+    };
+    await writeProxyState(statePath, state);
+    return state;
+}
+export async function stopProxyProcess(path = getDefaultProxyStatePath()) {
+    const state = await readProxyState(path);
+    if (!state) {
+        return { running: false };
+    }
+    if (isProcessRunning(state.pid)) {
+        process.kill(state.pid, "SIGTERM");
+    }
+    await rm(path, { force: true });
+    return { running: false, state };
+}
+async function readProxyState(path) {
+    if (!(await fileExists(path))) {
+        return undefined;
+    }
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    if (typeof parsed.pid !== "number" || typeof parsed.profileId !== "string") {
+        return undefined;
+    }
+    return {
+        pid: parsed.pid,
+        profileId: parsed.profileId,
+        baseURL: String(parsed.baseURL ?? ""),
+        authToken: String(parsed.authToken ?? ""),
+        startedAt: String(parsed.startedAt ?? "")
+    };
+}
+async function writeProxyState(path, state) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+function isProcessRunning(pid) {
+    if (!pid) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/proxy/responses.js

@@ -0,0 +1,107 @@
+export function responsesToChatCompletionRequest(request) {
+    if (request.stream) {
+        throw new Error("Responses streaming is not supported yet");
+    }
+    const messages = [];
+    if (request.instructions) {
+        messages.push({ role: "system", content: request.instructions });
+    }
+    if (typeof request.input === "string") {
+        messages.push({ role: "user", content: request.input });
+    }
+    else {
+        for (const item of request.input) {
+            messages.push(responsesInputItemToChatMessage(item));
+        }
+    }
+    return pruneUndefined({
+        model: request.model,
+        messages,
+        max_tokens: request.max_output_tokens,
+        temperature: request.temperature,
+        top_p: request.top_p,
+        tools: request.tools?.map((tool) => ({
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters ?? {}
+            }
+        }))
+    });
+}
+export function chatCompletionToResponses(response) {
+    const choice = response.choices[0];
+    const message = choice?.message;
+    const output = [];
+    if (message?.content) {
+        output.push({
+            id: `msg_${response.id}`,
+            type: "message",
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text: message.content, annotations: [] }]
+        });
+    }
+    for (const toolCall of message?.tool_calls ?? []) {
+        output.push({
+            id: toolCall.id,
+            type: "function_call",
+            status: "completed",
+            call_id: toolCall.id,
+            name: toolCall.function.name,
+            arguments: toolCall.function.arguments
+        });
+    }
+    return {
+        id: `resp_${response.id}`,
+        object: "response",
+        status: "completed",
+        model: response.model,
+        output,
+        output_text: outputText(output),
+        usage: {
+            input_tokens: response.usage?.prompt_tokens ?? 0,
+            output_tokens: response.usage?.completion_tokens ?? 0
+        }
+    };
+}
+function responsesInputItemToChatMessage(item) {
+    if (item.type === "function_call_output") {
+        return { role: "tool", tool_call_id: item.call_id, content: item.output };
+    }
+    const content = responsesContentToText(item.content);
+    if (item.role === "assistant") {
+        return { role: "assistant", content };
+    }
+    return {
+        role: item.role === "user" ? "user" : "system",
+        content
+    };
+}
+function responsesContentToText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .map((part) => {
+        if (part.type === "input_text" || part.type === "output_text" || part.type === "text") {
+            return part.text;
+        }
+        throw new Error(`Unsupported Responses content part type: ${part.type ?? "unknown"}`);
+    })
+        .join("\n");
+}
+function outputText(output) {
+    return output
+        .flatMap((item) => (Array.isArray(item.content) ? item.content : []))
+        .filter((part) => isRecord(part) && part.type === "output_text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function pruneUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}

package/dist/proxy/server.js

@@ -1,5 +1,6 @@
 import { createServer } from "node:http";
 import { anthropicMessageToChatRequest, chatCompletionToAnthropicMessage, createAnthropicStreamEvents, formatSseEvent } from "./anthropic-chat.js";
+import { chatCompletionToResponses, responsesToChatCompletionRequest } from "./responses.js";
 import { parseOpenAiSseStream } from "./sse.js";
 export async function startProxyServer(input) {
     const profile = input.config.profiles[input.profileId];
@@ -30,6 +31,14 @@ export async function startProxyServer(input) {
                 await handleMessages(request, response, profile, fetchImpl);
                 return;
             }
+            if (request.method === "POST" && (request.url === "/v1/chat/completions" || request.url === "/v1/completions")) {
+                await passthroughOpenAi(request, response, profile, fetchImpl, request.url);
+                return;
+            }
+            if (request.method === "POST" && request.url === "/v1/responses") {
+                await handleResponses(request, response, profile, fetchImpl);
+                return;
+            }
             writeJson(response, 404, { error: { type: "not_found_error", message: "Not found" } });
         }
         catch (error) {
@@ -45,6 +54,65 @@ export async function startProxyServer(input) {
         close: () => new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())))
     };
 }
+async function passthroughOpenAi(request, response, profile, fetchImpl, path) {
+    const body = await readRaw(request);
+    const upstream = await fetchImpl(`${profile.baseURL.replace(/\/+$/, "")}${path.replace(/^\/v1/, "")}`, {
+        method: "POST",
+        headers: {
+            "content-type": request.headers["content-type"] ?? "application/json",
+            ...(profile.apiKey ? { Authorization: `Bearer ${profile.apiKey}` } : {})
+        },
+        body: new Uint8Array(body)
+    });
+    if (!upstream.ok) {
+        const message = upstream.text ? await upstream.text() : upstream.statusText;
+        writeJson(response, upstream.status ?? 502, { error: { type: "upstream_error", message } });
+        return;
+    }
+    if (isStreamingOpenAiRequest(body) && upstream.body) {
+        response.writeHead(200, {
+            "content-type": "text/event-stream; charset=utf-8"
+        });
+        for await (const chunk of upstream.body) {
+            response.write(Buffer.from(chunk));
+        }
+        response.end();
+        return;
+    }
+    if (!upstream.json) {
+        throw new Error("Upstream response did not include JSON");
+    }
+    writeJson(response, 200, await upstream.json());
+}
+function isStreamingOpenAiRequest(body) {
+    try {
+        return Boolean(JSON.parse(body.toString("utf8")).stream);
+    }
+    catch {
+        return false;
+    }
+}
+async function handleResponses(request, response, profile, fetchImpl) {
+    const body = (await readJson(request));
+    const chatRequest = responsesToChatCompletionRequest(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 (!upstream.json) {
+        throw new Error("Upstream response did not include JSON");
+    }
+    writeJson(response, 200, chatCompletionToResponses((await upstream.json())));
+}
 async function handleMessages(request, response, profile, fetchImpl) {
     const body = (await readJson(request));
     const chatRequest = anthropicMessageToChatRequest(body);
@@ -88,11 +156,14 @@ function isAuthorized(request, authToken) {
     return authorization === `Bearer ${authToken}` || apiKey === authToken;
 }
 async function readJson(request) {
+    return JSON.parse((await readRaw(request)).toString("utf8") || "{}");
+}
+async function readRaw(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") || "{}");
+    return Buffer.concat(chunks);
 }
 function writeJson(response, status, body) {
     response.writeHead(status, { "content-type": "application/json; charset=utf-8" });

package/dist/targets/codex.js

@@ -0,0 +1,84 @@
+import { copyFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export function getDefaultCodexConfigPath(homeDir = homedir()) {
+    return join(homeDir, ".codex", "config.toml");
+}
+export function mergeCodexConfig(text, provider) {
+    let next = text.trimEnd();
+    next = upsertTopLevelString(next, "model", provider.model);
+    next = upsertTopLevelString(next, "model_provider", provider.providerId);
+    next = removeTable(next, `model_providers.${quoteTomlKey(provider.providerId)}`);
+    const providerBlock = [
+        `[model_providers.${quoteTomlKey(provider.providerId)}]`,
+        `name = ${quoteTomlString(provider.providerName)}`,
+        `base_url = ${quoteTomlString(provider.baseURL)}`,
+        'wire_api = "responses"',
+        "",
+        `[model_providers.${quoteTomlKey(provider.providerId)}.auth]`,
+        `command = ${quoteTomlString(provider.authCommand)}`,
+        `args = [${provider.authArgs.map(quoteTomlString).join(", ")}]`,
+        "refresh_interval_ms = 0"
+    ].join("\n");
+    return `${next.trimEnd()}\n\n${providerBlock}\n`;
+}
+export async function writeCodexConfig(input) {
+    const targetPath = input.targetPath ?? getDefaultCodexConfigPath();
+    await mkdir(dirname(targetPath), { recursive: true });
+    const exists = await fileExists(targetPath);
+    const current = exists ? await readFile(targetPath, "utf8") : "";
+    let backupPath;
+    if (exists) {
+        backupPath = `${targetPath}.${timestamp()}.bak`;
+        await copyFile(targetPath, backupPath);
+    }
+    await writeFile(targetPath, mergeCodexConfig(current, input), "utf8");
+    return { targetPath, backupPath };
+}
+function upsertTopLevelString(text, key, value) {
+    const line = `${key} = ${quoteTomlString(value)}`;
+    const pattern = new RegExp(`^${escapeRegExp(key)}\\s*=.*$`, "m");
+    if (pattern.test(text)) {
+        return text.replace(pattern, line);
+    }
+    return text ? `${line}\n${text}` : line;
+}
+function removeTable(text, tableName) {
+    const lines = text.split(/\r?\n/);
+    const header = `[${tableName}]`;
+    const kept = [];
+    let removing = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+            removing = trimmed === header || trimmed.startsWith(`[${tableName}.`);
+            if (removing) {
+                continue;
+            }
+        }
+        if (!removing) {
+            kept.push(line);
+        }
+    }
+    return kept.join("\n").trimEnd();
+}
+function quoteTomlKey(value) {
+    return quoteTomlString(value);
+}
+function quoteTomlString(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function timestamp() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heventure/model-provider-x",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "TUI configurator and local API proxy for wiring custom model providers into OpenCode and Claude Code.",
   "private": false,
   "license": "MIT",