llm-cli-gateway 2.10.0 → 2.11.0

package/dist/async-job-manager.js

@@ -6,6 +6,18 @@ import { computeRequestKey } from "./job-store.js";
 import { NoopFlightRecorder, } from "./flight-recorder.js";
 import { codexFrResponse } from "./codex-json-parser.js";
 import { getRequestContext, resolveOwnerPrincipal } from "./request-context.js";
+import { runApiRequest, ApiHttpError, } from "./api-provider.js";
+function extractApiHttpStatus(error) {
+    for (const candidate of [error, error?.cause]) {
+        if (candidate instanceof ApiHttpError && typeof candidate.status === "number") {
+            return candidate.status;
+        }
+        const status = candidate?.status;
+        if (typeof status === "number")
+            return status;
+    }
+    return null;
+}
 const MAX_OUTPUT_SIZE = 50 * 1024 * 1024;
 const JOB_TTL_MS = 60 * 60 * 1000;
 const EVICTION_INTERVAL_MS = 5 * 60 * 1000;
@@ -120,6 +132,7 @@ export class AsyncJobManager {
             circuitBreakerState: "closed",
             optimizationApplied: false,
             exitCode: orphan.exitCode ?? 1,
+            httpStatus: orphan.transport === "http" ? (orphan.httpStatus ?? undefined) : undefined,
             errorMessage: "orphaned after gateway restart",
             status: "failed",
         };
@@ -244,6 +257,171 @@ export class AsyncJobManager {
         const extra = cli === "codex" ? `${withCwd}|fmt:${outputFormat ?? "text"}` : withCwd;
         return computeRequestKey(cli, args, extra);
     }
+    buildHttpRequestKey(providerName, req) {
+        const canonical = {
+            transport: "http",
+            provider: providerName,
+            baseUrl: req.baseUrl,
+            model: req.model,
+            messages: req.messages,
+            temperature: req.temperature ?? null,
+            topP: req.topP ?? null,
+            reasoningEffort: req.reasoningEffort ?? null,
+            maxOutputTokens: req.maxOutputTokens ?? null,
+            previousResponseId: req.previousResponseId ?? null,
+        };
+        return computeRequestKey(`http:${providerName}`, [], JSON.stringify(canonical));
+    }
+    tryReuseDedupedJob(requestKey, correlationId, label, onComplete) {
+        if (!this.store)
+            return null;
+        try {
+            const existing = this.store.findByRequestKey(requestKey);
+            if (!existing)
+                return null;
+            let record = this.jobs.get(existing.id);
+            if (!record)
+                record = this.hydrateFromStore(existing.id) ?? undefined;
+            if (!record)
+                return null;
+            this.logger.info(`Job ${existing.id} reused via dedup for ${label}`, {
+                correlationId,
+                originalCorrelationId: record.correlationId,
+                status: record.status,
+            });
+            if (onComplete) {
+                try {
+                    onComplete();
+                }
+                catch (err) {
+                    this.logger.error("dedup onComplete cleanup threw", err);
+                }
+            }
+            return {
+                snapshot: this.snapshot(record),
+                deduped: true,
+                originalCorrelationId: record.correlationId,
+            };
+        }
+        catch (err) {
+            this.logger.error("dedup lookup failed; proceeding with fresh run", err);
+            return null;
+        }
+    }
+    startHttpJob(params) {
+        const { provider, apiRequest, correlationId, forceRefresh, onComplete, writeFlightStart, flightRecorderEntry, extractUsage, } = params;
+        const requestKey = this.buildHttpRequestKey(provider.name, apiRequest);
+        if (!forceRefresh) {
+            const reused = this.tryReuseDedupedJob(requestKey, correlationId, provider.name, onComplete);
+            if (reused)
+                return reused;
+        }
+        const id = randomUUID();
+        const startedAt = new Date().toISOString();
+        const abort = new AbortController();
+        const ownerPrincipal = resolveOwnerPrincipal(getRequestContext());
+        const payloadJson = JSON.stringify({
+            baseUrl: apiRequest.baseUrl,
+            model: apiRequest.model,
+            messages: apiRequest.messages,
+            maxOutputTokens: apiRequest.maxOutputTokens,
+            temperature: apiRequest.temperature,
+            topP: apiRequest.topP,
+            reasoningEffort: apiRequest.reasoningEffort,
+            previousResponseId: apiRequest.previousResponseId,
+        });
+        const job = {
+            id,
+            cli: provider.name,
+            args: [],
+            requestKey,
+            correlationId,
+            status: "running",
+            startedAt,
+            finishedAt: null,
+            exitCode: null,
+            stdout: "",
+            stderr: "",
+            outputTruncated: false,
+            canceled: false,
+            error: null,
+            process: null,
+            transport: "http",
+            abort,
+            httpStatus: null,
+            payloadJson,
+            exited: false,
+            metricsRecorded: false,
+            ownerPrincipal,
+            onComplete,
+            onCompleteFired: false,
+            outputDirty: false,
+            lastOutputFlushAt: Date.now(),
+            flightRecorderEntry,
+            extractUsage,
+            flightRecorderComplete: false,
+            flightCompleteArmed: writeFlightStart === true,
+        };
+        this.jobs.set(id, job);
+        this.safeStoreCall("recordStart", () => this.store.recordStart({
+            id,
+            correlationId,
+            requestKey,
+            cli: provider.name,
+            args: [],
+            startedAt,
+            pid: null,
+            ownerPrincipal,
+            transport: "http",
+            payloadJson,
+        }));
+        if (writeFlightStart && flightRecorderEntry) {
+            try {
+                this.flightRecorder.logStart({
+                    correlationId,
+                    cli: provider.name,
+                    model: flightRecorderEntry.model,
+                    prompt: flightRecorderEntry.prompt,
+                    sessionId: flightRecorderEntry.sessionId,
+                    asyncJobId: id,
+                });
+            }
+            catch (err) {
+                this.logger.error("Async-path flight recorder logStart failed", err);
+            }
+        }
+        this.logger.info(`Job ${id} started for ${provider.name} (http)`, { correlationId });
+        runApiRequest(provider, apiRequest, this.logger, { signal: abort.signal })
+            .then(result => this.finalizeHttpJob(job, result, null))
+            .catch(error => this.finalizeHttpJob(job, null, error));
+        return { snapshot: this.snapshot(job), deduped: false };
+    }
+    finalizeHttpJob(job, result, error) {
+        if (job.status !== "running")
+            return;
+        if (result) {
+            job.status = "completed";
+            job.stdout = result.text;
+            job.httpStatus = result.httpStatus;
+            job.exitCode = 0;
+        }
+        else {
+            job.status = "failed";
+            const status = extractApiHttpStatus(error);
+            job.httpStatus = status;
+            const message = error?.message ?? "API request failed";
+            job.stderr = message;
+            job.error = message;
+            job.exitCode = 1;
+        }
+        job.finishedAt = new Date().toISOString();
+        job.exited = true;
+        job.abort = null;
+        this.emitMetrics(job);
+        this.persistComplete(job);
+        this.writeFlightComplete(job, job.status === "completed" ? "completed" : "failed");
+        this.fireOnComplete(job);
+    }
     fireOnComplete(job) {
         if (job.onCompleteFired)
             return;
@@ -268,7 +446,7 @@ export class AsyncJobManager {
         const usage = finalStatus === "completed" && job.extractUsage ? this.safeExtractUsage(job) : {};
         const isFailure = finalStatus === "failed";
         let response;
-        if (job.cli === "codex") {
+        if (job.transport === "process" && job.cli === "codex") {
             const codexText = codexFrResponse(job.outputFormat, job.stdout);
             response = isFailure ? job.stderr || codexText : codexText;
         }
@@ -287,6 +465,7 @@ export class AsyncJobManager {
                 circuitBreakerState: "closed",
                 optimizationApplied: false,
                 exitCode,
+                httpStatus: job.transport === "http" ? (job.httpStatus ?? undefined) : undefined,
                 errorMessage,
                 status: finalStatus,
                 inputTokens: usage.inputTokens,
@@ -364,6 +543,7 @@ export class AsyncJobManager {
             outputTruncated: job.outputTruncated,
             error: job.error,
             finishedAt: job.finishedAt,
+            httpStatus: job.httpStatus,
         }));
     }
     hydrateFromStore(jobId) {
@@ -391,7 +571,7 @@ export class AsyncJobManager {
         const reconstituted = {
             id: row.id,
             cli: row.cli,
-            args,
+            args: row.transport === "http" ? [] : args,
             requestKey: row.requestKey,
             correlationId: row.correlationId,
             status: row.status,
@@ -404,6 +584,10 @@ export class AsyncJobManager {
             canceled: row.status === "canceled",
             error: row.error,
             process: null,
+            transport: row.transport,
+            abort: null,
+            httpStatus: row.httpStatus,
+            payloadJson: row.payloadJson,
             exited: row.status !== "running",
             metricsRecorded: true,
             outputFormat: row.outputFormat ?? undefined,
@@ -437,39 +621,10 @@ export class AsyncJobManager {
     startJobWithDedup(cli, args, correlationId, opts = {}) {
         const { cwd, idleTimeoutMs, outputFormat, forceRefresh, env: extraEnv, stdin, onComplete, flightRecorderEntry, extractUsage, writeFlightStart, } = opts;
         const requestKey = this.buildRequestKey(cli, args, extraEnv, stdin, cwd, outputFormat);
-        if (!forceRefresh && this.store) {
-            try {
-                const existing = this.store.findByRequestKey(requestKey);
-                if (existing) {
-                    let record = this.jobs.get(existing.id);
-                    if (!record) {
-                        record = this.hydrateFromStore(existing.id) ?? undefined;
-                    }
-                    if (record) {
-                        this.logger.info(`Job ${existing.id} reused via dedup for ${cli}`, {
-                            correlationId,
-                            originalCorrelationId: record.correlationId,
-                            status: record.status,
-                        });
-                        if (onComplete) {
-                            try {
-                                onComplete();
-                            }
-                            catch (err) {
-                                this.logger.error("dedup onComplete cleanup threw", err);
-                            }
-                        }
-                        return {
-                            snapshot: this.snapshot(record),
-                            deduped: true,
-                            originalCorrelationId: record.correlationId,
-                        };
-                    }
-                }
-            }
-            catch (err) {
-                this.logger.error("dedup lookup failed; proceeding with fresh run", err);
-            }
+        if (!forceRefresh) {
+            const reused = this.tryReuseDedupedJob(requestKey, correlationId, cli, onComplete);
+            if (reused)
+                return reused;
         }
         const id = randomUUID();
         const startedAt = new Date().toISOString();
@@ -515,6 +670,9 @@ export class AsyncJobManager {
             canceled: false,
             error: null,
             process: child,
+            transport: "process",
+            abort: null,
+            httpStatus: null,
             exited: false,
             metricsRecorded: false,
             outputFormat,
@@ -698,6 +856,24 @@ export class AsyncJobManager {
         if (job.status !== "running") {
             return { canceled: false, reason: `Job is already ${job.status}` };
         }
+        if (job.transport === "http") {
+            if (!job.abort) {
+                return {
+                    canceled: false,
+                    reason: "Job has no live request (orphaned from prior gateway run)",
+                };
+            }
+            job.canceled = true;
+            job.status = "canceled";
+            job.finishedAt = new Date().toISOString();
+            job.abort.abort();
+            this.logger.info(`Job ${jobId} canceled (http)`, { correlationId: job.correlationId });
+            this.emitMetrics(job);
+            this.persistComplete(job);
+            this.writeFlightComplete(job, "failed", "canceled by caller");
+            this.fireOnComplete(job);
+            return { canceled: true };
+        }
         if (!job.process) {
             return {
                 canceled: false,

package/dist/claude-mcp-config.d.ts

@@ -1,5 +1,5 @@
-export declare const CLAUDE_MCP_SERVER_NAMES: readonly ["sqry", "exa", "ref_tools", "trstr"];
-export type ClaudeMcpServerName = (typeof CLAUDE_MCP_SERVER_NAMES)[number];
+export { CLAUDE_MCP_SERVER_NAMES } from "./mcp-registry.js";
+export type ClaudeMcpServerName = string;
 export interface ClaudeMcpConfigResult {
     path: string;
     enabled: ClaudeMcpServerName[];

package/dist/claude-mcp-config.js

@@ -1,8 +1,9 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, renameSync, openSync, fsyncSync, closeSync, chmodSync, } from "fs";
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, openSync, fsyncSync, closeSync, chmodSync, } from "fs";
 import { homedir } from "os";
-import { dirname, join } from "path";
+import { delimiter, dirname, join } from "path";
 import { parse as parseToml } from "smol-toml";
-export const CLAUDE_MCP_SERVER_NAMES = ["sqry", "exa", "ref_tools", "trstr"];
+import { INTERNAL_MCP_REGISTRY } from "./mcp-registry.js";
+export { CLAUDE_MCP_SERVER_NAMES } from "./mcp-registry.js";
 function asStringArray(value) {
     if (!Array.isArray(value)) {
         return undefined;
@@ -52,69 +53,58 @@ function readCodexServerConfig(server) {
         return {};
     }
 }
-function findInstalledExaEntrypoint() {
-    const nvmVersionsDir = join(homedir(), ".nvm", "versions", "node");
-    if (!existsSync(nvmVersionsDir)) {
-        return null;
-    }
-    let versions = [];
-    try {
-        versions = readdirSync(nvmVersionsDir);
-    }
-    catch {
-        return null;
-    }
-    const candidates = [];
-    for (const version of versions) {
-        const entrypoint = join(nvmVersionsDir, version, "lib", "node_modules", "exa-mcp-server", ".smithery", "stdio", "index.cjs");
-        if (existsSync(entrypoint)) {
-            candidates.push(entrypoint);
+function commandExists(command) {
+    if (command.includes("/") || command.includes("\\")) {
+        try {
+            accessSync(command, constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
         }
     }
-    if (candidates.length === 0) {
-        return null;
-    }
-    candidates.sort((a, b) => b.localeCompare(a, undefined, { numeric: true, sensitivity: "base" }));
-    return candidates[0];
-}
-function defaultServerDef(server) {
-    switch (server) {
-        case "sqry":
-            return { command: join(homedir(), ".local", "bin", "sqry-mcp"), args: [] };
-        case "trstr":
-            return { command: join(homedir(), ".local", "bin", "trstr-mcp"), args: [] };
-        case "exa": {
-            const exaEntrypoint = findInstalledExaEntrypoint();
-            if (exaEntrypoint) {
-                return { command: "node", args: [exaEntrypoint] };
+    const pathEnv = process.env.PATH || "";
+    const extensions = process.platform === "win32" ? (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";") : [""];
+    for (const dir of pathEnv.split(delimiter).filter(Boolean)) {
+        for (const ext of extensions) {
+            try {
+                accessSync(join(dir, `${command}${ext}`), constants.X_OK);
+                return true;
+            }
+            catch {
             }
-            return { command: "npx", args: ["-y", "exa-mcp-server"] };
-        }
-        case "ref_tools":
-            return { command: "npx", args: ["-y", "ref-tools-mcp"] };
-        default: {
-            const _exhaustive = server;
-            throw new Error(`Unknown MCP server: ${_exhaustive}`);
         }
     }
+    return false;
 }
 function toClaudeServerDef(server) {
+    const entry = INTERNAL_MCP_REGISTRY[server];
     const codexDef = readCodexServerConfig(server);
-    const fallback = defaultServerDef(server);
+    const fallback = entry ? entry.defaultDef() : {};
     const command = codexDef.command || fallback.command;
+    if (!command) {
+        return null;
+    }
     const args = codexDef.args || fallback.args || [];
     const env = {};
     if (codexDef.env) {
         Object.assign(env, codexDef.env);
     }
-    if (server === "exa" && process.env.EXA_API_KEY) {
-        env.EXA_API_KEY = process.env.EXA_API_KEY;
-    }
-    if (server === "ref_tools" && process.env.REF_API_KEY) {
-        env.REF_API_KEY = process.env.REF_API_KEY;
-    }
-    if ((server === "exa" && !env.EXA_API_KEY) || (server === "ref_tools" && !env.REF_API_KEY)) {
-        return null;
+    if (entry) {
+        for (const key of entry.forwardEnv ?? []) {
+            const value = process.env[key];
+            if (value) {
+                env[key] = value;
+            }
+        }
+        for (const key of entry.requireEnv ?? []) {
+            if (!env[key]) {
+                return null;
+            }
+        }
+        if (entry.requireCommandOnPath && !codexDef.command && !commandExists(command)) {
+            return null;
+        }
     }
     return {
         command,

package/dist/cli-updater.js

@@ -34,6 +34,7 @@ const VERSION_ARGS = {
     gemini: ["--version"],
     grok: ["--version"],
     mistral: ["--version"],
+    devin: ["--version"],
 };
 const CODEX_NPM_PACKAGE = "@openai/codex";
 export function buildCliUpgradePlan(cli, target = "latest", detectMistral = detectMistralInstallMethod) {
@@ -93,6 +94,20 @@ export function buildCliUpgradePlan(cli, target = "latest", detectMistral = dete
             requiresNetwork: true,
         };
     }
+    if (cli === "devin") {
+        if (normalizedTarget !== "latest") {
+            throw new Error("Devin CLI upgrades support only the 'latest' target via 'devin update'.");
+        }
+        return {
+            cli,
+            target: normalizedTarget,
+            command: "devin",
+            args: ["update"],
+            strategy: "self-update",
+            requiresNetwork: true,
+            note: "Devin CLI self-updates via 'devin update' (use --force to reinstall the latest).",
+        };
+    }
     if (cli === "gemini") {
         if (normalizedTarget !== "latest") {
             throw new Error("Antigravity CLI upgrades support only the 'latest' target via 'agy update'.");
@@ -150,7 +165,7 @@ export async function getCliVersion(cli) {
     }
 }
 export async function getCliVersions(cli) {
-    const clis = cli ? [cli] : ["claude", "codex", "gemini", "grok", "mistral"];
+    const clis = cli ? [cli] : ["claude", "codex", "gemini", "grok", "mistral", "devin"];
     return Promise.all(clis.map(item => getCliVersion(item)));
 }
 function buildMistralUpgradePlan(normalizedTarget, detectMistral) {

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import type { Logger } from "./logger.js";
 import type { RemoteOAuthConfig } from "./auth.js";
+import type { ApiProviderKind } from "./api-provider.js";
 export interface DatabaseConfig {
     connectionString: string;
     pool: {
@@ -68,13 +69,32 @@ export interface XaiProviderConfig {
     baseUrl: string;
     defaultModel: string;
 }
+export interface ApiProviderConfig {
+    name: string;
+    kind: ApiProviderKind;
+    apiKeyEnv: string | null;
+    baseUrl: string;
+    defaultModel: string;
+    models?: string[];
+}
+export interface ApiProviderRuntime {
+    name: string;
+    kind: ApiProviderKind;
+    baseUrl: string;
+    defaultModel: string;
+    models?: string[];
+    apiKey: string;
+}
 export interface ProvidersConfig {
     xai: XaiProviderConfig | null;
+    providers: Record<string, ApiProviderConfig>;
     sources: {
         configFile: string | null;
     };
 }
 export declare function loadProvidersConfig(logger?: Logger): ProvidersConfig;
+export declare function isApiProviderEnabled(provider: ApiProviderConfig, env?: NodeJS.ProcessEnv): boolean;
+export declare function enabledApiProviders(config: ProvidersConfig, env?: NodeJS.ProcessEnv): ApiProviderRuntime[];
 export declare function isXaiProviderEnabled(config: ProvidersConfig, env?: NodeJS.ProcessEnv): boolean;
 export declare const ACP_TRANSPORTS: readonly ["cli", "acp"];
 export type AcpTransport = (typeof ACP_TRANSPORTS)[number];