llm-cli-gateway 2.13.1 → 2.14.0-rc.1

package/dist/request-helpers.d.ts

@@ -72,6 +72,20 @@ export declare const CODEX_SANDBOX_MODES: readonly ["read-only", "workspace-writ
 export type CodexSandboxMode = (typeof CODEX_SANDBOX_MODES)[number];
 export declare const CODEX_ASK_FOR_APPROVAL_MODES: readonly ["untrusted", "on-request", "never"];
 export type CodexAskForApproval = (typeof CODEX_ASK_FOR_APPROVAL_MODES)[number];
+export declare const CODEX_LOCAL_PROVIDERS: readonly ["lmstudio", "ollama"];
+export type CodexLocalProvider = (typeof CODEX_LOCAL_PROVIDERS)[number];
+export declare const CODEX_COLOR_MODES: readonly ["always", "never", "auto"];
+export type CodexColorMode = (typeof CODEX_COLOR_MODES)[number];
+export type UnexposedFlagReason = "interactive-only" | "gateway-managed" | "admin-deferred";
+export interface UnexposedCliFlag {
+    flag: string;
+    reason: UnexposedFlagReason;
+    detail: string;
+}
+export declare const CLAUDE_UNEXPOSED_CLI_FLAGS: readonly UnexposedCliFlag[];
+export declare const CODEX_UNEXPOSED_CLI_FLAGS: readonly UnexposedCliFlag[];
+export declare const GEMINI_UNEXPOSED_CLI_FLAGS: readonly UnexposedCliFlag[];
+export declare const MISTRAL_UNEXPOSED_CLI_FLAGS: readonly UnexposedCliFlag[];
 export interface CodexSandboxFlagsInput {
     sandboxMode?: CodexSandboxMode;
     askForApproval?: CodexAskForApproval;
@@ -98,8 +112,8 @@ export declare const CLAUDE_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodEffects<z.ZodObject<
     effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>;
     excludeDynamicSystemPromptSections: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    agent?: string | undefined;
     agents?: Record<string, Record<string, unknown>> | undefined;
+    agent?: string | undefined;
     forkSession?: boolean | undefined;
     systemPrompt?: string | undefined;
     appendSystemPrompt?: string | undefined;
@@ -108,8 +122,8 @@ export declare const CLAUDE_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodEffects<z.ZodObject<
     effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
     excludeDynamicSystemPromptSections?: boolean | undefined;
 }, {
-    agent?: string | undefined;
     agents?: Record<string, Record<string, unknown>> | undefined;
+    agent?: string | undefined;
     forkSession?: boolean | undefined;
     systemPrompt?: string | undefined;
     appendSystemPrompt?: string | undefined;
@@ -118,8 +132,8 @@ export declare const CLAUDE_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodEffects<z.ZodObject<
     effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
     excludeDynamicSystemPromptSections?: boolean | undefined;
 }>, {
-    agent?: string | undefined;
     agents?: Record<string, Record<string, unknown>> | undefined;
+    agent?: string | undefined;
     forkSession?: boolean | undefined;
     systemPrompt?: string | undefined;
     appendSystemPrompt?: string | undefined;
@@ -128,8 +142,8 @@ export declare const CLAUDE_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodEffects<z.ZodObject<
     effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
     excludeDynamicSystemPromptSections?: boolean | undefined;
 }, {
-    agent?: string | undefined;
     agents?: Record<string, Record<string, unknown>> | undefined;
+    agent?: string | undefined;
     forkSession?: boolean | undefined;
     systemPrompt?: string | undefined;
     appendSystemPrompt?: string | undefined;
@@ -180,6 +194,17 @@ export interface ClaudeHighImpactFlagsInput {
     settingSources?: string;
     settings?: string;
     tools?: string[];
+    includeHookEvents?: boolean;
+    replayUserMessages?: boolean;
+    systemPromptFile?: string;
+    appendSystemPromptFile?: string;
+    name?: string;
+    pluginDir?: string[];
+    pluginUrl?: string[];
+    safeMode?: boolean;
+    bare?: boolean;
+    debug?: string | boolean;
+    debugFile?: string;
 }
 export declare function prepareClaudeHighImpactFlags(input: ClaudeHighImpactFlagsInput): string[];
 export declare const CODEX_CONFIG_OVERRIDES_SCHEMA: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, string, string>>>;
@@ -200,6 +225,8 @@ export declare const CODEX_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodObject<{
     images: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     ignoreUserConfig: z.ZodOptional<z.ZodBoolean>;
     ignoreRules: z.ZodOptional<z.ZodBoolean>;
+    enable: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    disable: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     search?: boolean | undefined;
     outputSchema?: string | Record<string, unknown> | undefined;
@@ -209,6 +236,8 @@ export declare const CODEX_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodObject<{
     images?: string[] | undefined;
     ignoreUserConfig?: boolean | undefined;
     ignoreRules?: boolean | undefined;
+    enable?: string[] | undefined;
+    disable?: string[] | undefined;
 }, {
     search?: boolean | undefined;
     outputSchema?: string | Record<string, unknown> | undefined;
@@ -218,6 +247,8 @@ export declare const CODEX_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodObject<{
     images?: string[] | undefined;
     ignoreUserConfig?: boolean | undefined;
     ignoreRules?: boolean | undefined;
+    enable?: string[] | undefined;
+    disable?: string[] | undefined;
 }>;
 export interface CodexHighImpactFlagsInput {
     outputSchema?: string | Record<string, unknown>;
@@ -228,6 +259,8 @@ export interface CodexHighImpactFlagsInput {
     images?: string[];
     ignoreUserConfig?: boolean;
     ignoreRules?: boolean;
+    enable?: string[];
+    disable?: string[];
 }
 export interface CodexHighImpactFlagsResult {
     args: string[];

package/dist/request-helpers.js

@@ -176,6 +176,86 @@ export function resolveClaudePermissionFlags(input) {
 export const GEMINI_APPROVAL_MODES = ["default", "auto_edit", "yolo", "plan"];
 export const CODEX_SANDBOX_MODES = ["read-only", "workspace-write", "danger-full-access"];
 export const CODEX_ASK_FOR_APPROVAL_MODES = ["untrusted", "on-request", "never"];
+export const CODEX_LOCAL_PROVIDERS = ["lmstudio", "ollama"];
+export const CODEX_COLOR_MODES = ["always", "never", "auto"];
+export const CLAUDE_UNEXPOSED_CLI_FLAGS = [
+    {
+        flag: "--tmux",
+        reason: "interactive-only",
+        detail: "Creates an attached tmux/iTerm2 session for a worktree (requires --worktree); incompatible with headless --print.",
+    },
+    {
+        flag: "--background",
+        reason: "gateway-managed",
+        detail: "Starts a detached background agent (managed via `claude agents`); conflicts with the gateway's own async-job model.",
+    },
+    {
+        flag: "--remote-control",
+        reason: "gateway-managed",
+        detail: "Starts an interactive Remote Control session; a stateful/remote surface deferred to the gateway-managed transport.",
+    },
+    {
+        flag: "--remote",
+        reason: "admin-deferred",
+        detail: "No bare --remote exists in installed Claude help; the only remote surface is --remote-control (gateway-managed).",
+    },
+    {
+        flag: "--worktree",
+        reason: "gateway-managed",
+        detail: "claude --help advertises -w, --worktree [name], but gateway worktrees are owned by slice λ (worktree-manager); the native --worktree is intentionally never emitted so the gateway owns the checkout lifecycle.",
+    },
+    {
+        flag: "--resume",
+        reason: "gateway-managed",
+        detail: "claude --help advertises -r, --resume [value] for interactive resume; the gateway session model maps continuity onto --continue (continueSession) and --session-id (sessionId), so the raw --resume passthrough is intentionally not wired.",
+    },
+];
+export const CODEX_UNEXPOSED_CLI_FLAGS = [
+    {
+        flag: "--remote",
+        reason: "admin-deferred",
+        detail: "TUI-only (top-level `codex` help, not `codex exec`): connects the TUI to a remote app-server endpoint; not a headless exec flag.",
+    },
+    {
+        flag: "--remote-auth-token-env",
+        reason: "admin-deferred",
+        detail: "TUI-only companion to --remote (bearer-token env var for the remote app-server websocket); not a headless exec flag.",
+    },
+    {
+        flag: "--ask-for-approval",
+        reason: "admin-deferred",
+        detail: "Removed from the installed `codex exec` upstream: current codex exec no longer accepts --ask-for-approval. The askForApproval MCP input is retained for back-compat but warns and emits no argv (accepted-but-ignored); classified here because the flag is not present in the installed headless help.",
+    },
+    {
+        flag: "--search",
+        reason: "admin-deferred",
+        detail: "Removed from the installed `codex exec` upstream: current codex exec no longer accepts --search. The search MCP input is retained for back-compat but warns and emits no argv (accepted-but-ignored); classified here because the flag is not present in the installed headless help.",
+    },
+];
+export const GEMINI_UNEXPOSED_CLI_FLAGS = [
+    {
+        flag: "--prompt-interactive",
+        reason: "interactive-only",
+        detail: "Runs an initial prompt then continues in an attached interactive session (short alias -i); incompatible with the headless --print run mode the gateway drives.",
+    },
+    {
+        flag: "--log-file",
+        reason: "admin-deferred",
+        detail: "Overrides agy's internal CLI log file path (a diagnostic/maintenance surface); the gateway flight recorder is the request-logging surface, so this is deferred to a later admin phase.",
+    },
+];
+export const MISTRAL_UNEXPOSED_CLI_FLAGS = [
+    {
+        flag: "--setup",
+        reason: "admin-deferred",
+        detail: "Vibe `--setup` configures the API key and exits; a credential/setup maintenance op, not a headless run flag. Deferred to the phase-6 admin surface.",
+    },
+    {
+        flag: "--check-upgrade",
+        reason: "admin-deferred",
+        detail: "Vibe `--check-upgrade` checks for a Vibe update, prompts to install, and exits; a maintenance op, not a headless run flag. Deferred to the phase-6 admin surface.",
+    },
+];
 export function resolveCodexSandboxFlags(input) {
     const { sandboxMode, askForApproval, fullAuto, useLegacyFullAutoFlag } = input;
     const args = [];
@@ -324,6 +404,48 @@ export function prepareClaudeHighImpactFlags(input) {
     if (input.tools && input.tools.length > 0) {
         args.push("--tools", ...input.tools);
     }
+    if (input.includeHookEvents) {
+        args.push("--include-hook-events");
+    }
+    if (input.replayUserMessages) {
+        args.push("--replay-user-messages");
+    }
+    if (input.systemPromptFile !== undefined) {
+        args.push("--system-prompt-file", input.systemPromptFile);
+    }
+    if (input.appendSystemPromptFile !== undefined) {
+        args.push("--append-system-prompt-file", input.appendSystemPromptFile);
+    }
+    if (input.name !== undefined) {
+        args.push("--name", input.name);
+    }
+    if (input.pluginDir && input.pluginDir.length > 0) {
+        for (const dir of input.pluginDir) {
+            args.push("--plugin-dir", dir);
+        }
+    }
+    if (input.pluginUrl && input.pluginUrl.length > 0) {
+        for (const url of input.pluginUrl) {
+            args.push("--plugin-url", url);
+        }
+    }
+    if (input.safeMode) {
+        args.push("--safe-mode");
+    }
+    if (input.bare) {
+        args.push("--bare");
+    }
+    if (input.debug !== undefined && input.debug !== false) {
+        if (typeof input.debug === "string") {
+            args.push("--debug", input.debug);
+        }
+        else {
+            args.push("--debug");
+        }
+    }
+    if (input.debugFile !== undefined) {
+        args.push("--debug-file", input.debugFile);
+    }
     return args;
 }
 export const CODEX_CONFIG_OVERRIDES_SCHEMA = z
@@ -382,6 +504,8 @@ export const CODEX_HIGH_IMPACT_PARAMS_SCHEMA = z.object({
     images: z.array(z.string()).optional(),
     ignoreUserConfig: z.boolean().optional(),
     ignoreRules: z.boolean().optional(),
+    enable: z.array(z.string()).optional(),
+    disable: z.array(z.string()).optional(),
 });
 export function prepareCodexHighImpactFlags(input) {
     const missingImagePath = findMissingImagePath(input.images);
@@ -417,6 +541,16 @@ export function prepareCodexHighImpactFlags(input) {
     if (input.ignoreRules) {
         args.push("--ignore-rules");
     }
+    if (input.enable && input.enable.length > 0) {
+        for (const feature of input.enable) {
+            args.push("--enable", feature);
+        }
+    }
+    if (input.disable && input.disable.length > 0) {
+        for (const feature of input.disable) {
+            args.push("--disable", feature);
+        }
+    }
     return {
         args,
         cleanup,

package/dist/resources.d.ts

@@ -1,8 +1,11 @@
 import { ISessionManager } from "./session-manager.js";
+import { type CliType } 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, type ProvidersConfig } from "./config.js";
+import type { AcpConfig } from "./config.js";
+import { type ResolvedProviderCapability } from "./provider-capability-resolver.js";
 export interface ResourceDefinition {
     uri: string;
     name: string;
@@ -26,7 +29,9 @@ export declare class ResourceProvider {
     private flightRecorder;
     private cacheAwareness;
     private providers;
-    constructor(sessionManager: ISessionManager, performanceMetrics: PerformanceMetrics, flightRecorder?: FlightRecorderQuery, cacheAwareness?: CacheAwarenessConfig | null, providers?: ProvidersConfig | null);
+    private capabilityPeek;
+    private acpConfig;
+    constructor(sessionManager: ISessionManager, performanceMetrics: PerformanceMetrics, flightRecorder?: FlightRecorderQuery, cacheAwareness?: CacheAwarenessConfig | null, providers?: ProvidersConfig | null, capabilityPeek?: (id: CliType) => ResolvedProviderCapability | null, acpConfig?: AcpConfig | null);
     getFlightRecorderQuery(): FlightRecorderQuery;
     private apiRuntimes;
     private continuityTrackedApiRuntimes;

package/dist/resources.js

@@ -1,3 +1,4 @@
+import { callerIsRemote, remoteSafeSession, } from "./session-manager.js";
 import { CLI_TYPES, PROVIDER_TYPES } from "./session-manager.js";
 import { getRequestContext, principalCanAccess, resolveOwnerPrincipal } from "./request-context.js";
 import { getAvailableCliInfo } from "./model-registry.js";
@@ -7,18 +8,26 @@ import { apiContinuityForKind } from "./api-provider.js";
 import { apiProviderCatalogEntry } from "./api-request.js";
 import { buildProviderSubcommandsCompactCatalog, getCliSubcommandContract, serializeCliSubcommandContract, } from "./upstream-contracts.js";
 import { getOneProviderToolCapabilities, getProviderToolCapabilities, knownProviderCapabilityIds, providerCapabilityIds, } from "./provider-tool-capabilities.js";
+import { generateProviderAcpDescriptors, generateResourceDescriptors, parseModelsResourceUri, parseProviderAcpResourceUri, parseSessionsResourceUri, } from "./provider-surface-generator.js";
+import { getProviderDefinition } from "./provider-definitions.js";
+import { buildProviderAcpCapabilityRecord } from "./provider-acp-capabilities.js";
+import { buildProviderDiscoveredView, peekProviderCapabilitySet, } from "./provider-capability-resolver.js";
 export class ResourceProvider {
     sessionManager;
     performanceMetrics;
     flightRecorder;
     cacheAwareness;
     providers;
-    constructor(sessionManager, performanceMetrics, flightRecorder = { queryRequests: () => [] }, cacheAwareness = null, providers = null) {
+    capabilityPeek;
+    acpConfig;
+    constructor(sessionManager, performanceMetrics, flightRecorder = { queryRequests: () => [] }, cacheAwareness = null, providers = null, capabilityPeek = peekProviderCapabilitySet, acpConfig = null) {
         this.sessionManager = sessionManager;
         this.performanceMetrics = performanceMetrics;
         this.flightRecorder = flightRecorder;
         this.cacheAwareness = cacheAwareness;
         this.providers = providers;
+        this.capabilityPeek = capabilityPeek;
+        this.acpConfig = acpConfig;
     }
     getFlightRecorderQuery() {
         return this.flightRecorder;
@@ -60,61 +69,19 @@ export class ResourceProvider {
                     lastModified: new Date().toISOString(),
                 },
             },
-            {
-                uri: "sessions://claude",
-                name: "Claude Sessions",
-                title: "🤖 Claude Sessions",
-                description: "List of Claude conversation sessions",
-                mimeType: "application/json",
-                annotations: {
-                    audience: ["user", "assistant"],
-                    priority: 0.6,
-                },
-            },
-            {
-                uri: "sessions://codex",
-                name: "Codex Sessions",
-                title: "💻 Codex Sessions",
-                description: "List of Codex conversation sessions",
-                mimeType: "application/json",
-                annotations: {
-                    audience: ["user", "assistant"],
-                    priority: 0.6,
-                },
-            },
-            {
-                uri: "sessions://gemini",
-                name: "Gemini Sessions",
-                title: "✨ Gemini Sessions",
-                description: "List of Gemini conversation sessions",
-                mimeType: "application/json",
-                annotations: {
-                    audience: ["user", "assistant"],
-                    priority: 0.6,
-                },
-            },
-            {
-                uri: "sessions://grok",
-                name: "Grok Sessions",
-                title: "⚡ Grok Sessions",
-                description: "List of Grok conversation sessions",
+            ...generateResourceDescriptors()
+                .filter(descriptor => descriptor.exposesSessionsResource)
+                .map(descriptor => ({
+                uri: descriptor.sessionsUri,
+                name: `${descriptor.sessionLabel}s`,
+                title: `${descriptor.icon} ${descriptor.sessionLabel}s`,
+                description: `List of ${descriptor.displayName} conversation sessions`,
                 mimeType: "application/json",
                 annotations: {
                     audience: ["user", "assistant"],
                     priority: 0.6,
                 },
-            },
-            {
-                uri: "sessions://mistral",
-                name: "Mistral Sessions",
-                title: "🌬 Mistral Sessions",
-                description: "List of Mistral Vibe conversation sessions",
-                mimeType: "application/json",
-                annotations: {
-                    audience: ["user", "assistant"],
-                    priority: 0.6,
-                },
-            },
+            })),
             ...this.continuityTrackedApiRuntimes().map(rt => ({
                 uri: `sessions://${rt.name}`,
                 name: `${rt.name} Sessions`,
@@ -126,61 +93,19 @@ export class ResourceProvider {
                     priority: 0.6,
                 },
             })),
-            {
-                uri: "models://claude",
-                name: "Claude Models",
-                title: "🧠 Claude Models & Capabilities",
-                description: "Available Claude models and their capabilities",
-                mimeType: "application/json",
-                annotations: {
-                    audience: ["user", "assistant"],
-                    priority: 0.8,
-                },
-            },
-            {
-                uri: "models://codex",
-                name: "Codex Models",
-                title: "🔧 Codex Models & Capabilities",
-                description: "Available Codex models and their capabilities",
-                mimeType: "application/json",
-                annotations: {
-                    audience: ["user", "assistant"],
-                    priority: 0.8,
-                },
-            },
-            {
-                uri: "models://gemini",
-                name: "Gemini Models",
-                title: "🌟 Gemini Models & Capabilities",
-                description: "Available Gemini models and their capabilities",
-                mimeType: "application/json",
-                annotations: {
-                    audience: ["user", "assistant"],
-                    priority: 0.8,
-                },
-            },
-            {
-                uri: "models://grok",
-                name: "Grok Models",
-                title: "⚡ Grok Models & Capabilities",
-                description: "Available Grok models and their capabilities",
-                mimeType: "application/json",
-                annotations: {
-                    audience: ["user", "assistant"],
-                    priority: 0.8,
-                },
-            },
-            {
-                uri: "models://mistral",
-                name: "Mistral Models",
-                title: "🌬 Mistral Models & Capabilities",
-                description: "Available Mistral Vibe models and their capabilities",
+            ...generateResourceDescriptors()
+                .filter(descriptor => descriptor.exposesModelsResource)
+                .map(descriptor => ({
+                uri: descriptor.modelsUri,
+                name: `${descriptor.displayName} Models`,
+                title: `${descriptor.icon} ${descriptor.displayName} Models & Capabilities`,
+                description: `Available ${descriptor.displayName} models and their capabilities`,
                 mimeType: "application/json",
                 annotations: {
                     audience: ["user", "assistant"],
                     priority: 0.8,
                 },
-            },
+            })),
             ...this.apiRuntimes().map(rt => ({
                 uri: `models://${rt.name}`,
                 name: `${rt.name} Models`,
@@ -236,11 +161,23 @@ export class ResourceProvider {
                     priority: 0.8,
                 },
             })),
+            ...generateProviderAcpDescriptors().map(descriptor => ({
+                uri: descriptor.acpUri,
+                name: `${descriptor.displayName} ACP Capabilities`,
+                title: `${descriptor.icon} ${descriptor.displayName} ACP Capabilities`,
+                description: `Native ACP entrypoint, negotiated capabilities, supported session methods, and host-service policy for ${descriptor.displayName}`,
+                mimeType: "application/json",
+                annotations: {
+                    audience: ["user", "assistant"],
+                    priority: 0.7,
+                },
+            })),
         ];
     }
     ownedSessions(sessions) {
         const caller = resolveOwnerPrincipal(getRequestContext());
-        return sessions.filter(s => principalCanAccess(s.ownerPrincipal, caller));
+        const owned = sessions.filter(s => principalCanAccess(s.ownerPrincipal, caller));
+        return callerIsRemote() ? owned.map(remoteSafeSession) : owned;
     }
     async ownedActiveId(provider) {
         const active = await Promise.resolve(this.sessionManager.getActiveSession(provider));
@@ -269,109 +206,28 @@ export class ResourceProvider {
                 }, null, 2),
             };
         }
-        if (uri === "sessions://claude") {
-            const sessions = this.ownedSessions(await this.sessionManager.listSessions("claude"));
+        const sessionProvider = parseSessionsResourceUri(uri);
+        if (sessionProvider) {
+            const sessions = this.ownedSessions(await this.sessionManager.listSessions(sessionProvider));
             return {
                 uri,
                 mimeType: "application/json",
                 text: JSON.stringify({
-                    cli: "claude",
+                    cli: sessionProvider,
                     total: sessions.length,
                     sessions,
-                    activeSession: await this.ownedActiveId("claude"),
+                    activeSession: await this.ownedActiveId(sessionProvider),
                 }, null, 2),
             };
         }
-        if (uri === "sessions://codex") {
-            const sessions = this.ownedSessions(await this.sessionManager.listSessions("codex"));
-            return {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify({
-                    cli: "codex",
-                    total: sessions.length,
-                    sessions,
-                    activeSession: await this.ownedActiveId("codex"),
-                }, null, 2),
-            };
-        }
-        if (uri === "sessions://gemini") {
-            const sessions = this.ownedSessions(await this.sessionManager.listSessions("gemini"));
-            return {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify({
-                    cli: "gemini",
-                    total: sessions.length,
-                    sessions,
-                    activeSession: await this.ownedActiveId("gemini"),
-                }, null, 2),
-            };
-        }
-        if (uri === "sessions://grok") {
-            const sessions = this.ownedSessions(await this.sessionManager.listSessions("grok"));
-            return {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify({
-                    cli: "grok",
-                    total: sessions.length,
-                    sessions,
-                    activeSession: await this.ownedActiveId("grok"),
-                }, null, 2),
-            };
-        }
-        if (uri === "sessions://mistral") {
-            const sessions = this.ownedSessions(await this.sessionManager.listSessions("mistral"));
-            return {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify({
-                    cli: "mistral",
-                    total: sessions.length,
-                    sessions,
-                    activeSession: await this.ownedActiveId("mistral"),
-                }, null, 2),
-            };
-        }
-        if (uri === "models://claude") {
+        const modelProvider = parseModelsResourceUri(uri);
+        if (modelProvider) {
             const cliInfo = getAvailableCliInfo();
+            const discovered = buildProviderDiscoveredView(getProviderDefinition(modelProvider), cliInfo[modelProvider], this.capabilityPeek);
             return {
                 uri,
                 mimeType: "application/json",
-                text: JSON.stringify(cliInfo.claude, null, 2),
-            };
-        }
-        if (uri === "models://codex") {
-            const cliInfo = getAvailableCliInfo();
-            return {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(cliInfo.codex, null, 2),
-            };
-        }
-        if (uri === "models://gemini") {
-            const cliInfo = getAvailableCliInfo();
-            return {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(cliInfo.gemini, null, 2),
-            };
-        }
-        if (uri === "models://grok") {
-            const cliInfo = getAvailableCliInfo();
-            return {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(cliInfo.grok, null, 2),
-            };
-        }
-        if (uri === "models://mistral") {
-            const cliInfo = getAvailableCliInfo();
-            return {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(cliInfo.mistral, null, 2),
+                text: JSON.stringify({ ...cliInfo[modelProvider], discovered }, null, 2),
             };
         }
         if (uri.startsWith("models://")) {
@@ -418,7 +274,10 @@ export class ResourceProvider {
             return {
                 uri,
                 mimeType: "application/json",
-                text: JSON.stringify(getProviderToolCapabilities({ providersConfig: this.providers ?? undefined }), null, 2),
+                text: JSON.stringify(getProviderToolCapabilities({
+                    providersConfig: this.providers ?? undefined,
+                    acpConfig: this.acpConfig ?? undefined,
+                }), null, 2),
             };
         }
         const providerToolsResource = parseProviderToolsUri(uri, this.providerCapabilityIds());
@@ -428,9 +287,24 @@ export class ResourceProvider {
                 mimeType: "application/json",
                 text: JSON.stringify(getOneProviderToolCapabilities(providerToolsResource.provider, {
                     providersConfig: this.providers ?? undefined,
+                    acpConfig: this.acpConfig ?? undefined,
                 }), null, 2),
             };
         }
+        const acpProvider = parseProviderAcpResourceUri(uri);
+        if (acpProvider) {
+            const resolved = this.capabilityPeek(acpProvider);
+            const record = buildProviderAcpCapabilityRecord(acpProvider, {
+                discovered: resolved?.set.acpInitialize ?? null,
+                discoveredDegraded: resolved?.degraded ?? false,
+                acpConfig: this.acpConfig,
+            });
+            return {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(record, null, 2),
+            };
+        }
         const subcommandResource = parseProviderSubcommandUri(uri);
         if (subcommandResource) {
             const contract = getCliSubcommandContract(subcommandResource.provider, subcommandResource.commandPath);

package/dist/session-manager.d.ts

@@ -23,6 +23,8 @@ export interface SessionStorage {
     sessions: Record<string, Session>;
     activeSession: Record<ProviderType, string | null>;
 }
+export declare function remoteSafeSession(session: Session): Session;
+export declare function callerIsRemote(): boolean;
 export type SessionCleanupHook = (session: Session) => void | Promise<void>;
 export declare class FileSessionManager {
     private storagePath;