dsh-github-copilot 0.4.0-alpha.18

package/lib/search-routing-pFLux0W7.js

@@ -0,0 +1,763 @@
+import { attributionHeaders } from "@deepseek-ai/dsh-llm";
+import { WebError } from "@deepseek-ai/dsh-web";
+import { builtinProviders, getBuiltinModels } from "@earendil-works/pi-ai/providers/all";
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+//#region lib/types/copilot-identity.js
+/** Native OAuth ownership and the sole plugin-owned, account-discovered route. */
+const GITHUB_COPILOT_CREDENTIAL_KEY$1 = "llm-pi-ai/github-copilot";
+const GITHUB_COPILOT_PROVIDER_ID = "github-copilot";
+const GITHUB_COPILOT_PREVIEW_PROVIDER_ID = "github-copilot-preview";
+//#endregion
+//#region lib/types/model-protocol.js
+/** Project only public leaves and the same pi library's supported wire efforts. */
+function projectModelFacts(model) {
+	const supported = getSupportedThinkingLevels(model);
+	return {
+		id: model.id,
+		provider: model.provider,
+		api: model.api,
+		name: model.name,
+		baseUrl: model.baseUrl,
+		contextWindow: model.contextWindow,
+		maxTokens: model.maxTokens,
+		input: [...model.input],
+		reasoning: model.reasoning,
+		supportsReasoningOff: supported.includes("off"),
+		reasoningEfforts: Object.fromEntries(supported.filter((level) => level !== "off").map((level) => [level, model.thinkingLevelMap?.[level] ?? level])),
+		...model.headers === void 0 ? {} : { headers: { ...model.headers } }
+	};
+}
+/** Stock Core owns its own catalog; local metadata must not retire corrections on its behalf. */
+function readCopilotCatalog(_ctx) {
+	return {
+		models: getBuiltinModels("github-copilot").map(projectModelFacts),
+		authoritative: false
+	};
+}
+/** Scope optional preview contributions to this plugin's successfully mounted route service. */
+function isPluginPreviewProvider(ctx, provider) {
+	if (provider !== "github-copilot-preview") return false;
+	const service = ctx.get("githubCopilotPreview");
+	if (typeof service !== "object" || service === null) return false;
+	const getView = Reflect.get(service, "getView");
+	if (typeof getView !== "function") return false;
+	const view = getView.call(service);
+	return typeof view === "object" && view !== null && Reflect.get(view, "provider") === provider;
+}
+//#endregion
+//#region lib/types/current-provider.js
+/**
+* Detection of an operation's provider route: the initiating Agent or explicit
+* request names a route and model, the `llm-pi-ai` settings
+* section carries the route's profile, and the pi-ai catalog supplies the
+* defaults (wire protocol, base URL) a profile that overrides nothing inherits.
+* The probe and plan modules read this to decide which search-capable
+* protocol to use without any configuration.
+* @module dsh-github-copilot/current-provider
+*/
+/** Settings namespace of the harness's pi-ai LLM adapter (its `providers` dict). */
+const LLM_PI_AI_NAMESPACE = "llm-pi-ai";
+/** Catalog providers indexed by route id. The catalog is static for a given
+* pi-ai version; constructing it per call would rebuild ~30 provider objects
+* on every route read (several per request). */
+let catalogCache;
+function catalogById() {
+	if (catalogCache === void 0) {
+		const map = /* @__PURE__ */ new Map();
+		for (const provider of builtinProviders()) map.set(provider.id, provider);
+		catalogCache = map;
+	}
+	return catalogCache;
+}
+/** Per-provider model tables, cached the same way. */
+const modelTableCache = /* @__PURE__ */ new Map();
+function modelTableOf(provider) {
+	const cached = modelTableCache.get(provider);
+	if (cached !== void 0) return cached;
+	try {
+		const models = getBuiltinModels(provider);
+		modelTableCache.set(provider, models);
+		return models;
+	} catch {
+		return [];
+	}
+}
+/**
+* The catalog facts for one route+model: the model's own wire protocol and
+* base URL. A route pi-ai does not ship, or a model it does not list, yields
+* no facts — the profile is then the whole answer.
+* @param provider - provider route key.
+* @param model - model id.
+* @returns the catalog protocol and base URL, when known.
+*/
+function catalogModelFacts(ctx, provider, model) {
+	if (provider === "github-copilot-preview") {
+		if (!isPluginPreviewProvider(ctx, provider)) return {};
+		const owner = ctx.get("githubCopilotPreview");
+		if (typeof owner !== "object" || owner === null) return {};
+		const method = Reflect.get(owner, "routeFacts");
+		if (typeof method !== "function") return {};
+		const facts = method.call(owner, model);
+		if (typeof facts !== "object" || facts === null) return {};
+		const api = Reflect.get(facts, "api"), baseURL = Reflect.get(facts, "baseURL");
+		if (typeof api !== "string" || typeof baseURL !== "string") return {};
+		return {
+			api,
+			baseUrl: baseURL
+		};
+	}
+	if (provider === "github-copilot") {
+		const found = readCopilotCatalog(ctx).models.find((candidate) => candidate.id === model);
+		return found === void 0 ? {} : {
+			api: found.api,
+			baseUrl: found.baseUrl,
+			headers: found.headers
+		};
+	}
+	if (catalogById().get(provider) === void 0) return {};
+	const found = modelTableOf(provider).find((candidate) => candidate.id === model);
+	return found === void 0 ? {} : {
+		api: found.api,
+		baseUrl: found.baseUrl,
+		headers: found.headers
+	};
+}
+/** Read one route profile from the llm-pi-ai settings section, defensively narrowed. */
+function profileFacts(section, provider, model) {
+	if (typeof section !== "object" || section === null) return void 0;
+	const providers = section["providers"];
+	if (typeof providers !== "object" || providers === null) return void 0;
+	const profile = providers[provider];
+	if (typeof profile !== "object" || profile === null) return void 0;
+	const record = profile;
+	const stringField = (key) => typeof record[key] === "string" && record[key].length > 0 ? record[key] : void 0;
+	const selected = (Array.isArray(record["models"]) ? record["models"] : []).find((candidate) => typeof candidate === "object" && candidate !== null && candidate["id"] === model);
+	const declaredApis = Array.isArray(selected?.["apis"]) ? selected.apis.filter((api) => typeof api === "string") : [];
+	const selectedApi = typeof selected?.["api"] === "string" ? selected.api : void 0;
+	const routeApi = stringField("api");
+	const effectiveApi = provider === "github-copilot" ? routeApi : selectedApi ?? routeApi;
+	const supportedApis = provider === "github-copilot" ? void 0 : declaredApis.length > 0 ? declaredApis : selectedApi === void 0 ? void 0 : [selectedApi];
+	return {
+		...effectiveApi === void 0 ? {} : { api: effectiveApi },
+		...stringField("baseURL") === void 0 ? {} : { baseURL: stringField("baseURL") },
+		...stringField("apiKeyEnv") === void 0 ? {} : { apiKeyEnv: stringField("apiKeyEnv") },
+		...supportedApis === void 0 ? {} : { supportedApis }
+	};
+}
+/**
+* Read the public asynchronous initiator seam when supported by Core.
+* Older Core and agentless callers have no session selection; never substitute
+* the default-model service or an arbitrary registered Agent.
+* @param ctx - Host context with the optional Agent registry.
+* @returns the initiating Agent, or undefined when the capability/caller is absent.
+*/
+function currentSearchInitiator(ctx) {
+	const agents = ctx.get("agents");
+	return typeof agents?.currentInitiator === "function" ? agents.currentInitiator() : void 0;
+}
+/**
+* Capture the initiating Session's effective request route. Agent.options is
+* only an activation seed; Core model-selection waterfalls need not update it.
+* @param agent - initiating Agent recovered at the operation entry.
+* @returns provider/model leaves from the last committed request header, or none.
+*/
+function currentSearchSelection(agent) {
+	const session = agent?.session;
+	const config = typeof session?.requestHeader === "function" ? session.requestHeader()?.config : void 0;
+	return config?.provider && config.model ? {
+		provider: config.provider,
+		model: config.model
+	} : void 0;
+}
+/**
+* Resolve one operation's route. Explicit GenerateOptions fields are already
+* resolved by Core and take precedence; otherwise use the initiating Session's
+* effective request header. Missing request evidence fails closed.
+* @param ctx - context used for public initiator, settings and catalog reads.
+* @param explicit - explicit request selection, captured at operation entry.
+* @returns owned route facts, or undefined without a usable selection.
+*/
+function currentChatRoute(ctx, explicit) {
+	const selection = explicit ?? currentSearchSelection(currentSearchInitiator(ctx));
+	if (!selection?.provider || !selection.model) return void 0;
+	if (selection.provider === "github-copilot-preview" && !isPluginPreviewProvider(ctx, selection.provider)) return void 0;
+	const profile = selection.provider === "github-copilot-preview" ? void 0 : profileFacts(ctx.get("settings")?.get(LLM_PI_AI_NAMESPACE), selection.provider, selection.model);
+	const catalog = catalogModelFacts(ctx, selection.provider, selection.model);
+	return {
+		provider: selection.provider,
+		model: selection.model,
+		...profile?.api === void 0 ? {} : { api: profile.api },
+		...profile?.api === void 0 && catalog.api !== void 0 ? { api: catalog.api } : {},
+		...profile?.baseURL === void 0 ? {} : { baseURL: profile.baseURL },
+		...profile?.baseURL === void 0 && catalog.baseUrl !== void 0 ? { baseURL: catalog.baseUrl } : {},
+		...profile?.apiKeyEnv === void 0 ? {} : { apiKeyEnv: profile.apiKeyEnv },
+		...profile?.supportedApis === void 0 ? {} : { supportedApis: profile.supportedApis },
+		...catalog.headers === void 0 ? {} : { headers: catalog.headers }
+	};
+}
+//#endregion
+//#region lib/types/plan.js
+/**
+* Search-plan resolution: which protocol and endpoint native search runs
+* through. The initiating Agent's captured chat route (selection plus the
+* `llm-pi-ai` settings section) is detected and probed — its own protocol
+* when that can search. The {@link SearchPlan} class owns the probe lifecycle so
+* `available()` stays synchronous while the verdict lands in the background.
+* @module dsh-github-copilot/plan
+*/
+/** Credential record that owns GitHub Copilot OAuth state and refresh. */
+const GITHUB_COPILOT_CREDENTIAL_KEY = "llm-pi-ai/github-copilot";
+/** Default `anthropic-version` header value. */
+const DEFAULT_API_VERSION = "2023-06-01";
+/** Standard server-side web search tool type (OpenAI/DeepSeek official). */
+const WEB_SEARCH_TOOL_TYPE = "web_search";
+/**
+* Versioned Responses spelling retained as a capability-probe fallback.
+*/
+const RESPONSES_WEB_SEARCH_TOOL_TYPE = "web_search_2025_08_26";
+/** Anthropic server-side web search tool type (versioned). */
+const ANTHROPIC_WEB_SEARCH_TOOL_TYPE = "web_search_20250305";
+/** Whether an anthropic base already carries the `/v1` version segment. */
+function hasV1Segment(baseURL) {
+	return /\/v1\/?$/u.test(baseURL);
+}
+/**
+* Normalize an anthropic-messages base so appending `/messages` reaches the
+* Messages endpoint under either base convention: the SDK-style root
+* (`https://api.anthropic.com` → `/v1/messages`) and the v1-included base
+* (`https://api.deepseek.com/anthropic/v1` → `/messages`).
+* @param baseURL - the configured or catalog base.
+* @returns the base `/messages` is appended to.
+*/
+function ensureV1Base(baseURL) {
+	const trimmed = baseURL.replace(/\/+$/, "");
+	return hasV1Segment(trimmed) ? trimmed : `${trimmed}/v1`;
+}
+/**
+* Return the selected Copilot model's native search protocol. No endpoint or
+* cross-provider sibling is guessed.
+* @param route - the current chat route facts.
+* @returns the single native candidate, or none for an unsupported route.
+*/
+function siblingCandidates(route) {
+	if (route.provider !== "github-copilot" && route.provider !== "github-copilot-preview") return [];
+	const base = route.baseURL?.replace(/\/+$/, "") ?? "";
+	if (base.length === 0) return [];
+	if (route.api === "openai-responses" || route.api === "anthropic-messages") return [{
+		protocol: route.api,
+		baseURL: base
+	}];
+	if (route.supportedApis?.includes("openai-responses") === true) return [{
+		protocol: "openai-responses",
+		baseURL: base
+	}];
+	return [];
+}
+/** Build one fully defaulted candidate from a protocol and its base. */
+function buildCandidate(protocol, baseURL, route) {
+	return {
+		protocol,
+		baseURL: protocol === "anthropic-messages" ? ensureV1Base(baseURL) : baseURL,
+		model: route.model,
+		apiKeyEnv: GITHUB_COPILOT_CREDENTIAL_KEY,
+		apiVersion: DEFAULT_API_VERSION,
+		...route.headers === void 0 ? {} : { headers: route.headers },
+		...protocol === "openai-responses" ? { webSearchToolType: WEB_SEARCH_TOOL_TYPE } : {}
+	};
+}
+/**
+* Build only from the route captured by the caller, without rereading selection.
+* @param route - operation-local route facts.
+* @returns native Copilot candidates, or none without supported facts.
+*/
+function candidatesForRoute(route) {
+	if (route === void 0 || route.provider !== "github-copilot" && route.provider !== "github-copilot-preview") return [];
+	if (route.api === void 0 || route.api === "openai-completions" || route.api === "openai-responses" || route.api === "anthropic-messages") return siblingCandidates(route).map(({ protocol, baseURL }) => buildCandidate(protocol, baseURL, route));
+	return [];
+}
+/**
+* One candidate set plus its probe lifecycle. The probe runs in the
+* background so plugin load never blocks on a provider round-trip;
+* `available()` stays synchronous and `settle()` awaits the verdict. A
+* failed plan keeps its reason so the first search (or tool call) surfaces
+* the auto-disable diagnostic instead of a bare "no provider" error.
+*/
+var SearchPlan = class {
+	probe;
+	signal;
+	candidates;
+	/** Resolves when the probe verdict (or the immediate decision) lands. */
+	settled;
+	status;
+	chosen;
+	reason;
+	/**
+	* @param candidates - the candidates in probe order; empty disables the plan.
+	* @param probe - verifies one candidate; called sequentially until one passes.
+	* @param probeEnabled - when false the first candidate is trusted outright.
+	* @param signal - captured owner/proof cancellation, retained through final HTTP.
+	*/
+	constructor(candidates, probe, probeEnabled, signal) {
+		this.probe = probe;
+		this.signal = signal;
+		this.candidates = candidates;
+		if (candidates.length === 0) {
+			this.status = "failed";
+			this.reason = "GitHub Copilot hosted search is unavailable: select an account-available github-copilot model whose pi-ai catalog protocol is openai-responses or anthropic-messages";
+			this.settled = Promise.resolve();
+			return;
+		}
+		if (!probeEnabled) {
+			this.status = "ready";
+			this.chosen = candidates[0];
+			this.settled = Promise.resolve();
+			return;
+		}
+		this.status = "probing";
+		this.settled = this.runProbe();
+	}
+	/** Probe candidates in order; the first supported verdict wins. */
+	async runProbe() {
+		for (const candidate of this.candidates) {
+			let outcome;
+			try {
+				outcome = await this.probe(candidate);
+			} catch (error) {
+				outcome = {
+					supported: false,
+					detail: `probe crashed: ${String(error)}`
+				};
+			}
+			if (outcome.supported) {
+				this.status = "ready";
+				this.chosen = outcome.webSearchToolType !== void 0 && outcome.webSearchToolType !== candidate.webSearchToolType ? {
+					...candidate,
+					webSearchToolType: outcome.webSearchToolType
+				} : candidate;
+				return;
+			}
+			this.reason = outcome.detail;
+		}
+		this.status = "failed";
+		if (this.reason === void 0) this.reason = "native web search is disabled: every candidate failed the capability probe";
+		else this.reason = `native web search is disabled: ${this.reason}`;
+	}
+	/**
+	* Cheap synchronous usability check for the listener gate. While probing
+	* the plan is PROVISIONALLY available — the first gated request may enter
+	* and await {@link settle} — so the probe verdict and the stream start in
+	* parallel; only a failed (or candidate-less) plan is unavailable and keeps
+	* the request on the normal adapter path.
+	* @returns whether a search can currently be served.
+	*/
+	available() {
+		return this.candidates.length > 0 && this.status !== "failed";
+	}
+	/**
+	* Await the probe verdict and return the winning candidate.
+	* @returns the candidate whose probe passed (or the first, when probing is off).
+	* @throws WebError `WEB_PROVIDER_UNAVAILABLE` naming the auto-disable reason.
+	*/
+	async settle() {
+		await this.settled;
+		if (this.status === "ready" && this.chosen !== void 0) return this.chosen;
+		throw new WebError(this.reason ?? "native web search is unavailable", "WEB_PROVIDER_UNAVAILABLE");
+	}
+	/** The candidate currently serving searches, once the plan settled on one. */
+	chosenCandidate() {
+		return this.chosen;
+	}
+	/** The auto-disable reason, once a probe failed (or no candidate existed). */
+	failureReason() {
+		return this.reason;
+	}
+};
+/** Whether two candidate sets are identical (skips re-probing on no-op settings changes). */
+function sameCandidates(left, right) {
+	if (left.length !== right.length) return false;
+	return left.every((candidate, index) => {
+		const other = right[index];
+		return other !== void 0 && candidate.protocol === other.protocol && candidate.baseURL === other.baseURL && candidate.model === other.model && candidate.apiKeyEnv === other.apiKeyEnv && candidate.apiVersion === other.apiVersion && JSON.stringify(candidate.headers) === JSON.stringify(other.headers) && candidate.webSearchToolType === other.webSearchToolType;
+	});
+}
+//#endregion
+//#region lib/types/copilot-request.js
+function normalizeRequestAuth(auth) {
+	return typeof auth === "string" ? { apiKey: auth } : auth;
+}
+function applyRequestAuth(candidate, auth) {
+	return {
+		...candidate,
+		...auth.baseURL === void 0 ? {} : { baseURL: candidate.protocol === "anthropic-messages" ? `${auth.baseURL.replace(/\/+$/, "").replace(/\/v1$/u, "")}/v1` : auth.baseURL },
+		...auth.headers === void 0 ? {} : { headers: {
+			...candidate.headers,
+			...auth.headers
+		} }
+	};
+}
+/** Materialize pi-ai catalog headers and Copilot's per-request metadata. */
+function providerRequestHeaders(candidate, initiator) {
+	const headers = {};
+	for (const [name, value] of Object.entries(candidate.headers ?? {})) if (value !== null) headers[name] = value;
+	try {
+		const hostname = new URL(candidate.baseURL).hostname.toLowerCase();
+		if (hostname.endsWith(".githubcopilot.com") || hostname.startsWith("copilot-api.")) {
+			headers["X-Initiator"] = initiator;
+			headers["Openai-Intent"] = "conversation-edits";
+		}
+	} catch {}
+	return headers;
+}
+//#endregion
+//#region lib/types/http.js
+/**
+* Shared HTTP plumbing for the capability probe and the inline wires:
+* bounded response reading, caller-cancellation races for preflight steps,
+* and the stable {@link WebError} translations. The patterns mirror the
+* harness `dsh-web` package family (web-search-deepseek, model discovery) so
+* every credentialed request rejects redirects before a `Location` target can
+* be contacted.
+* @module dsh-github-copilot/http
+*/
+/**
+* Endpoint replies larger than this are refused. The endpoint is whatever
+* base URL the configuration named, so the ceiling holds on the bytes
+* actually read rather than on the length the server claims.
+*/
+const MAX_RESPONSE_BYTES = 4194304;
+/**
+* Read a response body with a hard byte cap, refusing one that outgrows it.
+* A declared length is checked first so an honest server is turned away
+* without transferring anything; the accumulated total is what actually
+* enforces the bound, because a server that under-declares (or streams) tells
+* us nothing up front.
+* @param response - the HTTP response whose body is read to completion.
+* @param url - the requested URL, named in the refusal message.
+* @returns the decoded body text.
+* @throws WebError `WEB_PROVIDER_ERROR` when the body exceeds the cap.
+*/
+async function readBounded(response, url) {
+	const oversized = () => new WebError(`${url} answered with more than ${MAX_RESPONSE_BYTES} bytes`, "WEB_PROVIDER_ERROR");
+	const declared = Number(response.headers.get("content-length") ?? NaN);
+	if (Number.isFinite(declared) && declared > 4194304) {
+		await response.body?.cancel();
+		throw oversized();
+	}
+	if (response.body === null) return "";
+	const reader = response.body.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			total += value.byteLength;
+			if (total > 4194304) throw oversized();
+			chunks.push(value);
+		}
+	} finally {
+		await reader.cancel().catch(() => void 0);
+	}
+	const body = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		body.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new TextDecoder("utf-8", { fatal: true }).decode(body);
+}
+/** Whether an error is the fetch/`AbortSignal` abort signal. */
+function isAbortError(error) {
+	return error instanceof DOMException && error.name === "AbortError";
+}
+/**
+* Race a same-process asynchronous preflight (credential resolution) against
+* a cancellation signal. The attached settlement handlers keep observing an
+* uncooperative operation after the race is lost, so a later rejection cannot
+* become unhandled.
+* @param operation - the preflight promise.
+* @param signal - the cancellation signal (request abort or idle watchdog).
+* @returns the operation's value, or a rejection once the signal fires.
+*/
+function abortable(operation, signal) {
+	if (signal === void 0) return operation;
+	if (signal.aborted) {
+		operation.then(() => void 0, () => void 0);
+		return Promise.reject(new DOMException("aborted", "AbortError"));
+	}
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(new DOMException("aborted", "AbortError"));
+		signal.addEventListener("abort", onAbort, { once: true });
+		operation.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+/**
+* Extract a provider error message from an error envelope whose shape varies
+* by protocol and vendor: `{ error: { message } }`, `{ error: "text" }`, or
+* `{ message }`. Returns `undefined` when nothing usable is present.
+* @param body - the parsed non-2xx response body.
+* @returns the provider message, or `undefined`.
+*/
+function providerErrorMessage(body) {
+	if (typeof body !== "object" || body === null) return void 0;
+	const record = body;
+	const error = record["error"];
+	if (typeof error === "string" && error.length > 0) return error;
+	if (typeof error === "object" && error !== null) {
+		const message = error["message"];
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	const message = record["message"];
+	return typeof message === "string" && message.length > 0 ? message : void 0;
+}
+//#endregion
+//#region lib/types/traditional-search.js
+/**
+* Traditional `ctx.web` search provider backed by a verified OpenAI Responses
+* candidate. This is intentionally search-only: URL fetching remains owned by
+* dedicated anonymous fetch providers.
+* @module dsh-github-copilot/traditional-search
+*/
+/** Stable provider id selected through `web.searchProvider`. */
+const GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID = "github-copilot-hosted";
+/** @deprecated Use {@link GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID}. */
+const COPILOT_HOSTED_SEARCH_PROVIDER_ID = GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID;
+/** Build the search-only provider registered with `ctx.web`. */
+function createTraditionalSearchProvider(available, plan, hooks, config, unavailableMessage = "the github-copilot-hosted search provider requires an initiating Agent via agents.currentInitiator() and an eligible Session.requestHeader().config route") {
+	return {
+		id: GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID,
+		available,
+		search: (request, signal) => {
+			if (signal?.aborted === true) return Promise.reject(aborted());
+			if (!available()) return Promise.reject(new WebError(unavailableMessage, "WEB_PROVIDER_UNAVAILABLE"));
+			return searchResponses(request, signal, plan, hooks, config());
+		}
+	};
+}
+/** Execute one bounded native-search Responses request and normalize its result. */
+async function searchResponses(request, signal, plan, hooks, config) {
+	if (isAborted(signal)) throw aborted();
+	const timeout = AbortSignal.timeout(config.idleTimeoutMs);
+	let combined = signal === void 0 ? timeout : AbortSignal.any([signal, timeout]);
+	let ownership;
+	let candidate;
+	try {
+		const resolved = await abortable(Promise.resolve(plan(combined)), combined);
+		ownership = resolved.signal;
+		if (ownership !== void 0) combined = AbortSignal.any([combined, ownership]);
+		candidate = await abortable(resolved.settle(), combined);
+	} catch (error) {
+		if (signal?.aborted === true) throw aborted();
+		if (isAborted(ownership)) throw invalidated();
+		if (timeout.aborted || isAbortError(error)) throw new WebError("web search timed out", "WEB_PROVIDER_ERROR");
+		throw new WebError("the native search capability probe did not find a usable Responses provider", "WEB_PROVIDER_UNAVAILABLE");
+	}
+	if (candidate.protocol !== "openai-responses") throw new WebError("the verified search candidate does not support the Responses bridge", "WEB_PROVIDER_UNAVAILABLE");
+	let auth;
+	try {
+		auth = normalizeRequestAuth(await abortable(hooks.resolveApiKey(candidate), combined));
+	} catch (error) {
+		throw translateError(error, signal, timeout, ownership);
+	}
+	if (auth === void 0 || auth.apiKey.length === 0) throw new WebError(`no API key for "${candidate.apiKeyEnv}"`, "WEB_PROVIDER_UNAVAILABLE");
+	candidate = applyRequestAuth(candidate, auth);
+	const apiKey = auth.apiKey;
+	const endpoint = `${candidate.baseURL.replace(/\/+$/, "")}/responses`;
+	let response;
+	try {
+		combined.throwIfAborted();
+		response = await fetch(endpoint, {
+			method: "POST",
+			redirect: "error",
+			signal: combined,
+			headers: {
+				authorization: `Bearer ${apiKey}`,
+				"content-type": "application/json",
+				accept: "application/json",
+				...attributionHeaders(),
+				...providerRequestHeaders(candidate, "user")
+			},
+			body: JSON.stringify({
+				model: candidate.model,
+				input: [{
+					role: "user",
+					content: [{
+						type: "input_text",
+						text: request.query
+					}]
+				}],
+				tools: [{ type: candidate.webSearchToolType ?? "web_search" }],
+				tool_choice: candidate.webSearchToolType === "web_search" || candidate.webSearchToolType === void 0 ? "required" : { type: candidate.webSearchToolType },
+				include: ["web_search_call.action.sources"],
+				stream: false
+			})
+		});
+	} catch (error) {
+		throw translateError(error, signal, timeout, ownership);
+	}
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => void 0);
+		throw new WebError(`Responses API error (HTTP ${response.status})`, "WEB_PROVIDER_ERROR");
+	}
+	let body;
+	try {
+		body = JSON.parse(await abortable(readBounded(response, endpoint), combined));
+		combined.throwIfAborted();
+	} catch (error) {
+		if (combined.aborted || isAbortError(error)) throw translateError(error, signal, timeout, ownership);
+		throw new WebError("Responses API returned an invalid search result", "WEB_PROVIDER_ERROR");
+	}
+	const content = [];
+	const sources = /* @__PURE__ */ new Map();
+	for (const item of body.output ?? []) {
+		if (item.type === "web_search_call") {
+			for (const source of item.action?.sources ?? []) addSource(sources, source);
+			continue;
+		}
+		if (item.type !== "message") continue;
+		for (const part of item.content ?? []) {
+			if (typeof part.text === "string" && part.text.length > 0) content.push(part.text);
+			for (const annotation of part.annotations ?? []) addSource(sources, annotation);
+		}
+	}
+	return {
+		...content.length > 0 ? { content: content.join("\n") } : {},
+		sources: [...sources.values()],
+		truncated: false
+	};
+}
+/** Add one valid source, merging richer duplicate metadata without inventing it. */
+function addSource(sources, source) {
+	if (typeof source.url !== "string" || source.url.length === 0) return;
+	const existing = sources.get(source.url);
+	sources.set(source.url, {
+		url: source.url,
+		...existing?.title !== void 0 ? { title: existing.title } : typeof source.title === "string" ? { title: source.title } : {},
+		...existing?.snippet !== void 0 ? { snippet: existing.snippet } : typeof source.snippet === "string" ? { snippet: source.snippet } : {},
+		...existing?.publishedAt !== void 0 ? { publishedAt: existing.publishedAt } : typeof source.published_at === "string" ? { publishedAt: source.published_at } : {}
+	});
+}
+/** Translate cancellation/timeout/transport failures into the web seam taxonomy. */
+function translateError(error, caller, timeout, ownership) {
+	if (isAborted(caller)) return aborted();
+	if (isAborted(ownership)) return invalidated();
+	if (timeout.aborted || isAbortError(error)) return new WebError("web search timed out", "WEB_PROVIDER_ERROR", { cause: error });
+	if (error instanceof WebError) return error;
+	return new WebError("web search provider request failed", "WEB_PROVIDER_ERROR", { cause: error });
+}
+function invalidated() {
+	return new WebError("web search owner or credential proof was invalidated", "WEB_PROVIDER_UNAVAILABLE");
+}
+function aborted() {
+	return new WebError("web search aborted", "WEB_ABORTED");
+}
+/** Read the signal live after awaits without preserving an earlier narrowing. */
+function isAborted(signal) {
+	return signal?.aborted === true;
+}
+//#endregion
+//#region lib/types/search-backend.js
+/** Bounded metadata included in the same query's successful or failed fallback notice. */
+function describeSearchBackend(backend) {
+	const origin = backend.origin.slice(0, 512) + (backend.origin.length > 512 ? " (truncated)" : "");
+	const model = JSON.stringify(backend.model.slice(0, 256)) + (backend.model.length > 256 ? " (truncated)" : "");
+	return `Fallback backend: adapter=${backend.provider}; origin=${origin}; model=${model}; endpoint=${backend.customEndpoint ? "custom" : "default"}.`;
+}
+/** Known sanitized failure, distinct from arbitrary native provider exception messages. */
+var DescribedSearchFallbackError = class extends WebError {
+	backend;
+	constructor(backend, code = "WEB_PROVIDER_ERROR") {
+		super("the configured DeepSeek fallback failed", code);
+		this.backend = backend;
+	}
+};
+//#endregion
+//#region lib/types/search-routing.js
+/** Match only the canonical route or a verified plugin-owned managed route. */
+function isCopilotSearchSelection(selection, managedOwned) {
+	return selection?.provider === "github-copilot" || selection?.provider === "github-copilot-preview" && managedOwned;
+}
+function assertContinuable(signal, canContinue) {
+	if (signal?.aborted === true) throw new WebError("web search aborted", "WEB_ABORTED");
+	if (!canContinue()) throw new WebError("web search owner or account proof invalidated", "WEB_PROVIDER_UNAVAILABLE");
+}
+/** Public reason codes only: never copy upstream bodies, headers or arbitrary exception messages. */
+function publicFailureReason(error) {
+	if (error instanceof WebError && [
+		"WEB_PROVIDER_UNAVAILABLE",
+		"WEB_PROVIDER_ERROR",
+		"WEB_PROVIDER_CONFIGURED_UNAVAILABLE",
+		"WEB_PROVIDER_CONFIGURED_MISSING"
+	].includes(error.code)) return error.code;
+	return "COPILOT_SEARCH_FAILED";
+}
+/**
+* Route one already-validated search using captured request identity.
+* Non-Copilot calls delegate untouched. Copilot failures reach a known DeepSeek
+* provider only under the explicit spending policy; cancellation and invalidated
+* ownership never trigger fallback. Consumer validation, batching and deadlines
+* remain the caller's responsibility, not this provider-selection function.
+*/
+async function routeSessionSearch(request, signal, deps) {
+	if (!isCopilotSearchSelection(deps.selection, deps.managedOwned)) return { result: await deps.delegate(request, signal) };
+	const model = deps.selection.model;
+	const allowFallback = deps.fallback === "deepseek";
+	assertContinuable(signal, deps.canContinue);
+	if (deps.copilot.id !== "github-copilot-hosted") throw new WebError("plugin-owned Copilot search provider is required", "WEB_PROVIDER_UNAVAILABLE");
+	let failure;
+	try {
+		if (!deps.copilot.available()) throw new WebError("Copilot search is unavailable for this initiating model", "WEB_PROVIDER_UNAVAILABLE");
+		const result = await deps.copilot.search(request, signal);
+		assertContinuable(signal, deps.canContinue);
+		return {
+			result,
+			routing: {
+				requestedProvider: GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID,
+				actualProvider: GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID,
+				model,
+				fallback: false
+			}
+		};
+	} catch (error) {
+		assertContinuable(signal, deps.canContinue);
+		if (error instanceof WebError && error.code === "WEB_ABORTED") throw error;
+		if (!allowFallback) throw error;
+		failure = error;
+	}
+	const fallback = await deps.resolveDeepSeek();
+	assertContinuable(signal, deps.canContinue);
+	if (fallback.id !== "deepseek-official" || !fallback.available()) throw new WebError("the explicitly requested DeepSeek fallback is unavailable", "WEB_PROVIDER_UNAVAILABLE");
+	const reason = publicFailureReason(failure);
+	let result;
+	try {
+		result = await fallback.search(request, signal);
+	} catch (error) {
+		assertContinuable(signal, deps.canContinue);
+		if (error instanceof WebError && error.code === "WEB_ABORTED") throw error;
+		const backend = error instanceof DescribedSearchFallbackError && error.backend !== void 0 ? ` ${describeSearchBackend(error.backend)}` : "";
+		throw new WebError(`Copilot search failed (${reason}); DeepSeek fallback also failed and may have incurred DeepSeek API charges (or configured backend charges).${backend}`, "WEB_PROVIDER_ERROR");
+	}
+	assertContinuable(signal, deps.canContinue);
+	const notice = `Search provider: deepseek-official (explicit fallback from github-copilot-hosted; reason: ${reason}). This fallback may incur DeepSeek API charges (or charges from a configured custom backend). These are not Copilot search results.`;
+	return {
+		result: {
+			...result,
+			content: `${notice}\n\n${result.content ?? ""}`.trimEnd()
+		},
+		routing: {
+			requestedProvider: GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID,
+			actualProvider: "deepseek-official",
+			model,
+			fallback: true,
+			reason
+		}
+	};
+}
+//#endregion
+export { currentSearchInitiator as C, GITHUB_COPILOT_CREDENTIAL_KEY$1 as D, readCopilotCatalog as E, GITHUB_COPILOT_PREVIEW_PROVIDER_ID as O, currentChatRoute as S, isPluginPreviewProvider as T, RESPONSES_WEB_SEARCH_TOOL_TYPE as _, COPILOT_HOSTED_SEARCH_PROVIDER_ID as a, candidatesForRoute as b, abortable as c, readBounded as d, applyRequestAuth as f, GITHUB_COPILOT_CREDENTIAL_KEY as g, ANTHROPIC_WEB_SEARCH_TOOL_TYPE as h, describeSearchBackend as i, GITHUB_COPILOT_PROVIDER_ID as k, isAbortError as l, providerRequestHeaders as m, routeSessionSearch as n, GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID as o, normalizeRequestAuth as p, DescribedSearchFallbackError as r, createTraditionalSearchProvider as s, isCopilotSearchSelection as t, providerErrorMessage as u, SearchPlan as v, currentSearchSelection as w, sameCandidates as x, WEB_SEARCH_TOOL_TYPE as y };