@eddyskywalker/dsh-chatgpt-subscription 0.1.37 → 0.1.38

package/lib/index.js

@@ -1,18 +1,20 @@
+import { createRequire } from "node:module";
 import * as LlmModule from "@deepseek-ai/dsh-llm";
 import { HarnessError, LlmAdapter, LlmError, ProviderRequestId, ReasoningEffortId, attributionHeaders, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { WebError } from "@deepseek-ai/dsh-web";
 import { createUserMessage } from "@deepseek-ai/dsh-llm/message";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import http from "node:http";
+import http, { createServer } from "node:http";
 import { execSync, spawn } from "node:child_process";
 import { ProxyAgent, fetch as fetch$1 } from "undici";
 import * as SettingsModule from "@deepseek-ai/dsh-settings";
 import z from "@deepseek-ai/schemastery";
-import { constants } from "node:fs";
-import { chmod, lstat, mkdir, open, rename, stat, unlink } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import fs, { constants } from "node:fs";
+import fsPromises, { chmod, lstat, mkdir, open, rename, stat, unlink } from "node:fs/promises";
+import os, { homedir } from "node:os";
+import path, { dirname, join } from "node:path";
+import { URL as URL$1, URLSearchParams as URLSearchParams$1 } from "node:url";
 //#region src/compat.ts
 /**
 * Compatibility constants for the ChatGPT-backed Codex flow. The backend and
@@ -55,7 +57,8 @@ const CODEX_MODEL_CATALOG = [
 		inputModalities: ["text", "image"],
 		defaultReasoningEffort: "medium",
 		reasoningProfile: "gpt-5.6",
-		supportsReasoningSummary: true
+		supportsReasoningSummary: true,
+		fallbackModelId: "gpt-5.6-terra"
 	},
 	{
 		id: "gpt-5.6-terra",
@@ -64,7 +67,8 @@ const CODEX_MODEL_CATALOG = [
 		inputModalities: ["text", "image"],
 		defaultReasoningEffort: "medium",
 		reasoningProfile: "gpt-5.6",
-		supportsReasoningSummary: true
+		supportsReasoningSummary: true,
+		fallbackModelId: "gpt-5.5"
 	},
 	{
 		id: "gpt-5.6-luna",
@@ -73,7 +77,8 @@ const CODEX_MODEL_CATALOG = [
 		inputModalities: ["text", "image"],
 		defaultReasoningEffort: "medium",
 		reasoningProfile: "gpt-5.6",
-		supportsReasoningSummary: true
+		supportsReasoningSummary: true,
+		fallbackModelId: "gpt-5.5"
 	},
 	{
 		id: "gpt-5.5",
@@ -91,7 +96,8 @@ const CODEX_MODEL_CATALOG = [
 		inputModalities: ["text", "image"],
 		defaultReasoningEffort: "none",
 		reasoningProfile: "standard",
-		supportsReasoningSummary: true
+		supportsReasoningSummary: true,
+		fallbackModelId: "gpt-5.4-mini"
 	},
 	{
 		id: "gpt-5.4-mini",
@@ -149,14 +155,19 @@ function codexModelSupportsImageInput(model) {
 function codexModelSupportsReasoningSummary(model) {
 	return resolveCodexCatalogEntry(model).supportsReasoningSummary;
 }
+function resolveCodexFallbackModel(model) {
+	const entry = resolveCodexCatalogEntry(model);
+	if (!entry.fallbackModelId) return void 0;
+	return CODEX_MODEL_CATALOG.find((cand) => cand.id === entry.fallbackModelId);
+}
 //#endregion
 //#region src/host/model-catalog.ts
-const PROVIDER_ID = CODEX_CHATGPT_PROVIDER_ID;
-const PROVIDER_NAME = "Codex（ChatGPT 订阅）";
+const PROVIDER_ID$1 = CODEX_CHATGPT_PROVIDER_ID;
+const PROVIDER_NAME$1 = "Codex（ChatGPT 订阅）";
 function listCodexModels(preferences) {
 	const visible = new Set(preferences?.status().visibleModelIds ?? CODEX_MODEL_CATALOG.map((entry) => entry.id));
 	return CODEX_MODEL_CATALOG.filter((entry) => visible.has(entry.id)).map((entry) => ({
-		provider: PROVIDER_ID,
+		provider: PROVIDER_ID$1,
 		id: entry.id,
 		name: entry.name,
 		inputModalities: [...entry.inputModalities]
@@ -168,7 +179,7 @@ function resolveCodexModel(model, preferences) {
 	const configuredContextWindow = isConfigurableContextModelId(model) ? status?.contextWindowOverrides[model] : void 0;
 	const efforts = reasoningEffortsForModel(model);
 	return {
-		provider: PROVIDER_ID,
+		provider: PROVIDER_ID$1,
 		id: model,
 		name: entry.id === model ? entry.name : model,
 		inputModalities: [...entry.inputModalities],
@@ -213,7 +224,7 @@ var CodexChatGptAdapter = class extends LlmAdapter {
 	providerInfo(provider) {
 		return {
 			id: provider,
-			name: PROVIDER_NAME
+			name: PROVIDER_NAME$1
 		};
 	}
 	providerRetryPolicy() {
@@ -1416,6 +1427,137 @@ function withWritable(value) {
 	};
 }
 //#endregion
+//#region node_modules/@deepseek-ai/dsh-timeout/lib/index.js
+/**
+* Shared timeout arithmetic, signal fusion, and classification. The library
+* only notifies through abort signals; each capability still owns the mechanism
+* that stops its work and translates timeout reasons into public outcomes.
+* @module @deepseek-ai/dsh-timeout
+*/
+/**
+* Internal abort reason carrying a capability-owned code and elapsed deadline.
+* Providers translate it through {@link timeoutOf} before returning to callers.
+*/
+var TimeoutReason = class extends Error {
+	code;
+	timeoutMs;
+	name = "TimeoutReason";
+	/**
+	* @param code Capability-owned timeout code (e.g. `BASH_TIMEOUT`).
+	* @param timeoutMs The deadline that elapsed, in milliseconds.
+	*/
+	constructor(code, timeoutMs) {
+		super(`${code} after ${timeoutMs}ms`);
+		this.code = code;
+		this.timeoutMs = timeoutMs;
+	}
+};
+/** Largest delay Node schedules without clamping it to one millisecond. */
+const MAX_TIMER_DELAY_MS = 2147483647;
+function assertTimerDelay(timeoutMs, name) {
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) throw new Error(`${name} must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+}
+/**
+* Create a rearmable idle watchdog for an async iterator. The timer exists only
+* while {@link IdleWatchdog.next} is outstanding, so consumer think time does
+* not count as provider idle time. The returned signal is stable for the whole
+* call and only notifies; the iterator must observe it to terminate its work.
+*
+* @param upstream - caller cancellation fused into the stable signal.
+* @param timeoutMs - positive finite idle interval in milliseconds.
+* @param code - capability-owned code carried by the timeout reason.
+* @returns a stable signal, guarded next operation, and timer disposer.
+*/
+function idleWatchdog(upstream, timeoutMs, code) {
+	assertTimerDelay(timeoutMs, "idleWatchdog timeoutMs");
+	const timeout = new AbortController();
+	const signal = upstream === void 0 ? timeout.signal : AbortSignal.any([upstream, timeout.signal]);
+	let timer;
+	let outstanding = false;
+	let disposed = false;
+	const arm = () => {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timeout.abort(new TimeoutReason(code, timeoutMs));
+		}, timeoutMs);
+	};
+	return {
+		signal,
+		async next(iterator) {
+			if (disposed) throw new Error("idleWatchdog is disposed");
+			if (outstanding) throw new Error("idleWatchdog next is already outstanding");
+			outstanding = true;
+			arm();
+			try {
+				return await iterator.next();
+			} finally {
+				clearTimeout(timer);
+				timer = void 0;
+				outstanding = false;
+			}
+		},
+		pulse() {
+			if (disposed || !outstanding) return;
+			arm();
+		},
+		[Symbol.dispose]() {
+			if (disposed) return;
+			disposed = true;
+			if (timer !== void 0) clearTimeout(timer);
+			timer = void 0;
+		}
+	};
+}
+/**
+* Recover a timeout reason from a reason-bearing object. Supplying `code`
+* distinguishes this deadline from a nested upstream deadline; a foreign code
+* follows the ordinary cancellation path.
+*
+* @param x An {@link AbortSignal} or any `{ reason }` carrier (e.g. a caught abort error).
+* @param code When provided, only a {@link TimeoutReason} with this exact `code` matches.
+* @returns The matching {@link TimeoutReason}, else `undefined`.
+*/
+function timeoutOf(x, code) {
+	const reason = x.reason;
+	if (!(reason instanceof TimeoutReason)) return void 0;
+	return code === void 0 || reason.code === code ? reason : void 0;
+}
+//#endregion
+//#region src/host/common/idle-watchdog.ts
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
+const STREAM_IDLE_TIMEOUT_CODE$1 = "LLM_STREAM_IDLE_TIMEOUT";
+/**
+* 为异步流包裹可复位的空闲超时看门狗。
+* 当流式 chunk 产出之间的间隔超过指定阈值时，主动终止并抛出带有 TIMEOUT 的 LlmError。
+*/
+async function* wrapStreamWithWatchdog(source, upstreamSignal, timeoutMs = DEFAULT_STREAM_IDLE_TIMEOUT_MS, timeoutCode = STREAM_IDLE_TIMEOUT_CODE$1, providerTag = "llm") {
+	const consumer = new AbortController();
+	const watchdog = idleWatchdog(upstreamSignal === void 0 ? consumer.signal : AbortSignal.any([upstreamSignal, consumer.signal]), timeoutMs, timeoutCode);
+	const iterator = source(watchdog.signal)[Symbol.asyncIterator]();
+	let exhausted = false;
+	try {
+		while (true) {
+			const result = await watchdog.next(iterator);
+			if (timeoutOf(watchdog.signal, timeoutCode) !== void 0) throw new LlmError(`${providerTag} stream idle timeout after ${timeoutMs}ms`, "TIMEOUT");
+			if (result.done) {
+				exhausted = true;
+				return;
+			}
+			yield result.value;
+		}
+	} catch (error) {
+		if (timeoutOf(watchdog.signal, timeoutCode) !== void 0) throw new LlmError(`${providerTag} stream idle timeout after ${timeoutMs}ms`, "TIMEOUT", { cause: error });
+		if (upstreamSignal?.aborted) throw new LlmError(`${providerTag} request aborted by caller`, "ABORTED", { cause: error });
+		throw error;
+	} finally {
+		consumer.abort(`${providerTag} stream consumer stopped`);
+		if (!exhausted) try {
+			await iterator.return?.(void 0);
+		} catch {}
+		watchdog[Symbol.dispose]();
+	}
+}
+//#endregion
 //#region src/host/responses-mapper.ts
 function hiddenSandboxControlToolNames(options) {
 	const retryTools = recentSandboxRetryToolNames(options.messages);
@@ -1854,11 +1996,33 @@ var ResponsesClient = class {
 	}
 	localRawImages;
 	async *stream(options) {
-		const payload = await buildResponsesPayload(options, this.attachments, this.localRawImages, this.outputVerbosity(), this.fastMode());
 		const hiddenSandboxControls = hiddenSandboxControlToolNames(options);
 		const sessionId = stableSessionId(options.sessionId);
+		let currentModel = options.model;
+		let attemptOptions = options;
+		let response;
+		while (true) {
+			const payload = await buildResponsesPayload(attemptOptions, this.attachments, this.localRawImages, this.outputVerbosity(), this.fastMode());
+			try {
+				response = await this.send(payload, sessionId, options.signal);
+				break;
+			} catch (error) {
+				if (error instanceof LlmError && (error.code === "NOT_FOUND" || error.status === 404)) {
+					const fallback = resolveCodexFallbackModel(currentModel);
+					if (fallback && fallback.id !== currentModel) {
+						currentModel = fallback.id;
+						attemptOptions = {
+							...attemptOptions,
+							model: fallback.id
+						};
+						continue;
+					}
+				}
+				throw error;
+			}
+		}
 		try {
-			yield* parseResponsesStream(await this.send(payload, sessionId, options.signal), options.signal, hiddenSandboxControls);
+			yield* wrapStreamWithWatchdog((watchdogSignal) => parseResponsesStream(response, watchdogSignal, hiddenSandboxControls), options.signal, 3e5, "LLM_STREAM_IDLE_TIMEOUT", "Codex");
 		} finally {
 			this.onGenerationFinished();
 		}
@@ -2203,6 +2367,7 @@ async function responseError(response) {
 		...response.status === 429 ? { providerRetryAfterMs: retryAfterMs(response.headers) } : {}
 	};
 	if (response.status === 401) return new LlmError("ChatGPT sign-in has expired. Sign in again.", "AUTH", options);
+	if (response.status === 404) return new LlmError(`Codex model or resource not found (${response.status})${detail ? `: ${detail}` : "."}`, "NOT_FOUND", options);
 	if (response.status === 429) return new LlmError("Codex rate limit reached.", "RATE_LIMIT", options);
 	if (response.status >= 500) return new LlmError(`Codex service error (${response.status}).`, "SERVER_ERROR", options);
 	return new LlmError(`Codex request failed (${response.status})${detail ? `: ${detail}` : "."}`, "PROVIDER_ERROR", options);
@@ -2651,6 +2816,20 @@ function registerRoutes(ctx, oauth, usage, preferences, proxyManager) {
 			});
 			return;
 		}
+		if (request.method === "GET" && url.pathname === `/api/dsh-chatgpt-subscription/mermaid.min.js`) {
+			try {
+				const mermaidPath = createRequire(import.meta.url).resolve("mermaid/dist/mermaid.min.js");
+				response.writeHead(200, {
+					"Content-Type": "application/javascript; charset=utf-8",
+					"Cache-Control": "public, max-age=86400"
+				});
+				fs.createReadStream(mermaidPath).pipe(response);
+			} catch {
+				response.writeHead(404, { "Content-Type": "text/plain" });
+				response.end("Not found");
+			}
+			return;
+		}
 		if (request.method !== "POST") {
 			jsonError(response, 405, {
 				code: "bad-request",
@@ -2854,7 +3033,7 @@ function field(value, name) {
 	const candidate = value[name];
 	return typeof candidate === "string" && candidate !== "" ? candidate : null;
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readPreferencesUpdate(value, current) {
@@ -2880,7 +3059,7 @@ function readPreferencesUpdate(value, current) {
 		patch.searchProvider = value.searchProvider;
 	}
 	if ("contextWindowOverrides" in value) {
-		if (!isRecord(value.contextWindowOverrides)) throw new PreferenceError("contextWindowOverrides must be an object.");
+		if (!isRecord$1(value.contextWindowOverrides)) throw new PreferenceError("contextWindowOverrides must be an object.");
 		const overrides = {};
 		for (const [model, contextWindow] of Object.entries(value.contextWindowOverrides)) {
 			if (!isConfigurableContextModelId(model)) throw new PreferenceError("Only GPT-5.6 context windows can be changed.");
@@ -3307,6 +3486,1691 @@ function currentConfig(entry) {
 	return typeof config === "object" && config !== null && !Array.isArray(config) ? config : {};
 }
 //#endregion
+//#region src/host/antigravity/types.ts
+const PROVIDER_NAME = "Antigravity";
+const PROVIDER_ID = "antigravity";
+const STREAM_IDLE_TIMEOUT_MS = 3e5;
+const STREAM_IDLE_TIMEOUT_CODE = "LLM_STREAM_IDLE_TIMEOUT";
+const DISCOVERY_TIMEOUT_MS = 8e3;
+const PROJECT_CACHE_TTL_MS = 1800 * 1e3;
+const OAUTH_CALLBACK_TIMEOUT_MS = 300 * 1e3;
+const ENDPOINT_FALLBACKS = ["https://cloudcode-pa.googleapis.com", "https://daily-cloudcode-pa.sandbox.googleapis.com"];
+const REDIRECT_PATH = "/oauth-callback";
+const AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+const TOKEN_URL = "https://oauth2.googleapis.com/token";
+const SCOPES = [
+	"https://www.googleapis.com/auth/aicode",
+	"https://www.googleapis.com/auth/cloud-platform",
+	"https://www.googleapis.com/auth/userinfo.email",
+	"https://www.googleapis.com/auth/userinfo.profile",
+	"https://www.googleapis.com/auth/cclog",
+	"https://www.googleapis.com/auth/experimentsandconfigs"
+];
+const DEFAULT_CLIENT_ID = Buffer.from("MTA3MTAwNjA2MDU5MS10bWhzc2luMmgyMWxjcmUyMzV2dG9sb2poNGc0MDNlcC5hcHBzLmdvb2dsZXVzZXJjb250ZW50LmNvbQ==", "base64").toString("utf8");
+const DEFAULT_CLIENT_SECRET = Buffer.from("R09DU1BYLUs1OEZXUjQ4NkxkTEoxbUxCOHNYQzR6NnFEQWY=", "base64").toString("utf8");
+const ANTIGRAVITY_SYSTEM_INSTRUCTION = "You are Antigravity, a powerful agentic AI coding assistant designed by Google DeepMind. You are pair programming with a user to solve coding tasks. Be concise, practical, and tool-aware.";
+const ANTIGRAVITY_NO_PREAMBLE_INSTRUCTION = "CRITICAL: NEVER output rule checks, formatting guidelines, constraint checklists, or thinking/personality preambles in the final response. Output only the final response.";
+const GEMINI_ROLE = {
+	user: "user",
+	model: "model"
+};
+const TOOL_CALLING_MODE = {
+	none: "NONE",
+	any: "ANY",
+	auto: "AUTO",
+	validated: "VALIDATED"
+};
+const ROUTING = {
+	"gemini-3.8-flash": {
+		off: "gemini-3.8-flash-tiered",
+		routing: {
+			minimal: "gemini-3.8-flash-tiered",
+			low: "gemini-3.8-flash-tiered",
+			medium: "gemini-3.8-flash-tiered",
+			high: "gemini-3.8-flash-tiered",
+			xhigh: "gemini-3.8-flash-tiered"
+		},
+		defaultRequestId: "gemini-3.8-flash-tiered",
+		fallbackCandidates: ["gemini-3.7-flash-tiered", "gemini-3.6-flash-low"]
+	},
+	"claude-opus-4-6": {
+		off: "claude-opus-4-6-thinking",
+		routing: {
+			minimal: "claude-opus-4-6-thinking",
+			low: "claude-opus-4-6-thinking",
+			medium: "claude-opus-4-6-thinking",
+			high: "claude-opus-4-6-thinking",
+			xhigh: "claude-opus-4-6-thinking"
+		},
+		defaultRequestId: "claude-opus-4-6-thinking",
+		fallbackCandidates: ["claude-sonnet-4-6"]
+	},
+	"claude-sonnet-4-6": {
+		off: "claude-sonnet-4-6",
+		routing: {
+			minimal: "claude-sonnet-4-6",
+			low: "claude-sonnet-4-6",
+			medium: "claude-sonnet-4-6",
+			high: "claude-sonnet-4-6",
+			xhigh: "claude-sonnet-4-6"
+		},
+		defaultRequestId: "claude-sonnet-4-6"
+	},
+	"gemini-3.7-flash": {
+		off: "gemini-3.7-flash-tiered",
+		routing: {
+			minimal: "gemini-3.7-flash-tiered",
+			low: "gemini-3.7-flash-tiered",
+			medium: "gemini-3.7-flash-tiered",
+			high: "gemini-3.7-flash-tiered",
+			xhigh: "gemini-3.7-flash-tiered"
+		},
+		defaultRequestId: "gemini-3.7-flash-tiered",
+		fallbackCandidates: ["gemini-3.6-flash-low"]
+	},
+	"gemini-3.6-flash": {
+		off: "gemini-3.6-flash-low",
+		routing: {
+			minimal: "gemini-3.6-flash-low",
+			low: "gemini-3.6-flash-low",
+			medium: "gemini-3.6-flash-medium",
+			high: "gemini-3.6-flash-high",
+			xhigh: "gemini-3.6-flash-high"
+		},
+		defaultRequestId: "gemini-3.6-flash-high"
+	},
+	"gemini-3.5-flash": {
+		off: "gemini-3.5-flash-extra-low",
+		routing: {
+			minimal: "gemini-3.5-flash-extra-low",
+			low: "gemini-3.5-flash-low",
+			medium: "gemini-3.5-flash-low",
+			high: "gemini-3-flash-agent",
+			xhigh: "gemini-3-flash-agent"
+		},
+		defaultRequestId: "gemini-3-flash-agent"
+	},
+	"gemini-3.1-pro": {
+		off: "gemini-3.1-pro-low",
+		routing: {
+			minimal: "gemini-3.1-pro-low",
+			low: "gemini-3.1-pro-low",
+			medium: "gemini-pro-agent",
+			high: "gemini-pro-agent",
+			xhigh: "gemini-pro-agent"
+		},
+		defaultRequestId: "gemini-pro-agent"
+	},
+	"gemini-3.1-flash-image": {
+		off: "gemini-3.1-flash-image",
+		routing: {
+			minimal: "gemini-3.1-flash-image",
+			low: "gemini-3.1-flash-image",
+			medium: "gemini-3.1-flash-image",
+			high: "gemini-3.1-flash-image",
+			xhigh: "gemini-3.1-flash-image"
+		},
+		defaultRequestId: "gemini-3.1-flash-image"
+	},
+	"gemini-3-flash": {
+		off: "gemini-3-flash",
+		routing: {
+			minimal: "gemini-3-flash",
+			low: "gemini-3-flash",
+			medium: "gemini-3-flash",
+			high: "gemini-3-flash",
+			xhigh: "gemini-3-flash"
+		},
+		defaultRequestId: "gemini-3-flash"
+	},
+	"gemini-2.5-pro": {
+		off: "gemini-2.5-pro",
+		routing: {
+			minimal: "gemini-2.5-pro",
+			low: "gemini-2.5-pro",
+			medium: "gemini-2.5-pro",
+			high: "gemini-2.5-pro",
+			xhigh: "gemini-2.5-pro"
+		},
+		defaultRequestId: "gemini-2.5-pro"
+	},
+	"gemini-2.5-flash": {
+		off: "gemini-2.5-flash",
+		routing: {
+			minimal: "gemini-2.5-flash",
+			low: "gemini-2.5-flash",
+			medium: "gemini-2.5-flash",
+			high: "gemini-2.5-flash",
+			xhigh: "gemini-2.5-flash"
+		},
+		defaultRequestId: "gemini-2.5-flash"
+	},
+	"gpt-oss-120b": {
+		off: "gpt-oss-120b-medium",
+		routing: {
+			minimal: "gpt-oss-120b-medium",
+			low: "gpt-oss-120b-medium",
+			medium: "gpt-oss-120b-medium",
+			high: "gpt-oss-120b-medium",
+			xhigh: "gpt-oss-120b-medium"
+		},
+		defaultRequestId: "gpt-oss-120b-medium"
+	}
+};
+const RUNTIME_MAX_OUTPUT_TOKENS = {
+	"gemini-3.8-flash": 65536,
+	"gemini-3.8-flash-tiered": 65536,
+	"gemini-3.7-flash": 65536,
+	"gemini-3.7-flash-tiered": 65536,
+	"gemini-3.7-flash-low": 65536,
+	"gemini-3.7-flash-medium": 65536,
+	"gemini-3.7-flash-high": 65536,
+	"gemini-3.6-flash": 65536,
+	"gemini-3.6-flash-low": 65536,
+	"gemini-3.6-flash-medium": 65536,
+	"gemini-3.6-flash-high": 65536,
+	"gemini-3.5-flash": 65536,
+	"gemini-3.5-flash-extra-low": 65536,
+	"gemini-3.5-flash-low": 65536,
+	"gemini-3-flash-agent": 65536,
+	"gemini-3.1-pro": 65535,
+	"gemini-3.1-pro-low": 65535,
+	"gemini-3.1-pro-high": 65535,
+	"gemini-pro-agent": 65535,
+	"claude-opus-4-6": 64e3,
+	"claude-opus-4-6-thinking": 64e3,
+	"claude-sonnet-4-6": 64e3,
+	"gpt-oss-120b": 32768,
+	"gpt-oss-120b-medium": 32768
+};
+const MODELS = [
+	{
+		id: "gemini-3.8-flash",
+		name: "Gemini 3.8 Flash",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 65536,
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high"
+		]
+	},
+	{
+		id: "gemini-3.7-flash",
+		name: "Gemini 3.7 Flash",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 65536,
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high"
+		]
+	},
+	{
+		id: "gemini-3.6-flash",
+		name: "Gemini 3.6 Flash",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 65536,
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high"
+		]
+	},
+	{
+		id: "gemini-3.5-flash",
+		name: "Gemini 3.5 Flash",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 65536,
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high"
+		]
+	},
+	{
+		id: "gemini-3.1-pro",
+		name: "Gemini 3.1 Pro",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 65535,
+		reasoningEfforts: ["low", "high"]
+	},
+	{
+		id: "gemini-3.1-flash-image",
+		name: "Gemini 3.1 Flash Image",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 8192
+	},
+	{
+		id: "gemini-3-flash",
+		name: "Gemini 3 Flash",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 65536
+	},
+	{
+		id: "gemini-2.5-pro",
+		name: "Gemini 2.5 Pro",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 65535
+	},
+	{
+		id: "gemini-2.5-flash",
+		name: "Gemini 2.5 Flash",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 65536
+	},
+	{
+		id: "claude-opus-4-6",
+		name: "Claude Opus 4.6",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 64e3,
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high"
+		]
+	},
+	{
+		id: "claude-sonnet-4-6",
+		name: "Claude Sonnet 4.6",
+		inputModalities: ["text", "image"],
+		contextWindow: 1048576,
+		maxTokens: 64e3,
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high"
+		]
+	},
+	{
+		id: "gpt-oss-120b",
+		name: "GPT-OSS 120B",
+		inputModalities: ["text"],
+		contextWindow: 262144,
+		maxTokens: 32768,
+		reasoningEfforts: [
+			"low",
+			"medium",
+			"high"
+		]
+	}
+];
+//#endregion
+//#region src/host/antigravity/token-store.ts
+const ANTIGRAVITY_PREFERENCES_NAMESPACE = "dsh-antigravity";
+function registerAntigravityPreferenceStore(settings, fallbackStore = new FileModelSettingsStore()) {
+	if (!settings) return {
+		status: () => ({
+			enabledModelIds: MODELS.map((m) => m.id),
+			catalogModels: [],
+			contextWindowOverrides: {},
+			defaultReasoningEffort: null
+		}),
+		update: async (patch) => fallbackStore.updateSettings(patch)
+	};
+	const ns = SettingsModule.settingsNamespace ? SettingsModule.settingsNamespace(ANTIGRAVITY_PREFERENCES_NAMESPACE) : ANTIGRAVITY_PREFERENCES_NAMESPACE;
+	const scope = settings.register.call(settings, ns, z.object({
+		enabledModelIds: z.array(z.string()).default(MODELS.map((m) => m.id)),
+		contextWindowOverrides: z.dict(z.number()).default({}),
+		defaultReasoningEffort: z.union([
+			z.const("low"),
+			z.const("medium"),
+			z.const("high"),
+			z.const(null)
+		]).default(null)
+	}));
+	return {
+		status: () => {
+			const val = scope.get();
+			return {
+				enabledModelIds: val.enabledModelIds,
+				catalogModels: [],
+				contextWindowOverrides: val.contextWindowOverrides,
+				defaultReasoningEffort: val.defaultReasoningEffort
+			};
+		},
+		update: async (patch) => {
+			const current = scope.get();
+			const normalized = {
+				enabledModelIds: patch.enabledModelIds ?? current.enabledModelIds,
+				contextWindowOverrides: patch.contextWindowOverrides ? {
+					...current.contextWindowOverrides,
+					...patch.contextWindowOverrides
+				} : current.contextWindowOverrides,
+				defaultReasoningEffort: patch.defaultReasoningEffort !== void 0 ? patch.defaultReasoningEffort : current.defaultReasoningEffort
+			};
+			await scope.update(normalized);
+			fallbackStore.updateSettings(patch).catch(() => void 0);
+			return {
+				...normalized,
+				catalogModels: []
+			};
+		}
+	};
+}
+function dshHomeDir() {
+	return process.env.DSH_HOME?.trim() || path.join(os.homedir(), ".dsh");
+}
+function credentialPath() {
+	return path.join(dshHomeDir(), "storages", "antigravity-oauth.json");
+}
+function modelSettingsPath() {
+	return path.join(dshHomeDir(), "storages", "antigravity-models.json");
+}
+var FileCredentialStore = class {
+	filePath;
+	constructor(filePath = credentialPath()) {
+		this.filePath = filePath;
+	}
+	path() {
+		return this.filePath;
+	}
+	async read() {
+		try {
+			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const parsed = JSON.parse(content);
+			if (typeof parsed === "object" && parsed !== null && ("access_token" in parsed || "access" in parsed)) return parsed;
+			return null;
+		} catch {
+			return null;
+		}
+	}
+	async write(credentials) {
+		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		const tmp = `${this.filePath}.tmp.${Date.now()}`;
+		await fsPromises.writeFile(tmp, JSON.stringify(credentials, null, 2), "utf8");
+		await fsPromises.rename(tmp, this.filePath);
+	}
+	async delete() {
+		try {
+			await fsPromises.unlink(this.filePath);
+		} catch (err) {
+			if (err.code !== "ENOENT") throw err;
+		}
+	}
+};
+var FileModelSettingsStore = class {
+	filePath;
+	constructor(filePath = modelSettingsPath()) {
+		this.filePath = filePath;
+	}
+	path() {
+		return this.filePath;
+	}
+	async read() {
+		try {
+			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const parsed = JSON.parse(content);
+			if (typeof parsed === "object" && parsed !== null) {
+				const record = parsed;
+				return {
+					enabledModelIds: Array.isArray(record.enabledModelIds) ? record.enabledModelIds.filter((id) => typeof id === "string") : MODELS.map((m) => m.id),
+					catalogModels: Array.isArray(record.catalogModels) ? record.catalogModels : [],
+					contextWindowOverrides: typeof record.contextWindowOverrides === "object" && record.contextWindowOverrides !== null ? record.contextWindowOverrides : {},
+					defaultReasoningEffort: record.defaultReasoningEffort === "low" || record.defaultReasoningEffort === "medium" || record.defaultReasoningEffort === "high" ? record.defaultReasoningEffort : null
+				};
+			}
+		} catch {}
+		return {
+			enabledModelIds: MODELS.map((m) => m.id),
+			catalogModels: [],
+			contextWindowOverrides: {},
+			defaultReasoningEffort: null
+		};
+	}
+	async write(settings) {
+		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		const tmp = `${this.filePath}.tmp.${Date.now()}`;
+		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fsPromises.rename(tmp, this.filePath);
+	}
+	async updateSettings(patch) {
+		const current = await this.read();
+		const next = {
+			...current,
+			...patch.enabledModelIds !== void 0 ? { enabledModelIds: patch.enabledModelIds } : {},
+			...patch.contextWindowOverrides !== void 0 ? { contextWindowOverrides: {
+				...current.contextWindowOverrides || {},
+				...patch.contextWindowOverrides
+			} } : {},
+			...patch.defaultReasoningEffort !== void 0 ? { defaultReasoningEffort: patch.defaultReasoningEffort } : {}
+		};
+		await this.write(next);
+		return next;
+	}
+	async setEnabledModelIds(enabledModelIds) {
+		return this.updateSettings({ enabledModelIds });
+	}
+	async setCatalogModels(catalogModels, options) {
+		const current = await this.read();
+		const next = {
+			...current,
+			enabledModelIds: options?.enabledModelIds ?? current.enabledModelIds,
+			catalogModels
+		};
+		await this.write(next);
+		return next;
+	}
+};
+//#endregion
+//#region src/host/antigravity/client.ts
+const projectCache = /* @__PURE__ */ new Map();
+let cachedQuota;
+const PLATFORM = process.platform === "darwin" ? "MACOS" : process.platform === "win32" ? "WINDOWS" : "LINUX";
+function defaultUserAgent() {
+	return `antigravity/1.15.8 ${process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "windows" : "linux"}/${process.arch === "x64" ? "amd64" : process.arch}`;
+}
+function antigravityHeaders(token) {
+	return {
+		Authorization: `Bearer ${token}`,
+		"Content-Type": "application/json",
+		Accept: "text/event-stream",
+		"User-Agent": process.env.DSH_ANTIGRAVITY_USER_AGENT || defaultUserAgent(),
+		"X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+		"Client-Metadata": JSON.stringify({
+			ideType: "ANTIGRAVITY",
+			platform: PLATFORM,
+			pluginType: "GEMINI"
+		})
+	};
+}
+function jsonHeaders(token) {
+	return {
+		...antigravityHeaders(token),
+		Accept: "application/json"
+	};
+}
+function endpointCandidates() {
+	const custom = process.env.DSH_ANTIGRAVITY_ENDPOINT?.trim();
+	if (custom) return [custom];
+	return ENDPOINT_FALLBACKS;
+}
+function extractProjectId(data) {
+	if (typeof data !== "object" || data === null) return void 0;
+	const record = data;
+	const direct = record.antigravityProjectId ?? record.projectId ?? record.backendProjectId ?? record.userDefinedCloudaicompanionProject ?? record.cloudaicompanionProject ?? record.project;
+	if (typeof direct === "string" && direct.length > 0) return direct;
+	if (typeof direct === "object" && direct !== null && "id" in direct && typeof direct.id === "string") return direct.id;
+	for (const key of [
+		"projects",
+		"projectIds",
+		"cloudaicompanionProjects"
+	]) {
+		const list = record[key];
+		if (Array.isArray(list)) for (const item of list) {
+			const nested = extractProjectId(item);
+			if (nested) return nested;
+			if (typeof item === "string" && item.length > 0) return item;
+		}
+	}
+}
+async function listCloudAICompanionProjects(token) {
+	for (const endpoint of endpointCandidates()) try {
+		const response = await fetch(`${endpoint}/v1internal:listCloudAICompanionProjects`, {
+			method: "POST",
+			headers: antigravityHeaders(token),
+			body: JSON.stringify({}),
+			signal: AbortSignal.timeout(DISCOVERY_TIMEOUT_MS)
+		});
+		if (!response.ok) continue;
+		return extractProjectId(await response.json());
+	} catch {}
+}
+async function loadCodeAssist(token) {
+	const cached = projectCache.get(token);
+	if (cached && cached.expiresAt > Date.now()) return cached.projectId;
+	const body = JSON.stringify({ metadata: {
+		ideType: "ANTIGRAVITY",
+		platform: "PLATFORM_UNSPECIFIED",
+		pluginType: "GEMINI"
+	} });
+	for (const endpoint of endpointCandidates()) try {
+		const response = await fetch(`${endpoint}/v1internal:loadCodeAssist`, {
+			method: "POST",
+			headers: antigravityHeaders(token),
+			body,
+			signal: AbortSignal.timeout(DISCOVERY_TIMEOUT_MS)
+		});
+		if (!response.ok) continue;
+		const project = extractProjectId(await response.json());
+		if (project) {
+			projectCache.set(token, {
+				projectId: project,
+				expiresAt: Date.now() + PROJECT_CACHE_TTL_MS
+			});
+			return project;
+		}
+		const listProj = await listCloudAICompanionProjects(token);
+		if (listProj) {
+			projectCache.set(token, {
+				projectId: listProj,
+				expiresAt: Date.now() + PROJECT_CACHE_TTL_MS
+			});
+			return listProj;
+		}
+	} catch {}
+}
+async function postJson(path, token, body) {
+	for (const endpoint of endpointCandidates()) try {
+		const response = await fetch(`${endpoint}${path}`, {
+			method: "POST",
+			headers: jsonHeaders(token),
+			body: JSON.stringify(body)
+		});
+		if (response.ok) return {
+			endpoint,
+			status: response.status,
+			data: await response.json()
+		};
+	} catch {}
+	throw new Error(`Failed to call Antigravity API ${path}`);
+}
+function parseQuotaSummary(data) {
+	const summary = typeof data === "object" && data !== null ? data : {};
+	const rawGroups = Array.isArray(summary.groups) ? summary.groups : [];
+	const groups = [];
+	for (const group of rawGroups) {
+		if (typeof group !== "object" || group === null) continue;
+		const groupRec = group;
+		const buckets = [];
+		const rawBuckets = Array.isArray(groupRec.buckets) ? groupRec.buckets : [];
+		for (const bucket of rawBuckets) {
+			if (typeof bucket !== "object" || bucket === null) continue;
+			const bRec = bucket;
+			const remaining = typeof bRec.remainingFraction === "number" ? Math.max(0, Math.min(1, bRec.remainingFraction)) : 0;
+			buckets.push({
+				bucketId: String(bRec.bucketId || bRec.displayName || "limit"),
+				displayName: String(bRec.displayName || bRec.bucketId || "Limit"),
+				window: typeof bRec.window === "string" ? bRec.window : void 0,
+				resetTime: typeof bRec.resetTime === "string" ? bRec.resetTime : void 0,
+				description: typeof bRec.description === "string" ? bRec.description : void 0,
+				remainingFraction: remaining
+			});
+		}
+		if (buckets.length > 0 || groupRec.displayName) groups.push({
+			displayName: String(groupRec.displayName || "Quota group"),
+			description: typeof groupRec.description === "string" ? groupRec.description : void 0,
+			buckets
+		});
+	}
+	return {
+		groups,
+		description: typeof summary.description === "string" ? summary.description : void 0
+	};
+}
+function parseCatalogModels(data) {
+	if (typeof data !== "object" || data === null) return [];
+	const record = data;
+	const rawModels = typeof record.models === "object" && record.models !== null ? record.models : {};
+	const list = [];
+	for (const [modelId, info] of Object.entries(rawModels)) {
+		if (typeof info !== "object" || info === null) continue;
+		const rec = info;
+		if (rec.isInternal || modelId.startsWith("chat_")) continue;
+		list.push({
+			id: modelId,
+			name: typeof rec.displayName === "string" ? rec.displayName : modelId,
+			description: typeof rec.description === "string" ? rec.description : void 0
+		});
+	}
+	return list;
+}
+async function fetchAccountQuota(store = new FileCredentialStore(), modelSettings) {
+	const { token, projectId: credentialProjectId } = await ensureApiKey(store);
+	const [assistResult, summaryResult] = await Promise.all([postJson("/v1internal:loadCodeAssist", token, { metadata: {
+		ideType: "ANTIGRAVITY",
+		platform: "PLATFORM_UNSPECIFIED",
+		pluginType: "GEMINI"
+	} }).catch(() => null), postJson("/v1internal:retrieveUserQuotaSummary", token, {}).catch(() => null)]);
+	const discoveredProject = assistResult ? extractProjectId(assistResult.data) : void 0;
+	const projectId = credentialProjectId || discoveredProject || "antigravity-default";
+	const modelsData = (await postJson("/v1internal:fetchAvailableModels", token, { project: projectId }).catch(() => null))?.data;
+	const { groups, description } = summaryResult ? parseQuotaSummary(summaryResult.data) : { groups: [] };
+	const catalogModels = modelsData ? parseCatalogModels(modelsData) : [];
+	const assistData = assistResult?.data || {};
+	const currentTier = assistData.currentTier;
+	const paidTier = assistData.paidTier;
+	const planLabel = paidTier?.name || currentTier?.name || void 0;
+	cachedQuota = {
+		projectId,
+		endpoint: summaryResult?.endpoint || "https://cloudcode-pa.googleapis.com",
+		planLabel,
+		productTier: currentTier,
+		paidTier,
+		groups,
+		groupDescription: description,
+		models: catalogModels.map((m) => ({
+			modelId: m.id,
+			displayName: m.name,
+			description: m.description
+		})),
+		catalogModels,
+		fetchedAt: Date.now()
+	};
+	if (modelSettings && catalogModels.length > 0) {
+		const current = await modelSettings.read();
+		const isFirstTime = current.catalogModels.length === 0 && current.enabledModelIds.length === 0;
+		const catalogIds = new Set(catalogModels.map((m) => m.id));
+		const mergedEnabled = isFirstTime ? catalogModels.map((m) => m.id) : current.enabledModelIds.filter((id) => catalogIds.has(id));
+		await modelSettings.setCatalogModels(catalogModels, { enabledModelIds: mergedEnabled });
+	}
+	return cachedQuota;
+}
+function getCachedQuota() {
+	return cachedQuota;
+}
+//#endregion
+//#region src/host/antigravity/oauth.ts
+let webLoginFlow = { status: "idle" };
+function antigravityEnv(namePart) {
+	const full = `DSH_ANTIGRAVITY_${namePart}`;
+	return process.env[full];
+}
+function callbackPort() {
+	const configured = Number(antigravityEnv("CALLBACK_PORT"));
+	if (Number.isInteger(configured) && configured > 0 && configured <= 65535) return configured;
+	return 51121;
+}
+function resolveCallbackHost(raw = antigravityEnv("CALLBACK_HOST")) {
+	const host = (raw || "localhost").trim().toLowerCase();
+	if (host === "localhost" || host === "127.0.0.1" || host === "::1") return host;
+	return "localhost";
+}
+function redirectUri() {
+	return `http://${resolveCallbackHost()}:${callbackPort()}${"/oauth-callback".startsWith("/"), REDIRECT_PATH}`;
+}
+function clientId() {
+	return antigravityEnv("CLIENT_ID")?.trim() || DEFAULT_CLIENT_ID;
+}
+function clientSecret() {
+	return antigravityEnv("CLIENT_SECRET")?.trim() || DEFAULT_CLIENT_SECRET;
+}
+function base64Url(buffer) {
+	return buffer.toString("base64url");
+}
+function generatePKCE() {
+	const verifier = base64Url(randomBytes(32));
+	return {
+		verifier,
+		challenge: base64Url(createHash("sha256").update(verifier).digest())
+	};
+}
+function escapeHtml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeOAuthProviderError(text) {
+	return escapeHtml(text.slice(0, 300).replace(/[\r\n\t]+/g, " "));
+}
+function openBrowser(url) {
+	try {
+		if (process.platform === "darwin") spawn("open", [url], {
+			stdio: "ignore",
+			detached: true
+		});
+		else if (process.platform === "win32") spawn("cmd", [
+			"/c",
+			"start",
+			"",
+			url
+		], {
+			stdio: "ignore",
+			detached: true
+		});
+		else spawn("xdg-open", [url], {
+			stdio: "ignore",
+			detached: true
+		});
+	} catch {}
+}
+async function getUserEmail(token) {
+	try {
+		const response = await fetch("https://www.googleapis.com/oauth2/v1/userinfo?alt=json", { headers: { Authorization: `Bearer ${token}` } });
+		if (!response.ok) return void 0;
+		const data = await response.json();
+		return typeof data.email === "string" ? data.email : void 0;
+	} catch {
+		return;
+	}
+}
+function startCallbackServer(expectedState) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let timeout;
+		let resolveCode;
+		let rejectCode;
+		const codePromise = new Promise((res, rej) => {
+			resolveCode = res;
+			rejectCode = rej;
+		});
+		const finish = (fn) => {
+			if (settled) return;
+			settled = true;
+			if (timeout) clearTimeout(timeout);
+			fn();
+		};
+		const callbackUrl = redirectUri();
+		const server = createServer((request, response) => {
+			if (request.method !== "GET" && request.method !== "HEAD") {
+				response.writeHead(405, { "Content-Type": "text/plain; charset=utf-8" });
+				response.end("Method Not Allowed");
+				return;
+			}
+			const url = new URL$1(request.url || "", callbackUrl);
+			if (url.pathname !== "/oauth-callback") {
+				response.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+				response.end("Antigravity OAuth callback route not found.");
+				return;
+			}
+			const providerError = url.searchParams.get("error");
+			const code = url.searchParams.get("code");
+			const state = url.searchParams.get("state");
+			if (providerError) {
+				const safe = escapeHtml(providerError.slice(0, 200));
+				response.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+				response.end(`Antigravity authentication failed: ${safe}`);
+				finish(() => rejectCode(/* @__PURE__ */ new Error(`OAuth error: ${providerError.slice(0, 200)}`)));
+				return;
+			}
+			if (!code || !state) {
+				response.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+				response.end("Antigravity authentication failed: missing code or state.");
+				finish(() => rejectCode(/* @__PURE__ */ new Error("Missing code or state in OAuth callback")));
+				return;
+			}
+			if (state !== expectedState) {
+				response.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+				response.end("Antigravity authentication failed: invalid state.");
+				finish(() => rejectCode(/* @__PURE__ */ new Error("OAuth state mismatch")));
+				return;
+			}
+			response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+			response.end("Antigravity authentication complete. You can close this window and return to DSH.");
+			finish(() => resolveCode({
+				code,
+				state
+			}));
+		});
+		server.on("error", reject);
+		server.listen(callbackPort(), resolveCallbackHost(), () => {
+			timeout = setTimeout(() => {
+				finish(() => rejectCode(/* @__PURE__ */ new Error("OAuth callback timed out waiting for browser login")));
+				server.close();
+			}, OAUTH_CALLBACK_TIMEOUT_MS);
+			resolve({
+				server,
+				waitForCode: () => codePromise
+			});
+		});
+	});
+}
+async function exchangeOAuthCode(code, verifier, callbackUrl) {
+	const tokenResponse = await fetch(TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams$1({
+			client_id: clientId(),
+			client_secret: clientSecret(),
+			code,
+			grant_type: "authorization_code",
+			redirect_uri: callbackUrl,
+			code_verifier: verifier
+		}).toString()
+	});
+	if (!tokenResponse.ok) throw new Error(`Token exchange failed: ${sanitizeOAuthProviderError(await tokenResponse.text())}`);
+	const tokenData = await tokenResponse.json();
+	const refreshToken = typeof tokenData.refresh_token === "string" ? tokenData.refresh_token : void 0;
+	const accessToken = typeof tokenData.access_token === "string" ? tokenData.access_token : "";
+	const expiresIn = typeof tokenData.expires_in === "number" ? tokenData.expires_in : 3600;
+	if (!refreshToken) throw new Error("No refresh token received. Re-run login and allow offline access.");
+	const [email, discoveredProject] = await Promise.all([getUserEmail(accessToken), loadCodeAssist(accessToken).catch(() => void 0)]);
+	return {
+		refresh: refreshToken,
+		refresh_token: refreshToken,
+		access: accessToken,
+		access_token: accessToken,
+		expires: Date.now() + expiresIn * 1e3 - 300 * 1e3,
+		expires_at: Date.now() + expiresIn * 1e3 - 300 * 1e3,
+		projectId: discoveredProject || void 0,
+		email
+	};
+}
+async function beginWebLogin(store) {
+	if (webLoginFlow.status === "pending") return { ...webLoginFlow };
+	const { verifier, challenge } = generatePKCE();
+	const state = base64Url(randomBytes(32));
+	const { server, waitForCode } = await startCallbackServer(state);
+	const callbackUrl = redirectUri();
+	webLoginFlow = {
+		status: "pending",
+		authUrl: `${AUTH_URL}?${new URLSearchParams$1({
+			client_id: clientId(),
+			response_type: "code",
+			redirect_uri: callbackUrl,
+			scope: SCOPES.join(" "),
+			code_challenge: challenge,
+			code_challenge_method: "S256",
+			state,
+			access_type: "offline",
+			prompt: "consent"
+		}).toString()}`,
+		startedAt: Date.now(),
+		error: void 0
+	};
+	(async () => {
+		try {
+			const { code, state: returnedState } = await waitForCode();
+			if (returnedState !== state) throw new Error("OAuth state mismatch");
+			const credentials = await exchangeOAuthCode(code, verifier, callbackUrl);
+			await store.write(credentials);
+			webLoginFlow.status = "complete";
+			webLoginFlow.email = credentials.email;
+			webLoginFlow.completedAt = Date.now();
+		} catch (error) {
+			webLoginFlow.status = "error";
+			webLoginFlow.error = error instanceof Error ? error.message : String(error);
+			webLoginFlow.completedAt = Date.now();
+		} finally {
+			server.close();
+		}
+	})();
+	return { ...webLoginFlow };
+}
+function getWebLoginStatus() {
+	return { ...webLoginFlow };
+}
+async function refreshAntigravityToken(credentials) {
+	const refreshToken = credentials.refresh || credentials.refresh_token;
+	if (!refreshToken) throw new Error("Missing Antigravity refresh token.");
+	const response = await fetch(TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams$1({
+			client_id: clientId(),
+			client_secret: clientSecret(),
+			refresh_token: refreshToken,
+			grant_type: "refresh_token"
+		}).toString()
+	});
+	if (!response.ok) throw new Error(`Token refresh failed: ${sanitizeOAuthProviderError(await response.text())}`);
+	const data = await response.json();
+	const accessToken = typeof data.access_token === "string" ? data.access_token : "";
+	const expiresIn = typeof data.expires_in === "number" ? data.expires_in : 3600;
+	const nextRefreshToken = typeof data.refresh_token === "string" ? data.refresh_token : refreshToken;
+	return {
+		...credentials,
+		refresh: nextRefreshToken,
+		refresh_token: nextRefreshToken,
+		access: accessToken,
+		access_token: accessToken,
+		expires: Date.now() + expiresIn * 1e3 - 300 * 1e3,
+		expires_at: Date.now() + expiresIn * 1e3 - 300 * 1e3
+	};
+}
+async function ensureApiKey(store) {
+	let credentials = await store.read();
+	if (!credentials) throw new Error("Not logged into Antigravity. Please log in from Settings > Antigravity.");
+	const expires = credentials.expires || credentials.expires_at || 0;
+	if (!(credentials.access || credentials.access_token) || expires <= Date.now() + 6e4) {
+		credentials = await refreshAntigravityToken(credentials);
+		await store.write(credentials);
+	}
+	return {
+		token: credentials.access || credentials.access_token,
+		projectId: credentials.projectId
+	};
+}
+async function loginAndSave(store, signal, onUrl) {
+	const { verifier, challenge } = generatePKCE();
+	const state = base64Url(randomBytes(32));
+	const { server, waitForCode } = await startCallbackServer(state);
+	const callbackUrl = redirectUri();
+	const authUrl = `${AUTH_URL}?${new URLSearchParams$1({
+		client_id: clientId(),
+		response_type: "code",
+		redirect_uri: callbackUrl,
+		scope: SCOPES.join(" "),
+		code_challenge: challenge,
+		code_challenge_method: "S256",
+		state,
+		access_type: "offline",
+		prompt: "consent"
+	}).toString()}`;
+	try {
+		if (onUrl) onUrl(authUrl);
+		openBrowser(authUrl);
+		if (signal?.aborted) throw new Error("OAuth login aborted");
+		const { code, state: returnedState } = await waitForCode();
+		if (returnedState !== state) throw new Error("OAuth state mismatch");
+		const credentials = await exchangeOAuthCode(code, verifier, callbackUrl);
+		await store.write(credentials);
+		return credentials;
+	} finally {
+		server.close();
+	}
+}
+//#endregion
+//#region src/host/antigravity/mapper.ts
+let toolCallCounter = 0;
+function sanitizeText(text) {
+	return text.replace(/\0/g, "");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function safeJsonParse(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+function sanitizeToolCallId(id, fallbackName) {
+	return String(id || "").replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || `${fallbackName || "tool"}_${Date.now()}_${++toolCallCounter}`;
+}
+function toolCallIdNeeded(modelId, runtimeModel) {
+	return modelId.startsWith("claude-") || modelId.startsWith("gpt-oss-") || runtimeModel.startsWith("claude-") || runtimeModel.startsWith("gpt-oss-");
+}
+function parseArguments(raw) {
+	if (isRecord(raw)) return raw;
+	if (raw === void 0 || raw === null || raw === "") return {};
+	const parsed = typeof raw === "string" ? safeJsonParse(raw) : raw;
+	return isRecord(parsed) ? parsed : {};
+}
+function imageBlockToPart(block) {
+	let data = asString(block.data) || asString(block.base64);
+	const source = isRecord(block.source) ? block.source : void 0;
+	if (!data && source) data = asString(source.data) || asString(source.base64);
+	let mimeType = asString(block.mimeType) || asString(block.mediaType) || (source ? asString(source.mimeType) || asString(source.mediaType) : void 0) || "image/png";
+	if (data?.startsWith("data:")) {
+		const match = data.match(/^data:([^;,]+);base64,(.*)$/s);
+		if (match) {
+			mimeType = match[1] || mimeType;
+			data = match[2] || "";
+		}
+	}
+	return data ? { inlineData: {
+		mimeType,
+		data
+	} } : void 0;
+}
+function contentToUserParts(content) {
+	if (typeof content === "string") return [{ text: sanitizeText(content) }];
+	if (!Array.isArray(content)) return [];
+	const parts = [];
+	for (const block of content) if (isRecord(block) && block.type === "text" && typeof block.text === "string") parts.push({ text: sanitizeText(block.text) });
+	else if (isRecord(block) && block.type === "image") {
+		const img = imageBlockToPart(block);
+		if (img) parts.push(img);
+	}
+	return parts;
+}
+function toolResultText(blocks) {
+	if (!Array.isArray(blocks)) return "";
+	return blocks.map((block) => {
+		if (!isRecord(block)) return "";
+		if (block.type === "text" && typeof block.text === "string") return sanitizeText(block.text);
+		if (block.type === "tool-result") return toolResultText(block.content);
+		return "";
+	}).join("");
+}
+function replayBlockFor(message, index) {
+	const source = message.source;
+	if (!source || source.kind !== "model") return void 0;
+	const state = source.replayState;
+	if (!isRecord(state)) return void 0;
+	const resp = isRecord(state.response) ? state.response : void 0;
+	if (resp) {
+		if (Array.isArray(resp.outputItems)) return resp.outputItems[index];
+		if (Array.isArray(resp.blocks)) return resp.blocks[index];
+	}
+	if (Array.isArray(state.blocks)) return state.blocks[index];
+}
+function assistantParts(message, model, runtimeModel, toolNames) {
+	const parts = [];
+	if (!Array.isArray(message.content)) return parts;
+	for (let index = 0; index < message.content.length; index++) {
+		const block = message.content[index];
+		if (!isRecord(block)) continue;
+		const replay = replayBlockFor(message, index);
+		if (block.type === "text" && String(block.text || "").trim()) parts.push({ text: sanitizeText(String(block.text)) });
+		else if (block.type === "reasoning" && String(block.text || "").trim()) {
+			const sig = asString(replay?.thinkingSignature) || asString(replay?.thought_signature) || asString(block.thought_signature);
+			if (sig) parts.push({
+				thought: true,
+				text: sanitizeText(String(block.text)),
+				thought_signature: sig,
+				thoughtSignature: sig
+			});
+			else parts.push({ text: sanitizeText(String(block.text)) });
+		} else if (block.type === "tool-call") {
+			const toolId = String(block.id || "");
+			const toolName = String(block.name || "");
+			toolNames.set(toolId, toolName);
+			const sig = asString(replay?.thought_signature) || asString(replay?.thoughtSignature) || asString(block.thought_signature) || asString(block.thoughtSignature) || "skip_thought_signature_validator";
+			parts.push({
+				functionCall: {
+					name: toolName,
+					args: parseArguments(block.arguments),
+					...toolCallIdNeeded(model.id, runtimeModel) ? { id: sanitizeToolCallId(toolId, toolName) } : {}
+				},
+				thought_signature: sig,
+				thoughtSignature: sig
+			});
+		}
+	}
+	return parts;
+}
+function pushToolResult(contents, result, toolNames, model, runtimeModel) {
+	const toolCallId = String(result.toolCallId || "");
+	const toolName = toolNames.get(toolCallId) || "unknown";
+	const responseText = toolResultText(result.content) || (result.isError ? "Tool failed" : "");
+	const part = { functionResponse: {
+		name: toolName,
+		response: result.isError ? { error: responseText } : { output: responseText },
+		...toolCallIdNeeded(model.id, runtimeModel) ? { id: sanitizeToolCallId(toolCallId, toolName) } : {}
+	} };
+	const last = contents[contents.length - 1];
+	if (last?.role === GEMINI_ROLE.user && last.parts.some((entry) => "functionResponse" in entry)) last.parts.push(part);
+	else contents.push({
+		role: GEMINI_ROLE.user,
+		parts: [part]
+	});
+}
+function convertMessages(options, model, runtimeModel) {
+	const contents = [];
+	const toolNames = /* @__PURE__ */ new Map();
+	for (const message of options.messages) {
+		const role = message.role || (message.source?.kind === "model" ? "assistant" : "user");
+		if (role === "assistant" || message.source?.kind === "model") {
+			const parts = assistantParts(message, model, runtimeModel, toolNames);
+			if (parts.length) contents.push({
+				role: GEMINI_ROLE.model,
+				parts
+			});
+			continue;
+		}
+		const content = Array.isArray(message.content) ? message.content : [];
+		const userParts = contentToUserParts(content.filter((b) => !isRecord(b) || b.type !== "tool-result"));
+		if (role === "system") {
+			if (userParts.length) contents.push({
+				role: GEMINI_ROLE.user,
+				parts: userParts
+			});
+			continue;
+		}
+		if (userParts.length) contents.push({
+			role: GEMINI_ROLE.user,
+			parts: userParts
+		});
+		for (const b of content) if (isRecord(b) && b.type === "tool-result") pushToolResult(contents, b, toolNames, model, runtimeModel);
+	}
+	return contents;
+}
+function stripMetaSchema(schema) {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
+	const omit = /* @__PURE__ */ new Set([
+		"$schema",
+		"$id",
+		"$anchor",
+		"$dynamicAnchor",
+		"$vocabulary",
+		"$comment",
+		"$defs",
+		"definitions"
+	]);
+	const out = {};
+	for (const [k, v] of Object.entries(schema)) if (!omit.has(k)) out[k] = stripMetaSchema(v);
+	return out;
+}
+function convertTools(tools) {
+	if (!tools || tools.length === 0) return void 0;
+	return [{ functionDeclarations: tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description || "",
+		parameters: stripMetaSchema(tool.parameters) || {
+			type: "object",
+			properties: {}
+		}
+	})) }];
+}
+function mapToolChoiceMode(toolChoice) {
+	if (toolChoice === "none") return TOOL_CALLING_MODE.none;
+	if (toolChoice === "any" || toolChoice === "required") return TOOL_CALLING_MODE.any;
+	return TOOL_CALLING_MODE.auto;
+}
+function getMaxOutputTokens(modelId, runtimeModel) {
+	return RUNTIME_MAX_OUTPUT_TOKENS[runtimeModel] || RUNTIME_MAX_OUTPUT_TOKENS[modelId] || 65536;
+}
+function buildRequest(options, model, projectId, runtimeModel, effort) {
+	const request = {
+		contents: convertMessages(options, model, runtimeModel),
+		systemInstruction: {
+			role: GEMINI_ROLE.user,
+			parts: [
+				{ text: ANTIGRAVITY_SYSTEM_INSTRUCTION },
+				{ text: `Please ignore following [ignore]${ANTIGRAVITY_SYSTEM_INSTRUCTION}[/ignore]` },
+				{ text: ANTIGRAVITY_NO_PREAMBLE_INSTRUCTION },
+				...options.system ? [{ text: sanitizeText(options.system) }] : []
+			]
+		}
+	};
+	const generationConfig = {};
+	if (options.temperature !== void 0) generationConfig.temperature = options.temperature;
+	if (runtimeModel === "gemini-3.8-flash-tiered" || runtimeModel === "gemini-3.7-flash-tiered") {
+		const selected = effort || "off";
+		generationConfig.thinkingConfig = { thinkingLevel: selected === "high" || selected === "xhigh" ? "HIGH" : selected === "medium" ? "MEDIUM" : "LOW" };
+	}
+	const maxAllowed = getMaxOutputTokens(model.id, runtimeModel);
+	generationConfig.maxOutputTokens = options.maxTokens !== void 0 ? Math.min(options.maxTokens, maxAllowed) : maxAllowed;
+	request.generationConfig = generationConfig;
+	const toolChoice = options.toolChoice;
+	const tools = convertTools(options.tools);
+	if (tools) {
+		request.tools = tools;
+		if (toolChoice) request.toolConfig = { functionCallingConfig: { mode: mapToolChoiceMode(toolChoice) } };
+	}
+	if (options.sessionId) request.sessionId = String(options.sessionId);
+	return {
+		project: projectId,
+		model: runtimeModel,
+		request,
+		requestType: "agent",
+		userAgent: "antigravity",
+		requestId: `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+	};
+}
+function createStreamState() {
+	return {
+		blocks: [],
+		replayBlocks: [],
+		currentBlock: null,
+		hasContent: false,
+		hasToolCall: false
+	};
+}
+function processStreamLine(line, state) {
+	if (!line.startsWith("data:")) return [];
+	const json = line.slice(5).trim();
+	if (!json || json === "[DONE]") return [];
+	const chunk = safeJsonParse(json);
+	if (!isRecord(chunk)) return [];
+	const responseData = isRecord(chunk.response) ? chunk.response : chunk;
+	const candidate = (Array.isArray(responseData.candidates) ? responseData.candidates : [])[0];
+	const content = isRecord(candidate?.content) ? candidate.content : void 0;
+	const parts = Array.isArray(content?.parts) ? content.parts : [];
+	const out = [];
+	const closeCurrentBlock = () => {
+		if (!state.currentBlock) return;
+		const index = state.blocks.length - 1;
+		if (state.currentBlock.type === "text") out.push({
+			type: "block-end",
+			index,
+			block: {
+				type: "text",
+				text: state.currentBlock.text
+			}
+		});
+		else out.push({
+			type: "block-end",
+			index,
+			block: {
+				type: "reasoning",
+				text: state.currentBlock.text
+			}
+		});
+		state.currentBlock = null;
+	};
+	for (const part of parts) {
+		if (!isRecord(part)) continue;
+		if (part.text !== void 0 && typeof part.text === "string") {
+			const isThinking = part.thought === true;
+			const blockType = isThinking ? "reasoning" : "text";
+			if (!state.currentBlock || state.currentBlock.type !== blockType) {
+				closeCurrentBlock();
+				state.currentBlock = {
+					type: blockType,
+					text: ""
+				};
+				const index = state.blocks.length;
+				state.blocks.push({
+					type: blockType,
+					text: ""
+				});
+				state.replayBlocks.push({ type: blockType });
+				out.push({
+					type: "block-start",
+					index,
+					blockType
+				});
+			}
+			const delta = sanitizeText(part.text);
+			state.currentBlock.text += delta;
+			state.hasContent = true;
+			if (isThinking && part.thoughtSignature) {
+				state.currentBlock.thinkingSignature = part.thoughtSignature;
+				state.replayBlocks[state.blocks.length - 1].thinkingSignature = part.thoughtSignature;
+			} else if (!isThinking && part.thoughtSignature) {
+				state.currentBlock.textSignature = part.thoughtSignature;
+				state.replayBlocks[state.blocks.length - 1].textSignature = part.thoughtSignature;
+			}
+			out.push({
+				type: isThinking ? "reasoning-delta" : "text-delta",
+				index: state.blocks.length - 1,
+				text: delta
+			});
+		}
+		if (isRecord(part.functionCall)) {
+			closeCurrentBlock();
+			const fc = part.functionCall;
+			const toolName = asString(fc.name) || "";
+			const toolId = sanitizeToolCallId(asString(fc.id) || "", toolName);
+			const argsText = JSON.stringify(isRecord(fc.args) ? fc.args : {});
+			const index = state.blocks.length;
+			const sig = asString(part.thought_signature) || asString(part.thoughtSignature) || asString(part.thinkingSignature) || asString(fc.thought_signature) || asString(fc.thoughtSignature) || state.currentBlock?.thinkingSignature;
+			const block = {
+				type: "tool-call",
+				id: toolId,
+				name: toolName,
+				arguments: argsText,
+				...sig ? {
+					thought_signature: sig,
+					thoughtSignature: sig
+				} : {}
+			};
+			state.blocks.push(block);
+			state.replayBlocks.push({
+				type: "tool-call",
+				...sig ? {
+					thought_signature: sig,
+					thoughtSignature: sig
+				} : {}
+			});
+			state.hasContent = true;
+			state.hasToolCall = true;
+			out.push({
+				type: "block-start",
+				index,
+				blockType: "tool-call"
+			});
+			out.push({
+				type: "tool-call-delta",
+				index,
+				id: toolId,
+				name: toolName,
+				argumentsDelta: argsText
+			});
+			out.push({
+				type: "block-end",
+				index,
+				block
+			});
+		}
+	}
+	if (responseData.usageMetadata && isRecord(responseData.usageMetadata)) {
+		const u = responseData.usageMetadata;
+		const usage = {
+			inputTokens: Math.max(0, (u.promptTokenCount || 0) - (u.cachedContentTokenCount || 0)),
+			outputTokens: (u.candidatesTokenCount || 0) + (u.thoughtsTokenCount || 0),
+			...u.cachedContentTokenCount ? { cacheReadTokens: u.cachedContentTokenCount } : {}
+		};
+		out.push({
+			type: "usage",
+			usage
+		});
+	}
+	const finishReason = candidate?.finishReason;
+	if (finishReason) {
+		closeCurrentBlock();
+		const reason = state.hasToolCall ? { kind: "tool-calls" } : finishReason === "MAX_TOKENS" ? { kind: "max-tokens" } : { kind: "stop" };
+		out.push({
+			type: "finish",
+			reason,
+			replayState: { response: {
+				outputItems: state.replayBlocks,
+				blocks: state.replayBlocks
+			} }
+		});
+	}
+	return out;
+}
+function closeStream(state) {
+	const out = [];
+	if (state.currentBlock) {
+		const index = state.blocks.length - 1;
+		if (state.currentBlock.type === "text") out.push({
+			type: "block-end",
+			index,
+			block: {
+				type: "text",
+				text: state.currentBlock.text
+			}
+		});
+		else out.push({
+			type: "block-end",
+			index,
+			block: {
+				type: "reasoning",
+				text: state.currentBlock.text
+			}
+		});
+		state.currentBlock = null;
+	}
+	return out;
+}
+//#endregion
+//#region src/host/antigravity/adapter.ts
+var AntigravityAdapter = class extends LlmAdapter {
+	store;
+	modelSettings;
+	preferences;
+	constructor(store = new FileCredentialStore(), modelSettings = new FileModelSettingsStore(), preferences) {
+		super();
+		this.store = store;
+		this.modelSettings = modelSettings;
+		this.preferences = preferences;
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: PROVIDER_NAME
+		};
+	}
+	async listModels(provider) {
+		const prov = provider || "antigravity";
+		const settings = this.preferences ? this.preferences.status() : await this.modelSettings.read();
+		const enabledSet = new Set(settings.enabledModelIds);
+		const available = MODELS.filter((m) => enabledSet.has(m.id));
+		const overrides = settings.contextWindowOverrides || {};
+		return available.map((model) => ({
+			provider: prov,
+			id: model.id,
+			name: model.name,
+			inputModalities: model.inputModalities,
+			context: { contextWindow: overrides[model.id] || model.contextWindow },
+			defaultMaxTokens: model.maxTokens,
+			...model.reasoningEfforts ? { reasoningEfforts: model.reasoningEfforts } : {}
+		}));
+	}
+	async resolveModel(provider, modelId, signal) {
+		if (signal?.aborted) throw new LlmError("antigravity model resolution aborted", "ABORTED");
+		const model = MODELS.find((m) => m.id === modelId) || {
+			id: modelId,
+			name: modelId,
+			inputModalities: ["text", "image"],
+			contextWindow: 128e3,
+			maxTokens: 65536
+		};
+		const settings = this.preferences ? this.preferences.status() : await this.modelSettings.read();
+		const overrides = settings.contextWindowOverrides || {};
+		const efforts = model.reasoningEfforts || [
+			"low",
+			"medium",
+			"high"
+		];
+		const defaultEffort = settings.defaultReasoningEffort || "medium";
+		return {
+			provider,
+			id: model.id,
+			name: model.name,
+			inputModalities: model.inputModalities,
+			context: { contextWindow: overrides[model.id] || model.contextWindow },
+			defaultMaxTokens: model.maxTokens,
+			...model.reasoningEfforts ? { reasoning: {
+				efforts: efforts.map((effort) => ({
+					id: ReasoningEffortId(effort),
+					name: effort
+				})),
+				defaultEffort: ReasoningEffortId(defaultEffort)
+			} } : {}
+		};
+	}
+	async prepareCall(provider, model, signal) {
+		return {
+			model: await this.resolveModel(provider, model, signal),
+			stream: (options) => this.stream(options)
+		};
+	}
+	async *stream(options) {
+		const model = MODELS.find((m) => m.id === options.model) || {
+			id: options.model,
+			name: options.model,
+			inputModalities: ["text", "image"],
+			contextWindow: 128e3,
+			maxTokens: 65536
+		};
+		const settings = await this.modelSettings.read();
+		const effectiveEffort = options.reasoningEffort || settings.defaultReasoningEffort || void 0;
+		const effectiveOptions = effectiveEffort ? {
+			...options,
+			reasoningEffort: effectiveEffort
+		} : options;
+		yield* wrapStreamWithWatchdog((watchdogSignal) => this.requestStream(effectiveOptions, model, watchdogSignal), options.signal, STREAM_IDLE_TIMEOUT_MS, STREAM_IDLE_TIMEOUT_CODE, "Antigravity");
+	}
+	async *requestStream(options, model, signal) {
+		const { token, projectId: defaultProj } = await ensureApiKey(this.store);
+		const projectId = defaultProj || "antigravity-default";
+		const effort = String(options.reasoningEffort || "medium").toLowerCase();
+		const routing = ROUTING[model.id];
+		const initialRuntime = routing?.routing[effort] || routing?.defaultRequestId || model.id;
+		const fallbackRuntime = routing?.off && routing.off !== initialRuntime ? routing.off : void 0;
+		const candidates = [initialRuntime];
+		if (fallbackRuntime && !candidates.includes(fallbackRuntime)) candidates.push(fallbackRuntime);
+		if (routing?.fallbackCandidates) {
+			for (const fc of routing.fallbackCandidates) if (!candidates.includes(fc)) candidates.push(fc);
+		}
+		let response;
+		candidates[0];
+		for (const runtimeModel of candidates) {
+			const body = JSON.stringify(buildRequest(options, model, projectId, runtimeModel, effort));
+			const headers = {
+				...antigravityHeaders(token),
+				...model.id.startsWith("claude-") ? { "anthropic-beta": "interleaved-thinking-2025-05-14" } : {}
+			};
+			for (const endpoint of endpointCandidates()) try {
+				response = await fetch(`${endpoint}/v1internal:streamGenerateContent?alt=sse`, {
+					method: "POST",
+					headers,
+					body,
+					signal
+				});
+				if (response.ok) break;
+				if (response.status === 404) break;
+			} catch (err) {
+				if (signal.aborted) throw new LlmError("Antigravity request aborted", "ABORTED", { cause: err });
+			}
+			if (response && response.ok) break;
+		}
+		if (!response || !response.ok) {
+			const status = response?.status ?? 500;
+			const errText = await response?.text().catch(() => "");
+			if (status === 429) throw new LlmError(`Antigravity 账号配额已耗尽或请求受限 (429 RESOURCE_EXHAUSTED)。请在插件设置页查看配额剩余百分比及重置倒计时。原始响应: ${errText || "No response"}`, "RATE_LIMIT", { status: 429 });
+			throw new LlmError(`Antigravity API error (${status}): ${errText || "No response"}`, "PROVIDER_ERROR", { status });
+		}
+		if (!response.body) throw new LlmError("Antigravity returned empty response body", "PROVIDER_ERROR");
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		const state = createStreamState();
+		let buffer = "";
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() || "";
+				for (const line of lines) {
+					const trimmed = line.trim();
+					if (!trimmed) continue;
+					const chunks = processStreamLine(trimmed, state);
+					for (const chunk of chunks) yield chunk;
+				}
+			}
+			if (buffer.trim()) {
+				const chunks = processStreamLine(buffer.trim(), state);
+				for (const chunk of chunks) yield chunk;
+			}
+			for (const chunk of closeStream(state)) yield chunk;
+		} finally {
+			reader.cancel().catch(() => void 0);
+		}
+	}
+};
+//#endregion
+//#region src/host/antigravity/routes.ts
+function sendJson(response, status, body) {
+	response.writeHead(status, { "Content-Type": "application/json" });
+	response.end(JSON.stringify(body));
+}
+function sendMethodNotAllowed(response) {
+	sendJson(response, 405, {
+		ok: false,
+		error: "Method Not Allowed"
+	});
+}
+async function readRequestJson(request) {
+	return new Promise((resolve, reject) => {
+		let raw = "";
+		request.on("data", (chunk) => {
+			raw += String(chunk);
+			if (raw.length > 64 * 1024) reject(/* @__PURE__ */ new Error("Request body too large"));
+		});
+		request.on("end", () => {
+			try {
+				resolve(raw ? JSON.parse(raw) : {});
+			} catch (err) {
+				reject(err);
+			}
+		});
+		request.on("error", reject);
+	});
+}
+async function getAntigravityWebStatus(store, modelSettings, preferences) {
+	const credentials = await store.read();
+	const settings = preferences ? preferences.status() : await modelSettings.read();
+	const quota = getCachedQuota();
+	const enabledSet = new Set(settings.enabledModelIds);
+	const overrides = settings.contextWindowOverrides || {};
+	const models = MODELS.map((m) => ({
+		id: m.id,
+		name: m.name,
+		enabled: enabledSet.has(m.id),
+		defaultContextWindow: m.contextWindow,
+		contextWindow: overrides[m.id] || m.contextWindow,
+		reasoningEfforts: m.reasoningEfforts
+	}));
+	return {
+		authenticated: !!(credentials?.access || credentials?.access_token),
+		email: credentials?.email,
+		projectId: credentials?.projectId,
+		hasCredentials: !!credentials,
+		storagePath: store.path(),
+		lastFetchedAt: quota?.fetchedAt,
+		quota,
+		models,
+		contextWindowOverrides: overrides,
+		defaultReasoningEffort: settings.defaultReasoningEffort || null
+	};
+}
+function registerAntigravityRoutes(ctx, store, modelSettings, preferences) {
+	return ctx.webServer.register({
+		kind: "prefix",
+		path: "/antigravity/api",
+		handler: async (request, response) => {
+			const path = new URL(request.url || "/", "http://dsh.local").pathname.replace(/^\/antigravity\/api\/?/, "");
+			try {
+				if (path === "status" || path === "") {
+					if (request.method !== "GET") return sendMethodNotAllowed(response);
+					return sendJson(response, 200, {
+						ok: true,
+						value: await getAntigravityWebStatus(store, modelSettings, preferences)
+					});
+				}
+				if (path === "login") {
+					if (request.method !== "POST") return sendMethodNotAllowed(response);
+					return sendJson(response, 200, {
+						ok: true,
+						value: await beginWebLogin(store)
+					});
+				}
+				if (path === "login/status") {
+					if (request.method !== "GET") return sendMethodNotAllowed(response);
+					return sendJson(response, 200, {
+						ok: true,
+						value: getWebLoginStatus()
+					});
+				}
+				if (path === "quota") {
+					if (request.method !== "GET" && request.method !== "POST") return sendMethodNotAllowed(response);
+					const quota = await fetchAccountQuota(store, modelSettings);
+					return sendJson(response, 200, {
+						ok: true,
+						value: {
+							...await getAntigravityWebStatus(store, modelSettings, preferences),
+							quota
+						}
+					});
+				}
+				if (path === "settings") {
+					if (request.method !== "POST") return sendMethodNotAllowed(response);
+					const body = await readRequestJson(request);
+					if (preferences) await preferences.update(body);
+					else await modelSettings.updateSettings(body);
+					return sendJson(response, 200, {
+						ok: true,
+						value: await getAntigravityWebStatus(store, modelSettings, preferences)
+					});
+				}
+				if (path === "models") {
+					if (request.method === "GET") return sendJson(response, 200, {
+						ok: true,
+						value: (await getAntigravityWebStatus(store, modelSettings, preferences)).models
+					});
+					if (request.method === "POST") {
+						const body = await readRequestJson(request);
+						if (Array.isArray(body.enabledModelIds) || body.contextWindowOverrides || body.defaultReasoningEffort !== void 0) if (preferences) await preferences.update(body);
+						else await modelSettings.updateSettings(body);
+						return sendJson(response, 200, {
+							ok: true,
+							value: await getAntigravityWebStatus(store, modelSettings, preferences)
+						});
+					}
+					return sendMethodNotAllowed(response);
+				}
+				if (path === "logout") {
+					if (request.method !== "POST") return sendMethodNotAllowed(response);
+					await store.delete();
+					return sendJson(response, 200, {
+						ok: true,
+						value: await getAntigravityWebStatus(store, modelSettings)
+					});
+				}
+				return sendJson(response, 404, {
+					ok: false,
+					error: "not-found"
+				});
+			} catch (err) {
+				return sendJson(response, 500, {
+					ok: false,
+					error: err instanceof Error ? err.message : String(err)
+				});
+			}
+		}
+	});
+}
+//#endregion
 //#region src/index.ts
 const inject = [
 	"webServer",
@@ -3320,6 +5184,18 @@ const inject = [
 function apply(ctx) {
 	const store = createPlatformTokenStore();
 	const preferences = registerPreferenceStore(ctx.settings);
+	const antigravityStore = new FileCredentialStore();
+	const antigravityModelSettings = new FileModelSettingsStore();
+	const antigravityPreferences = registerAntigravityPreferenceStore(ctx.settings, antigravityModelSettings);
+	const antigravityAdapter = new AntigravityAdapter(antigravityStore, antigravityModelSettings, antigravityPreferences);
+	ctx.effect(() => {
+		const disposeAntigravityAdapter = ctx.llm.registerAdapter([PROVIDER_ID], antigravityAdapter);
+		const disposeAntigravityRoutes = registerAntigravityRoutes(ctx, antigravityStore, antigravityModelSettings, antigravityPreferences);
+		return () => {
+			disposeAntigravityRoutes();
+			disposeAntigravityAdapter();
+		};
+	}, "dsh-antigravity: adapter, routes, and lifecycle");
 	ctx.effect(() => {
 		const proxyManager = new ProxyManager({
 			getPreferences: () => preferences.status(),
@@ -3345,7 +5221,7 @@ function apply(ctx) {
 			});
 		};
 		const disposeRoutes = registerRoutes(ctx, oauth, usage, preferences, proxyManager);
-		const disposeAdapter = ctx.llm.registerAdapter([PROVIDER_ID], adapter);
+		const disposeAdapter = ctx.llm.registerAdapter([PROVIDER_ID$1], adapter);
 		const disposeImageTool = ctx.tools.register(createCodexImageTool(oauth, ctx.attachments, { fetchFn: proxyFetch }));
 		let disposeWebProviders = () => {};
 		const registerWebProviders = () => {
@@ -3377,4 +5253,4 @@ function localWebServerBaseUrl(host, port) {
 	return `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${port}`;
 }
 //#endregion
-export { CodexChatGptAdapter, LinuxFileTokenStore, MacKeychainTokenStore, OAuthService, ProxyManager, ResponsesClient, UsageService, WindowsDpapiTokenStore, apply, createCodexFetchProvider, createCodexImageTool, createCodexSearchProvider, createPlatformTokenStore, detectSystemProxy, inject, mapCodexUsage, parseCodexUsage, parseResponsesStream };
+export { AntigravityAdapter, CodexChatGptAdapter, FileCredentialStore, FileModelSettingsStore, LinuxFileTokenStore, MacKeychainTokenStore, OAuthService, ProxyManager, ResponsesClient, UsageService, WindowsDpapiTokenStore, apply, beginWebLogin, createCodexFetchProvider, createCodexImageTool, createCodexSearchProvider, createPlatformTokenStore, credentialPath, detectSystemProxy, fetchAccountQuota, getCachedQuota, inject, loginAndSave, mapCodexUsage, modelSettingsPath, parseCodexUsage, parseResponsesStream, refreshAntigravityToken };