dsh-antigravity-auth 0.1.0

package/lib/project-context.js

@@ -0,0 +1,133 @@
+import { d as privateStatusError, i as DEFAULT_PRIVATE_RESPONSE_BYTES, l as createPrivateTransport, m as PrivateTransportError, n as DEFAULT_PRIVATE_IDLE_TIMEOUT_MS, o as DEFAULT_PRIVATE_TOTAL_TIMEOUT_MS, p as readPrivateText } from "./private-transport-urF138qW.js";
+import { ANTIGRAVITY_WIRE_ORIGIN } from "./wire-identity.js";
+import { t as classifyPrivateFailure } from "./private-failure-B9vzUkQ7.js";
+import { buildAntigravityLoadCodeAssistMetadata } from "@cortexkit/antigravity-auth-core";
+//#region src/project-context.ts
+/** Host-only, read-only project discovery and safe project normalization. */
+const PROJECT_DISCOVERY_PATH = "/v1internal:loadCodeAssist";
+const PROJECT_DISCOVERY_ENDPOINT = `${ANTIGRAVITY_WIRE_ORIGIN}${PROJECT_DISCOVERY_PATH}`;
+const MAX_RESPONSE_BYTES = Math.min(DEFAULT_PRIVATE_RESPONSE_BYTES, 65536);
+const DEFAULT_OPERATION_TIMEOUT_MS = 1e4;
+const MAX_OPERATION_TIMEOUT_MS = 6e5;
+const MAX_PROJECT_ID_LENGTH = 128;
+const PROJECT_ID_PATTERN = /^[a-z][a-z0-9-]{2,127}$/u;
+var ProjectDiscoveryError = class extends Error {
+	code;
+	constructor(code, message = projectDiscoveryErrorMessage(code)) {
+		super(message);
+		this.name = "ProjectDiscoveryError";
+		this.code = code;
+	}
+};
+/** Create the fixed, read-only loadCodeAssist project probe. */
+function createProjectDiscovery(options = {}) {
+	const timeoutMs = boundedTimeout(options.operationTimeoutMs);
+	const transport = options.transport ?? createPrivateTransport({
+		...options.transportOptions?.responseHeaderTimeoutMs === void 0 ? {} : { responseHeaderTimeoutMs: options.transportOptions.responseHeaderTimeoutMs },
+		...options.transportOptions?.maxRequestBytes === void 0 ? {} : { maxRequestBytes: options.transportOptions.maxRequestBytes }
+	});
+	return { discover: async (accessToken, signal) => {
+		if (signal?.aborted === true) throw new ProjectDiscoveryError("cancelled");
+		const body = JSON.stringify({ metadata: buildAntigravityLoadCodeAssistMetadata() });
+		let response;
+		try {
+			response = await transport.request({
+				url: PROJECT_DISCOVERY_ENDPOINT,
+				accessToken,
+				body,
+				...signal === void 0 ? {} : { signal },
+				responseHeaderTimeoutMs: timeoutMs
+			});
+		} catch (error) {
+			throw mapTransportError(error);
+		}
+		const statusError = privateStatusError(response.status);
+		if (statusError !== void 0) {
+			await response.body?.cancel().catch(() => {});
+			throw mapTransportError(statusError);
+		}
+		try {
+			const text = await readPrivateText(response, {
+				...signal === void 0 ? {} : { signal },
+				idleTimeoutMs: Math.min(timeoutMs, DEFAULT_PRIVATE_IDLE_TIMEOUT_MS),
+				totalTimeoutMs: Math.min(timeoutMs, DEFAULT_PRIVATE_TOTAL_TIMEOUT_MS),
+				maxBytes: MAX_RESPONSE_BYTES
+			});
+			let value;
+			try {
+				value = JSON.parse(text);
+			} catch {
+				throw new ProjectDiscoveryError("malformed");
+			}
+			return parseProjectResponse(value);
+		} catch (error) {
+			if (error instanceof ProjectDiscoveryError) throw error;
+			throw mapTransportError(error);
+		}
+	} };
+}
+/** Compatibility name used by the parent capability design. */
+const createProjectContext = createProjectDiscovery;
+/** Normalize the only project field that may cross into the credential store. */
+function normalizeProjectId(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	if (normalized.length === 0 || normalized.length > MAX_PROJECT_ID_LENGTH) return void 0;
+	return PROJECT_ID_PATTERN.test(normalized) ? normalized : void 0;
+}
+function parseProjectResponse(value) {
+	if (!isRecord(value)) throw new ProjectDiscoveryError("malformed");
+	if (!Object.prototype.hasOwnProperty.call(value, "cloudaicompanionProject")) return void 0;
+	const candidate = value.cloudaicompanionProject;
+	if (candidate === null || candidate === void 0) return void 0;
+	if (typeof candidate === "string") {
+		if (candidate.trim().length === 0) return void 0;
+		return projectFromValue(candidate);
+	}
+	if (!isRecord(candidate)) throw new ProjectDiscoveryError("protocol-drift");
+	if (!Object.prototype.hasOwnProperty.call(candidate, "id")) return void 0;
+	if (candidate.id === null || candidate.id === void 0) throw new ProjectDiscoveryError("protocol-drift");
+	return projectFromValue(candidate.id);
+}
+function projectFromValue(value) {
+	const projectId = normalizeProjectId(value);
+	if (projectId === void 0) throw new ProjectDiscoveryError("protocol-drift");
+	return { projectId };
+}
+function boundedTimeout(value) {
+	if (value === void 0 || !Number.isFinite(value) || value <= 0) return DEFAULT_OPERATION_TIMEOUT_MS;
+	return Math.min(Math.floor(value), MAX_OPERATION_TIMEOUT_MS);
+}
+const PROJECT_FAILURE_CODES = {
+	authentication: "authentication",
+	forbidden: "forbidden",
+	"rate-limited": "rate-limited",
+	cancelled: "cancelled",
+	timeout: "offline",
+	"attribution-rejected": "protocol-drift",
+	"protocol-drift": "protocol-drift",
+	"response-limit": "protocol-drift",
+	"request-limit": "protocol-drift",
+	upstream: "offline",
+	network: "offline",
+	failed: "offline"
+};
+function mapTransportError(error) {
+	if (error instanceof ProjectDiscoveryError) return error;
+	if (error instanceof PrivateTransportError) return new ProjectDiscoveryError(PROJECT_FAILURE_CODES[classifyPrivateFailure(error)]);
+	return new ProjectDiscoveryError("offline");
+}
+function projectDiscoveryErrorMessage(code) {
+	if (code === "authentication") return "The Antigravity project probe requires authentication";
+	if (code === "forbidden") return "The Antigravity project probe was forbidden";
+	if (code === "rate-limited") return "The Antigravity project probe is rate-limited";
+	if (code === "offline") return "The Antigravity project probe is offline";
+	if (code === "malformed") return "The Antigravity project response was malformed";
+	if (code === "protocol-drift") return "The Antigravity project protocol changed";
+	return "The Antigravity project probe was cancelled";
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { PROJECT_DISCOVERY_ENDPOINT, PROJECT_DISCOVERY_PATH, ProjectDiscoveryError, createProjectContext, createProjectDiscovery, normalizeProjectId };

package/lib/quota.js

@@ -0,0 +1,283 @@
+import { d as privateStatusError, i as DEFAULT_PRIVATE_RESPONSE_BYTES, l as createPrivateTransport, m as PrivateTransportError, p as readPrivateText } from "./private-transport-urF138qW.js";
+import { ANTIGRAVITY_WIRE_ORIGIN } from "./wire-identity.js";
+import { t as classifyPrivateFailure } from "./private-failure-B9vzUkQ7.js";
+//#region src/quota.ts
+/** Single-account Antigravity quota normalization and bounded Host service. */
+const ANTIGRAVITY_QUOTA_ENDPOINT = `${ANTIGRAVITY_WIRE_ORIGIN}/v1internal:retrieveUserQuotaSummary`;
+const QUOTA_REFRESH_MIN_INTERVAL_MS = 3e4;
+/** Normalize only validated, display-safe quota facts from a provider response. */
+function normalizeQuotaResponse(value, now = Date.now()) {
+	const groups = [];
+	const sourceValue = isRecord(value) && isRecord(value.response) ? value.response : value;
+	const source = isRecord(sourceValue) ? sourceValue : void 0;
+	const candidates = source === void 0 ? [] : [
+		...Array.isArray(source.groups) ? source.groups : [],
+		...Array.isArray(source.buckets) ? source.buckets : [],
+		...Array.isArray(source.quotaBuckets) ? source.quotaBuckets : [],
+		...Array.isArray(source.quota_buckets) ? source.quota_buckets : [],
+		...Array.isArray(source.userQuotaSummary) ? source.userQuotaSummary : [],
+		...Array.isArray(source.quotas) ? source.quotas : []
+	];
+	for (const candidate of candidates) {
+		if (!isRecord(candidate)) continue;
+		const buckets = Array.isArray(candidate.buckets) ? candidate.buckets : Array.isArray(candidate.quotaBuckets) ? candidate.quotaBuckets : Array.isArray(candidate.windows) ? candidate.windows : [candidate];
+		for (const rawBucket of buckets) {
+			if (!isRecord(rawBucket)) continue;
+			const window = identifyWindow(rawBucket);
+			const resetTime = normalizeResetTime(rawBucket.resetTime ?? rawBucket.reset_time ?? rawBucket.resetAt ?? rawBucket.reset_at, now);
+			const fraction = normalizeFraction(rawBucket.remainingFraction ?? rawBucket.remaining_fraction ?? rawBucket.fraction ?? rawBucket.remaining ?? rawBucket.remaining_percent ?? rawBucket.percentage);
+			if (window === void 0 || resetTime === void 0 || fraction === void 0) continue;
+			const group = identifyGroup(candidate, rawBucket);
+			if (group === void 0) continue;
+			const modelCount = boundedCount(candidate.modelCount ?? candidate.model_count ?? candidate.models ?? descriptionModelCount(candidate.description));
+			const existing = groups.find((item) => item.group === group);
+			if (existing === void 0) groups.push({
+				group,
+				modelCount,
+				windows: [{
+					window,
+					remainingFraction: fraction,
+					resetTime
+				}]
+			});
+			else if (!existing.windows.some((item) => item.window === window)) {
+				const updated = {
+					group,
+					modelCount: Math.max(existing.modelCount, modelCount),
+					windows: [...existing.windows, {
+						window,
+						remainingFraction: fraction,
+						resetTime
+					}].sort(windowOrder)
+				};
+				groups.splice(groups.indexOf(existing), 1, updated);
+			} else {
+				const updatedWindows = existing.windows.map((item) => item.window === window ? {
+					window,
+					remainingFraction: Math.min(item.remainingFraction, fraction),
+					resetTime: item.resetTime
+				} : item);
+				const updated = {
+					group,
+					modelCount: Math.max(existing.modelCount, modelCount),
+					windows: updatedWindows.sort(windowOrder)
+				};
+				groups.splice(groups.indexOf(existing), 1, updated);
+			}
+		}
+	}
+	if (groups.length === 0) {
+		if (isRecord(source)) return {
+			state: "available",
+			checkedAt: new Date(now).toISOString(),
+			groups: []
+		};
+		throw new QuotaNormalizationError("The quota response did not contain recognized windows");
+	}
+	return {
+		state: "available",
+		checkedAt: new Date(now).toISOString(),
+		groups: groups.sort((left, right) => left.group.localeCompare(right.group))
+	};
+}
+var QuotaNormalizationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "QuotaNormalizationError";
+	}
+};
+function createQuotaService(options) {
+	const now = options.now ?? (() => Date.now());
+	const minInterval = positive(options.minIntervalMs, QUOTA_REFRESH_MIN_INTERVAL_MS);
+	const transport = options.transport ?? createPrivateTransport({
+		...options.transportOptions?.responseHeaderTimeoutMs === void 0 ? {} : { responseHeaderTimeoutMs: options.transportOptions.responseHeaderTimeoutMs },
+		...options.transportOptions?.maxRequestBytes === void 0 ? {} : { maxRequestBytes: options.transportOptions.maxRequestBytes }
+	});
+	let current = { state: "unauthenticated" };
+	let checkedAt = 0;
+	let inFlight;
+	let inFlightAbort;
+	const lifecycleController = new AbortController();
+	let disposed = false;
+	return {
+		refresh: async (signal, force = false) => {
+			if (disposed) return current;
+			if (!force && checkedAt > 0 && now() - checkedAt < minInterval) return current;
+			if (inFlight !== void 0) return await waitForCaller(inFlight, signal);
+			const combined = mergeAbortSignals(void 0, lifecycleController.signal);
+			inFlightAbort = combined.dispose;
+			inFlight = refreshQuota(options.auth, transport, combined.signal, now).then((value) => {
+				current = value;
+				checkedAt = now();
+				return value;
+			}).catch((error) => {
+				current = mapQuotaError(error, now());
+				checkedAt = now();
+				return current;
+			}).finally(() => {
+				combined.dispose();
+				inFlightAbort = void 0;
+				inFlight = void 0;
+			});
+			return await waitForCaller(inFlight, signal);
+		},
+		status: () => current,
+		dispose: async () => {
+			disposed = true;
+			lifecycleController.abort();
+			inFlightAbort?.();
+			await inFlight?.catch(() => {});
+		}
+	};
+}
+async function refreshQuota(auth, transport, signal, now) {
+	const credential = await auth.credential(signal);
+	if (credential === void 0) return { state: "unauthenticated" };
+	const body = credential.projectId ? { project: credential.projectId } : {};
+	let response = await transport.request({
+		url: ANTIGRAVITY_QUOTA_ENDPOINT,
+		accessToken: credential.accessToken,
+		body: JSON.stringify(body),
+		...signal === void 0 ? {} : { signal }
+	});
+	if (response.status === 403 && credential.projectId) try {
+		const retryResponse = await transport.request({
+			url: ANTIGRAVITY_QUOTA_ENDPOINT,
+			accessToken: credential.accessToken,
+			body: JSON.stringify({}),
+			...signal === void 0 ? {} : { signal }
+		});
+		if (retryResponse.ok) response = retryResponse;
+	} catch {}
+	const statusError = privateStatusError(response.status);
+	if (statusError !== void 0) {
+		await response.body?.cancel().catch(() => {});
+		throw statusError;
+	}
+	let value;
+	try {
+		value = JSON.parse(await readPrivateText(response, {
+			...signal === void 0 ? {} : { signal },
+			maxBytes: DEFAULT_PRIVATE_RESPONSE_BYTES
+		}));
+	} catch (error) {
+		if (error instanceof PrivateTransportError) throw error;
+		throw new QuotaNormalizationError("The quota response was not valid JSON");
+	}
+	return normalizeQuotaResponse(value, now());
+}
+const QUOTA_FAILURE_STATES = {
+	authentication: "unauthenticated",
+	forbidden: "forbidden",
+	"rate-limited": "rate-limited",
+	cancelled: "offline",
+	timeout: "timeout",
+	"attribution-rejected": "protocol-drift",
+	"protocol-drift": "protocol-drift",
+	"response-limit": "protocol-drift",
+	"request-limit": "protocol-drift",
+	upstream: "offline",
+	network: "offline",
+	failed: "offline"
+};
+function mapQuotaError(error, checkedAt) {
+	return {
+		state: error instanceof PrivateTransportError ? QUOTA_FAILURE_STATES[classifyPrivateFailure(error)] : error instanceof QuotaNormalizationError ? "protocol-drift" : "offline",
+		checkedAt: new Date(checkedAt).toISOString()
+	};
+}
+function identifyWindow(value) {
+	const raw = String(value.window ?? value.windowType ?? value.window_type ?? value.bucketId ?? value.bucket_id ?? "").toLowerCase();
+	if (raw.includes("5h") || raw.includes("5-hour") || raw.includes("five")) return "5h";
+	if (raw.includes("week") || raw.includes("weekly") || raw.includes("7d")) return "weekly";
+	const seconds = numberValue(value.durationSeconds ?? value.duration_seconds);
+	if (seconds !== void 0) {
+		if (seconds <= 18e3) return "5h";
+		if (seconds <= 691200) return "weekly";
+	}
+}
+function identifyGroup(candidate, bucket) {
+	const raw = [
+		candidate.displayName,
+		candidate.group,
+		candidate.quotaGroup,
+		candidate.quota_group,
+		candidate.modelFamily,
+		candidate.title,
+		candidate.name,
+		candidate.description,
+		bucket?.bucketId,
+		bucket?.bucket_id,
+		bucket?.displayName
+	].filter(Boolean).map(String).join(" ").toLowerCase();
+	if (raw.includes("3p") || raw.includes("non") || raw.includes("claude") || raw.includes("gpt") || raw.includes("openai") || raw.includes("anthropic") || raw.includes("third-party") || raw.includes("external")) return "non-gemini";
+	if (raw.includes("gemini") || raw.includes("google") || raw.includes("chat") || raw.includes("code") || raw.includes("default") || raw.length === 0) return "gemini";
+	return "gemini";
+}
+function normalizeFraction(value) {
+	const number = numberValue(value);
+	if (number === void 0) return void 0;
+	if (number >= 0 && number <= 1) return number;
+	if (number <= 100) return number / 100;
+}
+function normalizeResetTime(value, now) {
+	const parsed = typeof value === "number" ? value < 1e10 ? value * 1e3 : value : typeof value === "string" ? Date.parse(value) : NaN;
+	if (!Number.isFinite(parsed) || parsed < 0 || parsed > 0x5af3107a4000) return void 0;
+	const iso = new Date(parsed).toISOString();
+	return Number.isFinite(Date.parse(iso)) && parsed >= now - 31536e6 ? iso : void 0;
+}
+function boundedCount(value) {
+	if (Array.isArray(value)) return Math.min(value.length, 1e4);
+	const number = numberValue(value);
+	return number === void 0 ? 0 : Math.min(Math.floor(number), 1e4);
+}
+function descriptionModelCount(value) {
+	if (typeof value !== "string" || value.length === 0 || value.length > 16384) return 0;
+	if (!/^[^:]{1,256}:\s*/u.test(value)) return 0;
+	const payload = value.replace(/^[^:]{1,256}:\s*/u, "");
+	return Math.min(payload.split(",").map((item) => item.trim()).filter((item) => item.length > 0).length, 1e4);
+}
+function windowOrder(left, right) {
+	return left.window === right.window ? 0 : left.window === "5h" ? -1 : 1;
+}
+function positive(value, fallback) {
+	return value === void 0 || !Number.isFinite(value) || value <= 0 ? fallback : Math.min(Math.floor(value), 864e5);
+}
+function numberValue(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+async function waitForCaller(promise, signal) {
+	if (signal === void 0) return await promise;
+	if (signal.aborted) throw new PrivateTransportError("cancelled", "The quota request was cancelled", { accepted: false });
+	let remove;
+	const cancellation = new Promise((_, reject) => {
+		const abort = () => reject(new PrivateTransportError("cancelled", "The quota request was cancelled", { accepted: false }));
+		remove = () => signal.removeEventListener("abort", abort);
+		signal.addEventListener("abort", abort, { once: true });
+	});
+	try {
+		return await Promise.race([promise, cancellation]);
+	} finally {
+		remove?.();
+	}
+}
+function mergeAbortSignals(first, second) {
+	const controller = new AbortController();
+	const abort = (event) => {
+		if (!controller.signal.aborted) controller.abort(event.target.reason);
+	};
+	const signals = first === void 0 ? [second] : [first, second];
+	for (const signal of signals) if (signal.aborted) controller.abort(signal.reason);
+	else signal.addEventListener("abort", abort, { once: true });
+	return {
+		signal: controller.signal,
+		dispose: () => {
+			for (const signal of signals) signal.removeEventListener("abort", abort);
+		}
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { ANTIGRAVITY_QUOTA_ENDPOINT, QUOTA_REFRESH_MIN_INTERVAL_MS, QuotaNormalizationError, createQuotaService, normalizeQuotaResponse };

package/lib/replay.js

@@ -0,0 +1,156 @@
+//#region src/replay.ts
+const ANTIGRAVITY_REPLAY_VERSION = 1;
+const MAX_SIGNATURE_LENGTH = 16384;
+const MAX_BLOCKS = 128;
+/** Keep only provider-issued signatures and bounded response facts. */
+function createReplayState(model, family, finish, blocks) {
+	const boundedBlocks = blocks.slice(0, MAX_BLOCKS).map((block) => {
+		const signature = safeSignature(block.signature);
+		return {
+			kind: block.kind,
+			...signature === void 0 ? {} : { signature }
+		};
+	});
+	const boundedFinish = safeFinish(finish);
+	return {
+		response: {
+			version: 1,
+			provider: "google-antigravity",
+			model: model.slice(0, 256),
+			family,
+			...boundedFinish === void 0 ? {} : { finish: boundedFinish }
+		},
+		blocks: boundedBlocks
+	};
+}
+/** Validate replay metadata before it can affect a later private request. */
+function compatibleReplayState(message, provider, model, _blockKinds) {
+	if (provider !== "google-antigravity" || message.role !== "assistant") return void 0;
+	const provenance = isRecord(message.source) ? message.source : void 0;
+	if (provenance !== void 0 && provenance.kind === "model" && (provenance.provider !== provider || provenance.model !== model)) return void 0;
+	const value = isRecord(provenance?.replayState) ? provenance.replayState : isRecord(message.replayState) ? message.replayState : void 0;
+	if (!isRecord(value) || !isRecord(value.response) || !Array.isArray(value.blocks)) return void 0;
+	const family = value.response.family;
+	if (value.response.version !== 1 || value.response.provider !== provider || value.response.model !== model || !isFamily(family) || value.blocks.length > MAX_BLOCKS) return void 0;
+	const blocks = [];
+	for (const item of value.blocks) {
+		if (!isRecord(item) || typeof item.kind !== "string") continue;
+		const kind = item.kind;
+		const signature = typeof item.signature === "string" && safeSignature(item.signature) !== void 0 ? item.signature : void 0;
+		blocks.push({
+			kind,
+			...signature === void 0 ? {} : { signature }
+		});
+	}
+	const finish = value.response.finish === void 0 ? void 0 : safeFinish(value.response.finish);
+	if (value.response.finish !== void 0 && finish === void 0) return void 0;
+	return {
+		response: {
+			version: 1,
+			provider: "google-antigravity",
+			model,
+			family,
+			...finish === void 0 ? {} : { finish }
+		},
+		blocks
+	};
+}
+/** Return the block family without allowing a model alias to cross families. */
+function antigravityModelFamily(model) {
+	const value = model.toLowerCase();
+	if (value.includes("gemini")) return "gemini";
+	if (value.includes("claude")) return "claude";
+	if (value.includes("gpt-oss")) return "gpt-oss";
+	return "unknown";
+}
+/** Convert DSH schemas to the small function-declaration subset accepted privately. */
+function sanitizeToolSchemas(tools) {
+	if (tools === void 0) return [];
+	return tools.slice(0, 64).map((tool) => ({
+		name: boundedName(tool.name),
+		description: boundedText(tool.description, 4096),
+		parameters: sanitizeSchema(tool.parameters)
+	}));
+}
+function buildFunctionDeclarations(tools) {
+	return sanitizeToolSchemas(tools).map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.parameters
+	}));
+}
+function sanitizeSchema(value, depth = 0) {
+	if (depth > 8 || !isRecord(value)) return {
+		type: "object",
+		properties: {}
+	};
+	const type = typeof value.type === "string" && [
+		"object",
+		"array",
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"null"
+	].includes(value.type) ? value.type : "object";
+	const output = { type };
+	if (typeof value.description === "string") output.description = boundedText(value.description, 1024);
+	if (Array.isArray(value.required)) output.required = value.required.filter((item) => typeof item === "string").slice(0, 128);
+	if (Array.isArray(value.enum)) output.enum = value.enum.slice(0, 128).filter((item) => [
+		"string",
+		"number",
+		"boolean",
+		"null"
+	].includes(typeof item));
+	if (type === "object" && isRecord(value.properties)) {
+		const properties = {};
+		for (const [key, item] of Object.entries(value.properties).slice(0, 128)) if (!hasControl(key) && key.length > 0) properties[key.slice(0, 128)] = sanitizeSchema(item, depth + 1);
+		output.properties = properties;
+	}
+	if (type === "array") output.items = sanitizeSchema(value.items, depth + 1);
+	if (Array.isArray(value.oneOf)) output.oneOf = value.oneOf.slice(0, 8).map((item) => sanitizeSchema(item, depth + 1));
+	return output;
+}
+function safeFinish(value) {
+	if (typeof value !== "string" || value.length === 0 || value.length > 128) return void 0;
+	const normalized = value.toUpperCase();
+	return [
+		"STOP",
+		"MAX_TOKENS",
+		"LENGTH",
+		"TOOL_CALLS",
+		"FUNCTION_CALL",
+		"SAFETY",
+		"BLOCKLIST",
+		"ERROR"
+	].includes(normalized) ? normalized : void 0;
+}
+function safeSignature(value) {
+	if (typeof value !== "string" || value.length === 0 || value.length > MAX_SIGNATURE_LENGTH) return void 0;
+	for (const character of value) {
+		const code = character.charCodeAt(0);
+		if (code < 32 || code === 127) return void 0;
+	}
+	return value;
+}
+function boundedName(value) {
+	return typeof value === "string" && value.length > 0 && !hasControl(value) ? value.slice(0, 128) : "unnamed_tool";
+}
+function boundedText(value, limit) {
+	return typeof value === "string" && !hasControl(value) ? value.slice(0, limit) : "";
+}
+function hasControl(value) {
+	for (const character of value) {
+		const code = character.charCodeAt(0);
+		if (code < 32 || code === 127) return true;
+	}
+	return false;
+}
+function isFamily(value) {
+	return value === "gemini" || value === "claude" || value === "gpt-oss" || value === "unknown";
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { ANTIGRAVITY_REPLAY_VERSION, antigravityModelFamily, buildFunctionDeclarations, compatibleReplayState, createReplayState, sanitizeToolSchemas };