@eddyskywalker/dsh-chatgpt-subscription 0.11.5 → 0.12.1

package/lib/index.js

@@ -2984,6 +2984,24 @@ var CodexAccountPool = class extends AccountPoolCore {
 	}
 };
 //#endregion
+//#region src/host/fetch-configuration.ts
+const DEFAULT_FETCH_MAX_BODY_CHARS = 1e5;
+const DEFAULT_FETCH_MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+function positiveFetchLimit(value, fallback, name) {
+	const resolved = value === void 0 ? fallback : value;
+	if (!Number.isSafeInteger(resolved) || resolved < 1) throw new Error(`${name} must be a positive safe integer.`);
+	return resolved;
+}
+function resolveFetchConfiguration(config) {
+	const fetchProvider = config.fetchProvider ?? "auto";
+	if (fetchProvider !== "auto" && fetchProvider !== "plugin" && fetchProvider !== "dsh") throw new Error("fetchProvider must be auto, plugin, or dsh.");
+	return {
+		fetchProvider,
+		fetchMaxBodyChars: positiveFetchLimit(config.fetchMaxBodyChars, DEFAULT_FETCH_MAX_BODY_CHARS, "fetchMaxBodyChars"),
+		fetchMaxResponseBytes: positiveFetchLimit(config.fetchMaxResponseBytes, DEFAULT_FETCH_MAX_RESPONSE_BYTES, "fetchMaxResponseBytes")
+	};
+}
+//#endregion
 //#region src/host/fetch-address-policy.ts
 /**
 * Destination policy for this plugin's fetch provider.
@@ -3001,7 +3019,8 @@ var CodexAccountPool = class extends AccountPoolCore {
 * proxy on this machine must not become a path into loopback or a LAN — and it
 * also refuses a name this machine resolves into private space. Only the proxy's
 * own fake-ip answers are accepted, since that is what the proxy's name
-* resolution looks like from here; the URL hostname still reaches the proxy
+* resolution looks like from here: the IPv4 one, and the IPv6 one only beside it
+* (see assertPublicFetchTarget). The URL hostname still reaches the proxy
 * intact, so the proxy decides where the name really goes.
 *
 * @module dsh-chatgpt-subscription/fetch-address-policy
@@ -3114,11 +3133,22 @@ function isNonPublicIpLiteral(hostname) {
 */
 function assertPublicFetchTarget(hostname, addresses) {
 	if (isNonPublicIpLiteral(hostname)) throw new WebError(`URL hostname "${hostname}" is not a public IP address`, "WEB_BLOCKED_URL");
+	const claimedByProxy = addresses.some(isProxyFakeIpAddress);
 	for (const address of addresses) {
 		if (isPublicIpAddress(address) || isProxyFakeIpAddress(address)) continue;
+		if (claimedByProxy && isUnassignedUniqueLocal(address)) continue;
 		throw new WebError(`URL hostname "${hostname}" resolves to a non-public IP address`, "WEB_BLOCKED_URL");
 	}
 }
+/**
+* Whether an IPv6 address is inside fc00::/8: the unique-local half RFC 4193
+* leaves unassigned (real unique-local networks are numbered from fd00::/8), and
+* where proxies place their IPv6 fake-ip range.
+*/
+function isUnassignedUniqueLocal(address) {
+	const words = ipv6Words(unbracket(address));
+	return words !== void 0 && (words[0] ?? 0) >> 8 === 252;
+}
 /** Whether a dotted quad is public, using {@link NON_PUBLIC_IPV4}. */
 function isPublicIpv4(address) {
 	const value = ipv4Value(address);
@@ -3204,12 +3234,10 @@ function unbracket(hostname) {
 }
 //#endregion
 //#region src/host/codex-fetch.ts
-const DEFAULT_MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
-const DEFAULT_MAX_BODY_CHARS = 1e5;
 function createCodexFetchProvider(options = {}) {
 	const fetchFn = options.fetchFn ?? fetch;
-	const maxResponseBytes = options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
-	const maxBodyChars = options.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS;
+	const maxResponseBytes = positiveFetchLimit(options.maxResponseBytes, DEFAULT_FETCH_MAX_RESPONSE_BYTES, "maxResponseBytes");
+	const maxBodyChars = positiveFetchLimit(options.maxBodyChars, DEFAULT_FETCH_MAX_BODY_CHARS, "maxBodyChars");
 	const resolveHostAddresses = options.resolveHostAddresses ?? lookupHostAddresses;
 	return {
 		id: CODEX_FETCH_PROVIDER_ID,
@@ -7363,7 +7391,7 @@ function identityKey(credentials) {
 //#endregion
 //#region src/host/routes.ts
 const MAX_BODY_BYTES$6 = 64 * 1024;
-function registerRoutes(ctx, oauth, usage, preferences, proxyManager, searchSwitcher, routeAudit, accountPool) {
+function registerRoutes(ctx, oauth, usage, preferences, proxyManager, searchSwitcher, routeAudit, accountPool, fetchConfiguration) {
 	const handler = async (request, response) => {
 		const url = new URL(request.url ?? "/", "http://dsh.local");
 		if (request.method === "GET" && url.pathname === `/api/dsh-chatgpt-subscription/status`) {
@@ -7378,7 +7406,8 @@ function registerRoutes(ctx, oauth, usage, preferences, proxyManager, searchSwit
 					preferences: preferences.status(),
 					detectedProxy: proxyManager?.getSystemProxy() ?? null,
 					activeProxy: proxyManager?.resolveActiveProxyUrl() ?? null,
-					switcher: searchSwitcher?.status() ?? null
+					switcher: searchSwitcher?.status() ?? null,
+					fetchConfiguration
 				}
 			});
 			return;
@@ -7790,10 +7819,13 @@ var SearchProviderSwitcher = class {
 		}
 		const codexSelected = preference === SEARCH_PROVIDER_CODEX;
 		const nextSearch = codexSelected ? CODEX_SEARCH_PROVIDER_ID : this.originalSearchProvider;
-		const nextFetch = codexSelected || options.pluginFetch === true ? CODEX_FETCH_PROVIDER_ID : this.originalFetchProvider;
+		const nextFetch = options.fetchProvider === "plugin" || options.fetchProvider !== "dsh" && (codexSelected || options.pluginFetch === true) ? CODEX_FETCH_PROVIDER_ID : this.originalFetchProvider;
 		const configured = config.searchProvider === nextSearch && config.fetchProvider === nextFetch;
 		const applied = running === void 0 || running.searchProvider === nextSearch && running.fetchProvider === nextFetch;
-		if (configured && applied) return;
+		if (configured && applied) {
+			this.state = "applied";
+			return;
+		}
 		const nextConfig = { ...config };
 		if (nextSearch === void 0) delete nextConfig.searchProvider;
 		else nextConfig.searchProvider = nextSearch;
@@ -8562,7 +8594,170 @@ function mergeSchemas(left, right) {
 	if (Array.isArray(left.required) && Array.isArray(right.required)) merged.required = [.../* @__PURE__ */ new Set([...left.required, ...right.required])];
 	return merged;
 }
-function toAntigravityToolSchema(schema) {
+/** Value constraints a branch summary reports, in a stable order. */
+const constraintFields = [
+	"format",
+	"pattern",
+	"minimum",
+	"maximum",
+	"minLength",
+	"maxLength",
+	"minItems",
+	"maxItems",
+	"minProperties",
+	"maxProperties"
+];
+/** Keys the same-type union merge below represents rather than drops. */
+const mergedTypeKeys = /* @__PURE__ */ new Set([
+	"type",
+	"enum",
+	"nullable",
+	"description",
+	...constraintFields
+]);
+/**
+* One alternative in the words a model can act on.
+*
+* Folding removes the branch from the schema itself, so this text carries the
+* branch description and its constraints too: the type alone would leave the
+* model with strictly less than the schema it started from.
+*/
+function describeBranch(branch) {
+	const type = typeof branch.type === "string" ? branch.type : isRecord$22(branch.properties) ? "object" : isRecord$22(branch.items) ? "array" : "value";
+	const details = [];
+	if (isRecord$22(branch.properties)) {
+		const names = Object.keys(branch.properties);
+		if (names.length > 0) details.push(`{${names.join(",")}}`);
+	}
+	if (Array.isArray(branch.required) && branch.required.length > 0) details.push(`requires ${branch.required.map(String).join(",")}`);
+	if (Array.isArray(branch.enum)) details.push(`enum[${branch.enum.map((value) => JSON.stringify(value)).join(",")}]`);
+	for (const field of constraintFields) if (branch[field] !== void 0) details.push(`${field}=${JSON.stringify(branch[field])}`);
+	if (branch.nullable === true) details.push("or null");
+	const summary = details.length > 0 ? `${type} ${details.join(" ")}` : type;
+	const description = typeof branch.description === "string" ? branch.description.trim() : "";
+	return description === "" ? summary : `${summary} — "${description}"`;
+}
+/** How well one branch can stand in for a whole union; a named object shape wins. */
+function branchRank(branch) {
+	if (isRecord$22(branch.properties)) return 3;
+	if (branch.type === "object") return 2;
+	if (branch.type === "array") return 1;
+	return 0;
+}
+/**
+* The one JSON Schema type a literal set declares, when it declares exactly one.
+*
+* Read from the caller's literals, never from the wire's stringified `enum`: a
+* `{ const: 5 }` branch is a number, and `String(5)` alone cannot say so.
+*/
+function literalType(values) {
+	const kinds = new Set(values.map((value) => typeof value));
+	if (kinds.size !== 1) return void 0;
+	const [kind] = kinds;
+	return kind === "string" || kind === "number" || kind === "boolean" ? kind : void 0;
+}
+/**
+* The single form the wire can declare for a set of union branches.
+*
+* `folded` is false only when the declared form carries every constraint the
+* branches between them declared; once a constraint is only in the description,
+* the fold says so instead of passing a partial restatement off as the union.
+*/
+function unionShape(branches) {
+	if (branches.length === 1) return {
+		shape: branches[0],
+		folded: false
+	};
+	if (new Set(branches.map((branch) => branch.type)).size === 1 && branches.every((branch) => !isRecord$22(branch.properties) && !isRecord$22(branch.items))) {
+		const shape = { type: branches[0].type };
+		if (branches.every((branch) => Array.isArray(branch.enum))) {
+			const values = [...new Set(branches.flatMap((branch) => branch.enum))];
+			if (values.length > 0) shape.enum = values;
+		}
+		if (branches.some((branch) => branch.nullable === true)) shape.nullable = true;
+		return {
+			shape,
+			folded: branches.some((branch) => Object.entries(branch).some(([key, value]) => !mergedTypeKeys.has(key) && !Object.is(shape[key], value)))
+		};
+	}
+	return {
+		shape: branches.reduce((best, branch) => branchRank(branch) > branchRank(best) ? branch : best),
+		folded: true
+	};
+}
+/** Append the folded union to whatever description the node already carried. */
+function withUnionHint(description, hint) {
+	const base = typeof description === "string" ? description.trim() : "";
+	return base === "" ? hint : `${base}\n\n${hint}`;
+}
+function unionHint(alternatives, declared) {
+	const text = `Union of accepted forms: ${alternatives.map(describeBranch).join(" | ")}.`;
+	return declared === void 0 ? text : `${text} Send "${describeBranch(declared)}": this gateway validates the declared form only, and the alternatives describe the original tool contract.`;
+}
+/**
+* One node's own fields, children folded, composition keys set aside.
+*
+* `anyOf`, `oneOf` and `allOf` are keywords only in these positions: a parameter
+* NAMED `anyOf` is data, so recursion goes through `properties` by name and never
+* reads a property key as a keyword.
+*/
+function foldOwnFields(node) {
+	const out = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "anyOf" || key === "oneOf" || key === "allOf") continue;
+		if (key === "properties" && isRecord$22(value)) {
+			out.properties = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, foldSchemaUnions(child)]));
+			continue;
+		}
+		if (key === "items") {
+			out.items = foldSchemaUnions(value);
+			continue;
+		}
+		out[key] = value;
+	}
+	return out;
+}
+/**
+* Replace every composition keyword in one already-converted schema with a
+* single declared form, moving what folding drops into `description`.
+*
+* This runs after {@link toAntigravityToolSchema} resolved references and merged
+* `allOf`, so it is one pass over the wire shape and no second sanitizer can
+* strip the hint it just wrote.
+*
+* Folding NARROWS the wire contract: preferring the object branch leaves the
+* schema declaring an object, so a caller that would have sent the string form
+* now sends against a schema that does not mention it. That is the only way
+* past a gateway that refuses a composed schema outright, and the description
+* keeps the dropped forms visible as the original tool contract rather than
+* silently erasing them. DSH's own tool validator is the real gate: an
+* argument the model sends anyway fails there, naming the actual problem.
+*/
+function foldSchemaUnions(node) {
+	if (!isRecord$22(node)) return node;
+	let own = foldOwnFields(node);
+	if (Array.isArray(node.allOf)) for (const branch of node.allOf) {
+		const folded = foldSchemaUnions(branch);
+		if (isRecord$22(folded)) own = mergeSchemas(own, folded);
+	}
+	const alternatives = Array.isArray(node.anyOf) ? node.anyOf : Array.isArray(node.oneOf) ? node.oneOf : [];
+	if (alternatives.length === 0) return own;
+	const branches = alternatives.map((branch) => foldSchemaUnions(branch)).filter(isRecord$22);
+	if (branches.length === 0) return own;
+	const shapes = branches.filter((branch) => branch.type !== "null");
+	const acceptsNull = branches.some((branch) => branch.type === "null");
+	if (shapes.length === 0) {
+		const onlyNull = mergeSchemas({ nullable: true }, own);
+		onlyNull.description = withUnionHint(own.description, unionHint(branches, { nullable: true }));
+		return onlyNull;
+	}
+	const { shape, folded } = unionShape(shapes);
+	const merged = mergeSchemas(shape, own);
+	if (acceptsNull) merged.nullable = true;
+	if (branches.length > 1) merged.description = withUnionHint(merged.description, unionHint(branches, folded ? shape : void 0));
+	return merged;
+}
+function toAntigravityToolSchema(schema, options = {}) {
 	if (!isRecord$22(schema)) return schema;
 	const root = schema;
 	function resolveReference(reference) {
@@ -8605,9 +8800,17 @@ function toAntigravityToolSchema(schema) {
 				"boolean"
 			].includes(typeof node.const)) out.enum = [String(node.const)];
 		} else if (Array.isArray(node.enum)) out.enum = node.enum.map((value) => String(value));
+		if (options.foldUnions && node.type === void 0 && !Array.isArray(node.type)) {
+			const values = Object.hasOwn(node, "const") ? [node.const] : node.enum;
+			if (Array.isArray(values) && values.length > 0) {
+				const literal = literalType(values);
+				if (literal !== void 0) out.type = literal;
+			}
+		}
 		return mergeSchemas(inherited, out);
 	}
-	return convert(root, /* @__PURE__ */ new Set());
+	const converted = convert(root, /* @__PURE__ */ new Set());
+	return options.foldUnions === true ? foldSchemaUnions(converted) : converted;
 }
 //#endregion
 //#region src/host/antigravity/mapper.ts
@@ -9018,15 +9221,27 @@ function convertMessages(options, model, runtimeModel, images = NO_RESOLVED_IMAG
 	}
 	return contents;
 }
-function stripMetaSchema$3(schema) {
-	return toAntigravityToolSchema(schema);
+function stripMetaSchema$3(schema, options) {
+	return toAntigravityToolSchema(schema, options);
+}
+/**
+* Whether this request's tool declarations must declare one form per parameter.
+*
+* Antigravity routes a Claude-family runtime model to Vertex Anthropic, whose
+* `input_schema` validation rejects a request whose tool schema still composes
+* itself with `anyOf`/`oneOf`/`allOf` (#39). Gemini ignores `anyOf`, so its
+* declarations keep the composed form they always sent.
+*/
+function foldsToolSchemaUnions(modelId, runtimeModel) {
+	return modelId.startsWith("claude-") || runtimeModel.startsWith("claude-");
 }
-function convertTools(tools) {
+function convertTools(tools, modelId = "", runtimeModel = "") {
 	if (!tools || tools.length === 0) return void 0;
+	const foldUnions = foldsToolSchemaUnions(modelId, runtimeModel);
 	return [{ functionDeclarations: tools.map((tool) => ({
 		name: tool.name,
 		description: tool.description || "",
-		parameters: stripMetaSchema$3(tool.parameters) || {
+		parameters: stripMetaSchema$3(tool.parameters, { foldUnions }) || {
 			type: "object",
 			properties: {}
 		}
@@ -9087,7 +9302,7 @@ function buildRequest$2(options, model, projectId, runtimeModel, effort, images
 	generationConfig.maxOutputTokens = options.maxTokens !== void 0 ? Math.min(options.maxTokens, maxAllowed) : maxAllowed;
 	request.generationConfig = generationConfig;
 	const toolChoice = options.toolChoice;
-	const tools = convertTools(options.tools);
+	const tools = convertTools(options.tools, model.id, runtimeModel);
 	if (tools) {
 		request.tools = tools;
 		if (toolChoice) request.toolConfig = { functionCallingConfig: { mode: mapToolChoiceMode(toolChoice) } };
@@ -9979,6 +10194,103 @@ function registerAntigravityRoutes(ctx, store, modelSettings, preferences, fetch
 	});
 }
 //#endregion
+//#region src/host/common/context-budget-fetch.ts
+/**
+* Recover a rejected input+output budget without dropping model-visible history.
+* Only explicit wire output controls and provider-confirmed counts qualify.
+* HTTP success/SSE, auth, quota, and byte-limit failures retain their old paths.
+*/
+function fetchWithContextBudgetRecovery(fetchFn) {
+	return async (input, init) => {
+		const response = await fetchFn(input, init);
+		if (response.status !== 400 && response.status !== 422) return response;
+		if (typeof init?.body !== "string") return response;
+		let body;
+		try {
+			const parsed = JSON.parse(init.body);
+			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return response;
+			body = parsed;
+		} catch {
+			return response;
+		}
+		const keys = [
+			"max_tokens",
+			"max_completion_tokens",
+			"max_output_tokens"
+		].filter((key) => key in body);
+		if (keys.length !== 1) return response;
+		const key = keys[0];
+		const requested = body[key];
+		if (typeof requested !== "number" || !Number.isSafeInteger(requested) || requested <= 0) return response;
+		const reduced = reducedOutputBudget(await boundedDiagnostic(response), requested);
+		if (reduced === void 0) return response;
+		const thinking = body.thinking;
+		if (typeof thinking === "object" && thinking !== null) {
+			const budget = thinking.budget_tokens;
+			if (typeof budget === "number" && reduced <= budget) return response;
+		}
+		init.signal?.throwIfAborted();
+		await response.body?.cancel().catch(() => void 0);
+		return fetchFn(input, {
+			...init,
+			body: JSON.stringify({
+				...body,
+				[key]: reduced
+			})
+		});
+	};
+}
+/** Read a bounded clone so a non-recoverable refusal remains readable by its owner. */
+async function boundedDiagnostic(response) {
+	const reader = response.clone().body?.getReader();
+	if (reader === void 0) return "";
+	const decoder = new TextDecoder();
+	let size = 0;
+	let text = "";
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) return text + decoder.decode();
+			size += value.byteLength;
+			if (size > 16384) return "";
+			text += decoder.decode(value, { stream: true });
+		}
+	} catch {
+		return "";
+	} finally {
+		reader.cancel().catch(() => void 0);
+	}
+}
+function diagnosticMessage(value, depth = 0) {
+	if (depth > 4) return void 0;
+	if (typeof value === "string") return value;
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const fields = value;
+	return diagnosticMessage(fields.error, depth + 1) ?? diagnosticMessage(fields.message, depth + 1);
+}
+/** Never infer capacity from a model name or from an echoed request. */
+function reducedOutputBudget(detail, requested) {
+	let message;
+	try {
+		message = diagnosticMessage(JSON.parse(detail));
+	} catch {
+		message = detail;
+	}
+	if (message === void 0) return void 0;
+	const match = /maximum context length is ([\d,]+) tokens[\s\S]*?requested ([\d,]+) tokens[\s\S]*?\(([\d,]+) in the messages, ([\d,]+) in the completion\)/i.exec(message);
+	if (match === null) return void 0;
+	const [window, total, prompt, completion] = match.slice(1).map((value) => Number(value.replaceAll(",", "")));
+	if (![
+		window,
+		total,
+		prompt,
+		completion
+	].every((value) => Number.isSafeInteger(value) && value > 0)) return void 0;
+	if (completion !== requested || prompt + completion !== total || total <= window) return void 0;
+	const available = window - prompt - 1024;
+	return available >= 1024 && available < requested ? available : void 0;
+}
+//#endregion
 //#region src/host/command-code/model-catalog.ts
 /** Every model the Command Code registry describes, in registry order. */
 const COMMAND_CODE_MODELS = [
@@ -14092,7 +14404,7 @@ var CommandCodeAdapter = class extends LlmAdapter {
 				"anthropic-version": "2023-06-01"
 			} : baseHeaders;
 			try {
-				response = await fetchFn(endpoint, {
+				response = await fetchWithContextBudgetRecovery(fetchFn)(endpoint, {
 					method: "POST",
 					headers,
 					body,
@@ -19923,7 +20235,20 @@ function estimatedInputTokens(options) {
 			characters += JSON.stringify(tool.parameters).length;
 		} catch {}
 	}
-	for (const message of options.messages) characters += textOf$3(message.content).length;
+	const contentCharacters = (content) => {
+		if (!Array.isArray(content)) return typeof content === "string" ? content.length : 0;
+		return content.reduce((total, block) => {
+			if (!isRecord$16(block)) return total;
+			if ((block.type === "text" || block.type === "reasoning") && typeof block.text === "string") return total + block.text.length;
+			if (block.type === "tool-result") return total + contentCharacters(block.content);
+			if (block.type === "tool-call") {
+				const args = toolCallArguments$3(block.arguments);
+				return total + String(block.name ?? "").length + args.length;
+			}
+			return total;
+		}, 0);
+	};
+	for (const message of options.messages) characters += contentCharacters(message.content);
 	if (characters === 0) return void 0;
 	return Math.ceil(characters / 4);
 }
@@ -21082,7 +21407,7 @@ var KimiCodeAdapter = class extends LlmAdapter {
 			const endpoint = wire === "anthropic" ? `${base}/v1/messages?beta=true` : `${base}/v1/chat/completions`;
 			const headers = await modelRequestHeaders$1(apiCredentials.accessToken, wire);
 			try {
-				response = await fetchFn(endpoint, {
+				response = await fetchWithContextBudgetRecovery(fetchFn)(endpoint, {
 					method: "POST",
 					headers,
 					body,
@@ -25799,7 +26124,7 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 		let response;
 		for (let attempt = 0;; attempt += 1) {
 			try {
-				response = await fetchFn(messagesUrl(credentials.region), {
+				response = await fetchWithContextBudgetRecovery(fetchFn)(messagesUrl(credentials.region), {
 					method: "POST",
 					headers: modelRequestHeaders(credentials.accessToken),
 					body,
@@ -30539,7 +30864,7 @@ var WorkBuddyAdapter = class extends LlmAdapter {
 				credentials = effective.credentials;
 			}
 			try {
-				response = await fetchFn(`${credentials.backend}${CHAT_PATH}`, {
+				response = await fetchWithContextBudgetRecovery(fetchFn)(`${credentials.backend}${CHAT_PATH}`, {
 					method: "POST",
 					headers: workBuddyHeaders(credentials, { accept: "text/event-stream" }),
 					body,
@@ -34202,14 +34527,94 @@ function offloadOldestRequestImages(options) {
 	};
 }
 /**
+* Longest side, in pixels, the wire accepts for one image in any request.
+* TRANSCRIBED from the API's vision limits. The harness normalizes stored
+* images to an 8192 px long edge, so a stored image can still exceed this.
+*/
+const MAX_IMAGE_EDGE = 8e3;
+/**
+* Longest side, in pixels, the wire accepts for every image once one request
+* carries more than {@link MANY_IMAGE_THRESHOLD} images. TRANSCRIBED: past that
+* count the request is rejected with "At least one of the image dimensions
+* exceed max allowed size for many-image requests: 2000 pixels".
+*
+* Rejection is a 400 for the whole request. History keeps every image, so a
+* long session can only add images. Once it holds more than twenty and one is
+* wider than 2000 px, which is common for side-by-side screenshots, every later
+* turn fails. The session cannot recover by itself.
+*/
+const MANY_IMAGE_EDGE = 2e3;
+/**
+* Encoded-byte target for one downscaled request version.
+*
+* CHOICE: 3.5 MiB of raw bytes is about 4.9 MB of base64. That stays under the
+* 5 MB per-image ceiling whichever form the server measures. When no quality
+* level meets the target, the harness keeps its smallest output.
+*/
+const REQUEST_IMAGE_VERSION_MAX_BYTES = 3.5 * 1024 * 1024;
+function countRequestImages(content) {
+	if (!Array.isArray(content)) return 0;
+	let count = 0;
+	for (const block of content) {
+		if (!isRecord$5(block)) continue;
+		if (block.type === "image") count += 1;
+		else if (block.type === "tool-result") count += countRequestImages(block.content);
+	}
+	return count;
+}
+/**
+* Long-edge ceiling every image of this request must meet.
+*
+* The API counts image blocks, so a repeated attachment counts every time it
+* appears. The count is taken before images are resolved: a block that later
+* degrades to placeholder text still counts. Overcounting can only lower the
+* ceiling, and a lower ceiling never causes a rejection.
+*/
+function requestImageEdgeLimit(options) {
+	let count = 0;
+	for (const message of options.messages) count += countRequestImages(message.content);
+	return count > 20 ? MANY_IMAGE_EDGE : MAX_IMAGE_EDGE;
+}
+/**
+* Request-version target for one stored image whose long edge is over the
+* ceiling, or undefined when it fits. The short edge rounds to the nearest
+* pixel, matching the harness's long-edge resize. A reference without usable
+* dimensions is sent as stored.
+*/
+function requestImageEdgeTarget(ref, edge) {
+	const { width, height } = ref;
+	if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0) return void 0;
+	if (Math.max(width, height) <= edge) return void 0;
+	const maxPixels = Math.max(1, Math.floor(edge * edge * (Math.min(width, height) / Math.max(width, height))));
+	return width >= height ? {
+		width: edge,
+		height: Math.max(1, Math.round(edge * height / width)),
+		maxPixels,
+		maxBytes: REQUEST_IMAGE_VERSION_MAX_BYTES
+	} : {
+		width: Math.max(1, Math.round(edge * width / height)),
+		height: edge,
+		maxPixels,
+		maxBytes: REQUEST_IMAGE_VERSION_MAX_BYTES
+	};
+}
+/**
 * Read every durable { type: 'image', attachment } block one request carries.
 * An unreadable image resolves to 'unavailable' rather than disappearing, so
 * the model is told the picture is missing instead of answering about a blank.
+*
+* An image whose long edge is over this request's ceiling is sent as the
+* harness's downscaled request version (see {@link requestImageEdgeLimit}). The
+* stored image and durable history do not change, and an image that already
+* fits is sent byte-for-byte as stored. If a downscaled version cannot be
+* produced, the image resolves to 'unavailable'. A visible placeholder is better
+* than sending the original, which would make the whole request fail.
 */
 async function resolveRequestImages(options, attachments, signal) {
 	const refs = /* @__PURE__ */ new Map();
 	for (const message of options.messages) collectImageRefs(message.content, refs);
 	if (refs.size === 0) return NO_RESOLVED_IMAGES;
+	const edge = requestImageEdgeLimit(options);
 	const resolved = /* @__PURE__ */ new Map();
 	await Promise.all([...refs].map(async ([attachmentId, ref]) => {
 		if (!attachments) {
@@ -34217,6 +34622,16 @@ async function resolveRequestImages(options, attachments, signal) {
 			return;
 		}
 		try {
+			const target = requestImageEdgeTarget(ref, edge);
+			if (target !== void 0) {
+				const version = await attachments.readImageRequest(ref, target, signal);
+				resolved.set(attachmentId, Math.max(version.width, version.height) > edge ? { kind: "unavailable" } : {
+					kind: "inline",
+					mediaType: version.mediaType,
+					data: Buffer.from(version.data).toString("base64")
+				});
+				return;
+			}
 			const stored = await attachments.readImage(ref, signal);
 			resolved.set(attachmentId, {
 				kind: "inline",
@@ -36687,7 +37102,7 @@ var ClaudeAdapter = class ClaudeAdapter extends LlmAdapter {
 			cacheTtl
 		});
 		try {
-			return await fetchFn("https://api.anthropic.com/v1/messages?beta=true", {
+			return await fetchWithContextBudgetRecovery(fetchFn)("https://api.anthropic.com/v1/messages?beta=true", {
 				method: "POST",
 				headers: buildClaudeHeaders(credentials.accessToken, {
 					model: requestOptions.model,
@@ -42055,6 +42470,13 @@ function releaseListener(handle) {
 //#endregion
 //#region src/index.ts
 const Config = z.object({
+	fetchProvider: z.union([
+		z.const("auto"),
+		z.const("plugin"),
+		z.const("dsh")
+	]).default("auto"),
+	fetchMaxBodyChars: z.number().min(1).max(Number.MAX_SAFE_INTEGER).step(1).default(DEFAULT_FETCH_MAX_BODY_CHARS),
+	fetchMaxResponseBytes: z.number().min(1).max(Number.MAX_SAFE_INTEGER).step(1).default(DEFAULT_FETCH_MAX_RESPONSE_BYTES),
 	syncAgentPresets: z.boolean().default(true),
 	subagentModelAuthorization: z.boolean().default(true),
 	subagentModelTools: z.array(z.string()).default([]),
@@ -42071,6 +42493,7 @@ const inject = [
 	"loader"
 ];
 function apply(ctx, pluginConfig = {}) {
+	const fetchConfiguration = resolveFetchConfiguration(pluginConfig);
 	if (pluginConfig.syncAgentPresets !== false) ctx.effect(() => installBundledPresets(ctx, installDispatchPreset(ctx)), "dsh-chatgpt-subscription: agent preset sync");
 	const store = createPlatformTokenStore();
 	const preferences = registerPreferenceStore(ctx.settings);
@@ -42407,9 +42830,22 @@ function apply(ctx, pluginConfig = {}) {
 			signal: options?.signal
 		})).catch(() => []));
 		const searchSwitcher = new SearchProviderSwitcher(ctx.loader);
+		let lastFetchDiagnostic;
 		const applyWebProviders = (current = preferences.status()) => {
 			const pluginFetch = proxyManager.resolveActiveProxyUrl() !== null;
-			searchSwitcher.select(current.searchProvider, { pluginFetch }).catch((error) => {
+			searchSwitcher.select(current.searchProvider, {
+				pluginFetch,
+				fetchProvider: fetchConfiguration.fetchProvider
+			}).then(() => {
+				const status = searchSwitcher.status();
+				if (status.state === "missing" || status.state === "failed") return;
+				const reason = fetchConfiguration.fetchProvider !== "auto" ? "explicit configuration" : current.searchProvider === "codex" ? "Codex search selected" : pluginFetch ? "active proxy detected" : "no proxy or Codex search";
+				const diagnostic = `${status.configuredFetchProvider ?? "DSH default"} (mode=${fetchConfiguration.fetchProvider}; ${reason}; plugin limits=${fetchConfiguration.fetchMaxBodyChars} chars/${fetchConfiguration.fetchMaxResponseBytes} bytes)`;
+				if (diagnostic !== lastFetchDiagnostic) {
+					lastFetchDiagnostic = diagnostic;
+					ctx.logger.info(`[dsh-chatgpt-subscription] Web fetch provider configured: ${diagnostic}`);
+				}
+			}).catch((error) => {
 				ctx.logger.warn(`[dsh-chatgpt-subscription] Web provider selection could not be applied: ${error instanceof Error ? error.message : String(error)}`);
 			});
 		};
@@ -42435,13 +42871,17 @@ function apply(ctx, pluginConfig = {}) {
 				}))
 			});
 		};
-		const disposeRoutes = registerRoutes(ctx, oauth, usage, preferences, proxyManager, searchSwitcher, readRouteAudit, codexAccountPool);
+		const disposeRoutes = registerRoutes(ctx, oauth, usage, preferences, proxyManager, searchSwitcher, readRouteAudit, codexAccountPool, fetchConfiguration);
 		const disposeAdapter = ctx.llm.registerAdapter([PROVIDER_ID$7], adapter);
 		const disposeImageTool = ctx.tools.register(createCodexImageTool(oauth, ctx.attachments, { fetchFn: proxyFetch }));
 		const disposeVideoTool = ctx.tools.register(createKimiVideoTool(ctx, { fetchFn: proxyFetch }));
 		ctx.inject(["web"], (ctx) => {
 			ctx.web.registerSearchProvider(createCodexSearchProvider(oauth, { fetchFn: proxyFetch }));
-			ctx.web.registerFetchProvider(createCodexFetchProvider({ fetchFn: proxyFetch }));
+			ctx.web.registerFetchProvider(createCodexFetchProvider({
+				fetchFn: proxyFetch,
+				maxBodyChars: fetchConfiguration.fetchMaxBodyChars,
+				maxResponseBytes: fetchConfiguration.fetchMaxResponseBytes
+			}));
 			setTimeout(applyWebProviders, 0);
 		});
 		const disposePreferenceWatch = preferences.watch((next) => applyWebProviders(next));