@gajae-code/coding-agent 0.11.7 → 0.11.9

package/src/tools/image-gen.ts

@@ -41,10 +41,12 @@ const OPENAI_IMAGE_OUTPUT_FORMAT = "webp";
 const OPENAI_IMAGE_MIME_TYPE = "image/webp";
 
 const ANTIGRAVITY_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+const ALIBABA_TOKEN_PLAN_HOST = "https://token-plan.ap-southeast-1.maas.aliyuncs.com";
+const ALIBABA_IMAGE_GENERATION_URL = `${ALIBABA_TOKEN_PLAN_HOST}/api/v1/services/aigc/multimodal-generation/generation`;
 const IMAGE_SYSTEM_INSTRUCTION =
 	"You are an AI image generator. Generate images based on user descriptions. Focus on creating high-quality, visually appealing images that match the user's request.";
 
-type ImageProvider = "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter";
+type ImageProvider = "alibaba" | "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter";
 interface ImageApiKey {
 	provider: ImageProvider;
 	apiKey: string;
@@ -296,6 +298,81 @@ interface AntigravityResponseChunk {
 	};
 }
 
+interface AlibabaImageContentPart {
+	type?: string;
+	text?: string;
+	image?: string;
+}
+
+interface AlibabaImageResponse {
+	code?: string;
+	message?: string;
+	output?: {
+		choices?: Array<{ message?: { content?: AlibabaImageContentPart[] } }>;
+	};
+}
+
+/** Map the tool's image_size values onto wan2.7's 1K/2K size classes. */
+export function resolveAlibabaImageSize(imageSize: string | undefined): string | undefined {
+	switch (imageSize) {
+		case "1024x1024":
+			return "1K";
+		case "1536x1024":
+		case "1024x1536":
+			return "2K";
+		default:
+			return undefined;
+	}
+}
+
+/**
+ * Build the Bailian multimodal-generation request body for wan2.7 image
+ * generation/editing. Input images ride along as data URLs; generation-only
+ * calls send just the prompt text. The sync endpoint returns OSS URLs inline.
+ */
+export function buildAlibabaImageRequest(
+	model: string,
+	promptText: string,
+	inputImages: InlineImageData[],
+	imageSize: string | undefined,
+): {
+	model: string;
+	input: { messages: Array<{ role: "user"; content: Array<{ text: string } | { image: string }> }> };
+	parameters: { n: number; watermark: boolean; size?: string };
+} {
+	const content: Array<{ text: string } | { image: string }> = [];
+	for (const image of inputImages) {
+		content.push({ image: toDataUrl(image) });
+	}
+	content.push({ text: promptText });
+	const size = resolveAlibabaImageSize(imageSize);
+	return {
+		model,
+		input: { messages: [{ role: "user", content }] },
+		parameters: { n: 1, watermark: false, ...(size ? { size } : {}) },
+	};
+}
+
+/** Collect OSS image URLs and any text parts from a Bailian image response. */
+export function collectAlibabaImageResult(response: AlibabaImageResponse): {
+	imageUrls: string[];
+	responseText?: string;
+} {
+	const imageUrls: string[] = [];
+	const textParts: string[] = [];
+	for (const choice of response.output?.choices ?? []) {
+		for (const part of choice.message?.content ?? []) {
+			if (part.image) {
+				imageUrls.push(part.image);
+			} else if (part.text) {
+				textParts.push(part.text);
+			}
+		}
+	}
+	const responseText = textParts.join("\n").trim();
+	return { imageUrls, responseText: responseText.length > 0 ? responseText : undefined };
+}
+
 interface ImageGenToolDetails {
 	provider: ImageProvider;
 	model: string;
@@ -585,6 +662,7 @@ export function setPreferredImageProvider(provider: ImageProvider | "auto"): voi
 /** Provider → default image model mapping for auto-binding */
 export const IMAGE_PROVIDER_DEFAULTS: Record<string, string> = {
 	openai: "gpt-image-2",
+	alibaba: "wan2.7-image",
 	"openai-codex": "gpt-image-2",
 	antigravity: "gemini-3-pro-image",
 	gemini: "gemini-3-pro-image-preview",
@@ -704,6 +782,18 @@ async function findOpenAIHostedImageCredentials(
 	};
 }
 
+async function findAlibabaImageCredentials(
+	modelRegistry: ModelRegistry | undefined,
+	sessionId?: string,
+): Promise<ImageApiKey | null> {
+	const envKey = getEnvApiKey("alibaba-token-plan");
+	if (envKey) return { provider: "alibaba", apiKey: envKey };
+	if (!modelRegistry) return null;
+	const apiKey = await modelRegistry.getApiKeyForProvider("alibaba-token-plan", sessionId);
+	if (!isAuthenticated(apiKey)) return null;
+	return { provider: "alibaba", apiKey };
+}
+
 async function findImageApiKey(
 	modelRegistry?: ModelRegistry,
 	activeModel?: Model,
@@ -744,6 +834,9 @@ async function findImageApiKey(
 			const openRouterKey = getEnvApiKey("openrouter");
 			return openRouterKey ? { provider: "openrouter", apiKey: openRouterKey } : null;
 		}
+		if (config.provider === "alibaba") {
+			return await findAlibabaImageCredentials(modelRegistry, sessionId);
+		}
 	}
 
 	// If a specific provider is preferred (legacy path), try it first.
@@ -762,9 +855,11 @@ async function findImageApiKey(
 	} else if (preferredImageProvider === "openrouter") {
 		const openRouterKey = getEnvApiKey("openrouter");
 		return openRouterKey ? { provider: "openrouter", apiKey: openRouterKey } : null;
+	} else if (preferredImageProvider === "alibaba") {
+		return await findAlibabaImageCredentials(modelRegistry, sessionId);
 	}
 
-	// Auto-detect: GPT hosted image generation, then Antigravity, OpenRouter, Gemini.
+	// Auto-detect: GPT hosted image generation, then Antigravity, OpenRouter, Gemini, Alibaba.
 	const openAI = await findOpenAIHostedImageCredentials(modelRegistry, activeModel, sessionId);
 	if (openAI) return openAI;
 
@@ -782,6 +877,9 @@ async function findImageApiKey(
 	const googleKey = $env.GOOGLE_API_KEY;
 	if (googleKey) return { provider: "gemini", apiKey: googleKey };
 
+	const alibaba = await findAlibabaImageCredentials(modelRegistry, sessionId);
+	if (alibaba) return alibaba;
+
 	return null;
 }
 
@@ -1218,7 +1316,7 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 			const apiKey = await findImageApiKey(ctx.modelRegistry, ctx.model, sessionId);
 			if (!apiKey) {
 				throw new Error(
-					"No image API credentials found. Use a GPT Responses/Codex model with OpenAI credentials, login with google-antigravity, or set OPENROUTER_API_KEY, GEMINI_API_KEY, or GOOGLE_API_KEY.",
+					"No image API credentials found. Use a GPT Responses/Codex model with OpenAI credentials, login with google-antigravity, or set OPENROUTER_API_KEY, GEMINI_API_KEY, GOOGLE_API_KEY, or ALIBABA_TOKEN_PLAN_API_KEY.",
 				);
 			}
 
@@ -1230,9 +1328,11 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 						? (apiKey.model?.id ?? resolveImageModel(provider, null))
 						: provider === "antigravity"
 							? resolveImageModel("antigravity", null)
-							: provider === "openrouter"
-								? resolveImageModel("openrouter", null)
-								: resolveImageModel("gemini", null);
+							: provider === "alibaba"
+								? resolveImageModel("alibaba", null)
+								: provider === "openrouter"
+									? resolveImageModel("openrouter", null)
+									: resolveImageModel("gemini", null);
 			const resolvedModel = provider === "openrouter" ? resolveOpenRouterModel(model) : model;
 			const cwd = ctx.sessionManager.getCwd();
 
@@ -1450,6 +1550,78 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 				};
 			}
 
+			if (provider === "alibaba") {
+				const requestBody = buildAlibabaImageRequest(
+					model,
+					assemblePrompt(params),
+					resolvedImages,
+					params.image_size,
+				);
+
+				const response = await fetch(ALIBABA_IMAGE_GENERATION_URL, {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: `Bearer ${apiKey.apiKey}`,
+					},
+					body: JSON.stringify(requestBody),
+					signal: requestSignal,
+				});
+
+				const rawText = await response.text();
+				if (!response.ok) {
+					let message = rawText;
+					try {
+						const parsed = JSON.parse(rawText) as { message?: string; error?: { message?: string } };
+						message = parsed.error?.message ?? parsed.message ?? message;
+					} catch {
+						// Keep raw text.
+					}
+					throw new Error(`Alibaba image request failed (${response.status}): ${message}`);
+				}
+
+				const data = JSON.parse(rawText) as AlibabaImageResponse;
+				if (data.code) {
+					throw new Error(`Alibaba image request failed: ${data.code}: ${data.message ?? ""}`.trim());
+				}
+
+				const { imageUrls, responseText } = collectAlibabaImageResult(data);
+				// Result URLs are short-lived OSS-signed URLs (24h); download immediately.
+				const inlineImages: InlineImageData[] = [];
+				for (const imageUrl of imageUrls) {
+					inlineImages.push(await loadImageFromUrl(imageUrl, requestSignal));
+				}
+
+				if (inlineImages.length === 0) {
+					const messageText = responseText ? `\n\n${responseText}` : "";
+					return {
+						content: [{ type: "text", text: `No image data returned.${messageText}` }],
+						details: {
+							provider,
+							model,
+							imageCount: 0,
+							imagePaths: [],
+							images: [],
+							responseText,
+						},
+					};
+				}
+
+				const imagePaths = await saveImagesToTemp(inlineImages);
+
+				return {
+					content: [{ type: "text", text: buildResponseSummary(provider, model, imagePaths, responseText) }],
+					details: {
+						provider,
+						model,
+						imageCount: inlineImages.length,
+						imagePaths,
+						images: inlineImages,
+						responseText,
+					},
+				};
+			}
+
 			const parts = [] as Array<{ text?: string; inlineData?: InlineImageData }>;
 			for (const image of resolvedImages) {
 				parts.push({ inlineData: image });

package/src/tools/index.ts

@@ -137,6 +137,8 @@ export interface AskAnswerRequest {
 	options: string[];
 	interaction: "selector" | "custom_editor" | "clarification_editor";
 	controls: readonly AskRemoteControl[];
+	/** Optional zero-based recommendation into the authoritative raw options. */
+	recommendedIndex?: number;
 }
 
 export type AskRemoteInteraction =
@@ -232,6 +234,8 @@ export interface ToolSession {
 	 *  its terminal-phase chain guard. Returns the raw phase string or undefined
 	 *  when no active skill (or accessor) is available. */
 	getActiveSkillPhase?: () => string | undefined;
+	/** Restrict provider-facing deep-interview ask metadata to the active workflow stage. */
+	getDeepInterviewAskStage?: () => "topology" | "post-topology" | undefined;
 	/** Pre-loaded prompt templates */
 	promptTemplates?: PromptTemplate[];
 	/** Whether LSP integrations are enabled */

package/src/tools/render-utils.ts

@@ -571,7 +571,13 @@ export function truncateDiffByHunk(
 export function shortenPath(filePath: string, homeDir?: string): string {
 	if (typeof filePath !== "string") return "";
 	const home = homeDir ?? os.homedir();
-	if (home && filePath.startsWith(home)) {
+	if (!home) return filePath;
+	// Only abbreviate paths that are exactly home or genuinely inside it. A bare
+	// startsWith(home) also matches siblings that merely share the prefix
+	// (e.g. "/home/woodyx/notes.txt" for home "/home/woody"), which would corrupt
+	// them into "~x/notes.txt"; require a path-separator boundary after home.
+	const boundary = home.endsWith(path.sep) ? home : home + path.sep;
+	if (filePath === home || filePath.startsWith(boundary)) {
 		return `~${filePath.slice(home.length)}`;
 	}
 	return filePath;

package/src/utils/edit-mode.ts

@@ -1,4 +1,4 @@
-import { $env } from "@gajae-code/utils/env";
+import { $pickenv } from "@gajae-code/utils/env";
 
 export type EditMode = "replace" | "patch" | "hashline" | "vim" | "apply_patch";
 
@@ -34,7 +34,7 @@ export function resolveEditMode(session: EditModeSessionLike): EditMode {
 	const modelVariant = session.settings.getEditVariantForModel?.(activeModel);
 	if (modelVariant) return modelVariant;
 
-	const envMode = normalizeEditMode($env.PI_EDIT_VARIANT);
+	const envMode = normalizeEditMode($pickenv("GJC_EDIT_VARIANT", "PI_EDIT_VARIANT"));
 	if (envMode) return envMode;
 
 	const settingsMode = normalizeEditMode(String(session.settings.get("edit.mode") ?? ""));

package/src/utils/prompt-suggestion.ts

@@ -0,0 +1,265 @@
+/**
+ * Predict the user's likely next prompt after an agent turn using a smol,
+ * fast model. Native GJC port of the ghost-text prompt-suggestion behavior
+ * from Claude Code: the prediction renders as dim ghost text in the empty
+ * composer and Tab accepts it.
+ */
+import type { AgentMessage } from "@gajae-code/agent-core";
+import { type Api, type AssistantMessage, completeSimple, type Model } from "@gajae-code/ai";
+import { logger, prompt } from "@gajae-code/utils";
+import type { ModelRegistry } from "../config/model-registry";
+import { resolveRoleSelection } from "../config/model-resolver";
+import type { Settings } from "../config/settings";
+import suggestionSystemPrompt from "../prompts/system/prompt-suggestion-system.md" with { type: "text" };
+
+const SUGGESTION_SYSTEM_PROMPT = prompt.render(suggestionSystemPrompt);
+
+export const PROMPT_SUGGESTION_MAX_WORDS = 12;
+export const PROMPT_SUGGESTION_MAX_CHARS = 100;
+
+const SUGGESTION_MAX_TOKENS = 64;
+const REASONING_SAFE_MAX_TOKENS = 1024;
+const MAX_CONTEXT_MESSAGES = 12;
+const MAX_MESSAGE_CHARS = 1500;
+const MAX_CONTEXT_CHARS = 8000;
+
+/** Single words a user plausibly types on their own; anything else needs >= 2 words. */
+const SINGLE_WORD_ALLOWLIST = new Set([
+	"yes",
+	"yeah",
+	"yep",
+	"yea",
+	"yup",
+	"sure",
+	"ok",
+	"okay",
+	"push",
+	"commit",
+	"deploy",
+	"stop",
+	"continue",
+	"check",
+	"exit",
+	"quit",
+	"no",
+]);
+
+/** Model responses that are meta-statements about staying silent, not suggestions. */
+const META_TEXT_PATTERN = /\bsilence is\b|\bstay(s|ing)? silent\b/;
+
+/**
+ * Strip wrapper tags and label prefixes a model sometimes adds despite being
+ * told to reply with only the suggestion.
+ */
+export function sanitizePromptSuggestion(raw: string): string {
+	return raw
+		.trim()
+		.replace(/^<(suggestion|response|output|answer|result)>([\s\S]*)<\/\1>$/i, (match, tag: string, inner: string) =>
+			// Keep the original when the inner text itself contains the closing
+			// tag (nested/ambiguous markup) instead of producing a mangled strip.
+			inner.includes(`</${tag.toLowerCase()}>`) || inner.includes(`</${tag.toUpperCase()}>`) ? match : inner,
+		)
+		.replace(
+			/^\s*(suggested\s+(response|reply|input|prompt)|suggestion|response|reply|answer|output|result)\s*:\s*/i,
+			"",
+		)
+		.trim();
+}
+
+/**
+ * Heuristic gate rejecting model output that would make a bad ghost-text
+ * suggestion. Returns the rejection reason, or null when the text is usable.
+ */
+export function suppressPromptSuggestionReason(text: string): string | null {
+	if (!text) return "empty";
+	const lower = text.toLowerCase();
+	const wordCount = text.trim().split(/\s+/).length;
+
+	if (lower === "done") return "done";
+	if (
+		lower === "nothing found" ||
+		lower === "nothing found." ||
+		lower.startsWith("nothing to suggest") ||
+		lower.startsWith("no suggestion") ||
+		META_TEXT_PATTERN.test(lower) ||
+		/^\W*silence\W*$/.test(lower)
+	) {
+		return "meta_text";
+	}
+	if (/^\(.*\)$|^\[.*\]$/.test(text)) return "meta_wrapped";
+	if (
+		lower.startsWith("api error:") ||
+		lower.startsWith("prompt is too long") ||
+		lower.startsWith("request timed out") ||
+		lower.startsWith("invalid api key")
+	) {
+		return "error_message";
+	}
+	if (/^\w+:\s/.test(text)) return "prefixed_label";
+	if (wordCount < 2 && !text.startsWith("/") && !SINGLE_WORD_ALLOWLIST.has(lower)) return "too_few_words";
+	if (wordCount > PROMPT_SUGGESTION_MAX_WORDS) return "too_many_words";
+	if (text.length >= PROMPT_SUGGESTION_MAX_CHARS) return "too_long";
+	if (/[.!?]\s+[A-Z]/.test(text)) return "multiple_sentences";
+	if (/[\n*]|\*\*/.test(text)) return "has_formatting";
+	if (
+		/thanks|thank you|looks good|sounds good|that works|that worked|that's all|nice|great|perfect|makes sense|awesome|excellent/.test(
+			lower,
+		)
+	) {
+		return "evaluative";
+	}
+	if (
+		/^(let me|i'll|i've|i'm|i can|i would|i think|i notice|here's|here is|here are|that's|this is|this will|you can|you should|you could|sure,|of course|certainly)/i.test(
+			text,
+		)
+	) {
+		return "claude_voice";
+	}
+	return null;
+}
+
+function extractTranscriptEntry(message: AgentMessage): { role: "User" | "Assistant"; text: string } | null {
+	if (message.role === "user") {
+		const content = message.content;
+		const text =
+			typeof content === "string"
+				? content
+				: content
+						.filter(block => block.type === "text")
+						.map(block => block.text)
+						.join("\n");
+		const trimmed = text.trim();
+		return trimmed ? { role: "User", text: trimmed } : null;
+	}
+	if (message.role === "assistant") {
+		const text = (message as AssistantMessage).content
+			.filter(block => block.type === "text")
+			.map(block => block.text)
+			.join("\n")
+			.trim();
+		return text ? { role: "Assistant", text } : null;
+	}
+	return null;
+}
+
+/**
+ * Build a compact recent-conversation transcript for the prediction request.
+ * Returns null when there is no user message to predict from.
+ */
+export function buildPromptSuggestionContext(messages: AgentMessage[]): string | null {
+	const entries: { role: "User" | "Assistant"; text: string }[] = [];
+	let totalChars = 0;
+	for (let index = messages.length - 1; index >= 0 && entries.length < MAX_CONTEXT_MESSAGES; index--) {
+		const message = messages[index];
+		if (!message) continue;
+		const entry = extractTranscriptEntry(message);
+		if (!entry) continue;
+		const text = entry.text.length > MAX_MESSAGE_CHARS ? `${entry.text.slice(0, MAX_MESSAGE_CHARS)}…` : entry.text;
+		if (totalChars + text.length > MAX_CONTEXT_CHARS && entries.length > 0) break;
+		entries.push({ role: entry.role, text });
+		totalChars += text.length;
+	}
+	if (!entries.some(entry => entry.role === "User")) return null;
+	entries.reverse();
+	const transcript = entries.map(entry => `${entry.role}: ${entry.text}`).join("\n\n");
+	return `<conversation>\n${transcript}\n</conversation>\n\nPredict the user's next message.`;
+}
+
+function getSuggestionModel(
+	registry: ModelRegistry,
+	settings: Settings,
+	currentModel?: Model<Api>,
+): Model<Api> | undefined {
+	const availableModels = registry.getAvailable();
+	if (availableModels.length === 0) return undefined;
+	const model = resolveRoleSelection(["default"], settings, availableModels, registry)?.model;
+	if (model) return model;
+	return currentModel;
+}
+
+function extractSuggestionText(contentBlocks: AssistantMessage["content"]): string {
+	let text = "";
+	for (const content of contentBlocks) {
+		if (content.type === "text") {
+			text += content.text;
+		}
+	}
+	return text;
+}
+
+/**
+ * Generate a predicted next user prompt from the recent conversation.
+ * Returns null when no usable suggestion is produced (silence is the
+ * expected steady state).
+ */
+export async function generatePromptSuggestion(
+	messages: AgentMessage[],
+	registry: ModelRegistry,
+	settings: Settings,
+	sessionId?: string,
+	currentModel?: Model<Api>,
+	metadataResolver?: (provider: string) => Record<string, unknown> | undefined,
+): Promise<string | null> {
+	const context = buildPromptSuggestionContext(messages);
+	if (!context) return null;
+
+	const model = getSuggestionModel(registry, settings, currentModel);
+	if (!model) {
+		logger.debug("prompt-suggestion: no model available");
+		return null;
+	}
+
+	const apiKey = await registry.getApiKey(model, sessionId);
+	if (!apiKey) {
+		logger.debug("prompt-suggestion: no API key", { provider: model.provider, id: model.id });
+		return null;
+	}
+	// Resolve metadata after getApiKey so the session-sticky credential for
+	// this request is already recorded (same contract as title-generator).
+	const metadata = metadataResolver?.(model.provider);
+
+	// A suggestion is a 2-12 word task, but some reasoning backends ignore
+	// disableReasoning; reserve output room for the answer after any
+	// unavoidable thinking tokens.
+	const maxTokens = model.reasoning
+		? Math.max(SUGGESTION_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS)
+		: SUGGESTION_MAX_TOKENS;
+
+	try {
+		const response = await completeSimple(
+			model,
+			{
+				systemPrompt: [SUGGESTION_SYSTEM_PROMPT],
+				messages: [{ role: "user", content: context, timestamp: Date.now() }],
+			},
+			{
+				apiKey,
+				maxTokens,
+				disableReasoning: true,
+				metadata,
+			},
+		);
+
+		if (response.stopReason === "error") {
+			logger.debug("prompt-suggestion: response error", {
+				model: `${model.provider}/${model.id}`,
+				errorMessage: response.errorMessage,
+			});
+			return null;
+		}
+
+		const suggestion = sanitizePromptSuggestion(extractSuggestionText(response.content));
+		const suppressReason = suppressPromptSuggestionReason(suggestion);
+		if (suppressReason) {
+			logger.debug("prompt-suggestion: suppressed", { reason: suppressReason });
+			return null;
+		}
+		return suggestion;
+	} catch (err) {
+		logger.debug("prompt-suggestion: error", {
+			model: `${model.provider}/${model.id}`,
+			error: err instanceof Error ? err.message : String(err),
+		});
+		return null;
+	}
+}

package/src/utils/sixel.ts

@@ -1,4 +1,4 @@
-import { $env, $flag } from "@gajae-code/utils";
+import { $pickenv, $pickflag } from "@gajae-code/utils";
 
 const SIXEL_START_REGEX = /\x1bP(?:[0-9;]*)q/u;
 const SIXEL_END_SEQUENCE = "\x1b\\";
@@ -14,8 +14,8 @@ const SIXEL_PLACEHOLDER_PREFIX = "__GJC_SIXEL_SEQUENCE_";
  * - PI_ALLOW_SIXEL_PASSTHROUGH=1
  */
 export function isSixelPassthroughEnabled(): boolean {
-	const forcedProtocol = $env.PI_FORCE_IMAGE_PROTOCOL?.trim().toLowerCase();
-	return forcedProtocol === "sixel" && $flag("PI_ALLOW_SIXEL_PASSTHROUGH");
+	const forcedProtocol = $pickenv("GJC_FORCE_IMAGE_PROTOCOL", "PI_FORCE_IMAGE_PROTOCOL")?.trim().toLowerCase();
+	return forcedProtocol === "sixel" && $pickflag("GJC_ALLOW_SIXEL_PASSTHROUGH", "PI_ALLOW_SIXEL_PASSTHROUGH");
 }
 /** Returns true when the text contains a SIXEL start sequence. */
 export function containsSixelSequence(text: string): boolean {

package/src/web/insane/url-guard.ts

@@ -244,8 +244,10 @@ export async function guardedPublicFetch(
 		logicalUrl.protocol === "https:"
 			? { rejectUnauthorized: true, ...(net.isIP(hostname) === 0 ? { serverName: hostname } : {}) }
 			: undefined;
+	const method = (init.method ?? "GET").toUpperCase();
+	const addresses = method === "GET" || method === "HEAD" ? guard.addresses : guard.addresses.slice(0, 1);
 	let lastError: unknown;
-	for (const address of guard.addresses) {
+	for (const address of addresses) {
 		if (hasConfiguredProxy(process.env)) {
 			return { ok: false, reason: "proxy routing appeared during resolution", logicalUrl: rawUrl };
 		}

package/src/web/scrapers/docs-rs.ts

@@ -299,7 +299,21 @@ async function readCachedRustdocCrate(
 ): Promise<{ crate: RustdocCrate; fetchedAt: string } | null> {
 	const cachePath = getDocsRsCachePath(target);
 	try {
-		const [jsonStr, stat] = await Promise.all([Bun.file(cachePath).text(), fs.stat(cachePath)]);
+		const stat = await fs.stat(cachePath);
+		if (stat.size > MAX_BYTES) {
+			await fs.rm(cachePath, { force: true });
+			return null;
+		}
+
+		const cacheBytes = await Bun.file(cachePath)
+			.slice(0, MAX_BYTES + 1)
+			.arrayBuffer();
+		if (cacheBytes.byteLength > MAX_BYTES) {
+			await fs.rm(cachePath, { force: true });
+			return null;
+		}
+
+		const jsonStr = Buffer.from(cacheBytes).toString("utf-8");
 		const crate = tryParseJson<RustdocCrate>(jsonStr);
 		if (!crate?.index) return null;
 		return { crate, fetchedAt: stat.mtime.toISOString() };
@@ -378,11 +392,22 @@ export const handleDocsRs: SpecialHandler = async (
 		const requestSignal = ptree.combineSignals(signal, timeout * 1000);
 		const response = await fetch(jsonUrl, {
 			signal: requestSignal,
-			headers: { "User-Agent": "gjc-web-fetch/1.0", Accept: "application/gzip" },
+			headers: {
+				"User-Agent": "gjc-web-fetch/1.0",
+				Accept: "application/gzip",
+				"Accept-Encoding": "identity",
+			},
 			redirect: "follow",
+			decompress: false,
 		});
 		if (!response.ok) return null;
 
+		const contentEncoding = response.headers.get("Content-Encoding");
+		if (contentEncoding && contentEncoding.trim().toLowerCase() !== "identity") {
+			await response.body?.cancel();
+			return null;
+		}
+
 		const reader = response.body?.getReader();
 		if (!reader) return null;
 
@@ -394,13 +419,13 @@ export const handleDocsRs: SpecialHandler = async (
 			chunks.push(value);
 			totalSize += value.length;
 			if (totalSize > MAX_BYTES) {
-				reader.cancel();
-				break;
+				await reader.cancel();
+				return null;
 			}
 		}
 
 		const compressed = Buffer.concat(chunks);
-		const jsonStr = gunzipSync(compressed).toString("utf-8");
+		const jsonStr = gunzipSync(compressed, { maxOutputLength: MAX_BYTES }).toString("utf-8");
 		crate_ = tryParseJson<RustdocCrate>(jsonStr);
 		if (crate_?.index) {
 			await writeCachedRustdocCrate(target, jsonStr);