@phnx-labs/agents-cli 1.22.119 → 1.22.121

package/dist/lib/pr-land-detach.js

@@ -1,30 +1,11 @@
-/**
- * Headless-exit warning for an open PR left behind by a run (RUSH-2394).
- *
- * A headless agent that backgrounds `gh pr checks --watch` and exits strands its
- * own PR: that watcher is a child of the agent's process tree, so it dies with
- * the agent and nothing merges on green. This module is the fail-loud half of
- * that story — it probes the run's branch for an OPEN PR on exit and says so.
- *
- * The `agents pr land --detach` lander this warning used to point at was removed
- * with the `agents pr` command group (RUSH-2472): merge-on-green is a monitor
- * (`agents monitors`), not a bespoke command with its own scheduler. The
- * reusable CI/review polling it will run on lives in lib/teams/pr-watch.ts, so
- * this module keeps only the exit-path warning and names no specific command.
- */
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 const execFileAsyncDefault = promisify(execFile);
-/**
- * Pure classifier: should the exit path warn about this open PR?
- * Warn when the PR exists and is still OPEN.
- */
 export function shouldWarnOrphanedOpenPr(pr) {
     if (!pr)
         return false;
     return pr.state.toUpperCase() === 'OPEN';
 }
-/** Human-readable warning for an open PR the exiting run left unattended. */
 export function formatOrphanedOpenPrWarning(pr) {
     const lines = [
         '',
@@ -39,17 +20,11 @@ export function formatOrphanedOpenPrWarning(pr) {
     ];
     return lines.join('\n');
 }
-/** Tiny chalk-free red for environments where chalk is not wanted on the exit path. */
 function chalkRed(s) {
-    // Match warn-unpushed: bold red when stderr is a TTY; plain otherwise.
     if (process.stderr.isTTY)
         return `\u001b[1m\u001b[31m${s}\u001b[0m`;
     return s;
 }
-/**
- * Probe `cwd` for an open PR on the current branch via `gh pr view`.
- * Fail-open: any error / missing gh → null (never block the run's exit).
- */
 export async function getBranchOpenPr(cwd, execFileAsync) {
     try {
         const { stdout } = await execFileAsync('gh', ['pr', 'view', '--json', 'number,url,state'], { cwd, timeout: 5000, maxBuffer: 512 * 1024 });
@@ -62,10 +37,6 @@ export async function getBranchOpenPr(cwd, execFileAsync) {
         return null;
     }
 }
-/**
- * Headless-exit fail-loud: if the cwd's branch has an OPEN PR, print a loud
- * stderr warning. Never throws.
- */
 export async function warnOrphanedOpenPr(cwd = process.cwd()) {
     try {
         const pr = await getBranchOpenPr(cwd, (file, args, opts) => execFileAsyncDefault(file, args, opts).then((r) => ({ stdout: String(r.stdout ?? '') })));
@@ -74,6 +45,5 @@ export async function warnOrphanedOpenPr(cwd = process.cwd()) {
         process.stderr.write(formatOrphanedOpenPrWarning(pr));
     }
     catch {
-        // Advisory only — never break the run's exit.
     }
 }

package/dist/lib/pricing/cost.d.ts

@@ -1,4 +1,3 @@
-/** A single usage record: one model and the tokens it consumed in each direction. */
 export interface TokenUsage {
     model?: string;
     inputTokens?: number;
@@ -6,50 +5,22 @@ export interface TokenUsage {
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
 }
-/**
- * USD cost of one usage record. Returns 0 when the model is missing or unpriced
- * (cost is additive — an unknown model contributes nothing, not NaN). Cache
- * read/write tokens are priced at their dedicated rates when the table exposes
- * them, otherwise they fall back to the input rate (the standard LiteLLM
- * convention for models that don't publish a separate cache price).
- */
 export declare function costOfUsage(u: TokenUsage): number;
-/**
- * USD cost of one usage record priced as if caching were OFF: cache-read and
- * cache-write tokens are billed at the model's full INPUT rate rather than their
- * discounted cache rates. This is the "what would this have cost with no prompt
- * caching?" scenario that `agents insights output --pricing no-cache` models. Output and
- * uncached input are unchanged — only the cache tokens are repriced. Returns 0
- * for a missing/unpriced model, exactly like {@link costOfUsage}.
- */
 export declare function costOfUsageNoCache(u: TokenUsage): number;
-/** Sum the USD cost of every usage record in a session. */
 export declare function costOfSession(usages: TokenUsage[]): number;
-/**
- * Format a USD amount for human display. Cents-precise, with a "<$0.01" floor
- * so tiny-but-nonzero sessions don't render as "$0.00" and read as free.
- */
 export declare function formatUsd(usd: number): string;
-/** Token bundle accepted by the #346 estimator/actual-cost helpers. */
 interface EstimatorTokens {
     inputTokens: number;
     outputTokens: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
 }
-/**
- * Pre-flight cost estimate for a model + token bundle (issue #346's budget
- * gate). Returns the resolved canonical model id (`modelMatched`) so callers
- * can warn when an estimate fell back to $0 because the model is unpriced.
- */
 export declare function estimateCost(model: string, tokens: EstimatorTokens): {
     usd: number;
     modelMatched: string | null;
 };
-/** Actual (post-hoc) cost of a model + observed usage. Thin alias over costOfUsage. */
 export declare function actualCost(model: string, usage: EstimatorTokens): {
     usd: number;
 };
-/** True when the model resolves to a priced entry in the table. */
 export declare function isModelPriced(model: string): boolean;
 export {};

package/dist/lib/pricing/cost.js

@@ -1,19 +1,4 @@
-/**
- * Token-usage → USD cost math, built on the offline pricing table.
- *
- * `costOfUsage` is the single multiply-by-price primitive every other helper
- * (and issue #346's budget pre-flight estimator) routes through. It returns 0
- * for unknown/unpriced models rather than throwing — cost is additive, and a
- * single unknown model in a session shouldn't blow up the whole rollup.
- */
 import { getModelPricing } from './table.js';
-/**
- * USD cost of one usage record. Returns 0 when the model is missing or unpriced
- * (cost is additive — an unknown model contributes nothing, not NaN). Cache
- * read/write tokens are priced at their dedicated rates when the table exposes
- * them, otherwise they fall back to the input rate (the standard LiteLLM
- * convention for models that don't publish a separate cache price).
- */
 export function costOfUsage(u) {
     if (!u.model)
         return 0;
@@ -31,14 +16,6 @@ export function costOfUsage(u) {
         cacheRead * cacheReadRate +
         cacheWrite * cacheWriteRate);
 }
-/**
- * USD cost of one usage record priced as if caching were OFF: cache-read and
- * cache-write tokens are billed at the model's full INPUT rate rather than their
- * discounted cache rates. This is the "what would this have cost with no prompt
- * caching?" scenario that `agents insights output --pricing no-cache` models. Output and
- * uncached input are unchanged — only the cache tokens are repriced. Returns 0
- * for a missing/unpriced model, exactly like {@link costOfUsage}.
- */
 export function costOfUsageNoCache(u) {
     if (!u.model)
         return 0;
@@ -49,23 +26,17 @@ export function costOfUsageNoCache(u) {
     const output = u.outputTokens ?? 0;
     const cacheRead = u.cacheReadTokens ?? 0;
     const cacheWrite = u.cacheCreationTokens ?? 0;
-    // Cache tokens repriced at the input rate — no caching discount applied.
     return (input * pricing.inputPerToken +
         output * pricing.outputPerToken +
         cacheRead * pricing.inputPerToken +
         cacheWrite * pricing.inputPerToken);
 }
-/** Sum the USD cost of every usage record in a session. */
 export function costOfSession(usages) {
     let total = 0;
     for (const u of usages)
         total += costOfUsage(u);
     return total;
 }
-/**
- * Format a USD amount for human display. Cents-precise, with a "<$0.01" floor
- * so tiny-but-nonzero sessions don't render as "$0.00" and read as free.
- */
 export function formatUsd(usd) {
     if (!Number.isFinite(usd) || usd <= 0)
         return '$0.00';
@@ -73,23 +44,14 @@ export function formatUsd(usd) {
         return '<$0.01';
     return `$${usd.toFixed(2)}`;
 }
-/**
- * Pre-flight cost estimate for a model + token bundle (issue #346's budget
- * gate). Returns the resolved canonical model id (`modelMatched`) so callers
- * can warn when an estimate fell back to $0 because the model is unpriced.
- */
 export function estimateCost(model, tokens) {
     const pricing = getModelPricing(model);
     const usd = costOfUsage({ model, ...tokens });
-    // modelMatched is the input model when priced, null when unknown — callers
-    // only need the priced/unpriced signal, not the internal canonical key.
     return { usd, modelMatched: pricing ? model : null };
 }
-/** Actual (post-hoc) cost of a model + observed usage. Thin alias over costOfUsage. */
 export function actualCost(model, usage) {
     return { usd: costOfUsage({ model, ...usage }) };
 }
-/** True when the model resolves to a priced entry in the table. */
 export function isModelPriced(model) {
     return getModelPricing(model) !== null;
 }

package/dist/lib/pricing/index.d.ts

@@ -1,8 +1,2 @@
-/**
- * Canonical, reusable pricing module.
- *
- * Public surface re-exported here is the contract issue #346 (budget
- * enforcement) imports against — keep it stable.
- */
 export { type ModelPricing, PRICING_VERSION, getModelPricing, listPricedModels, } from './table.js';
 export { type TokenUsage, costOfUsage, costOfUsageNoCache, costOfSession, formatUsd, estimateCost, actualCost, isModelPriced, } from './cost.js';

package/dist/lib/pricing/index.js

@@ -1,8 +1,2 @@
-/**
- * Canonical, reusable pricing module.
- *
- * Public surface re-exported here is the contract issue #346 (budget
- * enforcement) imports against — keep it stable.
- */
 export { PRICING_VERSION, getModelPricing, listPricedModels, } from './table.js';
 export { costOfUsage, costOfUsageNoCache, costOfSession, formatUsd, estimateCost, actualCost, isModelPriced, } from './cost.js';

package/dist/lib/pricing/table.d.ts

@@ -1,17 +1,9 @@
-/** Per-token USD prices for a single model. Cache fields optional (not all vendors expose them). */
 export interface ModelPricing {
     inputPerToken: number;
     outputPerToken: number;
     cacheReadPerToken?: number;
     cacheWritePerToken?: number;
 }
-/** Date-stamped version of the pricing table (e.g. "2026-06-24"). */
 export declare const PRICING_VERSION: string;
-/**
- * Resolve per-token pricing for a model id. Tolerant of vendor prefixes,
- * version dashes, and date suffixes. Returns null when no canonical key is a
- * substring of the normalized id (i.e. genuinely unknown model).
- */
 export declare function getModelPricing(modelId: string): ModelPricing | null;
-/** List every canonical model id that carries a price. */
 export declare function listPricedModels(): string[];

package/dist/lib/pricing/table.js

@@ -1,86 +1,33 @@
-/**
- * Offline, versioned per-model pricing table.
- *
- * The canonical data lives in `prices.json` (LiteLLM-style per-token USD map)
- * and is imported with a `type: json` attribute so it survives `tsc` emit AND
- * Node ESM's import-attribute requirement at runtime (the package is ESM).
- *
- * ## Keeping it current
- *
- * A model missing from `prices.json` prices to NOTHING — `getModelPricing` returns
- * null and the session contributes $0, silently. That is how 478 `claude-opus-5`
- * sessions read as free: matching is dash-bounded, so `claude-opus-5` cannot fall back
- * to the `claude-opus-4` entry. When a new model ships, add it here in the same change.
- *
- * **Dated rate: Claude Sonnet 5 is priced at its introductory $2/$10 per MTok, which
- * ends 2026-08-31.** From 2026-09-01 the standard rate is $3/$15 (cache write $3.75,
- * cache read $0.30). This table has no notion of an effective date — every row is a
- * single current rate — so that entry MUST be updated then, or Sonnet 5 spend will
- * read ~33% low. Source: https://platform.claude.com/docs/en/about-claude/pricing
- *
- * `getModelPricing` is prefix/suffix-tolerant: real model identifiers carry
- * vendor prefixes (`us.anthropic.`), version dashes (`claude-opus-4-8`), and
- * date suffixes (`-20250514`), none of which appear in the canonical keys. We
- * normalize the input, then match against the LONGEST canonical key the
- * normalized id contains so `claude-opus-4` wins over a hypothetical
- * `claude-opus` when both are present.
- */
 import pricesData from './prices.json' with { type: 'json' };
 const PRICES = pricesData;
-/** Date-stamped version of the pricing table (e.g. "2026-06-24"). */
 export const PRICING_VERSION = PRICES.version;
 const MODELS = PRICES.models;
-// Canonical keys sorted longest-first so containment matching prefers the most
-// specific key (e.g. "gemini-2.5-flash-lite" before "gemini-2.5-flash").
 const KEYS_BY_LENGTH = Object.keys(MODELS).sort((a, b) => b.length - a.length);
-/**
- * Normalize a raw model id into the dash-delimited token space the canonical
- * keys live in. Strips vendor prefixes (`anthropic/`, `us.anthropic.`,
- * `models/`, `openai/`), lowercases, and collapses any non [a-z0-9.] run to a
- * single dash so `claude-opus-4-8`, `Claude Opus 4`, and `claude.opus.4` all
- * normalize to a comparable form.
- */
 function normalizeModelId(modelId) {
     let id = modelId.trim().toLowerCase();
-    // Drop a leading vendor segment: "anthropic/claude-..", "us.anthropic.claude-..",
-    // "google/gemini-..", "models/gemini-..", "openai/gpt-..".
-    id = id.replace(/^[a-z]+\//, ''); // "anthropic/x" -> "x"
-    id = id.replace(/^[a-z]+\.[a-z]+\./, ''); // "us.anthropic.x" -> "x"
-    id = id.replace(/^models\//, ''); // already handled, defensive
-    // Collapse separators to single dashes, keep dots (gpt-5.4) intact.
+    id = id.replace(/^[a-z]+\//, '');
+    id = id.replace(/^[a-z]+\.[a-z]+\./, '');
+    id = id.replace(/^models\//, '');
     id = id.replace(/[\s_]+/g, '-').replace(/-+/g, '-');
     return id;
 }
-/**
- * Resolve per-token pricing for a model id. Tolerant of vendor prefixes,
- * version dashes, and date suffixes. Returns null when no canonical key is a
- * substring of the normalized id (i.e. genuinely unknown model).
- */
 export function getModelPricing(modelId) {
     if (!modelId)
         return null;
     const norm = normalizeModelId(modelId);
-    // Exact key first (fast path + unambiguous).
     if (MODELS[norm])
         return MODELS[norm];
-    // Containment match, longest canonical key wins. The canonical key must
-    // appear as a dash-bounded prefix of the normalized id so "claude-opus-4"
-    // matches "claude-opus-4-8" and "claude-opus-4-20250514" but a stray
-    // "gpt-4" inside "gpt-40-turbo-experimental" still requires the boundary.
     for (const key of KEYS_BY_LENGTH) {
         if (norm === key || norm.startsWith(key + '-') || norm.startsWith(key + '.')) {
             return MODELS[key];
         }
     }
-    // Last resort: canonical key contained anywhere (handles "anthropic-claude-opus-4"
-    // style ids the prefix strip missed). Still longest-first.
     for (const key of KEYS_BY_LENGTH) {
         if (norm.includes(key))
             return MODELS[key];
     }
     return null;
 }
-/** List every canonical model id that carries a price. */
 export function listPricedModels() {
     return Object.keys(MODELS);
 }

package/dist/lib/probe.d.ts

@@ -1,8 +1,3 @@
-/**
- * Async probe capturing stdout. Rejects on spawn error, non-zero exit, or
- * timeout — matching the `execFileAsync` contract the version probe had — and
- * reaps the probe's whole process group on every settle path.
- */
 export declare function probeCapture(cmd: string, args: string[], timeoutMs: number, options?: {
     acceptedExitCodes?: number[];
     maxOutputBytes?: number;

package/dist/lib/probe.js

@@ -1,29 +1,3 @@
-/**
- * Spawn helpers for CAPABILITY PROBES — short-lived invocations of third-party
- * binaries (`copilot --version`, a manifest's `check:` command) whose only job
- * is an exit status or a line of stdout.
- *
- * A probed binary may fork children of its own: the copilot npm wrapper forks
- * a platform-binary downloader into `~/Library/Caches/copilot` on first run
- * under a fresh HOME. Node's `timeout:` option kills only the DIRECT child, so
- * such grandchildren outlive the probe and keep writing — under a test's temp
- * HOME that race is the ENOTEMPTY teardown class (RUSH-3028; residual after
- * RUSH-3021 gated the daemon autostart). Every probe here therefore runs in
- * its OWN process group (`detached`), and the whole group is reaped once the
- * probe settles, so nothing a probe spawned can outlive it.
- *
- * Group semantics are POSIX only: on win32 `detached` means a new console and
- * negative-pid group kills are unsupported, so there the DIRECT child is
- * killed on settle instead — the same guarantee `execFileAsync`'s `timeout:`
- * gave (the grandchild leak class is a darwin/linux temp-HOME teardown race).
- *
- * The parent dying mid-probe is covered too: a detached probe leaves the
- * terminal's foreground group, so a Ctrl-C that hard-exits the CLI
- * (`process.exit(130)` in index.ts) would strand it. Live probe groups are
- * tracked in LIVE_GROUPS and a `process.on('exit')` hook — which runs on
- * every `process.exit` path, including that SIGINT handler — reaps them
- * synchronously.
- */
 import { spawn } from 'child_process';
 const GROUP_REAP = process.platform !== 'win32';
 const LIVE_GROUPS = new Set();
@@ -38,7 +12,6 @@ function ensureExitHook() {
                 process.kill(-pid, 'SIGKILL');
             }
             catch {
-                /* group already fully exited */
             }
         }
     });
@@ -51,14 +24,8 @@ function reapGroup(pid) {
         process.kill(-pid, 'SIGKILL');
     }
     catch {
-        /* group already fully exited */
     }
 }
-/**
- * Async probe capturing stdout. Rejects on spawn error, non-zero exit, or
- * timeout — matching the `execFileAsync` contract the version probe had — and
- * reaps the probe's whole process group on every settle path.
- */
 export function probeCapture(cmd, args, timeoutMs, options = {}) {
     return new Promise((resolve, reject) => {
         const child = spawn(cmd, args, {
@@ -78,9 +45,6 @@ export function probeCapture(cmd, args, timeoutMs, options = {}) {
             settled = true;
             clearTimeout(timer);
             reapGroup(child.pid);
-            // win32 has no group to reap: kill the direct child so a timed-out
-            // probe still dies, matching execFile's `timeout:` behavior. No-op
-            // after a clean exit.
             if (!GROUP_REAP)
                 child.kill('SIGKILL');
             if (err)
@@ -97,10 +61,6 @@ export function probeCapture(cmd, args, timeoutMs, options = {}) {
             }
         });
         child.on('error', (e) => settle(e));
-        // 'exit', not 'close': a forked grandchild inherits the stdout pipe, and
-        // 'close' waits for EVERY holder of that pipe to exit — exactly the
-        // process this helper exists to reap. Settle when the probed binary
-        // itself exits; one tick's grace lets its final stdout chunks land.
         child.on('exit', (code) => {
             setImmediate(() => settle(code !== null && (options.acceptedExitCodes ?? [0]).includes(code) ? null : new Error(`probe exited ${code}: ${cmd} ${args.join(' ')}`)));
         });

package/dist/lib/profiles-presets.d.ts

@@ -1,25 +1,12 @@
-/**
- * Built-in profile presets for popular model providers.
- *
- * Each preset bundles a host CLI, API base URL, default model, and provider
- * name so users can `agents harness add kimi` without manual configuration.
- */
 import type { AgentId } from './types.js';
 export interface PresetVar {
-    /** Env var name to set in the resulting profile. */
     envVar: string;
-    /** User-facing prompt text. */
     prompt: string;
-    /** True for secrets — wizard will mask input and store in keychain. */
     secret?: boolean;
-    /** Default value (shown in prompt). */
     default?: string;
-    /** Optional regex pattern — input validated against it. */
     pattern?: string;
-    /** Optional hint text shown beside the prompt. */
     hint?: string;
 }
-/** A pre-configured profile template for a model provider. */
 export interface Preset {
     name: string;
     description: string;
@@ -28,24 +15,17 @@ export interface Preset {
     env: Record<string, string>;
     vars?: PresetVar[];
     authEnvVar: string;
-    /** True if the provider can function without a keychain token (e.g. Bedrock with SSO). */
     authOptional?: boolean;
     signupUrl?: string;
     docPath?: string;
 }
 export declare const PRESETS: Preset[];
 interface ResolvedPresetEnv {
-    /** Env vars from preset.env — always set, no user input. */
     static: Record<string, string>;
-    /** Vars the wizard needs to prompt for. */
     prompts: PresetVar[];
 }
-/** Split a preset into static env vars and prompts needed from the user. */
 export declare function expandPreset(p: Preset): ResolvedPresetEnv;
-/** Look up a preset by name (case-sensitive). */
 export declare function getPreset(name: string): Preset | undefined;
-/** Return a copy of all available presets. */
 export declare function listPresets(): Preset[];
-/** Return the unique set of provider names across all presets. */
 export declare function listProviders(): string[];
 export {};

package/dist/lib/profiles-presets.js

@@ -1,26 +1,3 @@
-/**
- * Built-in profile presets for popular model providers.
- *
- * Each preset bundles a host CLI, API base URL, default model, and provider
- * name so users can `agents harness add kimi` without manual configuration.
- */
-// Model IDs verified against openrouter.ai/api/v1/models on 2026-07-31
-// (spark presets corrected from the never-served meta/claude-spark-1.1 to the
-// live meta/muse-spark-1.1, confirmed on both OpenRouter and OpenCode id:meta).
-// Presets target the top-ranked open-source model per provider based on
-// SWE-bench Verified, LiveCodeBench, HumanEval, and Chatbot Arena rankings.
-//
-// Important limitation of Claude Code + non-Anthropic models via OpenRouter:
-// Claude Code sends `thinking:{type:"enabled"}` in its Anthropic payload by
-// default, and its headless output consolidation returns empty text when a
-// response contains thinking/redacted_thinking blocks — even when the model
-// *also* emits a text block. This means reasoning models work fine in
-// interactive `claude` mode (same env vars) but headless invocations
-// (`agents run <profile> "<prompt>"`) see empty stdout.
-//
-// Presets flagged "headless-safe" use non-reasoning variants that ignore
-// thinking:enabled. Presets flagged "reasoning" are the leaderboard leaders
-// but are best invoked interactively.
 const OPENROUTER_BASE = 'https://openrouter.ai/api';
 const OPENROUTER_AUTH = {
     provider: 'openrouter',
@@ -29,7 +6,6 @@ const OPENROUTER_AUTH = {
     signupUrl: 'https://openrouter.ai/keys',
 };
 export const PRESETS = [
-    // ----- Top coding (via OpenRouter) -----
     {
         name: 'kimi',
         description: 'Kimi K2.5 via OpenRouter (262K ctx, $0.38/$1.72 per 1M). Top Kimi: 99% HumanEval, 76.8% SWE-bench. REASONING — works interactively, but `agents run kimi "<prompt>"` (headless) returns empty stdout. Use `kimi-chat` preset for scripting.',
@@ -110,7 +86,6 @@ export const PRESETS = [
             ANTHROPIC_SMALL_FAST_MODEL: 'meta/muse-spark-1.1',
         },
     },
-    // ----- OpenCode CLI (open-claude harness) -----
     {
         name: 'opencode',
         description: 'OpenCode default — uses your configured model via opencode auth. Run `opencode auth` to login, then `agents run opencode --model meta/muse-spark-1.1 "prompt"` for spark usage.',
@@ -142,7 +117,6 @@ export const PRESETS = [
             OPENCODE_MODEL: 'qwen/qwen3-coder-next',
         },
     },
-    // ----- xAI Grok Build CLI (native host) -----
     {
         name: 'grok-fast',
         description: 'xAI Grok Build CLI — fast tier. Optimized for speed and low-latency coding tasks.',
@@ -165,7 +139,6 @@ export const PRESETS = [
             GROK_MODEL: 'grok-4.3',
         },
     },
-    // ----- Google Antigravity CLI (native host) -----
     {
         name: 'agy',
         description: 'Google Antigravity CLI default (gemini-3.5-flash). Optimized for speed and large context.',
@@ -173,11 +146,8 @@ export const PRESETS = [
         host: 'antigravity',
         authEnvVar: 'ANTIGRAVITY_API_KEY',
         signupUrl: 'https://antigravity.google',
-        env: {
-        // Antigravity defaults to gemini-3.5-flash as of June 2026
-        },
+        env: {},
     },
-    // ----- Direct Providers -----
     {
         name: 'anthropic',
         description: 'Anthropic direct API — standard Claude Code experience with your own API key.',
@@ -203,7 +173,6 @@ export const PRESETS = [
             OPENAI_MODEL: 'deepseek-ai/DeepSeek-V3',
         },
     },
-    // ----- Gateway / enterprise / self-hosted -----
     {
         name: 'proxy',
         description: 'Generic local proxy / gateway — points at a local router (CCR, LiteLLM) or internal corporate inference endpoint.',
@@ -368,19 +337,15 @@ export const PRESETS = [
         ],
     },
 ];
-/** Split a preset into static env vars and prompts needed from the user. */
 export function expandPreset(p) {
     return { static: { ...p.env }, prompts: p.vars ?? [] };
 }
-/** Look up a preset by name (case-sensitive). */
 export function getPreset(name) {
     return PRESETS.find((p) => p.name === name);
 }
-/** Return a copy of all available presets. */
 export function listPresets() {
     return [...PRESETS];
 }
-/** Return the unique set of provider names across all presets. */
 export function listProviders() {
     return [...new Set(PRESETS.map((p) => p.provider))];
 }