@eddyskywalker/dsh-chatgpt-subscription 0.2.1 → 0.2.3

package/lib/index.js

@@ -1,6 +1,6 @@
 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 { CallId, 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";
@@ -14,6 +14,7 @@ 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 { isDeepStrictEqual } from "node:util";
 import { URL as URL$1, URLSearchParams as URLSearchParams$1 } from "node:url";
 //#region src/compat.ts
 /**
@@ -49,6 +50,7 @@ const OAUTH_TOKEN_URL = `${CHATGPT_OAUTH_ISSUER}/oauth/token`;
 //#endregion
 //#region src/shared/model-catalog.ts
 const GPT_56_MAX_CONTEXT_WINDOW = 1e6;
+const GPT_6_ASTRA_MAX_CONTEXT_WINDOW = 872e3;
 const CODEX_MODEL_CATALOG = [
 	{
 		id: "gpt-5.6-sol",
@@ -60,6 +62,15 @@ const CODEX_MODEL_CATALOG = [
 		supportsReasoningSummary: true,
 		fallbackModelId: "gpt-5.6-terra"
 	},
+	{
+		id: "gpt-6-astra",
+		name: "6 Astra",
+		contextWindow: 272e3,
+		inputModalities: ["text", "image"],
+		defaultReasoningEffort: "medium",
+		reasoningProfile: "gpt-6-astra",
+		supportsReasoningSummary: true
+	},
 	{
 		id: "gpt-5.6-terra",
 		name: "5.6 Terra",
@@ -120,11 +131,13 @@ const CODEX_MODEL_CATALOG = [
 ];
 const DEFAULT_VISIBLE_CODEX_MODEL_IDS = [
 	"gpt-5.6-sol",
+	"gpt-6-astra",
 	"gpt-5.6-terra",
 	"gpt-5.6-luna"
 ];
 const DEFAULT_CODEX_MODEL = CODEX_MODEL_CATALOG[0];
 const CONFIGURABLE_CONTEXT_MODEL_IDS = [
+	"gpt-6-astra",
 	"gpt-5.6-sol",
 	"gpt-5.6-terra",
 	"gpt-5.6-luna"
@@ -137,8 +150,17 @@ const STANDARD_REASONING_EFFORTS = [
 	"xhigh"
 ];
 const GPT_56_REASONING_EFFORTS = [...STANDARD_REASONING_EFFORTS, "max"];
+const GPT_6_ASTRA_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
 function reasoningEffortsForModel(model) {
-	return resolveCodexCatalogEntry(model).reasoningProfile === "gpt-5.6" ? GPT_56_REASONING_EFFORTS : STANDARD_REASONING_EFFORTS;
+	const profile = resolveCodexCatalogEntry(model).reasoningProfile;
+	if (profile === "gpt-6-astra") return GPT_6_ASTRA_REASONING_EFFORTS;
+	return profile === "gpt-5.6" ? GPT_56_REASONING_EFFORTS : STANDARD_REASONING_EFFORTS;
 }
 function isCodexModelId(model) {
 	return typeof model === "string" && CODEX_MODEL_CATALOG.some((entry) => entry.id === model);
@@ -146,6 +168,9 @@ function isCodexModelId(model) {
 function isConfigurableContextModelId(model) {
 	return typeof model === "string" && CONFIGURABLE_CONTEXT_MODEL_IDS.some((id) => id === model);
 }
+function contextWindowLimitForModel(model) {
+	return model === "gpt-6-astra" ? GPT_6_ASTRA_MAX_CONTEXT_WINDOW : GPT_56_MAX_CONTEXT_WINDOW;
+}
 function resolveCodexCatalogEntry(model) {
 	return CODEX_MODEL_CATALOG.find((entry) => entry.id === model) ?? DEFAULT_CODEX_MODEL;
 }
@@ -1321,6 +1346,7 @@ const DEFAULT_PREFERENCES = {
 	visibleModelIds: [...DEFAULT_VISIBLE_CODEX_MODEL_IDS],
 	searchProvider: "dsh",
 	contextWindowOverrides: {
+		"gpt-6-astra": 272e3,
 		"gpt-5.6-sol": 272e3,
 		"gpt-5.6-terra": 272e3,
 		"gpt-5.6-luna": 272e3
@@ -1366,6 +1392,7 @@ function registerPreferenceStore(settings) {
 		visibleModelIds: z.array(z.string()).default(DEFAULT_PREFERENCES.visibleModelIds),
 		searchProvider: z.union([z.const("dsh"), z.const(SEARCH_PROVIDER_CODEX)]).default(DEFAULT_PREFERENCES.searchProvider),
 		contextWindowOverrides: z.object({
+			"gpt-6-astra": z.number().step(1).min(1).max(GPT_6_ASTRA_MAX_CONTEXT_WINDOW).default(DEFAULT_PREFERENCES.contextWindowOverrides["gpt-6-astra"]),
 			"gpt-5.6-sol": z.number().step(1).min(1).max(GPT_56_MAX_CONTEXT_WINDOW).default(DEFAULT_PREFERENCES.contextWindowOverrides["gpt-5.6-sol"]),
 			"gpt-5.6-terra": z.number().step(1).min(1).max(GPT_56_MAX_CONTEXT_WINDOW).default(DEFAULT_PREFERENCES.contextWindowOverrides["gpt-5.6-terra"]),
 			"gpt-5.6-luna": z.number().step(1).min(1).max(GPT_56_MAX_CONTEXT_WINDOW).default(DEFAULT_PREFERENCES.contextWindowOverrides["gpt-5.6-luna"])
@@ -1691,10 +1718,13 @@ async function buildResponsesPayload(options, attachments, localRawImages = {},
 	}
 	if (outputVerbosity !== null) payload.text = { verbosity: outputVerbosity };
 	if (fastMode) payload.service_tier = "priority";
-	if (options.reasoningEffort !== void 0) payload.reasoning = codexModelSupportsReasoningSummary(options.model) ? {
-		effort: options.reasoningEffort,
-		summary: reasoningSummary ?? "auto"
-	} : { effort: options.reasoningEffort };
+	if (options.reasoningEffort !== void 0) {
+		const effort = options.model === "gpt-6-astra" && ["none", "minimal"].includes(options.reasoningEffort) ? "low" : options.reasoningEffort;
+		payload.reasoning = codexModelSupportsReasoningSummary(options.model) ? {
+			effort,
+			summary: reasoningSummary ?? "auto"
+		} : { effort };
+	}
 	return payload;
 }
 function progressExplanationInstruction(tools) {
@@ -3083,8 +3113,8 @@ function readPreferencesUpdate(value, current) {
 		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.");
-			if (!Number.isSafeInteger(contextWindow) || contextWindow < 1 || contextWindow > 1e6) throw new PreferenceError(`contextWindowOverrides.${model} must be a positive integer no greater than the provider limit.`);
+			if (!isConfigurableContextModelId(model)) throw new PreferenceError("This model does not support a configurable context window.");
+			if (!Number.isSafeInteger(contextWindow) || contextWindow < 1 || contextWindow > contextWindowLimitForModel(model)) throw new PreferenceError(`contextWindowOverrides.${model} must be a positive integer no greater than the provider limit.`);
 			overrides[model] = contextWindow;
 		}
 		patch.contextWindowOverrides = overrides;
@@ -3162,16 +3192,18 @@ const DEFAULT_ACCOUNT = "oauth";
 * `security` command-line tool. The payload is encrypted at rest by the
 * Keychain, so this store reports itself as encrypted like Windows DPAPI.
 */
-var MacKeychainTokenStore = class {
+var MacKeychainCredentialStore = class {
 	service;
 	account;
+	parse;
 	storage = {
 		kind: "macos-keychain",
 		encrypted: true
 	};
-	constructor(service = DEFAULT_SERVICE, account = DEFAULT_ACCOUNT) {
+	constructor(service, account, parse) {
 		this.service = service;
 		this.account = account;
+		this.parse = parse;
 		if (process.platform !== "darwin") throw new Error("macOS Keychain storage requires macOS");
 	}
 	async load() {
@@ -3187,7 +3219,7 @@ var MacKeychainTokenStore = class {
 		if (result.code !== 0) throw new Error("Keychain credential read failed");
 		try {
 			const payload = result.stdout.replace(/\r?\n$/, "");
-			return parseStoredCredentials(JSON.parse(payload));
+			return this.parse(JSON.parse(payload));
 		} catch {
 			throw new Error("Keychain credential payload is invalid");
 		}
@@ -3215,6 +3247,11 @@ var MacKeychainTokenStore = class {
 		if (result.code !== 0 && result.code !== 44) throw new Error("Keychain credential deletion failed");
 	}
 };
+var MacKeychainTokenStore = class extends MacKeychainCredentialStore {
+	constructor(service = DEFAULT_SERVICE, account = DEFAULT_ACCOUNT) {
+		super(service, account, parseStoredCredentials);
+	}
+};
 function runSecurity(args) {
 	return new Promise((resolve, reject) => {
 		const child = spawn("security", args, {
@@ -3359,8 +3396,16 @@ $cipher = [Security.Cryptography.ProtectedData]::Protect($bytes, $null, [Securit
 $directory = [IO.Path]::GetDirectoryName($path)
 [IO.Directory]::CreateDirectory($directory) | Out-Null
 $temporary = $path + '.tmp-' + [Guid]::NewGuid().ToString('N')
-[IO.File]::WriteAllBytes($temporary, $cipher)
-if ([IO.File]::Exists($path)) { [IO.File]::Replace($temporary, $path, $null) } else { [IO.File]::Move($temporary, $path) }
+try {
+  [IO.File]::WriteAllBytes($temporary, $cipher)
+  if ([IO.File]::Exists($path)) {
+    [IO.File]::Replace($temporary, $path, [System.Management.Automation.Language.NullString]::Value)
+  } else {
+    [IO.File]::Move($temporary, $path)
+  }
+} finally {
+  if ([IO.File]::Exists($temporary)) { [IO.File]::Delete($temporary) }
+}
 `;
 const UNPROTECT_SCRIPT = String.raw`
 $ErrorActionPreference = 'Stop'
@@ -3379,14 +3424,16 @@ if ([IO.File]::Exists($path)) { [IO.File]::Delete($path) }
 function defaultDpapiCredentialPath() {
 	return join(process.env.DSH_HOME?.trim() || join(homedir(), ".dsh"), "storages", "dsh-chatgpt-subscription", "oauth.dpapi");
 }
-var WindowsDpapiTokenStore = class {
+var WindowsDpapiCredentialStore = class {
 	path;
+	parse;
 	storage = {
 		kind: "windows-dpapi",
 		encrypted: true
 	};
-	constructor(path = defaultDpapiCredentialPath()) {
+	constructor(path, parse) {
 		this.path = path;
+		this.parse = parse;
 		if (process.platform !== "win32") throw new Error("Windows DPAPI storage requires Windows");
 		if (dirname(path) === path) throw new Error("invalid DPAPI credential path");
 	}
@@ -3395,7 +3442,7 @@ var WindowsDpapiTokenStore = class {
 		if (result.code === 3) return null;
 		if (result.code !== 0) throw new Error("DPAPI credential read failed");
 		try {
-			return parseStoredCredentials(JSON.parse(result.stdout));
+			return this.parse(JSON.parse(result.stdout));
 		} catch {
 			throw new Error("DPAPI credential payload is invalid");
 		}
@@ -3407,6 +3454,11 @@ var WindowsDpapiTokenStore = class {
 		if ((await runPowerShell(CLEAR_SCRIPT, this.path, "")).code !== 0) throw new Error("DPAPI credential deletion failed");
 	}
 };
+var WindowsDpapiTokenStore = class extends WindowsDpapiCredentialStore {
+	constructor(path = defaultDpapiCredentialPath()) {
+		super(path, parseStoredCredentials);
+	}
+};
 function runPowerShell(script, path, stdin) {
 	return new Promise((resolve, reject) => {
 		const child = spawn("powershell.exe", [
@@ -3827,6 +3879,96 @@ const MODELS = [
 	}
 ];
 //#endregion
+//#region src/host/credential-store-secret-service.ts
+const UNAVAILABLE = "Linux encrypted credential storage requires secret-tool (libsecret) and an unlocked Secret Service keyring.";
+/** Secrets travel over stdin/stdout; command arguments contain only lookup attributes. */
+var SecretServiceCredentialStore = class {
+	service;
+	account;
+	parse;
+	constructor(service, account, parse) {
+		this.service = service;
+		this.account = account;
+		this.parse = parse;
+	}
+	attributes() {
+		return [
+			"service",
+			this.service,
+			"account",
+			this.account
+		];
+	}
+	async load() {
+		const result = await runSecretTool(["lookup", ...this.attributes()]);
+		if (result.code === 1 && !result.hasStderr && result.stdout === "") return null;
+		if (result.code !== 0) throw new Error(UNAVAILABLE);
+		try {
+			return this.parse(JSON.parse(result.stdout));
+		} catch {
+			throw new Error("Secret Service credential payload is invalid");
+		}
+	}
+	async save(value) {
+		const payload = JSON.stringify(value);
+		if (Buffer.byteLength(payload, "utf8") >= 8192) throw new Error("Secret Service credential payload is too large");
+		if ((await runSecretTool([
+			"store",
+			"--label=DSH Antigravity OAuth",
+			...this.attributes()
+		], payload)).code !== 0) throw new Error(UNAVAILABLE);
+	}
+	async clear() {
+		const result = await runSecretTool(["clear", ...this.attributes()]);
+		if (result.code !== 0 && !(result.code === 1 && !result.hasStderr)) throw new Error(UNAVAILABLE);
+	}
+};
+function runSecretTool(args, stdin = "") {
+	return new Promise((resolve, reject) => {
+		const child = spawn("secret-tool", args, {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			windowsHide: true
+		});
+		let stdout = "";
+		let stderrLength = 0;
+		let settled = false;
+		const fail = () => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			child.kill();
+			reject(/* @__PURE__ */ new Error(UNAVAILABLE));
+		};
+		const timer = setTimeout(fail, 1e4);
+		child.stdout.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+			if (stdout.length > 1 << 20) fail();
+		});
+		child.stderr.on("data", (chunk) => {
+			stderrLength += chunk.length;
+			if (stderrLength > 1 << 20) fail();
+		});
+		child.once("error", fail);
+		child.stdin.once("error", fail);
+		child.once("close", (code) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve({
+				code: code ?? 1,
+				stdout,
+				hasStderr: stderrLength > 0
+			});
+		});
+		child.stdin.end(stdin);
+	});
+}
+//#endregion
 //#region src/host/antigravity/token-store.ts
 const ANTIGRAVITY_PREFERENCES_NAMESPACE = "dsh-antigravity";
 function registerAntigravityPreferenceStore(settings, fallbackStore = new FileModelSettingsStore()) {
@@ -3888,36 +4030,110 @@ function credentialPath() {
 function modelSettingsPath() {
 	return path.join(dshHomeDir(), "storages", "antigravity-models.json");
 }
+function parseAntigravityCredentials(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("Antigravity credential payload is invalid");
+	const record = value;
+	const credentials = {};
+	for (const key of [
+		"access",
+		"access_token",
+		"refresh",
+		"refresh_token",
+		"email",
+		"projectId"
+	]) {
+		if (record[key] === void 0) continue;
+		if (typeof record[key] !== "string") throw new Error("Antigravity credential payload is invalid");
+		credentials[key] = record[key];
+	}
+	for (const key of ["expires", "expires_at"]) {
+		if (record[key] === void 0) continue;
+		if (typeof record[key] !== "number" || !Number.isFinite(record[key])) throw new Error("Antigravity credential expiry is invalid");
+		credentials[key] = record[key];
+	}
+	if (!(credentials.access || credentials.access_token || credentials.refresh || credentials.refresh_token)) throw new Error("Antigravity credential tokens are missing");
+	return credentials;
+}
+function credentialAccount(filePath) {
+	return createHash("sha256").update(path.resolve(filePath)).digest("hex");
+}
+function createCredentialBackend(filePath) {
+	if (process.platform === "win32") return new WindowsDpapiCredentialStore(`${filePath}.dpapi`, parseAntigravityCredentials);
+	if (process.platform === "darwin") return new MacKeychainCredentialStore("dsh-antigravity", credentialAccount(filePath), parseAntigravityCredentials);
+	if (process.platform === "linux") return new SecretServiceCredentialStore("dsh-antigravity", credentialAccount(filePath), parseAntigravityCredentials);
+	throw new Error("Antigravity encrypted credential storage requires Windows, macOS, or Linux.");
+}
+const credentialOperations = /* @__PURE__ */ new Map();
+/** Keeps the public API; filePath identifies the legacy JSON that is migrated on first use. */
 var FileCredentialStore = class {
 	filePath;
-	constructor(filePath = credentialPath()) {
+	backend;
+	constructor(filePath = credentialPath(), backend = createCredentialBackend(filePath)) {
 		this.filePath = filePath;
+		this.backend = backend;
 	}
 	path() {
-		return this.filePath;
+		if (process.platform === "win32") return `${this.filePath}.dpapi`;
+		return `${process.platform === "darwin" ? "Keychain" : "Secret Service"}: dsh-antigravity/${credentialAccount(this.filePath)}`;
+	}
+	serialize(operation) {
+		const key = path.resolve(this.filePath);
+		const result = (credentialOperations.get(key) || Promise.resolve()).then(operation);
+		const settled = result.then(() => void 0, () => void 0);
+		credentialOperations.set(key, settled);
+		settled.then(() => {
+			if (credentialOperations.get(key) === settled) credentialOperations.delete(key);
+		});
+		return result;
 	}
-	async read() {
+	async removeLegacy() {
 		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;
+			await fsPromises.unlink(this.filePath);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw new Error("Antigravity legacy credential removal failed");
 		}
 	}
-	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 saveVerified(credentials) {
+		await this.backend.save(credentials);
+		if (!isDeepStrictEqual(await this.backend.load(), credentials)) throw new Error("Antigravity encrypted credential verification failed");
+		await this.removeLegacy();
+	}
+	read() {
+		return this.serialize(async () => {
+			const current = await this.backend.load();
+			if (current !== null) {
+				await this.removeLegacy();
+				return current;
+			}
+			let legacy;
+			try {
+				const stats = await fsPromises.lstat(this.filePath);
+				if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Invalid credential file");
+				if (process.getuid && stats.uid !== process.getuid()) throw new Error("Invalid credential owner");
+				if (process.platform !== "win32") await fsPromises.chmod(this.filePath, 384);
+				legacy = await fsPromises.readFile(this.filePath, "utf8");
+			} catch (error) {
+				if (error.code === "ENOENT") return null;
+				throw new Error("Antigravity legacy credential read failed");
+			}
+			let credentials;
+			try {
+				credentials = parseAntigravityCredentials(JSON.parse(legacy));
+			} catch {
+				throw new Error("Antigravity legacy credential payload is invalid");
+			}
+			await this.saveVerified(credentials);
+			return credentials;
+		});
 	}
-	async delete() {
-		try {
-			await fsPromises.unlink(this.filePath);
-		} catch (err) {
-			if (err.code !== "ENOENT") throw err;
-		}
+	write(credentials) {
+		return this.serialize(() => this.saveVerified(parseAntigravityCredentials(credentials)));
+	}
+	delete() {
+		return this.serialize(async () => {
+			await this.removeLegacy();
+			await this.backend.clear();
+		});
 	}
 };
 var FileModelSettingsStore = class {
@@ -4549,15 +4765,27 @@ function toolResultText(blocks) {
 }
 function replayBlockFor(message, index) {
 	const source = message.source;
-	if (!source || source.kind !== "model") return void 0;
+	if (!source || source.kind !== "model" || source.provider !== "antigravity") return void 0;
 	const state = source.replayState;
 	if (!isRecord(state)) return void 0;
+	if (Array.isArray(state.blocks)) return state.blocks[index];
 	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 thoughtSignature(part) {
+	return asString(part?.thoughtSignature) || asString(part?.thought_signature) || asString(part?.thinkingSignature) || asString(part?.textSignature);
+}
+function replayPart(part) {
+	const copy = { ...part };
+	const signature = thoughtSignature(part);
+	delete copy.thought_signature;
+	delete copy.thinkingSignature;
+	if (signature) copy.thoughtSignature = signature;
+	if (typeof copy.text === "string") copy.text = sanitizeText(copy.text);
+	return copy;
 }
 function assistantParts(message, model, runtimeModel, toolNames) {
 	const parts = [];
@@ -4566,30 +4794,39 @@ function assistantParts(message, model, runtimeModel, toolNames) {
 		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({
+		const originalParts = Array.isArray(replay?.parts) ? replay.parts.filter(isRecord) : [];
+		if ((block.type === "text" || block.type === "reasoning") && originalParts.length > 0 && originalParts.every((part) => !part.functionCall) && originalParts.map((part) => asString(part.text) || "").join("") === sanitizeText(String(block.text || ""))) {
+			parts.push(...originalParts.map(replayPart));
+			continue;
+		}
+		if (block.type === "text" && String(block.text || "").trim()) {
+			const sig = thoughtSignature(replay) || thoughtSignature(block);
+			parts.push({
+				text: sanitizeText(String(block.text)),
+				...sig ? { thoughtSignature: sig } : {}
+			});
+		} else if (block.type === "reasoning" && String(block.text || "").trim()) {
+			const sig = thoughtSignature(replay) || thoughtSignature(block);
+			parts.push({
 				thought: true,
 				text: sanitizeText(String(block.text)),
-				thought_signature: sig,
-				thoughtSignature: sig
+				...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";
+			const originalCall = originalParts.find((part) => isRecord(part.functionCall));
+			const effectiveSignature = thoughtSignature(originalCall) || thoughtSignature(replay) || thoughtSignature(block) || (originalCall ? void 0 : "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
+				...effectiveSignature ? { thoughtSignature: effectiveSignature } : {}
 			});
+			parts.push(...originalParts.filter((part) => !part.functionCall).map(replayPart));
 		}
 	}
 	return parts;
@@ -4693,6 +4930,8 @@ function buildRequest(options, model, projectId, runtimeModel, effort) {
 	const isTiered = runtimeModel === "gemini-3.8-flash-tiered" || runtimeModel === "gemini-3.7-flash-tiered";
 	const isSuffixed = /^gemini-.+(?:-(?:extra-)?low|-medium|-high|-xhigh)$/.test(runtimeModel);
 	const isGemini25 = runtimeModel.startsWith("gemini-2.5-") || model.id.startsWith("gemini-2.5-");
+	const isGemini3 = /^gemini-3[.-]/.test(runtimeModel) && !runtimeModel.includes("image");
+	const isGeminiAgent = runtimeModel === "gemini-pro-agent" || runtimeModel === "gemini-3-flash-agent";
 	if (isTiered) {
 		const selected = (effort || "medium").toLowerCase();
 		const isOff = selected === "off" || selected === "none";
@@ -4700,7 +4939,7 @@ function buildRequest(options, model, projectId, runtimeModel, effort) {
 			thinkingLevel: isOff ? "MINIMAL" : selected === "high" || selected === "xhigh" ? "HIGH" : selected === "medium" ? "MEDIUM" : "LOW",
 			includeThoughts: !isOff
 		};
-	} else if (isSuffixed) {
+	} else if (isSuffixed || isGemini3 || isGeminiAgent) {
 		const selected = (effort || "medium").toLowerCase();
 		generationConfig.thinkingConfig = { includeThoughts: !(selected === "off" || selected === "none") };
 	} else if (isGemini25) {
@@ -4736,58 +4975,90 @@ function createStreamState() {
 		replayBlocks: [],
 		currentBlock: null,
 		hasContent: false,
-		hasToolCall: false
+		hasToolCall: false,
+		usageMetadata: null,
+		done: false,
+		finished: false
+	};
+}
+function closeCurrentBlock(state) {
+	if (!state.currentBlock) return [];
+	const { index, type, text } = state.currentBlock;
+	const block = {
+		type,
+		text
+	};
+	state.blocks[index] = block;
+	state.currentBlock = null;
+	return [{
+		type: "block-end",
+		index,
+		block
+	}];
+}
+const USAGE_FIELDS = [
+	"promptTokenCount",
+	"cachedContentTokenCount",
+	"candidatesTokenCount",
+	"thoughtsTokenCount",
+	"totalTokenCount"
+];
+function collectUsage(value, state) {
+	if (!isRecord(value)) return;
+	for (const key of USAGE_FIELDS) {
+		const count = value[key];
+		if (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0) continue;
+		state.usageMetadata ??= {};
+		state.usageMetadata[key] = count;
+	}
+}
+function tokenUsage(u) {
+	const prompt = u.promptTokenCount ?? 0;
+	const cache = Math.min(prompt, u.cachedContentTokenCount ?? 0);
+	const thoughts = u.thoughtsTokenCount ?? 0;
+	const explicitOutput = (u.candidatesTokenCount ?? 0) + thoughts;
+	const totalOutput = u.totalTokenCount !== void 0 && u.promptTokenCount !== void 0 ? Math.max(0, u.totalTokenCount - prompt) : 0;
+	return {
+		inputTokens: prompt - cache,
+		outputTokens: Math.max(explicitOutput, totalOutput),
+		...cache > 0 ? { cacheReadTokens: cache } : {},
+		...u.thoughtsTokenCount !== void 0 ? { reasoningTokens: thoughts } : {}
 	};
 }
 function processStreamLine(line, state) {
-	if (!line.startsWith("data:")) return [];
+	if (state.finished || !line.startsWith("data:")) return [];
 	const json = line.slice(5).trim();
-	if (!json || json === "[DONE]") return [];
+	if (json === "[DONE]") {
+		state.done = true;
+		return closeStream(state);
+	}
+	if (!json) 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 candidates = Array.isArray(responseData.candidates) ? responseData.candidates : [];
+	const candidate = isRecord(candidates[0]) ? candidates[0] : void 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") {
+		if (typeof part.text === "string" && part.text !== "") {
 			const isThinking = Boolean(part.thought);
 			const blockType = isThinking ? "reasoning" : "text";
 			if (!state.currentBlock || state.currentBlock.type !== blockType) {
-				closeCurrentBlock();
+				out.push(...closeCurrentBlock(state));
+				const index = state.blocks.length;
 				state.currentBlock = {
+					index,
 					type: blockType,
 					text: ""
 				};
-				const index = state.blocks.length;
 				state.blocks.push({
 					type: blockType,
 					text: ""
 				});
-				state.replayBlocks.push({ type: blockType });
+				state.replayBlocks.push({ parts: [] });
 				out.push({
 					type: "block-start",
 					index,
@@ -4797,45 +5068,55 @@ function processStreamLine(line, state) {
 			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;
-			}
+			state.replayBlocks[state.currentBlock.index].parts.push(replayPart(part));
 			out.push({
 				type: isThinking ? "reasoning-delta" : "text-delta",
-				index: state.blocks.length - 1,
+				index: state.currentBlock.index,
 				text: delta
 			});
+		} else if (!isRecord(part.functionCall) && thoughtSignature(part)) {
+			if (state.replayBlocks.length === 0) {
+				const type = part.thought ? "reasoning" : "text";
+				state.blocks.push({
+					type,
+					text: ""
+				});
+				state.replayBlocks.push({ parts: [] });
+				out.push({
+					type: "block-start",
+					index: 0,
+					blockType: type
+				});
+				out.push({
+					type: "block-end",
+					index: 0,
+					block: {
+						type,
+						text: ""
+					}
+				});
+			}
+			state.replayBlocks[state.replayBlocks.length - 1].parts.push(replayPart(part));
 		}
 		if (isRecord(part.functionCall)) {
-			closeCurrentBlock();
+			out.push(...closeCurrentBlock(state));
 			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,
+				id: CallId(toolId),
 				name: toolName,
-				arguments: argsText,
-				...sig ? {
-					thought_signature: sig,
-					thoughtSignature: sig
-				} : {}
+				arguments: argsText
 			};
 			state.blocks.push(block);
-			state.replayBlocks.push({
-				type: "tool-call",
-				...sig ? {
-					thought_signature: sig,
-					thoughtSignature: sig
-				} : {}
-			});
+			const sig = thoughtSignature(part) || thoughtSignature(fc);
+			state.replayBlocks.push({ parts: [{
+				...replayPart(part),
+				...sig ? { thoughtSignature: sig } : {}
+			}] });
 			state.hasContent = true;
 			state.hasToolCall = true;
 			out.push({
@@ -4846,7 +5127,7 @@ function processStreamLine(line, state) {
 			out.push({
 				type: "tool-call-delta",
 				index,
-				id: toolId,
+				id: CallId(toolId),
 				name: toolName,
 				argumentsDelta: argsText
 			});
@@ -4857,55 +5138,33 @@ function processStreamLine(line, state) {
 			});
 		}
 	}
-	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;
+	collectUsage(chunk.usageMetadata, state);
+	if (responseData !== chunk) collectUsage(responseData.usageMetadata, state);
+	const finishReason = asString(candidate?.finishReason) || asString(responseData.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
-			} }
-		});
+		state.finishReason = finishReason;
+		out.push(...closeCurrentBlock(state));
 	}
 	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;
-	}
+	if (state.finished) return [];
+	if (!state.finishReason && !state.done) throw new LlmError("Antigravity stream ended before its terminal response", "PROVIDER_ERROR");
+	state.finished = true;
+	const out = closeCurrentBlock(state);
+	if (state.usageMetadata) out.push({
+		type: "usage",
+		usage: tokenUsage(state.usageMetadata)
+	});
+	const reason = state.finishReason === "MAX_TOKENS" ? { kind: "max-tokens" } : state.hasToolCall ? { kind: "tool-calls" } : { kind: "stop" };
+	out.push({
+		type: "finish",
+		reason,
+		replayState: {
+			response: { provider: PROVIDER_ID },
+			blocks: state.replayBlocks
+		}
+	});
 	return out;
 }
 //#endregion
@@ -4989,7 +5248,7 @@ var AntigravityAdapter = class extends LlmAdapter {
 			contextWindow: 128e3,
 			maxTokens: 65536
 		};
-		const settings = await this.modelSettings.read();
+		const settings = this.preferences ? this.preferences.status() : await this.modelSettings.read();
 		const effectiveEffort = options.reasoningEffort || settings.defaultReasoningEffort || void 0;
 		const effectiveOptions = effectiveEffort ? {
 			...options,
@@ -5010,7 +5269,6 @@ var AntigravityAdapter = class extends LlmAdapter {
 			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 = {
@@ -5054,8 +5312,10 @@ var AntigravityAdapter = class extends LlmAdapter {
 					if (!trimmed) continue;
 					const chunks = processStreamLine(trimmed, state);
 					for (const chunk of chunks) yield chunk;
+					if (state.finished) return;
 				}
 			}
+			buffer += decoder.decode();
 			if (buffer.trim()) {
 				const chunks = processStreamLine(buffer.trim(), state);
 				for (const chunk of chunks) yield chunk;