llm-cli-gateway 2.10.0 → 2.11.1

package/dist/config.js

@@ -5,6 +5,7 @@ import { createRequire } from "module";
 import { z } from "zod/v3";
 import { logWarn, noopLogger } from "./logger.js";
 import { hashSecret, isSecretHash } from "./oauth.js";
+import { isHttpsOrLoopbackUrl, isLoopbackUrl } from "./api-http.js";
 const DatabaseUrlSchema = z
     .string()
     .url()
@@ -267,22 +268,17 @@ export function minStableTokensForModel(config, modelName) {
         return table.haiku;
     return table.default;
 }
+const RESERVED_CLI_PROVIDER_NAMES = [
+    "claude",
+    "codex",
+    "gemini",
+    "grok",
+    "mistral",
+    "devin",
+];
 export const DEFAULT_XAI_API_KEY_ENV = "XAI_API_KEY";
 export const DEFAULT_XAI_BASE_URL = "https://api.x.ai/v1";
 export const DEFAULT_XAI_MODEL = "grok-build-0.1";
-function isHttpsOrLoopbackUrl(value) {
-    try {
-        const url = new URL(value);
-        if (url.protocol === "https:")
-            return true;
-        if (url.protocol !== "http:")
-            return false;
-        return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(url.hostname);
-    }
-    catch {
-        return false;
-    }
-}
 const XaiProviderSchema = z
     .object({
     api_key_env: z.string().min(1).default(DEFAULT_XAI_API_KEY_ENV),
@@ -296,6 +292,17 @@ const XaiProviderSchema = z
     default_model: z.string().min(1).default(DEFAULT_XAI_MODEL),
 })
     .strict();
+const ApiProviderSchema = z
+    .object({
+    kind: z.enum(["openai-compatible", "anthropic", "xai-responses"]),
+    base_url: z.string().url().refine(isHttpsOrLoopbackUrl, {
+        message: "base_url must use https unless it targets localhost/loopback",
+    }),
+    api_key_env: z.string().min(1).optional(),
+    default_model: z.string().min(1),
+    models: z.array(z.string().min(1)).nonempty().optional(),
+})
+    .strict();
 function readProvidersFile(configPath, logger) {
     if (!existsSync(configPath)) {
         return { raw: undefined, sourcePath: null };
@@ -315,32 +322,83 @@ function readProvidersFile(configPath, logger) {
 export function loadProvidersConfig(logger = noopLogger) {
     const configPath = defaultGatewayConfigPath();
     const { raw, sourcePath } = readProvidersFile(configPath, logger);
-    const providers = raw ?? {};
-    const rawXai = providers.xai;
-    if (rawXai === undefined) {
-        return {
-            xai: null,
-            sources: { configFile: sourcePath },
+    const rawProviders = raw ?? {};
+    const providers = {};
+    let xai = null;
+    const rawXai = rawProviders.xai;
+    if (rawXai !== undefined) {
+        const parsed = XaiProviderSchema.safeParse(rawXai);
+        if (parsed.success) {
+            xai = {
+                apiKeyEnv: parsed.data.api_key_env,
+                baseUrl: parsed.data.base_url,
+                defaultModel: parsed.data.default_model,
+            };
+            providers.xai = {
+                name: "xai",
+                kind: "xai-responses",
+                apiKeyEnv: parsed.data.api_key_env,
+                baseUrl: parsed.data.base_url,
+                defaultModel: parsed.data.default_model,
+            };
+        }
+        else {
+            logWarn(logger, "Invalid [providers.xai] config; xAI API provider disabled", {
+                error: parsed.error.message,
+            });
+        }
+    }
+    for (const [name, rawProvider] of Object.entries(rawProviders)) {
+        if (name === "xai")
+            continue;
+        if (RESERVED_CLI_PROVIDER_NAMES.includes(name)) {
+            logWarn(logger, `[providers.${name}] is rejected: "${name}" is a reserved CLI provider name and cannot be used for an API provider`);
+            continue;
+        }
+        const parsed = ApiProviderSchema.safeParse(rawProvider);
+        if (!parsed.success) {
+            logWarn(logger, `Invalid [providers.${name}] config; API provider disabled`, {
+                error: parsed.error.message,
+            });
+            continue;
+        }
+        providers[name] = {
+            name,
+            kind: parsed.data.kind,
+            apiKeyEnv: parsed.data.api_key_env ?? null,
+            baseUrl: parsed.data.base_url,
+            defaultModel: parsed.data.default_model,
+            models: parsed.data.models ? [...parsed.data.models] : undefined,
         };
     }
-    const parsed = XaiProviderSchema.safeParse(rawXai);
-    if (!parsed.success) {
-        logWarn(logger, "Invalid [providers.xai] config; xAI API provider disabled", {
-            error: parsed.error.message,
+    return { xai, providers, sources: { configFile: sourcePath } };
+}
+function resolveProviderKey(apiKeyEnv, env) {
+    if (!apiKeyEnv)
+        return null;
+    const value = env[apiKeyEnv];
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+export function isApiProviderEnabled(provider, env = process.env) {
+    if (resolveProviderKey(provider.apiKeyEnv, env) !== null)
+        return true;
+    return provider.kind === "openai-compatible" && isLoopbackUrl(provider.baseUrl);
+}
+export function enabledApiProviders(config, env = process.env) {
+    const runtimes = [];
+    for (const provider of Object.values(config.providers ?? {})) {
+        if (!isApiProviderEnabled(provider, env))
+            continue;
+        runtimes.push({
+            name: provider.name,
+            kind: provider.kind,
+            baseUrl: provider.baseUrl,
+            defaultModel: provider.defaultModel,
+            models: provider.models,
+            apiKey: resolveProviderKey(provider.apiKeyEnv, env) ?? "",
         });
-        return {
-            xai: null,
-            sources: { configFile: sourcePath },
-        };
     }
-    return {
-        xai: {
-            apiKeyEnv: parsed.data.api_key_env,
-            baseUrl: parsed.data.base_url,
-            defaultModel: parsed.data.default_model,
-        },
-        sources: { configFile: sourcePath },
-    };
+    return runtimes;
 }
 export function isXaiProviderEnabled(config, env = process.env) {
     const keyEnv = config.xai?.apiKeyEnv;

package/dist/doctor.d.ts

@@ -3,7 +3,7 @@ import { type ProviderLoginStatus } from "./provider-status.js";
 import type { FlightRecorderQuery } from "./flight-recorder.js";
 import { type CacheAwarenessConfig } from "./config.js";
 import { type ProviderCapabilityId, type ProviderKind } from "./provider-tool-capabilities.js";
-export type CliType = "claude" | "codex" | "gemini" | "grok" | "mistral";
+export type CliType = "claude" | "codex" | "gemini" | "grok" | "mistral" | "devin";
 export interface CacheAwarenessReport {
     enabled_features: Array<"anthropic_cache_control" | "ttl_warnings">;
     last_24h: {

package/dist/flight-recorder.d.ts

@@ -27,6 +27,7 @@ export interface FlightLogResult {
     optimizationApplied: boolean;
     thinkingBlocks?: string[];
     exitCode: number;
+    httpStatus?: number;
     errorMessage?: string;
     status: "completed" | "failed";
 }

package/dist/flight-recorder.js

@@ -40,6 +40,13 @@ function ensureCacheControlBlocksColumn(db) {
         db.exec("ALTER TABLE requests ADD COLUMN cache_control_blocks INTEGER");
     }
 }
+function ensureMetadataHttpStatusColumn(db) {
+    const rows = db.prepare("PRAGMA table_info(gateway_metadata)").all();
+    const names = new Set(rows.map((row) => (row && typeof row.name === "string" ? row.name : "")));
+    if (!names.has("http_status")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN http_status INTEGER");
+    }
+}
 function ensureCacheControlTtlSecondsColumn(db) {
     const rows = db.prepare("PRAGMA table_info(requests)").all();
     const names = new Set(rows.map((row) => (row && typeof row.name === "string" ? row.name : "")));
@@ -137,6 +144,7 @@ export class FlightRecorder {
         optimization_applied INTEGER DEFAULT 0,
         thinking_blocks TEXT,
         exit_code INTEGER,
+        http_status INTEGER,
         error_message TEXT,
         async_job_id TEXT,
         status TEXT NOT NULL DEFAULT 'started'
@@ -168,6 +176,7 @@ export class FlightRecorder {
             .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(5, ?)")
             .run(new Date().toISOString());
         ensureRequestsOwnerColumn(this.db);
+        ensureMetadataHttpStatusColumn(this.db);
         this.db
             .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(6, ?)")
             .run(new Date().toISOString());
@@ -229,6 +238,7 @@ export class FlightRecorder {
           optimization_applied = @optimization_applied,
           thinking_blocks = @thinking_blocks,
           exit_code = @exit_code,
+          http_status = @http_status,
           error_message = @error_message,
           status = @status
       WHERE request_id = @id AND status = 'started'
@@ -255,6 +265,7 @@ export class FlightRecorder {
                 optimization_applied: result.optimizationApplied ? 1 : 0,
                 thinking_blocks: thinkingBlocks,
                 exit_code: result.exitCode,
+                http_status: result.httpStatus ?? null,
                 error_message: result.errorMessage ?? null,
                 status: result.status,
             });

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod/v3";
-import { ISessionManager, type ProviderType } from "./session-manager.js";
+import { ISessionManager, type CliType, type ProviderType } from "./session-manager.js";
 import { ResourceProvider } from "./resources.js";
 import { PerformanceMetrics } from "./metrics.js";
-import { type PersistenceConfig, type CacheAwarenessConfig, type ProvidersConfig } from "./config.js";
+import { type PersistenceConfig, type CacheAwarenessConfig, type ProvidersConfig, type ApiProviderRuntime, type AcpConfig } from "./config.js";
 import { type XaiReasoningEffort } from "./xai-api-provider.js";
 import { DatabaseConnection } from "./db.js";
 import { AsyncJobManager } from "./async-job-manager.js";
@@ -61,8 +61,8 @@ export declare const WORKTREE_SCHEMA: z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
     ref?: string | undefined;
 }>]>;
 export declare const WORKSPACE_ALIAS_SCHEMA: z.ZodString;
-export declare const SESSION_PROVIDER_VALUES: readonly ["claude", "codex", "gemini", "grok", "mistral", "grok-api"];
-export declare const SESSION_PROVIDER_ENUM: z.ZodEnum<["claude", "codex", "gemini", "grok", "mistral", "grok-api"]>;
+export declare const SESSION_PROVIDER_VALUES: readonly ["claude", "codex", "gemini", "grok", "mistral", "devin", "grok-api"];
+export declare const SESSION_PROVIDER_ENUM: z.ZodEnum<["claude", "codex", "gemini", "grok", "mistral", "devin", "grok-api"]>;
 export type SessionProvider = ProviderType;
 export interface GatewayServerDeps {
     sessionManager?: ISessionManager;
@@ -76,6 +76,7 @@ export interface GatewayServerDeps {
     persistence?: PersistenceConfig;
     cacheAwareness?: CacheAwarenessConfig;
     providers?: ProvidersConfig;
+    acpConfig?: AcpConfig;
     workspaces?: WorkspaceRegistry;
 }
 export interface GatewayServerRuntime {
@@ -90,12 +91,20 @@ export interface GatewayServerRuntime {
     persistence: PersistenceConfig;
     cacheAwareness: CacheAwarenessConfig;
     providers: ProvidersConfig;
+    acpConfig: AcpConfig;
     workspaces: WorkspaceRegistry;
 }
 export declare function resolveGatewayServerRuntime(deps?: GatewayServerDeps, options?: {
     isolateState?: boolean;
 }): GatewayServerRuntime;
 export declare function shouldRegisterGrokApiTools(providers: ProvidersConfig): boolean;
+export declare function runAcpTransport(deps: HandlerDeps, params: {
+    provider: CliType;
+    prompt?: string;
+    model?: string;
+    sessionId?: string;
+    correlationId?: string;
+}): Promise<ExtendedToolResponse>;
 export interface ResolvedWorktree {
     cwd?: string;
     worktreePath?: string;
@@ -111,7 +120,7 @@ export declare function resolveWorktreeForRequest(worktreeOpt: boolean | {
     workspaceRoot?: string;
 }): Promise<ResolvedWorktree>;
 export declare function formatWorktreePrefix(worktreePath?: string): string;
-export declare function extractUsageAndCost(cli: "claude" | "codex" | "gemini" | "grok" | "mistral", output: string, outputFormat?: string, ctx?: {
+export declare function extractUsageAndCost(cli: "claude" | "codex" | "gemini" | "grok" | "mistral" | "devin", output: string, outputFormat?: string, ctx?: {
     sessionId?: string;
     home?: string;
 }): {
@@ -316,6 +325,20 @@ export interface GrokApiRequestParams {
     timeoutMs?: number;
 }
 export declare function handleGrokApiRequest(deps: HandlerDeps, params: GrokApiRequestParams): Promise<ExtendedToolResponse>;
+interface ApiProviderToolParams {
+    prompt?: string;
+    system?: string;
+    model?: string;
+    correlationId?: string;
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    reasoningEffort?: "none" | "low" | "medium" | "high";
+    timeoutMs?: number;
+}
+export declare function handleApiProviderRequest(runtimeArg: GatewayServerRuntime, providerRuntime: ApiProviderRuntime, params: ApiProviderToolParams): Promise<ExtendedToolResponse>;
+export declare function handleApiProviderRequestAsync(runtimeArg: GatewayServerRuntime, providerRuntime: ApiProviderRuntime, params: ApiProviderToolParams): ExtendedToolResponse;
+export declare function registerApiProviderTools(server: McpServer, runtime: GatewayServerRuntime, providers: ProvidersConfig, asyncJobsEnabled: boolean): string[];
 export interface GeminiRequestParams {
     prompt?: string;
     promptParts?: PromptParts;
@@ -368,6 +391,7 @@ export interface GrokRequestParams {
     promptParts?: PromptParts;
     model?: string;
     outputFormat?: string;
+    transport?: "cli" | "acp";
     sessionId?: string;
     resumeLatest: boolean;
     createNewSession: boolean;
@@ -421,11 +445,38 @@ export interface GrokRequestParams {
 }
 export declare function handleGrokRequest(deps: HandlerDeps, params: GrokRequestParams): Promise<ExtendedToolResponse>;
 export declare function handleGrokRequestAsync(deps: AsyncHandlerDeps, params: Omit<GrokRequestParams, "optimizeResponse">): Promise<ExtendedToolResponse>;
+export interface DevinRequestParams {
+    prompt?: string;
+    model?: string;
+    permissionMode?: "auto" | "smart" | "dangerous";
+    promptFile?: string;
+    transport?: "cli" | "acp";
+    sessionId?: string;
+    resumeLatest?: boolean;
+    createNewSession?: boolean;
+    correlationId?: string;
+    optimizePrompt: boolean;
+    optimizeResponse?: boolean;
+    idleTimeoutMs?: number;
+    forceRefresh?: boolean;
+}
+export declare function prepareDevinRequest(params: {
+    prompt?: string;
+    model?: string;
+    permissionMode?: DevinRequestParams["permissionMode"];
+    promptFile?: string;
+    correlationId?: string;
+    optimizePrompt: boolean;
+    operation: string;
+}, _runtime: GatewayServerRuntime): CliRequestPrep | ExtendedToolResponse;
+export declare function handleDevinRequest(deps: HandlerDeps, params: DevinRequestParams): Promise<ExtendedToolResponse>;
+export declare function handleDevinRequestAsync(deps: AsyncHandlerDeps, params: Omit<DevinRequestParams, "optimizeResponse">): Promise<ExtendedToolResponse>;
 export interface MistralRequestParams {
     prompt?: string;
     promptParts?: PromptParts;
     model?: string;
     outputFormat?: string;
+    transport?: "cli" | "acp";
     sessionId?: string;
     resumeLatest: boolean;
     createNewSession: boolean;