llm-cli-gateway 1.4.0 → 1.5.13

package/dist/job-store.d.ts

@@ -1,4 +1,5 @@
 import type { Logger } from "./logger.js";
+import type { PersistenceConfig } from "./config.js";
 export type JobStoreStatus = "running" | "completed" | "failed" | "canceled" | "orphaned";
 export interface JobRecord {
     id: string;
@@ -22,7 +23,43 @@ export declare function resolveJobStoreDbPath(): string | null;
 export declare function resolveJobRetentionMs(): number;
 export declare function resolveDedupWindowMs(): number;
 export declare function computeRequestKey(cli: string, args: string[], extra?: string): string;
-export declare class JobStore {
+/**
+ * Public surface every backend (sqlite/postgres/memory) must implement. The
+ * AsyncJobManager talks to this interface only.
+ */
+export interface JobStore {
+    recordStart(input: {
+        id: string;
+        correlationId: string;
+        requestKey: string;
+        cli: string;
+        args: string[];
+        outputFormat?: string;
+        startedAt: string;
+        pid: number | null;
+    }): void;
+    recordOutput(id: string, stdout: string, stderr: string, outputTruncated: boolean): void;
+    recordComplete(input: {
+        id: string;
+        status: Exclude<JobStoreStatus, "running">;
+        exitCode: number | null;
+        stdout: string;
+        stderr: string;
+        outputTruncated: boolean;
+        error: string | null;
+        finishedAt: string;
+    }): void;
+    getById(id: string): JobRecord | null;
+    findByRequestKey(requestKey: string): JobRecord | null;
+    markOrphanedOnStartup(): number;
+    evictExpired(): number;
+    close(): void;
+}
+/**
+ * SQLite-backed job store. Default backend for production. Durable across
+ * gateway restarts; safe for single-instance deployments.
+ */
+export declare class SqliteJobStore implements JobStore {
     private logger;
     private db;
     private retentionMs;
@@ -34,7 +71,10 @@ export declare class JobStore {
     private findByRequestKeyStmt;
     private markOrphanedStmt;
     private deleteExpiredStmt;
-    constructor(dbPath: string, logger?: Logger);
+    constructor(dbPath: string, logger?: Logger, options?: {
+        retentionMs?: number;
+        dedupWindowMs?: number;
+    });
     /**
      * Insert a new running job row. Caller has already computed requestKey.
      */
@@ -82,3 +122,79 @@ export declare class JobStore {
     evictExpired(): number;
     close(): void;
 }
+/**
+ * Backwards-compatibility alias. Older code and tests construct `new JobStore(path)`
+ * directly; that surface now resolves to the SQLite implementation. Prefer
+ * `createJobStore(config)` in new code.
+ *
+ * @deprecated Use `SqliteJobStore` directly, or `createJobStore(persistenceConfig)`.
+ */
+export declare const JobStoreClass: typeof SqliteJobStore;
+/**
+ * In-process job store. Same semantics as SqliteJobStore but state lives in a
+ * Map and is lost on process exit. Use for tests and ephemeral/CI gateways
+ * that have explicitly acknowledged the trade-off via
+ * `[persistence].acknowledgeEphemeral = true`.
+ */
+export declare class MemoryJobStore implements JobStore {
+    private rows;
+    private retentionMs;
+    private dedupWindowMs;
+    constructor(options?: {
+        retentionMs?: number;
+        dedupWindowMs?: number;
+    });
+    recordStart(input: {
+        id: string;
+        correlationId: string;
+        requestKey: string;
+        cli: string;
+        args: string[];
+        outputFormat?: string;
+        startedAt: string;
+        pid: number | null;
+    }): void;
+    recordOutput(id: string, stdout: string, stderr: string, outputTruncated: boolean): void;
+    recordComplete(input: {
+        id: string;
+        status: Exclude<JobStoreStatus, "running">;
+        exitCode: number | null;
+        stdout: string;
+        stderr: string;
+        outputTruncated: boolean;
+        error: string | null;
+        finishedAt: string;
+    }): void;
+    getById(id: string): JobRecord | null;
+    findByRequestKey(requestKey: string): JobRecord | null;
+    /**
+     * In-memory stores have no cross-process state, so any "running" rows here
+     * came from this very process and aren't actually orphaned. No-op.
+     */
+    markOrphanedOnStartup(): number;
+    evictExpired(): number;
+    close(): void;
+}
+/**
+ * Stub for the planned Postgres backend. The interface and config surface ship
+ * now so multi-instance deployments can plan around them, but the
+ * implementation is intentionally not yet provided — calling code must select
+ * `sqlite` or `memory` until a real impl lands.
+ */
+export declare class PostgresJobStore implements JobStore {
+    constructor(_dsn: string, _logger?: Logger);
+    recordStart(): void;
+    recordOutput(): void;
+    recordComplete(): void;
+    getById(): JobRecord | null;
+    findByRequestKey(): JobRecord | null;
+    markOrphanedOnStartup(): number;
+    evictExpired(): number;
+    close(): void;
+}
+/**
+ * Construct the JobStore appropriate to the resolved PersistenceConfig.
+ * Returns `null` when `backend = "none"` — callers must not register
+ * `*_request_async` tools in that case (use `config.asyncJobsEnabled`).
+ */
+export declare function createJobStore(config: PersistenceConfig, logger?: Logger): JobStore | null;

package/dist/job-store.js

@@ -59,7 +59,11 @@ function rowToRecord(row) {
         expiresAt: row.expires_at,
     };
 }
-export class JobStore {
+/**
+ * SQLite-backed job store. Default backend for production. Durable across
+ * gateway restarts; safe for single-instance deployments.
+ */
+export class SqliteJobStore {
     logger;
     db;
     retentionMs;
@@ -71,7 +75,7 @@ export class JobStore {
     findByRequestKeyStmt;
     markOrphanedStmt;
     deleteExpiredStmt;
-    constructor(dbPath, logger = noopLogger) {
+    constructor(dbPath, logger = noopLogger, options = {}) {
         this.logger = logger;
         const require = createRequire(import.meta.url);
         const BetterSqlite3 = require("better-sqlite3");
@@ -114,8 +118,8 @@ export class JobStore {
                 // Best effort permissions hardening.
             }
         }
-        this.retentionMs = resolveJobRetentionMs();
-        this.dedupWindowMs = resolveDedupWindowMs();
+        this.retentionMs = options.retentionMs ?? resolveJobRetentionMs();
+        this.dedupWindowMs = options.dedupWindowMs ?? resolveDedupWindowMs();
         this.insertStmt = this.db.prepare(`
       INSERT INTO jobs (id, correlation_id, request_key, cli, args_json, output_format,
                         status, exit_code, stdout, stderr, output_truncated, error,
@@ -245,7 +249,174 @@ export class JobStore {
             this.db.close();
         }
         catch (err) {
-            this.logger.error("JobStore close failed", err);
+            this.logger.error("SqliteJobStore close failed", err);
         }
     }
 }
+/**
+ * Backwards-compatibility alias. Older code and tests construct `new JobStore(path)`
+ * directly; that surface now resolves to the SQLite implementation. Prefer
+ * `createJobStore(config)` in new code.
+ *
+ * @deprecated Use `SqliteJobStore` directly, or `createJobStore(persistenceConfig)`.
+ */
+export const JobStoreClass = SqliteJobStore;
+/**
+ * In-process job store. Same semantics as SqliteJobStore but state lives in a
+ * Map and is lost on process exit. Use for tests and ephemeral/CI gateways
+ * that have explicitly acknowledged the trade-off via
+ * `[persistence].acknowledgeEphemeral = true`.
+ */
+export class MemoryJobStore {
+    rows = new Map();
+    retentionMs;
+    dedupWindowMs;
+    constructor(options = {}) {
+        this.retentionMs = options.retentionMs ?? resolveJobRetentionMs();
+        this.dedupWindowMs = options.dedupWindowMs ?? resolveDedupWindowMs();
+    }
+    recordStart(input) {
+        this.rows.set(input.id, {
+            id: input.id,
+            correlationId: input.correlationId,
+            requestKey: input.requestKey,
+            cli: input.cli,
+            argsJson: JSON.stringify(input.args),
+            outputFormat: input.outputFormat ?? null,
+            status: "running",
+            exitCode: null,
+            stdout: "",
+            stderr: "",
+            outputTruncated: false,
+            error: null,
+            startedAt: input.startedAt,
+            finishedAt: null,
+            pid: input.pid,
+            expiresAt: FAR_FUTURE_ISO,
+        });
+    }
+    recordOutput(id, stdout, stderr, outputTruncated) {
+        const row = this.rows.get(id);
+        if (!row)
+            return;
+        row.stdout = stdout;
+        row.stderr = stderr;
+        row.outputTruncated = outputTruncated;
+    }
+    recordComplete(input) {
+        const row = this.rows.get(input.id);
+        if (!row)
+            return;
+        row.status = input.status;
+        row.exitCode = input.exitCode;
+        row.stdout = input.stdout;
+        row.stderr = input.stderr;
+        row.outputTruncated = input.outputTruncated;
+        row.error = input.error;
+        row.finishedAt = input.finishedAt;
+        row.expiresAt = new Date(Date.parse(input.finishedAt) + this.retentionMs).toISOString();
+    }
+    getById(id) {
+        const row = this.rows.get(id);
+        return row ? { ...row } : null;
+    }
+    findByRequestKey(requestKey) {
+        const cutoffMs = Date.now() - this.dedupWindowMs;
+        let best = null;
+        for (const row of this.rows.values()) {
+            if (row.requestKey !== requestKey)
+                continue;
+            if (row.status !== "running" && row.status !== "completed")
+                continue;
+            if (Date.parse(row.startedAt) < cutoffMs)
+                continue;
+            if (!best || Date.parse(row.startedAt) > Date.parse(best.startedAt)) {
+                best = row;
+            }
+        }
+        return best ? { ...best } : null;
+    }
+    /**
+     * In-memory stores have no cross-process state, so any "running" rows here
+     * came from this very process and aren't actually orphaned. No-op.
+     */
+    markOrphanedOnStartup() {
+        return 0;
+    }
+    evictExpired() {
+        const nowIso = new Date().toISOString();
+        let removed = 0;
+        for (const [id, row] of this.rows) {
+            if (row.expiresAt < nowIso) {
+                this.rows.delete(id);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    close() {
+        this.rows.clear();
+    }
+}
+/**
+ * Stub for the planned Postgres backend. The interface and config surface ship
+ * now so multi-instance deployments can plan around them, but the
+ * implementation is intentionally not yet provided — calling code must select
+ * `sqlite` or `memory` until a real impl lands.
+ */
+export class PostgresJobStore {
+    constructor(_dsn, _logger = noopLogger) {
+        throw new Error("PostgresJobStore is not yet implemented. Use backend = 'sqlite' (single-instance) or " +
+            "backend = 'memory' (ephemeral) until the Postgres backend ships.");
+    }
+    recordStart() {
+        throw new Error("not implemented");
+    }
+    recordOutput() {
+        throw new Error("not implemented");
+    }
+    recordComplete() {
+        throw new Error("not implemented");
+    }
+    getById() {
+        throw new Error("not implemented");
+    }
+    findByRequestKey() {
+        throw new Error("not implemented");
+    }
+    markOrphanedOnStartup() {
+        throw new Error("not implemented");
+    }
+    evictExpired() {
+        throw new Error("not implemented");
+    }
+    close() {
+        /* no-op */
+    }
+}
+/**
+ * Construct the JobStore appropriate to the resolved PersistenceConfig.
+ * Returns `null` when `backend = "none"` — callers must not register
+ * `*_request_async` tools in that case (use `config.asyncJobsEnabled`).
+ */
+export function createJobStore(config, logger = noopLogger) {
+    const opts = {
+        retentionMs: config.retentionDays * 24 * 60 * 60 * 1000,
+        dedupWindowMs: config.dedupWindowMs,
+    };
+    switch (config.backend) {
+        case "none":
+            return null;
+        case "memory":
+            return new MemoryJobStore(opts);
+        case "postgres":
+            // Throws today; design surface is honest so callers can react.
+            return new PostgresJobStore(config.dsn ?? "", logger);
+        case "sqlite":
+        default:
+            if (!config.path) {
+                throw new Error("SqliteJobStore requires a non-empty path");
+            }
+            return new SqliteJobStore(config.path, logger, opts);
+    }
+}

package/dist/logger.d.ts

@@ -2,5 +2,14 @@ export interface Logger {
     info(message: string, meta?: unknown): void;
     error(message: string, meta?: unknown): void;
     debug(message: string, meta?: unknown): void;
+    /** Optional: callers that want explicit WARN routing can implement this. */
+    warn?(message: string, meta?: unknown): void;
 }
 export declare const noopLogger: Logger;
+/**
+ * Emit a warning through whichever logger surface is available. Some Logger
+ * implementations (legacy) only provide `info`/`error`/`debug`; in that case
+ * the message is prefixed with `[WARN]` and routed through `info` so it still
+ * reaches stderr.
+ */
+export declare function logWarn(logger: Logger, message: string, meta?: unknown): void;

package/dist/logger.js

@@ -2,4 +2,18 @@ export const noopLogger = {
     info: () => { },
     error: () => { },
     debug: () => { },
+    warn: () => { },
 };
+/**
+ * Emit a warning through whichever logger surface is available. Some Logger
+ * implementations (legacy) only provide `info`/`error`/`debug`; in that case
+ * the message is prefixed with `[WARN]` and routed through `info` so it still
+ * reaches stderr.
+ */
+export function logWarn(logger, message, meta) {
+    if (typeof logger.warn === "function") {
+        logger.warn(message, meta);
+        return;
+    }
+    logger.info(`[WARN] ${message}`, meta);
+}

package/dist/model-registry.js

@@ -14,17 +14,19 @@ const FALLBACK_INFO = {
         modelOrder: ["opus", "sonnet", "haiku"],
     },
     codex: {
-        // Note: no hardcoded `defaultModel`. Let Codex CLI pick its own built-in default
-        // unless an explicit value is found via config.toml / env vars in applyCodexOverrides.
-        // This prevents the gateway from pinning a model that may become deprecated upstream.
+        // U26: gpt-5.5 is the bundled fallback default. Config/env overrides still
+        // win (applyCodexOverrides runs after). Older aliases are retained in the
+        // models map so callers that still pass `gpt-5.3-codex` resolve cleanly.
         description: "OpenAI's Codex CLI - best for code execution in sandboxed environments",
         models: {
-            "gpt-5.4": "Frontier coding and professional-work model. Best for: most Codex tasks, long-running agentic work",
-            "gpt-5.3-codex": "Specialized Codex model. Best for: agentic coding workflows with Codex-tuned behavior",
+            "gpt-5.5": "Latest Codex frontier model. Best for: most Codex tasks (default since U26)",
+            "gpt-5.4": "Frontier coding and professional-work model. Best for: long-running agentic work",
+            "gpt-5.3-codex": "Legacy specialized Codex model (kept for backwards-compat). Best for: agentic coding workflows with Codex-tuned behavior",
             "gpt-5.2": "Strong general-purpose GPT-5 model. Best for: broad coding and reasoning tasks",
             "gpt-5-pro": "Highest-capability GPT-5 model. Best for: deep reasoning and difficult professional workflows",
         },
-        modelOrder: ["gpt-5.3-codex", "gpt-5.4", "gpt-5.2", "gpt-5-pro"],
+        defaultModel: "gpt-5.5",
+        modelOrder: ["gpt-5.5", "gpt-5.4", "gpt-5.3-codex", "gpt-5.2", "gpt-5-pro"],
     },
     gemini: {
         description: "Google's Gemini CLI - best for multimodal tasks and Google ecosystem integration",
@@ -42,6 +44,20 @@ const FALLBACK_INFO = {
         },
         modelOrder: ["grok-build"],
     },
+    mistral: {
+        // Mistral Vibe selects the active model via the VIBE_ACTIVE_MODEL environment
+        // variable; there is NO `--model` flag. Aliases here are still resolvable so
+        // callers can pass e.g. `latest` → `devstral-medium`; the resolved value is
+        // injected via env in prepareMistralRequest.
+        description: "Mistral AI's Vibe CLI - agentic coding via Mistral models (model selection via VIBE_ACTIVE_MODEL env var)",
+        models: {
+            "devstral-medium": "Default Vibe coding model. Best for: most Vibe sessions (default when VIBE_ACTIVE_MODEL is unset)",
+            "devstral-large": "Higher-capability Devstral model. Best for: harder reasoning/coding tasks",
+            "mistral-large-latest": "General-purpose flagship Mistral model. Best for: non-Devstral reasoning workloads",
+        },
+        defaultModel: "devstral-medium",
+        modelOrder: ["devstral-medium", "devstral-large", "mistral-large-latest"],
+    },
 };
 const MODEL_CACHE_TTL_MS = 2 * 60 * 1000;
 const MAX_GEMINI_HISTORY_FILES = 200;
@@ -98,11 +114,13 @@ function buildCliInfo() {
         codex: cloneInfo(FALLBACK_INFO.codex),
         gemini: cloneInfo(FALLBACK_INFO.gemini),
         grok: cloneInfo(FALLBACK_INFO.grok),
+        mistral: cloneInfo(FALLBACK_INFO.mistral),
     };
     applyClaudeOverrides(info.claude);
     applyCodexOverrides(info.codex);
     applyGeminiOverrides(info.gemini);
     applyGrokOverrides(info.grok);
+    applyMistralOverrides(info.mistral);
     return info;
 }
 function cloneInfo(source) {
@@ -322,6 +340,22 @@ function applyGrokOverrides(info) {
     }
     info.modelOrder = buildOrder(info, info.defaultModel);
 }
+function applyMistralOverrides(info) {
+    // Vibe selects its active model via VIBE_ACTIVE_MODEL (no --model flag). When
+    // present, treat it as the configured default so resolveModelAlias("latest")
+    // returns the user-selected value.
+    const envDefault = process.env.MISTRAL_DEFAULT_MODEL || process.env.VIBE_ACTIVE_MODEL;
+    addEnvModels(info, "MISTRAL_MODELS");
+    addEnvAliases(info, "mistral", "MISTRAL_MODEL_ALIASES");
+    addGlobalEnvAliases(info, "mistral");
+    if (envDefault) {
+        const source = process.env.MISTRAL_DEFAULT_MODEL
+            ? "MISTRAL_DEFAULT_MODEL"
+            : "VIBE_ACTIVE_MODEL";
+        setDefaultModel(info, envDefault, source, "env");
+    }
+    info.modelOrder = buildOrder(info, info.defaultModel);
+}
 function readJsonStringValue(filePath, paths, info) {
     if (!existsSync(filePath)) {
         return undefined;

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

@@ -0,0 +1,21 @@
+import type { CliType } from "./session-manager.js";
+export interface ProviderLoginGuidance {
+    provider: CliType;
+    displayName: string;
+    install: {
+        summary: string;
+        commands: string[];
+        documentationUrl?: string;
+    };
+    login: {
+        summary: string;
+        commands: string[];
+        credentialHandling: string;
+    };
+    verification: {
+        command: string;
+        expected: string;
+    };
+}
+export declare function getProviderLoginGuidance(provider: CliType): ProviderLoginGuidance;
+export declare function getAllProviderLoginGuidance(): Record<CliType, ProviderLoginGuidance>;

package/dist/provider-login-guidance.js

@@ -0,0 +1,98 @@
+const GUIDANCE = {
+    claude: {
+        provider: "claude",
+        displayName: "Claude Code",
+        install: {
+            summary: "Install Claude Code using Anthropic's current official installer.",
+            commands: ["npm install -g @anthropic-ai/claude-code"],
+            documentationUrl: "https://docs.anthropic.com/claude-code",
+        },
+        login: {
+            summary: "Sign in through Claude Code's official browser/device flow.",
+            commands: ["claude auth login"],
+            credentialHandling: "Do not paste Claude passwords, OAuth tokens, or credential files into the gateway or a remote chat.",
+        },
+        verification: {
+            command: "claude auth status --json",
+            expected: "loggedIn is true",
+        },
+    },
+    codex: {
+        provider: "codex",
+        displayName: "Codex CLI",
+        install: {
+            summary: "Install Codex CLI using OpenAI's npm package or the current official installer.",
+            commands: ["npm install -g @openai/codex"],
+            documentationUrl: "https://developers.openai.com/codex",
+        },
+        login: {
+            summary: "Sign in through Codex's official login flow.",
+            commands: ["codex login", "codex login --device-auth"],
+            credentialHandling: "Prefer browser or device-code login. Do not paste API keys or access tokens into assistant prompts.",
+        },
+        verification: {
+            command: "codex login status",
+            expected: "command reports that Codex is logged in",
+        },
+    },
+    gemini: {
+        provider: "gemini",
+        displayName: "Gemini CLI",
+        install: {
+            summary: "Install Gemini CLI using Google's npm package or current official installer.",
+            commands: ["npm install -g @google/gemini-cli"],
+            documentationUrl: "https://github.com/google-gemini/gemini-cli",
+        },
+        login: {
+            summary: "Run Gemini CLI and complete Google's official sign-in flow when prompted.",
+            commands: ["gemini"],
+            credentialHandling: "Let Gemini CLI store credentials in its own local store. Do not paste OAuth files or API keys into chat.",
+        },
+        verification: {
+            command: "gemini --version",
+            expected: "CLI is installed; doctor checks the local Gemini credential store for login evidence",
+        },
+    },
+    grok: {
+        provider: "grok",
+        displayName: "Grok CLI",
+        install: {
+            summary: "Install Grok CLI using xAI's current official installer or managed update flow.",
+            commands: ["npm install -g grok-build"],
+            documentationUrl: "https://docs.x.ai/build/cli",
+        },
+        login: {
+            summary: "Sign in through Grok's official OAuth or device-code flow.",
+            commands: ["grok login --oauth", "grok login --device-auth"],
+            credentialHandling: "Do not paste xAI API keys, OAuth tokens, or Grok auth files into the gateway or a remote chat.",
+        },
+        verification: {
+            command: "grok inspect --json",
+            expected: "CLI can inspect local configuration and a local auth store is present",
+        },
+    },
+    mistral: {
+        provider: "mistral",
+        displayName: "Mistral Vibe CLI",
+        install: {
+            summary: "Install Mistral Vibe CLI via pip, uv, or Homebrew (Vibe does not self-update; cli_upgrade dispatches to the installer it detects).",
+            commands: ["pip install vibe-cli", "uv tool install vibe-cli", "brew install mistral-vibe"],
+            documentationUrl: "https://docs.mistral.ai/agents/vibe-cli",
+        },
+        login: {
+            summary: "Sign in through Mistral's official auth flow and enable session_logging in ~/.vibe/config.toml.",
+            commands: ["vibe auth login", "vibe config set session_logging.enabled true"],
+            credentialHandling: "Do not paste Mistral API keys, OAuth tokens, or ~/.vibe/credentials into the gateway or a remote chat.",
+        },
+        verification: {
+            command: "vibe --version",
+            expected: "Vibe CLI is installed; doctor additionally checks ~/.vibe/config.toml for session_logging.enabled=true",
+        },
+    },
+};
+export function getProviderLoginGuidance(provider) {
+    return GUIDANCE[provider];
+}
+export function getAllProviderLoginGuidance() {
+    return { ...GUIDANCE };
+}

package/dist/provider-status.d.ts

@@ -0,0 +1,41 @@
+import type { CliType } from "./session-manager.js";
+import { type ProviderLoginGuidance } from "./provider-login-guidance.js";
+export type ProviderLoginStatus = "authenticated" | "not_authenticated" | "unknown" | "not_checked";
+export interface ProviderRuntimeStatus {
+    provider: CliType;
+    displayName: string;
+    command: string;
+    installed: boolean;
+    version: string | null;
+    versionCommand: string[];
+    loginStatus: ProviderLoginStatus;
+    loginCheck: {
+        method: "cli" | "credential_store" | "not_checked";
+        command: string[] | null;
+        credentialStore: "present" | "not_found" | "not_checked";
+        detail: string;
+    };
+    guidance: ProviderLoginGuidance;
+}
+export declare const PROVIDER_COMMANDS: Record<CliType, string>;
+export declare function listProviderRuntimeStatuses(): Record<CliType, ProviderRuntimeStatus>;
+export declare function getProviderRuntimeStatus(provider: CliType): ProviderRuntimeStatus;
+export interface GeminiAuthMethods {
+    oauth: boolean;
+    geminiApiKey: boolean;
+    googleApiKey: boolean;
+    vertexAi: boolean;
+}
+export interface GeminiAuthStatus {
+    status: "present" | "not_found";
+    methods: GeminiAuthMethods;
+}
+/**
+ * U27: Detect Gemini auth across all supported methods.
+ * Returns "present" if ANY of:
+ *   - OAuth credential file present (~/.gemini/oauth_creds.json, etc.)
+ *   - GEMINI_API_KEY env var set and non-empty
+ *   - GOOGLE_API_KEY env var set and non-empty
+ *   - GOOGLE_CLOUD_PROJECT set AND GOOGLE_GENAI_USE_VERTEXAI=true
+ */
+export declare function geminiAuthStatus(env?: NodeJS.ProcessEnv, home?: string): GeminiAuthStatus;