codehere 0.8.0 → 1.0.2

package/dist/infrastructure/orchestration/gemini-adapter.js

@@ -1,583 +0,0 @@
-/**
- * Gemini adapter — F2 fifth concrete AgentAdapter (v0.4 sprint Track 1a).
- *
- * Wraps the official Google `gemini` CLI (`@google/gemini-cli`) as a subprocess.
- * Headless mode: `gemini -p "<prompt>" -o stream-json --approval-mode=yolo`.
- *
- * Event schema verified against the installed gemini-cli source
- * (StreamJsonFormatter / JsonStreamEventType in @google/gemini-cli bundle):
- *   init         — { session_id, model, timestamp }
- *   message      — { role: "user"|"assistant", content, delta?: bool }
- *   tool_use     — { tool_name, tool_id, parameters }
- *   tool_result  — tool execution output (best-effort parse — schema sparse)
- *   error        — { error: {...} }
- *   result       — { status: "success"|"error", stats?, error?: { type, message } }
- *
- * Token usage from result.stats: { total_tokens, input_tokens, output_tokens, cached }.
- *
- * Sandbox: Gemini's --approval-mode=yolo enables sandboxing by default. codehere is
- * the external safety layer — its PreToolUse hook (F0) is where destructive-command
- * scanning happens. We DISABLE Gemini's sandbox via GEMINI_SANDBOX=false so file
- * writes / shell commands aren't blocked at the wrong layer. (Note: today's hook
- * still only wraps Claude Code; for Gemini, codehere observes via session events
- * and audits at task-completion. Per-tool blocking parity for non-Claude adapters
- * is v0.4+ work — see project_v04_sprint.md Track 3.)
- *
- * Same structural pattern as ClaudeCodeAdapter / CodexAdapter / AiderAdapter:
- * event buffer, late-joiner replay, SIGTERM→SIGKILL escalation, known-error
- * fingerprints. Finalizes on `close` (not `exit`) so trailing stdout flushes.
- * Kills the process group (negative pid) so subagents under gemini exit too.
- */
-import { spawn, execFile, execFileSync } from 'child_process';
-import { startRecording } from './cassette-recorder.js';
-import { promisify } from 'util';
-const execFileAsync = promisify(execFile);
-import { EventEmitter } from 'events';
-import { randomUUID } from 'crypto';
-import { existsSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { ProgressAggregator } from './progress-aggregator.js';
-import { resolveAgentSpawn } from './mocks/resolve-agent-spawn.js';
-import { applyMemoryPrefix } from './memory-injector.js';
-import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
-import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
-// `--approval-mode=yolo` auto-accepts every tool action without prompting (the
-// older `--yolo` flag is deprecated). codehere's safety hook is the external
-// gate, so gemini-side prompts would block headless tasks.
-//
-// `-o stream-json` — JSONL events, one per line, schema verified above.
-//
-// `--skip-trust` — skip the per-workspace trust prompt that gemini shows on
-// first run in a new directory.
-const HEADLESS_FLAGS = ['--approval-mode', 'yolo', '--skip-trust', '-o', 'stream-json'];
-// Error patterns scoped to STDERR / result.error / error events only — NOT
-// every JSON-serialized event (which would false-positive on tool output).
-const ERROR_PATTERNS = [
-    {
-        code: 'auth_missing',
-        regex: /please set an auth method|GEMINI_API_KEY|GOOGLE_API_KEY|GOOGLE_GENAI_USE_VERTEXAI|GOOGLE_GENAI_USE_GCA|GOOGLE_APPLICATION_CREDENTIALS/i,
-        message: 'Gemini auth missing.',
-        recovery: 'Set GEMINI_API_KEY env var (free tier at https://aistudio.google.com/apikey) — or configure Vertex AI / Application Default Credentials per https://google-gemini.github.io/gemini-cli/docs/get-started/authentication.html',
-    },
-    {
-        code: 'auth_invalid',
-        regex: /authentication\s+failed|401\s*unauth|invalid\s+api\s+key|api\s+key\s+not\s+valid/i,
-        message: 'Gemini API key is rejected.',
-        recovery: 'Verify GEMINI_API_KEY at https://aistudio.google.com/apikey and re-export.',
-    },
-    {
-        code: 'rate_limit',
-        regex: /rate.?limit(ed)?|HTTP\s*429|too many requests/i,
-        message: 'Gemini rate-limited the request.',
-        recovery: 'Wait a minute and retry, or check your Google AI Studio quota.',
-    },
-    {
-        code: 'quota_exceeded',
-        regex: /\bRESOURCE_EXHAUSTED\b|quota[\s_]exceeded|insufficient[_\s]quota/i,
-        message: 'Google AI Studio / Vertex quota exhausted.',
-        recovery: 'Check quota at https://aistudio.google.com/ or top up your Google Cloud billing account.',
-    },
-];
-function scanForKnownError(text) {
-    for (const p of ERROR_PATTERNS) {
-        if (p.regex.test(text))
-            return { code: p.code, message: p.message, recovery: p.recovery };
-    }
-    return null;
-}
-/**
- * Parse the plain-text output of `gemini --list-sessions` and return the
- * 1-based index for a given session UUID, or null if not found.
- *
- * Format (verified against gemini-cli source — packages/cli/src/utils/sessions.ts):
- *   Available sessions for this project (3):
- *
- *     1. Some Title (5 minutes ago) [a1b2c3d4-...]
- *     2. Other Title (1 hour ago, current) [e5f6g7h8-...]
- *     3. Third One (yesterday) [9i0j1k2l-...]
- *
- * Indices are 1-based and stable within one run (sort-by-startTime); the UUID
- * is the durable handle. We exported as a pure function so tests don't need
- * the real gemini binary or a real session store.
- */
-export function parseGeminiSessionIndexForUuid(listOutput, uuid) {
-    if (!uuid)
-        return null;
-    // Match `  N. <title> ... [<uuid>]` — UUID is always the last bracketed
-    // segment on the line. Title can contain anything (including bracketed
-    // text), so we match `[uuid]` at end-of-line, not the first `[...]`.
-    const lineRegex = /^\s*(\d+)\.\s.*\[([0-9a-fA-F-]{8,})\]\s*$/;
-    for (const raw of listOutput.split('\n')) {
-        const line = raw.replace(/\r$/, '');
-        const m = line.match(lineRegex);
-        if (!m)
-            continue;
-        const idx = Number.parseInt(m[1], 10);
-        if (!Number.isFinite(idx) || idx <= 0)
-            continue;
-        if (m[2] === uuid)
-            return idx;
-    }
-    return null;
-}
-export function spawnGemini(prompt, options = {}) {
-    const sessionId = randomUUID();
-    const startedAt = Date.now();
-    const emitter = new EventEmitter();
-    const buffer = [];
-    let statusValue = 'running';
-    let killRequested = false;
-    const cwd = options.cwd ?? process.cwd();
-    // F3 Task 8 — memory injection (same shape as every other adapter).
-    const injected = applyMemoryPrefix(prompt, cwd, options);
-    const finalPrompt = injected.prompt;
-    const snapshot = snapshotCwd(cwd);
-    const aggregator = new ProgressAggregator('gemini');
-    let stepsSnapshot = [];
-    let artifactsSnapshot;
-    let textAccum = '';
-    let usageSnapshot;
-    let errorEmitted = false;
-    const emit = (event) => {
-        buffer.push(event);
-        emitter.emit('event', event);
-        if (aggregator.ingest(event)) {
-            stepsSnapshot = aggregator.steps.map((s) => ({ ...s }));
-            const snapEvt = {
-                type: 'codehere:steps',
-                timestamp: Date.now(),
-                data: { steps: stepsSnapshot },
-            };
-            buffer.push(snapEvt);
-            emitter.emit('event', snapEvt);
-        }
-        // Accumulate assistant text for the test-summary parser. Real schema:
-        // { type: 'message', role: 'assistant', content: '...', delta?: bool }.
-        // Both deltas (streaming chunks) and full messages contribute.
-        if (event.type === 'message') {
-            const data = event.data;
-            if (data?.role === 'assistant' && typeof data.content === 'string') {
-                textAccum += data.content;
-                // Only add a newline at non-delta boundaries to avoid breaking up streamed words
-                if (!event.data?.delta)
-                    textAccum += '\n';
-            }
-        }
-        // tool_result event — schema sparse in source; accept common output fields.
-        if (event.type === 'tool_result') {
-            const data = event.data;
-            const t = data?.output ?? data?.result ?? data?.content;
-            if (typeof t === 'string')
-                textAccum += t + '\n';
-        }
-        // #110 slice 4 — mirror gemini tool calls to the audit log. Same
-        // shape Codex uses (post-hoc, no block). gemini emits tool_use
-        // BEFORE the call lands; mirror at that point so the audit row
-        // appears around when the action happens.
-        if (event.type === 'tool_use') {
-            const data = event.data;
-            const toolName = String(data?.tool_name ?? 'tool');
-            const params = data?.parameters ?? {};
-            const input = (typeof params.command === 'string' && params.command) ||
-                (typeof params.file_path === 'string' && params.file_path) ||
-                (typeof params.path === 'string' && params.path) ||
-                (typeof params.query === 'string' && params.query) ||
-                JSON.stringify(params).slice(0, 500);
-            mirrorToolCallToAudit({
-                sessionId,
-                agent: 'gemini',
-                toolName,
-                toolInput: String(input),
-                cwd,
-            });
-        }
-        // Token usage comes ONLY in the final `result` event with status:'success',
-        // shape { stats: { input_tokens, output_tokens, total_tokens, cached } }.
-        if (event.type === 'result') {
-            const data = event.data;
-            if (data?.status === 'success' && data.stats) {
-                const s = data.stats;
-                usageSnapshot = {
-                    inputTokens: Number(s.input_tokens ?? 0),
-                    outputTokens: Number(s.output_tokens ?? 0),
-                    ...(s.cached ? { cacheReadTokens: Number(s.cached) } : {}),
-                };
-            }
-        }
-        // Scoped error matching: ONLY look at stderr lines and the FAILURE form of
-        // the `result` event (status:"error"). DO NOT scan `error` stream events
-        // because gemini's headless docs explicitly classify them as "Non-fatal
-        // warnings and system errors" — e.g. loop-detection warnings emit `error`
-        // events with severity:"warning". The terminal failure signal is the final
-        // `result` event with status:"error". Treating non-fatal `error` events as
-        // a terminal codehere:error would falsely mark successful sessions as failed.
-        if (!errorEmitted) {
-            let text = '';
-            const data = event.data;
-            if (event.type === 'stderr' && data && typeof data.line === 'string') {
-                text = data.line;
-            }
-            else if (event.type === 'result') {
-                const r = data;
-                if (r?.status === 'error' && r.error) {
-                    text = `${r.error.type ?? ''} ${r.error.message ?? ''}`;
-                }
-            }
-            if (text) {
-                const hit = scanForKnownError(text);
-                if (hit) {
-                    errorEmitted = true;
-                    const errEvent = {
-                        type: 'codehere:error',
-                        timestamp: Date.now(),
-                        data: { code: hit.code, message: hit.message, recovery: hit.recovery },
-                    };
-                    buffer.push(errEvent);
-                    emitter.emit('event', errEvent);
-                }
-            }
-        }
-    };
-    // Disable Gemini's built-in sandbox — codehere is the external safety layer.
-    // GEMINI_SANDBOX=false trumps any sandbox-on default that --approval-mode=yolo
-    // would otherwise enable. (Settings precedence: env > settings.json > default.)
-    const spawnEnv = {
-        ...process.env,
-        GEMINI_SANDBOX: 'false',
-        ...(options.env ?? {}),
-    };
-    let child;
-    try {
-        const sp = resolveAgentSpawn('gemini', 'gemini', ['-p', finalPrompt, ...HEADLESS_FLAGS, ...(options.extraArgs ?? [])], finalPrompt);
-        child = spawn(sp.command, sp.args, {
-            cwd,
-            env: spawnEnv,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            // Detach into its own process group so kill() can reap subagents.
-            detached: true,
-        });
-        // Don't keep the parent alive on this child alone.
-        child.unref();
-    }
-    catch (err) {
-        statusValue = 'error';
-        const msg = err instanceof Error ? err.message : String(err);
-        queueMicrotask(() => emit({ type: 'error', timestamp: Date.now(), data: { message: msg } }));
-        return {
-            sessionId,
-            startedAt,
-            prompt,
-            agent: 'gemini',
-            get status() {
-                return statusValue;
-            },
-            get steps() {
-                return stepsSnapshot;
-            },
-            get artifacts() {
-                return artifactsSnapshot;
-            },
-            subscribe(handler) {
-                for (const e of buffer)
-                    handler(e);
-                emitter.on('event', handler);
-                return () => emitter.off('event', handler);
-            },
-            kill() {
-                /* already not running */
-            },
-        };
-    }
-    let stdoutBuf = '';
-    // Captured from the gemini-cli `init` event so appendMessage can resolve
-    // it to a session-list index (gemini's --resume only takes index or
-    // 'latest', NOT the UUID itself). See parseGeminiSessionIndexForUuid +
-    // the appendMessage block below.
-    let geminiSessionUuid = null;
-    // Organic cassette recording (S2b · capture-first plan) · no-op unless
-    // CODEHERE_RECORD_CASSETTES=1, so zero overhead by default.
-    const recorder = startRecording({ adapter: 'gemini', sessionId, prompt: finalPrompt, cwd });
-    child.stdout?.on('data', (chunk) => {
-        const text = chunk.toString('utf-8');
-        recorder.onStdout(text);
-        stdoutBuf += text;
-        let idx;
-        while ((idx = stdoutBuf.indexOf('\n')) >= 0) {
-            const line = stdoutBuf.slice(0, idx).trim();
-            stdoutBuf = stdoutBuf.slice(idx + 1);
-            if (!line)
-                continue;
-            try {
-                const data = JSON.parse(line);
-                if (data.type === 'init' && typeof data.session_id === 'string') {
-                    geminiSessionUuid = data.session_id;
-                }
-                emit({ type: data.type ?? 'gemini_event', timestamp: Date.now(), data });
-            }
-            catch {
-                emit({ type: 'stdout', timestamp: Date.now(), data: { line } });
-            }
-        }
-    });
-    child.stderr?.on('data', (chunk) => {
-        const text = chunk.toString('utf-8');
-        recorder.onStderr(text);
-        for (const line of text.split('\n')) {
-            if (line.trim())
-                emit({ type: 'stderr', timestamp: Date.now(), data: { line } });
-        }
-    });
-    // Use `close` (after all stdio has drained), not `exit` (which can fire while
-    // unread stdout is still in-flight). Flush any final un-newlined buffered line.
-    child.on('close', (code, signal) => {
-        recorder.onExit(code ?? -1, signal);
-        if (stdoutBuf.trim()) {
-            const line = stdoutBuf.trim();
-            stdoutBuf = '';
-            try {
-                const data = JSON.parse(line);
-                emit({ type: data.type ?? 'gemini_event', timestamp: Date.now(), data });
-            }
-            catch {
-                emit({ type: 'stdout', timestamp: Date.now(), data: { line } });
-            }
-        }
-        statusValue =
-            killRequested || signal !== null ? 'killed' : errorEmitted ? 'error' : code === 0 ? 'completed' : 'error';
-        if (aggregator.finalize(statusValue === 'completed' ? 'completed' : statusValue === 'killed' ? 'killed' : 'error')) {
-            stepsSnapshot = aggregator.steps.map((s) => ({ ...s }));
-            emit({ type: 'codehere:steps', timestamp: Date.now(), data: { steps: stepsSnapshot } });
-        }
-        if (statusValue === 'completed') {
-            try {
-                artifactsSnapshot = { ...extractArtifacts(snapshot, textAccum), usage: usageSnapshot };
-                emit({ type: 'codehere:artifacts', timestamp: Date.now(), data: artifactsSnapshot });
-            }
-            catch {
-                /* best-effort */
-            }
-        }
-        emit({
-            type: 'exit',
-            timestamp: Date.now(),
-            data: { code, signal, status: statusValue, durationMs: Date.now() - startedAt },
-        });
-    });
-    child.on('error', (err) => {
-        statusValue = 'error';
-        emit({ type: 'error', timestamp: Date.now(), data: { message: err.message } });
-    });
-    return {
-        sessionId,
-        startedAt,
-        prompt,
-        agent: 'gemini',
-        memoryInjection: injected.record,
-        get status() {
-            return statusValue;
-        },
-        get steps() {
-            return stepsSnapshot;
-        },
-        get artifacts() {
-            return artifactsSnapshot;
-        },
-        subscribe(handler) {
-            for (const e of buffer)
-                handler(e);
-            emitter.on('event', handler);
-            return () => emitter.off('event', handler);
-        },
-        kill() {
-            if (statusValue !== 'running')
-                return;
-            killRequested = true;
-            // Process-group kill via negative pid is POSIX-only — Node on Windows
-            // throws ESRCH for that. Fall back to direct child.kill on Windows.
-            const isPosix = process.platform !== 'win32';
-            const sendSignal = (sig) => {
-                if (isPosix && child.pid) {
-                    try {
-                        process.kill(-child.pid, sig);
-                        return;
-                    }
-                    catch {
-                        /* fall through to child.kill */
-                    }
-                }
-                try {
-                    child.kill(sig);
-                }
-                catch {
-                    /* already dead */
-                }
-            };
-            sendSignal('SIGTERM');
-            setTimeout(() => {
-                if (statusValue === 'running')
-                    sendSignal('SIGKILL');
-            }, 3000);
-        },
-        canAppendMessage: true,
-        /**
-         * v0.6.x — UUID→index resolution (replaces the prior --resume latest
-         * shortcut). Gemini's --resume flag accepts a numeric INDEX (per-cwd
-         * ordinal of past sessions) or the literal 'latest' — NOT the session_id
-         * UUID that the init JSONL event emits.
-         *
-         * Strategy: capture session_id on spawn (see geminiSessionUuid above) →
-         * here, run `gemini --list-sessions` (plain text, no --json flag), parse
-         * each line for `[uuid]` at end of line, find the index that matches our
-         * captured UUID, and use it in --resume <N>. If anything fails (binary
-         * missing, list times out, UUID not found), fall back to --resume latest
-         * — same posture as before for safety, but with a chance to nail the
-         * exact session in the common case.
-         *
-         * Concurrency win: if a sibling session is spawned in the same cwd between
-         * spawn and reply, we no longer route the reply to the wrong one.
-         */
-        async appendMessage(text) {
-            const startedAt = Date.now();
-            // Resolve UUID→index ASYNCHRONOUSLY before spawning the followup. Must
-            // be async (not execFileSync) because this runs in the daemon's HTTP
-            // request path; a sync call would block the event loop and freeze every
-            // other in-flight session for up to the timeout.
-            let resumeArg = 'latest';
-            if (geminiSessionUuid) {
-                try {
-                    // gemini-cli's --list-sessions runs an internal generateSummary()
-                    // first, which itself has a 5000ms LLM-call abort timeout (see
-                    // sessionSummaryService.ts DEFAULT_TIMEOUT_MS in upstream). Our
-                    // wrapper timeout MUST be comfortably greater than that or we kill
-                    // the child mid-summary, get empty stdout, and silently fall back
-                    // to --resume latest — which would defeat the whole UUID→index fix.
-                    // 15s = 5s upstream LLM cap + parse/flush/spawn overhead + slack.
-                    // Override via CODEHERE_GEMINI_LIST_TIMEOUT_MS for slow boxes.
-                    const timeoutMs = Number(process.env.CODEHERE_GEMINI_LIST_TIMEOUT_MS) || 15000;
-                    const { stdout: listOut } = await execFileAsync('gemini', ['--list-sessions'], {
-                        cwd,
-                        env: spawnEnv,
-                        encoding: 'utf-8',
-                        timeout: timeoutMs,
-                    });
-                    const idx = parseGeminiSessionIndexForUuid(listOut, geminiSessionUuid);
-                    if (idx !== null)
-                        resumeArg = String(idx);
-                }
-                catch {
-                    // Binary missing, slow auth, no sessions yet — fall through to latest.
-                }
-            }
-            return new Promise((resolve, reject) => {
-                let stdout = '';
-                let stderr = '';
-                const followup = spawn('gemini', ['-p', text, '--resume', resumeArg, ...HEADLESS_FLAGS], {
-                    cwd,
-                    env: spawnEnv,
-                    stdio: ['ignore', 'pipe', 'pipe'],
-                });
-                followup.on('error', (err) => reject(err));
-                followup.stdout?.on('data', (chunk) => {
-                    stdout += chunk.toString('utf-8');
-                });
-                followup.stderr?.on('data', (chunk) => {
-                    stderr += chunk.toString('utf-8');
-                });
-                followup.on('exit', (code) => {
-                    if (code !== 0) {
-                        reject(new Error(`gemini --resume ${resumeArg} exited ${code}: ${stderr.slice(0, 300)}`));
-                        return;
-                    }
-                    // Parse stream-json — extract assistant message text from 'message'
-                    // events with role='assistant'. Same source codex/claude-code use.
-                    const fragments = [];
-                    for (const line of stdout.split('\n')) {
-                        const trimmed = line.trim();
-                        if (!trimmed)
-                            continue;
-                        try {
-                            const obj = JSON.parse(trimmed);
-                            if (obj.type === 'message' && obj.role === 'assistant' && typeof obj.content === 'string') {
-                                fragments.push(obj.content);
-                            }
-                        }
-                        catch {
-                            /* non-JSON — skip */
-                        }
-                    }
-                    const result = fragments.join('\n').trim() || '(gemini returned no assistant message)';
-                    resolve({ result, durationMs: Date.now() - startedAt });
-                });
-            });
-        },
-    };
-}
-export const GeminiAdapter = {
-    id: 'gemini',
-    label: 'Gemini',
-    description: "Google's coding agent. Has a free tier and can read very large amounts of code or docs at once. Useful when the paid agents are out of credits.",
-    // Match `gemini`, `node /path/.../gemini`, and `./gemini` invocations.
-    processPattern: /(?:^|\/)gemini(?:\s|$)|node\s+\S*gemini/,
-    isInstalled() {
-        try {
-            const out = execFileSync('which', ['gemini'], { encoding: 'utf-8', timeout: 2000 });
-            return out.trim().length > 0;
-        }
-        catch {
-            return false;
-        }
-    },
-    spawn(prompt, options) {
-        return spawnGemini(prompt, options);
-    },
-    checkReadiness() {
-        const installed = this.isInstalled();
-        if (!installed) {
-            return {
-                id: this.id,
-                label: this.label,
-                state: 'needs_install',
-                installed: false,
-                installHint: {
-                    command: 'npm install -g @google/gemini-cli',
-                    url: 'https://github.com/google-gemini/gemini-cli',
-                },
-            };
-        }
-        // Gemini supports several auth paths:
-        //   env: GEMINI_API_KEY (free tier), GOOGLE_API_KEY, GOOGLE_GENAI_USE_VERTEXAI,
-        //        GOOGLE_GENAI_USE_GCA, GOOGLE_APPLICATION_CREDENTIALS
-        //   file: ~/.gemini/settings.json (the file gemini's own error msg points at)
-        //   file: ~/.gemini/oauth_creds.json (cached Google login)
-        //
-        // Pre-May-1 we returned 'ready' on install alone, deferring to runtime to
-        // catch missing-auth via ERROR_PATTERNS.auth_missing. That was dishonest:
-        // /api/readiness/agents would say 'ready' → user would spawn → 41s later
-        // the task errored with no clear next step. Surfaced May 1 2026 by the
-        // multi-agent dogfood test (see SECURITY_AUDIT_2026-05-01.md spirit —
-        // honest readiness signals are a UX security property).
-        const hasEnvAuth = !!process.env.GEMINI_API_KEY ||
-            !!process.env.GOOGLE_API_KEY ||
-            !!process.env.GOOGLE_GENAI_USE_VERTEXAI ||
-            !!process.env.GOOGLE_GENAI_USE_GCA ||
-            !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
-        const hasFileAuth = existsSync(join(homedir(), '.gemini', 'settings.json')) ||
-            existsSync(join(homedir(), '.gemini', 'oauth_creds.json'));
-        if (!hasEnvAuth && !hasFileAuth) {
-            return {
-                id: this.id,
-                label: this.label,
-                state: 'needs_auth',
-                installed: true,
-                authHint: {
-                    command: 'export GEMINI_API_KEY=...  # free tier: https://aistudio.google.com/apikey',
-                    url: 'https://google-gemini.github.io/gemini-cli/docs/get-started/authentication.html',
-                    detail: 'Gemini found on PATH but no auth detected (no GEMINI_API_KEY env var, no ~/.gemini/settings.json, no ~/.gemini/oauth_creds.json). Free tier available at aistudio.google.com/apikey.',
-                },
-            };
-        }
-        return { id: this.id, label: this.label, state: 'ready', installed: true };
-    },
-};
-//# sourceMappingURL=gemini-adapter.js.map