llm-cli-gateway 2.10.0 → 2.11.1

package/dist/api-provider.js

@@ -0,0 +1,258 @@
+import { createCircuitBreaker, withRetry } from "./retry.js";
+import { logWarn, noopLogger } from "./logger.js";
+import { ApiHttpError, buildEndpointUrl, isHttpTransient, postJson, DEFAULT_API_TIMEOUT_MS, } from "./api-http.js";
+function numberOrUndefined(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function firstNumber(...candidates) {
+    for (const candidate of candidates) {
+        const n = numberOrUndefined(candidate);
+        if (n !== undefined)
+            return n;
+    }
+    return undefined;
+}
+export class OpenAiCompatibleProvider {
+    name;
+    kind = "openai-compatible";
+    constructor(name) {
+        this.name = name;
+    }
+    endpointUrl(baseUrl) {
+        return buildEndpointUrl(baseUrl, "chat/completions");
+    }
+    buildBody(req) {
+        const body = {
+            model: req.model,
+            messages: req.messages.map(m => ({ role: m.role, content: m.content })),
+        };
+        if (req.maxOutputTokens !== undefined)
+            body.max_tokens = req.maxOutputTokens;
+        if (req.temperature !== undefined)
+            body.temperature = req.temperature;
+        if (req.topP !== undefined)
+            body.top_p = req.topP;
+        return body;
+    }
+    parseResult(httpStatus, body) {
+        const parsed = JSON.parse(body);
+        const choice = Array.isArray(parsed?.choices) ? parsed.choices[0] : undefined;
+        const text = typeof choice?.message?.content === "string" ? choice.message.content : "";
+        const usage = parsed?.usage ?? {};
+        return {
+            model: typeof parsed?.model === "string" ? parsed.model : "unknown",
+            text,
+            usage: {
+                inputTokens: firstNumber(usage.prompt_tokens, usage.input_tokens),
+                outputTokens: firstNumber(usage.completion_tokens, usage.output_tokens),
+                cacheReadTokens: firstNumber(usage?.prompt_tokens_details?.cached_tokens),
+                raw: usage,
+            },
+            raw: parsed,
+            httpStatus,
+        };
+    }
+    authHeaders(apiKey) {
+        return apiKey ? { authorization: `Bearer ${apiKey}` } : {};
+    }
+    isTransient(err) {
+        return isHttpTransient(err);
+    }
+}
+export const DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+const DEFAULT_ANTHROPIC_MAX_TOKENS = 4096;
+export class AnthropicProvider {
+    name;
+    anthropicVersion;
+    kind = "anthropic";
+    constructor(name, anthropicVersion = DEFAULT_ANTHROPIC_VERSION) {
+        this.name = name;
+        this.anthropicVersion = anthropicVersion;
+    }
+    endpointUrl(baseUrl) {
+        return buildEndpointUrl(baseUrl, "messages");
+    }
+    buildBody(req) {
+        const system = req.messages
+            .filter(m => m.role === "system")
+            .map(m => m.content)
+            .join("\n\n");
+        const messages = req.messages
+            .filter(m => m.role !== "system")
+            .map(m => ({ role: m.role, content: m.content }));
+        const body = {
+            model: req.model,
+            messages,
+            max_tokens: req.maxOutputTokens ?? DEFAULT_ANTHROPIC_MAX_TOKENS,
+        };
+        if (system.length > 0)
+            body.system = system;
+        if (req.temperature !== undefined)
+            body.temperature = req.temperature;
+        if (req.topP !== undefined)
+            body.top_p = req.topP;
+        return body;
+    }
+    parseResult(httpStatus, body) {
+        const parsed = JSON.parse(body);
+        const blocks = Array.isArray(parsed?.content) ? parsed.content : [];
+        const text = blocks
+            .filter((b) => b?.type === "text" && typeof b.text === "string")
+            .map((b) => b.text)
+            .join("");
+        const usage = parsed?.usage ?? {};
+        return {
+            model: typeof parsed?.model === "string" ? parsed.model : "unknown",
+            text,
+            usage: {
+                inputTokens: firstNumber(usage.input_tokens),
+                outputTokens: firstNumber(usage.output_tokens),
+                cacheReadTokens: firstNumber(usage.cache_read_input_tokens),
+                raw: usage,
+            },
+            raw: parsed,
+            httpStatus,
+        };
+    }
+    authHeaders(apiKey) {
+        return { "x-api-key": apiKey, "anthropic-version": this.anthropicVersion };
+    }
+    isTransient(err) {
+        return isHttpTransient(err);
+    }
+}
+function normalizeXaiCostUsd(usage) {
+    const ticks = usage?.cost_in_usd_ticks;
+    if (typeof ticks === "number" && Number.isFinite(ticks))
+        return ticks / 10_000_000_000;
+    const nanos = usage?.cost_in_nano_usd;
+    if (typeof nanos === "number" && Number.isFinite(nanos))
+        return nanos / 1_000_000_000;
+    return undefined;
+}
+function extractXaiResponseText(parsed) {
+    const output = Array.isArray(parsed?.output) ? parsed.output : [];
+    const chunks = [];
+    for (const item of output) {
+        if (item?.type !== "message" || !Array.isArray(item.content))
+            continue;
+        for (const content of item.content) {
+            if ((content?.type === "output_text" || content?.type === "text") &&
+                typeof content.text === "string") {
+                chunks.push(content.text);
+            }
+        }
+    }
+    if (chunks.length > 0)
+        return chunks.join("");
+    if (typeof parsed?.output_text === "string")
+        return parsed.output_text;
+    return "";
+}
+export class XaiResponsesProvider {
+    name;
+    kind = "xai-responses";
+    constructor(name) {
+        this.name = name;
+    }
+    endpointUrl(baseUrl) {
+        return buildEndpointUrl(baseUrl, "responses");
+    }
+    buildBody(req) {
+        const instructions = req.messages
+            .filter(m => m.role === "system")
+            .map(m => m.content)
+            .join("\n\n");
+        const input = req.messages
+            .filter(m => m.role !== "system")
+            .map(m => ({ role: m.role, content: m.content }));
+        const body = { model: req.model, input, store: true };
+        if (instructions.length > 0)
+            body.instructions = instructions;
+        if (req.previousResponseId)
+            body.previous_response_id = req.previousResponseId;
+        if (req.maxOutputTokens !== undefined)
+            body.max_output_tokens = req.maxOutputTokens;
+        if (req.temperature !== undefined)
+            body.temperature = req.temperature;
+        if (req.topP !== undefined)
+            body.top_p = req.topP;
+        if (req.reasoningEffort !== undefined)
+            body.reasoning = { effort: req.reasoningEffort };
+        return body;
+    }
+    parseResult(httpStatus, body) {
+        const parsed = JSON.parse(body);
+        const usage = parsed?.usage ?? {};
+        return {
+            responseId: typeof parsed?.id === "string" ? parsed.id : null,
+            model: typeof parsed?.model === "string" ? parsed.model : "unknown",
+            text: extractXaiResponseText(parsed),
+            usage: {
+                inputTokens: firstNumber(usage.input_tokens, usage.prompt_tokens),
+                outputTokens: firstNumber(usage.output_tokens, usage.completion_tokens),
+                cacheReadTokens: firstNumber(usage?.input_tokens_details?.cached_tokens, usage?.prompt_tokens_details?.cached_tokens),
+                costUsd: normalizeXaiCostUsd(usage),
+                raw: usage,
+            },
+            raw: parsed,
+            httpStatus,
+        };
+    }
+    authHeaders(apiKey) {
+        return { authorization: `Bearer ${apiKey}` };
+    }
+    isTransient(err) {
+        return isHttpTransient(err);
+    }
+}
+export function createApiProvider(name, kind) {
+    switch (kind) {
+        case "openai-compatible":
+            return new OpenAiCompatibleProvider(name);
+        case "anthropic":
+            return new AnthropicProvider(name);
+        case "xai-responses":
+            return new XaiResponsesProvider(name);
+        default: {
+            const exhaustive = kind;
+            throw new Error(`Unknown api provider kind: ${String(exhaustive)}`);
+        }
+    }
+}
+const breakers = new Map();
+function getProviderBreaker(name, logger) {
+    let breaker = breakers.get(name);
+    if (!breaker) {
+        breaker = createCircuitBreaker({
+            failureThreshold: 3,
+            resetTimeout: 60_000,
+            onStateChange: state => logWarn(logger, `[api:${name}] circuit breaker state changed to ${state}`),
+        });
+        breakers.set(name, breaker);
+    }
+    return breaker;
+}
+export function resetApiProviderBreakers() {
+    breakers.clear();
+}
+export function apiProviderBreakerState(name) {
+    return breakers.get(name)?.state ?? "CLOSED";
+}
+export async function runApiRequest(provider, req, logger = noopLogger, opts = {}) {
+    const url = provider.endpointUrl(req.baseUrl);
+    const body = provider.buildBody(req);
+    const headers = provider.authHeaders(req.apiKey);
+    const timeoutMs = req.timeoutMs ?? DEFAULT_API_TIMEOUT_MS;
+    const response = await withRetry(() => postJson(url, body, headers, timeoutMs, undefined, opts.signal), getProviderBreaker(provider.name, logger), {
+        initialDelay: 1_000,
+        maxDelay: 30_000,
+        factor: 2,
+        isTransient: err => provider.isTransient(err),
+        onRetry: (error, attempt, delay) => {
+            logWarn(logger, `[api:${provider.name}] transient failure on attempt ${attempt}; retrying in ${delay}ms: ${error.message}`);
+        },
+    }, logger);
+    return provider.parseResult(response.status, response.text);
+}
+export { ApiHttpError };

package/dist/api-request.d.ts

@@ -0,0 +1,30 @@
+import type { ApiProviderRuntime } from "./config.js";
+import type { ApiChatMessage, ApiRequest } from "./api-provider.js";
+export interface PrepareApiRequestParams {
+    prompt: string;
+    system?: string;
+    model?: string;
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    reasoningEffort?: "none" | "low" | "medium" | "high";
+    timeoutMs?: number;
+    previousResponseId?: string;
+}
+export interface ApiProviderCatalogEntry {
+    name: string;
+    providerKind: "api";
+    kind: ApiProviderRuntime["kind"];
+    defaultModel: string;
+    models: string[] | null;
+}
+export declare function apiProviderCatalogEntry(runtime: ApiProviderRuntime): ApiProviderCatalogEntry;
+export declare class ApiModelNotAllowedError extends Error {
+    readonly provider: string;
+    readonly model: string;
+    readonly allowed: readonly string[];
+    constructor(provider: string, model: string, allowed: readonly string[]);
+}
+export declare function resolveApiModel(runtime: ApiProviderRuntime, requested?: string): string;
+export declare function assembleApiMessages(prompt: string, system?: string): ApiChatMessage[];
+export declare function prepareApiRequest(runtime: ApiProviderRuntime, params: PrepareApiRequestParams): ApiRequest;

package/dist/api-request.js

@@ -0,0 +1,51 @@
+export function apiProviderCatalogEntry(runtime) {
+    return {
+        name: runtime.name,
+        providerKind: "api",
+        kind: runtime.kind,
+        defaultModel: runtime.defaultModel,
+        models: runtime.models ?? null,
+    };
+}
+export class ApiModelNotAllowedError extends Error {
+    provider;
+    model;
+    allowed;
+    constructor(provider, model, allowed) {
+        super(`Model "${model}" is not in the allowlist for provider "${provider}". Allowed: ${allowed.join(", ")}.`);
+        this.provider = provider;
+        this.model = model;
+        this.allowed = allowed;
+        this.name = "ApiModelNotAllowedError";
+    }
+}
+export function resolveApiModel(runtime, requested) {
+    if (!requested)
+        return runtime.defaultModel;
+    if (runtime.models && runtime.models.length > 0 && !runtime.models.includes(requested)) {
+        throw new ApiModelNotAllowedError(runtime.name, requested, runtime.models);
+    }
+    return requested;
+}
+export function assembleApiMessages(prompt, system) {
+    const messages = [];
+    if (system && system.trim().length > 0) {
+        messages.push({ role: "system", content: system });
+    }
+    messages.push({ role: "user", content: prompt });
+    return messages;
+}
+export function prepareApiRequest(runtime, params) {
+    return {
+        baseUrl: runtime.baseUrl,
+        apiKey: runtime.apiKey,
+        model: resolveApiModel(runtime, params.model),
+        messages: assembleApiMessages(params.prompt, params.system),
+        maxOutputTokens: params.maxOutputTokens,
+        temperature: params.temperature,
+        topP: params.topP,
+        reasoningEffort: params.reasoningEffort,
+        timeoutMs: params.timeoutMs,
+        previousResponseId: params.previousResponseId,
+    };
+}

package/dist/approval-manager.d.ts

@@ -2,7 +2,7 @@ import type { Logger } from "./logger.js";
 import type { ReviewIntegrityResult } from "./review-integrity.js";
 export type ApprovalPolicy = "strict" | "balanced" | "permissive";
 export type ApprovalStrategy = "legacy" | "mcp_managed";
-export type ApprovalCli = "claude" | "codex" | "gemini" | "grok" | "mistral";
+export type ApprovalCli = "claude" | "codex" | "gemini" | "grok" | "mistral" | "devin";
 export type ApprovalStatus = "approved" | "denied";
 export interface ApprovalRequest {
     cli: ApprovalCli;

package/dist/approval-manager.js

@@ -3,6 +3,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
 import { noopLogger } from "./logger.js";
+import { INTERNAL_MCP_REGISTRY } from "./mcp-registry.js";
 import { isReviewContext } from "./review-integrity.js";
 function parsePolicy(policy) {
     if (policy) {
@@ -60,13 +61,11 @@ export class ApprovalManager {
             score += 2;
             reasons.push("Request combines full permission bypass with full-auto execution");
         }
-        if (request.requestedMcpServers.includes("exa")) {
-            score += 2;
-            reasons.push("Request enables external web/company research MCP (exa)");
-        }
-        if (request.requestedMcpServers.includes("ref_tools")) {
-            score += 1;
-            reasons.push("Request enables documentation retrieval MCP (ref_tools)");
+        for (const [name, entry] of Object.entries(INTERNAL_MCP_REGISTRY)) {
+            if (entry.approval && request.requestedMcpServers.includes(name)) {
+                score += entry.approval.score;
+                reasons.push(entry.approval.reason);
+            }
         }
         if (request.allowedTools && request.allowedTools.length === 0) {
             const promptIsReview = isReviewContext(request.prompt);

package/dist/async-job-manager.d.ts

@@ -2,7 +2,9 @@ import type { Logger } from "./logger.js";
 import { type JobHealth } from "./process-monitor.js";
 import { JobStore } from "./job-store.js";
 import { type FlightRecorderLike } from "./flight-recorder.js";
-export type LlmCli = "claude" | "codex" | "gemini" | "grok" | "mistral";
+import { type ApiProvider, type ApiRequest } from "./api-provider.js";
+export type LlmCli = "claude" | "codex" | "gemini" | "grok" | "mistral" | "devin";
+export type JobProvider = LlmCli | (string & {});
 export type AsyncJobStatus = "running" | "completed" | "failed" | "canceled" | "orphaned";
 export interface AsyncJobFlightRecorderEntry {
     model: string;
@@ -22,7 +24,7 @@ export type AsyncJobUsageExtractor = (stdout: string) => {
 };
 export interface AsyncJobSnapshot {
     id: string;
-    cli: LlmCli;
+    cli: JobProvider;
     status: AsyncJobStatus;
     startedAt: string;
     finishedAt: string | null;
@@ -66,13 +68,26 @@ export declare class AsyncJobManager {
     private processMonitor;
     private store;
     private flightRecorder;
-    constructor(logger?: Logger, onJobComplete?: ((cli: LlmCli, durationMs: number, success: boolean) => void) | undefined, store?: JobStore | null, flightRecorder?: FlightRecorderLike);
+    constructor(logger?: Logger, onJobComplete?: ((cli: JobProvider, durationMs: number, success: boolean) => void) | undefined, store?: JobStore | null, flightRecorder?: FlightRecorderLike);
     private buildOrphanFlightResult;
     checkStalledJobs(now?: number): void;
     hasStore(): boolean;
     private emitMetrics;
     private evictCompletedJobs;
     private buildRequestKey;
+    private buildHttpRequestKey;
+    private tryReuseDedupedJob;
+    startHttpJob(params: {
+        provider: ApiProvider;
+        apiRequest: ApiRequest;
+        correlationId: string;
+        forceRefresh?: boolean;
+        onComplete?: () => void;
+        writeFlightStart?: boolean;
+        flightRecorderEntry?: AsyncJobFlightRecorderEntry;
+        extractUsage?: AsyncJobUsageExtractor;
+    }): StartJobOutcome;
+    private finalizeHttpJob;
     private fireOnComplete;
     private writeFlightComplete;
     private safeExtractUsage;
@@ -105,7 +120,7 @@ export declare class AsyncJobManager {
         jobs: JobHealth[];
     };
     getJobOutputFormat(jobId: string): string | undefined;
-    getJobCli(jobId: string): LlmCli | undefined;
+    getJobCli(jobId: string): JobProvider | undefined;
     private snapshot;
     private appendOutput;
 }