llm-cli-gateway 2.13.2 → 2.14.0

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

@@ -8,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;
@@ -61,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`,
@@ -127,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`,
@@ -237,6 +161,17 @@ 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) {
@@ -271,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://")) {
@@ -420,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());
@@ -430,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.js

@@ -6,6 +6,7 @@ import { DEFAULT_SESSION_TTL_SECONDS } from "./config.js";
 import { noopLogger } from "./logger.js";
 import { getRequestContext, resolveOwnerPrincipal } from "./request-context.js";
 import { API_PROVIDER_TYPES, CLI_TYPES, } from "./provider-types.js";
+import { getAllProviderDefinitions } from "./provider-definitions.js";
 export { API_PROVIDER_TYPES, CLI_TYPES };
 export const PROVIDER_TYPES = [...CLI_TYPES, ...API_PROVIDER_TYPES];
 export function isCliType(provider) {
@@ -15,13 +16,7 @@ export function providerKind(provider) {
     return isCliType(provider) ? "cli" : "api";
 }
 const KNOWN_SESSION_DESCRIPTIONS = {
-    claude: "Claude Session",
-    codex: "Codex Session",
-    gemini: "Gemini Session",
-    grok: "Grok Session",
-    mistral: "Mistral Session",
-    devin: "Devin Session",
-    cursor: "Cursor Session",
+    ...Object.fromEntries(getAllProviderDefinitions().map(def => [def.id, def.sessionLabel])),
     "grok-api": "Grok API Session",
 };
 export function defaultSessionDescription(provider) {
@@ -33,11 +28,23 @@ export function remoteSafeSession(session) {
     if (!metadata)
         return session;
     const next = { ...metadata };
+    const root = typeof next.workspaceRoot === "string" ? next.workspaceRoot : undefined;
+    const reducePath = (absolute) => {
+        const rel = root ? pathRelative(root, absolute) : "";
+        return rel && !rel.startsWith("..") && !pathIsAbsolute(rel) ? rel : pathBasename(absolute);
+    };
     if (typeof next.worktreePath === "string") {
-        const root = typeof next.workspaceRoot === "string" ? next.workspaceRoot : undefined;
-        const rel = root ? pathRelative(root, next.worktreePath) : "";
-        next.worktreePath =
-            rel && !rel.startsWith("..") && !pathIsAbsolute(rel) ? rel : pathBasename(next.worktreePath);
+        next.worktreePath = reducePath(next.worktreePath);
+    }
+    if (next.acp && typeof next.acp === "object" && !Array.isArray(next.acp)) {
+        const acp = { ...next.acp };
+        if (typeof acp.cwd === "string")
+            acp.cwd = reducePath(acp.cwd);
+        if (typeof acp.worktreePath === "string")
+            acp.worktreePath = reducePath(acp.worktreePath);
+        if ("sessionId" in acp)
+            delete acp.sessionId;
+        next.acp = acp;
     }
     if (typeof next.workspaceRoot === "string")
         delete next.workspaceRoot;

package/dist/sqlite-driver.d.ts

@@ -9,7 +9,7 @@ export interface GatewayStatement {
 export interface GatewayDatabase {
     exec(sql: string): void;
     prepare(sql: string): GatewayStatement;
-    withTransaction<A extends unknown[]>(fn: (...args: A) => void): (...args: A) => void;
+    withTransaction<A extends unknown[], R = void>(fn: (...args: A) => R): (...args: A) => R;
     close(): void;
 }
 export declare function openDatabase(dbPath: string): GatewayDatabase;

package/dist/sqlite-driver.js

@@ -115,8 +115,9 @@ class GatewayDatabaseImpl {
             this.db.exec("BEGIN");
             this.inTransaction = true;
             try {
-                fn(...args);
+                const result = fn(...args);
                 this.db.exec("COMMIT");
+                return result;
             }
             catch (error) {
                 try {

package/dist/stream-json-parser.d.ts

@@ -13,5 +13,6 @@ export interface StreamJsonResult {
     durationApiMs: number | null;
     isError: boolean;
     numTurns: number | null;
+    stopReason: string | null;
 }
 export declare function parseStreamJson(stdout: string): StreamJsonResult;

package/dist/stream-json-parser.js

@@ -51,6 +51,7 @@ export function parseStreamJson(stdout) {
             durationApiMs: numberOrNull(resultEvent.duration_api_ms),
             isError: resultEvent.is_error === true,
             numTurns: numberOrNull(resultEvent.num_turns),
+            stopReason: stringOrNull(resultEvent.stop_reason) ?? stringOrNull(assistantEvent?.message?.stop_reason),
         };
     }
     if (assistantEvent) {
@@ -74,6 +75,7 @@ export function parseStreamJson(stdout) {
             durationApiMs: null,
             isError: false,
             numTurns: null,
+            stopReason: stringOrNull(message?.stop_reason),
         };
     }
     return {
@@ -85,5 +87,6 @@ export function parseStreamJson(stdout) {
         durationApiMs: null,
         isError: false,
         numTurns: null,
+        stopReason: null,
     };
 }

package/dist/upstream-contracts.d.ts

@@ -1,4 +1,4 @@
-import type { CliType } from "./session-manager.js";
+import { type CliType } from "./provider-definitions.js";
 export type CliFlagArity = "none" | "one" | "optional" | "variadic";
 export interface CliFlagContract {
     arity: CliFlagArity;
@@ -199,3 +199,19 @@ export declare function buildUpstreamContractReport(options?: {
     cli?: CliType;
     probeInstalled?: boolean;
 }): Record<string, unknown>;
+export interface DiscoveryContractDrift {
+    cli: CliType;
+    version: string;
+    contractTargetVersion: string;
+    versionMatchesContract: boolean;
+    missingContractFlags: string[];
+    newDiscoveredFlags: string[];
+    discoveredUnmappedCount: number;
+    status: "clean" | "drift" | "degraded";
+}
+export declare function computeDiscoveryContractDrift(cli: CliType, discovered: {
+    version: string;
+    discoveredFlagNames: readonly string[];
+    discoveredUnmappedCount: number;
+    status: "ok" | "degraded" | "error";
+}): DiscoveryContractDrift;