@tool-bridge/server 0.21.1 → 0.23.0

package/dist/brave_search-TG2M2KOD.js

@@ -0,0 +1,302 @@
+import {
+  createAuthedClient
+} from "./chunk-TDAWLMDE.js";
+import "./chunk-VWRUGUSU.js";
+import {
+  asJsonObject,
+  compactDefined,
+  trimmedText
+} from "./chunk-JXHMDBAY.js";
+import {
+  createProviderPlugin,
+  upstreamError
+} from "./chunk-WJHG6OK7.js";
+import "./chunk-2JNAI4OC.js";
+import "./chunk-BADVCN6K.js";
+import {
+  TBError
+} from "./chunk-5ICRY3VU.js";
+import "./chunk-U67V476Y.js";
+
+// ../plugins/src/brave_search/api.ts
+var SERVICE = "brave_search";
+var API_BASE = "https://api.search.brave.com";
+var RATE_LIMIT_CODES = /* @__PURE__ */ new Set(["QUOTA_LIMITED", "RATE_LIMITED", "USAGE_LIMIT_EXCEEDED"]);
+var AUTH_CODES = /* @__PURE__ */ new Set(["SUBSCRIPTION_TOKEN_INVALID", "SUBSCRIPTION_NOT_FOUND"]);
+var INVALID_CODES = /* @__PURE__ */ new Set(["RESOURCE_NOT_ALLOWED", "OPTION_NOT_IN_PLAN", "INVALID_URL"]);
+function nullableRecord(value) {
+  return value === null ? null : asJsonObject(value);
+}
+function requireRecord(value, label) {
+  const result = asJsonObject(value);
+  if (result === void 0) {
+    throw new TBError("unavailable", `${label}\u4E0D\u662F\u5BF9\u8C61`, { retryable: true });
+  }
+  return result;
+}
+function objectArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  return value.map((item) => requireRecord(item, "Brave Search \u7ED3\u679C\u9879"));
+}
+function searchTerm(value) {
+  const term = trimmedText(value);
+  if (term === void 0) throw new TBError("invalid_argument", "q \u4E0D\u80FD\u662F\u7A7A\u767D");
+  return term;
+}
+function goggles(value) {
+  if (value === void 0 || typeof value === "string") return trimmedText(value);
+  const items = value.map((item) => trimmedText(item)).filter((item) => item !== void 0);
+  return items.length > 0 ? items : void 0;
+}
+function braveSearchError(status, payload) {
+  const error = asJsonObject(asJsonObject(payload)?.error);
+  const message = trimmedText(error?.detail) ?? trimmedText(error?.code) ?? `Brave Search \u8FD4\u56DE HTTP ${status}`;
+  const code = trimmedText(error?.code);
+  if (code !== void 0) {
+    if (RATE_LIMIT_CODES.has(code)) return upstreamError(429, message);
+    if (AUTH_CODES.has(code)) return upstreamError(401, message);
+    if (INVALID_CODES.has(code)) return upstreamError(400, message);
+  }
+  return upstreamError(status, message);
+}
+var http = createAuthedClient({
+  baseUrl: `${API_BASE}/`,
+  service: SERVICE,
+  auth: { kind: "header", name: "x-subscription-token" },
+  headers: { accept: "application/json" },
+  // 稳定错误码码表比 HTTP 状态准,整段覆写而不用标准键序提取。
+  mapError: ({ data: payload, status }) => braveSearchError(status, payload)
+});
+async function request(ctx, path, query) {
+  const { data } = await http.request(ctx, {
+    path,
+    method: "GET",
+    query: Object.entries(query),
+    invalidJsonMessage: "Brave Search \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94"
+  });
+  return data ?? null;
+}
+function normalizeWebSearch(payload) {
+  const result = requireRecord(payload, "Brave Search \u54CD\u5E94");
+  return compactDefined({
+    type: trimmedText(result.type) ?? "search",
+    query: nullableRecord(result.query),
+    web: nullableRecord(result.web),
+    news: nullableRecord(result.news),
+    videos: nullableRecord(result.videos),
+    locations: nullableRecord(result.locations),
+    discussions: nullableRecord(result.discussions),
+    faq: nullableRecord(result.faq),
+    infobox: nullableRecord(result.infobox),
+    mixed: nullableRecord(result.mixed),
+    summarizer: nullableRecord(result.summarizer),
+    rich: nullableRecord(result.rich)
+  });
+}
+function normalizeCollection(payload, withExtra) {
+  const result = requireRecord(payload, "Brave Search \u54CD\u5E94");
+  return compactDefined({
+    type: trimmedText(result.type) ?? "search",
+    query: nullableRecord(result.query),
+    results: objectArray(result.results),
+    extra: withExtra ? nullableRecord(result.extra) : void 0
+  });
+}
+async function webSearch(input, ctx) {
+  return normalizeWebSearch(await request(ctx, "/res/v1/web/search", {
+    q: searchTerm(input.q),
+    search_lang: trimmedText(input.search_lang),
+    ui_lang: trimmedText(input.ui_lang),
+    country: trimmedText(input.country),
+    safesearch: trimmedText(input.safesearch),
+    count: input.count,
+    offset: input.offset,
+    spellcheck: input.spellcheck,
+    freshness: trimmedText(input.freshness),
+    result_filter: trimmedText(input.result_filter),
+    extra_snippets: input.extra_snippets,
+    goggles: goggles(input.goggles),
+    text_decorations: input.text_decorations,
+    units: trimmedText(input.units),
+    operators: input.operators,
+    include_fetch_metadata: input.include_fetch_metadata
+  }));
+}
+async function newsSearch(input, ctx) {
+  const payload = await request(ctx, "/res/v1/news/search", {
+    q: searchTerm(input.q),
+    search_lang: trimmedText(input.search_lang),
+    ui_lang: trimmedText(input.ui_lang),
+    country: trimmedText(input.country),
+    safesearch: trimmedText(input.safesearch),
+    count: input.count,
+    offset: input.offset,
+    spellcheck: input.spellcheck,
+    freshness: trimmedText(input.freshness),
+    extra_snippets: input.extra_snippets,
+    goggles: goggles(input.goggles),
+    operators: input.operators,
+    include_fetch_metadata: input.include_fetch_metadata
+  });
+  return normalizeCollection(payload, false);
+}
+async function videoSearch(input, ctx) {
+  const payload = await request(ctx, "/res/v1/videos/search", {
+    q: searchTerm(input.q),
+    search_lang: trimmedText(input.search_lang),
+    ui_lang: trimmedText(input.ui_lang),
+    country: trimmedText(input.country),
+    safesearch: trimmedText(input.safesearch),
+    count: input.count,
+    offset: input.offset,
+    spellcheck: input.spellcheck,
+    freshness: trimmedText(input.freshness),
+    operators: input.operators,
+    include_fetch_metadata: input.include_fetch_metadata
+  });
+  return normalizeCollection(payload, true);
+}
+async function imageSearch(input, ctx) {
+  const payload = await request(ctx, "/res/v1/images/search", {
+    q: searchTerm(input.q),
+    search_lang: trimmedText(input.search_lang),
+    country: trimmedText(input.country),
+    safesearch: trimmedText(input.safesearch),
+    count: input.count,
+    spellcheck: input.spellcheck
+  });
+  return normalizeCollection(payload, true);
+}
+
+// ../plugins/src/brave_search/schema.ts
+import { z } from "zod/v4";
+var webSearchInput = z.strictObject({
+  q: z.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: z.string().min(2).describe("The preferred search result language code.").optional(),
+  ui_lang: z.string().min(2).describe("The preferred user interface language for response formatting.").optional(),
+  country: z.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: z.enum(["off", "moderate", "strict"]).describe("Filters adult content from web results.").optional(),
+  count: z.int().min(1).max(20).describe("The maximum number of web results to return.").optional(),
+  offset: z.int().min(0).max(9).describe("The zero-based results page offset used for pagination.").optional(),
+  spellcheck: z.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional(),
+  freshness: z.union([z.enum(["pd", "pw", "pm", "py"]).describe("A predefined freshness window such as past day or past year."), z.string().min(1).describe("A custom date range in the format YYYY-MM-DDtoYYYY-MM-DD.")]).describe("Filters web results by page age.").optional(),
+  result_filter: z.string().min(1).describe("A comma-delimited list of result types to include, such as web,news,videos,locations,discussions,faq,infobox,mixed,summarizer or rich.").optional(),
+  extra_snippets: z.boolean().describe("Whether Brave Search should return extra alternate snippets.").optional(),
+  goggles: z.union([z.string().min(1).describe("One goggle URL or inline definition."), z.array(z.string().min(1).describe("One goggle URL or inline definition.")).min(1).describe("Multiple goggles to apply to the search request.")]).describe("One or more Brave Search goggles used to rerank results.").optional(),
+  text_decorations: z.boolean().describe("Whether display strings should include decoration markers such as highlights.").optional(),
+  units: z.enum(["metric", "imperial"]).describe("The measurement units used for localized results.").optional(),
+  operators: z.boolean().describe("Whether Brave Search should apply search operators.").optional(),
+  include_fetch_metadata: z.boolean().describe("Whether Brave Search should include fetch metadata in results when available.").optional()
+}).describe("Input parameters for a Brave Search web search request.");
+var webSearchOutput = z.strictObject({
+  type: z.string().describe("The Brave Search response type."),
+  query: z.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  web: z.looseObject({}).describe("Web result payload returned by Brave Search.").nullable().optional(),
+  news: z.looseObject({}).describe("News result payload returned by Brave Search.").nullable().optional(),
+  videos: z.looseObject({}).describe("Video result payload returned by Brave Search.").nullable().optional(),
+  locations: z.looseObject({}).describe("Location result payload returned by Brave Search.").nullable().optional(),
+  discussions: z.looseObject({}).describe("Discussion clusters returned by Brave Search.").nullable().optional(),
+  faq: z.looseObject({}).describe("Frequently asked questions returned by Brave Search.").nullable().optional(),
+  infobox: z.looseObject({}).describe("Infobox payload returned by Brave Search.").nullable().optional(),
+  mixed: z.looseObject({}).describe("Mixed ranking payload returned by Brave Search.").nullable().optional(),
+  summarizer: z.looseObject({}).describe("Summary metadata returned by Brave Search.").nullable().optional(),
+  rich: z.looseObject({}).describe("Rich result callback payload returned by Brave Search.").nullable().optional()
+}).describe("A normalized Brave Search web search response.");
+var newsSearchInput = z.strictObject({
+  q: z.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: z.string().min(2).describe("The preferred search result language code.").optional(),
+  ui_lang: z.string().min(2).describe("The preferred user interface language for response formatting.").optional(),
+  country: z.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: z.enum(["off", "moderate", "strict"]).describe("Filters adult content from news results.").optional(),
+  count: z.int().min(1).max(50).describe("The maximum number of results to return.").optional(),
+  offset: z.int().min(0).max(9).describe("The zero-based results page offset used for pagination.").optional(),
+  spellcheck: z.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional(),
+  freshness: z.union([z.enum(["pd", "pw", "pm", "py"]).describe("A predefined freshness window such as past day or past year."), z.string().min(1).describe("A custom date range in the format YYYY-MM-DDtoYYYY-MM-DD.")]).describe("Filters news results by page age.").optional(),
+  extra_snippets: z.boolean().describe("Whether Brave Search should return extra alternate snippets.").optional(),
+  goggles: z.union([z.string().min(1).describe("One goggle URL or inline definition."), z.array(z.string().min(1).describe("One goggle URL or inline definition.")).min(1).describe("Multiple goggles to apply to the search request.")]).describe("One or more Brave Search goggles used to rerank results.").optional(),
+  operators: z.boolean().describe("Whether Brave Search should apply search operators.").optional(),
+  include_fetch_metadata: z.boolean().describe("Whether Brave Search should include fetch metadata in results when available.").optional()
+}).describe("Input parameters for a Brave Search news request.");
+var newsSearchOutput = z.strictObject({
+  type: z.string().describe("The Brave Search response type."),
+  query: z.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  results: z.array(z.looseObject({}).describe("One news result item returned by Brave Search.")).describe("The list of news results returned by Brave Search.").optional()
+}).describe("A normalized Brave Search news response.");
+var videoSearchInput = z.strictObject({
+  q: z.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: z.string().min(2).describe("The preferred search result language code.").optional(),
+  ui_lang: z.string().min(2).describe("The preferred user interface language for response formatting.").optional(),
+  country: z.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: z.enum(["off", "moderate", "strict"]).describe("Filters adult content from video results.").optional(),
+  count: z.int().min(1).max(50).describe("The maximum number of results to return.").optional(),
+  offset: z.int().min(0).max(9).describe("The zero-based results page offset used for pagination.").optional(),
+  spellcheck: z.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional(),
+  freshness: z.union([z.enum(["pd", "pw", "pm", "py"]).describe("A predefined freshness window such as past day or past year."), z.string().min(1).describe("A custom date range in the format YYYY-MM-DDtoYYYY-MM-DD.")]).describe("Filters video results by page age.").optional(),
+  operators: z.boolean().describe("Whether Brave Search should apply search operators.").optional(),
+  include_fetch_metadata: z.boolean().describe("Whether Brave Search should include fetch metadata in results when available.").optional()
+}).describe("Input parameters for a Brave Search video request.");
+var videoSearchOutput = z.strictObject({
+  type: z.string().describe("The Brave Search response type."),
+  query: z.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  results: z.array(z.looseObject({}).describe("One video result item returned by Brave Search.")).describe("The list of video results returned by Brave Search.").optional(),
+  extra: z.looseObject({}).describe("Additional metadata returned with the video results.").nullable().optional()
+}).describe("A normalized Brave Search video response.");
+var imageSearchInput = z.strictObject({
+  q: z.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: z.string().min(2).describe("The preferred search result language code.").optional(),
+  country: z.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: z.enum(["off", "strict"]).describe("Filters adult content from image results.").optional(),
+  count: z.int().min(1).max(200).describe("The maximum number of image results to return.").optional(),
+  spellcheck: z.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional()
+}).describe("Input parameters for a Brave Search image request.");
+var imageSearchOutput = z.strictObject({
+  type: z.string().describe("The Brave Search response type."),
+  query: z.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  results: z.array(z.looseObject({}).describe("One image result item returned by Brave Search.")).describe("The list of image results returned by Brave Search.").optional(),
+  extra: z.looseObject({}).describe("Additional metadata returned with the image results.").nullable().optional()
+}).describe("A normalized Brave Search image response.");
+var braveSearchActions = {
+  web_search: {
+    description: "Search the Brave Search web index and return the selected result families.",
+    effect: "write",
+    inputSchema: webSearchInput,
+    outputSchema: z.toJSONSchema(webSearchOutput, { io: "output", unrepresentable: "any" })
+  },
+  news_search: {
+    description: "Search Brave's news index for recent articles related to a query.",
+    effect: "write",
+    inputSchema: newsSearchInput,
+    outputSchema: z.toJSONSchema(newsSearchOutput, { io: "output", unrepresentable: "any" })
+  },
+  video_search: {
+    description: "Search Brave's video index for videos related to a query.",
+    effect: "write",
+    inputSchema: videoSearchInput,
+    outputSchema: z.toJSONSchema(videoSearchOutput, { io: "output", unrepresentable: "any" })
+  },
+  image_search: {
+    description: "Search Brave's image index for images related to a query.",
+    effect: "write",
+    inputSchema: imageSearchInput,
+    outputSchema: z.toJSONSchema(imageSearchOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/brave_search/index.ts
+function createBraveSearchPlugin() {
+  return createProviderPlugin({
+    description: "Brave Search",
+    actions: braveSearchActions,
+    handlers: {
+      web_search: webSearch,
+      news_search: newsSearch,
+      video_search: videoSearch,
+      image_search: imageSearch
+    }
+  });
+}
+var brave_search_default = createBraveSearchPlugin();
+export {
+  createBraveSearchPlugin,
+  brave_search_default as default
+};

package/dist/chunk-2JNAI4OC.js

@@ -0,0 +1,161 @@
+import {
+  TBError
+} from "./chunk-5ICRY3VU.js";
+
+// ../plugins/src/_runtime/ipPolicy.ts
+import ipaddr from "ipaddr.js";
+function isStrictIpv4(value) {
+  return ipaddr.IPv4.isValidFourPartDecimal(value) && value.split(".").every((part) => part === "0" || !part.startsWith("0"));
+}
+function parseAddress(value) {
+  let text = value;
+  if (text.startsWith("[") && text.endsWith("]")) text = text.slice(1, -1);
+  const embeddedIpv4 = text.includes(".") ? text.slice(text.lastIndexOf(":") + 1) : void 0;
+  if (embeddedIpv4 !== void 0 && !isStrictIpv4(embeddedIpv4)) return void 0;
+  try {
+    if (isStrictIpv4(text)) return ipaddr.IPv4.parse(text);
+    if (ipaddr.IPv6.isValid(text)) return ipaddr.IPv6.parse(text);
+  } catch {
+  }
+  return void 0;
+}
+function classifyIpv4(octets) {
+  const a = octets[0];
+  const b = octets[1];
+  const c = octets[2];
+  if (a === 0) return "blocked";
+  if (a === 10) return "blocked";
+  if (a === 127) return "blocked";
+  if (a === 169 && b === 254) return "blocked";
+  if (a === 172 && b >= 16 && b <= 31) return "blocked";
+  if (a === 192 && b === 0 && c === 0) return "blocked";
+  if (a === 192 && b === 0 && c === 2) return "blocked";
+  if (a === 192 && b === 168) return "blocked";
+  if (a === 198 && (b === 18 || b === 19)) return "blocked";
+  if (a === 198 && b === 51 && c === 100) return "blocked";
+  if (a === 203 && b === 0 && c === 113) return "blocked";
+  if (a === 100 && b >= 64 && b <= 127) return "blocked";
+  if (a >= 224) return "blocked";
+  return "public";
+}
+function classifyIpv6(bytes) {
+  const isZero = bytes.every((byte) => byte === 0);
+  if (isZero) return "blocked";
+  if (bytes.slice(0, 15).every((byte) => byte === 0) && bytes[15] === 1) return "blocked";
+  const v4Mapped = bytes.slice(0, 10).every((byte) => byte === 0) && (bytes[10] === 255 && bytes[11] === 255 || bytes[10] === 0 && bytes[11] === 0);
+  if (v4Mapped) {
+    return classifyIpv4([bytes[12], bytes[13], bytes[14], bytes[15]]);
+  }
+  const first = bytes[0];
+  if ((first & 254) === 252) return "blocked";
+  if (first === 254 && (bytes[1] & 192) === 128) return "blocked";
+  if (first === 255) return "blocked";
+  if (first === 32 && bytes[1] === 1 && bytes[2] === 13 && bytes[3] === 184) return "blocked";
+  return "public";
+}
+function isIpAddress(value) {
+  return parseAddress(value) !== void 0;
+}
+function classifyIpAddress(address) {
+  const parsed = parseAddress(address);
+  if (parsed === void 0) return "blocked";
+  if (parsed instanceof ipaddr.IPv4) return classifyIpv4(parsed.octets);
+  const bytes = new Uint8Array(parsed.toByteArray());
+  if (parsed.isIPv4MappedAddress()) return classifyIpv4(parsed.toIPv4Address().octets);
+  return classifyIpv6(bytes);
+}
+
+// ../plugins/src/_runtime/guardedFetch.ts
+var MAX_REDIRECTS = 5;
+var CROSS_ORIGIN_STRIPPED_HEADERS = [
+  "authorization",
+  "cookie",
+  "proxy-authorization"
+  // 各家自定义的密钥头没有统一命名,凡是名字里带 key/token/secret 的一律剥掉:
+  // 宁可让跨源跳转少带一个无关头,也不能漏带走一个凭证。
+];
+var REQUEST_BODY_HEADERS = [
+  "content-encoding",
+  "content-language",
+  "content-location",
+  "content-type"
+];
+function looksLikeCredentialHeader(name) {
+  return /(?:^|-)(?:api[-_]?key|key|token|secret|auth)(?:$|-)/i.test(name);
+}
+function stripCredentials(headers, sensitiveHeaders) {
+  const next = new Headers(headers);
+  for (const [name] of headers) {
+    if (CROSS_ORIGIN_STRIPPED_HEADERS.includes(name.toLowerCase()) || looksLikeCredentialHeader(name) || sensitiveHeaders.has(name.toLowerCase())) {
+      next.delete(name);
+    }
+  }
+  return next;
+}
+var EgressBlockedError = class extends TBError {
+  constructor(message) {
+    super("invalid_argument", message);
+    this.name = "EgressBlockedError";
+  }
+};
+function assertPublicHttpUrl(value) {
+  let url;
+  try {
+    url = value instanceof URL ? value : new URL(value);
+  } catch {
+    throw new EgressBlockedError(`\u51FA\u7AD9\u76EE\u6807\u4E0D\u662F\u5408\u6CD5 URL: ${String(value)}`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new EgressBlockedError(`\u51FA\u7AD9\u76EE\u6807\u534F\u8BAE\u4E0D\u88AB\u5141\u8BB8: ${url.protocol}`);
+  }
+  const hostname = url.hostname.startsWith("[") && url.hostname.endsWith("]") ? url.hostname.slice(1, -1) : url.hostname;
+  if (hostname === "") throw new EgressBlockedError("\u51FA\u7AD9\u76EE\u6807\u7F3A\u5C11\u4E3B\u673A\u540D");
+  if (isIpAddress(hostname) && classifyIpAddress(hostname) === "blocked") {
+    throw new EgressBlockedError("\u51FA\u7AD9\u76EE\u6807\u6307\u5411\u79C1\u6709\u6216\u4FDD\u7559\u5730\u5740");
+  }
+  return url;
+}
+function createGuardedFetch(options = {}) {
+  const crossOriginRedirect = options.crossOriginRedirect ?? "error";
+  const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS;
+  const sensitiveHeaders = new Set(
+    (options.sensitiveHeaders ?? []).map((name) => name.toLowerCase())
+  );
+  return async function guardedFetch2(input, init) {
+    const transport = options.fetch ?? globalThis.fetch;
+    const initial = input instanceof Request ? input.url : String(input);
+    let url = assertPublicHttpUrl(initial);
+    let request = input instanceof Request ? new Request(url, new Request(input, init)) : new Request(url, { ...init, redirect: "manual" });
+    for (let hop = 0; ; hop += 1) {
+      const response = await transport(new Request(request.clone(), { redirect: "manual" }));
+      const location = response.headers.get("location");
+      if (response.status < 300 || response.status > 399 || location === null) return response;
+      if (hop >= maxRedirects) {
+        throw new EgressBlockedError(`\u51FA\u7AD9\u91CD\u5B9A\u5411\u8D85\u8FC7 ${maxRedirects} \u8DF3`);
+      }
+      const previousOrigin = new URL(request.url).origin;
+      url = assertPublicHttpUrl(new URL(location, url));
+      const crossesOrigin = url.origin !== previousOrigin;
+      if (crossesOrigin && crossOriginRedirect === "error") {
+        throw new EgressBlockedError("\u643A\u5E26\u654F\u611F\u4FE1\u606F\u7684\u51FA\u7AD9\u8BF7\u6C42\u4E0D\u5141\u8BB8\u8DE8\u6E90\u91CD\u5B9A\u5411");
+      }
+      const headers = !crossesOrigin ? request.headers : stripCredentials(request.headers, sensitiveHeaders);
+      const downgrade = (response.status === 301 || response.status === 302) && request.method === "POST" || response.status === 303 && request.method !== "GET" && request.method !== "HEAD";
+      if (downgrade) {
+        const redirectedHeaders = new Headers(headers);
+        for (const name of REQUEST_BODY_HEADERS) redirectedHeaders.delete(name);
+        request = new Request(url, { method: "GET", headers: redirectedHeaders, redirect: "manual" });
+      } else {
+        const redirected = new Request(url, request);
+        request = crossesOrigin ? new Request(redirected, { headers, redirect: "manual" }) : redirected;
+      }
+    }
+  };
+}
+var guardedFetch = createGuardedFetch();
+
+export {
+  assertPublicHttpUrl,
+  createGuardedFetch,
+  guardedFetch
+};