llm-cli-gateway 2.12.1 → 2.12.2

package/dist/provider-login-guidance.d.ts

@@ -1,4 +1,5 @@
 import type { CliType } from "./session-manager.js";
+import type { ApiProviderConfig } from "./config.js";
 export interface ProviderLoginGuidance {
     provider: CliType;
     displayName: string;
@@ -19,3 +20,14 @@ export interface ProviderLoginGuidance {
 }
 export declare function getProviderLoginGuidance(provider: CliType): ProviderLoginGuidance;
 export declare function getAllProviderLoginGuidance(): Record<CliType, ProviderLoginGuidance>;
+export interface ApiProviderLoginGuidance {
+    provider: string;
+    displayName: string;
+    kind: ApiProviderConfig["kind"];
+    baseUrl: string;
+    apiKeyEnv: string | null;
+    summary: string;
+    steps: string[];
+    credentialHandling: string;
+}
+export declare function getApiProviderLoginGuidance(provider: ApiProviderConfig): ApiProviderLoginGuidance;

package/dist/provider-login-guidance.js

@@ -1,3 +1,4 @@
+import { redactDiagnosticUrl } from "./endpoint-exposure.js";
 const GUIDANCE = {
     claude: {
         provider: "claude",
@@ -122,3 +123,30 @@ export function getProviderLoginGuidance(provider) {
 export function getAllProviderLoginGuidance() {
     return { ...GUIDANCE };
 }
+export function getApiProviderLoginGuidance(provider) {
+    const keyless = provider.apiKeyEnv === null;
+    const baseUrl = redactDiagnosticUrl(provider.baseUrl) ?? provider.baseUrl;
+    const summary = keyless
+        ? `Keyless-local API provider "${provider.name}" (kind: ${provider.kind}); no credential is required for its loopback endpoint.`
+        : `API provider "${provider.name}" (kind: ${provider.kind}) authenticates with a key read from the ${provider.apiKeyEnv} environment variable.`;
+    const steps = keyless
+        ? [
+            `Ensure the local endpoint at ${baseUrl} is running (e.g. Ollama or llama.cpp).`,
+            `No API key is needed; the provider is enabled as soon as the loopback endpoint is reachable.`,
+        ]
+        : [
+            `Obtain an API key from the provider that serves ${baseUrl}.`,
+            `Export it as ${provider.apiKeyEnv} in the gateway's environment (the value is read only at request time).`,
+            `Confirm [providers.${provider.name}] in the gateway config points at the intended base_url and default_model.`,
+        ];
+    return {
+        provider: provider.name,
+        displayName: provider.name,
+        kind: provider.kind,
+        baseUrl,
+        apiKeyEnv: provider.apiKeyEnv,
+        summary,
+        steps,
+        credentialHandling: "Set the API key only via the named environment variable. Do not paste the key into the gateway config, prompts, or a remote chat.",
+    };
+}

package/dist/provider-status.d.ts

@@ -1,5 +1,6 @@
 import type { CliType } from "./session-manager.js";
 import { type ProviderLoginGuidance } from "./provider-login-guidance.js";
+import { type ApiProviderConfig } from "./config.js";
 export type ProviderLoginStatus = "authenticated" | "not_authenticated" | "unknown" | "not_checked";
 export interface ProviderRuntimeStatus {
     provider: CliType;
@@ -17,6 +18,17 @@ export interface ProviderRuntimeStatus {
     };
     guidance: ProviderLoginGuidance;
 }
+export interface ApiProviderRuntimeStatus {
+    provider: string;
+    kind: ApiProviderConfig["kind"];
+    baseUrl: string;
+    defaultModel: string;
+    models: string[] | null;
+    apiKeyEnv: string | null;
+    apiKeyPresent: boolean;
+    enabled: boolean;
+}
+export declare function getApiProviderStatus(provider: ApiProviderConfig, env?: NodeJS.ProcessEnv): ApiProviderRuntimeStatus;
 export declare const PROVIDER_COMMANDS: Record<CliType, string>;
 export declare function listProviderRuntimeStatuses(): Record<CliType, ProviderRuntimeStatus>;
 export declare function getProviderRuntimeStatus(provider: CliType): ProviderRuntimeStatus;

package/dist/provider-status.js

@@ -3,7 +3,21 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { getProviderLoginGuidance } from "./provider-login-guidance.js";
+import { apiProviderKeyPresent, isApiProviderEnabled } from "./config.js";
+import { redactDiagnosticUrl } from "./endpoint-exposure.js";
 import { envWithExtendedPath, getExtendedPath, providerCommandName, resolveCommandForSpawn, } from "./executor.js";
+export function getApiProviderStatus(provider, env = process.env) {
+    return {
+        provider: provider.name,
+        kind: provider.kind,
+        baseUrl: redactDiagnosticUrl(provider.baseUrl) ?? provider.baseUrl,
+        defaultModel: provider.defaultModel,
+        models: provider.models ?? null,
+        apiKeyEnv: provider.apiKeyEnv,
+        apiKeyPresent: apiProviderKeyPresent(provider, env),
+        enabled: isApiProviderEnabled(provider, env),
+    };
+}
 const PROVIDERS = ["claude", "codex", "gemini", "grok", "mistral", "devin"];
 const VERSION_ARGS = {
     claude: ["--version"],

package/dist/provider-tool-capabilities.d.ts

@@ -1,5 +1,6 @@
 import { type CliInfo } from "./model-registry.js";
 import { type CliType } from "./session-manager.js";
+import { type ProvidersConfig } from "./config.js";
 export interface ProviderToolControl {
     name?: string;
     supported: boolean;
@@ -128,6 +129,7 @@ export interface ProviderCapabilityQuery {
     includeUnsupported?: boolean;
     includePaths?: boolean;
     refresh?: boolean;
+    providersConfig?: ProvidersConfig;
 }
 export type ProviderToolCapabilitiesMap = Partial<Record<ProviderCapabilityId, ProviderToolCapabilities>>;
 export declare function getProviderToolCapabilities(queryOrCli?: ProviderCapabilityQuery | ProviderCapabilityId): ProviderToolCapabilitiesMap;
@@ -137,4 +139,5 @@ export declare function _getCapabilityCacheForTest(): Map<string, {
     loadedAt: number;
     value: ProviderToolCapabilities;
 }>;
-export declare function providerCapabilityIds(): readonly KnownProviderCapabilityId[];
+export declare function providerCapabilityIds(providersConfig?: ProvidersConfig): readonly ProviderCapabilityId[];
+export declare function knownProviderCapabilityIds(): readonly KnownProviderCapabilityId[];

package/dist/provider-tool-capabilities.js

@@ -5,7 +5,8 @@ import { parse as parseToml } from "smol-toml";
 import { CLAUDE_MCP_SERVER_NAMES } from "./claude-mcp-config.js";
 import { getAvailableCliInfo } from "./model-registry.js";
 import { CLI_TYPES } from "./session-manager.js";
-import { isXaiProviderEnabled, loadProvidersConfig } from "./config.js";
+import { enabledApiProviders, isXaiProviderEnabled, loadProvidersConfig, } from "./config.js";
+import { apiContinuityForKind } from "./api-provider.js";
 const MAX_SKILLS_PER_DIR = 100;
 const MAX_SKILL_BYTES = 64 * 1024;
 const MAX_CONFIG_BYTES = 128 * 1024;
@@ -809,7 +810,7 @@ const TOOL_CONTROLS = {
 const CAPABILITY_CACHE = new Map();
 export function getProviderToolCapabilities(queryOrCli = {}) {
     const query = normalizeQuery(queryOrCli);
-    const providers = query.cli ? [query.cli] : PROVIDER_CAPABILITY_IDS;
+    const providers = query.cli ? [query.cli] : allProviderCapabilityIds(query.providersConfig);
     const entries = providers.map(provider => [
         provider,
         getOneProviderToolCapabilities(provider, query),
@@ -833,14 +834,35 @@ export function clearProviderToolCapabilitiesCache() {
 export function _getCapabilityCacheForTest() {
     return CAPABILITY_CACHE;
 }
-export function providerCapabilityIds() {
+function providersConfigForQuery(query) {
+    return query.providersConfig ?? loadProvidersConfig();
+}
+function enabledApiCapabilityIds(providersConfig) {
+    return enabledApiProviders(providersConfig ?? loadProvidersConfig()).map(provider => provider.name);
+}
+function allProviderCapabilityIds(providersConfig) {
+    return [
+        ...new Set([
+            ...PROVIDER_CAPABILITY_IDS,
+            ...enabledApiCapabilityIds(providersConfig),
+        ]),
+    ];
+}
+export function providerCapabilityIds(providersConfig) {
+    return allProviderCapabilityIds(providersConfig);
+}
+export function knownProviderCapabilityIds() {
     return PROVIDER_CAPABILITY_IDS;
 }
 function buildOneProviderToolCapabilities(cli, query) {
     const warnings = [];
     if (!isKnownProviderCapabilityId(cli)) {
-        throw new Error(`No tool-capability metadata for provider "${cli}". ` +
-            `Known providers: ${PROVIDER_CAPABILITY_IDS.join(", ")}.`);
+        const runtime = enabledApiProviders(providersConfigForQuery(query)).find(provider => provider.name === cli);
+        if (!runtime) {
+            throw new Error(`No tool-capability metadata for provider "${cli}". ` +
+                `Known providers: ${allProviderCapabilityIds(query.providersConfig).join(", ")}.`);
+        }
+        return buildApiProviderToolCapabilities(runtime, query);
     }
     const definition = TOOL_CONTROLS[cli];
     const discoveredSkills = query.includeSkills && cli !== "grok_api" ? discoverSkills(cli, warnings, query) : [];
@@ -848,7 +870,7 @@ function buildOneProviderToolCapabilities(cli, query) {
         ? extractProviderTools(cli, discoveredSkills)
         : [];
     const features = { ...definition.features };
-    const gatewayRequestTools = cli === "grok_api" && !isXaiProviderEnabled(loadProvidersConfig())
+    const gatewayRequestTools = cli === "grok_api" && !isXaiProviderEnabled(providersConfigForQuery(query))
         ? []
         : [...definition.gatewayRequestTools];
     if (cli === "grok") {
@@ -864,7 +886,7 @@ function buildOneProviderToolCapabilities(cli, query) {
         providerKind: definition.providerKind,
         gatewayRequestTools,
         gatewayRequestTool: gatewayRequestTools[0] ?? definition.gatewayRequestTools[0],
-        modelInfo: getModelInfo(cli, query.refresh),
+        modelInfo: getModelInfo(cli, query),
         summary: definition.summary,
         acpContract: { ...ACP_CONTRACT.providers[cli] },
         acp: cloneAcpCapability(ACP_CAPABILITIES[cli]),
@@ -883,6 +905,172 @@ function buildOneProviderToolCapabilities(cli, query) {
         },
     };
 }
+function apiProviderCapabilityDefinition(runtime) {
+    const { name, kind } = runtime;
+    const forwardsReasoning = kind === "xai-responses";
+    const continuity = apiContinuityForKind(kind);
+    const continuityTracked = continuity !== "none";
+    return {
+        providerKind: "api",
+        gatewayRequestTools: [`api_${name}_request`],
+        summary: `Generic ${kind} API provider "${name}" configured through [providers.${name}]. ` +
+            "HTTP request tool only: no local CLI tools, skills, MCP servers, or workspaces.",
+        controls: {
+            allowlist: {
+                supported: false,
+                behavior: `api_${name}_request has no CLI tool allow-list input.`,
+            },
+            denylist: {
+                supported: false,
+                behavior: `api_${name}_request has no CLI tool deny-list input.`,
+            },
+            mcpServers: {
+                supported: false,
+                behavior: "API requests do not configure or expose MCP servers.",
+            },
+            nativeSkills: {
+                supported: false,
+                behavior: "API requests do not read local provider skills.",
+            },
+            reasoningEffort: forwardsReasoning
+                ? {
+                    supported: true,
+                    requestField: "reasoningEffort",
+                    behavior: "Passed to the xAI Responses API reasoning.effort field.",
+                }
+                : {
+                    supported: false,
+                    requestField: "reasoningEffort",
+                    behavior: `Accepted by the schema but ignored by the ${kind} adapter.`,
+                },
+            maxOutputTokens: {
+                supported: true,
+                requestField: "maxOutputTokens",
+                behavior: "Bounds the provider API max output tokens.",
+            },
+            sampling: {
+                supported: true,
+                requestField: "temperature/topP",
+                behavior: "Sampling controls are passed through to the provider API.",
+            },
+            timeout: {
+                supported: true,
+                requestField: "timeoutMs",
+                behavior: "Bounds the API HTTP request timeout.",
+            },
+            session: continuityTracked
+                ? {
+                    supported: true,
+                    requestField: "sessionId/createNewSession",
+                    behavior: continuity === "server-side-id"
+                        ? "Gateway stores the provider continuation handle (previous_response_id) in session metadata."
+                        : "Gateway tracks the session (active/owner); stateless adapters resend prior context caller-side without storing conversation content.",
+                }
+                : {
+                    supported: false,
+                    requestField: "sessionId/createNewSession",
+                    behavior: "This provider kind does not support multi-turn continuity.",
+                },
+        },
+        features: baseFeatures({
+            apiProvider: true,
+            structuredTextResponses: true,
+            sessionContinuity: continuityTracked,
+        }),
+        unsupportedInputs: [
+            {
+                input: "localSkills",
+                behavior: "not_supported",
+                details: `api_${name}_request does not inspect local CLI skills.`,
+            },
+            {
+                input: "allowedTools/disallowedTools",
+                behavior: "not_supported",
+                details: "Tool allow/deny controls are CLI-only and are not routed to the API.",
+            },
+            {
+                input: "workspace/worktree",
+                behavior: "not_supported",
+                details: "API providers have no local workspace or worktree controls.",
+            },
+        ],
+    };
+}
+function apiProviderModelInfo(runtime) {
+    const list = runtime.models && runtime.models.length > 0 ? runtime.models : [runtime.defaultModel];
+    const models = {};
+    for (const model of list) {
+        models[model] =
+            model === runtime.defaultModel ? "Configured default model" : "Configured allowlisted model";
+    }
+    if (!(runtime.defaultModel in models)) {
+        models[runtime.defaultModel] = "Configured default model (always permitted)";
+    }
+    return {
+        description: `Generic ${runtime.kind} API provider configured through [providers.${runtime.name}].`,
+        models,
+        defaultModel: runtime.defaultModel,
+        defaultModelSource: `[providers.${runtime.name}].default_model`,
+    };
+}
+function apiProviderConfigSurfaces(runtime) {
+    return [
+        {
+            name: `providers.${runtime.name}`,
+            kind: "gateway",
+            present: true,
+            details: `Generic ${runtime.kind} API provider; secret key material is read only from the named environment variable at request time.`,
+        },
+        {
+            name: "api_key_env",
+            kind: "env",
+            present: runtime.apiKey.length > 0,
+            entries: runtime.apiKeyEnv ? [runtime.apiKeyEnv] : [],
+            details: "Reports only the configured environment variable name and whether a key is resolved (keyless-local providers report false); never the value.",
+        },
+    ];
+}
+function buildApiProviderToolCapabilities(runtime, query) {
+    const definition = apiProviderCapabilityDefinition(runtime);
+    return {
+        schemaVersion: "provider-tool-capabilities.v2",
+        generatedAt: new Date().toISOString(),
+        cli: runtime.name,
+        providerKind: "api",
+        gatewayRequestTools: [...definition.gatewayRequestTools],
+        gatewayRequestTool: definition.gatewayRequestTools[0],
+        modelInfo: apiProviderModelInfo(runtime),
+        summary: definition.summary,
+        acpContract: {
+            classification: "absent_watchlist",
+            summary: `${runtime.name} is an HTTP API provider with no ACP process transport; watchlist item only.`,
+        },
+        acp: {
+            status: "not_applicable",
+            mediation: "none",
+            targetVersion: `${runtime.kind} API`,
+            entrypoint: null,
+            runtimeEnabled: false,
+            smokeSupported: false,
+            smokeStatus: "unsupported",
+            caveats: ["ACP is a CLI-stdio transport; the HTTP API provider has no ACP surface."],
+            docs: ACP_DOCS_REFERENCE,
+        },
+        controls: cloneControls(definition.controls),
+        features: { ...definition.features },
+        discoveredSkills: [],
+        discoveredProviderTools: [],
+        configSurfaces: apiProviderConfigSurfaces(runtime),
+        unsupportedInputs: query.includeUnsupported ? [...definition.unsupportedInputs] : [],
+        warnings: [],
+        metadata: {
+            deprecatedFields: {
+                gatewayRequestTool: "Use gatewayRequestTools instead.",
+            },
+            cacheTtlMs: CAPABILITY_CACHE_TTL_MS,
+        },
+    };
+}
 function discoverSkills(cli, warnings, query) {
     const skills = [];
     for (const root of skillRoots(cli)) {
@@ -960,6 +1148,7 @@ function normalizeQuery(queryOrCli) {
         includeUnsupported: query.includeUnsupported ?? true,
         includePaths: query.includePaths ?? false,
         refresh: query.refresh ?? false,
+        providersConfig: query.providersConfig,
     };
 }
 function capabilityCacheKey(cli, query) {
@@ -969,8 +1158,33 @@ function capabilityCacheKey(cli, query) {
         includeProviderTools: query.includeProviderTools,
         includeUnsupported: query.includeUnsupported,
         includePaths: query.includePaths,
+        providersConfig: query.providersConfig ? providerConfigCacheKey(query.providersConfig) : null,
     });
 }
+function providerConfigCacheKey(config) {
+    return {
+        xai: config.xai
+            ? {
+                apiKeyEnv: config.xai.apiKeyEnv,
+                baseUrl: config.xai.baseUrl,
+                defaultModel: config.xai.defaultModel,
+            }
+            : null,
+        providers: Object.fromEntries(Object.entries(config.providers ?? {})
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([name, provider]) => [
+            name,
+            {
+                kind: provider.kind,
+                apiKeyEnv: provider.apiKeyEnv,
+                baseUrl: provider.baseUrl,
+                defaultModel: provider.defaultModel,
+                models: provider.models ?? null,
+                usageInclude: provider.usageInclude ?? null,
+            },
+        ])),
+    };
+}
 function baseFeatures(overrides) {
     const names = [
         "gatewayRequestTools",
@@ -1012,11 +1226,11 @@ function baseFeatures(overrides) {
 function cloneControls(controls) {
     return Object.fromEntries(Object.entries(controls).map(([name, control]) => [name, { name, ...control }]));
 }
-function getModelInfo(cli, refresh) {
+function getModelInfo(cli, query) {
     if (cli !== "grok_api") {
-        return getAvailableCliInfo(refresh)[cli];
+        return getAvailableCliInfo(query.refresh)[cli];
     }
-    const providers = loadProvidersConfig();
+    const providers = providersConfigForQuery(query);
     const enabled = isXaiProviderEnabled(providers);
     const defaultModel = providers.xai?.defaultModel;
     return {
@@ -1031,7 +1245,7 @@ function getModelInfo(cli, refresh) {
 }
 function discoverConfigSurfaces(cli, query, discoveredSkills) {
     if (cli === "grok_api") {
-        const providers = loadProvidersConfig();
+        const providers = providersConfigForQuery(query);
         return [
             {
                 name: "providers.xai",

package/dist/resources.d.ts

@@ -2,7 +2,7 @@ import { ISessionManager } from "./session-manager.js";
 import { PerformanceMetrics } from "./metrics.js";
 import { FlightRecorderQuery } from "./flight-recorder.js";
 import { type GlobalCacheStats, type PrefixCacheStats, type SessionCacheStats } from "./cache-stats.js";
-import type { CacheAwarenessConfig } from "./config.js";
+import { type CacheAwarenessConfig, type ProvidersConfig } from "./config.js";
 export interface ResourceDefinition {
     uri: string;
     name: string;
@@ -25,8 +25,12 @@ export declare class ResourceProvider {
     private performanceMetrics;
     private flightRecorder;
     private cacheAwareness;
-    constructor(sessionManager: ISessionManager, performanceMetrics: PerformanceMetrics, flightRecorder?: FlightRecorderQuery, cacheAwareness?: CacheAwarenessConfig | null);
+    private providers;
+    constructor(sessionManager: ISessionManager, performanceMetrics: PerformanceMetrics, flightRecorder?: FlightRecorderQuery, cacheAwareness?: CacheAwarenessConfig | null, providers?: ProvidersConfig | null);
     getFlightRecorderQuery(): FlightRecorderQuery;
+    private apiRuntimes;
+    private continuityTrackedApiRuntimes;
+    private providerCapabilityIds;
     readCacheStateGlobal(opts?: {
         lastNHours?: number;
     }): GlobalCacheStats;

package/dist/resources.js

@@ -2,22 +2,36 @@ import { CLI_TYPES, PROVIDER_TYPES } from "./session-manager.js";
 import { getRequestContext, principalCanAccess, resolveOwnerPrincipal } from "./request-context.js";
 import { getAvailableCliInfo } from "./model-registry.js";
 import { computeGlobalCacheStats, computePrefixCacheStats, computeSessionCacheStats, computeTtlRemaining, } from "./cache-stats.js";
+import { enabledApiProviders, } from "./config.js";
+import { apiContinuityForKind } from "./api-provider.js";
+import { apiProviderCatalogEntry } from "./api-request.js";
 import { buildProviderSubcommandsCompactCatalog, getCliSubcommandContract, serializeCliSubcommandContract, } from "./upstream-contracts.js";
-import { getOneProviderToolCapabilities, getProviderToolCapabilities, providerCapabilityIds, } from "./provider-tool-capabilities.js";
+import { getOneProviderToolCapabilities, getProviderToolCapabilities, knownProviderCapabilityIds, providerCapabilityIds, } from "./provider-tool-capabilities.js";
 export class ResourceProvider {
     sessionManager;
     performanceMetrics;
     flightRecorder;
     cacheAwareness;
-    constructor(sessionManager, performanceMetrics, flightRecorder = { queryRequests: () => [] }, cacheAwareness = null) {
+    providers;
+    constructor(sessionManager, performanceMetrics, flightRecorder = { queryRequests: () => [] }, cacheAwareness = null, providers = null) {
         this.sessionManager = sessionManager;
         this.performanceMetrics = performanceMetrics;
         this.flightRecorder = flightRecorder;
         this.cacheAwareness = cacheAwareness;
+        this.providers = providers;
     }
     getFlightRecorderQuery() {
         return this.flightRecorder;
     }
+    apiRuntimes() {
+        return this.providers ? enabledApiProviders(this.providers) : [];
+    }
+    continuityTrackedApiRuntimes() {
+        return this.apiRuntimes().filter(rt => apiContinuityForKind(rt.kind) !== "none");
+    }
+    providerCapabilityIds() {
+        return this.providers ? providerCapabilityIds(this.providers) : knownProviderCapabilityIds();
+    }
     readCacheStateGlobal(opts = {}) {
         return computeGlobalCacheStats(this.flightRecorder, opts);
     }
@@ -101,6 +115,17 @@ export class ResourceProvider {
                     priority: 0.6,
                 },
             },
+            ...this.continuityTrackedApiRuntimes().map(rt => ({
+                uri: `sessions://${rt.name}`,
+                name: `${rt.name} Sessions`,
+                title: `${rt.name} Sessions`,
+                description: `List of ${rt.name} API provider conversation sessions`,
+                mimeType: "application/json",
+                annotations: {
+                    audience: ["user", "assistant"],
+                    priority: 0.6,
+                },
+            })),
             {
                 uri: "models://claude",
                 name: "Claude Models",
@@ -156,6 +181,17 @@ export class ResourceProvider {
                     priority: 0.8,
                 },
             },
+            ...this.apiRuntimes().map(rt => ({
+                uri: `models://${rt.name}`,
+                name: `${rt.name} Models`,
+                title: `${rt.name} Models & Capabilities`,
+                description: `Configured ${rt.name} API provider model catalog`,
+                mimeType: "application/json",
+                annotations: {
+                    audience: ["user", "assistant"],
+                    priority: 0.8,
+                },
+            })),
             {
                 uri: "metrics://performance",
                 name: "Performance Metrics",
@@ -189,7 +225,7 @@ export class ResourceProvider {
                     priority: 0.8,
                 },
             },
-            ...providerCapabilityIds().map(cli => ({
+            ...this.providerCapabilityIds().map(cli => ({
                 uri: `provider-tools://${cli}`,
                 name: `${cli} Tool Capabilities`,
                 title: `${cli} Tool Capabilities`,
@@ -338,6 +374,32 @@ export class ResourceProvider {
                 text: JSON.stringify(cliInfo.mistral, null, 2),
             };
         }
+        if (uri.startsWith("models://")) {
+            const runtime = this.apiRuntimes().find(rt => `models://${rt.name}` === uri);
+            if (runtime) {
+                return {
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify(apiProviderCatalogEntry(runtime), null, 2),
+                };
+            }
+        }
+        if (uri.startsWith("sessions://")) {
+            const runtime = this.continuityTrackedApiRuntimes().find(rt => `sessions://${rt.name}` === uri);
+            if (runtime) {
+                const sessions = this.ownedSessions(await this.sessionManager.listSessions(runtime.name));
+                return {
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        cli: runtime.name,
+                        total: sessions.length,
+                        sessions,
+                        activeSession: await this.ownedActiveId(runtime.name),
+                    }, null, 2),
+                };
+            }
+        }
         if (uri === "metrics://performance") {
             return {
                 uri,
@@ -356,15 +418,17 @@ export class ResourceProvider {
             return {
                 uri,
                 mimeType: "application/json",
-                text: JSON.stringify(getProviderToolCapabilities(), null, 2),
+                text: JSON.stringify(getProviderToolCapabilities({ providersConfig: this.providers ?? undefined }), null, 2),
             };
         }
-        const providerToolsResource = parseProviderToolsUri(uri);
+        const providerToolsResource = parseProviderToolsUri(uri, this.providerCapabilityIds());
         if (providerToolsResource) {
             return {
                 uri,
                 mimeType: "application/json",
-                text: JSON.stringify(getOneProviderToolCapabilities(providerToolsResource.provider), null, 2),
+                text: JSON.stringify(getOneProviderToolCapabilities(providerToolsResource.provider, {
+                    providersConfig: this.providers ?? undefined,
+                }), null, 2),
             };
         }
         const subcommandResource = parseProviderSubcommandUri(uri);
@@ -401,7 +465,7 @@ function parseProviderSubcommandUri(uri) {
         commandPath: pathParts.map(part => decodeURIComponent(part)).filter(Boolean),
     };
 }
-function parseProviderToolsUri(uri) {
+function parseProviderToolsUri(uri, providerIds) {
     const prefix = uri.startsWith("provider-tools://")
         ? "provider-tools://"
         : uri.startsWith("provider_tools://")
@@ -410,7 +474,7 @@ function parseProviderToolsUri(uri) {
     if (!prefix || uri === `${prefix}catalog`)
         return null;
     const provider = uri.slice(prefix.length);
-    if (!providerCapabilityIds().includes(provider))
+    if (!providerIds.includes(provider))
         return null;
     return { provider: provider };
 }

package/dist/validation-normalizer.js

@@ -1,10 +1,11 @@
 export function normalizeStartedJob(provider, model, snapshot, warning) {
+    const inProgress = snapshot.status === "running" || snapshot.status === "queued";
     return {
         provider,
         model,
-        status: snapshot.status,
-        verdict: snapshot.status === "running" ? "pending" : null,
-        rationale: snapshot.status === "running" ? "Provider job is running asynchronously." : null,
+        status: snapshot.status === "queued" ? "running" : snapshot.status,
+        verdict: inProgress ? "pending" : null,
+        rationale: inProgress ? "Provider job is running asynchronously." : null,
         risks: [],
         rawJobReference: {
             jobId: snapshot.id,
@@ -34,7 +35,7 @@ export function normalizeJobResult(provider, model, result) {
     return {
         provider,
         model,
-        status: result.status,
+        status: result.status === "queued" ? "running" : result.status,
         verdict: inferVerdict(output, result.status),
         rationale: output ? excerpt(output, 1800) : error,
         risks: extractRisks(output, error),

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "llm-cli-gateway",
-  "version": "2.12.1",
+  "version": "2.12.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "llm-cli-gateway",
-      "version": "2.12.1",
+      "version": "2.12.2",
       "license": "MIT",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.29.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-cli-gateway",
-  "version": "2.12.1",
+  "version": "2.12.2",
   "mcpName": "io.github.verivus-oss/llm-cli-gateway",
   "description": "MCP server providing unified access to Claude Code, Codex, Gemini, Grok, Mistral Vibe, and Devin CLIs with session management, retry logic, async job orchestration, durable job results, and cross-LLM validation.",
   "license": "MIT",